pax_global_header00006660000000000000000000000064130144172000014502gustar00rootroot0000000000000052 comment=1a1eaa0810151f38b6a63c0f947ee2d3d8fc3aa3 Slic3r-version_1.31.6/000077500000000000000000000000001301441720000144765ustar00rootroot00000000000000Slic3r-version_1.31.6/.github/000077500000000000000000000000001301441720000160365ustar00rootroot00000000000000Slic3r-version_1.31.6/.github/CONTRIBUTING.md000066400000000000000000000032031301441720000202650ustar00rootroot00000000000000Did you encounter an issue with using Slic3r? Fear not! This guide will help you to write a good bug report in just a few, simple steps. There is a good chance that the issue, you have encountered, is already reported. Please check the [list of reported issues](https://github.com/alexrj/Slic3r/issues) before creating a new issue report. If you find an existing issue report, feel free to add further information to that report. If possible, please include the following information when [reporting an issue](https://github.com/alexrj/Slic3r/issues/new): * Slic3r version (See the about dialog for the version number. If running from git, please include the git commit ID from `git rev-parse HEAD` also.) * Operating system type + version * Steps to reproduce the issue, including: * Command line parameters used, if any * Slic3r configuration file (Use ``Export Config...`` from the ``File`` menu - please don't export a bundle) * Expected result * Actual result * Any error messages * If the issue is related to G-code generation, please include the following: * STL, OBJ or AMF input file (please make sure the input file is not broken, e.g. non-manifold, before reporting a bug) * a screenshot of the G-code layer with the issue (e.g. using [Pronterface](https://github.com/kliment/Printrun)) Please make sure only to include one issue per report. If you encounter multiple, unrelated issues, please report them as such. Simon Tatham has written an excellent on article on [How to Report Bugs Effectively](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html) which is well worth reading, although it is not specific to Slic3r. Slic3r-version_1.31.6/.github/ISSUE_TEMPLATE.md000066400000000000000000000013371301441720000205470ustar00rootroot00000000000000### Version _Version of Slic3r used goes here_ _Use `About->About Slic3r` for release versions_ _For -dev versions, use `git describe --tag` or get the hash value for the version you downloaded or `git rev-parse HEAD`_ ### Operating system type + version _What OS are you using, and state any version #s_ ### Behavior * _Describe the problem_ * _Steps needed to reproduce the problem_ * _If this is a command-line slicing issue, include the options used_ * _Expected Results_ * _Actual Results_ * _Screenshots from __*Slic3r*__ preview are preferred_ _Is this a new feature request?_ #### STL/Config (.ZIP) where problem occurs _Upload a zipped copy of an STL and your config (`File -> Export Config`)_ Slic3r-version_1.31.6/.gitignore000066400000000000000000000001761301441720000164720ustar00rootroot00000000000000Build Build.bat MYMETA.json MYMETA.yml _build blib xs/buildtmp *.o MANIFEST.bak xs/MANIFEST.bak xs/assertlib* .init_bundle.iniSlic3r-version_1.31.6/.travis.yml000066400000000000000000000004361301441720000166120ustar00rootroot00000000000000language: perl install: true script: perl ./Build.PL perl: - "5.14" - "5.18" - "5.20" branches: only: - master - stable sudo: false cache: - apt addons: apt: sources: - boost-latest packages: - libboost-thread1.55-dev - libboost-system1.55-dev Slic3r-version_1.31.6/Build.PL000066400000000000000000000132211301441720000157710ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Config; use File::Spec; my %prereqs = qw( Devel::CheckLib 0 Encode 0 Encode::Locale 1.05 ExtUtils::MakeMaker 6.80 ExtUtils::ParseXS 3.22 File::Basename 0 File::Spec 0 Getopt::Long 0 Module::Build::WithXSpp 0.14 Moo 1.003001 POSIX 0 Scalar::Util 0 Test::More 0 Thread::Semaphore 0 IO::Scalar 0 threads 1.96 Time::HiRes 0 Unicode::Normalize 0 ); my %recommends = qw( Class::XSAccessor 0 XML::SAX::ExpatXS 0 Test::Harness 0 ); my $sudo = grep { $_ eq '--sudo' } @ARGV; my $gui = grep { $_ eq '--gui' } @ARGV; my $xs_only = grep { $_ eq '--xs' } @ARGV; if ($gui) { %prereqs = qw( Class::Accessor 0 Wx 0.9918 Socket 2.016 ); %recommends = qw( Growl::GNTP 0.15 Wx::GLCanvas 0 OpenGL <0.70 LWP::UserAgent 0 Net::Bonjour 0 ); if ($^O eq 'MSWin32') { $recommends{"Win32::TieRegistry"} = 0; # we need an up-to-date Win32::API because older aren't thread-safe (GH #2517) $prereqs{'Win32::API'} = 0.79; } } elsif ($xs_only) { %prereqs = %recommends = (); } my @missing_prereqs = (); if ($ENV{SLIC3R_NO_AUTO}) { foreach my $module (sort keys %prereqs) { my $version = $prereqs{$module}; next if eval "use $module $version; 1"; push @missing_prereqs, $module if exists $prereqs{$module}; print "Missing prerequisite $module $version\n"; } foreach my $module (sort keys %recommends) { my $version = $recommends{$module}; next if eval "use $module $version; 1"; print "Missing optional $module $version\n"; } } else { my @try = ( $ENV{CPANM} // (), File::Spec->catfile($Config{sitebin}, 'cpanm'), File::Spec->catfile($Config{installscript}, 'cpanm'), ); my $cpanm; foreach my $path (@try) { if (-e $path) { # don't use -x because it fails on Windows $cpanm = $path; last; } } if (!$cpanm) { if ($^O =~ /^(?:darwin|linux)$/ && system(qw(which cpanm)) == 0) { $cpanm = 'cpanm'; } } die <<'EOF' cpanm was not found. Please install it before running this script. There are several ways to install cpanm, try one of these: apt-get install cpanminus curl -L http://cpanmin.us | perl - --sudo App::cpanminus cpan App::cpanminus If it is installed in a non-standard location you can do: CPANM=/path/to/cpanm perl Build.PL EOF if !$cpanm; my @cpanm_args = (); push @cpanm_args, "--sudo" if $sudo; # make sure our cpanm is updated (old ones don't support the ~ syntax) system $cpanm, @cpanm_args, 'App::cpanminus'; # install the Windows-compatible Math::Libm if ($^O eq 'MSWin32' && !eval "use Math::Libm; 1") { system $cpanm, @cpanm_args, 'https://github.com/alexrj/Math-Libm/tarball/master'; } my %modules = (%prereqs, %recommends); foreach my $module (sort keys %modules) { my $version = $modules{$module}; my @cmd = ($cpanm, @cpanm_args); # temporary workaround for upstream bug in test push @cmd, '--notest' if $module =~ /^(?:OpenGL|Math::PlanePath|Test::Harness)$/; push @cmd, "$module~$version"; if ($module eq 'XML::SAX::ExpatXS' && $^O eq 'MSWin32') { my $mingw = 'C:\dev\CitrusPerl\mingw64'; $mingw = 'C:\dev\CitrusPerl\mingw32' if !-d $mingw; if (!-d $mingw) { print "Could not find the MinGW directory at $mingw; skipping XML::SAX::ExpatXS (only needed for faster parsing of AMF files)\n"; } else { push @cmd, sprintf('--configure-args="EXPATLIBPATH=%s\lib EXPATINCPATH=%s\include"', $mingw, $mingw); } } my $res = system @cmd; if ($res != 0) { if (exists $prereqs{$module}) { push @missing_prereqs, $module; } else { printf "Don't worry, this module is optional.\n"; } } } if (!$gui) { # clean xs directory before reinstalling, to make sure Build is called # with current perl binary if (-e './xs/Build') { if ($^O eq 'MSWin32') { system '.\xs\Build', 'distclean'; } else { system './xs/Build', 'distclean'; } } my $res = system $cpanm, @cpanm_args, '--reinstall', '--verbose', './xs'; if ($res != 0) { die "The XS/C++ code failed to compile, aborting\n"; } } } if (@missing_prereqs) { printf "The following prerequisites failed to install: %s\n", join(', ', @missing_prereqs); exit 1; } elsif (!$gui) { eval "use App::Prove; 1" or die "Failed to load App::Prove"; my $res = App::Prove->new->run ? 0 : 1; if ($res == 0) { print "If you also want to use the GUI you can now run `perl Build.PL --gui` to install the required modules.\n"; } else { print "Some tests failed. Please report the failure to the author!\n"; } exit $res; } __END__ Slic3r-version_1.31.6/README.md000066400000000000000000000543541301441720000157700ustar00rootroot00000000000000_Q: Oh cool, a new RepRap slicer?_ A: Yes. Slic3r [![Build Status](https://travis-ci.org/alexrj/Slic3r.png?branch=master)](https://travis-ci.org/alexrj/Slic3r) ====== Slic3r takes 3D models (STL, OBJ, AMF) and converts them into G-code instructions for 3D printers. It's compatible with any modern printer based on the RepRap toolchain, including all those based on the Marlin, Sprinter and Repetier firmware. It also works with Mach3, LinuxCNC and Machinekit controllers. See the [project homepage](http://slic3r.org/) at slic3r.org and the [manual](http://manual.slic3r.org/) for more information. ### What language is it written in? The core geometric algorithms and data structures are written in C++, and Perl is used for high-level flow abstraction, GUI and testing. If you're wondering why Perl, see http://xkcd.com/224/ The C++ API is public and its use in other projects is encouraged. The goal is to make Slic3r fully modular so that any part of its logic can be used separately. ### What are Slic3r's main features? Key features are: * **multi-platform** (Linux/Mac/Win) and packaged as standalone-app with no dependencies required * complete **command-line interface** to use it with no GUI * multi-material **(multiple extruders)** object printing * multiple G-code flavors supported (RepRap, Makerbot, Mach3, Machinekit etc.) * ability to plate **multiple objects having distinct print settings** * **multithread** processing * **STL auto-repair** (tolerance for broken models) * wide automated unit testing Other major features are: * combine infill every 'n' perimeters layer to speed up printing * **3D preview** (including multi-material files) * **multiple layer heights** in a single print * **spiral vase** mode for bumpless vases * fine-grained configuration of speed, acceleration, extrusion width * several infill patterns including honeycomb, spirals, Hilbert curves * support material, raft, brim, skirt * **standby temperature** and automatic wiping for multi-extruder printing * customizable **G-code macros** and output filename with variable placeholders * support for **post-processing scripts** * **cooling logic** controlling fan speed and dynamic print speed ### How to install? You can just download a precompiled package from [slic3r.org](http://slic3r.org/); it will run without the need for any dependency. If you want to compile the source yourself just do the following (checkout [slic3r.org](http://slic3r.org/download) for more details): ``` $ git clone https://github.com/alexrj/Slic3r.git $ cd Slic3r $ perl Build.PL --sudo $ perl Build.PL --sudo --gui $ ./slic3r.pl ``` ### Can I help? Sure! Drop me a line at aar@cpan.org. You can also find me in #reprap and in #slic3r on FreeNode with the nickname _Sound_. Before sending patches and pull requests contact me to discuss your proposed changes: this way we'll ensure nobody wastes their time and no conflicts arise in development. ### What's Slic3r license? Slic3r is licensed under the _GNU Affero General Public License, version 3_. The author is Alessandro Ranellucci. The [Silk icon set](http://www.famfamfam.com/lab/icons/silk/) used in Slic3r is licensed under the _Creative Commons Attribution 3.0 License_. The author of the Silk icon set is Mark James. ### How can I invoke slic3r.pl using the command line? Usage: slic3r.pl [ OPTIONS ] [ file.stl ] [ file2.stl ] ... --help Output this usage screen and exit --version Output the version of Slic3r and exit --save Save configuration to the specified file --load Load configuration from the specified file. It can be used more than once to load options from multiple files. -o, --output File to output gcode to (by default, the file will be saved into the same directory as the input file using the --output-filename-format to generate the filename.) If a directory is specified for this option, the output will be saved under that directory, and the filename will be generated by --output-filename-format. Non-slicing actions (no G-code will be generated): --repair Repair given STL files and save them as _fixed.obj --cut Cut given input files at given Z (relative) and export them as _upper.stl and _lower.stl --split Split the shells contained in given STL file into several STL files --info Output information about the supplied file(s) and exit -j, --threads Number of threads to use (1+, default: 2) GUI options: --gui Forces the GUI launch instead of command line slicing (if you supply a model file, it will be loaded into the plater) --no-plater Disable the plater tab --gui-mode Overrides the configured mode (simple/expert) --autosave Automatically export current configuration to the specified file Output options: --output-filename-format Output file name format; all config options enclosed in brackets will be replaced by their values, as well as [input_filename_base] and [input_filename] (default: [input_filename_base].gcode) --post-process Generated G-code will be processed with the supplied script; call this more than once to process through multiple scripts. --export-svg Export a SVG file containing slices instead of G-code. -m, --merge If multiple files are supplied, they will be composed into a single print rather than processed individually. Printer options: --nozzle-diameter Diameter of nozzle in mm (default: 0.5) --print-center Coordinates in mm of the point to center the print around (default: 100,100) --z-offset Additional height in mm to add to vertical coordinates (+/-, default: 0) --gcode-flavor The type of G-code to generate (reprap/teacup/makerware/sailfish/mach3/machinekit/no-extrusion, default: reprap) --use-relative-e-distances Enable this to get relative E values (default: no) --use-firmware-retraction Enable firmware-controlled retraction using G10/G11 (default: no) --use-volumetric-e Express E in cubic millimeters and prepend M200 (default: no) --gcode-arcs Use G2/G3 commands for native arcs (experimental, not supported by all firmwares) --gcode-comments Make G-code verbose by adding comments (default: no) --pressure-advance Adjust pressure using the experimental advance algorithm (K constant, set zero to disable; default: 0) Filament options: --filament-diameter Diameter in mm of your raw filament (default: 3) --extrusion-multiplier Change this to alter the amount of plastic extruded. There should be very little need to change this value, which is only useful to compensate for filament packing (default: 1) --temperature Extrusion temperature in degree Celsius, set 0 to disable (default: 200) --first-layer-temperature Extrusion temperature for the first layer, in degree Celsius, set 0 to disable (default: same as --temperature) --bed-temperature Heated bed temperature in degree Celsius, set 0 to disable (default: 0) --first-layer-bed-temperature Heated bed temperature for the first layer, in degree Celsius, set 0 to disable (default: same as --bed-temperature) Speed options: --travel-speed Speed of non-print moves in mm/s (default: 130) --perimeter-speed Speed of print moves for perimeters in mm/s (default: 30) --small-perimeter-speed Speed of print moves for small perimeters in mm/s or % over perimeter speed (default: 30) --external-perimeter-speed Speed of print moves for the external perimeter in mm/s or % over perimeter speed (default: 70%) --infill-speed Speed of print moves in mm/s (default: 60) --solid-infill-speed Speed of print moves for solid surfaces in mm/s or % over infill speed (default: 60) --top-solid-infill-speed Speed of print moves for top surfaces in mm/s or % over solid infill speed (default: 50) --support-material-speed Speed of support material print moves in mm/s (default: 60) --support-material-interface-speed Speed of support material interface print moves in mm/s or % over support material speed (default: 100%) --bridge-speed Speed of bridge print moves in mm/s (default: 60) --gap-fill-speed Speed of gap fill print moves in mm/s (default: 20) --first-layer-speed Speed of print moves for bottom layer, expressed either as an absolute value or as a percentage over normal speeds (default: 30%) Acceleration options: --perimeter-acceleration Overrides firmware's default acceleration for perimeters. (mm/s^2, set zero to disable; default: 0) --infill-acceleration Overrides firmware's default acceleration for infill. (mm/s^2, set zero to disable; default: 0) --bridge-acceleration Overrides firmware's default acceleration for bridges. (mm/s^2, set zero to disable; default: 0) --first-layer-acceleration Overrides firmware's default acceleration for first layer. (mm/s^2, set zero to disable; default: 0) --default-acceleration Acceleration will be reset to this value after the specific settings above have been applied. (mm/s^2, set zero to disable; default: 0) Accuracy options: --layer-height Layer height in mm (default: 0.3) --first-layer-height Layer height for first layer (mm or %, default: 0.35) --infill-every-layers Infill every N layers (default: 1) --solid-infill-every-layers Force a solid layer every N layers (default: 0) Print options: --perimeters Number of perimeters/horizontal skins (range: 0+, default: 3) --top-solid-layers Number of solid layers to do for top surfaces (range: 0+, default: 3) --bottom-solid-layers Number of solid layers to do for bottom surfaces (range: 0+, default: 3) --solid-layers Shortcut for setting the two options above at once --fill-density Infill density (range: 0%-100%, default: 40%) --fill-angle Infill angle in degrees (range: 0-90, default: 45) --fill-pattern Pattern to use to fill non-solid layers (default: honeycomb) --solid-fill-pattern Pattern to use to fill solid layers (default: rectilinear) --start-gcode Load initial G-code from the supplied file. This will overwrite the default command (home all axes [G28]). --end-gcode Load final G-code from the supplied file. This will overwrite the default commands (turn off temperature [M104 S0], home X axis [G28 X], disable motors [M84]). --before-layer-gcode Load before-layer-change G-code from the supplied file (default: nothing). --layer-gcode Load after-layer-change G-code from the supplied file (default: nothing). --toolchange-gcode Load tool-change G-code from the supplied file (default: nothing). --seam-position Position of loop starting points (random/nearest/aligned, default: aligned). --external-perimeters-first Reverse perimeter order. (default: no) --spiral-vase Experimental option to raise Z gradually when printing single-walled vases (default: no) --only-retract-when-crossing-perimeters Disable retraction when travelling between infill paths inside the same island. (default: no) --solid-infill-below-area Force solid infill when a region has a smaller area than this threshold (mm^2, default: 70) --infill-only-where-needed Only infill under ceilings (default: no) --infill-first Make infill before perimeters (default: no) Quality options (slower slicing): --extra-perimeters Add more perimeters when needed (default: yes) --ensure_vertical_shell_thickness Add solid infill near sloping surfaces to guarantee the vertical shell thickness (top+bottom solid layers). (default: no) --avoid-crossing-perimeters Optimize travel moves so that no perimeters are crossed (default: no) --thin-walls Detect single-width walls (default: yes) --overhangs Experimental option to use bridge flow, speed and fan for overhangs (default: yes) Support material options: --support-material Generate support material for overhangs --support-material-threshold Overhang threshold angle (range: 0-90, set 0 for automatic detection, default: 0) --support-material-pattern Pattern to use for support material (default: honeycomb) --support-material-spacing Spacing between pattern lines (mm, default: 2.5) --support-material-angle Support material angle in degrees (range: 0-90, default: 0) --support-material-contact-distance Vertical distance between object and support material (0+, default: 0.2) --support-material-interface-layers Number of perpendicular layers between support material and object (0+, default: 3) --support-material-interface-spacing Spacing between interface pattern lines (mm, set 0 to get a solid layer, default: 0) --raft-layers Number of layers to raise the printed objects by (range: 0+, default: 0) --support-material-enforce-layers Enforce support material on the specified number of layers from bottom, regardless of --support-material and threshold (0+, default: 0) --dont-support-bridges Experimental option for preventing support material from being generated under bridged areas (default: yes) Retraction options: --retract-length Length of retraction in mm when pausing extrusion (default: 1) --retract-speed Speed for retraction in mm/s (default: 30) --retract-restart-extra Additional amount of filament in mm to push after compensating retraction (default: 0) --retract-before-travel Only retract before travel moves of this length in mm (default: 2) --retract-lift Lift Z by the given distance in mm when retracting (default: 0) --retract-lift-above Only lift Z when above the specified height (default: 0) --retract-lift-below Only lift Z when below the specified height (default: 0) --retract-layer-change Enforce a retraction before each Z move (default: no) --wipe Wipe the nozzle while doing a retraction (default: no) Retraction options for multi-extruder setups: --retract-length-toolchange Length of retraction in mm when disabling tool (default: 10) --retract-restart-extra-toolchange Additional amount of filament in mm to push after switching tool (default: 0) Cooling options: --cooling Enable fan and cooling control --min-fan-speed Minimum fan speed (default: 35%) --max-fan-speed Maximum fan speed (default: 100%) --bridge-fan-speed Fan speed to use when bridging (default: 100%) --fan-below-layer-time Enable fan if layer print time is below this approximate number of seconds (default: 60) --slowdown-below-layer-time Slow down if layer print time is below this approximate number of seconds (default: 30) --min-print-speed Minimum print speed (mm/s, default: 10) --disable-fan-first-layers Disable fan for the first N layers (default: 1) --fan-always-on Keep fan always on at min fan speed, even for layers that don't need cooling Skirt options: --skirts Number of skirts to draw (0+, default: 1) --skirt-distance Distance in mm between innermost skirt and object (default: 6) --skirt-height Height of skirts to draw (expressed in layers, 0+, default: 1) --min-skirt-length Generate no less than the number of loops required to consume this length of filament on the first layer, for each extruder (mm, 0+, default: 0) --brim-width Width of the brim that will get added to each object to help adhesion (mm, default: 0) Transform options: --scale Factor for scaling input object (default: 1) --rotate Rotation angle in degrees (0-360, default: 0) --duplicate Number of items with auto-arrange (1+, default: 1) --duplicate-grid Number of items with grid arrangement (default: 1,1) --duplicate-distance Distance in mm between copies (default: 6) --dont-arrange Don't arrange the objects on the build plate. The model coordinates define the absolute positions on the build plate. The option --print-center will be ignored. --xy-size-compensation Grow/shrink objects by the configured absolute distance (mm, default: 0) Sequential printing options: --complete-objects When printing multiple objects and/or copies, complete each one before starting the next one; watch out for extruder collisions (default: no) --extruder-clearance-radius Radius in mm above which extruder won't collide with anything (default: 20) --extruder-clearance-height Maximum vertical extruder depth; i.e. vertical distance from extruder tip and carriage bottom (default: 20) Miscellaneous options: --notes Notes to be added as comments to the output file --resolution Minimum detail resolution (mm, set zero for full resolution, default: 0) Flow options (advanced): --extrusion-width Set extrusion width manually; it accepts either an absolute value in mm (like 0.65) or a percentage over layer height (like 200%) --first-layer-extrusion-width Set a different extrusion width for first layer --perimeter-extrusion-width Set a different extrusion width for perimeters --external-perimeter-extrusion-width Set a different extrusion width for external perimeters --infill-extrusion-width Set a different extrusion width for infill --solid-infill-extrusion-width Set a different extrusion width for solid infill --top-infill-extrusion-width Set a different extrusion width for top infill --support-material-extrusion-width Set a different extrusion width for support material --infill-overlap Overlap between infill and perimeters (default: 15%) --bridge-flow-ratio Multiplier for extrusion when bridging (> 0, default: 1) Multiple extruder options: --extruder-offset Offset of each extruder, if firmware doesn't handle the displacement (can be specified multiple times, default: 0x0) --perimeter-extruder Extruder to use for perimeters and brim (1+, default: 1) --infill-extruder Extruder to use for infill (1+, default: 1) --solid-infill-extruder Extruder to use for solid infill (1+, default: 1) --support-material-extruder Extruder to use for support material, raft and skirt (1+, default: 1) --support-material-interface-extruder Extruder to use for support material interface (1+, default: 1) --ooze-prevention Drop temperature and park extruders outside a full skirt for automatic wiping (default: no) --ooze-prevention Drop temperature and park extruders outside a full skirt for automatic wiping (default: no) --standby-temperature-delta Temperature difference to be applied when an extruder is not active and --ooze-prevention is enabled (default: -5) If you want to change a preset file, just do slic3r.pl --load config.ini --layer-height 0.25 --save config.ini If you want to slice a file overriding an option contained in your preset file: slic3r.pl --load config.ini --layer-height 0.25 file.stl Slic3r-version_1.31.6/doc/000077500000000000000000000000001301441720000152435ustar00rootroot00000000000000Slic3r-version_1.31.6/doc/How_to_build_Slic3r.txt000066400000000000000000000364131301441720000216500ustar00rootroot00000000000000How to build Slic3r on Mac OS X 10.7 Lion 64bit --------------------------------------------- Vojtech Bubnik, 2016-04-26 1) Install Mac OS X 10.7 Lion 64 bit with X Code ------------------------------------------------ One has to build the OSX Slic3r on a real Mac, either directly on the system, or on a virtualized OSX. On Mac, two commercial solutions are available to legally virtualize MacOS on MacOS: http://www.parallels.com/eu/products/desktop/ http://www.vmware.com/products/workstation/ Installation of a X Code on an OS X 10.7 Lion needs a bit of work. The latest X Code supported by the Lion on a Virtual Box is 4.21. The trouble is, the certificates of the X Code 4.21 installation package expired. One way to work around the certificate is to flatten the installation package by unpacking and repacking it: pkgutil --expand Foobar.pkg foobar pkgutil --flatten foobar barfoo.pkg The flattened package is available here: \\rs.prusa\Development\Slic3r-Prusa\installxcode_421_lion_fixed.pkg This installer does not install the X Code directly. Instead, it installs another installer with a set of 47 pkg files. These files have their certificates expired as well. You will find the packages on your MacOS here: /Applications/Install Xcode.app/Contents/Resources/Packages/ It is best to flatten them in a loop: cd /Applications/Install\ Xcode.app/Contents/Resources/Packages/ for f in *.pkg; do pkgutil --expand $f /tmp/$f rm -f $f pkgutil --flatten /tmp/$f $f done After that, you may finish the installation of Xcode by running /Applications/Install\ Xcode.app 1b) Installing the Xcode on a newer system ------------------------------------------- You will need to register as an Apple developer on https://developer.apple.com/ log in and download and install Xcode https://developer.apple.com/downloads/ You will likely need to download and install Xcode Command Line Tools, though the Xcode 4.1 came with the command line tools installed. 2) Prepare the development environment -------------------------------------- Install the brew package manager: http://brew.sh/ The brew package manager requires the git command line tool. Normally the git tool is installed as part of the Xcode command line tools. Copy and execute a command line from the top of http://brew.sh/ . It is possible, that the invocation of git fails because of some parameters the old git does not recognize. If so, invoke the git call manually. Compile the boost library using brew. Following line compiles a 64bit boost with both static and shared libraries. brew install boost --universal Install dylibbundler tool. The dylibbundler tool serves to collect dependent dynamic libraries and fix their linkage. Execute brew install dylibbundler 3) Install perl --------------- We don't want to distribute perl pre-installed on the Mac OS box. First, the system perl installation is not correct on some Mac OS versions, second it is not rellocatable. To compile a 64bit rellocatable perl, we use the perlbrew distribution. The perlbrew distribution installs into a user home directory and it allows switching between multiple versions of perl. http://perlbrew.pl/ First install perlbrew \curl -L http://install.perlbrew.pl | bash Then compile the newest perl with the rellocatable @INC path and with multithreading enabled, execute following line: perlbrew install --threads -Duserelocatableinc --switch perl-5.22.0 The --switch parameter switches the active perl to the currently compiled one. Available perl versions could be listed by calling perlbrew available Initialize CPAN, install PAR and PAR::Packer modules execute cpan command, from the cpan prompt, run install App::cpanminus install PAR install PAR::Packer quit 4) Download and install Slic3r ------------------------------ git clone git://github.com/alexrj/Slic3r cd Slic3r perl Build.PL Now Slic3r shall be compiled. You may try to execute perl slic3r.pl to get a help screen, or perl slic3r.pl some_model.stl to have the model sliced. 5) Download and compile the GUI libraries needed to execute Slic3r in GUI mode ------------------------------------------------------------------------------ For the current Slic3r 1.2.30 code base, set the environment variable SLIC3R_STATIC to link a static version of the boost library: export SLIC3R_STATIC=1 then execute perl Build.PL --gui and keep your fingers crossed. The Build.PL script downloads and compiles the WxWidgets 3.0 through a Alien::Wx PERL package. The WxWidget shared libraries will land into ~/perl5/perlbrew/perls/perl-5.22.1/lib/site_perl/5.22.1/darwin-thread-multi-2level/Alien/wxWidgets/ On Maverics, we experienced following issue compiling WxPerl: http://wiki.bolay.net/doku.php?id=acdsn:acdsn-a:mac Now you could run the GUI version of slic3r by calling perl slic3r.pl --gui If some dependency is missing, the MacOS system will let you know. 6) Packing the Slic3r --------------------- Perl is an operating system on its own. Many modules are shared among multiple applications and it is difficult to extract a stand-alone application from a perl installation manually. Fortunately, tools are available, which automate the process to some extent. One of the tools is the PAR::Packer. The PAR::Packer tool (pp executable) is able to create a standalone executable for a perl script. The standalone executable contains a PAR archive (a zip file) bundled with a perl interpreter. When executed, the bundled executable will decompress most of the PAR archive into a temp folder. Because of that, we will use the PAR::Packer to resolve and collect the dependencies, but we will create an installer manually. The PAR::Packer could analyze the dependencies by a statical analysis, or at a runtime. The statical analysis does not resolve the dynamically loaded modules. On the other side, the statical analysis is pessimistic, therefore it often collects unneeded packages. The dynamic analysis may miss some package, if not all branches of a code are executed. We will try to solely depend on the dynamic analysis to keep the installation size minimal. We may need to develop a protocol or an automatic UI tool to exercise as much as possible from the Slic3r GUI to pack the GUI version reliably. Once a reliable list of dependencies is collected, we may not need the PAR::Packer anymore. To create a PAR archive of a command line slic3r, execute pp -e -p -x slic3r.pl --xargs cube.stl -o slic3r.par and let the slic3r slice a cube.stl to load the dynamic modules. To create a PAR archive of a GUI slic3r, execute pp -e -p -x slic3r.pl --xargs --gui -o slic3r.par and exercise the slic3r gui to load all modules. Rename the slic3r.par file to slic3r.zip and decompress. Most of the code needed to execute Slic3r is there, only the perl executable is missing for the command line slic3r, and the WxWidgets shared libraries and the liblzma shared library are missing for the GUI version. 7) Collecting the dependent shared libraries, making the link paths relative ---------------------------------------------------------------------------- We have linked Slic3r against a static boost library, therefore the command line slic3r is not dependent on any non-system shared library. The situation is different for the GUI slic3r, which links dynamically against WxWidgets and liblzma. The trick developed by Apple to allow rellocable shared libraries is to addres a shared library relatively to the path of the executable by encoding a special token @executable_path at the start of the path. Unfortunately the libraries requried by Slic3r are compiled with absolute paths. Once the slic3r.par archive is unpacked, one may list the native shared libraries by find ./ -name '*.bundle' and one may list the dependencies by running otool -L somefile.bundle Most of the dependencies point to system directores and these dependences are always fulfilled. Dependencies pointing to the WxWidget libraries need to be fixed. These have a form ~/perlbrew/perls/perl-5.22.1/lib/site_perl/5.22.1/darwin-thread-multi-2level/Alien/wxWidgets/osx_cocoa_3_0_2_uni/lib/libwx_*.dylib and we need to replace them with @executable_path/../Frameworks/libwx_*.dylib Another dependency, which needs our attention is /usr/local/Cellar/xz/5.2.2/lib/liblzma.5.dylib Fortunately, a tool dylibbundler was developed to address this problem. First install dylibbundler by calling brew dylibbundler For some installations, the dylibbundler tool sufficiently fixes all dependencies. Unfortunately, the WxWidgets installation is inconsistent in the versioning, therefore a certain clean-up is required. Namely, the WxWidgets libraries are compiled with the full build number in their file name. For example, the base library is built as libwx_baseu-3.0.0.2.0.dylib and a symlink is created libwx_baseu-3.0.dylib pointing to the full name. Then some of the Wx libraries link against the full name and some against the symlink, leading the dylibbundler to pack both. We solved the problem by whipping up a following script: \\rs.prusa\Development\Slic3r-Prusa\How_to_build_on_MacOSX_Lion\fix_dependencies.sh call slic3r_dependencies.sh --fix to collect the shared libraries into Content/Frameworks and to fix their linkage. call slic3r_dependencies.sh --show to list dependent libraries in a sorted order. All the non-system dependencies shall start with @executable_path after the fix. 8) Packing Slic3r into a dmg image using a bunch of scripts ----------------------------------------------------------- Instead of relying on the PAR::Packer to collect the dependencies, we have used PAR::Packer to extract the dependencies, we manually cleaned them up and created an installer script. \\rs.prusa\Development\Slic3r-Prusa\How_to_build_on_MacOSX_Lion\Slic3r-Build-MacOS First compile Slic3r, then call build_dmg.sh with a path to the Slic3r source tree as a parameter. The script will collect all dependencies into Slic3r.app and it will create Slic3r.dmg. If SLIC3R_GUI variable is defined, a GUI variant of Slic3r will be packed. How to build on Windows ----------------------- The prefered perl distribution on MS Windows is the Strawberry Perl 5.22.1.3 (32bit) http://strawberryperl.com/ Let it install into c:\strawberry You may make a copy of the distribution. We recommend to make following copies: For a release command line only build: c:\strawberry-minimal For a release GUI build: c:\strawberry-minimal-gui For a development build with debugging information: c:\strawberry-debug and to make one of them active by making a directory junction: mklink /d c:\Strawberry c:\Strawberry-debug Building boost: Slic3r seems to have a trouble with the latest boost 1.60.0 on Windows. Please use 1.59. Decompress it to c:\dev\ otherwise it will not be found by the Build.PL on Windows. You may consider to hack xs\Build.PL with your prefered boost path. run bootstrap.bat mingw b2 toolset=gcc Install git command line https://git-scm.com/ Download Slic3r source code git clone git://github.com/alexrj/Slic3r.git Run compilation cd Slic3r perl Build.PL perl Build.PL --gui With a bit of luck, you will end up with a working Slic3r including GUI. Packing on Windows ------------------ Life is easy on Windows. PAR::Packer will help again to collect the dependencies. The basic procedure is the same as for MacOS: To create a PAR archive of a command line slic3r, execute pp -e -p -x slic3r.pl --xargs cube.stl -o slic3r.par and let the slic3r slice a cube.stl to load the dynamic modules. To create a PAR archive of a GUI slic3r, execute pp -e -p -x slic3r.pl --xargs --gui -o slic3r.par and exercise the slic3r gui to load all modules. The standalone installation is then created from the PAR archive by renaming it into a zip and adding following binaries from c:\strawberry to the root of the extracted zip: perl5.22.1.exe perl522.dll libgcc_s_sjlj-1.dll libstdc++-6.dll libwinpthread-1.dll The GUI build requires following DLLs in addition: libglut-0_.dll wxbase30u_gcc_custom.dll wxmsw30u_adv_gcc_custom.dll wxmsw30u_core_gcc_custom.dll wxmsw30u_gl_gcc_custom.dll wxmsw30u_html_gcc_custom.dll and the var directory with the icons needs to be copied to the destination directory. To run the slic3r, move the script\slic3r.pl one level up and create a following tiny windows batch in the root of the unpacked zip: @perl5.22.1.exe slic3r.pl %* A windows shortcut may be created for the GUI version. Instead of the perl.exe, it is better to use the wperl.exe to start the GUI Slic3r, because it does not open a text console. The strawberry perl is already rellocatable, which means that the perl interpreter will find the perl modules in the lib directory, and Windows look up the missing DLLs in the directory of the executable, therefore no further rellocation effort is necessary. Packing on Windows, a single EXE solution ----------------------------------------- One may try to create a PAR executable for command line slic3r: pp -M Encode::Locale -M Moo -M Thread::Semaphore -M Slic3r::XS -M Unicode::Normalize -o slic3r.exe slic3r.pl One may as well create a PAR executable for Windows GUI: pp -M Encode::Locale -M Moo -M Thread::Semaphore -M OpenGL -M Slic3r::XS -M Unicode::Normalize -M Wx -M Class::Accessor -M Wx::DND -M Wx::Grid -M Wx::Print -M Wx::Html -M Wx::GLCanvas -M Math::Trig -M threads -M threads::shared -M Thread::Queue -l C:\strawberry\perl\site\lib\auto\Wx\Wx.xs.dll -o -l C:\strawberry\perl\site\lib\Alien\wxWidgets\msw_3_0_2_uni_gcc_3_4\lib\wxbase30u_gcc_custom.dll -l C:\strawberry\perl\site\lib\Alien\wxWidgets\msw_3_0_2_uni_gcc_3_4\lib\wxmsw30u_core_gcc_custom.dll -l C:\strawberry\perl\site\lib\Alien\wxWidgets\msw_3_0_2_uni_gcc_3_4\lib\wxmsw30u_gl_gcc_custom.dll -l C:\strawberry\perl\site\lib\Alien\wxWidgets\msw_3_0_2_uni_gcc_3_4\lib\wxmsw30u_adv_gcc_custom.dll -l C:\strawberry\perl\site\lib\Alien\wxWidgets\msw_3_0_2_uni_gcc_3_4\lib\wxmsw30u_html_gcc_custom.dll -o slic3r.exe slic3r.pl Remember, that these executables will unpack into a temporary directory. The directory may be declared by setting an environment variable PAR_GLOBAL_TEMP. Otherwise the temporaries are unpacked into C:\Users\xxx\AppData\Local\Temp\par-xxxxxx Debugging the perl, debugging on Windows ---------------------------------------- It is possible to debug perl using the integrated debugger. The EPIC plugin for Eclipse works very well with an older eclipse-SDK-3.6.2. There is a catch though: The Perl debugger does not work correctly with multiple threads running under the Perl interpreter. If that happens, the EPIC plugin gets confused and the debugger stops working. The same happens with the Komodo IDE. Debugging the C++ code works fine using the latest Eclipse for C++ and the gdb of MinGW. The gdb packed with the Strawberry distribution does not contain the Python support, so pretty printing of the stl containers only works if another gdb build is used. The one of the QT installation works well. It is yet a bit more complicated. The Strawberry MINGW is compiled for a different C++ exception passing model (SJLJ) than the other MINGWs, so one cannot simply combine MINGWs on Windows. For an unknown reason the nice debugger of the QT Creator hangs when debugging the C++ compiled by the Strawberry MINGW. Mabe it is because of the different exception passing models. And to disable optimization of the C/C++ code, one has to manually modify Config_heavy.pl in the Perl central installation. The SLIC3R_DEBUG environment variable did not override all the -O2 and -O3 flags that the perl build adds the gcc execution line. Slic3r-version_1.31.6/lib/000077500000000000000000000000001301441720000152445ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r.pm000066400000000000000000000301321301441720000167400ustar00rootroot00000000000000# This package loads all the non-GUI Slic3r perl packages. # In addition, it implements utility functions for file handling and threading. package Slic3r; # Copyright holder: Alessandro Ranellucci # This application is licensed under the GNU Affero General Public License, version 3 use strict; use warnings; require v5.10; our $VERSION = VERSION(); our $FORK_NAME = FORK_NAME(); our $debug = 0; sub debugf { printf @_ if $debug; } # load threads before Moo as required by it our $have_threads; BEGIN { # Test, whether the perl was compiled with ithreads support and ithreads actually work. use Config; $have_threads = $Config{useithreads} && eval "use threads; use threads::shared; use Thread::Queue; 1"; warn "threads.pm >= 1.96 is required, please update\n" if $have_threads && $threads::VERSION < 1.96; ### temporarily disable threads if using the broken Moo version use Moo; $have_threads = 0 if $Moo::VERSION == 1.003000; # Disable multi threading completely by an environment value. # This is useful for debugging as the Perl debugger does not work # in multi-threaded context at all. # A good interactive perl debugger is the ActiveState Komodo IDE # or the EPIC http://www.epic-ide.org/ $have_threads = 0 if (defined($ENV{'SLIC3R_SINGLETHREADED'}) && $ENV{'SLIC3R_SINGLETHREADED'} == 1); print "Threading disabled\n" if !$have_threads; $debug = 1 if (defined($ENV{'SLIC3R_DEBUGOUT'}) && $ENV{'SLIC3R_DEBUGOUT'} == 1); print "Debugging output enabled\n" if $debug; } warn "Running Slic3r under Perl 5.16 is neither supported nor recommended\n" if $^V == v5.16; use FindBin; # Path to the images. our $var = sub { decode_path($FindBin::Bin) . "/var/" . $_[0] }; use Moo 1.003001; use Slic3r::XS; # import all symbols (constants etc.) before they get parsed use Slic3r::Config; use Slic3r::ExPolygon; use Slic3r::ExtrusionLoop; use Slic3r::ExtrusionPath; use Slic3r::Flow; use Slic3r::Format::AMF; use Slic3r::Format::OBJ; use Slic3r::Format::STL; use Slic3r::GCode::ArcFitting; use Slic3r::GCode::CoolingBuffer; use Slic3r::GCode::MotionPlanner; use Slic3r::GCode::PressureRegulator; use Slic3r::GCode::Reader; use Slic3r::GCode::SpiralVase; use Slic3r::Geometry qw(PI); use Slic3r::Geometry::Clipper; use Slic3r::Layer; use Slic3r::Line; use Slic3r::Model; use Slic3r::Point; use Slic3r::Polygon; use Slic3r::Polyline; use Slic3r::Print; use Slic3r::Print::GCode; use Slic3r::Print::Object; use Slic3r::Print::Simple; use Slic3r::Print::SupportMaterial; use Slic3r::Surface; our $build = eval "use Slic3r::Build; 1"; use Thread::Semaphore; use Encode::Locale 1.05; use Encode; use Unicode::Normalize; # Scaling between the float and integer coordinates. # Floats are in mm. use constant SCALING_FACTOR => 0.000001; use constant LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER => 0.15; # Following constants are used by the infill algorithms and integration tests. # Resolution to simplify perimeters to. These constants are now used in C++ code only. Better to publish them to Perl from the C++ code. # use constant RESOLUTION => 0.0125; # use constant SCALED_RESOLUTION => RESOLUTION / SCALING_FACTOR; use constant INFILL_OVERLAP_OVER_SPACING => 0.3; # Keep track of threads we created. Each thread keeps its own list of threads it spwaned. my @my_threads = (); my @threads : shared = (); my $pause_sema = Thread::Semaphore->new; my $parallel_sema; my $paused = 0; sub spawn_thread { my ($cb) = @_; my $parent_tid = threads->tid; lock @threads; @_ = (); my $thread = threads->create(sub { @my_threads = (); Slic3r::debugf "Starting thread %d (parent: %d)...\n", threads->tid, $parent_tid; local $SIG{'KILL'} = sub { Slic3r::debugf "Exiting thread %d...\n", threads->tid; $parallel_sema->up if $parallel_sema; kill_all_threads(); Slic3r::thread_cleanup(); threads->exit(); }; local $SIG{'STOP'} = sub { $pause_sema->down; $pause_sema->up; }; $cb->(); }); push @my_threads, $thread->tid; push @threads, $thread->tid; return $thread; } # If the threading is enabled, spawn a set of threads. # Otherwise run the task on the current thread. # Used for # Slic3r::Print::Object->layers->make_perimeters : This is a pure C++ function. # Slic3r::Print::Object->layers->make_fill : This is a pure C++ function. # Slic3r::Print::SupportMaterial::generate_toolpaths sub parallelize { my %params = @_; lock @threads; if (!$params{disable} && $Slic3r::have_threads && $params{threads} > 1) { my @items = (ref $params{items} eq 'CODE') ? $params{items}->() : @{$params{items}}; my $q = Thread::Queue->new; $q->enqueue(@items, (map undef, 1..$params{threads})); $parallel_sema = Thread::Semaphore->new(-$params{threads}); $parallel_sema->up; my $thread_cb = sub { # execute thread callback $params{thread_cb}->($q); # signal the parent thread that we're done $parallel_sema->up; # cleanup before terminating thread Slic3r::thread_cleanup(); # This explicit exit avoids an untrappable # "Attempt to free unreferenced scalar" error # triggered on Ubuntu 12.04 32-bit when we're running # from the Wx plater and # we're reusing the same plater object more than once. # The downside to using this exit is that we can't return # any value to the main thread but we're not doing that # anymore anyway. threads->exit; }; @_ = (); my @my_threads = map spawn_thread($thread_cb), 1..$params{threads}; # We use a semaphore instead of $th->join because joined threads are # not listed by threads->list or threads->object anymore, thus can't # be signalled. $parallel_sema->down; $_->detach for @my_threads; } else { $params{no_threads_cb}->(); } } # call this at the very end of each thread (except the main one) # so that it does not try to free existing objects. # at that stage, existing objects are only those that we # inherited at the thread creation (thus shared) and those # that we are returning: destruction will be handled by the # main thread in both cases. # reminder: do not destroy inherited objects in other threads, # as the main thread will still try to destroy them when they # go out of scope; in other words, if you're undef()'ing an # object in a thread, make sure the main thread still holds a # reference so that it won't be destroyed in thread. sub thread_cleanup { return if !$Slic3r::have_threads; if (threads->tid == 0) { warn "Calling thread_cleanup() from main thread\n"; return; } # prevent destruction of shared objects no warnings 'redefine'; *Slic3r::BridgeDetector::DESTROY = sub {}; *Slic3r::Config::DESTROY = sub {}; *Slic3r::Config::Full::DESTROY = sub {}; *Slic3r::Config::GCode::DESTROY = sub {}; *Slic3r::Config::Print::DESTROY = sub {}; *Slic3r::Config::PrintObject::DESTROY = sub {}; *Slic3r::Config::PrintRegion::DESTROY = sub {}; *Slic3r::Config::Static::DESTROY = sub {}; *Slic3r::ExPolygon::DESTROY = sub {}; *Slic3r::ExPolygon::Collection::DESTROY = sub {}; *Slic3r::Extruder::DESTROY = sub {}; *Slic3r::ExtrusionLoop::DESTROY = sub {}; *Slic3r::ExtrusionPath::DESTROY = sub {}; *Slic3r::ExtrusionPath::Collection::DESTROY = sub {}; *Slic3r::ExtrusionSimulator::DESTROY = sub {}; *Slic3r::Flow::DESTROY = sub {}; # Fillers are only being allocated in worker threads, which are not going to be forked. # Therefore the Filler instances shall be released at the end of the thread. # *Slic3r::Filler::DESTROY = sub {}; *Slic3r::GCode::DESTROY = sub {}; *Slic3r::GCode::AvoidCrossingPerimeters::DESTROY = sub {}; *Slic3r::GCode::OozePrevention::DESTROY = sub {}; *Slic3r::GCode::PlaceholderParser::DESTROY = sub {}; *Slic3r::GCode::Sender::DESTROY = sub {}; *Slic3r::GCode::Wipe::DESTROY = sub {}; *Slic3r::GCode::Writer::DESTROY = sub {}; *Slic3r::Geometry::BoundingBox::DESTROY = sub {}; *Slic3r::Geometry::BoundingBoxf::DESTROY = sub {}; *Slic3r::Geometry::BoundingBoxf3::DESTROY = sub {}; *Slic3r::Layer::PerimeterGenerator::DESTROY = sub {}; *Slic3r::Line::DESTROY = sub {}; *Slic3r::Linef3::DESTROY = sub {}; *Slic3r::Model::DESTROY = sub {}; *Slic3r::Model::Object::DESTROY = sub {}; *Slic3r::Point::DESTROY = sub {}; *Slic3r::Pointf::DESTROY = sub {}; *Slic3r::Pointf3::DESTROY = sub {}; *Slic3r::Polygon::DESTROY = sub {}; *Slic3r::Polyline::DESTROY = sub {}; *Slic3r::Polyline::Collection::DESTROY = sub {}; *Slic3r::Print::DESTROY = sub {}; *Slic3r::Print::Object::DESTROY = sub {}; *Slic3r::Print::Region::DESTROY = sub {}; *Slic3r::Surface::DESTROY = sub {}; *Slic3r::Surface::Collection::DESTROY = sub {}; *Slic3r::Print::SupportMaterial2::DESTROY = sub {}; *Slic3r::TriangleMesh::DESTROY = sub {}; return undef; # this prevents a "Scalars leaked" warning } sub get_running_threads { return grep defined($_), map threads->object($_), @_; } sub kill_all_threads { # if we're the main thread, we send SIGKILL to all the running threads if (threads->tid == 0) { lock @threads; foreach my $thread (get_running_threads(@threads)) { Slic3r::debugf "Thread %d killing %d...\n", threads->tid, $thread->tid; $thread->kill('KILL'); } # unlock semaphore before we block on wait # otherwise we'd get a deadlock if threads were paused resume_all_threads(); } # in any thread we wait for our children foreach my $thread (get_running_threads(@my_threads)) { Slic3r::debugf " Thread %d waiting for %d...\n", threads->tid, $thread->tid; $thread->join; # block until threads are killed Slic3r::debugf " Thread %d finished waiting for %d...\n", threads->tid, $thread->tid; } @my_threads = (); } sub pause_all_threads { return if $paused; lock @threads; $paused = 1; $pause_sema->down; $_->kill('STOP') for get_running_threads(@threads); } sub resume_all_threads { return unless $paused; lock @threads; $paused = 0; $pause_sema->up; } # Convert a Unicode path to a file system locale. # The encoding is (from Encode::Locale POD): # Alias | Windows | Mac OS X | POSIX # locale_fs | ANSI | UTF-8 | nl_langinfo # where nl_langinfo is en-US.UTF-8 on a modern Linux as well. # So this conversion seems to make the most sense on Windows. sub encode_path { my ($path) = @_; $path = Unicode::Normalize::NFC($path); $path = Encode::encode(locale_fs => $path); return $path; } # Convert a path coded by a file system locale to Unicode. sub decode_path { my ($path) = @_; $path = Encode::decode(locale_fs => $path) unless utf8::is_utf8($path); # The filesystem might force a normalization form (like HFS+ does) so # if we rely on the filename being comparable after the open() + readdir() # roundtrip (like when creating and then selecting a preset), we need to # restore our normalization form. $path = Unicode::Normalize::NFC($path); return $path; } # Open a file by converting $filename to local file system locales. sub open { my ($fh, $mode, $filename) = @_; return CORE::open $$fh, $mode, encode_path($filename); } # this package declaration prevents an ugly fatal warning to be emitted when # spawning a new thread package GLUquadricObjPtr; 1; Slic3r-version_1.31.6/lib/Slic3r/000077500000000000000000000000001301441720000164035ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/Config.pm000066400000000000000000000352331301441720000201540ustar00rootroot00000000000000# Extends C++ class Slic3r::DynamicPrintConfig # This perl class does not keep any perl class variables, # all the storage is handled by the underlying C++ code. package Slic3r::Config; use strict; use warnings; use utf8; use List::Util qw(first max); # cemetery of old config settings our @Ignore = qw(duplicate_x duplicate_y multiply_x multiply_y support_material_tool acceleration adjust_overhang_flow standby_temperature scale rotate duplicate duplicate_grid rotate scale duplicate_grid start_perimeters_at_concave_points start_perimeters_at_non_overhang randomize_start seal_position bed_size print_center g0 vibration_limit); # C++ Slic3r::PrintConfigDef exported as a Perl hash of hashes. # The C++ counterpart is a constant singleton. our $Options = print_config_def(); # overwrite the hard-coded readonly value (this information is not available in XS) $Options->{threads}{readonly} = !$Slic3r::have_threads; # generate accessors { no strict 'refs'; for my $opt_key (keys %$Options) { *{$opt_key} = sub { $_[0]->get($opt_key) }; } } # Fill in the underlying C++ Slic3r::DynamicPrintConfig with the content of the defaults # provided by the C++ class Slic3r::FullPrintConfig. sub new_from_defaults { my $class = shift; my (@opt_keys) = @_; my $self = $class->new; # Instantiating the C++ class Slic3r::FullPrintConfig. my $defaults = Slic3r::Config::Full->new; if (@opt_keys) { $self->set($_, $defaults->get($_)) for grep $defaults->has($_), @opt_keys; } else { $self->apply_static($defaults); } return $self; } # From command line parameters sub new_from_cli { my $class = shift; my %args = @_; # Delete hash keys with undefined value. delete $args{$_} for grep !defined $args{$_}, keys %args; # Replace the start_gcode, end_gcode ... hash values # with the content of the files they reference. for (qw(start end layer toolchange)) { my $opt_key = "${_}_gcode"; if ($args{$opt_key}) { if (-e $args{$opt_key}) { Slic3r::open(\my $fh, "<", $args{$opt_key}) or die "Failed to open $args{$opt_key}\n"; binmode $fh, ':utf8'; $args{$opt_key} = do { local $/; <$fh> }; close $fh; } } } my $self = $class->new; foreach my $opt_key (keys %args) { my $opt_def = $Options->{$opt_key}; # we use set_deserialize() for bool options since GetOpt::Long doesn't handle # arrays of boolean values if ($opt_key =~ /^(?:bed_shape|duplicate_grid|extruder_offset)$/ || $opt_def->{type} eq 'bool') { $self->set_deserialize($opt_key, $args{$opt_key}); } elsif (my $shortcut = $opt_def->{shortcut}) { $self->set($_, $args{$opt_key}) for @$shortcut; } else { $self->set($opt_key, $args{$opt_key}); } } return $self; } sub merge { my $class = shift; my $config = $class->new; $config->apply($_) for @_; return $config; } # Load a flat ini file without a category into the underlying C++ Slic3r::DynamicConfig class, # convert legacy configuration names. sub load { my $class = shift; my ($file) = @_; my $ini = __PACKAGE__->read_ini($file); return $class->load_ini_hash($ini->{_}); } # Deserialize a perl hash into the underlying C++ Slic3r::DynamicConfig class, # convert legacy configuration names. sub load_ini_hash { my $class = shift; my ($ini_hash) = @_; my $config = $class->new; foreach my $opt_key (keys %$ini_hash) { ($opt_key, my $value) = _handle_legacy($opt_key, $ini_hash->{$opt_key}); next if !defined $opt_key; $config->set_deserialize($opt_key, $value); } return $config; } sub clone { my $self = shift; my $new = (ref $self)->new; $new->apply($self); return $new; } sub get_value { my $self = shift; my ($opt_key) = @_; return $Options->{$opt_key}{ratio_over} ? $self->get_abs_value($opt_key) : $self->get($opt_key); } sub _handle_legacy { my ($opt_key, $value) = @_; # handle legacy options if ($opt_key =~ /^(extrusion_width|bottom_layer_speed|first_layer_height)_ratio$/) { $opt_key = $1; $opt_key =~ s/^bottom_layer_speed$/first_layer_speed/; $value = $value =~ /^\d+(?:\.\d+)?$/ && $value != 0 ? ($value*100) . "%" : 0; } if ($opt_key eq 'threads' && !$Slic3r::have_threads) { $value = 1; } if ($opt_key eq 'gcode_flavor' && $value eq 'makerbot') { $value = 'makerware'; } if ($opt_key eq 'fill_density' && defined($value) && $value !~ /%/ && $value <= 1) { # fill_density was turned into a percent value $value *= 100; $value = "$value"; # force update of the PV value, workaround for bug https://rt.cpan.org/Ticket/Display.html?id=94110 } if ($opt_key eq 'randomize_start' && $value) { $opt_key = 'seam_position'; $value = 'random'; } if ($opt_key eq 'bed_size' && $value) { $opt_key = 'bed_shape'; my ($x, $y) = split /,/, $value; $value = "0x0,${x}x0,${x}x${y},0x${y}"; } return () if first { $_ eq $opt_key } @Ignore; # For historical reasons, the world's full of configs having these very low values; # to avoid unexpected behavior we need to ignore them. Banning these two hard-coded # values is a dirty hack and will need to be removed sometime in the future, but it # will avoid lots of complaints for now. if ($opt_key eq 'perimeter_acceleration' && $value == '25') { $value = 0; } if ($opt_key eq 'infill_acceleration' && $value == '50') { $value = 0; } if (!exists $Options->{$opt_key}) { my @keys = grep { $Options->{$_}{aliases} && grep $_ eq $opt_key, @{$Options->{$_}{aliases}} } keys %$Options; if (!@keys) { warn "Unknown option $opt_key\n"; return (); } $opt_key = $keys[0]; } return ($opt_key, $value); } # Create a hash of hashes from the underlying C++ Slic3r::DynamicPrintConfig. # The first hash key is '_' meaning no category. sub as_ini { my ($self) = @_; my $ini = { _ => {} }; foreach my $opt_key (sort @{$self->get_keys}) { next if $Options->{$opt_key}{shortcut}; $ini->{_}{$opt_key} = $self->serialize($opt_key); } return $ini; } # Save the content of the underlying C++ Slic3r::DynamicPrintConfig as a flat ini file without any category. sub save { my $self = shift; my ($file) = @_; __PACKAGE__->write_ini($file, $self->as_ini); } # this method is idempotent by design and only applies to ::DynamicConfig or ::Full # objects because it performs cross checks sub validate { my $self = shift; # -j, --threads die "Invalid value for --threads\n" if $self->threads < 1; # --layer-height die "Invalid value for --layer-height\n" if $self->layer_height <= 0; die "--layer-height must be a multiple of print resolution\n" if $self->layer_height / &Slic3r::SCALING_FACTOR % 1 != 0; # --first-layer-height die "Invalid value for --first-layer-height\n" if $self->first_layer_height !~ /^(?:\d*(?:\.\d+)?)%?$/; die "Invalid value for --first-layer-height\n" if $self->get_value('first_layer_height') <= 0; # --filament-diameter die "Invalid value for --filament-diameter\n" if grep $_ < 1, @{$self->filament_diameter}; # --nozzle-diameter die "Invalid value for --nozzle-diameter\n" if grep $_ < 0, @{$self->nozzle_diameter}; # --perimeters die "Invalid value for --perimeters\n" if $self->perimeters < 0; # --solid-layers die "Invalid value for --solid-layers\n" if defined $self->solid_layers && $self->solid_layers < 0; die "Invalid value for --top-solid-layers\n" if $self->top_solid_layers < 0; die "Invalid value for --bottom-solid-layers\n" if $self->bottom_solid_layers < 0; # --gcode-flavor die "Invalid value for --gcode-flavor\n" if !first { $_ eq $self->gcode_flavor } @{$Options->{gcode_flavor}{values}}; die "--use-firmware-retraction is only supported by Marlin firmware\n" if $self->use_firmware_retraction && $self->gcode_flavor ne 'reprap' && $self->gcode_flavor ne 'machinekit'; die "--use-firmware-retraction is not compatible with --wipe\n" if $self->use_firmware_retraction && first {$_} @{$self->wipe}; # --fill-pattern die "Invalid value for --fill-pattern\n" if !first { $_ eq $self->fill_pattern } @{$Options->{fill_pattern}{values}}; # --external-fill-pattern die "Invalid value for --external-fill-pattern\n" if !first { $_ eq $self->external_fill_pattern } @{$Options->{external_fill_pattern}{values}}; # --fill-density die "The selected fill pattern is not supposed to work at 100% density\n" if $self->fill_density == 100 && !first { $_ eq $self->fill_pattern } @{$Options->{external_fill_pattern}{values}}; # --infill-every-layers die "Invalid value for --infill-every-layers\n" if $self->infill_every_layers !~ /^\d+$/ || $self->infill_every_layers < 1; # --skirt-height die "Invalid value for --skirt-height\n" if $self->skirt_height < -1; # -1 means as tall as the object # --bridge-flow-ratio die "Invalid value for --bridge-flow-ratio\n" if $self->bridge_flow_ratio <= 0; # extruder clearance die "Invalid value for --extruder-clearance-radius\n" if $self->extruder_clearance_radius <= 0; die "Invalid value for --extruder-clearance-height\n" if $self->extruder_clearance_height <= 0; # --extrusion-multiplier die "Invalid value for --extrusion-multiplier\n" if defined first { $_ <= 0 } @{$self->extrusion_multiplier}; # --default-acceleration die "Invalid zero value for --default-acceleration when using other acceleration settings\n" if ($self->perimeter_acceleration || $self->infill_acceleration || $self->bridge_acceleration || $self->first_layer_acceleration) && !$self->default_acceleration; # --spiral-vase if ($self->spiral_vase) { # Note that we might want to have more than one perimeter on the bottom # solid layers. die "Can't make more than one perimeter when spiral vase mode is enabled\n" if $self->perimeters > 1; die "Can't make less than one perimeter when spiral vase mode is enabled\n" if $self->perimeters < 1; die "Spiral vase mode can only print hollow objects, so you need to set Fill density to 0\n" if $self->fill_density > 0; die "Spiral vase mode is not compatible with top solid layers\n" if $self->top_solid_layers > 0; die "Spiral vase mode is not compatible with support material\n" if $self->support_material || $self->support_material_enforce_layers > 0; } # extrusion widths { my $max_nozzle_diameter = max(@{ $self->nozzle_diameter }); die "Invalid extrusion width (too large)\n" if defined first { $_ > 10 * $max_nozzle_diameter } map $self->get_abs_value_over("${_}_extrusion_width", $self->layer_height), qw(perimeter infill solid_infill top_infill support_material first_layer); } # general validation, quick and dirty foreach my $opt_key (@{$self->get_keys}) { my $opt = $Options->{$opt_key}; next unless defined $self->$opt_key; next unless defined $opt->{cli} && $opt->{cli} =~ /=(.+)$/; my $type = $1; my @values = (); if ($type =~ s/\@$//) { die "Invalid value for $opt_key\n" if ref($self->$opt_key) ne 'ARRAY'; @values = @{ $self->$opt_key }; } else { @values = ($self->$opt_key); } foreach my $value (@values) { if ($type eq 'i' || $type eq 'f' || $opt->{type} eq 'percent') { $value =~ s/%$// if $opt->{type} eq 'percent'; die "Invalid value for $opt_key\n" if ($type eq 'i' && $value !~ /^-?\d+$/) || (($type eq 'f' || $opt->{type} eq 'percent') && $value !~ /^-?(?:\d+|\d*\.\d+)$/) || (defined $opt->{min} && $value < $opt->{min}) || (defined $opt->{max} && $value > $opt->{max}); } elsif ($type eq 's' && $opt->{type} eq 'select') { die "Invalid value for $opt_key\n" unless first { $_ eq $value } @{ $opt->{values} }; } } } return 1; } # CLASS METHODS: # Write a "Windows" style ini file with categories enclosed in squre brackets. sub write_ini { my $class = shift; my ($file, $ini) = @_; Slic3r::open(\my $fh, '>', $file); binmode $fh, ':utf8'; my $localtime = localtime; printf $fh "# generated by Slic3r $Slic3r::VERSION on %s\n", "$localtime"; # make sure the _ category is the first one written foreach my $category (sort { ($a eq '_') ? -1 : ($a cmp $b) } keys %$ini) { printf $fh "\n[%s]\n", $category if $category ne '_'; foreach my $key (sort keys %{$ini->{$category}}) { printf $fh "%s = %s\n", $key, $ini->{$category}{$key}; } } close $fh; } # Parse a "Windows" style ini file with categories enclosed in squre brackets. # Returns a hash of hashes over strings. # {category}{name}=value # Non-categorized entries are stored under a category '_'. sub read_ini { my $class = shift; my ($file) = @_; local $/ = "\n"; Slic3r::open(\my $fh, '<', $file) or die "Unable to open $file: $!\n"; binmode $fh, ':utf8'; my $ini = { _ => {} }; my $category = '_'; while (<$fh>) { s/\R+$//; next if /^\s+/; next if /^$/; next if /^\s*#/; if (/^\[(.+?)\]$/) { $category = $1; next; } /^(\w+) *= *(.*)/ or die "Unreadable configuration file (invalid data at line $.)\n"; $ini->{$category}{$1} = $2; } close $fh; return $ini; } package Slic3r::Config::Static; use parent 'Slic3r::Config'; sub Slic3r::Config::GCode::new { Slic3r::Config::Static::new_GCodeConfig } sub Slic3r::Config::Print::new { Slic3r::Config::Static::new_PrintConfig } sub Slic3r::Config::PrintObject::new { Slic3r::Config::Static::new_PrintObjectConfig } sub Slic3r::Config::PrintRegion::new { Slic3r::Config::Static::new_PrintRegionConfig } sub Slic3r::Config::Full::new { Slic3r::Config::Static::new_FullPrintConfig } 1; Slic3r-version_1.31.6/lib/Slic3r/ExPolygon.pm000066400000000000000000000022211301441720000206620ustar00rootroot00000000000000package Slic3r::ExPolygon; use strict; use warnings; # an ExPolygon is a polygon with holes use List::Util qw(first); use Slic3r::Geometry qw(X Y A B point_in_polygon epsilon scaled_epsilon); use Slic3r::Geometry::Clipper qw(union_ex diff_pl); sub wkt { my $self = shift; return sprintf "POLYGON(%s)", join ',', map "($_)", map { join ',', map "$_->[0] $_->[1]", @$_ } @$self; } sub dump_perl { my $self = shift; return sprintf "[%s]", join ',', map "[$_]", map { join ',', map "[$_->[0],$_->[1]]", @$_ } @$self; } sub offset { my $self = shift; return Slic3r::Geometry::Clipper::offset(\@$self, @_); } sub offset_ex { my $self = shift; return Slic3r::Geometry::Clipper::offset_ex(\@$self, @_); } sub noncollapsing_offset_ex { my $self = shift; my ($distance, @params) = @_; return $self->offset_ex($distance + 1, @params); } sub bounding_box { my $self = shift; return $self->contour->bounding_box; } package Slic3r::ExPolygon::Collection; use Slic3r::Geometry qw(X1 Y1); sub size { my $self = shift; return [ Slic3r::Geometry::size_2D([ map @$_, map @$_, @$self ]) ]; } 1; Slic3r-version_1.31.6/lib/Slic3r/ExtrusionLoop.pm000066400000000000000000000003501301441720000215710ustar00rootroot00000000000000package Slic3r::ExtrusionLoop; use strict; use warnings; use parent qw(Exporter); our @EXPORT_OK = qw(EXTRL_ROLE_DEFAULT EXTRL_ROLE_CONTOUR_INTERNAL_PERIMETER EXTRL_ROLE_SKIRT); our %EXPORT_TAGS = (roles => \@EXPORT_OK); 1; Slic3r-version_1.31.6/lib/Slic3r/ExtrusionPath.pm000066400000000000000000000006561301441720000215650ustar00rootroot00000000000000package Slic3r::ExtrusionPath; use strict; use warnings; use parent qw(Exporter); our @EXPORT_OK = qw(EXTR_ROLE_PERIMETER EXTR_ROLE_EXTERNAL_PERIMETER EXTR_ROLE_OVERHANG_PERIMETER EXTR_ROLE_FILL EXTR_ROLE_SOLIDFILL EXTR_ROLE_TOPSOLIDFILL EXTR_ROLE_GAPFILL EXTR_ROLE_BRIDGE EXTR_ROLE_SKIRT EXTR_ROLE_SUPPORTMATERIAL EXTR_ROLE_SUPPORTMATERIAL_INTERFACE EXTR_ROLE_NONE); our %EXPORT_TAGS = (roles => \@EXPORT_OK); 1; Slic3r-version_1.31.6/lib/Slic3r/Flow.pm000066400000000000000000000005211301441720000176460ustar00rootroot00000000000000package Slic3r::Flow; use strict; use warnings; use parent qw(Exporter); our @EXPORT_OK = qw(FLOW_ROLE_EXTERNAL_PERIMETER FLOW_ROLE_PERIMETER FLOW_ROLE_INFILL FLOW_ROLE_SOLID_INFILL FLOW_ROLE_TOP_SOLID_INFILL FLOW_ROLE_SUPPORT_MATERIAL FLOW_ROLE_SUPPORT_MATERIAL_INTERFACE); our %EXPORT_TAGS = (roles => \@EXPORT_OK); 1; Slic3r-version_1.31.6/lib/Slic3r/Format/000077500000000000000000000000001301441720000176335ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/Format/AMF.pm000066400000000000000000000120771301441720000206030ustar00rootroot00000000000000package Slic3r::Format::AMF; use Moo; use Slic3r::Geometry qw(X Y Z); sub read_file { my $self = shift; my ($file) = @_; eval qq{ require Slic3r::Format::AMF::Parser; use XML::SAX::ParserFactory; 1; } or die "AMF parsing requires XML::SAX\n"; Slic3r::open(\my $fh, '<', $file) or die "Failed to open $file\n"; my $model = Slic3r::Model->new; XML::SAX::ParserFactory ->parser(Handler => Slic3r::Format::AMF::Parser->new(_model => $model)) ->parse_file($fh); close $fh; return $model; } sub write_file { my $self = shift; my ($file, $model, %params) = @_; my %vertices_offset = (); Slic3r::open(\my $fh, '>', $file); binmode $fh, ':utf8'; printf $fh qq{\n}; printf $fh qq{\n}; printf $fh qq{ Slic3r %s\n}, $Slic3r::VERSION; for my $material_id (sort @{ $model->material_names }) { next if $material_id eq ''; my $material = $model->get_material($material_id); # note that material-id must never be 0 since it's reserved by the AMF spec printf $fh qq{ \n}, $material_id; for (keys %{$material->attributes}) { printf $fh qq{ %s\n}, $_, $material->attributes->{$_}; } my $config = $material->config; foreach my $opt_key (@{$config->get_keys}) { printf $fh qq{ %s\n}, $opt_key, $config->serialize($opt_key); } printf $fh qq{ \n}; } my $instances = ''; for my $object_id (0 .. $#{ $model->objects }) { my $object = $model->objects->[$object_id]; printf $fh qq{ \n}, $object_id; my $config = $object->config; foreach my $opt_key (@{$config->get_keys}) { printf $fh qq{ %s\n}, $opt_key, $config->serialize($opt_key); } if ($object->name) { printf $fh qq{ %s\n}, $object->name; } printf $fh qq{ \n}; printf $fh qq{ \n}; my @vertices_offset = (); { my $vertices_offset = 0; foreach my $volume (@{ $object->volumes }) { push @vertices_offset, $vertices_offset; my $vertices = $volume->mesh->vertices; foreach my $vertex (@$vertices) { printf $fh qq{ \n}; printf $fh qq{ \n}; printf $fh qq{ %s\n}, $vertex->[X]; printf $fh qq{ %s\n}, $vertex->[Y]; printf $fh qq{ %s\n}, $vertex->[Z]; printf $fh qq{ \n}; printf $fh qq{ \n}; } $vertices_offset += scalar(@$vertices); } } printf $fh qq{ \n}; foreach my $volume (@{ $object->volumes }) { my $vertices_offset = shift @vertices_offset; printf $fh qq{ \n}, ($volume->material_id eq '') ? '' : (sprintf ' materialid="%s"', $volume->material_id); my $config = $volume->config; foreach my $opt_key (@{$config->get_keys}) { printf $fh qq{ %s\n}, $opt_key, $config->serialize($opt_key); } if ($volume->name) { printf $fh qq{ %s\n}, $volume->name; } if ($volume->modifier) { printf $fh qq{ 1\n}; } foreach my $facet (@{$volume->mesh->facets}) { printf $fh qq{ \n}; printf $fh qq{ %d\n}, $_, $facet->[$_-1] + $vertices_offset, $_ for 1..3; printf $fh qq{ \n}; } printf $fh qq{ \n}; } printf $fh qq{ \n}; printf $fh qq{ \n}; if ($object->instances) { foreach my $instance (@{$object->instances}) { $instances .= sprintf qq{ \n}, $object_id; $instances .= sprintf qq{ %s\n}, $instance->offset->[X]; $instances .= sprintf qq{ %s\n}, $instance->offset->[Y]; $instances .= sprintf qq{ %s\n}, $instance->rotation; $instances .= sprintf qq{ \n}; } } } if ($instances) { printf $fh qq{ \n}; printf $fh $instances; printf $fh qq{ \n}; } printf $fh qq{\n}; close $fh; } 1; Slic3r-version_1.31.6/lib/Slic3r/Format/AMF/000077500000000000000000000000001301441720000202365ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/Format/AMF/Parser.pm000066400000000000000000000147341301441720000220410ustar00rootroot00000000000000package Slic3r::Format::AMF::Parser; use strict; use warnings; use base 'XML::SAX::Base'; my %xyz_index = (x => 0, y => 1, z => 2); #= sub new { my $self = shift->SUPER::new(@_); $self->{_tree} = []; $self->{_objects_map} = {}; # this hash maps AMF object IDs to object indexes in $model->objects $self->{_instances} = {}; # apply these lazily to make sure all objects have been parsed $self; } sub start_element { my $self = shift; my $data = shift; if ($data->{LocalName} eq 'object') { $self->{_object} = $self->{_model}->add_object; $self->{_object_vertices} = []; $self->{_objects_map}{ $self->_get_attribute($data, 'id') } = $#{ $self->{_model}->objects }; } elsif ($data->{LocalName} eq 'vertex') { $self->{_vertex} = ["", "", ""]; } elsif ($self->{_vertex} && $data->{LocalName} =~ /^[xyz]$/ && $self->{_tree}[-1] eq 'coordinates') { $self->{_coordinate} = $data->{LocalName}; } elsif ($data->{LocalName} eq 'volume') { $self->{_volume} = $self->{_object}->add_volume( material_id => $self->_get_attribute($data, 'materialid') // undef, mesh => Slic3r::TriangleMesh->new, ); $self->{_volume_facets} = []; } elsif ($data->{LocalName} eq 'triangle') { $self->{_triangle} = ["", "", ""]; } elsif ($self->{_triangle} && $data->{LocalName} =~ /^v([123])$/ && $self->{_tree}[-1] eq 'triangle') { $self->{_vertex_idx} = $1-1; } elsif ($data->{LocalName} eq 'material') { my $material_id = $self->_get_attribute($data, 'id') // '_'; $self->{_material} = $self->{_model}->set_material($material_id); } elsif ($data->{LocalName} eq 'metadata') { $self->{_metadata_type} = $self->_get_attribute($data, 'type'); $self->{_metadata_value} = ''; } elsif ($data->{LocalName} eq 'constellation') { $self->{_constellation} = 1; # we merge all constellations as we don't support more than one } elsif ($data->{LocalName} eq 'instance' && $self->{_constellation}) { my $object_id = $self->_get_attribute($data, 'objectid'); $self->{_instances}{$object_id} ||= []; push @{ $self->{_instances}{$object_id} }, $self->{_instance} = {}; } elsif ($data->{LocalName} =~ /^(?:deltax|deltay|rz)$/ && $self->{_instance}) { $self->{_instance_property} = $data->{LocalName}; } push @{$self->{_tree}}, $data->{LocalName}; } sub characters { my $self = shift; my $data = shift; if ($self->{_vertex} && $self->{_coordinate}) { $self->{_vertex}[ $xyz_index{$self->{_coordinate}} ] .= $data->{Data}; } elsif ($self->{_triangle} && defined $self->{_vertex_idx}) { $self->{_triangle}[ $self->{_vertex_idx} ] .= $data->{Data}; } elsif ($self->{_metadata_type}) { $self->{_metadata_value} .= $data->{Data}; } elsif ($self->{_instance_property}) { $self->{_instance}{ $self->{_instance_property} } .= $data->{Data}; } } sub end_element { my $self = shift; my $data = shift; pop @{$self->{_tree}}; if ($data->{LocalName} eq 'object') { $self->{_object} = undef; $self->{_object_vertices} = undef; } elsif ($data->{LocalName} eq 'vertex') { push @{$self->{_object_vertices}}, $self->{_vertex}; $self->{_vertex} = undef; } elsif ($self->{_coordinate} && $data->{LocalName} =~ /^[xyz]$/) { $self->{_coordinate} = undef; } elsif ($data->{LocalName} eq 'volume') { $self->{_volume}->mesh->ReadFromPerl($self->{_object_vertices}, $self->{_volume_facets}); $self->{_volume}->mesh->repair; $self->{_volume} = undef; $self->{_volume_facets} = undef; } elsif ($data->{LocalName} eq 'triangle') { push @{$self->{_volume_facets}}, $self->{_triangle}; $self->{_triangle} = undef; } elsif (defined $self->{_vertex_idx} && $data->{LocalName} =~ /^v[123]$/) { $self->{_vertex_idx} = undef; } elsif ($data->{LocalName} eq 'material') { $self->{_material} = undef; } elsif ($data->{LocalName} eq 'metadata') { my $value = $self->{_metadata_value}; if ($self->{_metadata_type} =~ /^slic3r\.(.+)/) { my $opt_key = $1; if (exists $Slic3r::Config::Options->{$opt_key}) { my $config; if ($self->{_material}) { $config = $self->{_material}->config; } elsif ($self->{_volume}) { $config = $self->{_volume}->config; } elsif ($self->{_object}) { $config = $self->{_object}->config; } $config->set_deserialize($opt_key, $value) if defined $config; } elsif ($opt_key eq 'modifier' && $self->{_volume}) { $self->{_volume}->set_modifier($value); } } elsif ($self->{_metadata_type} eq 'name' && $self->{_volume}) { $self->{_volume}->set_name($value); } elsif ($self->{_metadata_type} eq 'name' && $self->{_object}) { $self->{_object}->set_name($value); } elsif ($self->{_material}) { $self->{_material}->set_attribute($self->{_metadata_type}, $value); } $self->{_metadata_type} = undef; $self->{_metadata_value} = undef; } elsif ($data->{LocalName} eq 'constellation') { $self->{_constellation} = undef; } elsif ($data->{LocalName} eq 'instance') { $self->{_instance} = undef; } elsif ($data->{LocalName} =~ /^(?:deltax|deltay|rz)$/ && $self->{_instance}) { $self->{_instance_property} = undef; } } sub end_document { my $self = shift; foreach my $object_id (keys %{ $self->{_instances} }) { my $new_object_id = $self->{_objects_map}{$object_id}; if (!defined $new_object_id) { warn "Undefined object $object_id referenced in constellation\n"; next; } foreach my $instance (@{ $self->{_instances}{$object_id} }) { next if !defined($instance->{deltax}) || !defined($instance->{deltay}); $self->{_model}->objects->[$new_object_id]->add_instance( rotation => $instance->{rz} || 0, offset => Slic3r::Pointf->new($instance->{deltax} || 0, $instance->{deltay} || 0), ); } } } sub _get_attribute { my $self = shift; my ($data, $name) = @_; return +(map $_->{Value}, grep $_->{Name} eq $name, values %{$data->{Attributes}})[0]; } 1; Slic3r-version_1.31.6/lib/Slic3r/Format/OBJ.pm000066400000000000000000000015361301441720000206100ustar00rootroot00000000000000package Slic3r::Format::OBJ; use Moo; use File::Basename qw(basename); sub read_file { my $self = shift; my ($file) = @_; Slic3r::open(\my $fh, '<', $file) or die "Failed to open $file\n"; my $vertices = []; my $facets = []; while (<$fh>) { if (/^v ([^ ]+)\s+([^ ]+)\s+([^ ]+)/) { push @$vertices, [$1, $2, $3]; } elsif (/^f (\d+).*? (\d+).*? (\d+).*?/) { push @$facets, [ $1-1, $2-1, $3-1 ]; } } close $fh; my $mesh = Slic3r::TriangleMesh->new; $mesh->ReadFromPerl($vertices, $facets); $mesh->repair; my $model = Slic3r::Model->new; my $basename = basename($file); my $object = $model->add_object(input_file => $file, name => $basename); my $volume = $object->add_volume(mesh => $mesh, name => $basename); return $model; } 1; Slic3r-version_1.31.6/lib/Slic3r/Format/STL.pm000066400000000000000000000017141301441720000206360ustar00rootroot00000000000000package Slic3r::Format::STL; use Moo; use File::Basename qw(basename); sub read_file { my $self = shift; my ($file) = @_; my $path = Slic3r::encode_path($file); die "Failed to open $file\n" if !-e $path; my $mesh = Slic3r::TriangleMesh->new; $mesh->ReadSTLFile($path); $mesh->repair; die "This STL file couldn't be read because it's empty.\n" if $mesh->facets_count == 0; my $model = Slic3r::Model->new; my $basename = basename($file); my $object = $model->add_object(input_file => $file, name => $basename); my $volume = $object->add_volume(mesh => $mesh, name => $basename); return $model; } sub write_file { my $self = shift; my ($file, $mesh, %params) = @_; $mesh = $mesh->mesh if $mesh->isa('Slic3r::Model'); my $path = Slic3r::encode_path($file); $params{binary} ? $mesh->write_binary($path) : $mesh->write_ascii($path); } 1; Slic3r-version_1.31.6/lib/Slic3r/GCode/000077500000000000000000000000001301441720000173645ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/GCode/ArcFitting.pm000066400000000000000000000205631301441720000217620ustar00rootroot00000000000000package Slic3r::GCode::ArcFitting; use Moo; use Slic3r::Geometry qw(X Y PI scale unscale epsilon scaled_epsilon deg2rad angle3points); extends 'Slic3r::GCode::Reader'; has 'config' => (is => 'ro', required => 0); has 'min_segments' => (is => 'rw', default => sub { 2 }); has 'min_total_angle' => (is => 'rw', default => sub { deg2rad(30) }); has 'max_relative_angle' => (is => 'rw', default => sub { deg2rad(15) }); has 'len_epsilon' => (is => 'rw', default => sub { scale 0.2 }); has 'angle_epsilon' => (is => 'rw', default => sub { abs(deg2rad(10)) }); has '_extrusion_axis' => (is => 'lazy'); has '_path' => (is => 'rw'); has '_cur_F' => (is => 'rw'); has '_cur_E' => (is => 'rw'); has '_cur_E0' => (is => 'rw'); has '_comment' => (is => 'rw'); sub _build__extrusion_axis { my ($self) = @_; return $self->config ? $self->config->get_extrusion_axis : 'E'; } sub process { my $self = shift; my ($gcode) = @_; die "Arc fitting is not available (incomplete feature)\n"; die "Arc fitting doesn't support extrusion axis not being E\n" if $self->_extrusion_axis ne 'E'; my $new_gcode = ""; $self->parse($gcode, sub { my ($reader, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { # this is an extrusion segment # get segment my $line = Slic3r::Line->new( Slic3r::Point->new_scale($self->X, $self->Y), Slic3r::Point->new_scale($args->{X}, $args->{Y}), ); # get segment speed my $F = $args->{F} // $reader->F; # get extrusion per unscaled distance unit my $e = $info->{dist_E} / unscale($line->length); if ($self->_path && $F == $self->_cur_F && abs($e - $self->_cur_E) < epsilon) { # if speed and extrusion per unit are the same as the previous segments, # append this segment to path $self->_path->append($line->b); } elsif ($self->_path) { # segment can't be appended to previous path, so we flush the previous one # and start over $new_gcode .= $self->path_to_gcode; $self->_path(undef); } if (!$self->_path) { # if this is the first segment of a path, start it from scratch $self->_path(Slic3r::Polyline->new(@$line)); $self->_cur_F($F); $self->_cur_E($e); $self->_cur_E0($self->E); $self->_comment($info->{comment}); } } else { # if we have a path, we flush it and go on $new_gcode .= $self->path_to_gcode if $self->_path; $new_gcode .= $info->{raw} . "\n"; $self->_path(undef); } }); $new_gcode .= $self->path_to_gcode if $self->_path; return $new_gcode; } sub path_to_gcode { my ($self) = @_; my @chunks = $self->detect_arcs($self->_path); my $gcode = ""; my $E = $self->_cur_E0; foreach my $chunk (@chunks) { if ($chunk->isa('Slic3r::Polyline')) { my @lines = @{$chunk->lines}; $gcode .= sprintf "G1 F%s\n", $self->_cur_F; foreach my $line (@lines) { $E += $self->_cur_E * unscale($line->length); $gcode .= sprintf "G1 X%.3f Y%.3f %s%.5f", (map unscale($_), @{$line->b}), $self->_extrusion_axis, $E; $gcode .= sprintf " ; %s", $self->_comment if $self->_comment; $gcode .= "\n"; } } elsif ($chunk->isa('Slic3r::GCode::ArcFitting::Arc')) { $gcode .= !$chunk->is_ccw ? "G2" : "G3"; $gcode .= sprintf " X%.3f Y%.3f", map unscale($_), @{$chunk->end}; # destination point # XY distance of the center from the start position $gcode .= sprintf " I%.3f", unscale($chunk->center->[X] - $chunk->start->[X]); $gcode .= sprintf " J%.3f", unscale($chunk->center->[Y] - $chunk->start->[Y]); $E += $self->_cur_E * unscale($chunk->length); $gcode .= sprintf " %s%.5f", $self->_extrusion_axis, $E; $gcode .= sprintf " F%s\n", $self->_cur_F; } } return $gcode; } sub detect_arcs { my ($self, $path) = @_; my @chunks = (); my @arc_points = (); my $polyline = undef; my $arc_start = undef; my @points = @$path; for (my $i = 1; $i <= $#points; ++$i) { my $end = undef; # we need at least three points to check whether they form an arc if ($i < $#points) { my $len = $points[$i-1]->distance_to($points[$i]); my $rel_angle = PI - angle3points(@points[$i, $i-1, $i+1]); if (abs($rel_angle) <= $self->max_relative_angle) { for (my $j = $i+1; $j <= $#points; ++$j) { # check whether @points[($i-1)..$j] form an arc last if abs($points[$j-1]->distance_to($points[$j]) - $len) > $self->len_epsilon; last if abs(PI - angle3points(@points[$j-1, $j-2, $j]) - $rel_angle) > $self->angle_epsilon; $end = $j; } } } if (defined $end && ($end - $i + 1) >= $self->min_segments) { my $arc = polyline_to_arc(Slic3r::Polyline->new(@points[($i-1)..$end])); if (1||$arc->angle >= $self->min_total_angle) { push @chunks, $arc; # continue scanning after arc points $i = $end; next; } } # if last chunk was a polyline, append to it if (@chunks && $chunks[-1]->isa('Slic3r::Polyline')) { $chunks[-1]->append($points[$i]); } else { push @chunks, Slic3r::Polyline->new(@points[($i-1)..$i]); } } return @chunks; } sub polyline_to_arc { my ($polyline) = @_; my @points = @$polyline; my $is_ccw = $points[2]->ccw(@points[0,1]) > 0; # to find the center, we intersect the perpendicular lines # passing by first and last vertex; # a better method would be to draw all the perpendicular lines # and find the centroid of the enclosed polygon, or to # intersect multiple lines and find the centroid of the convex hull # around the intersections my $arc_center; { my $first_ray = Slic3r::Line->new(@points[0,1]); $first_ray->rotate(PI/2 * ($is_ccw ? 1 : -1), $points[0]); my $last_ray = Slic3r::Line->new(@points[-2,-1]); $last_ray->rotate(PI/2 * ($is_ccw ? -1 : 1), $points[-1]); # require non-parallel rays in order to compute an accurate center return if abs($first_ray->atan2_ - $last_ray->atan2_) < deg2rad(30); $arc_center = $first_ray->intersection($last_ray, 0) or return; } # angle measured in ccw orientation my $abs_angle = Slic3r::Geometry::angle3points($arc_center, @points[0,-1]); my $rel_angle = $is_ccw ? $abs_angle : (2*PI - $abs_angle); my $arc = Slic3r::GCode::ArcFitting::Arc->new( start => $points[0]->clone, end => $points[-1]->clone, center => $arc_center, is_ccw => $is_ccw || 0, angle => $rel_angle, ); if (0) { printf "points = %d, path length = %f, arc angle = %f, arc length = %f\n", scalar(@points), unscale(Slic3r::Polyline->new(@points)->length), Slic3r::Geometry::rad2deg($rel_angle), unscale($arc->length); } return $arc; } package Slic3r::GCode::ArcFitting::Arc; use Moo; has 'start' => (is => 'ro', required => 1); has 'end' => (is => 'ro', required => 1); has 'center' => (is => 'ro', required => 1); has 'is_ccw' => (is => 'ro', required => 1); has 'angle' => (is => 'ro', required => 1); sub radius { my ($self) = @_; return $self->start->distance_to($self->center); } sub length { my ($self) = @_; return $self->radius * $self->angle; } 1; Slic3r-version_1.31.6/lib/Slic3r/GCode/CoolingBuffer.pm000066400000000000000000000105011301441720000224430ustar00rootroot00000000000000# A standalone (no C++ implementation) G-code filter, to control cooling of the print. # The G-code is processed per layer. Once a layer is collected, fan start / stop commands are edited # and the print is modified to stretch over a minimum layer time. package Slic3r::GCode::CoolingBuffer; use Moo; has 'config' => (is => 'ro', required => 1); # Slic3r::Config::Print has 'gcodegen' => (is => 'ro', required => 1); # Slic3r::GCode C++ instance has 'gcode' => (is => 'rw', default => sub {""}); # Cache of a G-code snippet emitted for a single layer. has 'elapsed_time' => (is => 'rw', default => sub {0}); has 'layer_id' => (is => 'rw'); has 'last_z' => (is => 'rw', default => sub { {} }); # obj_id => z (basically a 'last seen' table) has 'min_print_speed' => (is => 'lazy'); sub _build_min_print_speed { my $self = shift; return 60 * $self->config->min_print_speed; } sub append { my $self = shift; my ($gcode, $obj_id, $layer_id, $print_z) = @_; my $return = ""; if (exists $self->last_z->{$obj_id} && $self->last_z->{$obj_id} != $print_z) { # A layer was finished, Z of the object's layer changed. Process the layer. $return = $self->flush; } $self->layer_id($layer_id); $self->last_z->{$obj_id} = $print_z; $self->gcode($self->gcode . $gcode); #FIXME Vojtech: This is a very rough estimate of the print time, # not taking into account the acceleration profiles generated by the printer firmware. $self->elapsed_time($self->elapsed_time + $self->gcodegen->elapsed_time); $self->gcodegen->set_elapsed_time(0); return $return; } sub flush { my $self = shift; my $gcode = $self->gcode; my $elapsed = $self->elapsed_time; $self->gcode(""); $self->elapsed_time(0); $self->last_z({}); # reset the whole table otherwise we would compute overlapping times my $fan_speed = $self->config->fan_always_on ? $self->config->min_fan_speed : 0; my $speed_factor = 1; if ($self->config->cooling) { Slic3r::debugf "Layer %d estimated printing time: %d seconds\n", $self->layer_id, $elapsed; if ($elapsed < $self->config->slowdown_below_layer_time) { # Layer time very short. Enable the fan to a full throttle and slow down the print # (stretch the layer print time to slowdown_below_layer_time). $fan_speed = $self->config->max_fan_speed; $speed_factor = $elapsed / $self->config->slowdown_below_layer_time; } elsif ($elapsed < $self->config->fan_below_layer_time) { # Layer time quite short. Enable the fan proportionally according to the current layer time. $fan_speed = $self->config->max_fan_speed - ($self->config->max_fan_speed - $self->config->min_fan_speed) * ($elapsed - $self->config->slowdown_below_layer_time) / ($self->config->fan_below_layer_time - $self->config->slowdown_below_layer_time); #/ } Slic3r::debugf " fan = %d%%, speed = %d%%\n", $fan_speed, $speed_factor * 100; if ($speed_factor < 1) { # Adjust feed rate of G1 commands marked with an _EXTRUDE_SET_SPEED # as long as they are not _WIPE moves (they cannot if they are _EXTRUDE_SET_SPEED) # and they are not preceded directly by _BRIDGE_FAN_START (do not adjust bridging speed). $gcode =~ s/^(?=.*?;_EXTRUDE_SET_SPEED)(?!.*?;_WIPE)(?min_print_speed ? $self->min_print_speed : $new_speed) /gexm; } } $fan_speed = 0 if $self->layer_id < $self->config->disable_fan_first_layers; $gcode = $self->gcodegen->writer->set_fan($fan_speed) . $gcode; # bridge fan speed if (!$self->config->cooling || $self->config->bridge_fan_speed == 0 || $self->layer_id < $self->config->disable_fan_first_layers) { $gcode =~ s/^;_BRIDGE_FAN_(?:START|END)\n//gm; } else { $gcode =~ s/^;_BRIDGE_FAN_START\n/ $self->gcodegen->writer->set_fan($self->config->bridge_fan_speed, 1) /gmex; $gcode =~ s/^;_BRIDGE_FAN_END\n/ $self->gcodegen->writer->set_fan($fan_speed, 1) /gmex; } $gcode =~ s/;_WIPE//g; $gcode =~ s/;_EXTRUDE_SET_SPEED//g; return $gcode; } 1; Slic3r-version_1.31.6/lib/Slic3r/GCode/MotionPlanner.pm000066400000000000000000000253331301441720000225150ustar00rootroot00000000000000package Slic3r::GCode::MotionPlanner; use Moo; has 'islands' => (is => 'ro', required => 1); # arrayref of ExPolygons has 'internal' => (is => 'ro', default => sub { 1 }); has '_space' => (is => 'ro', default => sub { Slic3r::GCode::MotionPlanner::ConfigurationSpace->new }); has '_inner' => (is => 'ro', default => sub { [] }); # arrayref of ExPolygons use List::Util qw(first max); use Slic3r::Geometry qw(A B scale epsilon); use Slic3r::Geometry::Clipper qw(offset offset_ex diff_ex intersection_pl); # clearance (in mm) from the perimeters has '_inner_margin' => (is => 'ro', default => sub { scale 1 }); has '_outer_margin' => (is => 'ro', default => sub { scale 2 }); # this factor weigths the crossing of a perimeter # vs. the alternative path. a value of 5 means that # a perimeter will be crossed if the alternative path # is >= 5x the length of the straight line we could # follow if we decided to cross the perimeter. # a nearly-infinite value for this will only permit # perimeter crossing when there's no alternative path. use constant CROSSING_PENALTY => 20; use constant POINT_DISTANCE => 10; # unscaled # setup our configuration space sub BUILD { my $self = shift; my $point_distance = scale POINT_DISTANCE; my $nodes = $self->_space->nodes; my $edges = $self->_space->edges; # process individual islands for my $i (0 .. $#{$self->islands}) { my $expolygon = $self->islands->[$i]; # find external margin my $outer = offset([ @$expolygon ], +$self->_outer_margin); my @outer_points = map @{$_->equally_spaced_points($point_distance)}, @$outer; # add outer points to graph my $o_outer = $self->_space->add_nodes(@outer_points); # find pairs of visible outer points and add them to the graph for my $i (0 .. $#outer_points) { for my $j (($i+1) .. $#outer_points) { my ($a, $b) = ($outer_points[$i], $outer_points[$j]); my $line = Slic3r::Polyline->new($a, $b); # outer points are visible when their line has empty intersection with islands my $intersection = intersection_pl( [ $line ], [ map @$_, @{$self->islands} ], ); if (!@$intersection) { $self->_space->add_edge($i+$o_outer, $j+$o_outer, $line->length); } } } if ($self->internal) { # find internal margin my $inner = offset_ex([ @$expolygon ], -$self->_inner_margin); push @{ $self->_inner }, @$inner; my @inner_points = map @{$_->equally_spaced_points($point_distance)}, map @$_, @$inner; # add points to graph and get their offset my $o_inner = $self->_space->add_nodes(@inner_points); # find pairs of visible inner points and add them to the graph for my $i (0 .. $#inner_points) { for my $j (($i+1) .. $#inner_points) { my ($a, $b) = ($inner_points[$i], $inner_points[$j]); my $line = Slic3r::Line->new($a, $b); # turn $inner into an ExPolygonCollection and use $inner->contains_line() if (first { $_->contains_line($line) } @$inner) { $self->_space->add_edge($i+$o_inner, $j+$o_inner, $line->length); } } } # generate the stripe around slice contours my $contour = diff_ex( $outer, [ map @$_, @$inner ], ); # find pairs of visible points in this area and add them to the graph for my $i (0 .. $#inner_points) { for my $j (0 .. $#outer_points) { my ($a, $b) = ($inner_points[$i], $outer_points[$j]); my $line = Slic3r::Line->new($a, $b); # turn $contour into an ExPolygonCollection and use $contour->contains_line() if (first { $_->contains_line($line) } @$contour) { $self->_space->add_edge($i+$o_inner, $j+$o_outer, $line->length * CROSSING_PENALTY); } } } } } # since Perl has no infinity symbol and we don't want to overcomplicate # the Dijkstra algorithm with string constants or -1 values $self->_space->_infinity(10 * (max(map values %$_, values %{$self->_space->edges}) // 0)); if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("space.svg", no_arrows => 1, expolygons => $self->islands, lines => $self->_space->get_lines, points => $self->_space->nodes, ); printf "%d islands\n", scalar @{$self->islands}; eval "use Devel::Size"; print "MEMORY USAGE:\n"; printf " %-19s = %.1fMb\n", $_, Devel::Size::total_size($self->$_)/1024/1024 for qw(_space islands); printf " %-19s = %.1fMb\n", $_, Devel::Size::total_size($self->_space->$_)/1024/1024 for qw(nodes edges); printf " %-19s = %.1fMb\n", 'self', Devel::Size::total_size($self)/1024/1024; exit if $self->internal; } } sub shortest_path { my $self = shift; my ($from, $to) = @_; return Slic3r::Polyline->new($from, $to) if !@{$self->_space->nodes}; # create a temporary configuration space my $space = $self->_space->clone; # add from/to points to the temporary configuration space my $node_from = $self->_add_point_to_space($from, $space); my $node_to = $self->_add_point_to_space($to, $space); # compute shortest path my $path = $space->shortest_path($node_from, $node_to); if (!$path->is_valid) { Slic3r::debugf "Failed to compute shortest path.\n"; return Slic3r::Polyline->new($from, $to); } if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("path.svg", no_arrows => 1, expolygons => $self->islands, lines => $space->get_lines, red_points => [$from, $to], red_polylines => [$path], ); exit; } return $path; } # returns the index of the new node sub _add_point_to_space { my ($self, $point, $space) = @_; my $n = $space->add_nodes($point); # check whether we are inside an island or outside my $inside = defined first { $self->islands->[$_]->contains_point($point) } 0..$#{$self->islands}; # find candidates by checking visibility from $from to them foreach my $idx (0..$#{$space->nodes}) { my $line = Slic3r::Line->new($point, $space->nodes->[$idx]); # if $point is inside an island, it is visible from $idx when island contains their line # if $point is outside an island, it is visible from $idx when their line does not cross any island if ( ($inside && defined first { $_->contains_line($line) } @{$self->_inner}) || (!$inside && !@{intersection_pl( [ $line->as_polyline ], [ map @$_, @{$self->islands} ], )}) ) { # $n ($point) and $idx are visible $space->add_edge($n, $idx, $line->length); } } # if we found no visibility, retry with larger margins if (!exists $space->edges->{$n} && $inside) { foreach my $idx (0..$#{$space->nodes}) { my $line = Slic3r::Line->new($point, $space->nodes->[$idx]); if (defined first { $_->contains_line($line) } @{$self->islands}) { # $n ($point) and $idx are visible $space->add_edge($n, $idx, $line->length); } } } warn "Temporary node is not visible from any other node" if !exists $space->edges->{$n}; return $n; } package Slic3r::GCode::MotionPlanner::ConfigurationSpace; use Moo; has 'nodes' => (is => 'rw', default => sub { [] }); # [ Point, ... ] has 'edges' => (is => 'rw', default => sub { {} }); # node_idx => { node_idx => distance, ... } has '_infinity' => (is => 'rw'); sub clone { my $self = shift; return (ref $self)->new( nodes => [ map $_->clone, @{$self->nodes} ], edges => { map { $_ => { %{$self->edges->{$_}} } } keys %{$self->edges} }, _infinity => $self->_infinity, ); } sub nodes_count { my $self = shift; return scalar(@{ $self->nodes }); } sub add_nodes { my ($self, @nodes) = @_; my $offset = $self->nodes_count; push @{ $self->nodes }, @nodes; return $offset; } sub add_edge { my ($self, $a, $b, $dist) = @_; $self->edges->{$a}{$b} = $self->edges->{$b}{$a} = $dist; } sub shortest_path { my ($self, $node_from, $node_to) = @_; my $edges = $self->edges; my (%dist, %visited, %prev); $dist{$_} = $self->_infinity for keys %$edges; $dist{$node_from} = 0; my @queue = ($node_from); while (@queue) { my $u = -1; { # find node in @queue with smallest distance in %dist and has not been visited my $d = -1; foreach my $n (@queue) { next if $visited{$n}; if ($u == -1 || $dist{$n} < $d) { $u = $n; $d = $dist{$n}; } } } last if $u == $node_to; # remove $u from @queue @queue = grep $_ != $u, @queue; $visited{$u} = 1; # loop through neighbors of $u foreach my $v (keys %{ $edges->{$u} }) { my $alt = $dist{$u} + $edges->{$u}{$v}; if ($alt < $dist{$v}) { $dist{$v} = $alt; $prev{$v} = $u; if (!$visited{$v}) { push @queue, $v; } } } } my @points = (); { my $u = $node_to; while (exists $prev{$u}) { unshift @points, $self->nodes->[$u]; $u = $prev{$u}; } unshift @points, $self->nodes->[$node_from]; } return Slic3r::Polyline->new(@points); } # for debugging purposes sub get_lines { my $self = shift; my @lines = (); my %lines = (); for my $i (keys %{$self->edges}) { for my $j (keys %{$self->edges->{$i}}) { my $line_id = join '_', sort $i, $j; next if $lines{$line_id}; $lines{$line_id} = 1; push @lines, Slic3r::Line->new(map $self->nodes->[$_], $i, $j); } } return [@lines]; } 1; Slic3r-version_1.31.6/lib/Slic3r/GCode/PressureRegulator.pm000066400000000000000000000071541301441720000234260ustar00rootroot00000000000000# A pure perl (no C++ implementation) G-code filter, to control the pressure inside the nozzle. package Slic3r::GCode::PressureRegulator; use Moo; has 'config' => (is => 'ro', required => 1); has 'enable' => (is => 'rw', default => sub { 0 }); has 'reader' => (is => 'ro', default => sub { Slic3r::GCode::Reader->new }); has '_extrusion_axis' => (is => 'rw', default => sub { "E" }); has '_tool' => (is => 'rw', default => sub { 0 }); has '_last_print_F' => (is => 'rw', default => sub { 0 }); has '_advance' => (is => 'rw', default => sub { 0 }); # extra E injected use Slic3r::Geometry qw(epsilon); # Acknowledgements: # The advance algorithm was proposed by Matthew Roberts. # The initial work on this Slic3r feature was done by Luís Andrade (lluis) sub BUILD { my ($self) = @_; $self->reader->apply_print_config($self->config); $self->_extrusion_axis($self->config->get_extrusion_axis); } sub process { my $self = shift; my ($gcode, $flush) = @_; my $new_gcode = ""; $self->reader->parse($gcode, sub { my ($reader, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $self->_tool($1); } elsif ($info->{extruding} && $info->{dist_XY} > 0) { # This is a print move. my $F = $args->{F} // $reader->F; if ($F != $self->_last_print_F) { # We are setting a (potentially) new speed, so we calculate the new advance amount. # First calculate relative flow rate (mm of filament over mm of travel) my $rel_flow_rate = $info->{dist_E} / $info->{dist_XY}; # Then calculate absolute flow rate (mm/sec of feedstock) my $flow_rate = $rel_flow_rate * $F / 60; # And finally calculate advance by using the user-configured K factor. my $new_advance = $self->config->pressure_advance * ($flow_rate**2); if (abs($new_advance - $self->_advance) > 1E-5) { my $new_E = ($self->config->use_relative_e_distances ? 0 : $reader->E) + ($new_advance - $self->_advance); $new_gcode .= sprintf "G1 %s%.5f F%.3f ; pressure advance\n", $self->_extrusion_axis, $new_E, $self->_unretract_speed; $new_gcode .= sprintf "G92 %s%.5f ; restore E\n", $self->_extrusion_axis, $reader->E if !$self->config->use_relative_e_distances; $self->_advance($new_advance); } $self->_last_print_F($F); } } elsif (($info->{retracting} || $cmd eq 'G10') && $self->_advance != 0) { # We need to bring pressure to zero when retracting. $new_gcode .= $self->_discharge($args->{F}); } $new_gcode .= "$info->{raw}\n"; }); if ($flush) { $new_gcode .= $self->_discharge; } return $new_gcode; } sub _discharge { my ($self, $F) = @_; my $new_E = ($self->config->use_relative_e_distances ? 0 : $self->reader->E) - $self->_advance; my $gcode = sprintf "G1 %s%.5f F%.3f ; pressure discharge\n", $self->_extrusion_axis, $new_E, $F // $self->_unretract_speed; $gcode .= sprintf "G92 %s%.5f ; restore E\n", $self->_extrusion_axis, $self->reader->E if !$self->config->use_relative_e_distances; $self->_advance(0); return $gcode; } sub _unretract_speed { my ($self) = @_; return $self->config->get_at('retract_speed', $self->_tool) * 60; } 1; Slic3r-version_1.31.6/lib/Slic3r/GCode/Reader.pm000066400000000000000000000052001301441720000211210ustar00rootroot00000000000000package Slic3r::GCode::Reader; use Moo; has 'config' => (is => 'ro', default => sub { Slic3r::Config::GCode->new }); has 'X' => (is => 'rw', default => sub {0}); has 'Y' => (is => 'rw', default => sub {0}); has 'Z' => (is => 'rw', default => sub {0}); has 'E' => (is => 'rw', default => sub {0}); has 'F' => (is => 'rw', default => sub {0}); has '_extrusion_axis' => (is => 'rw', default => sub {"E"}); our $Verbose = 0; my @AXES = qw(X Y Z E); sub apply_print_config { my ($self, $print_config) = @_; $self->config->apply_static($print_config); $self->_extrusion_axis($self->config->get_extrusion_axis); } sub clone { my $self = shift; return (ref $self)->new( map { $_ => $self->$_ } (@AXES, 'F', '_extrusion_axis', 'config'), ); } sub parse { my $self = shift; my ($gcode, $cb) = @_; foreach my $raw_line (split /\R+/, $gcode) { print "$raw_line\n" if $Verbose || $ENV{SLIC3R_TESTS_GCODE}; my $line = $raw_line; $line =~ s/\s*;(.*)//; # strip comment my %info = (comment => $1, raw => $raw_line); # parse command my ($command, @args) = split /\s+/, $line; $command //= ''; my %args = map { /([A-Z])(.*)/; ($1 => $2) } @args; # convert extrusion axis if (exists $args{ $self->_extrusion_axis }) { $args{E} = $args{ $self->_extrusion_axis }; } # check motion if ($command =~ /^G[01]$/) { foreach my $axis (@AXES) { if (exists $args{$axis}) { $self->$axis(0) if $axis eq 'E' && $self->config->use_relative_e_distances; $info{"dist_$axis"} = $args{$axis} - $self->$axis; $info{"new_$axis"} = $args{$axis}; } else { $info{"dist_$axis"} = 0; $info{"new_$axis"} = $self->$axis; } } $info{dist_XY} = sqrt(($info{dist_X}**2) + ($info{dist_Y}**2)); if (exists $args{E}) { if ($info{dist_E} > 0) { $info{extruding} = 1; } elsif ($info{dist_E} < 0) { $info{retracting} = 1 } } else { $info{travel} = 1; } } # run callback $cb->($self, $command, \%args, \%info); # update coordinates if ($command =~ /^(?:G[01]|G92)$/) { for my $axis (@AXES, 'F') { $self->$axis($args{$axis}) if exists $args{$axis}; } } # TODO: update temperatures } } 1; Slic3r-version_1.31.6/lib/Slic3r/GCode/SpiralVase.pm000066400000000000000000000057471301441720000220100ustar00rootroot00000000000000package Slic3r::GCode::SpiralVase; use Moo; has 'config' => (is => 'ro', required => 1); has 'enable' => (is => 'rw', default => sub { 0 }); has 'reader' => (is => 'ro', default => sub { Slic3r::GCode::Reader->new }); use Slic3r::Geometry qw(unscale); sub BUILD { my ($self) = @_; $self->reader->apply_print_config($self->config); } sub process_layer { my $self = shift; my ($gcode) = @_; # This post-processor relies on several assumptions: # - all layers are processed through it, including those that are not supposed # to be transformed, in order to update the reader with the XY positions # - each call to this method includes a full layer, with a single Z move # at the beginning # - each layer is composed by suitable geometry (i.e. a single complete loop) # - loops were not clipped before calling this method # if we're not going to modify G-code, just feed it to the reader # in order to update positions if (!$self->enable) { $self->reader->parse($gcode, sub {}); return $gcode; } # get total XY length for this layer by summing all extrusion moves my $total_layer_length = 0; my $layer_height = 0; my $z = undef; $self->reader->clone->parse($gcode, sub { my ($reader, $cmd, $args, $info) = @_; if ($cmd eq 'G1') { if ($info->{extruding}) { $total_layer_length += $info->{dist_XY}; } elsif (exists $args->{Z}) { $layer_height += $info->{dist_Z}; $z //= $args->{Z}; } } }); #use XXX; XXX [ $gcode, $layer_height, $z, $total_layer_length ]; # remove layer height from initial Z $z -= $layer_height; my $new_gcode = ""; $self->reader->parse($gcode, sub { my ($reader, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && exists $args->{Z}) { # if this is the initial Z move of the layer, replace it with a # (redundant) move to the last Z of previous layer my $line = $info->{raw}; $line =~ s/ Z[.0-9]+/ Z$z/; $new_gcode .= "$line\n"; } elsif ($cmd eq 'G1' && !exists($args->{Z}) && $info->{dist_XY}) { # horizontal move my $line = $info->{raw}; if ($info->{extruding}) { $z += $info->{dist_XY} * $layer_height / $total_layer_length; $line =~ s/^G1 /sprintf 'G1 Z%.3f ', $z/e; $new_gcode .= "$line\n"; } # skip travel moves: the move to first perimeter point will # cause a visible seam when loops are not aligned in XY; by skipping # it we blend the first loop move in the XY plane (although the smoothness # of such blend depend on how long the first segment is; maybe we should # enforce some minimum length?) } else { $new_gcode .= "$info->{raw}\n"; } }); return $new_gcode; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI.pm000066400000000000000000000325571301441720000174010ustar00rootroot00000000000000package Slic3r::GUI; use strict; use warnings; use utf8; use File::Basename qw(basename); use FindBin; use List::Util qw(first); use Slic3r::GUI::2DBed; use Slic3r::GUI::AboutDialog; use Slic3r::GUI::BedShapeDialog; use Slic3r::GUI::BonjourBrowser; use Slic3r::GUI::ConfigWizard; use Slic3r::GUI::Controller; use Slic3r::GUI::Controller::ManualControlDialog; use Slic3r::GUI::Controller::PrinterPanel; use Slic3r::GUI::MainFrame; use Slic3r::GUI::Notifier; use Slic3r::GUI::Plater; use Slic3r::GUI::Plater::2D; use Slic3r::GUI::Plater::2DToolpaths; use Slic3r::GUI::Plater::3D; use Slic3r::GUI::Plater::3DPreview; use Slic3r::GUI::Plater::ObjectPartsPanel; use Slic3r::GUI::Plater::ObjectCutDialog; use Slic3r::GUI::Plater::ObjectSettingsDialog; use Slic3r::GUI::Plater::OverrideSettingsPanel; use Slic3r::GUI::Preferences; use Slic3r::GUI::ProgressStatusBar; use Slic3r::GUI::Projector; use Slic3r::GUI::OptionsGroup; use Slic3r::GUI::OptionsGroup::Field; use Slic3r::GUI::SimpleTab; use Slic3r::GUI::Tab; our $have_OpenGL = eval "use Slic3r::GUI::3DScene; 1"; our $have_LWP = eval "use LWP::UserAgent; 1"; use Wx 0.9901 qw(:bitmap :dialog :icon :id :misc :systemsettings :toplevelwindow :filedialog :font); use Wx::Event qw(EVT_IDLE EVT_COMMAND); use base 'Wx::App'; use constant FILE_WILDCARDS => { known => 'Known files (*.stl, *.obj, *.amf, *.xml)|*.stl;*.STL;*.obj;*.OBJ;*.amf;*.AMF;*.xml;*.XML', stl => 'STL files (*.stl)|*.stl;*.STL', obj => 'OBJ files (*.obj)|*.obj;*.OBJ', amf => 'AMF files (*.amf)|*.amf;*.AMF;*.xml;*.XML', ini => 'INI files *.ini|*.ini;*.INI', gcode => 'G-code files (*.gcode, *.gco, *.g, *.ngc)|*.gcode;*.GCODE;*.gco;*.GCO;*.g;*.G;*.ngc;*.NGC', svg => 'SVG files *.svg|*.svg;*.SVG', }; use constant MODEL_WILDCARD => join '|', @{&FILE_WILDCARDS}{qw(known stl obj amf)}; our $datadir; # If set, the "Controller" tab for the control of the printer over serial line and the serial port settings are hidden. our $no_controller; our $no_plater; our $mode; our $autosave; our @cb; our $Settings = { _ => { mode => 'simple', version_check => 1, autocenter => 1, background_processing => 1, # If set, the "Controller" tab for the control of the printer over serial line and the serial port settings are hidden. # By default, Prusa has the controller hidden. no_controller => 1, # If set, the "- default -" selections of print/filament/printer are suppressed, if there is a valid preset available. no_defaults => 1, }, }; our $have_button_icons = &Wx::wxVERSION_STRING =~ m" (?:2\.9\.[1-9]|3\.)"; our $small_font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $small_font->SetPointSize(11) if !&Wx::wxMSW; our $small_bold_font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $small_bold_font->SetPointSize(11) if !&Wx::wxMSW; $small_bold_font->SetWeight(wxFONTWEIGHT_BOLD); our $medium_font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $medium_font->SetPointSize(12); our $grey = Wx::Colour->new(200,200,200); our $VERSION_CHECK_EVENT : shared = Wx::NewEventType; our $DLP_projection_screen; sub OnInit { my ($self) = @_; $self->SetAppName('Slic3r'); $self->SetAppDisplayName('Slic3r Prusa Edition') if (Wx::wxVERSION >= 3.000000); Slic3r::debugf "wxWidgets version %s, Wx version %s\n", &Wx::wxVERSION_STRING, $Wx::VERSION; $self->{notifier} = Slic3r::GUI::Notifier->new; # locate or create data directory # Unix: ~/.Slic3r # Windows: "C:\Users\username\AppData\Roaming\Slic3r" or "C:\Documents and Settings\username\Application Data\Slic3r" # Mac: "~/Library/Application Support/Slic3r" $datadir ||= Slic3r::decode_path(Wx::StandardPaths::Get->GetUserDataDir); my $enc_datadir = Slic3r::encode_path($datadir); Slic3r::debugf "Data directory: %s\n", $datadir; # just checking for existence of $datadir is not enough: it may be an empty directory # supplied as argument to --datadir; in that case we should still run the wizard my $run_wizard = (-d $enc_datadir && -e "$enc_datadir/slic3r.ini") ? 0 : 1; foreach my $dir ($enc_datadir, "$enc_datadir/print", "$enc_datadir/filament", "$enc_datadir/printer") { next if -d $dir; if (!mkdir $dir) { my $error = "Slic3r was unable to create its data directory at $dir ($!)."; warn "$error\n"; fatal_error(undef, $error); } } # load settings my $last_version; if (-f "$enc_datadir/slic3r.ini") { my $ini = eval { Slic3r::Config->read_ini("$datadir/slic3r.ini") }; $Settings = $ini if $ini; $last_version = $Settings->{_}{version}; $Settings->{_}{mode} ||= 'expert'; $Settings->{_}{autocenter} //= 1; $Settings->{_}{background_processing} //= 1; # If set, the "Controller" tab for the control of the printer over serial line and the serial port settings are hidden. $Settings->{_}{no_controller} //= 1; # If set, the "- default -" selections of print/filament/printer are suppressed, if there is a valid preset available. $Settings->{_}{no_defaults} //= 1; } $Settings->{_}{version} = $Slic3r::VERSION; $self->save_settings; # application frame Wx::Image::AddHandler(Wx::PNGHandler->new); $self->{mainframe} = my $frame = Slic3r::GUI::MainFrame->new( mode => $mode // $Settings->{_}{mode}, # If set, the "Controller" tab for the control of the printer over serial line and the serial port settings are hidden. no_controller => $no_controller // $Settings->{_}{no_controller}, no_plater => $no_plater, ); $self->SetTopWindow($frame); # load init bundle { my @dirs = ($FindBin::Bin); if (&Wx::wxMAC) { push @dirs, qw(); } elsif (&Wx::wxMSW) { push @dirs, qw(); } my $init_bundle = first { -e $_ } map "$_/.init_bundle.ini", @dirs; if ($init_bundle) { Slic3r::debugf "Loading config bundle from %s\n", $init_bundle; $self->{mainframe}->load_configbundle($init_bundle, 1); $run_wizard = 0; } } if (!$run_wizard && (!defined $last_version || $last_version ne $Slic3r::VERSION)) { # user was running another Slic3r version on this computer if (!defined $last_version || $last_version =~ /^0\./) { show_info($self->{mainframe}, "Hello! Support material was improved since the " . "last version of Slic3r you used. It is strongly recommended to revert " . "your support material settings to the factory defaults and start from " . "those. Enjoy and provide feedback!", "Support Material"); } if (!defined $last_version || $last_version =~ /^(?:0|1\.[01])\./) { show_info($self->{mainframe}, "Hello! In this version a new Bed Shape option was " . "added. If the bed coordinates in the plater preview screen look wrong, go " . "to Print Settings and click the \"Set\" button next to \"Bed Shape\".", "Bed Shape"); } } $self->{mainframe}->config_wizard if $run_wizard; $self->check_version if $self->have_version_check && ($Settings->{_}{version_check} // 1) && (!$Settings->{_}{last_version_check} || (time - $Settings->{_}{last_version_check}) >= 86400); EVT_IDLE($frame, sub { while (my $cb = shift @cb) { $cb->(); } }); EVT_COMMAND($self, -1, $VERSION_CHECK_EVENT, sub { my ($self, $event) = @_; my ($success, $response, $manual_check) = @{$event->GetData}; if ($success) { if ($response =~ /^obsolete ?= ?([a-z0-9.-]+,)*\Q$Slic3r::VERSION\E(?:,|$)/) { my $res = Wx::MessageDialog->new(undef, "A new version is available. Do you want to open the Slic3r website now?", 'Update', wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxICON_INFORMATION | wxICON_ERROR)->ShowModal; Wx::LaunchDefaultBrowser('http://slic3r.org/') if $res == wxID_YES; } else { Slic3r::GUI::show_info(undef, "You're using the latest version. No updates are available.") if $manual_check; } $Settings->{_}{last_version_check} = time(); $self->save_settings; } else { Slic3r::GUI::show_error(undef, "Failed to check for updates. Try later.") if $manual_check; } }); return 1; } sub about { my ($self) = @_; my $about = Slic3r::GUI::AboutDialog->new(undef); $about->ShowModal; $about->Destroy; } # static method accepting a wxWindow object as first parameter sub catch_error { my ($self, $cb, $message_dialog) = @_; if (my $err = $@) { $cb->() if $cb; $message_dialog ? $message_dialog->($err, 'Error', wxOK | wxICON_ERROR) : Slic3r::GUI::show_error($self, $err); return 1; } return 0; } # static method accepting a wxWindow object as first parameter sub show_error { my ($parent, $message) = @_; Wx::MessageDialog->new($parent, $message, 'Error', wxOK | wxICON_ERROR)->ShowModal; } # static method accepting a wxWindow object as first parameter sub show_info { my ($parent, $message, $title) = @_; Wx::MessageDialog->new($parent, $message, $title || 'Notice', wxOK | wxICON_INFORMATION)->ShowModal; } # static method accepting a wxWindow object as first parameter sub fatal_error { show_error(@_); exit 1; } # static method accepting a wxWindow object as first parameter sub warning_catcher { my ($self, $message_dialog) = @_; return sub { my $message = shift; return if $message =~ /GLUquadricObjPtr|Attempt to free unreferenced scalar/; my @params = ($message, 'Warning', wxOK | wxICON_WARNING); $message_dialog ? $message_dialog->(@params) : Wx::MessageDialog->new($self, @params)->ShowModal; }; } sub notify { my ($self, $message) = @_; my $frame = $self->GetTopWindow; # try harder to attract user attention on OS X $frame->RequestUserAttention(&Wx::wxMAC ? wxUSER_ATTENTION_ERROR : wxUSER_ATTENTION_INFO) unless ($frame->IsActive); $self->{notifier}->notify($message); } sub save_settings { my ($self) = @_; Slic3r::Config->write_ini("$datadir/slic3r.ini", $Settings); } # Called after the Preferences dialog is closed and the program settings are saved. # Update the UI based on the current preferences. sub update_ui_from_settings { my ($self) = @_; $self->{mainframe}->update_ui_from_settings; } sub presets { my ($self, $section) = @_; my %presets = (); opendir my $dh, Slic3r::encode_path("$Slic3r::GUI::datadir/$section") or die "Failed to read directory $Slic3r::GUI::datadir/$section (errno: $!)\n"; foreach my $file (grep /\.ini$/i, readdir $dh) { $file = Slic3r::decode_path($file); my $name = basename($file); $name =~ s/\.ini$//; $presets{$name} = "$Slic3r::GUI::datadir/$section/$file"; } closedir $dh; return %presets; } sub have_version_check { my ($self) = @_; # return an explicit 0 return ($Slic3r::have_threads && $Slic3r::build && $have_LWP) || 0; } sub check_version { my ($self, $manual_check) = @_; Slic3r::debugf "Checking for updates...\n"; @_ = (); threads->create(sub { my $ua = LWP::UserAgent->new; $ua->timeout(10); my $response = $ua->get('http://slic3r.org/updatecheck'); Wx::PostEvent($self, Wx::PlThreadEvent->new(-1, $VERSION_CHECK_EVENT, threads::shared::shared_clone([ $response->is_success, $response->decoded_content, $manual_check ]))); Slic3r::thread_cleanup(); })->detach; } sub output_path { my ($self, $dir) = @_; return ($Settings->{_}{last_output_path} && $Settings->{_}{remember_output_path}) ? $Settings->{_}{last_output_path} : $dir; } sub open_model { my ($self, $window) = @_; my $dir = $Slic3r::GUI::Settings->{recent}{skein_directory} || $Slic3r::GUI::Settings->{recent}{config_directory} || ''; my $dialog = Wx::FileDialog->new($window // $self->GetTopWindow, 'Choose one or more files (STL/OBJ/AMF):', $dir, "", MODEL_WILDCARD, wxFD_OPEN | wxFD_MULTIPLE | wxFD_FILE_MUST_EXIST); if ($dialog->ShowModal != wxID_OK) { $dialog->Destroy; return; } my @input_files = map Slic3r::decode_path($_), $dialog->GetPaths; $dialog->Destroy; return @input_files; } sub CallAfter { my ($self, $cb) = @_; push @cb, $cb; } sub scan_serial_ports { my ($self) = @_; my @ports = (); if ($^O eq 'MSWin32') { # Windows if (eval "use Win32::TieRegistry; 1") { my $ts = Win32::TieRegistry->new("HKEY_LOCAL_MACHINE\\HARDWARE\\DEVICEMAP\\SERIALCOMM", { Access => 'KEY_READ' }); if ($ts) { # when no serial ports are available, the registry key doesn't exist and # TieRegistry->new returns undef $ts->Tie(\my %reg); push @ports, sort values %reg; } } } else { # UNIX and OS X push @ports, glob '/dev/{ttyUSB,ttyACM,tty.,cu.,rfcomm}*'; } return grep !/Bluetooth|FireFly/, @ports; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/000077500000000000000000000000001301441720000170275ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/GUI/2DBed.pm000066400000000000000000000166521301441720000202570ustar00rootroot00000000000000# Bed shape dialog package Slic3r::GUI::2DBed; use strict; use warnings; use List::Util qw(min max); use Slic3r::Geometry qw(PI X Y unscale deg2rad); use Slic3r::Geometry::Clipper qw(intersection_pl); use Wx qw(:misc :pen :brush :font :systemsettings wxTAB_TRAVERSAL wxSOLID); use Wx::Event qw(EVT_PAINT EVT_ERASE_BACKGROUND EVT_MOUSE_EVENTS EVT_SIZE); use base qw(Wx::Panel Class::Accessor); __PACKAGE__->mk_accessors(qw(bed_shape interactive pos _scale_factor _shift on_move _painted)); sub new { my ($class, $parent, $bed_shape) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, [250,-1], wxTAB_TRAVERSAL); $self->{user_drawn_background} = $^O ne 'darwin'; $self->bed_shape($bed_shape // []); EVT_PAINT($self, \&_repaint); EVT_ERASE_BACKGROUND($self, sub {}) if $self->{user_drawn_background}; EVT_MOUSE_EVENTS($self, \&_mouse_event); EVT_SIZE($self, sub { $self->Refresh; }); return $self; } sub _repaint { my ($self, $event) = @_; my $dc = Wx::AutoBufferedPaintDC->new($self); my ($cw, $ch) = $self->GetSizeWH; return if $cw == 0; # when canvas is not rendered yet, size is 0,0 if ($self->{user_drawn_background}) { # On all systems the AutoBufferedPaintDC() achieves double buffering. # On MacOS the background is erased, on Windows the background is not erased # and on Linux/GTK the background is erased to gray color. # Fill DC with the background on Windows & Linux/GTK. my $color = Wx::SystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT); $dc->SetPen(Wx::Pen->new($color, 1, wxSOLID)); $dc->SetBrush(Wx::Brush->new($color, wxSOLID)); my $rect = $self->GetUpdateRegion()->GetBox(); $dc->DrawRectangle($rect->GetLeft(), $rect->GetTop(), $rect->GetWidth(), $rect->GetHeight()); } # turn $cw and $ch from sizes to max coordinates $cw--; $ch--; my $cbb = Slic3r::Geometry::BoundingBoxf->new_from_points([ Slic3r::Pointf->new(0, 0), Slic3r::Pointf->new($cw, $ch), ]); # leave space for origin point $cbb->set_x_min($cbb->x_min + 4); $cbb->set_x_max($cbb->x_max - 4); $cbb->set_y_max($cbb->y_max - 4); # leave space for origin label $cbb->set_y_max($cbb->y_max - 13); # read new size ($cw, $ch) = @{$cbb->size}; my $ccenter = $cbb->center; # get bounding box of bed shape in G-code coordinates my $bed_shape = $self->bed_shape; my $bed_polygon = Slic3r::Polygon->new_scale(@$bed_shape); my $bb = Slic3r::Geometry::BoundingBoxf->new_from_points($bed_shape); $bb->merge_point(Slic3r::Pointf->new(0,0)); # origin needs to be in the visible area my ($bw, $bh) = @{$bb->size}; my $bcenter = $bb->center; # calculate the scaling factor for fitting bed shape in canvas area my $sfactor = min($cw/$bw, $ch/$bh); my $shift = Slic3r::Pointf->new( $ccenter->x - $bcenter->x * $sfactor, $ccenter->y - $bcenter->y * $sfactor, #- ); $self->_scale_factor($sfactor); $self->_shift(Slic3r::Pointf->new( $shift->x + $cbb->x_min, $shift->y - ($cbb->y_max-$self->GetSize->GetHeight), #++ )); # draw bed fill { $dc->SetPen(Wx::Pen->new(Wx::Colour->new(0,0,0), 1, wxSOLID)); $dc->SetBrush(Wx::Brush->new(Wx::Colour->new(255,255,255), wxSOLID)); $dc->DrawPolygon([ map $self->to_pixels($_), @$bed_shape ], 0, 0); } # draw grid { my $step = 10; # 1cm grid my @polylines = (); for (my $x = $bb->x_min - ($bb->x_min % $step) + $step; $x < $bb->x_max; $x += $step) { push @polylines, Slic3r::Polyline->new_scale([$x, $bb->y_min], [$x, $bb->y_max]); } for (my $y = $bb->y_min - ($bb->y_min % $step) + $step; $y < $bb->y_max; $y += $step) { push @polylines, Slic3r::Polyline->new_scale([$bb->x_min, $y], [$bb->x_max, $y]); } @polylines = @{intersection_pl(\@polylines, [$bed_polygon])}; $dc->SetPen(Wx::Pen->new(Wx::Colour->new(230,230,230), 1, wxSOLID)); $dc->DrawLine(map @{$self->to_pixels([map unscale($_), @$_])}, @$_[0,-1]) for @polylines; } # draw bed contour { $dc->SetPen(Wx::Pen->new(Wx::Colour->new(0,0,0), 1, wxSOLID)); $dc->SetBrush(Wx::Brush->new(Wx::Colour->new(255,255,255), wxTRANSPARENT)); $dc->DrawPolygon([ map $self->to_pixels($_), @$bed_shape ], 0, 0); } my $origin_px = $self->to_pixels(Slic3r::Pointf->new(0,0)); # draw axes { my $axes_len = 50; my $arrow_len = 6; my $arrow_angle = deg2rad(45); $dc->SetPen(Wx::Pen->new(Wx::Colour->new(255,0,0), 2, wxSOLID)); # red my $x_end = Slic3r::Pointf->new($origin_px->[X] + $axes_len, $origin_px->[Y]); $dc->DrawLine(@$origin_px, @$x_end); foreach my $angle (-$arrow_angle, +$arrow_angle) { my $end = $x_end->clone; $end->translate(-$arrow_len, 0); $end->rotate($angle, $x_end); $dc->DrawLine(@$x_end, @$end); } $dc->SetPen(Wx::Pen->new(Wx::Colour->new(0,255,0), 2, wxSOLID)); # green my $y_end = Slic3r::Pointf->new($origin_px->[X], $origin_px->[Y] - $axes_len); $dc->DrawLine(@$origin_px, @$y_end); foreach my $angle (-$arrow_angle, +$arrow_angle) { my $end = $y_end->clone; $end->translate(0, +$arrow_len); $end->rotate($angle, $y_end); $dc->DrawLine(@$y_end, @$end); } } # draw origin { $dc->SetPen(Wx::Pen->new(Wx::Colour->new(0,0,0), 1, wxSOLID)); $dc->SetBrush(Wx::Brush->new(Wx::Colour->new(0,0,0), wxSOLID)); $dc->DrawCircle(@$origin_px, 3); $dc->SetTextForeground(Wx::Colour->new(0,0,0)); $dc->SetFont(Wx::Font->new(10, wxDEFAULT, wxNORMAL, wxNORMAL)); $dc->DrawText("(0,0)", $origin_px->[X] + 1, $origin_px->[Y] + 2); } # draw current position if (defined $self->pos) { my $pos_px = $self->to_pixels($self->pos); $dc->SetPen(Wx::Pen->new(Wx::Colour->new(200,0,0), 2, wxSOLID)); $dc->SetBrush(Wx::Brush->new(Wx::Colour->new(200,0,0), wxTRANSPARENT)); $dc->DrawCircle(@$pos_px, 5); $dc->DrawLine($pos_px->[X]-15, $pos_px->[Y], $pos_px->[X]+15, $pos_px->[Y]); $dc->DrawLine($pos_px->[X], $pos_px->[Y]-15, $pos_px->[X], $pos_px->[Y]+15); } $self->_painted(1); } sub _mouse_event { my ($self, $event) = @_; return if !$self->interactive; return if !$self->_painted; my $pos = $event->GetPosition; my $point = $self->to_units([ $pos->x, $pos->y ]); #]] if ($event->LeftDown || $event->Dragging) { $self->on_move->($point) if $self->on_move; $self->Refresh; } } # convert G-code coordinates into pixels sub to_pixels { my ($self, $point) = @_; my $p = Slic3r::Pointf->new(@$point); $p->scale($self->_scale_factor); $p->translate(@{$self->_shift}); return [$p->x, $self->GetSize->GetHeight - $p->y]; #]] } # convert pixels into G-code coordinates sub to_units { my ($self, $point) = @_; my $p = Slic3r::Pointf->new( $point->[X], $self->GetSize->GetHeight - $point->[Y], ); $p->translate(@{$self->_shift->negative}); $p->scale(1/$self->_scale_factor); return $p; } sub set_pos { my ($self, $pos) = @_; $self->pos($pos); $self->Refresh; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/3DScene.pm000066400000000000000000001573631301441720000206300ustar00rootroot00000000000000# Implements pure perl packages # # Slic3r::GUI::3DScene::Base; # Slic3r::GUI::3DScene::Volume; # Slic3r::GUI::3DScene; # # It uses static methods of a C++ class Slic3r::GUI::_3DScene::GLVertexArray # for efficient building of vertex arrays for OpenGL rendering. # # Slic3r::GUI::Plater::3D derives from Slic3r::GUI::3DScene, # Slic3r::GUI::Plater::3DPreview, Slic3r::GUI::Plater::3DToolpaths, # Slic3r::GUI::Plater::ObjectCutDialog and Slic3r::GUI::Plater::ObjectPartsPanel # own $self->{canvas} of the Slic3r::GUI::3DScene type. # # Therefore the 3DScene supports renderng of STLs, extrusions and cutting planes, # and camera manipulation. package Slic3r::GUI::3DScene::Base; use strict; use warnings; use Wx::Event qw(EVT_PAINT EVT_SIZE EVT_ERASE_BACKGROUND EVT_IDLE EVT_MOUSEWHEEL EVT_MOUSE_EVENTS); # must load OpenGL *before* Wx::GLCanvas use OpenGL qw(:glconstants :glfunctions :glufunctions :gluconstants); use base qw(Wx::GLCanvas Class::Accessor); use Math::Trig qw(asin tan); use List::Util qw(reduce min max first); use Slic3r::Geometry qw(X Y Z MIN MAX triangle_normal normalize deg2rad tan scale unscale scaled_epsilon); use Slic3r::Geometry::Clipper qw(offset_ex intersection_pl); use Wx::GLCanvas qw(:all); use Slic3r::Geometry qw(PI); # _dirty: boolean flag indicating, that the screen has to be redrawn on EVT_IDLE. # volumes: reference to vector of Slic3r::GUI::3DScene::Volume. # _camera_type: 'perspective' or 'ortho' __PACKAGE__->mk_accessors( qw(_quat _dirty init enable_picking enable_moving on_viewport_changed on_hover on_select on_double_click on_right_click on_move volumes _sphi _stheta cutting_plane_z cut_lines_vertices bed_shape bed_triangles bed_grid_lines background origin _mouse_pos _hover_volume_idx _drag_volume_idx _drag_start_pos _drag_start_xy _dragged _camera_type _camera_target _camera_distance _zoom ) ); use constant TRACKBALLSIZE => 0.8; use constant TURNTABLE_MODE => 1; use constant GROUND_Z => -0.02; # For mesh selection: Not selected - bright yellow. use constant DEFAULT_COLOR => [1,1,0]; # For mesh selection: Selected - bright green. use constant SELECTED_COLOR => [0,1,0,1]; # For mesh selection: Mouse hovers over the object, but object not selected yet - dark green. use constant HOVER_COLOR => [0.4,0.9,0,1]; # phi / theta angles to orient the camera. use constant VIEW_DEFAULT => [45.0,45.0]; use constant VIEW_LEFT => [90.0,90.0]; use constant VIEW_RIGHT => [-90.0,90.0]; use constant VIEW_TOP => [0.0,0.0]; use constant VIEW_BOTTOM => [0.0,180.0]; use constant VIEW_FRONT => [0.0,90.0]; use constant VIEW_REAR => [180.0,90.0]; #use constant GIMBALL_LOCK_THETA_MAX => 150; use constant GIMBALL_LOCK_THETA_MAX => 170; # make OpenGL::Array thread-safe { no warnings 'redefine'; *OpenGL::Array::CLONE_SKIP = sub { 1 }; } sub new { my ($class, $parent) = @_; # We can only enable multi sample anti aliasing wih wxWidgets 3.0.3 and with a hacked Wx::GLCanvas, # which exports some new WX_GL_XXX constants, namely WX_GL_SAMPLE_BUFFERS and WX_GL_SAMPLES. my $can_multisample = Wx::wxVERSION >= 3.000003 && defined Wx::GLCanvas->can('WX_GL_SAMPLE_BUFFERS') && defined Wx::GLCanvas->can('WX_GL_SAMPLES'); my $attrib = [WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 24]; if ($can_multisample) { # Request a window with multi sampled anti aliasing. This is a new feature in Wx 3.0.3 (backported from 3.1.0). # Use eval to avoid compilation, if the subs WX_GL_SAMPLE_BUFFERS and WX_GL_SAMPLES are missing. eval 'push(@$attrib, (WX_GL_SAMPLE_BUFFERS, 1, WX_GL_SAMPLES, 4));'; } # wxWidgets expect the attrib list to be ended by zero. push(@$attrib, 0); # we request a depth buffer explicitely because it looks like it's not created by # default on Linux, causing transparency issues my $self = $class->SUPER::new($parent, -1, Wx::wxDefaultPosition, Wx::wxDefaultSize, 0, "", $attrib); if (Wx::wxVERSION >= 3.000003) { # Wx 3.0.3 contains an ugly hack to support some advanced OpenGL attributes through the attribute list. # The attribute list is transferred between the wxGLCanvas and wxGLContext constructors using a single static array s_wglContextAttribs. # Immediatelly force creation of the OpenGL context to consume the static variable s_wglContextAttribs. $self->GetContext(); } $self->background(1); $self->_quat((0, 0, 0, 1)); $self->_stheta(45); $self->_sphi(45); $self->_zoom(1); # 3D point in model space $self->_camera_type('ortho'); # $self->_camera_type('perspective'); $self->_camera_target(Slic3r::Pointf3->new(0,0,0)); $self->_camera_distance(0.); $self->reset_objects; EVT_PAINT($self, sub { my $dc = Wx::PaintDC->new($self); $self->Render($dc); }); EVT_SIZE($self, sub { $self->_dirty(1) }); EVT_IDLE($self, sub { return unless $self->_dirty; return if !$self->IsShownOnScreen; $self->Resize( $self->GetSizeWH ); $self->Refresh; }); EVT_MOUSEWHEEL($self, sub { my ($self, $e) = @_; # Calculate the zoom delta and apply it to the current zoom factor my $zoom = $e->GetWheelRotation() / $e->GetWheelDelta(); $zoom = max(min($zoom, 4), -4); $zoom /= 10; $self->_zoom($self->_zoom / (1-$zoom)); # In order to zoom around the mouse point we need to translate # the camera target my $size = Slic3r::Pointf->new($self->GetSizeWH); my $pos = Slic3r::Pointf->new($e->GetX, $size->y - $e->GetY); #- $self->_camera_target->translate( # ($pos - $size/2) represents the vector from the viewport center # to the mouse point. By multiplying it by $zoom we get the new, # transformed, length of such vector. # Since we want that point to stay fixed, we move our camera target # in the opposite direction by the delta of the length of such vector # ($zoom - 1). We then scale everything by 1/$self->_zoom since # $self->_camera_target is expressed in terms of model units. -($pos->x - $size->x/2) * ($zoom) / $self->_zoom, -($pos->y - $size->y/2) * ($zoom) / $self->_zoom, 0, ) if 0; $self->on_viewport_changed->() if $self->on_viewport_changed; $self->_dirty(1); $self->Refresh; }); EVT_MOUSE_EVENTS($self, \&mouse_event); return $self; } sub mouse_event { my ($self, $e) = @_; my $pos = Slic3r::Pointf->new($e->GetPositionXY); if ($e->Entering && &Wx::wxMSW) { # wxMSW needs focus in order to catch mouse wheel events $self->SetFocus; } elsif ($e->LeftDClick) { $self->on_double_click->() if $self->on_double_click; } elsif ($e->LeftDown || $e->RightDown) { # If user pressed left or right button we first check whether this happened # on a volume or not. my $volume_idx = $self->_hover_volume_idx // -1; # select volume in this 3D canvas if ($self->enable_picking) { $self->deselect_volumes; $self->select_volume($volume_idx); if ($volume_idx != -1) { my $group_id = $self->volumes->[$volume_idx]->select_group_id; my @volumes; if ($group_id != -1) { $self->select_volume($_) for grep $self->volumes->[$_]->select_group_id == $group_id, 0..$#{$self->volumes}; } } $self->Refresh; } # propagate event through callback $self->on_select->($volume_idx) if $self->on_select; if ($volume_idx != -1) { if ($e->LeftDown && $self->enable_moving) { $self->_drag_volume_idx($volume_idx); $self->_drag_start_pos($self->mouse_to_3d(@$pos)); } elsif ($e->RightDown) { # if right clicking on volume, propagate event through callback $self->on_right_click->($e->GetPosition) if $self->on_right_click; } } } elsif ($e->Dragging && $e->LeftIsDown && defined($self->_drag_volume_idx)) { # get new position at the same Z of the initial click point my $mouse_ray = $self->mouse_ray($e->GetX, $e->GetY); my $cur_pos = $mouse_ray->intersect_plane($self->_drag_start_pos->z); # calculate the translation vector my $vector = $self->_drag_start_pos->vector_to($cur_pos); # get volume being dragged my $volume = $self->volumes->[$self->_drag_volume_idx]; # get all volumes belonging to the same group, if any my @volumes; if ($volume->drag_group_id == -1) { @volumes = ($volume); } else { @volumes = grep $_->drag_group_id == $volume->drag_group_id, @{$self->volumes}; } # apply new temporary volume origin and ignore Z $_->origin->translate($vector->x, $vector->y, 0) for @volumes; #,, $self->_drag_start_pos($cur_pos); $self->_dragged(1); $self->Refresh; } elsif ($e->Dragging) { if ($e->LeftIsDown) { # if dragging over blank area with left button, rotate if (defined $self->_drag_start_pos) { my $orig = $self->_drag_start_pos; if (TURNTABLE_MODE) { $self->_sphi($self->_sphi + ($pos->x - $orig->x) * TRACKBALLSIZE); $self->_stheta($self->_stheta - ($pos->y - $orig->y) * TRACKBALLSIZE); #- $self->_stheta(GIMBALL_LOCK_THETA_MAX) if $self->_stheta > GIMBALL_LOCK_THETA_MAX; $self->_stheta(0) if $self->_stheta < 0; } else { my $size = $self->GetClientSize; my @quat = trackball( $orig->x / ($size->width / 2) - 1, 1 - $orig->y / ($size->height / 2), #/ $pos->x / ($size->width / 2) - 1, 1 - $pos->y / ($size->height / 2), #/ ); $self->_quat(mulquats($self->_quat, \@quat)); } $self->on_viewport_changed->() if $self->on_viewport_changed; $self->Refresh; } $self->_drag_start_pos($pos); } elsif ($e->MiddleIsDown || $e->RightIsDown) { # if dragging over blank area with right button, translate if (defined $self->_drag_start_xy) { # get point in model space at Z = 0 my $cur_pos = $self->mouse_ray($e->GetX, $e->GetY)->intersect_plane(0); my $orig = $self->mouse_ray(@{$self->_drag_start_xy})->intersect_plane(0); $self->_camera_target->translate( @{$orig->vector_to($cur_pos)->negative}, ); $self->on_viewport_changed->() if $self->on_viewport_changed; $self->Refresh; } $self->_drag_start_xy($pos); } } elsif ($e->LeftUp || $e->MiddleUp || $e->RightUp) { if ($self->on_move && defined($self->_drag_volume_idx) && $self->_dragged) { # get all volumes belonging to the same group, if any my @volume_idxs; my $group_id = $self->volumes->[$self->_drag_volume_idx]->drag_group_id; if ($group_id == -1) { @volume_idxs = ($self->_drag_volume_idx); } else { @volume_idxs = grep $self->volumes->[$_]->drag_group_id == $group_id, 0..$#{$self->volumes}; } $self->on_move->(@volume_idxs); } $self->_drag_volume_idx(undef); $self->_drag_start_pos(undef); $self->_drag_start_xy(undef); $self->_dragged(undef); } elsif ($e->Moving) { $self->_mouse_pos($pos); $self->Refresh; } else { $e->Skip(); } } # Reset selection. sub reset_objects { my ($self) = @_; $self->volumes([]); $self->_dirty(1); } # Setup camera to view all objects. sub set_viewport_from_scene { my ($self, $scene) = @_; $self->_sphi($scene->_sphi); $self->_stheta($scene->_stheta); $self->_camera_target($scene->_camera_target); $self->_zoom($scene->_zoom); $self->_quat($scene->_quat); $self->_dirty(1); } # Set the camera to a default orientation, # zoom to volumes. sub select_view { my ($self, $direction) = @_; my $dirvec; if (ref($direction)) { $dirvec = $direction; } else { if ($direction eq 'default') { $dirvec = VIEW_DEFAULT; } elsif ($direction eq 'left') { $dirvec = VIEW_LEFT; } elsif ($direction eq 'right') { $dirvec = VIEW_RIGHT; } elsif ($direction eq 'top') { $dirvec = VIEW_TOP; } elsif ($direction eq 'bottom') { $dirvec = VIEW_BOTTOM; } elsif ($direction eq 'front') { $dirvec = VIEW_FRONT; } elsif ($direction eq 'rear') { $dirvec = VIEW_REAR; } } my $bb = $self->volumes_bounding_box; if (! $bb->empty) { $self->_sphi($dirvec->[0]); $self->_stheta($dirvec->[1]); # Avoid gimball lock. $self->_stheta(GIMBALL_LOCK_THETA_MAX) if $self->_stheta > GIMBALL_LOCK_THETA_MAX; $self->_stheta(0) if $self->_stheta < 0; # View everything. $self->zoom_to_bounding_box($bb); $self->on_viewport_changed->() if $self->on_viewport_changed; $self->Refresh; } } sub zoom_to_bounding_box { my ($self, $bb) = @_; return if ($bb->empty); # calculate the zoom factor needed to adjust viewport to # bounding box my $max_size = max(@{$bb->size}) * 2; my $min_viewport_size = min($self->GetSizeWH); $self->_zoom($min_viewport_size / $max_size); # center view around bounding box center $self->_camera_target($bb->center); $self->on_viewport_changed->() if $self->on_viewport_changed; } sub zoom_to_bed { my ($self) = @_; if ($self->bed_shape) { $self->zoom_to_bounding_box($self->bed_bounding_box); } } sub zoom_to_volume { my ($self, $volume_idx) = @_; my $volume = $self->volumes->[$volume_idx]; my $bb = $volume->transformed_bounding_box; $self->zoom_to_bounding_box($bb); } sub zoom_to_volumes { my ($self) = @_; $self->zoom_to_bounding_box($self->volumes_bounding_box); } sub volumes_bounding_box { my ($self) = @_; my $bb = Slic3r::Geometry::BoundingBoxf3->new; $bb->merge($_->transformed_bounding_box) for @{$self->volumes}; return $bb; } sub bed_bounding_box { my ($self) = @_; my $bb = Slic3r::Geometry::BoundingBoxf3->new; if ($self->bed_shape) { $bb->merge_point(Slic3r::Pointf3->new(@$_, 0)) for @{$self->bed_shape}; } return $bb; } sub max_bounding_box { my ($self) = @_; my $bb = $self->bed_bounding_box; $bb->merge($self->volumes_bounding_box); return $bb; } sub set_auto_bed_shape { my ($self, $bed_shape) = @_; # draw a default square bed around object center my $max_size = max(@{ $self->volumes_bounding_box->size }); my $center = $self->volumes_bounding_box->center; $self->set_bed_shape([ [ $center->x - $max_size, $center->y - $max_size ], #-- [ $center->x + $max_size, $center->y - $max_size ], #-- [ $center->x + $max_size, $center->y + $max_size ], #++ [ $center->x - $max_size, $center->y + $max_size ], #++ ]); $self->origin(Slic3r::Pointf->new(@$center[X,Y])); } sub set_bed_shape { my ($self, $bed_shape) = @_; $self->bed_shape($bed_shape); # triangulate bed my $expolygon = Slic3r::ExPolygon->new([ map [map scale($_), @$_], @$bed_shape ]); my $bed_bb = $expolygon->bounding_box; { my @points = (); foreach my $triangle (@{ $expolygon->triangulate }) { push @points, map {+ unscale($_->x), unscale($_->y), GROUND_Z } @$triangle; #)) } $self->bed_triangles(OpenGL::Array->new_list(GL_FLOAT, @points)); } { my @polylines = (); for (my $x = $bed_bb->x_min; $x <= $bed_bb->x_max; $x += scale 10) { push @polylines, Slic3r::Polyline->new([$x,$bed_bb->y_min], [$x,$bed_bb->y_max]); } for (my $y = $bed_bb->y_min; $y <= $bed_bb->y_max; $y += scale 10) { push @polylines, Slic3r::Polyline->new([$bed_bb->x_min,$y], [$bed_bb->x_max,$y]); } # clip with a slightly grown expolygon because our lines lay on the contours and # may get erroneously clipped my @lines = map Slic3r::Line->new(@$_[0,-1]), @{intersection_pl(\@polylines, [ @{$expolygon->offset(+scaled_epsilon)} ])}; # append bed contours push @lines, map @{$_->lines}, @$expolygon; my @points = (); foreach my $line (@lines) { push @points, map {+ unscale($_->x), unscale($_->y), GROUND_Z } @$line; #)) } $self->bed_grid_lines(OpenGL::Array->new_list(GL_FLOAT, @points)); } $self->origin(Slic3r::Pointf->new(0,0)); } sub deselect_volumes { my ($self) = @_; $_->selected(0) for @{$self->volumes}; } sub select_volume { my ($self, $volume_idx) = @_; $self->volumes->[$volume_idx]->selected(1) if $volume_idx != -1; } sub SetCuttingPlane { my ($self, $z, $expolygons) = @_; $self->cutting_plane_z($z); # grow slices in order to display them better $expolygons = offset_ex([ map @$_, @$expolygons ], scale 0.1); my @verts = (); foreach my $line (map @{$_->lines}, map @$_, @$expolygons) { push @verts, ( unscale($line->a->x), unscale($line->a->y), $z, #)) unscale($line->b->x), unscale($line->b->y), $z, #)) ); } $self->cut_lines_vertices(OpenGL::Array->new_list(GL_FLOAT, @verts)); } # Given an axis and angle, compute quaternion. sub axis_to_quat { my ($ax, $phi) = @_; my $lena = sqrt(reduce { $a + $b } (map { $_ * $_ } @$ax)); my @q = map { $_ * (1 / $lena) } @$ax; @q = map { $_ * sin($phi / 2.0) } @q; $q[$#q + 1] = cos($phi / 2.0); return @q; } # Project a point on the virtual trackball. # If it is inside the sphere, map it to the sphere, if it outside map it # to a hyperbola. sub project_to_sphere { my ($r, $x, $y) = @_; my $d = sqrt($x * $x + $y * $y); if ($d < $r * 0.70710678118654752440) { # Inside sphere return sqrt($r * $r - $d * $d); } else { # On hyperbola my $t = $r / 1.41421356237309504880; return $t * $t / $d; } } sub cross { my ($v1, $v2) = @_; return (@$v1[1] * @$v2[2] - @$v1[2] * @$v2[1], @$v1[2] * @$v2[0] - @$v1[0] * @$v2[2], @$v1[0] * @$v2[1] - @$v1[1] * @$v2[0]); } # Simulate a track-ball. Project the points onto the virtual trackball, # then figure out the axis of rotation, which is the cross product of # P1 P2 and O P1 (O is the center of the ball, 0,0,0) Note: This is a # deformed trackball-- is a trackball in the center, but is deformed # into a hyperbolic sheet of rotation away from the center. # It is assumed that the arguments to this routine are in the range # (-1.0 ... 1.0). sub trackball { my ($p1x, $p1y, $p2x, $p2y) = @_; if ($p1x == $p2x && $p1y == $p2y) { # zero rotation return (0.0, 0.0, 0.0, 1.0); } # First, figure out z-coordinates for projection of P1 and P2 to # deformed sphere my @p1 = ($p1x, $p1y, project_to_sphere(TRACKBALLSIZE, $p1x, $p1y)); my @p2 = ($p2x, $p2y, project_to_sphere(TRACKBALLSIZE, $p2x, $p2y)); # axis of rotation (cross product of P1 and P2) my @a = cross(\@p2, \@p1); # Figure out how much to rotate around that axis. my @d = map { $_ * $_ } (map { $p1[$_] - $p2[$_] } 0 .. $#p1); my $t = sqrt(reduce { $a + $b } @d) / (2.0 * TRACKBALLSIZE); # Avoid problems with out-of-control values... $t = 1.0 if ($t > 1.0); $t = -1.0 if ($t < -1.0); my $phi = 2.0 * asin($t); return axis_to_quat(\@a, $phi); } # Build a rotation matrix, given a quaternion rotation. sub quat_to_rotmatrix { my ($q) = @_; my @m = (); $m[0] = 1.0 - 2.0 * (@$q[1] * @$q[1] + @$q[2] * @$q[2]); $m[1] = 2.0 * (@$q[0] * @$q[1] - @$q[2] * @$q[3]); $m[2] = 2.0 * (@$q[2] * @$q[0] + @$q[1] * @$q[3]); $m[3] = 0.0; $m[4] = 2.0 * (@$q[0] * @$q[1] + @$q[2] * @$q[3]); $m[5] = 1.0 - 2.0 * (@$q[2] * @$q[2] + @$q[0] * @$q[0]); $m[6] = 2.0 * (@$q[1] * @$q[2] - @$q[0] * @$q[3]); $m[7] = 0.0; $m[8] = 2.0 * (@$q[2] * @$q[0] - @$q[1] * @$q[3]); $m[9] = 2.0 * (@$q[1] * @$q[2] + @$q[0] * @$q[3]); $m[10] = 1.0 - 2.0 * (@$q[1] * @$q[1] + @$q[0] * @$q[0]); $m[11] = 0.0; $m[12] = 0.0; $m[13] = 0.0; $m[14] = 0.0; $m[15] = 1.0; return @m; } sub mulquats { my ($q1, $rq) = @_; return (@$q1[3] * @$rq[0] + @$q1[0] * @$rq[3] + @$q1[1] * @$rq[2] - @$q1[2] * @$rq[1], @$q1[3] * @$rq[1] + @$q1[1] * @$rq[3] + @$q1[2] * @$rq[0] - @$q1[0] * @$rq[2], @$q1[3] * @$rq[2] + @$q1[2] * @$rq[3] + @$q1[0] * @$rq[1] - @$q1[1] * @$rq[0], @$q1[3] * @$rq[3] - @$q1[0] * @$rq[0] - @$q1[1] * @$rq[1] - @$q1[2] * @$rq[2]) } sub mouse_to_3d { my ($self, $x, $y, $z) = @_; my @viewport = glGetIntegerv_p(GL_VIEWPORT); # 4 items my @mview = glGetDoublev_p(GL_MODELVIEW_MATRIX); # 16 items my @proj = glGetDoublev_p(GL_PROJECTION_MATRIX); # 16 items $y = $viewport[3] - $y; $z //= glReadPixels_p($x, $y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT); my @projected = gluUnProject_p($x, $y, $z, @mview, @proj, @viewport); return Slic3r::Pointf3->new(@projected); } sub mouse_ray { my ($self, $x, $y) = @_; return Slic3r::Linef3->new( $self->mouse_to_3d($x, $y, 0), $self->mouse_to_3d($x, $y, 1), ); } sub GetContext { my ($self) = @_; if (Wx::wxVERSION >= 2.009) { return $self->{context} ||= Wx::GLContext->new($self); } else { return $self->SUPER::GetContext; } } sub SetCurrent { my ($self, $context) = @_; if (Wx::wxVERSION >= 2.009) { return $self->SUPER::SetCurrent($context); } else { return $self->SUPER::SetCurrent; } } sub Resize { my ($self, $x, $y) = @_; return unless $self->GetContext; $self->_dirty(0); $self->SetCurrent($self->GetContext); glViewport(0, 0, $x, $y); $x /= $self->_zoom; $y /= $self->_zoom; glMatrixMode(GL_PROJECTION); glLoadIdentity(); if ($self->_camera_type eq 'ortho') { #FIXME setting the size of the box 10x larger than necessary # is only a workaround for an incorrectly set camera. # This workaround harms Z-buffer accuracy! # my $depth = 1.05 * $self->max_bounding_box->radius(); my $depth = 10.0 * $self->max_bounding_box->radius(); glOrtho( -$x/2, $x/2, -$y/2, $y/2, -$depth, $depth, ); } else { die "Invalid camera type: ", $self->_camera_type, "\n" if ($self->_camera_type ne 'perspective'); my $bbox_r = $self->max_bounding_box->radius(); my $fov = PI * 45. / 180.; my $fov_tan = tan(0.5 * $fov); my $cam_distance = 0.5 * $bbox_r / $fov_tan; $self->_camera_distance($cam_distance); my $nr = $cam_distance - $bbox_r * 1.1; my $fr = $cam_distance + $bbox_r * 1.1; $nr = 1 if ($nr < 1); $fr = $nr + 1 if ($fr < $nr + 1); my $h2 = $fov_tan * $nr; my $w2 = $h2 * $x / $y; glFrustum(-$w2, $w2, -$h2, $h2, $nr, $fr); } glMatrixMode(GL_MODELVIEW); } sub InitGL { my $self = shift; return if $self->init; return unless $self->GetContext; $self->init(1); glClearColor(0, 0, 0, 1); glColor3f(1, 0, 0); glEnable(GL_DEPTH_TEST); glClearDepth(1.0); glDepthFunc(GL_LEQUAL); glEnable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); # Set antialiasing/multisampling glDisable(GL_LINE_SMOOTH); glDisable(GL_POLYGON_SMOOTH); glEnable(GL_MULTISAMPLE); # glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST); # ambient lighting glLightModelfv_p(GL_LIGHT_MODEL_AMBIENT, 0.3, 0.3, 0.3, 1); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); # light from camera glLightfv_p(GL_LIGHT1, GL_POSITION, 1, 0, 1, 0); glLightfv_p(GL_LIGHT1, GL_SPECULAR, 0.3, 0.3, 0.3, 1); glLightfv_p(GL_LIGHT1, GL_DIFFUSE, 0.2, 0.2, 0.2, 1); # Enables Smooth Color Shading; try GL_FLAT for (lack of) fun. glShadeModel(GL_SMOOTH); glMaterialfv_p(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, 0.5, 0.3, 0.3, 1); glMaterialfv_p(GL_FRONT_AND_BACK, GL_SPECULAR, 1, 1, 1, 1); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50); glMaterialfv_p(GL_FRONT_AND_BACK, GL_EMISSION, 0.1, 0, 0, 0.9); # A handy trick -- have surface material mirror the color. glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glEnable(GL_COLOR_MATERIAL); glEnable(GL_MULTISAMPLE); } sub Render { my ($self, $dc) = @_; # prevent calling SetCurrent() when window is not shown yet return unless $self->IsShownOnScreen; return unless my $context = $self->GetContext; $self->SetCurrent($context); $self->InitGL; glClearColor(1, 1, 1, 1); glClearDepth(1); glDepthFunc(GL_LESS); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); { # Shift the perspective camera. my $camera_pos = Slic3r::Pointf3->new(0,0,-$self->_camera_distance); glTranslatef(@$camera_pos); } if (TURNTABLE_MODE) { glRotatef(-$self->_stheta, 1, 0, 0); # pitch glRotatef($self->_sphi, 0, 0, 1); # yaw } else { my @rotmat = quat_to_rotmatrix($self->quat); glMultMatrixd_p(@rotmat[0..15]); } glTranslatef(@{ $self->_camera_target->negative }); # light from above glLightfv_p(GL_LIGHT0, GL_POSITION, -0.5, -0.5, 1, 0); glLightfv_p(GL_LIGHT0, GL_SPECULAR, 0.2, 0.2, 0.2, 1); glLightfv_p(GL_LIGHT0, GL_DIFFUSE, 0.5, 0.5, 0.5, 1); if ($self->enable_picking) { # Render the object for picking. # FIXME This cannot possibly work in a multi-sampled context as the color gets mangled by the anti-aliasing. # Better to use software ray-casting on a bounding-box hierarchy. glDisable(GL_LIGHTING); $self->draw_volumes(1); glFlush(); glFinish(); if (my $pos = $self->_mouse_pos) { my $col = [ glReadPixels_p($pos->x, $self->GetSize->GetHeight - $pos->y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE) ]; my $volume_idx = $col->[0] + $col->[1]*256 + $col->[2]*256*256; $self->_hover_volume_idx(undef); $_->hover(0) for @{$self->volumes}; if ($volume_idx <= $#{$self->volumes}) { $self->_hover_volume_idx($volume_idx); $self->volumes->[$volume_idx]->hover(1); my $group_id = $self->volumes->[$volume_idx]->select_group_id; if ($group_id != -1) { $_->hover(1) for grep { $_->select_group_id == $group_id } @{$self->volumes}; } $self->on_hover->($volume_idx) if $self->on_hover; } } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glFlush(); glFinish(); glEnable(GL_LIGHTING); } # draw fixed background if ($self->background) { glDisable(GL_LIGHTING); glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); # Draws a bluish bottom to top gradient over the complete screen. glDisable(GL_DEPTH_TEST); glBegin(GL_QUADS); glColor3f(0.0,0.0,0.0); glVertex3f(-1.0,-1.0, 1.0); glVertex3f( 1.0,-1.0, 1.0); glColor3f(10/255,98/255,144/255); glVertex3f( 1.0, 1.0, 1.0); glVertex3f(-1.0, 1.0, 1.0); glEnd(); glPopMatrix(); glEnable(GL_DEPTH_TEST); glMatrixMode(GL_MODELVIEW); glPopMatrix(); glEnable(GL_LIGHTING); } # draw ground and axes glDisable(GL_LIGHTING); # draw ground my $ground_z = GROUND_Z; if ($self->bed_triangles) { glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnableClientState(GL_VERTEX_ARRAY); glColor4f(0.8, 0.6, 0.5, 0.4); glNormal3d(0,0,1); glVertexPointer_p(3, $self->bed_triangles); glDrawArrays(GL_TRIANGLES, 0, $self->bed_triangles->elements / 3); glDisableClientState(GL_VERTEX_ARRAY); # we need depth test for grid, otherwise it would disappear when looking # the object from below glEnable(GL_DEPTH_TEST); # draw grid glLineWidth(3); glColor4f(0.2, 0.2, 0.2, 0.4); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer_p(3, $self->bed_grid_lines); glDrawArrays(GL_LINES, 0, $self->bed_grid_lines->elements / 3); glDisableClientState(GL_VERTEX_ARRAY); glDisable(GL_BLEND); } my $volumes_bb = $self->volumes_bounding_box; { # draw axes # disable depth testing so that axes are not covered by ground glDisable(GL_DEPTH_TEST); my $origin = $self->origin; my $axis_len = max( 0.3 * max(@{ $self->bed_bounding_box->size }), 2 * max(@{ $volumes_bb->size }), ); glLineWidth(2); glBegin(GL_LINES); # draw line for x axis glColor3f(1, 0, 0); glVertex3f(@$origin, $ground_z); glVertex3f($origin->x + $axis_len, $origin->y, $ground_z); #,, # draw line for y axis glColor3f(0, 1, 0); glVertex3f(@$origin, $ground_z); glVertex3f($origin->x, $origin->y + $axis_len, $ground_z); #++ glEnd(); # draw line for Z axis # (re-enable depth test so that axis is correctly shown when objects are behind it) glEnable(GL_DEPTH_TEST); glBegin(GL_LINES); glColor3f(0, 0, 1); glVertex3f(@$origin, $ground_z); glVertex3f(@$origin, $ground_z+$axis_len); glEnd(); } glEnable(GL_LIGHTING); # draw objects $self->draw_volumes; # draw cutting plane if (defined $self->cutting_plane_z) { my $plane_z = $self->cutting_plane_z; my $bb = $volumes_bb; glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBegin(GL_QUADS); glColor4f(0.8, 0.8, 0.8, 0.5); glVertex3f($bb->x_min-20, $bb->y_min-20, $plane_z); glVertex3f($bb->x_max+20, $bb->y_min-20, $plane_z); glVertex3f($bb->x_max+20, $bb->y_max+20, $plane_z); glVertex3f($bb->x_min-20, $bb->y_max+20, $plane_z); glEnd(); glEnable(GL_CULL_FACE); glDisable(GL_BLEND); } glFlush(); $self->SwapBuffers(); } sub draw_volumes { # $fakecolor is a boolean indicating, that the objects shall be rendered in a color coding the object index for picking. my ($self, $fakecolor) = @_; glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); foreach my $volume_idx (0..$#{$self->volumes}) { my $volume = $self->volumes->[$volume_idx]; if ($fakecolor) { # Object picking mode. Render the object with a color encoding the object index. my $r = ($volume_idx & 0x000000FF) >> 0; my $g = ($volume_idx & 0x0000FF00) >> 8; my $b = ($volume_idx & 0x00FF0000) >> 16; glColor4f($r/255.0, $g/255.0, $b/255.0, 1); } elsif ($volume->selected) { glColor4f(@{ &SELECTED_COLOR }); } elsif ($volume->hover) { glColor4f(@{ &HOVER_COLOR }); } else { glColor4f(@{ $volume->color }); } my $qverts_begin = 0; my $qverts_end = defined($volume->qverts) ? $volume->qverts->size() : 0; my $tverts_begin = 0; my $tverts_end = defined($volume->tverts) ? $volume->tverts->size() : 0; my $n_offsets = ($volume->range && $volume->offsets) ? scalar(@{$volume->offsets}) : 0; if ($n_offsets) { # The Z layer range is specified. # First test whether the Z span of this object is not out of ($min_z, $max_z) completely. my ($min_z, $max_z) = @{$volume->range}; next if ($volume->offsets->[0] > $max_z || $volume->offsets->[-3] < $min_z); # Then find the lowest layer to be displayed. my $i = 0; while ($i < $n_offsets && $volume->offsets->[$i] < $min_z) { $i += 3; } # This shall not happen. next if ($i == $n_offsets); # Remember start of the layer. $qverts_begin = $volume->offsets->[$i+1]; $tverts_begin = $volume->offsets->[$i+2]; # Some layers are above $min_z. Which? while ($i < $n_offsets && $volume->offsets->[$i] <= $max_z) { $i += 3; } if ($i < $n_offsets) { $qverts_end = $volume->offsets->[$i+1]; $tverts_end = $volume->offsets->[$i+2]; } } glPushMatrix(); glTranslatef(@{$volume->origin}); glCullFace(GL_BACK); if ($qverts_begin < $qverts_end) { glVertexPointer_c(3, GL_FLOAT, 0, $volume->qverts->verts_ptr); glNormalPointer_c(GL_FLOAT, 0, $volume->qverts->norms_ptr); glDrawArrays(GL_QUADS, $qverts_begin / 3, ($qverts_end-$qverts_begin) / 3); } if ($tverts_begin < $tverts_end) { glVertexPointer_c(3, GL_FLOAT, 0, $volume->tverts->verts_ptr); glNormalPointer_c(GL_FLOAT, 0, $volume->tverts->norms_ptr); glDrawArrays(GL_TRIANGLES, $tverts_begin / 3, ($tverts_end-$tverts_begin) / 3); } glPopMatrix(); } glDisableClientState(GL_NORMAL_ARRAY); glDisable(GL_BLEND); if (defined $self->cutting_plane_z) { glLineWidth(2); glColor3f(0, 0, 0); glVertexPointer_p(3, $self->cut_lines_vertices); glDrawArrays(GL_LINES, 0, $self->cut_lines_vertices->elements / 3); } glDisableClientState(GL_VERTEX_ARRAY); } sub _report_opengl_state { my ($self, $comment) = @_; my $err = glGetError(); return 0 if ($err == 0); # gluErrorString() hangs. Don't use it. # my $errorstr = gluErrorString(); my $errorstr = ''; if ($err == 0x0500) { $errorstr = 'GL_INVALID_ENUM'; } elsif ($err == GL_INVALID_VALUE) { $errorstr = 'GL_INVALID_VALUE'; } elsif ($err == GL_INVALID_OPERATION) { $errorstr = 'GL_INVALID_OPERATION'; } elsif ($err == GL_STACK_OVERFLOW) { $errorstr = 'GL_STACK_OVERFLOW'; } elsif ($err == GL_OUT_OF_MEMORY) { $errorstr = 'GL_OUT_OF_MEMORY'; } else { $errorstr = 'unknown'; } if (defined($comment)) { printf("OpenGL error at %s, nr %d (0x%x): %s\n", $comment, $err, $err, $errorstr); } else { printf("OpenGL error nr %d (0x%x): %s\n", $err, $err, $errorstr); } } # Container for object geometry and selection status. package Slic3r::GUI::3DScene::Volume; use Moo; has 'bounding_box' => (is => 'ro', required => 1); has 'origin' => (is => 'rw', default => sub { Slic3r::Pointf3->new(0,0,0) }); has 'color' => (is => 'ro', required => 1); # An ID for group selection. It may be the same for all meshes of all object instances, or for just a single object instance. has 'select_group_id' => (is => 'rw', default => sub { -1 }); # An ID for group dragging. It may be the same for all meshes of all object instances, or for just a single object instance. has 'drag_group_id' => (is => 'rw', default => sub { -1 }); # Boolean: Is this object selected? has 'selected' => (is => 'rw', default => sub { 0 }); # Boolean: Is mouse over this object? has 'hover' => (is => 'rw', default => sub { 0 }); # Vector of two values: a span in the Z axis. Meaningful for a display of layers. has 'range' => (is => 'rw'); # Geometric data. # Quads: GLVertexArray object: C++ class maintaining an std::vector for coords and normals. has 'qverts' => (is => 'rw'); # Triangles: GLVertexArray object has 'tverts' => (is => 'rw'); # If the qverts or tverts contain thick extrusions, then offsets keeps pointers of the starts # of the extrusions per layer. # The offsets stores tripples of (z_top, qverts_idx, tverts_idx) in a linear array. has 'offsets' => (is => 'rw'); sub transformed_bounding_box { my ($self) = @_; my $bb = $self->bounding_box; $bb->translate(@{$self->origin}); return $bb; } # The 3D canvas to display objects and tool paths. package Slic3r::GUI::3DScene; use base qw(Slic3r::GUI::3DScene::Base); use OpenGL qw(:glconstants :gluconstants :glufunctions); use List::Util qw(first min max); use Slic3r::Geometry qw(scale unscale epsilon); use Slic3r::Print::State ':steps'; # Perimeter: yellow, Infill: redish, Suport: greenish, last: blueish, use constant COLORS => [ [1,1,0,1], [1,0.5,0.5,1], [0.5,1,0.5,1], [0.5,0.5,1,1] ]; __PACKAGE__->mk_accessors(qw( color_by select_by drag_by volumes_by_object _objects_by_volumes )); sub new { my $class = shift; my $self = $class->SUPER::new(@_); $self->color_by('volume'); # object | volume $self->select_by('object'); # object | volume | instance $self->drag_by('instance'); # object | instance $self->volumes_by_object({}); # obj_idx => [ volume_idx, volume_idx ... ] $self->_objects_by_volumes({}); # volume_idx => [ obj_idx, instance_idx ] return $self; } sub load_object { my ($self, $model, $obj_idx, $instance_idxs) = @_; my $model_object; if ($model->isa('Slic3r::Model::Object')) { $model_object = $model; $model = $model_object->model; $obj_idx = 0; } else { $model_object = $model->get_object($obj_idx); } $instance_idxs ||= [0..$#{$model_object->instances}]; my @volumes_idx = (); foreach my $volume_idx (0..$#{$model_object->volumes}) { my $volume = $model_object->volumes->[$volume_idx]; foreach my $instance_idx (@$instance_idxs) { my $instance = $model_object->instances->[$instance_idx]; my $mesh = $volume->mesh->clone; $instance->transform_mesh($mesh); my $color_idx; if ($self->color_by eq 'volume') { $color_idx = $volume_idx; } elsif ($self->color_by eq 'object') { $color_idx = $obj_idx; } # Using the colors 'yellowish', 'greenish', 'blueish' for both the extrusion paths # and the volumes of a single multi-color object. #FIXME so for 4 or more color print, there will be only 3 colors displayed, which will # not correspond to the color of the filament. my $color = [ @{COLORS->[ $color_idx % scalar(@{&COLORS}) ]} ]; $color->[3] = $volume->modifier ? 0.5 : 1; push @{$self->volumes}, my $v = Slic3r::GUI::3DScene::Volume->new( bounding_box => $mesh->bounding_box, color => $color, ); if ($self->select_by eq 'object') { $v->select_group_id($obj_idx*1000000); } elsif ($self->select_by eq 'volume') { $v->select_group_id($obj_idx*1000000 + $volume_idx*1000); } elsif ($self->select_by eq 'instance') { $v->select_group_id($obj_idx*1000000 + $volume_idx*1000 + $instance_idx); } if ($self->drag_by eq 'object') { $v->drag_group_id($obj_idx*1000); } elsif ($self->drag_by eq 'instance') { $v->drag_group_id($obj_idx*1000 + $instance_idx); } push @volumes_idx, my $scene_volume_idx = $#{$self->volumes}; $self->_objects_by_volumes->{$scene_volume_idx} = [ $obj_idx, $volume_idx, $instance_idx ]; my $verts = Slic3r::GUI::_3DScene::GLVertexArray->new; $verts->load_mesh($mesh); $v->tverts($verts); } } $self->volumes_by_object->{$obj_idx} = [@volumes_idx]; return @volumes_idx; } # Called possibly by utils/view-toolpaths.pl, likely broken. sub load_print_object_slices { my ($self, $object) = @_; my @verts = (); my @norms = (); my @quad_verts = (); my @quad_norms = (); foreach my $layer (@{$object->layers}) { my $gap = 0; my $top_z = $layer->print_z; my $bottom_z = $layer->print_z - $layer->height + $gap; foreach my $copy (@{ $object->_shifted_copies }) { { my @expolygons = map $_->clone, @{$layer->slices}; $_->translate(@$copy) for @expolygons; $self->_expolygons_to_verts(\@expolygons, $layer->print_z, \@verts, \@norms); } foreach my $slice (@{$layer->slices}) { foreach my $polygon (@$slice) { foreach my $line (@{$polygon->lines}) { $line->translate(@$copy); push @quad_norms, (0,0,-1), (0,0,-1); push @quad_verts, (map unscale($_), @{$line->a}), $bottom_z; push @quad_verts, (map unscale($_), @{$line->b}), $bottom_z; push @quad_norms, (0,0,1), (0,0,1); push @quad_verts, (map unscale($_), @{$line->b}), $top_z; push @quad_verts, (map unscale($_), @{$line->a}), $top_z; # We'll use this for the middle normal when using 4 quads: #my $xy_normal = $line->normal; #$_xynormal->scale(1/$line->length); } } } } } my $obb = $object->bounding_box; my $bb = Slic3r::Geometry::BoundingBoxf3->new; $bb->merge_point(Slic3r::Pointf3->new_unscale(@{$obb->min_point}, 0)); $bb->merge_point(Slic3r::Pointf3->new_unscale(@{$obb->max_point}, $object->size->z)); push @{$self->volumes}, my $v = Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[0], verts => OpenGL::Array->new_list(GL_FLOAT, @verts), norms => OpenGL::Array->new_list(GL_FLOAT, @norms), quad_verts => OpenGL::Array->new_list(GL_FLOAT, @quad_verts), quad_norms => OpenGL::Array->new_list(GL_FLOAT, @quad_norms), ); } # Create 3D thick extrusion lines for a skirt and brim. # Adds a new Slic3r::GUI::3DScene::Volume to $self->volumes. sub load_print_toolpaths { my ($self, $print) = @_; return if !$print->step_done(STEP_SKIRT); return if !$print->step_done(STEP_BRIM); return if !$print->has_skirt && $print->config->brim_width == 0; my $qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $offsets = []; # triples stored in a linear array, sorted by print_z: print_z, qverts, tverts my $skirt_height = 0; # number of layers if ($print->has_infinite_skirt) { $skirt_height = $print->total_layer_count; } else { $skirt_height = min($print->config->skirt_height, $print->total_layer_count); } $skirt_height ||= 1 if $print->config->brim_width > 0; # get first $skirt_height layers (maybe this should be moved to a PrintObject method?) my $object0 = $print->get_object(0); my @layers = (); push @layers, map $object0->get_layer($_-1), 1..min($skirt_height, $object0->layer_count); push @layers, map $object0->get_support_layer($_-1), 1..min($skirt_height, $object0->support_layer_count); @layers = sort { $a->print_z <=> $b->print_z } @layers; @layers = @layers[0..($skirt_height-1)]; foreach my $i (0..($skirt_height-1)) { my $top_z = $layers[$i]->print_z; push @$offsets, ($top_z, $qverts->size, $tverts->size); if ($i == 0) { $self->_extrusionentity_to_verts($print->brim, $top_z, Slic3r::Point->new(0,0), $qverts, $tverts); } $self->_extrusionentity_to_verts($print->skirt, $top_z, Slic3r::Point->new(0,0), $qverts, $tverts); } my $bb = Slic3r::Geometry::BoundingBoxf3->new; { my $pbb = $print->bounding_box; $bb->merge_point(Slic3r::Pointf3->new_unscale(@{$pbb->min_point})); $bb->merge_point(Slic3r::Pointf3->new_unscale(@{$pbb->max_point})); } push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[2], qverts => $qverts, tverts => $tverts, offsets => $offsets, ); } # Create 3D thick extrusion lines for object forming extrusions. # Adds a new Slic3r::GUI::3DScene::Volume to $self->volumes, # one for perimeters, one for infill and one for supports. sub load_print_object_toolpaths { my ($self, $object) = @_; my $perim_qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $perim_tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $infill_qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $infill_tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $support_qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $support_tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; my $perim_offsets = []; # triples of (print_z, qverts, tverts), stored linearly, sorted by print_z my $infill_offsets = []; my $support_offsets = []; # order layers by print_z my @layers = sort { $a->print_z <=> $b->print_z } @{$object->layers}, @{$object->support_layers}; # Bounding box of the object and its copies. my $bb = Slic3r::Geometry::BoundingBoxf3->new; { my $obb = $object->bounding_box; foreach my $copy (@{ $object->_shifted_copies }) { my $cbb = $obb->clone; $cbb->translate(@$copy); $bb->merge_point(Slic3r::Pointf3->new_unscale(@{$cbb->min_point}, 0)); $bb->merge_point(Slic3r::Pointf3->new_unscale(@{$cbb->max_point}, $object->size->z)); } } # Maximum size of an allocation block: 32MB / sizeof(float) my $alloc_size_max = 32 * 1048576 / 4; foreach my $layer (@layers) { my $top_z = $layer->print_z; push @$perim_offsets, ($top_z, $perim_qverts->size, $perim_tverts->size) if (!@$perim_offsets || $perim_offsets->[-3] != $top_z); push @$infill_offsets, ($top_z, $infill_qverts->size, $infill_tverts->size) if (!@$infill_offsets || $infill_offsets->[-3] != $top_z); push @$support_offsets, ($top_z, $support_qverts->size, $support_tverts->size) if (!@$support_offsets || $support_offsets->[-3] != $top_z); foreach my $copy (@{ $object->_shifted_copies }) { foreach my $layerm (@{$layer->regions}) { if ($object->step_done(STEP_PERIMETERS)) { $self->_extrusionentity_to_verts($layerm->perimeters, $top_z, $copy, $perim_qverts, $perim_tverts); } if ($object->step_done(STEP_INFILL)) { $self->_extrusionentity_to_verts($layerm->fills, $top_z, $copy, $infill_qverts, $infill_tverts); } } if ($layer->isa('Slic3r::Layer::Support') && $object->step_done(STEP_SUPPORTMATERIAL)) { $self->_extrusionentity_to_verts($layer->support_fills, $top_z, $copy, $support_qverts, $support_tverts); $self->_extrusionentity_to_verts($layer->support_interface_fills, $top_z, $copy, $support_qverts, $support_tverts); } } if ($perim_qverts->size() > $alloc_size_max || $perim_tverts->size() > $alloc_size_max) { # Store the vertex arrays and restart their containers. push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[0], qverts => $perim_qverts, tverts => $perim_tverts, offsets => $perim_offsets, ); $perim_qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; $perim_tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; $perim_offsets = []; } if ($infill_qverts->size() > $alloc_size_max || $infill_tverts->size() > $alloc_size_max) { # Store the vertex arrays and restart their containers. push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[1], qverts => $infill_qverts, tverts => $infill_tverts, offsets => $infill_offsets, ); $infill_qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; $infill_tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; $infill_offsets = []; } if ($support_qverts->size() > $alloc_size_max || $support_tverts->size() > $alloc_size_max) { # Store the vertex arrays and restart their containers. push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[2], qverts => $support_qverts, tverts => $support_tverts, offsets => $support_offsets, ); $support_qverts = Slic3r::GUI::_3DScene::GLVertexArray->new; $support_tverts = Slic3r::GUI::_3DScene::GLVertexArray->new; $support_offsets = []; } } if ($perim_qverts->size() > 0 || $perim_tverts->size() > 0) { push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[0], qverts => $perim_qverts, tverts => $perim_tverts, offsets => $perim_offsets, ); } if ($infill_qverts->size() > 0 || $infill_tverts->size() > 0) { push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[1], qverts => $infill_qverts, tverts => $infill_tverts, offsets => $infill_offsets, ); } if ($support_qverts->size() > 0 || $support_tverts->size() > 0) { push @{$self->volumes}, Slic3r::GUI::3DScene::Volume->new( bounding_box => $bb, color => COLORS->[2], qverts => $support_qverts, tverts => $support_tverts, offsets => $support_offsets, ); } } sub set_toolpaths_range { my ($self, $min_z, $max_z) = @_; foreach my $volume (@{$self->volumes}) { $volume->range([ $min_z, $max_z ]); } } # called by load_print_object_slices, probably not used. sub _expolygons_to_verts { my ($self, $expolygons, $z, $verts, $norms) = @_; my $tess = gluNewTess(); gluTessCallback($tess, GLU_TESS_BEGIN, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_END, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_VERTEX, sub { my ($x, $y, $z) = @_; push @$verts, $x, $y, $z; push @$norms, (0,0,1), (0,0,1), (0,0,1); }); gluTessCallback($tess, GLU_TESS_COMBINE, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_ERROR, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_EDGE_FLAG, 'DEFAULT'); foreach my $expolygon (@$expolygons) { gluTessBeginPolygon($tess); foreach my $polygon (@$expolygon) { gluTessBeginContour($tess); gluTessVertex_p($tess, (map unscale($_), @$_), $z) for @$polygon; gluTessEndContour($tess); } gluTessEndPolygon($tess); } gluDeleteTess($tess); } # Fill in the $qverts and $tverts with quads and triangles # for the extrusion $entity. sub _extrusionentity_to_verts { my ($self, $entity, $top_z, $copy, $qverts, $tverts) = @_; my ($lines, $widths, $heights, $closed); if ($entity->isa('Slic3r::ExtrusionPath::Collection')) { $self->_extrusionentity_to_verts($_, $top_z, $copy, $qverts, $tverts) for @$entity; return; } elsif ($entity->isa('Slic3r::ExtrusionPath')) { my $polyline = $entity->polyline->clone; $polyline->remove_duplicate_points; $polyline->translate(@$copy); $lines = $polyline->lines; $widths = [ map $entity->width, 0..$#$lines ]; $heights = [ map $entity->height, 0..$#$lines ]; $closed = 0; } else { $lines = []; $widths = []; $heights = []; $closed = 1; foreach my $path (@$entity) { my $polyline = $path->polyline->clone; $polyline->remove_duplicate_points; $polyline->translate(@$copy); my $path_lines = $polyline->lines; push @$lines, @$path_lines; push @$widths, map $path->width, 0..$#$path_lines; push @$heights, map $path->height, 0..$#$path_lines; } } # Calling the C++ implementation Slic3r::_3DScene::_extrusionentity_to_verts_do() # This adds new vertices to the $qverts and $tverts. Slic3r::GUI::_3DScene::_extrusionentity_to_verts_do($lines, $widths, $heights, $closed, # Top height of the extrusion. $top_z, # $copy is not used here. $copy, # GLVertexArray object: C++ class maintaining an std::vector for coords and normals. $qverts, $tverts); } sub object_idx { my ($self, $volume_idx) = @_; return $self->_objects_by_volumes->{$volume_idx}[0]; } sub volume_idx { my ($self, $volume_idx) = @_; return $self->_objects_by_volumes->{$volume_idx}[1]; } sub instance_idx { my ($self, $volume_idx) = @_; return $self->_objects_by_volumes->{$volume_idx}[2]; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/AboutDialog.pm000066400000000000000000000104341301441720000215610ustar00rootroot00000000000000package Slic3r::GUI::AboutDialog; use strict; use warnings; use utf8; use Wx qw(:font :html :misc :dialog :sizer :systemsettings :frame :id); use Wx::Event qw(EVT_HTML_LINK_CLICKED EVT_LEFT_DOWN EVT_BUTTON); use Wx::Print; use Wx::Html; use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, -1, 'About Slic3r', wxDefaultPosition, [600, 340], wxCAPTION); $self->SetBackgroundColour(Wx::wxWHITE); my $hsizer = Wx::BoxSizer->new(wxHORIZONTAL); $self->SetSizer($hsizer); # logo my $logo = Slic3r::GUI::AboutDialog::Logo->new($self, -1, wxDefaultPosition, wxDefaultSize); $logo->SetBackgroundColour(Wx::wxWHITE); $hsizer->Add($logo, 0, wxEXPAND | wxLEFT | wxRIGHT, 30); my $vsizer = Wx::BoxSizer->new(wxVERTICAL); $hsizer->Add($vsizer, 1, wxEXPAND, 0); # title my $title = Wx::StaticText->new($self, -1, $Slic3r::FORK_NAME, wxDefaultPosition, wxDefaultSize); my $title_font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $title_font->SetWeight(wxFONTWEIGHT_BOLD); $title_font->SetFamily(wxFONTFAMILY_ROMAN); $title_font->SetPointSize(24); $title->SetFont($title_font); $vsizer->Add($title, 0, wxALIGN_LEFT | wxTOP, 30); # version my $version = Wx::StaticText->new($self, -1, "Version $Slic3r::VERSION", wxDefaultPosition, wxDefaultSize); my $version_font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $version_font->SetPointSize(&Wx::wxMSW ? 9 : 11); $version->SetFont($version_font); $vsizer->Add($version, 0, wxALIGN_LEFT | wxBOTTOM, 10); # text my $text = '' . '' . '' . 'Copyright © 2016 Vojtech Bubnik, Prusa Research.
' . 'Copyright © 2011-2016 Alessandro Ranellucci.
' . 'Slic3r is licensed under the ' . 'GNU Affero General Public License, version 3.' . '


' . 'Contributions by Henrik Brix Andersen, Nicolas Dandrimont, Mark Hindess, Petr Ledvina, Y. Sapir, Mike Sheldrake and numerous others. ' . 'Manual by Gary Hodgson. Inspired by the RepRap community.
' . 'Slic3r logo designed by Corey Daniels, Silk Icon Set designed by Mark James. ' . '' . '' . ''; my $html = Wx::HtmlWindow->new($self, -1, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_NEVER); my $font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); my $size = &Wx::wxMSW ? 8 : 10; $html->SetFonts($font->GetFaceName, $font->GetFaceName, [$size, $size, $size, $size, $size, $size, $size]); $html->SetBorders(2); $html->SetPage($text); $vsizer->Add($html, 1, wxEXPAND | wxALIGN_LEFT | wxRIGHT | wxBOTTOM, 20); EVT_HTML_LINK_CLICKED($self, $html, \&link_clicked); my $buttons = $self->CreateStdDialogButtonSizer(wxOK); $self->SetEscapeId(wxID_CLOSE); EVT_BUTTON($self, wxID_CLOSE, sub { $self->EndModal(wxID_CLOSE); $self->Close; }); $vsizer->Add($buttons, 0, wxEXPAND | wxRIGHT | wxBOTTOM, 3); EVT_LEFT_DOWN($self, sub { $self->Close }); EVT_LEFT_DOWN($logo, sub { $self->Close }); return $self; } sub link_clicked { my ($self, $event) = @_; Wx::LaunchDefaultBrowser($event->GetLinkInfo->GetHref); $event->Skip(0); } package Slic3r::GUI::AboutDialog::Logo; use Wx qw(:bitmap :dc); use Wx::Event qw(EVT_PAINT); use base 'Wx::Panel'; sub new { my $class = shift; my $self = $class->SUPER::new(@_); $self->{logo} = Wx::Bitmap->new($Slic3r::var->("Slic3r_192px.png"), wxBITMAP_TYPE_PNG); $self->SetMinSize(Wx::Size->new($self->{logo}->GetWidth, $self->{logo}->GetHeight)); EVT_PAINT($self, \&repaint); return $self; } sub repaint { my ($self, $event) = @_; my $dc = Wx::PaintDC->new($self); $dc->SetBackgroundMode(wxTRANSPARENT); my $size = $self->GetSize; my $logo_w = $self->{logo}->GetWidth; my $logo_h = $self->{logo}->GetHeight; $dc->DrawBitmap($self->{logo}, ($size->GetWidth - $logo_w) / 2, ($size->GetHeight - $logo_h) / 2, 1); $event->Skip; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/BedShapeDialog.pm000066400000000000000000000252341301441720000221660ustar00rootroot00000000000000# The bed shape dialog. # The dialog opens from Print Settins tab -> Bed Shape: Set... package Slic3r::GUI::BedShapeDialog; use strict; use warnings; use utf8; use List::Util qw(min max); use Slic3r::Geometry qw(PI X Y unscale); use Wx qw(:dialog :id :misc :sizer :choicebook wxTAB_TRAVERSAL); use Wx::Event qw(EVT_CLOSE); use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent, $default) = @_; my $self = $class->SUPER::new($parent, -1, "Bed Shape", wxDefaultPosition, [350,700], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); $self->{panel} = my $panel = Slic3r::GUI::BedShapePanel->new($self, $default); my $main_sizer = Wx::BoxSizer->new(wxVERTICAL); $main_sizer->Add($panel, 1, wxEXPAND); $main_sizer->Add($self->CreateButtonSizer(wxOK | wxCANCEL), 0, wxEXPAND); $self->SetSizer($main_sizer); $self->SetMinSize($self->GetSize); $main_sizer->SetSizeHints($self); # needed to actually free memory EVT_CLOSE($self, sub { $self->EndModal(wxID_OK); $self->Destroy; }); return $self; } sub GetValue { my ($self) = @_; return $self->{panel}->GetValue; } package Slic3r::GUI::BedShapePanel; use List::Util qw(min max sum first); use Scalar::Util qw(looks_like_number); use Slic3r::Geometry qw(PI X Y scale unscale scaled_epsilon deg2rad); use Wx qw(:font :id :misc :sizer :choicebook :filedialog :pen :brush wxTAB_TRAVERSAL); use Wx::Event qw(EVT_CLOSE EVT_CHOICEBOOK_PAGE_CHANGED EVT_BUTTON); use base 'Wx::Panel'; use constant SHAPE_RECTANGULAR => 0; use constant SHAPE_CIRCULAR => 1; use constant SHAPE_CUSTOM => 2; sub new { my $class = shift; my ($parent, $default) = @_; my $self = $class->SUPER::new($parent, -1); $self->on_change(undef); my $box = Wx::StaticBox->new($self, -1, "Shape"); my $sbsizer = Wx::StaticBoxSizer->new($box, wxVERTICAL); # shape options $self->{shape_options_book} = Wx::Choicebook->new($self, -1, wxDefaultPosition, [300,-1], wxCHB_TOP); $sbsizer->Add($self->{shape_options_book}); $self->{optgroups} = []; { my $optgroup = $self->_init_shape_options_page('Rectangular'); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'rect_size', type => 'point', label => 'Size', tooltip => 'Size in X and Y of the rectangular plate.', default => [200,200], )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'rect_origin', type => 'point', label => 'Origin', tooltip => 'Distance of the 0,0 G-code coordinate from the front left corner of the rectangle.', default => [0,0], )); } { my $optgroup = $self->_init_shape_options_page('Circular'); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'diameter', type => 'f', label => 'Diameter', tooltip => 'Diameter of the print bed. It is assumed that origin (0,0) is located in the center.', sidetext => 'mm', default => 200, )); } { my $optgroup = $self->_init_shape_options_page('Custom'); $optgroup->append_line(Slic3r::GUI::OptionsGroup::Line->new( full_width => 1, widget => sub { my ($parent) = @_; my $btn = Wx::Button->new($parent, -1, "Load shape from STL...", wxDefaultPosition, wxDefaultSize); EVT_BUTTON($self, $btn, sub { $self->_load_stl }); return $btn; } )); } EVT_CHOICEBOOK_PAGE_CHANGED($self, -1, sub { $self->_update_shape; }); # right pane with preview canvas my $canvas = $self->{canvas} = Slic3r::GUI::2DBed->new($self); # main sizer my $top_sizer = Wx::BoxSizer->new(wxHORIZONTAL); $top_sizer->Add($sbsizer, 0, wxEXPAND | wxTOP | wxBOTTOM, 10); $top_sizer->Add($canvas, 1, wxEXPAND | wxALL, 10) if $canvas; $self->SetSizerAndFit($top_sizer); $self->_set_shape($default); $self->_update_preview; return $self; } sub on_change { my ($self, $cb) = @_; $self->{on_change} = $cb // sub {}; } # Called from the constructor. # Set the initial bed shape from a list of points. # Deduce the bed shape type (rect, circle, custom) # This routine shall be smart enough if the user messes up # with the list of points in the ini file directly. sub _set_shape { my ($self, $points) = @_; # is this a rectangle? if (@$points == 4) { my $polygon = Slic3r::Polygon->new_scale(@$points); my $lines = $polygon->lines; if ($lines->[0]->parallel_to_line($lines->[2]) && $lines->[1]->parallel_to_line($lines->[3])) { # okay, it's a rectangle # find origin # the || 0 hack prevents "-0" which might confuse the user my $x_min = min(map $_->[X], @$points) || 0; my $x_max = max(map $_->[X], @$points) || 0; my $y_min = min(map $_->[Y], @$points) || 0; my $y_max = max(map $_->[Y], @$points) || 0; my $origin = [-$x_min, -$y_min]; $self->{shape_options_book}->SetSelection(SHAPE_RECTANGULAR); my $optgroup = $self->{optgroups}[SHAPE_RECTANGULAR]; $optgroup->set_value('rect_size', [ $x_max-$x_min, $y_max-$y_min ]); $optgroup->set_value('rect_origin', $origin); $self->_update_shape; return; } } # is this a circle? { # Analyze the array of points. Do they reside on a circle? my $polygon = Slic3r::Polygon->new_scale(@$points); my $center = $polygon->bounding_box->center; my @vertex_distances = map $center->distance_to($_), @$polygon; my $avg_dist = sum(@vertex_distances)/@vertex_distances; if (!defined first { abs($_ - $avg_dist) > 10*scaled_epsilon } @vertex_distances) { # all vertices are equidistant to center $self->{shape_options_book}->SetSelection(SHAPE_CIRCULAR); my $optgroup = $self->{optgroups}[SHAPE_CIRCULAR]; $optgroup->set_value('diameter', sprintf("%.0f", unscale($avg_dist*2))); $self->_update_shape; return; } } if (@$points < 3) { # Invalid polygon. Revert to default bed dimensions. $self->{shape_options_book}->SetSelection(SHAPE_RECTANGULAR); my $optgroup = $self->{optgroups}[SHAPE_RECTANGULAR]; $optgroup->set_value('rect_size', [200, 200]); $optgroup->set_value('rect_origin', [0, 0]); $self->_update_shape; return; } # This is a custom bed shape, use the polygon provided. $self->{shape_options_book}->SetSelection(SHAPE_CUSTOM); # Copy the polygon to the canvas, make a copy of the array. $self->{canvas}->bed_shape([@$points]); $self->_update_shape; } # Update the bed shape from the dialog fields. sub _update_shape { my ($self) = @_; my $page_idx = $self->{shape_options_book}->GetSelection; if ($page_idx == SHAPE_RECTANGULAR) { my $rect_size = $self->{optgroups}[SHAPE_RECTANGULAR]->get_value('rect_size'); my $rect_origin = $self->{optgroups}[SHAPE_RECTANGULAR]->get_value('rect_origin'); my ($x, $y) = @$rect_size; return if !looks_like_number($x) || !looks_like_number($y); # empty strings or '-' or other things my ($x0, $y0) = (0,0); my ($x1, $y1) = ($x,$y); { my ($dx, $dy) = @$rect_origin; return if !looks_like_number($dx) || !looks_like_number($dy); # empty strings or '-' or other things $x0 -= $dx; $x1 -= $dx; $y0 -= $dy; $y1 -= $dy; } $self->{canvas}->bed_shape([ [$x0,$y0], [$x1,$y0], [$x1,$y1], [$x0,$y1], ]); } elsif ($page_idx == SHAPE_CIRCULAR) { my $diameter = $self->{optgroups}[SHAPE_CIRCULAR]->get_value('diameter'); return if !$diameter; my $r = $diameter/2; my $twopi = 2*PI; my $edges = 60; my $polygon = Slic3r::Polygon->new_scale( map [ $r * cos $_, $r * sin $_ ], map { $twopi/$edges*$_ } 1..$edges ); $self->{canvas}->bed_shape([ map [ unscale($_->x), unscale($_->y) ], @$polygon #)) ]); } $self->{on_change}->(); $self->_update_preview; } sub _update_preview { my ($self) = @_; $self->{canvas}->Refresh if $self->{canvas}; $self->Refresh; } # Called from the constructor. # Create a panel for a rectangular / circular / custom bed shape. sub _init_shape_options_page { my ($self, $title) = @_; my $panel = Wx::Panel->new($self->{shape_options_book}); my $optgroup; push @{$self->{optgroups}}, $optgroup = Slic3r::GUI::OptionsGroup->new( parent => $panel, title => 'Settings', label_width => 100, on_change => sub { my ($opt_id) = @_; #$self->{"_$opt_id"} = $optgroup->get_value($opt_id); $self->_update_shape; }, ); $panel->SetSizerAndFit($optgroup->sizer); $self->{shape_options_book}->AddPage($panel, $title); return $optgroup; } # Loads an stl file, projects it to the XY plane and calculates a polygon. sub _load_stl { my ($self) = @_; my $dialog = Wx::FileDialog->new($self, 'Choose a file to import bed shape from (STL/OBJ/AMF):', "", "", &Slic3r::GUI::MODEL_WILDCARD, wxFD_OPEN | wxFD_FILE_MUST_EXIST); if ($dialog->ShowModal != wxID_OK) { $dialog->Destroy; return; } my $input_file = Slic3r::decode_path($dialog->GetPaths); $dialog->Destroy; my $model = Slic3r::Model->read_from_file($input_file); my $mesh = $model->raw_mesh; my $expolygons = $mesh->horizontal_projection; if (@$expolygons == 0) { Slic3r::GUI::show_error($self, "The selected file contains no geometry."); return; } if (@$expolygons > 1) { Slic3r::GUI::show_error($self, "The selected file contains several disjoint areas. This is not supported."); return; } my $polygon = $expolygons->[0]->contour; $self->{canvas}->bed_shape([ map [ unscale($_->x), unscale($_->y) ], @$polygon ]); $self->_update_preview(); } # Returns the resulting bed shape polygon. This value will be stored to the ini file. sub GetValue { my ($self) = @_; return $self->{canvas}->bed_shape; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/BonjourBrowser.pm000066400000000000000000000030071301441720000223470ustar00rootroot00000000000000# A tiny dialog to select an OctoPrint device to print to. package Slic3r::GUI::BonjourBrowser; use strict; use warnings; use utf8; use Wx qw(:dialog :id :misc :sizer :choicebook wxTAB_TRAVERSAL); use Wx::Event qw(EVT_CLOSE); use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent, $devices) = @_; my $self = $class->SUPER::new($parent, -1, "Device Browser", wxDefaultPosition, [350,700], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); $self->{devices} = $devices; # label my $text = Wx::StaticText->new($self, -1, "Choose an OctoPrint device in your network:", wxDefaultPosition, wxDefaultSize); # selector $self->{choice} = my $choice = Wx::Choice->new($self, -1, wxDefaultPosition, wxDefaultSize, [ map $_->name, @{$self->{devices}} ]); my $main_sizer = Wx::BoxSizer->new(wxVERTICAL); $main_sizer->Add($text, 1, wxEXPAND | wxALL, 10); $main_sizer->Add($choice, 1, wxEXPAND | wxALL, 10); $main_sizer->Add($self->CreateButtonSizer(wxOK | wxCANCEL), 0, wxEXPAND); $self->SetSizer($main_sizer); $self->SetMinSize($self->GetSize); $main_sizer->SetSizeHints($self); # needed to actually free memory EVT_CLOSE($self, sub { $self->EndModal(wxID_OK); $self->Destroy; }); return $self; } sub GetValue { my ($self) = @_; return $self->{devices}[ $self->{choice}->GetSelection ]->address; } sub GetPort { my ($self) = @_; return $self->{devices}[ $self->{choice}->GetSelection ]->port; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/ConfigWizard.pm000066400000000000000000000277451301441720000217720ustar00rootroot00000000000000# The config wizard is executed when the Slic3r is first started. # The wizard helps the user to specify the 3D printer properties. package Slic3r::GUI::ConfigWizard; use strict; use warnings; use utf8; use Wx; use base 'Wx::Wizard'; use Slic3r::Geometry qw(unscale); # adhere to various human interface guidelines our $wizard = 'Wizard'; $wizard = 'Assistant' if &Wx::wxMAC || &Wx::wxGTK; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, -1, "Configuration $wizard"); # initialize an empty repository $self->{config} = Slic3r::Config->new; $self->add_page(Slic3r::GUI::ConfigWizard::Page::Welcome->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::Firmware->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::Bed->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::Nozzle->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::Filament->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::Temperature->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::BedTemperature->new($self)); $self->add_page(Slic3r::GUI::ConfigWizard::Page::Finished->new($self)); $_->build_index for @{$self->{pages}}; return $self; } sub add_page { my $self = shift; my ($page) = @_; my $n = push @{$self->{pages}}, $page; # add first page to the page area sizer $self->GetPageAreaSizer->Add($page) if $n == 1; # link pages $self->{pages}[$n-2]->set_next_page($page) if $n >= 2; $page->set_previous_page($self->{pages}[$n-2]) if $n >= 2; } sub run { my $self = shift; if (Wx::Wizard::RunWizard($self, $self->{pages}[0])) { # it would be cleaner to have these defined inside each page class, # in some event getting called before leaving the page { # set first_layer_height + layer_height based on nozzle_diameter my $nozzle = $self->{config}->nozzle_diameter; $self->{config}->set('first_layer_height', $nozzle->[0]); $self->{config}->set('layer_height', $nozzle->[0] - 0.1); # set first_layer_temperature to temperature + 5 $self->{config}->set('first_layer_temperature', [$self->{config}->temperature->[0] + 5]); # set first_layer_bed_temperature to temperature + 5 $self->{config}->set('first_layer_bed_temperature', ($self->{config}->bed_temperature > 0) ? ($self->{config}->bed_temperature + 5) : 0); } $self->Destroy; return $self->{config}; } else { $self->Destroy; return undef; } } package Slic3r::GUI::ConfigWizard::Index; use Wx qw(:bitmap :dc :font :misc :sizer :systemsettings :window); use Wx::Event qw(EVT_ERASE_BACKGROUND EVT_PAINT); use base 'Wx::Panel'; sub new { my $class = shift; my ($parent, $title) = @_; my $self = $class->SUPER::new($parent); push @{$self->{titles}}, $title; $self->{own_index} = 0; $self->{bullets}->{before} = Wx::Bitmap->new($Slic3r::var->("bullet_black.png"), wxBITMAP_TYPE_PNG); $self->{bullets}->{own} = Wx::Bitmap->new($Slic3r::var->("bullet_blue.png"), wxBITMAP_TYPE_PNG); $self->{bullets}->{after} = Wx::Bitmap->new($Slic3r::var->("bullet_white.png"), wxBITMAP_TYPE_PNG); $self->{background} = Wx::Bitmap->new($Slic3r::var->("Slic3r_192px_transparent.png"), wxBITMAP_TYPE_PNG); $self->SetMinSize(Wx::Size->new($self->{background}->GetWidth, $self->{background}->GetHeight)); EVT_PAINT($self, \&repaint); return $self; } sub repaint { my ($self, $event) = @_; my $size = $self->GetClientSize; my $gap = 5; my $dc = Wx::PaintDC->new($self); $dc->SetBackgroundMode(wxTRANSPARENT); $dc->SetFont($self->GetFont); $dc->SetTextForeground($self->GetForegroundColour); my $background_h = $self->{background}->GetHeight; my $background_w = $self->{background}->GetWidth; $dc->DrawBitmap($self->{background}, ($size->GetWidth - $background_w) / 2, ($size->GetHeight - $background_h) / 2, 1); my $label_h = $self->{bullets}->{own}->GetHeight; $label_h = $dc->GetCharHeight if $dc->GetCharHeight > $label_h; my $label_w = $size->GetWidth; my $i = 0; foreach (@{$self->{titles}}) { my $bullet = $self->{bullets}->{own}; $bullet = $self->{bullets}->{before} if $i < $self->{own_index}; $bullet = $self->{bullets}->{after} if $i > $self->{own_index}; $dc->SetTextForeground(Wx::Colour->new(128, 128, 128)) if $i > $self->{own_index}; $dc->DrawLabel($_, $bullet, Wx::Rect->new(0, $i * ($label_h + $gap), $label_w, $label_h)); $i++; } $event->Skip; } sub prepend_title { my $self = shift; my ($title) = @_; unshift @{$self->{titles}}, $title; $self->{own_index}++; $self->Refresh; } sub append_title { my $self = shift; my ($title) = @_; push @{$self->{titles}}, $title; $self->Refresh; } package Slic3r::GUI::ConfigWizard::Page; use Wx qw(:font :misc :sizer :staticline :systemsettings); use base 'Wx::WizardPage'; sub new { my $class = shift; my ($parent, $title, $short_title) = @_; my $self = $class->SUPER::new($parent); my $sizer = Wx::FlexGridSizer->new(0, 2, 10, 10); $sizer->AddGrowableCol(1, 1); $sizer->AddGrowableRow(1, 1); $sizer->AddStretchSpacer(0); $self->SetSizer($sizer); # title my $text = Wx::StaticText->new($self, -1, $title, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT); my $bold_font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $bold_font->SetWeight(wxFONTWEIGHT_BOLD); $bold_font->SetPointSize(14); $text->SetFont($bold_font); $sizer->Add($text, 0, wxALIGN_LEFT, 0); # index $self->{short_title} = $short_title ? $short_title : $title; $self->{index} = Slic3r::GUI::ConfigWizard::Index->new($self, $self->{short_title}); $sizer->Add($self->{index}, 1, wxEXPAND | wxTOP | wxRIGHT, 10); # contents $self->{width} = 430; $self->{vsizer} = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($self->{vsizer}, 1); return $self; } sub append_text { my $self = shift; my ($text) = @_; my $para = Wx::StaticText->new($self, -1, $text, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT); $para->Wrap($self->{width}); $para->SetMinSize([$self->{width}, -1]); $self->{vsizer}->Add($para, 0, wxALIGN_LEFT | wxTOP | wxBOTTOM, 10); } sub append_option { my $self = shift; my ($full_key) = @_; # populate repository with the factory default my ($opt_key, $opt_index) = split /#/, $full_key, 2; $self->config->apply(Slic3r::Config->new_from_defaults($opt_key)); # draw the control my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new( parent => $self, title => '', config => $self->config, full_labels => 1, ); $optgroup->append_single_option_line($opt_key, $opt_index); $self->{vsizer}->Add($optgroup->sizer, 0, wxEXPAND | wxTOP | wxBOTTOM, 10); } sub append_panel { my ($self, $panel) = @_; $self->{vsizer}->Add($panel, 0, wxEXPAND | wxTOP | wxBOTTOM, 10); } sub set_previous_page { my $self = shift; my ($previous_page) = @_; $self->{previous_page} = $previous_page; } sub GetPrev { my $self = shift; return $self->{previous_page}; } sub set_next_page { my $self = shift; my ($next_page) = @_; $self->{next_page} = $next_page; } sub GetNext { my $self = shift; return $self->{next_page}; } sub get_short_title { my $self = shift; return $self->{short_title}; } sub build_index { my $self = shift; my $page = $self; $self->{index}->prepend_title($page->get_short_title) while ($page = $page->GetPrev); $page = $self; $self->{index}->append_title($page->get_short_title) while ($page = $page->GetNext); } sub config { my ($self) = @_; return $self->GetParent->{config}; } package Slic3r::GUI::ConfigWizard::Page::Welcome; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, "Welcome to the Slic3r Configuration $wizard", 'Welcome'); $self->append_text('Hello, welcome to Slic3r! This '.lc($wizard).' helps you with the initial configuration; just a few settings and you will be ready to print.'); $self->append_text('To import an existing configuration instead, cancel this '.lc($wizard).' and use the Open Config menu item found in the File menu.'); $self->append_text('To continue, click Next.'); return $self; } package Slic3r::GUI::ConfigWizard::Page::Firmware; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Firmware Type'); $self->append_text('Choose the type of firmware used by your printer, then click Next.'); $self->append_option('gcode_flavor'); return $self; } package Slic3r::GUI::ConfigWizard::Page::Bed; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Bed Size'); $self->append_text('Set the shape of your printer\'s bed, then click Next.'); $self->config->apply(Slic3r::Config->new_from_defaults('bed_shape')); $self->{bed_shape_panel} = my $panel = Slic3r::GUI::BedShapePanel->new($self, $self->config->bed_shape); $self->{bed_shape_panel}->on_change(sub { $self->config->set('bed_shape', $self->{bed_shape_panel}->GetValue); }); $self->append_panel($self->{bed_shape_panel}); return $self; } package Slic3r::GUI::ConfigWizard::Page::Nozzle; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Nozzle Diameter'); $self->append_text('Enter the diameter of your printer\'s hot end nozzle, then click Next.'); $self->append_option('nozzle_diameter#0'); return $self; } package Slic3r::GUI::ConfigWizard::Page::Filament; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Filament Diameter'); $self->append_text('Enter the diameter of your filament, then click Next.'); $self->append_text('Good precision is required, so use a caliper and do multiple measurements along the filament, then compute the average.'); $self->append_option('filament_diameter#0'); return $self; } package Slic3r::GUI::ConfigWizard::Page::Temperature; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Extrusion Temperature'); $self->append_text('Enter the temperature needed for extruding your filament, then click Next.'); $self->append_text('A rule of thumb is 160 to 230 °C for PLA, and 215 to 250 °C for ABS.'); $self->append_option('temperature#0'); return $self; } package Slic3r::GUI::ConfigWizard::Page::BedTemperature; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Bed Temperature'); $self->append_text('Enter the bed temperature needed for getting your filament to stick to your heated bed, then click Next.'); $self->append_text('A rule of thumb is 60 °C for PLA and 110 °C for ABS. Leave zero if you have no heated bed.'); $self->append_option('bed_temperature'); return $self; } package Slic3r::GUI::ConfigWizard::Page::Finished; use base 'Slic3r::GUI::ConfigWizard::Page'; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, 'Congratulations!', 'Finish'); $self->append_text("You have successfully completed the Slic3r Configuration $wizard. " . 'Slic3r is now configured for your printer and filament.'); $self->append_text('To close this '.lc($wizard).' and apply the newly created configuration, click Finish.'); return $self; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Controller.pm000066400000000000000000000153371301441720000215210ustar00rootroot00000000000000# The "Controller" tab to control the printer using serial / USB. # This feature is rarely used. Much more often, the firmware reads the G-codes from a SD card. # May there be multiple subtabs per each printer connected? package Slic3r::GUI::Controller; use strict; use warnings; use utf8; use Wx qw(wxTheApp :frame :id :misc :sizer :bitmap :button :icon :dialog); use Wx::Event qw(EVT_CLOSE EVT_LEFT_DOWN EVT_MENU); use base qw(Wx::ScrolledWindow Class::Accessor); __PACKAGE__->mk_accessors(qw(_selected_printer_preset)); our @ConfigOptions = qw(bed_shape serial_port serial_speed); sub new { my ($class, $parent) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, [600,350]); $self->SetScrollbars(0, 1, 0, 1); $self->{sizer} = my $sizer = Wx::BoxSizer->new(wxVERTICAL); # warning to show when there are no printers configured { $self->{text_no_printers} = Wx::StaticText->new($self, -1, "No printers were configured for USB/serial control.", wxDefaultPosition, wxDefaultSize); $self->{sizer}->Add($self->{text_no_printers}, 0, wxTOP | wxLEFT, 30); } # button for adding new printer panels { my $btn = $self->{btn_add} = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("add.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, Wx::wxBORDER_NONE); $btn->SetToolTipString("Add printer…") if $btn->can('SetToolTipString'); EVT_LEFT_DOWN($btn, sub { my $menu = Wx::Menu->new; my %presets = wxTheApp->presets('printer'); # remove printers that already exist my @panels = $self->print_panels; delete $presets{$_} for map $_->printer_name, @panels; foreach my $preset_name (sort keys %presets) { my $config = Slic3r::Config->load($presets{$preset_name}); next if !$config->serial_port; my $id = &Wx::NewId(); $menu->Append($id, $preset_name); EVT_MENU($menu, $id, sub { $self->add_printer($preset_name, $config); }); } $self->PopupMenu($menu, $btn->GetPosition); $menu->Destroy; }); $self->{sizer}->Add($btn, 0, wxTOP | wxLEFT, 10); } $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); #$sizer->SetSizeHints($self); EVT_CLOSE($self, sub { my (undef, $event) = @_; if ($event->CanVeto) { foreach my $panel ($self->print_panels) { if ($panel->printing) { my $confirm = Wx::MessageDialog->new( $self, "Printer '" . $panel->printer_name . "' is printing.\n\nDo you want to stop printing?", 'Unfinished Print', wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION, ); if ($confirm->ShowModal == wxID_NO) { $event->Veto; return; } } } } foreach my $panel ($self->print_panels) { $panel->disconnect; } $event->Skip; }); $self->Layout; return $self; } sub OnActivate { my ($self) = @_; # get all available presets my %presets = (); { my %all = wxTheApp->presets('printer'); my %configs = map { my $name = $_; $name => Slic3r::Config->load($all{$name}) } keys %all; %presets = map { $_ => $configs{$_} } grep $configs{$_}->serial_port, keys %all; } # decide which ones we want to keep my %active = (); # keep the ones that are currently connected or have jobs in queue $active{$_} = 1 for map $_->printer_name, grep { $_->is_connected || @{$_->jobs} > 0 } $self->print_panels; if (%presets) { # if there are no active panels, use sensible defaults if (!%active && keys %presets <= 2) { # if only one or two presets exist, load them $active{$_} = 1 for keys %presets; } if (!%active) { # enable printers whose port is available my %ports = map { $_ => 1 } wxTheApp->scan_serial_ports; $active{$_} = 1 for grep exists $ports{$presets{$_}->serial_port}, keys %presets; } if (!%active && $self->_selected_printer_preset) { # enable currently selected printer if it is configured $active{$self->_selected_printer_preset} = 1 if $presets{$self->_selected_printer_preset}; } } # apply changes for my $panel ($self->print_panels) { next if $active{$panel->printer_name}; $self->{sizer}->DetachWindow($panel); $panel->Destroy; } $self->add_printer($_, $presets{$_}) for sort keys %active; # show/hide the warning about no printers $self->{text_no_printers}->Show(!%presets); # show/hide the Add button $self->{btn_add}->Show(keys %presets != keys %active); $self->Layout; # we need this in order to trigger the OnSize event of wxScrolledWindow which # recalculates the virtual size Wx::GetTopLevelParent($self)->SendSizeEvent; } sub add_printer { my ($self, $printer_name, $config) = @_; # check that printer doesn't exist already foreach my $panel ($self->print_panels) { if ($panel->printer_name eq $printer_name) { return $panel; } } my $printer_panel = Slic3r::GUI::Controller::PrinterPanel->new($self, $printer_name, $config); $self->{sizer}->Prepend($printer_panel, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 10); $self->Layout; return $printer_panel; } sub print_panels { my ($self) = @_; return grep $_->isa('Slic3r::GUI::Controller::PrinterPanel'), map $_->GetWindow, $self->{sizer}->GetChildren; } # Called by # Slic3r::GUI::Tab::Print::_on_presets_changed # Slic3r::GUI::Tab::Filament::_on_presets_changed # Slic3r::GUI::Tab::Printer::_on_presets_changed # when the presets are loaded or the user select another preset. sub update_presets { my $self = shift; my ($group, $presets, $default_suppressed, $selected, $is_dirty) = @_; # update configs of currently loaded print panels foreach my $panel ($self->print_panels) { foreach my $preset (@$presets) { if ($panel->printer_name eq $preset->name) { my $config = $preset->config(\@ConfigOptions); $panel->config->apply($config); } } } $self->_selected_printer_preset($presets->[$selected]->name); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Controller/000077500000000000000000000000001301441720000211525ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/GUI/Controller/ManualControlDialog.pm000066400000000000000000000147041301441720000254140ustar00rootroot00000000000000# A printer "Controller" -> "ManualControlDialog" subtab, opened per 3D printer connected? package Slic3r::GUI::Controller::ManualControlDialog; use strict; use warnings; use utf8; use Slic3r::Geometry qw(PI X Y unscale); use Wx qw(:dialog :id :misc :sizer :choicebook :button :bitmap wxBORDER_NONE wxTAB_TRAVERSAL); use Wx::Event qw(EVT_CLOSE EVT_BUTTON); use base qw(Wx::Dialog Class::Accessor); __PACKAGE__->mk_accessors(qw(sender config2 x_homed y_homed)); sub new { my ($class, $parent, $config, $sender) = @_; my $self = $class->SUPER::new($parent, -1, "Manual Control", wxDefaultPosition, [500,380], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); $self->sender($sender); $self->config2({ xy_travel_speed => 130, z_travel_speed => 10, }); my $bed_sizer = Wx::FlexGridSizer->new(2, 3, 1, 1); $bed_sizer->AddGrowableCol(1, 1); $bed_sizer->AddGrowableRow(0, 1); my $move_button = sub { my ($sizer, $label, $icon, $bold, $pos, $handler) = @_; my $btn = Wx::Button->new($self, -1, $label, wxDefaultPosition, wxDefaultSize, wxBU_LEFT | wxBU_EXACTFIT); $btn->SetFont($bold ? $Slic3r::GUI::small_bold_font : $Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("$icon.png"), wxBITMAP_TYPE_PNG)); $btn->SetBitmapPosition($pos); } EVT_BUTTON($self, $btn, $handler); $sizer->Add($btn, 1, wxEXPAND | wxALL, 0); }; # Y buttons { my $sizer = Wx::BoxSizer->new(wxVERTICAL); for my $d (qw(+10 +1 +0.1)) { $move_button->($sizer, $d, 'arrow_up', 0, wxLEFT, sub { $self->rel_move('Y', $d) }); } $move_button->($sizer, 'Y', 'house', 1, wxLEFT, sub { $self->home('Y') }); for my $d (qw(-0.1 -1 -10)) { $move_button->($sizer, $d, 'arrow_down', 0, wxLEFT, sub { $self->rel_move('Y', $d) }); }; $bed_sizer->Add($sizer, 1, wxEXPAND, 0); } # Bed canvas { my $bed_shape = $config->bed_shape; $self->{canvas} = my $canvas = Slic3r::GUI::2DBed->new($self, $bed_shape); $canvas->interactive(1); $canvas->on_move(sub { my ($pos) = @_; if (!($self->x_homed && $self->y_homed)) { Slic3r::GUI::show_error($self, "Please home both X and Y before moving."); return ; } # delete any pending commands to get a smoother movement $self->sender->purge_queue(1); $self->abs_xy_move($pos); }); $bed_sizer->Add($canvas, 0, wxEXPAND | wxRIGHT, 3); } # Z buttons { my $sizer = Wx::BoxSizer->new(wxVERTICAL); for my $d (qw(+10 +1 +0.1)) { $move_button->($sizer, $d, 'arrow_up', 0, wxLEFT, sub { $self->rel_move('Z', $d) }); } $move_button->($sizer, 'Z', 'house', 1, wxLEFT, sub { $self->home('Z') }); for my $d (qw(-0.1 -1 -10)) { $move_button->($sizer, $d, 'arrow_down', 0, wxLEFT, sub { $self->rel_move('Z', $d) }); }; $bed_sizer->Add($sizer, 1, wxEXPAND, 0); } # XYZ home button $move_button->($bed_sizer, 'XYZ', 'house', 1, wxTOP, sub { $self->home(undef) }); # X buttons { my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); for my $d (qw(-10 -1 -0.1)) { $move_button->($sizer, $d, 'arrow_left', 0, wxTOP, sub { $self->rel_move('X', $d) }); } $move_button->($sizer, 'X', 'house', 1, wxTOP, sub { $self->home('X') }); for my $d (qw(+0.1 +1 +10)) { $move_button->($sizer, $d, 'arrow_right', 0, wxTOP, sub { $self->rel_move('X', $d) }); } $bed_sizer->Add($sizer, 1, wxEXPAND, 0); } my $optgroup = Slic3r::GUI::OptionsGroup->new( parent => $self, title => 'Settings', on_change => sub { my ($opt_id, $value) = @_; $self->config2->{$opt_id} = $value; }, ); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Speed (mm/s)', ); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'xy_travel_speed', type => 'f', label => 'X/Y', tooltip => '', default => $self->config2->{xy_travel_speed}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'z_travel_speed', type => 'f', label => 'Z', tooltip => '', default => $self->config2->{z_travel_speed}, )); $optgroup->append_line($line); } my $main_sizer = Wx::BoxSizer->new(wxVERTICAL); $main_sizer->Add($bed_sizer, 1, wxEXPAND | wxALL, 10); $main_sizer->Add($optgroup->sizer, 0, wxEXPAND | wxALL, 10); #$main_sizer->Add($self->CreateButtonSizer(wxCLOSE), 0, wxEXPAND); #EVT_BUTTON($self, wxID_CLOSE, sub { $self->Close }); $self->SetSizer($main_sizer); $self->SetMinSize($self->GetSize); #$main_sizer->SetSizeHints($self); $self->Layout; # needed to actually free memory EVT_CLOSE($self, sub { $self->EndModal(wxID_OK); $self->Destroy; }); return $self; } sub abs_xy_move { my ($self, $pos) = @_; $self->sender->send("G90", 1); # set absolute positioning $self->sender->send(sprintf("G1 X%.1f Y%.1f F%d", @$pos, $self->config2->{xy_travel_speed}*60), 1); $self->{canvas}->set_pos($pos); } sub rel_move { my ($self, $axis, $distance) = @_; my $speed = ($axis eq 'Z') ? $self->config2->{z_travel_speed} : $self->config2->{xy_travel_speed}; $self->sender->send("G91", 1); # set relative positioning $self->sender->send(sprintf("G1 %s%.1f F%d", $axis, $distance, $speed*60), 1); $self->sender->send("G90", 1); # set absolute positioning if (my $pos = $self->{canvas}->pos) { if ($axis eq 'X') { $pos->translate($distance, 0); } elsif ($axis eq 'Y') { $pos->translate(0, $distance); } $self->{canvas}->set_pos($pos); } } sub home { my ($self, $axis) = @_; $axis //= ''; $self->sender->send(sprintf("G28 %s", $axis), 1); $self->{canvas}->set_pos(undef); $self->x_homed(1) if $axis eq 'X'; $self->y_homed(1) if $axis eq 'Y'; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Controller/PrinterPanel.pm000066400000000000000000000635141301441720000241240ustar00rootroot00000000000000package Slic3r::GUI::Controller::PrinterPanel; use strict; use warnings; use utf8; use Wx qw(wxTheApp :panel :id :misc :sizer :button :bitmap :window :gauge :timer :textctrl :font :systemsettings); use Wx::Event qw(EVT_BUTTON EVT_MOUSEWHEEL EVT_TIMER EVT_SCROLLWIN); use base qw(Wx::Panel Class::Accessor); __PACKAGE__->mk_accessors(qw(printer_name config sender jobs printing status_timer temp_timer)); use constant CONNECTION_TIMEOUT => 3; # seconds use constant STATUS_TIMER_INTERVAL => 1000; # milliseconds use constant TEMP_TIMER_INTERVAL => 5000; # milliseconds sub new { my ($class, $parent, $printer_name, $config) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, [500, 250]); $self->printer_name($printer_name || 'Printer'); $self->config($config); $self->jobs([]); # set up the timer that polls for updates { my $timer_id = &Wx::NewId(); $self->status_timer(Wx::Timer->new($self, $timer_id)); EVT_TIMER($self, $timer_id, sub { my ($self, $event) = @_; if ($self->printing) { my $queue_size = $self->sender->queue_size; $self->{gauge}->SetValue($self->{gauge}->GetRange - $queue_size); if ($queue_size == 0) { $self->print_completed; } } $self->{log_textctrl}->AppendText("$_\n") for @{$self->sender->purge_log}; { my $temp = $self->sender->getT; if ($temp eq '') { $self->{temp_panel}->Hide; } else { if (!$self->{temp_panel}->IsShown) { $self->{temp_panel}->Show; $self->Layout; } $self->{temp_text}->SetLabel($temp . "°C"); $temp = $self->sender->getB; if ($temp eq '') { $self->{bed_temp_text}->SetLabel('n.a.'); } else { $self->{bed_temp_text}->SetLabel($temp . "°C"); } } } }); } # set up the timer that sends temperature requests # (responses are handled by status_timer) { my $timer_id = &Wx::NewId(); $self->temp_timer(Wx::Timer->new($self, $timer_id)); EVT_TIMER($self, $timer_id, sub { my ($self, $event) = @_; $self->sender->send("M105", 1); # send it through priority queue }); } my $box = Wx::StaticBox->new($self, -1, ""); my $sizer = Wx::StaticBoxSizer->new($box, wxHORIZONTAL); my $left_sizer = Wx::BoxSizer->new(wxVERTICAL); # printer name { my $text = Wx::StaticText->new($box, -1, $self->printer_name, wxDefaultPosition, [220,-1]); my $font = $text->GetFont; $font->SetPointSize(20); $text->SetFont($font); $left_sizer->Add($text, 0, wxEXPAND, 0); } # connection info { my $conn_sizer = Wx::FlexGridSizer->new(2, 2, 1, 0); $conn_sizer->SetFlexibleDirection(wxHORIZONTAL); $conn_sizer->AddGrowableCol(1, 1); $left_sizer->Add($conn_sizer, 0, wxEXPAND | wxTOP, 5); { my $text = Wx::StaticText->new($box, -1, "Port:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $conn_sizer->Add($text, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5); } my $serial_port_sizer = Wx::BoxSizer->new(wxHORIZONTAL); { $self->{serial_port_combobox} = Wx::ComboBox->new($box, -1, $config->serial_port, wxDefaultPosition, wxDefaultSize, []); $self->{serial_port_combobox}->SetFont($Slic3r::GUI::small_font); $self->update_serial_ports; $serial_port_sizer->Add($self->{serial_port_combobox}, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 1); } { $self->{btn_rescan_serial} = my $btn = Wx::BitmapButton->new($box, -1, Wx::Bitmap->new($Slic3r::var->("arrow_rotate_clockwise.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, &Wx::wxBORDER_NONE); $btn->SetToolTipString("Rescan serial ports") if $btn->can('SetToolTipString'); $serial_port_sizer->Add($btn, 0, wxALIGN_CENTER_VERTICAL, 0); EVT_BUTTON($self, $btn, sub { $self->update_serial_ports }); } $conn_sizer->Add($serial_port_sizer, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5); { my $text = Wx::StaticText->new($box, -1, "Speed:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $conn_sizer->Add($text, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5); } my $serial_speed_sizer = Wx::BoxSizer->new(wxHORIZONTAL); { $self->{serial_speed_combobox} = Wx::ComboBox->new($box, -1, $config->serial_speed, wxDefaultPosition, wxDefaultSize, ["115200", "250000"]); $self->{serial_speed_combobox}->SetFont($Slic3r::GUI::small_font); $serial_speed_sizer->Add($self->{serial_speed_combobox}, 0, wxALIGN_CENTER_VERTICAL, 0); } { $self->{btn_disconnect} = my $btn = Wx::Button->new($box, -1, "Disconnect", wxDefaultPosition, wxDefaultSize); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("delete.png"), wxBITMAP_TYPE_PNG)); } $serial_speed_sizer->Add($btn, 0, wxLEFT, 5); EVT_BUTTON($self, $btn, \&disconnect); } $conn_sizer->Add($serial_speed_sizer, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5); } # buttons { $self->{btn_connect} = my $btn = Wx::Button->new($box, -1, "Connect to printer", wxDefaultPosition, [-1, 40]); my $font = $btn->GetFont; $font->SetPointSize($font->GetPointSize + 2); $btn->SetFont($font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("arrow_up.png"), wxBITMAP_TYPE_PNG)); } $left_sizer->Add($btn, 0, wxTOP, 15); EVT_BUTTON($self, $btn, \&connect); } # print progress bar { my $gauge = $self->{gauge} = Wx::Gauge->new($self, wxGA_HORIZONTAL, 100, wxDefaultPosition, wxDefaultSize); $left_sizer->Add($self->{gauge}, 0, wxEXPAND | wxTOP, 15); $gauge->Hide; } # status $self->{status_text} = Wx::StaticText->new($box, -1, "", wxDefaultPosition, [200,-1]); $left_sizer->Add($self->{status_text}, 1, wxEXPAND | wxTOP, 15); # manual control { $self->{btn_manual_control} = my $btn = Wx::Button->new($box, -1, "Manual control", wxDefaultPosition, wxDefaultSize); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG)); } $btn->Hide; $left_sizer->Add($btn, 0, wxTOP, 15); EVT_BUTTON($self, $btn, sub { my $dlg = Slic3r::GUI::Controller::ManualControlDialog->new ($self, $self->config, $self->sender); $dlg->ShowModal; }); } # temperature { my $temp_panel = $self->{temp_panel} = Wx::Panel->new($box, -1); my $temp_sizer = Wx::BoxSizer->new(wxHORIZONTAL); my $temp_font = Wx::Font->new($Slic3r::GUI::small_font); $temp_font->SetWeight(wxFONTWEIGHT_BOLD); { my $text = Wx::StaticText->new($temp_panel, -1, "Temperature:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $temp_sizer->Add($text, 0, wxALIGN_CENTER_VERTICAL); $self->{temp_text} = Wx::StaticText->new($temp_panel, -1, "", wxDefaultPosition, wxDefaultSize); $self->{temp_text}->SetFont($temp_font); $self->{temp_text}->SetForegroundColour(Wx::wxRED); $temp_sizer->Add($self->{temp_text}, 1, wxALIGN_CENTER_VERTICAL); } { my $text = Wx::StaticText->new($temp_panel, -1, "Bed:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $temp_sizer->Add($text, 0, wxALIGN_CENTER_VERTICAL); $self->{bed_temp_text} = Wx::StaticText->new($temp_panel, -1, "", wxDefaultPosition, wxDefaultSize); $self->{bed_temp_text}->SetFont($temp_font); $self->{bed_temp_text}->SetForegroundColour(Wx::wxRED); $temp_sizer->Add($self->{bed_temp_text}, 1, wxALIGN_CENTER_VERTICAL); } $temp_panel->SetSizer($temp_sizer); $temp_panel->Hide; $left_sizer->Add($temp_panel, 0, wxEXPAND | wxTOP | wxBOTTOM, 4); } # print jobs panel $self->{print_jobs_sizer} = my $print_jobs_sizer = Wx::BoxSizer->new(wxVERTICAL); { my $text = Wx::StaticText->new($box, -1, "Queue:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $print_jobs_sizer->Add($text, 0, wxEXPAND, 0); $self->{jobs_panel} = Wx::ScrolledWindow->new($box, -1, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxBORDER_NONE); $self->{jobs_panel}->SetScrollbars(0, 1, 0, 1); $self->{jobs_panel_sizer} = Wx::BoxSizer->new(wxVERTICAL); $self->{jobs_panel}->SetSizer($self->{jobs_panel_sizer}); $print_jobs_sizer->Add($self->{jobs_panel}, 1, wxEXPAND, 0); # TODO: fix this. We're trying to pass the scroll event to the parent but it # doesn't work. EVT_SCROLLWIN($self->{jobs_panel}, sub { my ($panel, $event) = @_; my $controller = $self->GetParent; my $new_event = Wx::ScrollWinEvent->new( $event->GetEventType, $event->GetPosition, $event->GetOrientation, ); $controller->ProcessEvent($new_event); }) if 0; } my $log_sizer = Wx::BoxSizer->new(wxVERTICAL); { my $text = Wx::StaticText->new($box, -1, "Log:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $log_sizer->Add($text, 0, wxEXPAND, 0); my $log = $self->{log_textctrl} = Wx::TextCtrl->new($box, -1, "", wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE | wxBORDER_NONE); $log->SetBackgroundColour($box->GetBackgroundColour); $log->SetFont($Slic3r::GUI::small_font); $log->SetEditable(0); $log_sizer->Add($self->{log_textctrl}, 1, wxEXPAND, 0); } $sizer->Add($left_sizer, 0, wxEXPAND | wxALL, 0); $sizer->Add($print_jobs_sizer, 2, wxEXPAND | wxALL, 0); $sizer->Add($log_sizer, 1, wxEXPAND | wxLEFT, 15); $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); $self->_update_connection_controls; return $self; } sub is_connected { my ($self) = @_; return $self->sender && $self->sender->is_connected; } sub _update_connection_controls { my ($self) = @_; $self->{btn_connect}->Show; $self->{btn_disconnect}->Hide; $self->{serial_port_combobox}->Enable; $self->{serial_speed_combobox}->Enable; $self->{btn_rescan_serial}->Enable; $self->{btn_manual_control}->Hide; $self->{btn_manual_control}->Disable; if ($self->is_connected) { $self->{btn_connect}->Hide; $self->{btn_manual_control}->Show; if (!$self->printing || $self->printing->paused) { $self->{btn_disconnect}->Show; $self->{btn_manual_control}->Enable; } $self->{serial_port_combobox}->Disable; $self->{serial_speed_combobox}->Disable; $self->{btn_rescan_serial}->Disable; } $self->Layout; } sub set_status { my ($self, $status) = @_; $self->{status_text}->SetLabel($status); $self->{status_text}->Wrap($self->{status_text}->GetSize->GetWidth); $self->{status_text}->Refresh; $self->Layout; } sub connect { my ($self) = @_; return if $self->is_connected; $self->set_status("Connecting..."); $self->sender(Slic3r::GCode::Sender->new); my $res = $self->sender->connect( $self->{serial_port_combobox}->GetValue, $self->{serial_speed_combobox}->GetValue, ); if (!$res) { $self->set_status("Connection failed. Check serial port and speed."); } else { if ($self->sender->wait_connected) { $self->set_status("Printer is online. You can now start printing from the queue on the right."); $self->status_timer->Start(STATUS_TIMER_INTERVAL, wxTIMER_CONTINUOUS); $self->temp_timer->Start(TEMP_TIMER_INTERVAL, wxTIMER_CONTINUOUS); # request temperature now, without waiting for the timer $self->sender->send("M105", 1); } else { $self->set_status("Connection failed. Check serial port and speed."); } } $self->_update_connection_controls; $self->reload_jobs; } sub disconnect { my ($self) = @_; $self->status_timer->Stop; $self->temp_timer->Stop; return if !$self->is_connected; $self->printing->printing(0) if $self->printing; $self->printing(undef); $self->{gauge}->Hide; $self->{temp_panel}->Hide; $self->sender->disconnect; $self->set_status(""); $self->_update_connection_controls; $self->reload_jobs; } sub update_serial_ports { my ($self) = @_; my $cb = $self->{serial_port_combobox}; my $current = $cb->GetValue; $cb->Clear; $cb->Append($_) for wxTheApp->scan_serial_ports; $cb->SetValue($current); } sub load_print_job { my ($self, $gcode_file, $filament_stats) = @_; push @{$self->jobs}, my $job = Slic3r::GUI::Controller::PrinterPanel::PrintJob->new( id => time() . $gcode_file . rand(1000), gcode_file => $gcode_file, filament_stats => $filament_stats, ); $self->reload_jobs; return $job; } sub delete_job { my ($self, $job) = @_; $self->jobs([ grep $_->id ne $job->id, @{$self->jobs} ]); $self->reload_jobs; } sub print_job { my ($self, $job) = @_; $self->printing($job); $job->printing(1); $self->reload_jobs; open my $fh, '<', $job->gcode_file; my $line_count = 0; while (my $row = <$fh>) { $self->sender->send($row); $line_count++; } close $fh; $self->_update_connection_controls; $self->{gauge}->SetRange($line_count); $self->{gauge}->SetValue(0); $self->{gauge}->Enable; $self->{gauge}->Show; $self->Layout; $self->set_status('Printing...'); $self->{log_textctrl}->AppendText(sprintf "=====\n"); $self->{log_textctrl}->AppendText(sprintf "Printing %s\n", $job->name); $self->{log_textctrl}->AppendText(sprintf "Print started at %s\n", $self->_timestamp); } sub print_completed { my ($self) = @_; my $job = $self->printing; $self->printing(undef); $job->printing(0); $job->printed(1); $self->_update_connection_controls; $self->{gauge}->Hide; $self->Layout; $self->set_status('Print completed.'); $self->{log_textctrl}->AppendText(sprintf "Print completed at %s\n", $self->_timestamp); $self->reload_jobs; } sub reload_jobs { my ($self) = @_; # reorder jobs @{$self->jobs} = sort { ($a->printed <=> $b->printed) || ($a->timestamp <=> $b->timestamp) } @{$self->jobs}; # remove all panels foreach my $child ($self->{jobs_panel_sizer}->GetChildren) { my $window = $child->GetWindow; $self->{jobs_panel_sizer}->Detach($window); # now $child does not exist anymore $window->Destroy; } # re-add all panels foreach my $job (@{$self->jobs}) { my $panel = Slic3r::GUI::Controller::PrinterPanel::PrintJobPanel->new($self->{jobs_panel}, $job); $self->{jobs_panel_sizer}->Add($panel, 0, wxEXPAND | wxBOTTOM, 5); $panel->on_delete_job(sub { my ($job) = @_; $self->delete_job($job); }); $panel->on_print_job(sub { my ($job) = @_; $self->print_job($job); }); $panel->on_pause_print(sub { my ($job) = @_; $self->sender->pause_queue; $job->paused(1); $self->reload_jobs; $self->_update_connection_controls; $self->{gauge}->Disable; $self->set_status('Print is paused. Click on Resume to continue.'); }); $panel->on_abort_print(sub { my ($job) = @_; $self->sender->purge_queue; $self->printing(undef); $job->printing(0); $job->paused(0); $self->reload_jobs; $self->_update_connection_controls; $self->{gauge}->Disable; $self->{gauge}->Hide; $self->set_status('Print was aborted.'); $self->{log_textctrl}->AppendText(sprintf "Print aborted at %s\n", $self->_timestamp); }); $panel->on_resume_print(sub { my ($job) = @_; $self->sender->resume_queue; $job->paused(0); $self->reload_jobs; $self->_update_connection_controls; $self->{gauge}->Enable; $self->set_status('Printing...'); }); $panel->enable_print if $self->is_connected && !$self->printing; EVT_MOUSEWHEEL($panel, sub { my (undef, $event) = @_; Wx::PostEvent($self->{jobs_panel}, $event); $event->Skip; }); } $self->{jobs_panel}->Layout; $self->{print_jobs_sizer}->Layout; } sub _timestamp { my ($self) = @_; my @time = localtime(time); return sprintf '%02d:%02d:%02d', @time[2,1,0]; } package Slic3r::GUI::Controller::PrinterPanel::PrintJob; use Moo; use File::Basename qw(basename); has 'id' => (is => 'ro', required => 1); has 'timestamp' => (is => 'ro', default => sub { time }); has 'gcode_file' => (is => 'ro', required => 1); has 'filament_stats' => (is => 'rw'); has 'printing' => (is => 'rw', default => sub { 0 }); has 'paused' => (is => 'rw', default => sub { 0 }); has 'printed' => (is => 'rw', default => sub { 0 }); sub name { my ($self) = @_; return basename($self->gcode_file); } package Slic3r::GUI::Controller::PrinterPanel::PrintJobPanel; use strict; use warnings; use utf8; use Wx qw(wxTheApp :panel :id :misc :sizer :button :bitmap :font :dialog :icon :timer :colour :brush :pen); use Wx::Event qw(EVT_BUTTON EVT_TIMER EVT_ERASE_BACKGROUND); use base qw(Wx::Panel Class::Accessor); __PACKAGE__->mk_accessors(qw(job on_delete_job on_print_job on_pause_print on_resume_print on_abort_print blink_timer)); sub new { my ($class, $parent, $job) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize); $self->job($job); $self->SetBackgroundColour(wxWHITE); { my $white_brush = Wx::Brush->new(wxWHITE, wxSOLID); my $pen = Wx::Pen->new(Wx::Colour->new(200,200,200), 1, wxSOLID); EVT_ERASE_BACKGROUND($self, sub { my ($self, $event) = @_; my $dc = $event->GetDC; my $size = $self->GetSize; $dc->SetBrush($white_brush); $dc->SetPen($pen); $dc->DrawRoundedRectangle(0, 0, $size->GetWidth,$size->GetHeight, 6); }); } my $left_sizer = Wx::BoxSizer->new(wxVERTICAL); { $self->{job_name_textctrl} = my $text = Wx::StaticText->new($self, -1, $job->name, wxDefaultPosition, wxDefaultSize); my $font = $text->GetFont; $font->SetWeight(wxFONTWEIGHT_BOLD); $text->SetFont($font); if ($job->printed) { $text->SetForegroundColour($Slic3r::GUI::grey); } $left_sizer->Add($text, 0, wxEXPAND, 0); } { my $filament_stats = join "\n", map "$_ (" . sprintf("%.2f", $job->filament_stats->{$_}/1000) . "m)", sort keys %{$job->filament_stats}; my $text = Wx::StaticText->new($self, -1, $filament_stats, wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); if ($job->printed && !$job->printing) { $text->SetForegroundColour($Slic3r::GUI::grey); } $left_sizer->Add($text, 0, wxEXPAND | wxTOP, 6); } my $buttons_sizer = Wx::BoxSizer->new(wxVERTICAL); my $button_style = Wx::wxBORDER_NONE | wxBU_EXACTFIT; { my $btn = $self->{btn_delete} = Wx::Button->new($self, -1, 'Delete', wxDefaultPosition, wxDefaultSize, $button_style); $btn->SetToolTipString("Delete this job from print queue") if $btn->can('SetToolTipString'); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("delete.png"), wxBITMAP_TYPE_PNG)); } if ($job->printing) { $btn->Hide; } $buttons_sizer->Add($btn, 0, wxBOTTOM, 2); EVT_BUTTON($self, $btn, sub { my $res = Wx::MessageDialog->new($self, "Are you sure you want to delete this print job?", 'Delete Job', wxYES_NO | wxYES_DEFAULT | wxICON_QUESTION)->ShowModal; return unless $res == wxID_YES; wxTheApp->CallAfter(sub { $self->on_delete_job->($job); }); }); } { my $label = $job->printed ? 'Print Again' : 'Print This'; my $btn = $self->{btn_print} = Wx::Button->new($self, -1, $label, wxDefaultPosition, wxDefaultSize, $button_style); $btn->SetFont($Slic3r::GUI::small_bold_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_play.png"), wxBITMAP_TYPE_PNG)); $btn->SetBitmapCurrent(Wx::Bitmap->new($Slic3r::var->("control_play_blue.png"), wxBITMAP_TYPE_PNG)); #$btn->SetBitmapPosition(wxRIGHT); } $btn->Hide; $buttons_sizer->Add($btn, 0, wxBOTTOM, 2); EVT_BUTTON($self, $btn, sub { wxTheApp->CallAfter(sub { $self->on_print_job->($job); }); }); } { my $btn = $self->{btn_pause} = Wx::Button->new($self, -1, "Pause", wxDefaultPosition, wxDefaultSize, $button_style); $btn->SetFont($Slic3r::GUI::small_font); if (!$job->printing || $job->paused) { $btn->Hide; } if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_pause.png"), wxBITMAP_TYPE_PNG)); $btn->SetBitmapCurrent(Wx::Bitmap->new($Slic3r::var->("control_pause_blue.png"), wxBITMAP_TYPE_PNG)); } $buttons_sizer->Add($btn, 0, wxBOTTOM, 2); EVT_BUTTON($self, $btn, sub { wxTheApp->CallAfter(sub { $self->on_pause_print->($job); }); }); } { my $btn = $self->{btn_resume} = Wx::Button->new($self, -1, "Resume", wxDefaultPosition, wxDefaultSize, $button_style); $btn->SetFont($Slic3r::GUI::small_font); if (!$job->printing || !$job->paused) { $btn->Hide; } if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_play.png"), wxBITMAP_TYPE_PNG)); $btn->SetBitmapCurrent(Wx::Bitmap->new($Slic3r::var->("control_play_blue.png"), wxBITMAP_TYPE_PNG)); } $buttons_sizer->Add($btn, 0, wxBOTTOM, 2); EVT_BUTTON($self, $btn, sub { wxTheApp->CallAfter(sub { $self->on_resume_print->($job); }); }); } { my $btn = $self->{btn_abort} = Wx::Button->new($self, -1, "Abort", wxDefaultPosition, wxDefaultSize, $button_style); $btn->SetFont($Slic3r::GUI::small_font); if (!$job->printing) { $btn->Hide; } if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_stop.png"), wxBITMAP_TYPE_PNG)); $btn->SetBitmapCurrent(Wx::Bitmap->new($Slic3r::var->("control_stop_blue.png"), wxBITMAP_TYPE_PNG)); } $buttons_sizer->Add($btn, 0, wxBOTTOM, 2); EVT_BUTTON($self, $btn, sub { wxTheApp->CallAfter(sub { $self->on_abort_print->($job); }); }); } my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($left_sizer, 1, wxEXPAND | wxALL, 6); $sizer->Add($buttons_sizer, 0, wxEXPAND | wxALL, 6); $self->SetSizer($sizer); # set-up the timer that changes the job name color while printing if ($self->job->printing && !$self->job->paused) { my $timer_id = &Wx::NewId(); $self->blink_timer(Wx::Timer->new($self, $timer_id)); my $blink = 0; # closure my $colour = Wx::Colour->new(0, 190, 0); EVT_TIMER($self, $timer_id, sub { my ($self, $event) = @_; $self->{job_name_textctrl}->SetForegroundColour($blink ? Wx::wxBLACK : $colour); $blink = !$blink; }); $self->blink_timer->Start(1000, wxTIMER_CONTINUOUS); } return $self; } sub enable_print { my ($self) = @_; if (!$self->job->printing) { $self->{btn_print}->Show; } $self->Layout; } sub Destroy { my ($self) = @_; # There's a gap between the time Perl destroys the wxPanel object and # the blink_timer member, so the wxTimer might still fire an event which # isn't handled properly, causing a crash. So we ensure that blink_timer # is stopped before we destroy the wxPanel. $self->blink_timer->Stop if $self->blink_timer; return $self->SUPER::Destroy; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/MainFrame.pm000066400000000000000000001024271301441720000212320ustar00rootroot00000000000000# The main frame, the parent of all. package Slic3r::GUI::MainFrame; use strict; use warnings; use utf8; use File::Basename qw(basename dirname); use List::Util qw(min); use Slic3r::Geometry qw(X Y Z); use Wx qw(:frame :bitmap :id :misc :notebook :panel :sizer :menu :dialog :filedialog :font :icon wxTheApp); use Wx::Event qw(EVT_CLOSE EVT_MENU EVT_NOTEBOOK_PAGE_CHANGED); use base 'Wx::Frame'; our $qs_last_input_file; our $qs_last_output_file; our $last_config; sub new { my ($class, %params) = @_; my $self = $class->SUPER::new(undef, -1, $Slic3r::FORK_NAME . ' - ' . $Slic3r::VERSION, wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE); if ($^O eq 'MSWin32') { # Load the icon either from the exe, or fron the ico file. my $iconfile = $Slic3r::var->('..\slic3r.exe'); $iconfile = $Slic3r::var->("Slic3r.ico") unless -f $iconfile; $self->SetIcon(Wx::Icon->new($iconfile, wxBITMAP_TYPE_ICO)); } else { $self->SetIcon(Wx::Icon->new($Slic3r::var->("Slic3r_128px.png"), wxBITMAP_TYPE_PNG)); } # store input params $self->{mode} = $params{mode}; $self->{mode} = 'expert' if $self->{mode} !~ /^(?:simple|expert)$/; # If set, the "Controller" tab for the control of the printer over serial line and the serial port settings are hidden. $self->{no_controller} = $params{no_controller}; $self->{no_plater} = $params{no_plater}; $self->{loaded} = 0; # initialize tabpanel and menubar $self->_init_tabpanel; $self->_init_menubar; # initialize status bar $self->{statusbar} = Slic3r::GUI::ProgressStatusBar->new($self, -1); $self->{statusbar}->SetStatusText("Version $Slic3r::VERSION - Remember to check for updates at http://github.com/prusa3d/slic3r/releases"); $self->SetStatusBar($self->{statusbar}); $self->{loaded} = 1; # initialize layout { my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($self->{tabpanel}, 1, wxEXPAND); $sizer->SetSizeHints($self); $self->SetSizer($sizer); $self->Fit; $self->SetMinSize([760, 490]); if (defined $Slic3r::GUI::Settings->{_}{main_frame_size}) { my $size = [ split ',', $Slic3r::GUI::Settings->{_}{main_frame_size}, 2 ]; $self->SetSize($size); my $display = Wx::Display->new->GetClientArea(); my $pos = [ split ',', $Slic3r::GUI::Settings->{_}{main_frame_pos}, 2 ]; if (($pos->[X] + $size->[X]/2) < $display->GetRight && ($pos->[Y] + $size->[Y]/2) < $display->GetBottom) { $self->Move($pos); } $self->Maximize(1) if $Slic3r::GUI::Settings->{_}{main_frame_maximized}; } else { $self->SetSize($self->GetMinSize); } $self->Show; $self->Layout; } # declare events EVT_CLOSE($self, sub { my (undef, $event) = @_; if ($event->CanVeto && !$self->check_unsaved_changes) { $event->Veto; return; } # save window size $Slic3r::GUI::Settings->{_}{main_frame_pos} = join ',', $self->GetScreenPositionXY; $Slic3r::GUI::Settings->{_}{main_frame_size} = join ',', $self->GetSizeWH; $Slic3r::GUI::Settings->{_}{main_frame_maximized} = $self->IsMaximized; wxTheApp->save_settings; # propagate event $event->Skip; }); $self->update_ui_from_settings; return $self; } sub _init_tabpanel { my ($self) = @_; $self->{tabpanel} = my $panel = Wx::Notebook->new($self, -1, wxDefaultPosition, wxDefaultSize, wxNB_TOP | wxTAB_TRAVERSAL); EVT_NOTEBOOK_PAGE_CHANGED($self, $self->{tabpanel}, sub { my $panel = $self->{tabpanel}->GetCurrentPage; $panel->OnActivate if $panel->can('OnActivate'); }); if (!$self->{no_plater}) { $panel->AddPage($self->{plater} = Slic3r::GUI::Plater->new($panel), "Plater"); if (!$self->{no_controller}) { $panel->AddPage($self->{controller} = Slic3r::GUI::Controller->new($panel), "Controller"); } } $self->{options_tabs} = {}; my $simple_config; if ($self->{mode} eq 'simple') { $simple_config = Slic3r::Config->load("$Slic3r::GUI::datadir/simple.ini") if -e Slic3r::encode_path("$Slic3r::GUI::datadir/simple.ini"); } my $class_prefix = $self->{mode} eq 'simple' ? "Slic3r::GUI::SimpleTab::" : "Slic3r::GUI::Tab::"; for my $tab_name (qw(print filament printer)) { my $tab; $tab = $self->{options_tabs}{$tab_name} = ($class_prefix . ucfirst $tab_name)->new( $panel, no_controller => $self->{no_controller}); $tab->on_value_change(sub { my ($opt_key, $value) = @_; my $config = $tab->config; if ($self->{plater}) { $self->{plater}->on_config_change($config); # propagate config change events to the plater $self->{plater}->on_extruders_change($value) if $opt_key eq 'extruders_count'; } if ($self->{loaded}) { # don't save while loading for the first time if ($self->{mode} eq 'simple') { # save config $self->config->save("$Slic3r::GUI::datadir/simple.ini"); # save a copy into each preset section # so that user gets the config when switching to expert mode $config->save(sprintf "$Slic3r::GUI::datadir/%s/%s.ini", $tab->name, 'Simple Mode'); $Slic3r::GUI::Settings->{presets}{$tab->name} = 'Simple Mode.ini'; wxTheApp->save_settings; } $self->config->save($Slic3r::GUI::autosave) if $Slic3r::GUI::autosave; } }); # Install a callback for the tab to update the platter and print controller presets, when # a preset changes at Slic3r::GUI::Tab. $tab->on_presets_changed(sub { if ($self->{plater}) { $self->{plater}->update_presets($tab_name, @_); $self->{plater}->on_config_change($tab->config); if ($self->{controller}) { $self->{controller}->update_presets($tab_name, @_); } } }); $tab->load_presets; $panel->AddPage($tab, $tab->title); $tab->load_config($simple_config) if $simple_config; } if ($self->{plater}) { $self->{plater}->on_select_preset(sub { my ($group, $i) = @_; $self->{options_tabs}{$group}->select_preset($i); }); # load initial config $self->{plater}->on_config_change($self->config); } } sub _init_menubar { my ($self) = @_; # File menu my $fileMenu = Wx::Menu->new; { $self->_append_menu_item($fileMenu, "&Load Config…\tCtrl+L", 'Load exported configuration file', sub { $self->load_config_file; }, undef, 'plugin_add.png'); $self->_append_menu_item($fileMenu, "&Export Config…\tCtrl+E", 'Export current configuration to file', sub { $self->export_config; }, undef, 'plugin_go.png'); $self->_append_menu_item($fileMenu, "&Load Config Bundle…", 'Load presets from a bundle', sub { $self->load_configbundle; }, undef, 'lorry_add.png'); $self->_append_menu_item($fileMenu, "&Export Config Bundle…", 'Export all presets to file', sub { $self->export_configbundle; }, undef, 'lorry_go.png'); $fileMenu->AppendSeparator(); my $repeat; $self->_append_menu_item($fileMenu, "Q&uick Slice…\tCtrl+U", 'Slice file', sub { wxTheApp->CallAfter(sub { $self->quick_slice; $repeat->Enable(defined $Slic3r::GUI::MainFrame::last_input_file); }); }, undef, 'cog_go.png'); $self->_append_menu_item($fileMenu, "Quick Slice and Save &As…\tCtrl+Alt+U", 'Slice file and save as', sub { wxTheApp->CallAfter(sub { $self->quick_slice(save_as => 1); $repeat->Enable(defined $Slic3r::GUI::MainFrame::last_input_file); }); }, undef, 'cog_go.png'); $repeat = $self->_append_menu_item($fileMenu, "&Repeat Last Quick Slice\tCtrl+Shift+U", 'Repeat last quick slice', sub { wxTheApp->CallAfter(sub { $self->quick_slice(reslice => 1); }); }, undef, 'cog_go.png'); $repeat->Enable(0); $fileMenu->AppendSeparator(); $self->_append_menu_item($fileMenu, "Slice to SV&G…\tCtrl+G", 'Slice file to SVG', sub { $self->quick_slice(save_as => 1, export_svg => 1); }, undef, 'shape_handles.png'); $self->{menu_item_reslice_now} = $self->_append_menu_item( $fileMenu, "(&Re)Slice Now\tCtrl+S", 'Start new slicing process', sub { $self->reslice_now; }, undef, 'shape_handles.png'); $fileMenu->AppendSeparator(); $self->_append_menu_item($fileMenu, "Repair STL file…", 'Automatically repair an STL file', sub { $self->repair_stl; }, undef, 'wrench.png'); $fileMenu->AppendSeparator(); # Cmd+, is standard on OS X - what about other operating systems? $self->_append_menu_item($fileMenu, "Preferences…\tCtrl+,", 'Application preferences', sub { Slic3r::GUI::Preferences->new($self)->ShowModal; }, wxID_PREFERENCES); $fileMenu->AppendSeparator(); $self->_append_menu_item($fileMenu, "&Quit", 'Quit Slic3r', sub { $self->Close(0); }, wxID_EXIT); } # Plater menu unless ($self->{no_plater}) { my $plater = $self->{plater}; $self->{plater_menu} = Wx::Menu->new; $self->_append_menu_item($self->{plater_menu}, "Export G-code...", 'Export current plate as G-code', sub { $plater->export_gcode; }, undef, 'cog_go.png'); $self->_append_menu_item($self->{plater_menu}, "Export plate as STL...", 'Export current plate as STL', sub { $plater->export_stl; }, undef, 'brick_go.png'); $self->_append_menu_item($self->{plater_menu}, "Export plate as AMF...", 'Export current plate as AMF', sub { $plater->export_amf; }, undef, 'brick_go.png'); $self->_append_menu_item($self->{plater_menu}, "Open DLP Projector…\tCtrl+L", 'Open projector window for DLP printing', sub { my $projector = Slic3r::GUI::Projector->new($self); # this double invocation is needed for properly hiding the MainFrame $projector->Show; $projector->ShowModal; }, undef, 'film.png'); $self->{object_menu} = $self->{plater}->object_menu; $self->on_plater_selection_changed(0); } # Window menu my $windowMenu = Wx::Menu->new; { my $tab_offset = 0; if (!$self->{no_plater}) { $self->_append_menu_item($windowMenu, "Select &Plater Tab\tCtrl+1", 'Show the plater', sub { $self->select_tab(0); }, undef, 'application_view_tile.png'); if (!$self->{no_controller}) { $self->_append_menu_item($windowMenu, "Select &Controller Tab\tCtrl+T", 'Show the printer controller', sub { $self->select_tab(1); }, undef, 'printer_empty.png'); } $windowMenu->AppendSeparator(); $tab_offset += 2; } $self->_append_menu_item($windowMenu, "Select P&rint Settings Tab\tCtrl+2", 'Show the print settings', sub { $self->select_tab($tab_offset+0); }, undef, 'cog.png'); $self->_append_menu_item($windowMenu, "Select &Filament Settings Tab\tCtrl+3", 'Show the filament settings', sub { $self->select_tab($tab_offset+1); }, undef, 'spool.png'); $self->_append_menu_item($windowMenu, "Select Print&er Settings Tab\tCtrl+4", 'Show the printer settings', sub { $self->select_tab($tab_offset+2); }, undef, 'printer_empty.png'); } # View menu if (!$self->{no_plater}) { $self->{viewMenu} = Wx::Menu->new; $self->_append_menu_item($self->{viewMenu}, "Default", 'Default View', sub { $self->select_view('default'); }); $self->_append_menu_item($self->{viewMenu}, "Top" , 'Top View' , sub { $self->select_view('top' ); }); $self->_append_menu_item($self->{viewMenu}, "Bottom" , 'Bottom View' , sub { $self->select_view('bottom' ); }); $self->_append_menu_item($self->{viewMenu}, "Front" , 'Front View' , sub { $self->select_view('front' ); }); $self->_append_menu_item($self->{viewMenu}, "Rear" , 'Rear View' , sub { $self->select_view('rear' ); }); $self->_append_menu_item($self->{viewMenu}, "Left" , 'Left View' , sub { $self->select_view('left' ); }); $self->_append_menu_item($self->{viewMenu}, "Right" , 'Right View' , sub { $self->select_view('right' ); }); } # Help menu my $helpMenu = Wx::Menu->new; { $self->_append_menu_item($helpMenu, "&Configuration $Slic3r::GUI::ConfigWizard::wizard…", "Run Configuration $Slic3r::GUI::ConfigWizard::wizard", sub { $self->config_wizard; }); $helpMenu->AppendSeparator(); $self->_append_menu_item($helpMenu, "Prusa 3D Drivers", 'Open the Prusa3D drivers download page in your browser', sub { Wx::LaunchDefaultBrowser('http://www.prusa3d.com/drivers/'); }); $self->_append_menu_item($helpMenu, "Prusa Edition Releases", 'Open the Prusa Edition releases page in your browser', sub { Wx::LaunchDefaultBrowser('http://github.com/prusa3d/slic3r/releases'); }); # my $versioncheck = $self->_append_menu_item($helpMenu, "Check for &Updates...", 'Check for new Slic3r versions', sub { # wxTheApp->check_version(1); # }); # $versioncheck->Enable(wxTheApp->have_version_check); $self->_append_menu_item($helpMenu, "Slic3r &Website", 'Open the Slic3r website in your browser', sub { Wx::LaunchDefaultBrowser('http://slic3r.org/'); }); $self->_append_menu_item($helpMenu, "Slic3r &Manual", 'Open the Slic3r manual in your browser', sub { Wx::LaunchDefaultBrowser('http://manual.slic3r.org/'); }); $helpMenu->AppendSeparator(); $self->_append_menu_item($helpMenu, "&About Slic3r", 'Show about dialog', sub { wxTheApp->about; }); } # menubar # assign menubar to frame after appending items, otherwise special items # will not be handled correctly { my $menubar = Wx::MenuBar->new; $menubar->Append($fileMenu, "&File"); $menubar->Append($self->{plater_menu}, "&Plater") if $self->{plater_menu}; $menubar->Append($self->{object_menu}, "&Object") if $self->{object_menu}; $menubar->Append($windowMenu, "&Window"); $menubar->Append($self->{viewMenu}, "&View") if $self->{viewMenu}; $menubar->Append($helpMenu, "&Help"); $self->SetMenuBar($menubar); } } sub is_loaded { my ($self) = @_; return $self->{loaded}; } sub on_plater_selection_changed { my ($self, $have_selection) = @_; return if !defined $self->{object_menu}; $self->{object_menu}->Enable($_->GetId, $have_selection) for $self->{object_menu}->GetMenuItems; } sub quick_slice { my $self = shift; my %params = @_; my $progress_dialog; eval { # validate configuration my $config = $self->config; $config->validate; # select input file my $input_file; my $dir = $Slic3r::GUI::Settings->{recent}{skein_directory} || $Slic3r::GUI::Settings->{recent}{config_directory} || ''; if (!$params{reslice}) { my $dialog = Wx::FileDialog->new($self, 'Choose a file to slice (STL/OBJ/AMF):', $dir, "", &Slic3r::GUI::MODEL_WILDCARD, wxFD_OPEN | wxFD_FILE_MUST_EXIST); if ($dialog->ShowModal != wxID_OK) { $dialog->Destroy; return; } $input_file = Slic3r::decode_path($dialog->GetPaths); $dialog->Destroy; $qs_last_input_file = $input_file unless $params{export_svg}; } else { if (!defined $qs_last_input_file) { Wx::MessageDialog->new($self, "No previously sliced file.", 'Error', wxICON_ERROR | wxOK)->ShowModal(); return; } if (! -e $qs_last_input_file) { Wx::MessageDialog->new($self, "Previously sliced file ($qs_last_input_file) not found.", 'File Not Found', wxICON_ERROR | wxOK)->ShowModal(); return; } $input_file = $qs_last_input_file; } my $input_file_basename = basename($input_file); $Slic3r::GUI::Settings->{recent}{skein_directory} = dirname($input_file); wxTheApp->save_settings; my $print_center; { my $bed_shape = Slic3r::Polygon->new_scale(@{$config->bed_shape}); $print_center = Slic3r::Pointf->new_unscale(@{$bed_shape->bounding_box->center}); } my $sprint = Slic3r::Print::Simple->new( print_center => $print_center, status_cb => sub { my ($percent, $message) = @_; return if &Wx::wxVERSION_STRING !~ m" 2\.(8\.|9\.[2-9])"; $progress_dialog->Update($percent, "$message…"); }, ); # keep model around my $model = Slic3r::Model->read_from_file($input_file); $sprint->apply_config($config); $sprint->set_model($model); { my $extra = $self->extra_variables; $sprint->placeholder_parser->set($_, $extra->{$_}) for keys %$extra; } # select output file my $output_file; if ($params{reslice}) { $output_file = $qs_last_output_file if defined $qs_last_output_file; } elsif ($params{save_as}) { $output_file = $sprint->expanded_output_filepath; $output_file =~ s/\.gcode$/.svg/i if $params{export_svg}; my $dlg = Wx::FileDialog->new($self, 'Save ' . ($params{export_svg} ? 'SVG' : 'G-code') . ' file as:', wxTheApp->output_path(dirname($output_file)), basename($output_file), $params{export_svg} ? &Slic3r::GUI::FILE_WILDCARDS->{svg} : &Slic3r::GUI::FILE_WILDCARDS->{gcode}, wxFD_SAVE | wxFD_OVERWRITE_PROMPT); if ($dlg->ShowModal != wxID_OK) { $dlg->Destroy; return; } $output_file = Slic3r::decode_path($dlg->GetPath); $qs_last_output_file = $output_file unless $params{export_svg}; $Slic3r::GUI::Settings->{_}{last_output_path} = dirname($output_file); wxTheApp->save_settings; $dlg->Destroy; } # show processbar dialog $progress_dialog = Wx::ProgressDialog->new('Slicing…', "Processing $input_file_basename…", 100, $self, 0); $progress_dialog->Pulse; { my @warnings = (); local $SIG{__WARN__} = sub { push @warnings, $_[0] }; $sprint->output_file($output_file); if ($params{export_svg}) { $sprint->export_svg; } else { $sprint->export_gcode; } $sprint->status_cb(undef); Slic3r::GUI::warning_catcher($self)->($_) for @warnings; } $progress_dialog->Destroy; undef $progress_dialog; my $message = "$input_file_basename was successfully sliced."; wxTheApp->notify($message); Wx::MessageDialog->new($self, $message, 'Slicing Done!', wxOK | wxICON_INFORMATION)->ShowModal; }; Slic3r::GUI::catch_error($self, sub { $progress_dialog->Destroy if $progress_dialog }); } sub reslice_now { my ($self) = @_; if ($self->{plater}) { $self->{plater}->reslice; } } sub repair_stl { my $self = shift; my $input_file; { my $dir = $Slic3r::GUI::Settings->{recent}{skein_directory} || $Slic3r::GUI::Settings->{recent}{config_directory} || ''; my $dialog = Wx::FileDialog->new($self, 'Select the STL file to repair:', $dir, "", &Slic3r::GUI::FILE_WILDCARDS->{stl}, wxFD_OPEN | wxFD_FILE_MUST_EXIST); if ($dialog->ShowModal != wxID_OK) { $dialog->Destroy; return; } $input_file = Slic3r::decode_path($dialog->GetPaths); $dialog->Destroy; } my $output_file = $input_file; { $output_file =~ s/\.stl$/_fixed.obj/i; my $dlg = Wx::FileDialog->new($self, "Save OBJ file (less prone to coordinate errors than STL) as:", dirname($output_file), basename($output_file), &Slic3r::GUI::FILE_WILDCARDS->{obj}, wxFD_SAVE | wxFD_OVERWRITE_PROMPT); if ($dlg->ShowModal != wxID_OK) { $dlg->Destroy; return undef; } $output_file = Slic3r::decode_path($dlg->GetPath); $dlg->Destroy; } my $tmesh = Slic3r::TriangleMesh->new; $tmesh->ReadSTLFile(Slic3r::encode_path($input_file)); $tmesh->repair; $tmesh->WriteOBJFile(Slic3r::encode_path($output_file)); Slic3r::GUI::show_info($self, "Your file was repaired.", "Repair"); } sub extra_variables { my $self = shift; my %extra_variables = (); if ($self->{mode} eq 'expert') { $extra_variables{"${_}_preset"} = $self->{options_tabs}{$_}->get_current_preset->name for qw(print filament printer); } return { %extra_variables }; } sub export_config { my $self = shift; my $config = $self->config; eval { # validate configuration $config->validate; }; Slic3r::GUI::catch_error($self) and return; my $dir = $last_config ? dirname($last_config) : $Slic3r::GUI::Settings->{recent}{config_directory} || $Slic3r::GUI::Settings->{recent}{skein_directory} || ''; my $filename = $last_config ? basename($last_config) : "config.ini"; my $dlg = Wx::FileDialog->new($self, 'Save configuration as:', $dir, $filename, &Slic3r::GUI::FILE_WILDCARDS->{ini}, wxFD_SAVE | wxFD_OVERWRITE_PROMPT); if ($dlg->ShowModal == wxID_OK) { my $file = Slic3r::decode_path($dlg->GetPath); $Slic3r::GUI::Settings->{recent}{config_directory} = dirname($file); wxTheApp->save_settings; $last_config = $file; $config->save($file); } $dlg->Destroy; } sub load_config_file { my $self = shift; my ($file) = @_; if (!$file) { return unless $self->check_unsaved_changes; my $dir = $last_config ? dirname($last_config) : $Slic3r::GUI::Settings->{recent}{config_directory} || $Slic3r::GUI::Settings->{recent}{skein_directory} || ''; my $dlg = Wx::FileDialog->new($self, 'Select configuration to load:', $dir, "config.ini", &Slic3r::GUI::FILE_WILDCARDS->{ini}, wxFD_OPEN | wxFD_FILE_MUST_EXIST); return unless $dlg->ShowModal == wxID_OK; $file = Slic3r::decode_path($dlg->GetPaths); $dlg->Destroy; } $Slic3r::GUI::Settings->{recent}{config_directory} = dirname($file); wxTheApp->save_settings; $last_config = $file; for my $tab (values %{$self->{options_tabs}}) { $tab->load_config_file($file); } } sub export_configbundle { my $self = shift; eval { # validate current configuration in case it's dirty $self->config->validate; }; Slic3r::GUI::catch_error($self) and return; my $dir = $last_config ? dirname($last_config) : $Slic3r::GUI::Settings->{recent}{config_directory} || $Slic3r::GUI::Settings->{recent}{skein_directory} || ''; my $filename = "Slic3r_config_bundle.ini"; my $dlg = Wx::FileDialog->new($self, 'Save presets bundle as:', $dir, $filename, &Slic3r::GUI::FILE_WILDCARDS->{ini}, wxFD_SAVE | wxFD_OVERWRITE_PROMPT); if ($dlg->ShowModal == wxID_OK) { my $file = Slic3r::decode_path($dlg->GetPath); $Slic3r::GUI::Settings->{recent}{config_directory} = dirname($file); wxTheApp->save_settings; # leave default category empty to prevent the bundle from being parsed as a normal config file my $ini = { _ => {} }; $ini->{settings}{$_} = $Slic3r::GUI::Settings->{_}{$_} for qw(autocenter mode); $ini->{presets} = $Slic3r::GUI::Settings->{presets}; if (-e "$Slic3r::GUI::datadir/simple.ini") { my $config = Slic3r::Config->load("$Slic3r::GUI::datadir/simple.ini"); $ini->{simple} = $config->as_ini->{_}; } foreach my $section (qw(print filament printer)) { my %presets = wxTheApp->presets($section); foreach my $preset_name (keys %presets) { my $config = Slic3r::Config->load($presets{$preset_name}); $ini->{"$section:$preset_name"} = $config->as_ini->{_}; } } Slic3r::Config->write_ini($file, $ini); } $dlg->Destroy; } sub load_configbundle { my ($self, $file, $skip_no_id) = @_; if (!$file) { my $dir = $last_config ? dirname($last_config) : $Slic3r::GUI::Settings->{recent}{config_directory} || $Slic3r::GUI::Settings->{recent}{skein_directory} || ''; my $dlg = Wx::FileDialog->new($self, 'Select configuration to load:', $dir, "config.ini", &Slic3r::GUI::FILE_WILDCARDS->{ini}, wxFD_OPEN | wxFD_FILE_MUST_EXIST); return unless $dlg->ShowModal == wxID_OK; $file = Slic3r::decode_path($dlg->GetPaths); $dlg->Destroy; } $Slic3r::GUI::Settings->{recent}{config_directory} = dirname($file); wxTheApp->save_settings; # load .ini file my $ini = Slic3r::Config->read_ini($file); if ($ini->{settings}) { $Slic3r::GUI::Settings->{_}{$_} = $ini->{settings}{$_} for keys %{$ini->{settings}}; wxTheApp->save_settings; } if ($ini->{presets}) { $Slic3r::GUI::Settings->{presets} = $ini->{presets}; wxTheApp->save_settings; } if ($ini->{simple}) { my $config = Slic3r::Config->load_ini_hash($ini->{simple}); $config->save("$Slic3r::GUI::datadir/simple.ini"); if ($self->{mode} eq 'simple') { foreach my $tab (values %{$self->{options_tabs}}) { $tab->load_config($config) for values %{$self->{options_tabs}}; } } } my $imported = 0; INI_BLOCK: foreach my $ini_category (sort keys %$ini) { next unless $ini_category =~ /^(print|filament|printer):(.+)$/; my ($section, $preset_name) = ($1, $2); my $config = Slic3r::Config->load_ini_hash($ini->{$ini_category}); next if $skip_no_id && !$config->get($section . "_settings_id"); { my %current_presets = Slic3r::GUI->presets($section); my %current_ids = map { $_ => 1 } grep $_, map Slic3r::Config->load($_)->get($section . "_settings_id"), values %current_presets; next INI_BLOCK if exists $current_ids{$config->get($section . "_settings_id")}; } $config->save(sprintf "$Slic3r::GUI::datadir/%s/%s.ini", $section, $preset_name); Slic3r::debugf "Imported %s preset %s\n", $section, $preset_name; $imported++; } if ($self->{mode} eq 'expert') { foreach my $tab (values %{$self->{options_tabs}}) { $tab->load_presets; } } return if !$imported; my $message = sprintf "%d presets successfully imported.", $imported; if ($self->{mode} eq 'simple' && $Slic3r::GUI::Settings->{_}{mode} eq 'expert') { Slic3r::GUI::show_info($self, "$message You need to restart Slic3r to make the changes effective."); } else { Slic3r::GUI::show_info($self, $message); } } sub load_config { my $self = shift; my ($config) = @_; foreach my $tab (values %{$self->{options_tabs}}) { $tab->load_config($config); } if ($self->{plater}) { $self->{plater}->on_config_change($config); } } sub config_wizard { my $self = shift; return unless $self->check_unsaved_changes; if (my $config = Slic3r::GUI::ConfigWizard->new($self)->run) { if ($self->{mode} eq 'expert') { for my $tab (values %{$self->{options_tabs}}) { $tab->select_default_preset; } } else { # TODO: select default settings in simple mode } $self->load_config($config); if ($self->{mode} eq 'expert') { for my $tab (values %{$self->{options_tabs}}) { $tab->save_preset('My Settings'); } } } } =head2 config This method collects all config values from the tabs and merges them into a single config object. =cut sub config { my $self = shift; return Slic3r::Config->new_from_defaults if !exists $self->{options_tabs}{print} || !exists $self->{options_tabs}{filament} || !exists $self->{options_tabs}{printer}; # retrieve filament presets and build a single config object for them my $filament_config; if (!$self->{plater} || $self->{plater}->filament_presets == 1 || $self->{mode} eq 'simple') { $filament_config = $self->{options_tabs}{filament}->config; } else { my $i = -1; foreach my $preset_idx ($self->{plater}->filament_presets) { $i++; my $config; if ($preset_idx == $self->{options_tabs}{filament}->current_preset) { # the selected preset for this extruder is the one in the tab # use the tab's config instead of the preset in case it is dirty # perhaps plater shouldn't expose dirty presets at all in multi-extruder environments. $config = $self->{options_tabs}{filament}->config; } else { my $preset = $self->{options_tabs}{filament}->get_preset($preset_idx); $config = $self->{options_tabs}{filament}->get_preset_config($preset); } if (!$filament_config) { $filament_config = $config->clone; next; } foreach my $opt_key (@{$config->get_keys}) { my $value = $filament_config->get($opt_key); next unless ref $value eq 'ARRAY'; $value->[$i] = $config->get($opt_key)->[0]; $filament_config->set($opt_key, $value); } } } my $config = Slic3r::Config->merge( Slic3r::Config->new_from_defaults, $self->{options_tabs}{print}->config, $self->{options_tabs}{printer}->config, $filament_config, ); if ($self->{mode} eq 'simple') { # set some sensible defaults $config->set('first_layer_height', $config->nozzle_diameter->[0]); $config->set('avoid_crossing_perimeters', 1); $config->set('infill_every_layers', 10); } else { my $extruders_count = $self->{options_tabs}{printer}{extruders_count}; $config->set("${_}_extruder", min($config->get("${_}_extruder"), $extruders_count)) for qw(perimeter infill solid_infill support_material support_material_interface); } return $config; } sub filament_preset_names { my ($self) = @_; if ($self->{mode} eq 'simple') { return ''; } return map $self->{options_tabs}{filament}->get_preset($_)->name, $self->{plater}->filament_presets; } sub check_unsaved_changes { my $self = shift; my @dirty = (); foreach my $tab (values %{$self->{options_tabs}}) { push @dirty, $tab->title if $tab->is_dirty; } if (@dirty) { my $titles = join ', ', @dirty; my $confirm = Wx::MessageDialog->new($self, "You have unsaved changes ($titles). Discard changes and continue anyway?", 'Unsaved Presets', wxICON_QUESTION | wxYES_NO | wxNO_DEFAULT); return ($confirm->ShowModal == wxID_YES); } return 1; } sub select_tab { my ($self, $tab) = @_; $self->{tabpanel}->SetSelection($tab); } # Set a camera direction, zoom to all objects. sub select_view { my ($self, $direction) = @_; if (! $self->{no_plater}) { $self->{plater}->select_view($direction); } } sub _append_menu_item { my ($self, $menu, $string, $description, $cb, $id, $icon) = @_; $id //= &Wx::NewId(); my $item = $menu->Append($id, $string, $description); $self->_set_menu_item_icon($item, $icon); EVT_MENU($self, $id, $cb); return $item; } sub _set_menu_item_icon { my ($self, $menuItem, $icon) = @_; # SetBitmap was not available on OS X before Wx 0.9927 if ($icon && $menuItem->can('SetBitmap')) { $menuItem->SetBitmap(Wx::Bitmap->new($Slic3r::var->($icon), wxBITMAP_TYPE_PNG)); } } # Called after the Preferences dialog is closed and the program settings are saved. # Update the UI based on the current preferences. sub update_ui_from_settings { my ($self) = @_; $self->{menu_item_reslice_now}->Enable(! $Slic3r::GUI::Settings->{_}{background_processing}); $self->{plater}->update_ui_from_settings if ($self->{plater}); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Notifier.pm000066400000000000000000000026651301441720000211550ustar00rootroot00000000000000# Notify about the end of slicing. # The notifications are sent out using the Growl protocol if installed, and using DBus XWindow protocol. package Slic3r::GUI::Notifier; use Moo; has 'growler' => (is => 'rw'); my $icon = $Slic3r::var->("Slic3r.png"); sub BUILD { my ($self) = @_; if (eval 'use Growl::GNTP; 1') { # register with growl eval { $self->growler(Growl::GNTP->new(AppName => 'Slic3r', AppIcon => $icon)); $self->growler->register([{Name => 'SKEIN_DONE', DisplayName => 'Slicing Done'}]); }; # if register() fails (for example because of a timeout), disable growler at all $self->growler(undef) if $@; } } sub notify { my ($self, $message) = @_; my $title = 'Slicing Done!'; eval { $self->growler->notify(Event => 'SKEIN_DONE', Title => $title, Message => $message) if $self->growler; }; # Net::DBus is broken in multithreaded environment if (0 && eval 'use Net::DBus; 1') { eval { my $session = Net::DBus->session; my $serv = $session->get_service('org.freedesktop.Notifications'); my $notifier = $serv->get_object('/org/freedesktop/Notifications', 'org.freedesktop.Notifications'); $notifier->Notify('Slic3r', 0, $icon, $title, $message, [], {}, -1); undef $Net::DBus::bus_session; }; } } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/OptionsGroup.pm000066400000000000000000000372051301441720000220440ustar00rootroot00000000000000# A dialog group object. Used by the Tab, SimpleTab, Preferences dialog, ManualControlDialog etc. package Slic3r::GUI::OptionsGroup; use Moo; use List::Util qw(first); use Wx qw(:combobox :font :misc :sizer :systemsettings :textctrl wxTheApp); use Wx::Event qw(EVT_CHECKBOX EVT_COMBOBOX EVT_SPINCTRL EVT_TEXT EVT_KILL_FOCUS EVT_SLIDER); has 'parent' => (is => 'ro', required => 1); has 'title' => (is => 'ro', required => 1); has 'on_change' => (is => 'rw', default => sub { sub {} }); has 'staticbox' => (is => 'ro', default => sub { 1 }); has 'label_width' => (is => 'rw', default => sub { 180 }); has 'extra_column' => (is => 'rw', default => sub { undef }); has 'label_font' => (is => 'rw'); has 'sidetext_font' => (is => 'rw', default => sub { Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) }); has 'sizer' => (is => 'rw'); has '_disabled' => (is => 'rw', default => sub { 0 }); has '_grid_sizer' => (is => 'rw'); has '_options' => (is => 'ro', default => sub { {} }); has '_fields' => (is => 'ro', default => sub { {} }); sub BUILD { my $self = shift; if ($self->staticbox) { my $box = Wx::StaticBox->new($self->parent, -1, $self->title); $self->sizer(Wx::StaticBoxSizer->new($box, wxVERTICAL)); } else { $self->sizer(Wx::BoxSizer->new(wxVERTICAL)); } my $num_columns = 1; ++$num_columns if $self->label_width != 0; ++$num_columns if $self->extra_column; $self->_grid_sizer(Wx::FlexGridSizer->new(0, $num_columns, 0, 0)); $self->_grid_sizer->SetFlexibleDirection(wxHORIZONTAL); $self->_grid_sizer->AddGrowableCol($self->label_width != 0); # TODO: border size may be related to wxWidgets 2.8.x vs. 2.9.x instead of wxMAC specific $self->sizer->Add($self->_grid_sizer, 0, wxEXPAND | wxALL, &Wx::wxMAC ? 0 : 5); } # this method accepts a Slic3r::GUI::OptionsGroup::Line object sub append_line { my ($self, $line) = @_; if ($line->sizer || ($line->widget && $line->full_width)) { # full-width widgets are appended *after* the grid sizer, so after all the non-full-width lines my $sizer = $line->sizer // $line->widget->($self->parent); $self->sizer->Add($sizer, 0, wxEXPAND | wxALL, &Wx::wxMAC ? 0 : 15); return; } my $grid_sizer = $self->_grid_sizer; # if we have an extra column, build it if ($self->extra_column) { if (defined (my $item = $self->extra_column->($line))) { $grid_sizer->Add($item, 0, wxALIGN_CENTER_VERTICAL, 0); } else { # if the callback provides no sizer for the extra cell, put a spacer $grid_sizer->AddSpacer(1); } } # build label if we have it my $label; if ($self->label_width != 0) { $label = Wx::StaticText->new($self->parent, -1, $line->label ? $line->label . ":" : "", wxDefaultPosition, [$self->label_width, -1]); $label->SetFont($self->label_font) if $self->label_font; $label->Wrap($self->label_width) ; # needed to avoid Linux/GTK bug $grid_sizer->Add($label, 0, wxALIGN_CENTER_VERTICAL, 0); $label->SetToolTipString($line->label_tooltip) if $line->label_tooltip; } # if we have a widget, add it to the sizer if ($line->widget) { my $widget_sizer = $line->widget->($self->parent); $grid_sizer->Add($widget_sizer, 0, wxEXPAND | wxALL, &Wx::wxMAC ? 0 : 15); return; } # if we have a single option with no sidetext just add it directly to the grid sizer my @options = @{$line->get_options}; $self->_options->{$_->opt_id} = $_ for @options; if (@options == 1 && !$options[0]->sidetext && !$options[0]->side_widget && !@{$line->get_extra_widgets}) { my $option = $options[0]; my $field = $self->_build_field($option); $grid_sizer->Add($field, 0, ($option->full_width ? wxEXPAND : 0) | wxALIGN_CENTER_VERTICAL, 0); return; } # if we're here, we have more than one option or a single option with sidetext # so we need a horizontal sizer to arrange these things my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $grid_sizer->Add($sizer, 0, 0, 0); foreach my $i (0..$#options) { my $option = $options[$i]; # add label if any if ($option->label) { my $field_label = Wx::StaticText->new($self->parent, -1, $option->label . ":", wxDefaultPosition, wxDefaultSize); $field_label->SetFont($self->sidetext_font); $sizer->Add($field_label, 0, wxALIGN_CENTER_VERTICAL, 0); } # add field my $field = $self->_build_field($option); $sizer->Add($field, 0, wxALIGN_CENTER_VERTICAL, 0); # add sidetext if any if ($option->sidetext) { my $sidetext = Wx::StaticText->new($self->parent, -1, $option->sidetext, wxDefaultPosition, wxDefaultSize); $sidetext->SetFont($self->sidetext_font); $sizer->Add($sidetext, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, 4); } # add side widget if any if ($option->side_widget) { $sizer->Add($option->side_widget->($self->parent), 0, wxLEFT | wxALIGN_CENTER_VERTICAL, 1); } if ($option != $#options) { $sizer->AddSpacer(4); } } # add extra sizers if any foreach my $extra_widget (@{$line->get_extra_widgets}) { $sizer->Add($extra_widget->($self->parent), 0, wxLEFT | wxALIGN_CENTER_VERTICAL , 4); } } sub create_single_option_line { my ($self, $option) = @_; my $line = Slic3r::GUI::OptionsGroup::Line->new( label => $option->label, label_tooltip => $option->tooltip, ); $option->label(""); $line->append_option($option); return $line; } sub append_single_option_line { my ($self, $option) = @_; return $self->append_line($self->create_single_option_line($option)); } sub _build_field { my $self = shift; my ($opt) = @_; my $opt_id = $opt->opt_id; my $on_change = sub { my ($opt_id, $value) = @_; $self->_on_change($opt_id, $value) unless $self->_disabled; }; my $on_kill_focus = sub { my ($opt_id) = @_; $self->_on_kill_focus($opt_id); }; my $type = $opt->{gui_type} || $opt->{type}; my $field; if ($type eq 'bool') { $field = Slic3r::GUI::OptionsGroup::Field::Checkbox->new( parent => $self->parent, option => $opt, ); } elsif ($type eq 'i') { $field = Slic3r::GUI::OptionsGroup::Field::SpinCtrl->new( parent => $self->parent, option => $opt, ); } elsif ($type eq 'color') { $field = Slic3r::GUI::OptionsGroup::Field::ColourPicker->new( parent => $self->parent, option => $opt, ); } elsif ($type =~ /^(f|s|s@|percent)$/) { $field = Slic3r::GUI::OptionsGroup::Field::TextCtrl->new( parent => $self->parent, option => $opt, ); } elsif ($type eq 'select' || $type eq 'select_open') { $field = Slic3r::GUI::OptionsGroup::Field::Choice->new( parent => $self->parent, option => $opt, ); } elsif ($type eq 'f_enum_open' || $type eq 'i_enum_open' || $type eq 'i_enum_closed') { $field = Slic3r::GUI::OptionsGroup::Field::NumericChoice->new( parent => $self->parent, option => $opt, ); } elsif ($type eq 'point') { $field = Slic3r::GUI::OptionsGroup::Field::Point->new( parent => $self->parent, option => $opt, ); } elsif ($type eq 'slider') { $field = Slic3r::GUI::OptionsGroup::Field::Slider->new( parent => $self->parent, option => $opt, ); } return undef if !$field; $field->on_change($on_change); $field->on_kill_focus($on_kill_focus); $self->_fields->{$opt_id} = $field; return $field->isa('Slic3r::GUI::OptionsGroup::Field::wxWindow') ? $field->wxWindow : $field->wxSizer; } sub get_option { my ($self, $opt_id) = @_; return undef if !exists $self->_options->{$opt_id}; return $self->_options->{$opt_id}; } sub get_field { my ($self, $opt_id) = @_; return undef if !exists $self->_fields->{$opt_id}; return $self->_fields->{$opt_id}; } sub get_value { my ($self, $opt_id) = @_; return if !exists $self->_fields->{$opt_id}; return $self->_fields->{$opt_id}->get_value; } sub set_value { my ($self, $opt_id, $value) = @_; return if !exists $self->_fields->{$opt_id}; $self->_fields->{$opt_id}->set_value($value); } sub _on_change { my ($self, $opt_id, $value) = @_; $self->on_change->($opt_id, $value); } sub enable { my ($self) = @_; $_->enable for values %{$self->_fields}; } sub disable { my ($self) = @_; $_->disable for values %{$self->_fields}; } sub _on_kill_focus { my ($self, $opt_id) = @_; # nothing } package Slic3r::GUI::OptionsGroup::Line; use Moo; has 'label' => (is => 'rw', default => sub { "" }); has 'full_width' => (is => 'rw', default => sub { 0 }); has 'label_tooltip' => (is => 'rw', default => sub { "" }); has 'sizer' => (is => 'rw'); has 'widget' => (is => 'rw'); has '_options' => (is => 'ro', default => sub { [] }); has '_extra_widgets' => (is => 'ro', default => sub { [] }); # this method accepts a Slic3r::GUI::OptionsGroup::Option object sub append_option { my ($self, $option) = @_; push @{$self->_options}, $option; } sub append_widget { my ($self, $widget) = @_; push @{$self->_extra_widgets}, $widget; } sub get_options { my ($self) = @_; return [ @{$self->_options} ]; } sub get_extra_widgets { my ($self) = @_; return [ @{$self->_extra_widgets} ]; } package Slic3r::GUI::OptionsGroup::Option; use Moo; has 'opt_id' => (is => 'rw', required => 1); has 'type' => (is => 'rw', required => 1); has 'default' => (is => 'rw', required => 1); has 'gui_type' => (is => 'rw', default => sub { undef }); has 'gui_flags' => (is => 'rw', default => sub { "" }); has 'label' => (is => 'rw', default => sub { "" }); has 'sidetext' => (is => 'rw', default => sub { "" }); has 'tooltip' => (is => 'rw', default => sub { "" }); has 'multiline' => (is => 'rw', default => sub { 0 }); has 'full_width' => (is => 'rw', default => sub { 0 }); has 'width' => (is => 'rw', default => sub { undef }); has 'height' => (is => 'rw', default => sub { undef }); has 'min' => (is => 'rw', default => sub { undef }); has 'max' => (is => 'rw', default => sub { undef }); has 'labels' => (is => 'rw', default => sub { [] }); has 'values' => (is => 'rw', default => sub { [] }); has 'readonly' => (is => 'rw', default => sub { 0 }); has 'side_widget' => (is => 'rw', default => sub { undef }); package Slic3r::GUI::ConfigOptionsGroup; use Moo; use List::Util qw(first); extends 'Slic3r::GUI::OptionsGroup'; has 'config' => (is => 'ro', required => 1); has 'full_labels' => (is => 'ro', default => sub { 0 }); has '_opt_map' => (is => 'ro', default => sub { {} }); sub get_option { my ($self, $opt_key, $opt_index) = @_; $opt_index //= -1; if (!$self->config->has($opt_key)) { die "No $opt_key in ConfigOptionsGroup config"; } my $opt_id = ($opt_index == -1 ? $opt_key : "${opt_key}#${opt_index}"); $self->_opt_map->{$opt_id} = [ $opt_key, $opt_index ]; my $optdef = $Slic3r::Config::Options->{$opt_key}; # we should access this from $self->config my $default_value = $self->_get_config_value($opt_key, $opt_index, $optdef->{gui_flags} =~ /\bserialized\b/); return Slic3r::GUI::OptionsGroup::Option->new( opt_id => $opt_id, type => $optdef->{type}, default => $default_value, gui_type => $optdef->{gui_type}, gui_flags => $optdef->{gui_flags}, label => ($self->full_labels && defined $optdef->{full_label}) ? $optdef->{full_label} : $optdef->{label}, sidetext => $optdef->{sidetext}, # calling serialize() ensures we get a stringified value tooltip => $optdef->{tooltip} . " (default: " . $self->config->serialize($opt_key) . ")", multiline => $optdef->{multiline}, width => $optdef->{width}, min => $optdef->{min}, max => $optdef->{max}, labels => $optdef->{labels}, values => $optdef->{values}, readonly => $optdef->{readonly}, ); } sub create_single_option_line { my ($self, $opt_key, $opt_index) = @_; my $option; if (ref($opt_key)) { $option = $opt_key; } else { $option = $self->get_option($opt_key, $opt_index); } return $self->SUPER::create_single_option_line($option); } sub append_single_option_line { my ($self, $option, $opt_index) = @_; return $self->append_line($self->create_single_option_line($option, $opt_index)); } sub reload_config { my ($self) = @_; foreach my $opt_id (keys %{ $self->_opt_map }) { my ($opt_key, $opt_index) = @{ $self->_opt_map->{$opt_id} }; my $option = $self->_options->{$opt_id}; $self->set_value($opt_id, $self->_get_config_value($opt_key, $opt_index, $option->gui_flags =~ /\bserialized\b/)); } } sub get_fieldc { my ($self, $opt_key, $opt_index) = @_; $opt_index //= -1; my $opt_id = first { $self->_opt_map->{$_}[0] eq $opt_key && $self->_opt_map->{$_}[1] == $opt_index } keys %{$self->_opt_map}; return defined($opt_id) ? $self->get_field($opt_id) : undef; } sub _get_config_value { my ($self, $opt_key, $opt_index, $deserialize) = @_; if ($deserialize) { die "Can't deserialize option indexed value" if $opt_index != -1; return $self->config->serialize($opt_key); } else { return $opt_index == -1 ? $self->config->get($opt_key) : $self->config->get_at($opt_key, $opt_index); } } sub _on_change { my ($self, $opt_id, $value) = @_; if (exists $self->_opt_map->{$opt_id}) { my ($opt_key, $opt_index) = @{ $self->_opt_map->{$opt_id} }; my $option = $self->_options->{$opt_id}; # get value my $field_value = $self->get_value($opt_id); if ($option->gui_flags =~ /\bserialized\b/) { die "Can't set serialized option indexed value" if $opt_index != -1; $self->config->set_deserialize($opt_key, $field_value); } else { if ($opt_index == -1) { $self->config->set($opt_key, $field_value); } else { my $value = $self->config->get($opt_key); $value->[$opt_index] = $field_value; $self->config->set($opt_key, $value); } } } $self->SUPER::_on_change($opt_id, $value); } sub _on_kill_focus { my ($self, $opt_id) = @_; # when a field loses focus, reapply the config value to it # (thus discarding any invalid input and reverting to the last # accepted value) $self->reload_config; } package Slic3r::GUI::OptionsGroup::StaticText; use Wx qw(:misc :systemsettings); use base 'Wx::StaticText'; sub new { my ($class, $parent) = @_; my $self = $class->SUPER::new($parent, -1, "", wxDefaultPosition, wxDefaultSize); my $font = Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); $self->SetFont($font); return $self; } sub SetText { my ($self, $value) = @_; $self->SetLabel($value); $self->Wrap(400); $self->GetParent->Layout; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/OptionsGroup/000077500000000000000000000000001301441720000214775ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/GUI/OptionsGroup/Field.pm000066400000000000000000000374201301441720000230660ustar00rootroot00000000000000package Slic3r::GUI::OptionsGroup::Field; use Moo; # This is a base class for option fields. has 'parent' => (is => 'ro', required => 1); has 'option' => (is => 'ro', required => 1); # Slic3r::GUI::OptionsGroup::Option has 'on_change' => (is => 'rw', default => sub { sub {} }); has 'on_kill_focus' => (is => 'rw', default => sub { sub {} }); has 'disable_change_event' => (is => 'rw', default => sub { 0 }); # This method should not fire the on_change event sub set_value { my ($self, $value) = @_; die "Method not implemented"; } sub get_value { my ($self) = @_; die "Method not implemented"; } sub set_tooltip { my ($self, $tooltip) = @_; $self->SetToolTipString($tooltip) if $tooltip && $self->can('SetToolTipString'); } sub toggle { my ($self, $enable) = @_; $enable ? $self->enable : $self->disable; } sub _on_change { my ($self, $opt_id) = @_; $self->on_change->($opt_id, $self->get_value) unless $self->disable_change_event; } sub _on_kill_focus { my ($self, $opt_id, $s, $event) = @_; # Without this, there will be nasty focus bugs on Windows. # Also, docs for wxEvent::Skip() say "In general, it is recommended to skip all # non-command events to allow the default handling to take place." $event->Skip(1); $self->on_kill_focus->($opt_id); } package Slic3r::GUI::OptionsGroup::Field::wxWindow; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field'; has 'wxWindow' => (is => 'rw', trigger => 1); # wxWindow object sub _default_size { my ($self) = @_; # default width on Windows is too large return Wx::Size->new($self->option->width || 60, $self->option->height || -1); } sub _trigger_wxWindow { my ($self) = @_; $self->wxWindow->SetToolTipString($self->option->tooltip) if $self->option->tooltip && $self->wxWindow->can('SetToolTipString'); } sub set_value { my ($self, $value) = @_; $self->disable_change_event(1); $self->wxWindow->SetValue($value); $self->disable_change_event(0); } sub get_value { my ($self) = @_; return $self->wxWindow->GetValue; } sub enable { my ($self) = @_; $self->wxWindow->Enable; $self->wxWindow->Refresh; } sub disable { my ($self) = @_; $self->wxWindow->Disable; $self->wxWindow->Refresh; } package Slic3r::GUI::OptionsGroup::Field::Checkbox; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxWindow'; use Wx qw(:misc); use Wx::Event qw(EVT_CHECKBOX); sub BUILD { my ($self) = @_; my $field = Wx::CheckBox->new($self->parent, -1, ""); $self->wxWindow($field); $field->SetValue($self->option->default); $field->Disable if $self->option->readonly; EVT_CHECKBOX($self->parent, $field, sub { $self->_on_change($self->option->opt_id); }); } package Slic3r::GUI::OptionsGroup::Field::SpinCtrl; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxWindow'; use Wx qw(:misc); use Wx::Event qw(EVT_SPINCTRL EVT_TEXT EVT_KILL_FOCUS); has 'tmp_value' => (is => 'rw'); sub BUILD { my ($self) = @_; my $field = Wx::SpinCtrl->new($self->parent, -1, $self->option->default, wxDefaultPosition, $self->_default_size, 0, $self->option->min || 0, $self->option->max || 2147483647, $self->option->default); $self->wxWindow($field); EVT_SPINCTRL($self->parent, $field, sub { $self->tmp_value(undef); $self->_on_change($self->option->opt_id); }); EVT_TEXT($self->parent, $field, sub { my ($s, $event) = @_; # On OSX/Cocoa, wxSpinCtrl::GetValue() doesn't return the new value # when it was changed from the text control, so the on_change callback # gets the old one, and on_kill_focus resets the control to the old value. # As a workaround, we get the new value from $event->GetString and store # here temporarily so that we can return it from $self->get_value $self->tmp_value($event->GetString) if $event->GetString =~ /^\d+$/; $self->_on_change($self->option->opt_id); # We don't reset tmp_value here because _on_change might put callbacks # in the CallAfter queue, and we want the tmp value to be available from # them as well. }); EVT_KILL_FOCUS($field, sub { $self->tmp_value(undef); $self->_on_kill_focus($self->option->opt_id, @_); }); } sub get_value { my ($self) = @_; return $self->tmp_value // $self->wxWindow->GetValue; } package Slic3r::GUI::OptionsGroup::Field::TextCtrl; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxWindow'; use Wx qw(:misc :textctrl); use Wx::Event qw(EVT_TEXT EVT_KILL_FOCUS); sub BUILD { my ($self) = @_; my $style = 0; $style = wxTE_MULTILINE if $self->option->multiline; my $field = Wx::TextCtrl->new($self->parent, -1, $self->option->default, wxDefaultPosition, $self->_default_size, $style); $self->wxWindow($field); # TODO: test loading a config that has empty string for multi-value options like 'wipe' EVT_TEXT($self->parent, $field, sub { $self->_on_change($self->option->opt_id); }); EVT_KILL_FOCUS($field, sub { $self->_on_kill_focus($self->option->opt_id, @_); }); } sub enable { my ($self) = @_; $self->wxWindow->Enable; $self->wxWindow->SetEditable(1); } sub disable { my ($self) = @_; $self->wxWindow->Disable; $self->wxWindow->SetEditable(0); } package Slic3r::GUI::OptionsGroup::Field::Choice; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxWindow'; use List::Util qw(first); use Wx qw(:misc :combobox); use Wx::Event qw(EVT_COMBOBOX EVT_TEXT); sub BUILD { my ($self) = @_; my $style = 0; $style |= wxCB_READONLY if defined $self->option->gui_type && $self->option->gui_type ne 'select_open'; my $field = Wx::ComboBox->new($self->parent, -1, "", wxDefaultPosition, $self->_default_size, $self->option->labels || $self->option->values || [], $style); $self->wxWindow($field); $self->set_value($self->option->default); EVT_COMBOBOX($self->parent, $field, sub { $self->_on_change($self->option->opt_id); }); EVT_TEXT($self->parent, $field, sub { $self->_on_change($self->option->opt_id); }); } sub set_value { my ($self, $value) = @_; $self->disable_change_event(1); my $idx; if ($self->option->values) { $idx = first { $self->option->values->[$_] eq $value } 0..$#{$self->option->values}; # if value is not among indexes values we use SetValue() } if (defined $idx) { $self->wxWindow->SetSelection($idx); } else { $self->wxWindow->SetValue($value); } $self->disable_change_event(0); } sub set_values { my ($self, $values) = @_; $self->disable_change_event(1); # it looks that Clear() also clears the text field in recent wxWidgets versions, # but we want to preserve it my $ww = $self->wxWindow; my $value = $ww->GetValue; $ww->Clear; $ww->Append($_) for @$values; $ww->SetValue($value); $self->disable_change_event(0); } sub get_value { my ($self) = @_; if ($self->option->values) { my $idx = $self->wxWindow->GetSelection; if ($idx != &Wx::wxNOT_FOUND) { return $self->option->values->[$idx]; } } return $self->wxWindow->GetValue; } package Slic3r::GUI::OptionsGroup::Field::NumericChoice; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxWindow'; use List::Util qw(first); use Wx qw(wxTheApp :misc :combobox); use Wx::Event qw(EVT_COMBOBOX EVT_TEXT); # if option has no 'values', indices are values # if option has no 'labels', values are labels sub BUILD { my ($self) = @_; my $field = Wx::ComboBox->new($self->parent, -1, $self->option->default, wxDefaultPosition, $self->_default_size, $self->option->labels || $self->option->values); $self->wxWindow($field); $self->set_value($self->option->default); EVT_COMBOBOX($self->parent, $field, sub { my $disable_change_event = $self->disable_change_event; $self->disable_change_event(1); my $idx = $field->GetSelection; # get index of selected value my $label; if ($self->option->labels && $idx <= $#{$self->option->labels}) { $label = $self->option->labels->[$idx]; } elsif ($self->option->values && $idx <= $#{$self->option->values}) { $label = $self->option->values->[$idx]; } else { $label = $idx; } # The MSW implementation of wxComboBox will leave the field blank if we call # SetValue() in the EVT_COMBOBOX event handler, so we postpone the call. wxTheApp->CallAfter(sub { my $dce = $self->disable_change_event; $self->disable_change_event(1); # ChangeValue() is not exported in wxPerl $field->SetValue($label); $self->disable_change_event($dce); }); $self->disable_change_event($disable_change_event); $self->_on_change($self->option->opt_id); }); EVT_TEXT($self->parent, $field, sub { $self->_on_change($self->option->opt_id); }); } sub set_value { my ($self, $value) = @_; $self->disable_change_event(1); my $field = $self->wxWindow; if ($self->option->gui_flags =~ /\bshow_value\b/) { $field->SetValue($value); } else { if ($self->option->values) { # check whether we have a value index my $value_idx = first { $self->option->values->[$_] eq $value } 0..$#{$self->option->values}; if (defined $value_idx) { $field->SetSelection($value_idx); $self->disable_change_event(0); return; } } elsif ($self->option->labels && $value <= $#{$self->option->labels}) { # if we have no values, we expect value to be an index $field->SetValue($self->option->labels->[$value]); $self->disable_change_event(0); return; } $field->SetValue($value); } $self->disable_change_event(0); } sub get_value { my ($self) = @_; my $label = $self->wxWindow->GetValue; if ($self->option->labels) { my $value_idx = first { $self->option->labels->[$_] eq $label } 0..$#{$self->option->labels}; if (defined $value_idx) { if ($self->option->values) { return $self->option->values->[$value_idx]; } return $value_idx; } } return $label; } package Slic3r::GUI::OptionsGroup::Field::ColourPicker; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxWindow'; use Wx qw(:misc :colour); use Wx::Event qw(EVT_COLOURPICKER_CHANGED); sub BUILD { my ($self) = @_; my $field = Wx::ColourPickerCtrl->new($self->parent, -1, $self->_string_to_colour($self->option->default), wxDefaultPosition, $self->_default_size); $self->wxWindow($field); EVT_COLOURPICKER_CHANGED($self->parent, $field, sub { $self->_on_change($self->option->opt_id); }); } sub set_value { my ($self, $value) = @_; $self->disable_change_event(1); $self->wxWindow->SetColour($self->_string_to_colour($value)); $self->disable_change_event(0); } sub get_value { my ($self) = @_; return $self->wxWindow->GetColour->GetAsString(wxC2S_HTML_SYNTAX); } sub _string_to_colour { my ($self, $string) = @_; $string =~ s/^#//; return Wx::Colour->new(unpack 'C*', pack 'H*', $string); } package Slic3r::GUI::OptionsGroup::Field::wxSizer; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field'; has 'wxSizer' => (is => 'rw'); # wxSizer object package Slic3r::GUI::OptionsGroup::Field::Point; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxSizer'; has 'x_textctrl' => (is => 'rw'); has 'y_textctrl' => (is => 'rw'); use Slic3r::Geometry qw(X Y); use Wx qw(:misc :sizer); use Wx::Event qw(EVT_TEXT); sub BUILD { my ($self) = @_; my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $self->wxSizer($sizer); my $field_size = Wx::Size->new(40, -1); $self->x_textctrl(Wx::TextCtrl->new($self->parent, -1, $self->option->default->[X], wxDefaultPosition, $field_size)); $self->y_textctrl(Wx::TextCtrl->new($self->parent, -1, $self->option->default->[Y], wxDefaultPosition, $field_size)); my @items = ( Wx::StaticText->new($self->parent, -1, "x:"), $self->x_textctrl, Wx::StaticText->new($self->parent, -1, " y:"), $self->y_textctrl, ); $sizer->Add($_, 0, wxALIGN_CENTER_VERTICAL, 0) for @items; if ($self->option->tooltip) { foreach my $item (@items) { $item->SetToolTipString($self->option->tooltip) if $item->can('SetToolTipString'); } } EVT_TEXT($self->parent, $_, sub { $self->_on_change($self->option->opt_id); }) for $self->x_textctrl, $self->y_textctrl; } sub set_value { my ($self, $value) = @_; $self->disable_change_event(1); $self->x_textctrl->SetValue($value->[X]); $self->y_textctrl->SetValue($value->[Y]); $self->disable_change_event(0); } sub get_value { my ($self) = @_; return [ $self->x_textctrl->GetValue, $self->y_textctrl->GetValue, ]; } sub enable { my ($self) = @_; $self->x_textctrl->Enable; $self->y_textctrl->Enable; } sub disable { my ($self) = @_; $self->x_textctrl->Disable; $self->y_textctrl->Disable; } package Slic3r::GUI::OptionsGroup::Field::Slider; use Moo; extends 'Slic3r::GUI::OptionsGroup::Field::wxSizer'; has 'scale' => (is => 'rw', default => sub { 10 }); has 'slider' => (is => 'rw'); has 'textctrl' => (is => 'rw'); use Slic3r::Geometry qw(X Y); use Wx qw(:misc :sizer); use Wx::Event qw(EVT_SLIDER EVT_TEXT EVT_KILL_FOCUS); sub BUILD { my ($self) = @_; my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $self->wxSizer($sizer); my $slider = Wx::Slider->new( $self->parent, -1, ($self->option->default // $self->option->min) * $self->scale, ($self->option->min // 0) * $self->scale, ($self->option->max // 100) * $self->scale, wxDefaultPosition, [ $self->option->width // -1, $self->option->height // -1 ], ); $self->slider($slider); my $textctrl = Wx::TextCtrl->new($self->parent, -1, $slider->GetValue/$self->scale, wxDefaultPosition, [50,-1]); $self->textctrl($textctrl); $sizer->Add($slider, 1, wxALIGN_CENTER_VERTICAL, 0); $sizer->Add($textctrl, 0, wxALIGN_CENTER_VERTICAL, 0); EVT_SLIDER($self->parent, $slider, sub { $self->_update_textctrl; $self->_on_change($self->option->opt_id); }); EVT_TEXT($self->parent, $textctrl, sub { my $value = $textctrl->GetValue; if ($value =~ /^-?\d+(\.\d*)?$/) { $self->set_value($value); $self->_on_change($self->option->opt_id); } }); EVT_KILL_FOCUS($textctrl, sub { $self->_on_kill_focus($self->option->opt_id, @_); }); } sub set_value { my ($self, $value) = @_; $self->disable_change_event(1); $self->slider->SetValue($value*$self->scale); $self->_update_textctrl; $self->disable_change_event(0); } sub get_value { my ($self) = @_; return $self->slider->GetValue/$self->scale; } sub _update_textctrl { my ($self) = @_; $self->textctrl->SetLabel($self->get_value); } sub enable { my ($self) = @_; $self->slider->Enable; $self->textctrl->Enable; $self->textctrl->SetEditable(1); } sub disable { my ($self) = @_; $self->slider->Disable; $self->textctrl->Disable; $self->textctrl->SetEditable(0); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater.pm000066400000000000000000002305401301441720000206200ustar00rootroot00000000000000# The "Plater" tab. It contains the "3D", "2D", "Preview" and "Layers" subtabs. package Slic3r::GUI::Plater; use strict; use warnings; use utf8; use File::Basename qw(basename dirname); use List::Util qw(sum first max); use Slic3r::Geometry qw(X Y Z MIN MAX scale unscale deg2rad); use threads::shared qw(shared_clone); use Wx qw(:button :cursor :dialog :filedialog :keycode :icon :font :id :listctrl :misc :panel :sizer :toolbar :window wxTheApp :notebook :combobox); use Wx::Event qw(EVT_BUTTON EVT_COMMAND EVT_KEY_DOWN EVT_LIST_ITEM_ACTIVATED EVT_LIST_ITEM_DESELECTED EVT_LIST_ITEM_SELECTED EVT_MOUSE_EVENTS EVT_PAINT EVT_TOOL EVT_CHOICE EVT_COMBOBOX EVT_TIMER EVT_NOTEBOOK_PAGE_CHANGED); use base 'Wx::Panel'; use constant TB_ADD => &Wx::NewId; use constant TB_REMOVE => &Wx::NewId; use constant TB_RESET => &Wx::NewId; use constant TB_ARRANGE => &Wx::NewId; use constant TB_EXPORT_GCODE => &Wx::NewId; use constant TB_EXPORT_STL => &Wx::NewId; use constant TB_MORE => &Wx::NewId; use constant TB_FEWER => &Wx::NewId; use constant TB_45CW => &Wx::NewId; use constant TB_45CCW => &Wx::NewId; use constant TB_SCALE => &Wx::NewId; use constant TB_SPLIT => &Wx::NewId; use constant TB_CUT => &Wx::NewId; use constant TB_SETTINGS => &Wx::NewId; # package variables to avoid passing lexicals to threads our $THUMBNAIL_DONE_EVENT : shared = Wx::NewEventType; our $PROGRESS_BAR_EVENT : shared = Wx::NewEventType; our $ERROR_EVENT : shared = Wx::NewEventType; # Emitted from the worker thread when the G-code export is finished. our $EXPORT_COMPLETED_EVENT : shared = Wx::NewEventType; our $PROCESS_COMPLETED_EVENT : shared = Wx::NewEventType; use constant FILAMENT_CHOOSERS_SPACING => 0; use constant PROCESS_DELAY => 0.5 * 1000; # milliseconds my $PreventListEvents = 0; sub new { my $class = shift; my ($parent) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL); $self->{config} = Slic3r::Config->new_from_defaults(qw( bed_shape complete_objects extruder_clearance_radius skirts skirt_distance brim_width serial_port serial_speed octoprint_host octoprint_apikey )); $self->{model} = Slic3r::Model->new; $self->{print} = Slic3r::Print->new; # List of Perl objects Slic3r::GUI::Plater::Object, representing a 2D preview of the platter. $self->{objects} = []; $self->{print}->set_status_cb(sub { my ($percent, $message) = @_; if ($Slic3r::have_threads) { Wx::PostEvent($self, Wx::PlThreadEvent->new(-1, $PROGRESS_BAR_EVENT, shared_clone([$percent, $message]))); } else { $self->on_progress_event($percent, $message); } }); # Initialize preview notebook $self->{preview_notebook} = Wx::Notebook->new($self, -1, wxDefaultPosition, [335,335], wxNB_BOTTOM); # Initialize handlers for canvases my $on_select_object = sub { my ($obj_idx) = @_; $self->select_object($obj_idx); }; my $on_double_click = sub { $self->object_settings_dialog if $self->selected_object; }; my $on_right_click = sub { my ($canvas, $click_pos) = @_; my ($obj_idx, $object) = $self->selected_object; return if !defined $obj_idx; my $menu = $self->object_menu; $canvas->PopupMenu($menu, $click_pos); $menu->Destroy; }; my $on_instances_moved = sub { $self->update; }; # Initialize 3D plater if ($Slic3r::GUI::have_OpenGL) { $self->{canvas3D} = Slic3r::GUI::Plater::3D->new($self->{preview_notebook}, $self->{objects}, $self->{model}, $self->{config}); $self->{preview_notebook}->AddPage($self->{canvas3D}, '3D'); $self->{canvas3D}->set_on_select_object($on_select_object); $self->{canvas3D}->set_on_double_click($on_double_click); $self->{canvas3D}->set_on_right_click(sub { $on_right_click->($self->{canvas3D}, @_); }); $self->{canvas3D}->set_on_instances_moved($on_instances_moved); $self->{canvas3D}->on_viewport_changed(sub { $self->{preview3D}->canvas->set_viewport_from_scene($self->{canvas3D}); }); } # Initialize 2D preview canvas $self->{canvas} = Slic3r::GUI::Plater::2D->new($self->{preview_notebook}, wxDefaultSize, $self->{objects}, $self->{model}, $self->{config}); $self->{preview_notebook}->AddPage($self->{canvas}, '2D'); $self->{canvas}->on_select_object($on_select_object); $self->{canvas}->on_double_click($on_double_click); $self->{canvas}->on_right_click(sub { $on_right_click->($self->{canvas}, @_); }); $self->{canvas}->on_instances_moved($on_instances_moved); # Initialize 3D toolpaths preview if ($Slic3r::GUI::have_OpenGL) { $self->{preview3D} = Slic3r::GUI::Plater::3DPreview->new($self->{preview_notebook}, $self->{print}); $self->{preview3D}->canvas->on_viewport_changed(sub { $self->{canvas3D}->set_viewport_from_scene($self->{preview3D}->canvas); }); $self->{preview_notebook}->AddPage($self->{preview3D}, 'Preview'); $self->{preview3D_page_idx} = $self->{preview_notebook}->GetPageCount-1; } # Initialize toolpaths preview if ($Slic3r::GUI::have_OpenGL) { $self->{toolpaths2D} = Slic3r::GUI::Plater::2DToolpaths->new($self->{preview_notebook}, $self->{print}); $self->{preview_notebook}->AddPage($self->{toolpaths2D}, 'Layers'); } EVT_NOTEBOOK_PAGE_CHANGED($self, $self->{preview_notebook}, sub { if ($self->{preview_notebook}->GetSelection == $self->{preview3D_page_idx}) { $self->{preview3D}->load_print; } }); # toolbar for object manipulation if (!&Wx::wxMSW) { Wx::ToolTip::Enable(1); $self->{htoolbar} = Wx::ToolBar->new($self, -1, wxDefaultPosition, wxDefaultSize, wxTB_HORIZONTAL | wxTB_TEXT | wxBORDER_SIMPLE | wxTAB_TRAVERSAL); $self->{htoolbar}->AddTool(TB_ADD, "Add…", Wx::Bitmap->new($Slic3r::var->("brick_add.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_REMOVE, "Delete", Wx::Bitmap->new($Slic3r::var->("brick_delete.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_RESET, "Delete All", Wx::Bitmap->new($Slic3r::var->("cross.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_ARRANGE, "Arrange", Wx::Bitmap->new($Slic3r::var->("bricks.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddSeparator; $self->{htoolbar}->AddTool(TB_MORE, "More", Wx::Bitmap->new($Slic3r::var->("add.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_FEWER, "Fewer", Wx::Bitmap->new($Slic3r::var->("delete.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddSeparator; $self->{htoolbar}->AddTool(TB_45CCW, "45° ccw", Wx::Bitmap->new($Slic3r::var->("arrow_rotate_anticlockwise.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_45CW, "45° cw", Wx::Bitmap->new($Slic3r::var->("arrow_rotate_clockwise.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_SCALE, "Scale…", Wx::Bitmap->new($Slic3r::var->("arrow_out.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_SPLIT, "Split", Wx::Bitmap->new($Slic3r::var->("shape_ungroup.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddTool(TB_CUT, "Cut…", Wx::Bitmap->new($Slic3r::var->("package.png"), wxBITMAP_TYPE_PNG), ''); $self->{htoolbar}->AddSeparator; $self->{htoolbar}->AddTool(TB_SETTINGS, "Settings…", Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG), ''); } else { my %tbar_buttons = ( add => "Add…", remove => "Delete", reset => "Delete All", arrange => "Arrange", increase => "", decrease => "", rotate45ccw => "", rotate45cw => "", changescale => "Scale…", split => "Split", cut => "Cut…", settings => "Settings…", ); $self->{btoolbar} = Wx::BoxSizer->new(wxHORIZONTAL); for (qw(add remove reset arrange increase decrease rotate45ccw rotate45cw changescale split cut settings)) { $self->{"btn_$_"} = Wx::Button->new($self, -1, $tbar_buttons{$_}, wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT); $self->{btoolbar}->Add($self->{"btn_$_"}); } } $self->{list} = Wx::ListView->new($self, -1, wxDefaultPosition, wxDefaultSize, wxLC_SINGLE_SEL | wxLC_REPORT | wxBORDER_SUNKEN | wxTAB_TRAVERSAL | wxWANTS_CHARS ); $self->{list}->InsertColumn(0, "Name", wxLIST_FORMAT_LEFT, 145); $self->{list}->InsertColumn(1, "Copies", wxLIST_FORMAT_CENTER, 45); $self->{list}->InsertColumn(2, "Scale", wxLIST_FORMAT_CENTER, wxLIST_AUTOSIZE_USEHEADER); EVT_LIST_ITEM_SELECTED($self, $self->{list}, \&list_item_selected); EVT_LIST_ITEM_DESELECTED($self, $self->{list}, \&list_item_deselected); EVT_LIST_ITEM_ACTIVATED($self, $self->{list}, \&list_item_activated); EVT_KEY_DOWN($self->{list}, sub { my ($list, $event) = @_; if ($event->GetKeyCode == WXK_TAB) { $list->Navigate($event->ShiftDown ? &Wx::wxNavigateBackward : &Wx::wxNavigateForward); } else { $event->Skip; } }); # right pane buttons $self->{btn_export_gcode} = Wx::Button->new($self, -1, "Export G-code…", wxDefaultPosition, [-1, 30], wxBU_LEFT); $self->{btn_reslice} = Wx::Button->new($self, -1, "Slice now", wxDefaultPosition, [-1, 30], wxBU_LEFT); $self->{btn_print} = Wx::Button->new($self, -1, "Print…", wxDefaultPosition, [-1, 30], wxBU_LEFT); $self->{btn_send_gcode} = Wx::Button->new($self, -1, "Send to printer", wxDefaultPosition, [-1, 30], wxBU_LEFT); $self->{btn_export_stl} = Wx::Button->new($self, -1, "Export STL…", wxDefaultPosition, [-1, 30], wxBU_LEFT); #$self->{btn_export_gcode}->SetFont($Slic3r::GUI::small_font); #$self->{btn_export_stl}->SetFont($Slic3r::GUI::small_font); $self->{btn_print}->Hide; $self->{btn_send_gcode}->Hide; if ($Slic3r::GUI::have_button_icons) { my %icons = qw( add brick_add.png remove brick_delete.png reset cross.png arrange bricks.png export_gcode cog_go.png print arrow_up.png send_gcode arrow_up.png reslice reslice.png export_stl brick_go.png increase add.png decrease delete.png rotate45cw arrow_rotate_clockwise.png rotate45ccw arrow_rotate_anticlockwise.png changescale arrow_out.png split shape_ungroup.png cut package.png settings cog.png ); for (grep $self->{"btn_$_"}, keys %icons) { $self->{"btn_$_"}->SetBitmap(Wx::Bitmap->new($Slic3r::var->($icons{$_}), wxBITMAP_TYPE_PNG)); } } $self->selection_changed(0); $self->object_list_changed; EVT_BUTTON($self, $self->{btn_export_gcode}, sub { $self->export_gcode; }); EVT_BUTTON($self, $self->{btn_print}, sub { $self->{print_file} = $self->export_gcode(Wx::StandardPaths::Get->GetTempDir()); }); EVT_BUTTON($self, $self->{btn_send_gcode}, sub { $self->{send_gcode_file} = $self->export_gcode(Wx::StandardPaths::Get->GetTempDir()); }); EVT_BUTTON($self, $self->{btn_reslice}, \&reslice); EVT_BUTTON($self, $self->{btn_export_stl}, \&export_stl); if ($self->{htoolbar}) { EVT_TOOL($self, TB_ADD, sub { $self->add; }); EVT_TOOL($self, TB_REMOVE, sub { $self->remove() }); # explicitly pass no argument to remove EVT_TOOL($self, TB_RESET, sub { $self->reset; }); EVT_TOOL($self, TB_ARRANGE, sub { $self->arrange; }); EVT_TOOL($self, TB_MORE, sub { $self->increase; }); EVT_TOOL($self, TB_FEWER, sub { $self->decrease; }); EVT_TOOL($self, TB_45CW, sub { $_[0]->rotate(-45) }); EVT_TOOL($self, TB_45CCW, sub { $_[0]->rotate(45) }); EVT_TOOL($self, TB_SCALE, sub { $self->changescale(undef); }); EVT_TOOL($self, TB_SPLIT, sub { $self->split_object; }); EVT_TOOL($self, TB_CUT, sub { $_[0]->object_cut_dialog }); EVT_TOOL($self, TB_SETTINGS, sub { $_[0]->object_settings_dialog }); } else { EVT_BUTTON($self, $self->{btn_add}, sub { $self->add; }); EVT_BUTTON($self, $self->{btn_remove}, sub { $self->remove() }); # explicitly pass no argument to remove EVT_BUTTON($self, $self->{btn_reset}, sub { $self->reset; }); EVT_BUTTON($self, $self->{btn_arrange}, sub { $self->arrange; }); EVT_BUTTON($self, $self->{btn_increase}, sub { $self->increase; }); EVT_BUTTON($self, $self->{btn_decrease}, sub { $self->decrease; }); EVT_BUTTON($self, $self->{btn_rotate45cw}, sub { $_[0]->rotate(-45) }); EVT_BUTTON($self, $self->{btn_rotate45ccw}, sub { $_[0]->rotate(45) }); EVT_BUTTON($self, $self->{btn_changescale}, sub { $self->changescale(undef); }); EVT_BUTTON($self, $self->{btn_split}, sub { $self->split_object; }); EVT_BUTTON($self, $self->{btn_cut}, sub { $_[0]->object_cut_dialog }); EVT_BUTTON($self, $self->{btn_settings}, sub { $_[0]->object_settings_dialog }); } $_->SetDropTarget(Slic3r::GUI::Plater::DropTarget->new($self)) for grep defined($_), $self, $self->{canvas}, $self->{canvas3D}, $self->{preview3D}, $self->{list}; EVT_COMMAND($self, -1, $THUMBNAIL_DONE_EVENT, sub { my ($self, $event) = @_; my ($obj_idx) = @{$event->GetData}; return if !$self->{objects}[$obj_idx]; # object was deleted before thumbnail generation completed $self->on_thumbnail_made($obj_idx); }); EVT_COMMAND($self, -1, $PROGRESS_BAR_EVENT, sub { my ($self, $event) = @_; my ($percent, $message) = @{$event->GetData}; $self->on_progress_event($percent, $message); }); EVT_COMMAND($self, -1, $ERROR_EVENT, sub { my ($self, $event) = @_; Slic3r::GUI::show_error($self, @{$event->GetData}); }); EVT_COMMAND($self, -1, $EXPORT_COMPLETED_EVENT, sub { my ($self, $event) = @_; $self->on_export_completed($event->GetData); }); EVT_COMMAND($self, -1, $PROCESS_COMPLETED_EVENT, sub { my ($self, $event) = @_; $self->on_process_completed($event->GetData); }); if ($Slic3r::have_threads) { my $timer_id = Wx::NewId(); $self->{apply_config_timer} = Wx::Timer->new($self, $timer_id); EVT_TIMER($self, $timer_id, sub { my ($self, $event) = @_; $self->async_apply_config; }); } $self->{canvas}->update_bed_size; if ($self->{canvas3D}) { $self->{canvas3D}->update_bed_size; $self->{canvas3D}->zoom_to_bed; } if ($self->{preview3D}) { $self->{preview3D}->set_bed_shape($self->{config}->bed_shape); } $self->update; { my $presets; if ($self->GetFrame->{mode} eq 'expert') { $presets = $self->{presets_sizer} = Wx::FlexGridSizer->new(3, 2, 1, 2); $presets->AddGrowableCol(1, 1); $presets->SetFlexibleDirection(wxHORIZONTAL); my %group_labels = ( print => 'Print settings', filament => 'Filament', printer => 'Printer', ); # UI Combo boxes for a print, multiple filaments, and a printer. # Initially a single filament combo box is created, but the number of combo boxes for the filament selection may increase, # once a printer preset with multiple extruders is activated. # $self->{preset_choosers}{$group}[$idx] $self->{preset_choosers} = {}; # Boolean indicating whether the '- default -' preset is shown by the combo box. $self->{preset_choosers_default_suppressed} = {}; for my $group (qw(print filament printer)) { my $text = Wx::StaticText->new($self, -1, "$group_labels{$group}:", wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT); $text->SetFont($Slic3r::GUI::small_font); my $choice = Wx::BitmapComboBox->new($self, -1, "", wxDefaultPosition, wxDefaultSize, [], wxCB_READONLY); $self->{preset_choosers}{$group} = [$choice]; $self->{preset_choosers_default_suppressed}{$group} = 0; # setup the listener EVT_COMBOBOX($choice, $choice, sub { my ($choice) = @_; wxTheApp->CallAfter(sub { $self->_on_select_preset($group, $choice); }); }); $presets->Add($text, 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL | wxRIGHT, 4); $presets->Add($choice, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND | wxBOTTOM, 0); } } my $object_info_sizer; { my $box = Wx::StaticBox->new($self, -1, "Info"); $object_info_sizer = Wx::StaticBoxSizer->new($box, wxVERTICAL); $object_info_sizer->SetMinSize([350,-1]); my $grid_sizer = Wx::FlexGridSizer->new(3, 4, 5, 5); $grid_sizer->SetFlexibleDirection(wxHORIZONTAL); $grid_sizer->AddGrowableCol(1, 1); $grid_sizer->AddGrowableCol(3, 1); $object_info_sizer->Add($grid_sizer, 0, wxEXPAND); my @info = ( size => "Size", volume => "Volume", facets => "Facets", materials => "Materials", manifold => "Manifold", ); while (my $field = shift @info) { my $label = shift @info; my $text = Wx::StaticText->new($self, -1, "$label:", wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT); $text->SetFont($Slic3r::GUI::small_font); $grid_sizer->Add($text, 0); $self->{"object_info_$field"} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT); $self->{"object_info_$field"}->SetFont($Slic3r::GUI::small_font); if ($field eq 'manifold') { $self->{object_info_manifold_warning_icon} = Wx::StaticBitmap->new($self, -1, Wx::Bitmap->new($Slic3r::var->("error.png"), wxBITMAP_TYPE_PNG)); $self->{object_info_manifold_warning_icon}->Hide; my $h_sizer = Wx::BoxSizer->new(wxHORIZONTAL); $h_sizer->Add($self->{object_info_manifold_warning_icon}, 0); $h_sizer->Add($self->{"object_info_$field"}, 0); $grid_sizer->Add($h_sizer, 0, wxEXPAND); } else { $grid_sizer->Add($self->{"object_info_$field"}, 0); } } } my $buttons_sizer = Wx::BoxSizer->new(wxHORIZONTAL); $self->{buttons_sizer} = $buttons_sizer; $buttons_sizer->AddStretchSpacer(1); $buttons_sizer->Add($self->{btn_export_stl}, 0, wxALIGN_RIGHT, 0); $buttons_sizer->Add($self->{btn_reslice}, 0, wxALIGN_RIGHT, 0); $buttons_sizer->Add($self->{btn_print}, 0, wxALIGN_RIGHT, 0); $buttons_sizer->Add($self->{btn_send_gcode}, 0, wxALIGN_RIGHT, 0); $buttons_sizer->Add($self->{btn_export_gcode}, 0, wxALIGN_RIGHT, 0); my $right_sizer = Wx::BoxSizer->new(wxVERTICAL); $right_sizer->Add($presets, 0, wxEXPAND | wxTOP, 10) if defined $presets; $right_sizer->Add($buttons_sizer, 0, wxEXPAND | wxBOTTOM, 5); $right_sizer->Add($self->{list}, 1, wxEXPAND, 5); $right_sizer->Add($object_info_sizer, 0, wxEXPAND, 0); my $hsizer = Wx::BoxSizer->new(wxHORIZONTAL); $hsizer->Add($self->{preview_notebook}, 1, wxEXPAND | wxTOP, 1); $hsizer->Add($right_sizer, 0, wxEXPAND | wxLEFT | wxRIGHT, 3); my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($self->{htoolbar}, 0, wxEXPAND, 0) if $self->{htoolbar}; $sizer->Add($self->{btoolbar}, 0, wxEXPAND, 0) if $self->{btoolbar}; $sizer->Add($hsizer, 1, wxEXPAND, 0); $sizer->SetSizeHints($self); $self->SetSizer($sizer); } $self->update_ui_from_settings(); return $self; } # sets the callback sub on_select_preset { my ($self, $cb) = @_; $self->{on_select_preset} = $cb; } sub _on_select_preset { my $self = shift; my ($group, $choice) = @_; # If user changed a filament preset and the selected machine is equipped with multiple extruders, # there are multiple filament selection combo boxes shown at the platter. In that case # don't propagate the filament selection changes to the tab. my $default_suppressed = $self->{preset_choosers_default_suppressed}{$group}; if ($group eq 'filament' && @{$self->{preset_choosers}{filament}} > 1) { # Indices of the filaments selected. my @filament_presets = $self->filament_presets; $Slic3r::GUI::Settings->{presets}{filament} = $choice->GetString($filament_presets[0] - $default_suppressed) . ".ini"; $Slic3r::GUI::Settings->{presets}{"filament_${_}"} = $choice->GetString($filament_presets[$_] - $default_suppressed) for 1 .. $#filament_presets; wxTheApp->save_settings; return; } # call GetSelection() in scalar context as it's context-aware $self->{on_select_preset}->($group, scalar($choice->GetSelection) + $default_suppressed) if $self->{on_select_preset}; # get new config and generate on_config_change() event for updating plater and other things $self->on_config_change($self->GetFrame->config); } sub GetFrame { my ($self) = @_; return &Wx::GetTopLevelParent($self); } # Called after the Preferences dialog is closed and the program settings are saved. # Update the UI based on the current preferences. sub update_ui_from_settings { my ($self) = @_; if (defined($self->{btn_reslice}) && $self->{buttons_sizer}->IsShown($self->{btn_reslice}) != (! $Slic3r::GUI::Settings->{_}{background_processing})) { $self->{buttons_sizer}->Show($self->{btn_reslice}, ! $Slic3r::GUI::Settings->{_}{background_processing}); $self->{buttons_sizer}->Layout; } } # Update presets (Print settings, Filament, Printer) from their respective tabs. # Called by # Slic3r::GUI::Tab::Print::_on_presets_changed # Slic3r::GUI::Tab::Filament::_on_presets_changed # Slic3r::GUI::Tab::Printer::_on_presets_changed # when the presets are loaded or the user selects another preset. # For Print settings and Printer, synchronize the selection index with their tabs. # For Filament, synchronize the selection index for a single extruder printer only, otherwise keep the selection. sub update_presets { my $self = shift; # $presets: one of qw(print filament printer) # $selected: index of the selected preset in the array. This may not correspond # with the index of selection in the UI element, where not all items are displayed. my ($group, $presets, $default_suppressed, $selected, $is_dirty) = @_; my @choosers = @{ $self->{preset_choosers}{$group} }; foreach my $choice (@choosers) { if ($group eq 'filament' && @choosers > 1) { # if we have more than one filament chooser, keep our selection # instead of importing the one from the tab $selected = $choice->GetSelection + $self->{preset_choosers_default_suppressed}{$group}; $is_dirty = 0; } $choice->Clear; foreach my $preset (@$presets) { next if ($preset->default && $default_suppressed); my $bitmap; if ($group eq 'filament') { my $config = $preset->config(['filament_colour']); my $rgb_hex = $config->filament_colour->[0]; if ($preset->default) { $bitmap = Wx::Bitmap->new($Slic3r::var->("spool.png"), wxBITMAP_TYPE_PNG); } else { $rgb_hex =~ s/^#//; my @rgb = unpack 'C*', pack 'H*', $rgb_hex; my $image = Wx::Image->new(16,16); $image->SetRGB(Wx::Rect->new(0,0,16,16), @rgb); $bitmap = Wx::Bitmap->new($image); } } elsif ($group eq 'print') { $bitmap = Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG); } elsif ($group eq 'printer') { $bitmap = Wx::Bitmap->new($Slic3r::var->("printer_empty.png"), wxBITMAP_TYPE_PNG); } $choice->AppendString($preset->name, $bitmap); } if ($selected <= $#$presets) { my $idx = $selected - $default_suppressed; if ($idx >= 0) { if ($is_dirty) { $choice->SetString($idx, $choice->GetString($idx) . " (modified)"); } # call SetSelection() only after SetString() otherwise the new string # won't be picked up as the visible string $choice->SetSelection($idx); } } } $self->{preset_choosers_default_suppressed}{$group} = $default_suppressed; } # Return a vector of indices of filaments selected by the $self->{preset_choosers}{filament} combo boxes. sub filament_presets { my $self = shift; # force scalar context for GetSelection() as it's context-aware return map scalar($_->GetSelection) + $self->{preset_choosers_default_suppressed}{filament}, @{ $self->{preset_choosers}{filament} }; } sub add { my $self = shift; my @input_files = wxTheApp->open_model($self); $self->load_file($_) for @input_files; } sub load_file { my $self = shift; my ($input_file) = @_; $Slic3r::GUI::Settings->{recent}{skein_directory} = dirname($input_file); wxTheApp->save_settings; my $process_dialog = Wx::ProgressDialog->new('Loading…', "Processing input file…", 100, $self, 0); $process_dialog->Pulse; local $SIG{__WARN__} = Slic3r::GUI::warning_catcher($self); my $model = eval { Slic3r::Model->read_from_file($input_file) }; Slic3r::GUI::show_error($self, $@) if $@; if (defined $model) { if ($model->looks_like_multipart_object) { my $dialog = Wx::MessageDialog->new($self, "This file contains several objects positioned at multiple heights. " . "Instead of considering them as multiple objects, should I consider\n" . "this file as a single object having multiple parts?\n", 'Multi-part object detected', wxICON_WARNING | wxYES | wxNO); if ($dialog->ShowModal() == wxID_YES) { $model->convert_multipart_object; } } $self->load_model_objects(@{$model->objects}); $self->statusbar->SetStatusText("Loaded " . basename($input_file)); } $process_dialog->Destroy; } sub load_model_objects { my ($self, @model_objects) = @_; my $bed_centerf = $self->bed_centerf; my $bed_shape = Slic3r::Polygon->new_scale(@{$self->{config}->bed_shape}); my $bed_size = $bed_shape->bounding_box->size; my $need_arrange = 0; my $scaled_down = 0; my @obj_idx = (); foreach my $model_object (@model_objects) { my $o = $self->{model}->add_object($model_object); push @{ $self->{objects} }, Slic3r::GUI::Plater::Object->new( name => basename($model_object->input_file), ); push @obj_idx, $#{ $self->{objects} }; if ($model_object->instances_count == 0) { # if object has no defined position(s) we need to rearrange everything after loading $need_arrange = 1; # add a default instance and center object around origin $o->center_around_origin; # also aligns object to Z = 0 $o->add_instance(offset => $bed_centerf); } { # if the object is too large (more than 5 times the bed), scale it down my $size = $o->bounding_box->size; my $ratio = max(@$size[X,Y]) / unscale(max(@$bed_size[X,Y])); if ($ratio > 5) { $_->set_scaling_factor(1/$ratio) for @{$o->instances}; $scaled_down = 1; } } $self->{print}->auto_assign_extruders($o); $self->{print}->add_model_object($o); } # if user turned autocentering off, automatic arranging would disappoint them if (!$Slic3r::GUI::Settings->{_}{autocenter}) { $need_arrange = 0; } if ($scaled_down) { Slic3r::GUI::show_info( $self, 'Your object appears to be too large, so it was automatically scaled down to fit your print bed.', 'Object too large?', ); } foreach my $obj_idx (@obj_idx) { my $object = $self->{objects}[$obj_idx]; my $model_object = $self->{model}->objects->[$obj_idx]; $self->{list}->InsertStringItem($obj_idx, $object->name); $self->{list}->SetItemFont($obj_idx, Wx::Font->new(10, wxDEFAULT, wxNORMAL, wxNORMAL)) if $self->{list}->can('SetItemFont'); # legacy code for wxPerl < 0.9918 not supporting SetItemFont() $self->{list}->SetItem($obj_idx, 1, $model_object->instances_count); $self->{list}->SetItem($obj_idx, 2, ($model_object->instances->[0]->scaling_factor * 100) . "%"); $self->make_thumbnail($obj_idx); } $self->arrange if $need_arrange; $self->update; # zoom to objects $self->{canvas3D}->zoom_to_volumes if $self->{canvas3D}; $self->{list}->Update; $self->{list}->Select($obj_idx[-1], 1); $self->object_list_changed; $self->schedule_background_process; } sub bed_centerf { my ($self) = @_; my $bed_shape = Slic3r::Polygon->new_scale(@{$self->{config}->bed_shape}); my $bed_center = $bed_shape->bounding_box->center; return Slic3r::Pointf->new(unscale($bed_center->x), unscale($bed_center->y)); #) } sub remove { my $self = shift; my ($obj_idx) = @_; $self->stop_background_process; # Prevent toolpaths preview from rendering while we modify the Print object $self->{toolpaths2D}->enabled(0) if $self->{toolpaths2D}; $self->{preview3D}->enabled(0) if $self->{preview3D}; # if no object index is supplied, remove the selected one if (!defined $obj_idx) { ($obj_idx, undef) = $self->selected_object; } splice @{$self->{objects}}, $obj_idx, 1; $self->{model}->delete_object($obj_idx); $self->{print}->delete_object($obj_idx); $self->{list}->DeleteItem($obj_idx); $self->object_list_changed; $self->select_object(undef); $self->update; $self->schedule_background_process; } sub reset { my $self = shift; $self->stop_background_process; # Prevent toolpaths preview from rendering while we modify the Print object $self->{toolpaths2D}->enabled(0) if $self->{toolpaths2D}; $self->{preview3D}->enabled(0) if $self->{preview3D}; @{$self->{objects}} = (); $self->{model}->clear_objects; $self->{print}->clear_objects; $self->{list}->DeleteAllItems; $self->object_list_changed; $self->select_object(undef); $self->update; } sub increase { my ($self, $copies) = @_; $copies //= 1; my ($obj_idx, $object) = $self->selected_object; my $model_object = $self->{model}->objects->[$obj_idx]; my $instance = $model_object->instances->[-1]; for my $i (1..$copies) { $instance = $model_object->add_instance( offset => Slic3r::Pointf->new(map 10+$_, @{$instance->offset}), scaling_factor => $instance->scaling_factor, rotation => $instance->rotation, ); $self->{print}->objects->[$obj_idx]->add_copy($instance->offset); } $self->{list}->SetItem($obj_idx, 1, $model_object->instances_count); # only autoarrange if user has autocentering enabled $self->stop_background_process; if ($Slic3r::GUI::Settings->{_}{autocenter}) { $self->arrange; } else { $self->update; } $self->schedule_background_process; } sub decrease { my ($self, $copies) = @_; $copies //= 1; $self->stop_background_process; my ($obj_idx, $object) = $self->selected_object; my $model_object = $self->{model}->objects->[$obj_idx]; if ($model_object->instances_count > $copies) { for my $i (1..$copies) { $model_object->delete_last_instance; $self->{print}->objects->[$obj_idx]->delete_last_copy; } $self->{list}->SetItem($obj_idx, 1, $model_object->instances_count); } else { $self->remove; } if ($self->{objects}[$obj_idx]) { $self->{list}->Select($obj_idx, 0); $self->{list}->Select($obj_idx, 1); } $self->update; $self->schedule_background_process; } sub set_number_of_copies { my ($self) = @_; $self->pause_background_process; # get current number of copies my ($obj_idx, $object) = $self->selected_object; my $model_object = $self->{model}->objects->[$obj_idx]; # prompt user my $copies = Wx::GetNumberFromUser("", "Enter the number of copies of the selected object:", "Copies", $model_object->instances_count, 0, 1000, $self); my $diff = $copies - $model_object->instances_count; if ($diff == 0) { # no variation $self->resume_background_process; } elsif ($diff > 0) { $self->increase($diff); } elsif ($diff < 0) { $self->decrease(-$diff); } } sub rotate { my $self = shift; my ($angle, $axis) = @_; # angle is in degrees $axis //= Z; my ($obj_idx, $object) = $self->selected_object; return if !defined $obj_idx; my $model_object = $self->{model}->objects->[$obj_idx]; my $model_instance = $model_object->instances->[0]; # we need thumbnail to be computed before allowing rotation return if !$object->thumbnail; if (!defined $angle) { my $axis_name = $axis == X ? 'X' : $axis == Y ? 'Y' : 'Z'; $angle = Wx::GetNumberFromUser("", "Enter the rotation angle:", "Rotate around $axis_name axis", $model_instance->rotation, -364, 364, $self); return if !$angle || $angle == -1; $angle = 0 - $angle; # rotate clockwise (be consistent with button icon) } $self->stop_background_process; if ($axis == Z) { my $new_angle = $model_instance->rotation + deg2rad($angle); $_->set_rotation($new_angle) for @{ $model_object->instances }; $object->transform_thumbnail($self->{model}, $obj_idx); } else { # rotation around X and Y needs to be performed on mesh # so we first apply any Z rotation if ($model_instance->rotation != 0) { $model_object->rotate($model_instance->rotation, Z); $_->set_rotation(0) for @{ $model_object->instances }; } $model_object->rotate(deg2rad($angle), $axis); # realign object to Z = 0 $model_object->center_around_origin; $self->make_thumbnail($obj_idx); } $model_object->update_bounding_box; # update print and start background processing $self->{print}->add_model_object($model_object, $obj_idx); $self->selection_changed; # refresh info (size etc.) $self->update; $self->schedule_background_process; } sub mirror { my ($self, $axis) = @_; my ($obj_idx, $object) = $self->selected_object; return if !defined $obj_idx; my $model_object = $self->{model}->objects->[$obj_idx]; my $model_instance = $model_object->instances->[0]; # apply Z rotation before mirroring if ($model_instance->rotation != 0) { $model_object->rotate($model_instance->rotation, Z); $_->set_rotation(0) for @{ $model_object->instances }; } $model_object->mirror($axis); $model_object->update_bounding_box; # realign object to Z = 0 $model_object->center_around_origin; $self->make_thumbnail($obj_idx); # update print and start background processing $self->stop_background_process; $self->{print}->add_model_object($model_object, $obj_idx); $self->selection_changed; # refresh info (size etc.) $self->update; $self->schedule_background_process; } sub changescale { my ($self, $axis, $tosize) = @_; my ($obj_idx, $object) = $self->selected_object; return if !defined $obj_idx; my $model_object = $self->{model}->objects->[$obj_idx]; my $model_instance = $model_object->instances->[0]; # we need thumbnail to be computed before allowing scaling return if !$object->thumbnail; my $object_size = $model_object->bounding_box->size; my $bed_size = Slic3r::Polygon->new_scale(@{$self->{config}->bed_shape})->bounding_box->size; if (defined $axis) { my $axis_name = $axis == X ? 'X' : $axis == Y ? 'Y' : 'Z'; my $scale; if ($tosize) { my $cursize = $object_size->[$axis]; my $newsize = Wx::GetNumberFromUser("", "Enter the new size for the selected object:", "Scale along $axis_name", $cursize, 0, $bed_size->[$axis], $self); return if !$newsize || $newsize < 0; $scale = $newsize / $cursize * 100; } else { $scale = Wx::GetNumberFromUser("", "Enter the scale % for the selected object:", "Scale along $axis_name", 100, 0, 100000, $self); } return if !$scale || $scale < 0; # apply Z rotation before scaling if ($model_instance->rotation != 0) { $model_object->rotate($model_instance->rotation, Z); $_->set_rotation(0) for @{ $model_object->instances }; } my $versor = [1,1,1]; $versor->[$axis] = $scale/100; $model_object->scale_xyz(Slic3r::Pointf3->new(@$versor)); # object was already aligned to Z = 0, so no need to realign it $self->make_thumbnail($obj_idx); } else { my $scale; if ($tosize) { my $cursize = max(@$object_size); my $newsize = Wx::GetNumberFromUser("", "Enter the new max size for the selected object:", "Scale", $cursize, 0, max(@$bed_size), $self); return if !$newsize || $newsize < 0; $scale = $newsize / $cursize * 100; } else { # max scale factor should be above 2540 to allow importing files exported in inches $scale = Wx::GetNumberFromUser("", "Enter the scale % for the selected object:", 'Scale', $model_instance->scaling_factor*100, 0, 100000, $self); } return if !$scale || $scale < 0; $self->{list}->SetItem($obj_idx, 2, "$scale%"); $scale /= 100; # turn percent into factor my $variation = $scale / $model_instance->scaling_factor; foreach my $range (@{ $model_object->layer_height_ranges }) { $range->[0] *= $variation; $range->[1] *= $variation; } $_->set_scaling_factor($scale) for @{ $model_object->instances }; $object->transform_thumbnail($self->{model}, $obj_idx); } $model_object->update_bounding_box; # update print and start background processing $self->stop_background_process; $self->{print}->add_model_object($model_object, $obj_idx); $self->selection_changed(1); # refresh info (size, volume etc.) $self->update; $self->schedule_background_process; } sub arrange { my $self = shift; $self->pause_background_process; my $bb = Slic3r::Geometry::BoundingBoxf->new_from_points($self->{config}->bed_shape); my $success = $self->{model}->arrange_objects($self->GetFrame->config->min_object_distance, $bb); # ignore arrange failures on purpose: user has visual feedback and we don't need to warn him # when parts don't fit in print bed $self->update(1); } sub split_object { my $self = shift; my ($obj_idx, $current_object) = $self->selected_object; # we clone model object because split_object() adds the split volumes # into the same model object, thus causing duplicates when we call load_model_objects() my $new_model = $self->{model}->clone; # store this before calling get_object() my $current_model_object = $new_model->get_object($obj_idx); if ($current_model_object->volumes_count > 1) { Slic3r::GUI::warning_catcher($self)->("The selected object can't be split because it contains more than one volume/material."); return; } $self->pause_background_process; my @model_objects = @{$current_model_object->split_object}; if (@model_objects == 1) { $self->resume_background_process; Slic3r::GUI::warning_catcher($self)->("The selected object couldn't be split because it contains only one part."); $self->resume_background_process; return; } foreach my $object (@model_objects) { $object->instances->[$_]->offset->translate($_ * 10, $_ * 10) for 1..$#{ $object->instances }; # we need to center this single object around origin $object->center_around_origin; } # remove the original object before spawning the object_loaded event, otherwise # we'll pass the wrong $obj_idx to it (which won't be recognized after the # thumbnail thread returns) $self->remove($obj_idx); $current_object = $obj_idx = undef; # load all model objects at once, otherwise the plate would be rearranged after each one # causing original positions not to be kept $self->load_model_objects(@model_objects); } sub schedule_background_process { my ($self) = @_; if (defined $self->{apply_config_timer}) { $self->{apply_config_timer}->Start(PROCESS_DELAY, 1); # 1 = one shot } } # Executed asynchronously by a timer every PROCESS_DELAY (0.5 second). # The timer is started by schedule_background_process(), sub async_apply_config { my ($self) = @_; # reset preview canvases $self->{toolpaths2D}->reload_print if $self->{toolpaths2D}; $self->{preview3D}->reload_print if $self->{preview3D}; # pause process thread before applying new config # since we don't want to touch data that is being used by the threads $self->pause_background_process; # apply new config my $invalidated = $self->{print}->apply_config($self->GetFrame->config); return if !$Slic3r::GUI::Settings->{_}{background_processing}; if ($invalidated) { # kill current thread if any $self->stop_background_process; } else { $self->resume_background_process; } # schedule a new process thread in case it wasn't running $self->start_background_process; } sub start_background_process { my ($self) = @_; return if !$Slic3r::have_threads; return if !@{$self->{objects}}; return if $self->{process_thread}; # It looks like declaring a local $SIG{__WARN__} prevents the ugly # "Attempt to free unreferenced scalar" warning... local $SIG{__WARN__} = Slic3r::GUI::warning_catcher($self); # don't start process thread if config is not valid eval { # this will throw errors if config is not valid $self->GetFrame->config->validate; $self->{print}->validate; }; if ($@) { $self->statusbar->SetStatusText($@); return; } # apply extra variables { my $extra = $self->GetFrame->extra_variables; $self->{print}->placeholder_parser->set($_, $extra->{$_}) for keys %$extra; } # start thread @_ = (); $self->{process_thread} = Slic3r::spawn_thread(sub { eval { $self->{print}->process; }; if ($@) { Slic3r::debugf "Background process error: $@\n"; Wx::PostEvent($self, Wx::PlThreadEvent->new(-1, $PROCESS_COMPLETED_EVENT, $@)); } else { Wx::PostEvent($self, Wx::PlThreadEvent->new(-1, $PROCESS_COMPLETED_EVENT, undef)); } Slic3r::thread_cleanup(); }); Slic3r::debugf "Background processing started.\n"; } sub stop_background_process { my ($self) = @_; $self->{apply_config_timer}->Stop if defined $self->{apply_config_timer}; $self->statusbar->SetCancelCallback(undef); $self->statusbar->StopBusy; $self->statusbar->SetStatusText(""); $self->{toolpaths2D}->reload_print if $self->{toolpaths2D}; $self->{preview3D}->reload_print if $self->{preview3D}; if ($self->{process_thread}) { Slic3r::debugf "Killing background process.\n"; Slic3r::kill_all_threads(); $self->{process_thread} = undef; } else { Slic3r::debugf "No background process running.\n"; } # if there's an export process, kill that one as well if ($self->{export_thread}) { Slic3r::debugf "Killing background export process.\n"; Slic3r::kill_all_threads(); $self->{export_thread} = undef; } } sub pause_background_process { my ($self) = @_; if ($self->{process_thread} || $self->{export_thread}) { Slic3r::pause_all_threads(); return 1; } elsif (defined $self->{apply_config_timer} && $self->{apply_config_timer}->IsRunning) { $self->{apply_config_timer}->Stop; return 1; } return 0; } sub resume_background_process { my ($self) = @_; if ($self->{process_thread} || $self->{export_thread}) { Slic3r::resume_all_threads(); } } sub reslice { # explicitly cancel a previous thread and start a new one. my ($self) = @_; # Don't reslice if export of G-code or sending to OctoPrint is running. if ($Slic3r::have_threads && ! defined($self->{export_gcode_output_file}) && ! defined($self->{send_gcode_file})) { $self->stop_background_process; $self->statusbar->SetCancelCallback(sub { $self->stop_background_process; $self->statusbar->SetStatusText("Slicing cancelled"); # this updates buttons status $self->object_list_changed; }); $self->start_background_process; } } sub export_gcode { my ($self, $output_file) = @_; return if !@{$self->{objects}}; if ($self->{export_gcode_output_file}) { Wx::MessageDialog->new($self, "Another export job is currently running.", 'Error', wxOK | wxICON_ERROR)->ShowModal; return; } # if process is not running, validate config # (we assume that if it is running, config is valid) eval { # this will throw errors if config is not valid $self->GetFrame->config->validate; $self->{print}->validate; }; Slic3r::GUI::catch_error($self) and return; # apply config and validate print my $config = $self->GetFrame->config; eval { # this will throw errors if config is not valid $config->validate; $self->{print}->apply_config($config); $self->{print}->validate; }; if (!$Slic3r::have_threads) { Slic3r::GUI::catch_error($self) and return; } # select output file if ($output_file) { $self->{export_gcode_output_file} = $self->{print}->expanded_output_filepath($output_file); } else { my $default_output_file = $self->{print}->expanded_output_filepath($main::opt{output}); my $dlg = Wx::FileDialog->new($self, 'Save G-code file as:', wxTheApp->output_path(dirname($default_output_file)), basename($default_output_file), &Slic3r::GUI::FILE_WILDCARDS->{gcode}, wxFD_SAVE | wxFD_OVERWRITE_PROMPT); if ($dlg->ShowModal != wxID_OK) { $dlg->Destroy; return; } my $path = Slic3r::decode_path($dlg->GetPath); $Slic3r::GUI::Settings->{_}{last_output_path} = dirname($path); wxTheApp->save_settings; $self->{export_gcode_output_file} = $path; $dlg->Destroy; } $self->statusbar->StartBusy; if ($Slic3r::have_threads) { $self->statusbar->SetCancelCallback(sub { $self->stop_background_process; $self->statusbar->SetStatusText("Export cancelled"); $self->{export_gcode_output_file} = undef; $self->{send_gcode_file} = undef; # this updates buttons status $self->object_list_changed; }); # start background process, whose completion event handler # will detect $self->{export_gcode_output_file} and proceed with export $self->start_background_process; } else { eval { $self->{print}->process; $self->{print}->export_gcode(output_file => $self->{export_gcode_output_file}); }; my $result = !Slic3r::GUI::catch_error($self); $self->on_export_completed($result); } # this updates buttons status $self->object_list_changed; return $self->{export_gcode_output_file}; } # This gets called only if we have threads. sub on_process_completed { my ($self, $error) = @_; $self->statusbar->SetCancelCallback(undef); $self->statusbar->StopBusy; $self->statusbar->SetStatusText($error // ""); Slic3r::debugf "Background processing completed.\n"; $self->{process_thread}->detach if $self->{process_thread}; $self->{process_thread} = undef; # if we're supposed to perform an explicit export let's display the error in a dialog if ($error && $self->{export_gcode_output_file}) { $self->{export_gcode_output_file} = undef; Slic3r::GUI::show_error($self, $error); } return if $error; $self->{toolpaths2D}->reload_print if $self->{toolpaths2D}; $self->{preview3D}->reload_print if $self->{preview3D}; # if we have an export filename, start a new thread for exporting G-code if ($self->{export_gcode_output_file}) { @_ = (); # workaround for "Attempt to free un referenced scalar..." our $_thread_self = $self; $self->{export_thread} = Slic3r::spawn_thread(sub { eval { $_thread_self->{print}->export_gcode(output_file => $_thread_self->{export_gcode_output_file}); }; if ($@) { Wx::PostEvent($_thread_self, Wx::PlThreadEvent->new(-1, $ERROR_EVENT, shared_clone([ $@ ]))); Wx::PostEvent($_thread_self, Wx::PlThreadEvent->new(-1, $EXPORT_COMPLETED_EVENT, 0)); } else { Wx::PostEvent($_thread_self, Wx::PlThreadEvent->new(-1, $EXPORT_COMPLETED_EVENT, 1)); } Slic3r::thread_cleanup(); }); Slic3r::debugf "Background G-code export started.\n"; } } # This gets called also if we have no threads. sub on_progress_event { my ($self, $percent, $message) = @_; $self->statusbar->SetProgress($percent); $self->statusbar->SetStatusText("$message…"); } # Called when the G-code export finishes, either successfully or with an error. # This gets called also if we don't have threads. sub on_export_completed { my ($self, $result) = @_; $self->statusbar->SetCancelCallback(undef); $self->statusbar->StopBusy; $self->statusbar->SetStatusText(""); Slic3r::debugf "Background export process completed.\n"; $self->{export_thread}->detach if $self->{export_thread}; $self->{export_thread} = undef; my $message; my $send_gcode = 0; my $do_print = 0; if ($result) { # G-code file exported successfully. if ($self->{print_file}) { $message = "File added to print queue"; $do_print = 1; } elsif ($self->{send_gcode_file}) { $message = "Sending G-code file to the OctoPrint server..."; $send_gcode = 1; } else { $message = "G-code file exported to " . $self->{export_gcode_output_file}; } } else { $message = "Export failed"; } $self->{export_gcode_output_file} = undef; $self->statusbar->SetStatusText($message); wxTheApp->notify($message); $self->do_print if $do_print; # Send $self->{send_gcode_file} to OctoPrint. $self->send_gcode if $send_gcode; $self->{print_file} = undef; $self->{send_gcode_file} = undef; # this updates buttons status $self->object_list_changed; } sub do_print { my ($self) = @_; my $printer_tab = $self->GetFrame->{options_tabs}{printer}; my $printer_name = $printer_tab->get_current_preset->name; my $controller = $self->GetFrame->{controller}; my $printer_panel = $controller->add_printer($printer_name, $printer_tab->config); my $filament_stats = $self->{print}->filament_stats; my @filament_names = $self->GetFrame->filament_preset_names; $filament_stats = { map { $filament_names[$_] => $filament_stats->{$_} } keys %$filament_stats }; $printer_panel->load_print_job($self->{print_file}, $filament_stats); $self->GetFrame->select_tab(1); } # Send $self->{send_gcode_file} to OctoPrint. #FIXME Currently this call blocks the UI. Make it asynchronous. sub send_gcode { my ($self) = @_; $self->statusbar->StartBusy; my $ua = LWP::UserAgent->new; $ua->timeout(180); my $path = Slic3r::encode_path($self->{send_gcode_file}); my $res = $ua->post( "http://" . $self->{config}->octoprint_host . "/api/files/local", Content_Type => 'form-data', 'X-Api-Key' => $self->{config}->octoprint_apikey, Content => [ # OctoPrint doesn't like Windows paths so we use basename() # Also, since we need to read from filesystem we process it through encode_path() file => [ $path, basename($path) ], ], ); $self->statusbar->StopBusy; if ($res->is_success) { $self->statusbar->SetStatusText("G-code file successfully uploaded to the OctoPrint server"); } else { my $message = "Error while uploading to the OctoPrint server: " . $res->status_line; Slic3r::GUI::show_error($self, $message); $self->statusbar->SetStatusText($message); } } sub export_stl { my $self = shift; return if !@{$self->{objects}}; my $output_file = $self->_get_export_file('STL') or return; Slic3r::Format::STL->write_file($output_file, $self->{model}, binary => 1); $self->statusbar->SetStatusText("STL file exported to $output_file"); } sub export_object_stl { my $self = shift; my ($obj_idx, $object) = $self->selected_object; return if !defined $obj_idx; my $model_object = $self->{model}->objects->[$obj_idx]; my $output_file = $self->_get_export_file('STL') or return; Slic3r::Format::STL->write_file($output_file, $model_object->mesh, binary => 1); $self->statusbar->SetStatusText("STL file exported to $output_file"); } sub export_amf { my $self = shift; return if !@{$self->{objects}}; my $output_file = $self->_get_export_file('AMF') or return; Slic3r::Format::AMF->write_file($output_file, $self->{model}); $self->statusbar->SetStatusText("AMF file exported to $output_file"); } sub _get_export_file { my $self = shift; my ($format) = @_; my $suffix = $format eq 'STL' ? '.stl' : '.amf.xml'; my $output_file = $main::opt{output}; { $output_file = $self->{print}->expanded_output_filepath($output_file); $output_file =~ s/\.gcode$/$suffix/i; my $dlg = Wx::FileDialog->new($self, "Save $format file as:", dirname($output_file), basename($output_file), &Slic3r::GUI::MODEL_WILDCARD, wxFD_SAVE | wxFD_OVERWRITE_PROMPT); if ($dlg->ShowModal != wxID_OK) { $dlg->Destroy; return undef; } $output_file = Slic3r::decode_path($dlg->GetPath); $dlg->Destroy; } return $output_file; } sub make_thumbnail { my $self = shift; my ($obj_idx) = @_; my $plater_object = $self->{objects}[$obj_idx]; $plater_object->thumbnail(Slic3r::ExPolygon::Collection->new); my $cb = sub { $plater_object->make_thumbnail($self->{model}, $obj_idx); if ($Slic3r::have_threads) { Wx::PostEvent($self, Wx::PlThreadEvent->new(-1, $THUMBNAIL_DONE_EVENT, shared_clone([ $obj_idx ]))); Slic3r::thread_cleanup(); threads->exit; } else { $self->on_thumbnail_made($obj_idx); } }; @_ = (); $Slic3r::have_threads ? threads->create(sub { $cb->(); Slic3r::thread_cleanup(); })->detach : $cb->(); } sub on_thumbnail_made { my $self = shift; my ($obj_idx) = @_; $self->{objects}[$obj_idx]->transform_thumbnail($self->{model}, $obj_idx); $self->refresh_canvases; } # this method gets called whenever print center is changed or the objects' bounding box changes # (i.e. when an object is added/removed/moved/rotated/scaled) sub update { my ($self, $force_autocenter) = @_; if ($Slic3r::GUI::Settings->{_}{autocenter} || $force_autocenter) { $self->{model}->center_instances_around_point($self->bed_centerf); } my $running = $self->pause_background_process; my $invalidated = $self->{print}->reload_model_instances(); # The mere fact that no steps were invalidated when reloading model instances # doesn't mean that all steps were done: for example, validation might have # failed upon previous instance move, so we have no running thread and no steps # are invalidated on this move, thus we need to schedule a new run. if ($invalidated || !$running) { $self->schedule_background_process; } else { $self->resume_background_process; } $self->refresh_canvases; } # When a number of extruders changes, the UI needs to be updated to show a single filament selection combo box per extruder. sub on_extruders_change { my ($self, $num_extruders) = @_; my $choices = $self->{preset_choosers}{filament}; while (@$choices < $num_extruders) { # copy strings from first choice my @presets = $choices->[0]->GetStrings; # initialize new choice my $choice = Wx::BitmapComboBox->new($self, -1, "", wxDefaultPosition, wxDefaultSize, [@presets], wxCB_READONLY); push @$choices, $choice; # copy icons from first choice $choice->SetItemBitmap($_, $choices->[0]->GetItemBitmap($_)) for 0..$#presets; # insert new choice into sizer $self->{presets_sizer}->Insert(4 + ($#$choices-1)*2, 0, 0); $self->{presets_sizer}->Insert(5 + ($#$choices-1)*2, $choice, 0, wxEXPAND | wxBOTTOM, FILAMENT_CHOOSERS_SPACING); # setup the listener EVT_COMBOBOX($choice, $choice, sub { my ($choice) = @_; wxTheApp->CallAfter(sub { $self->_on_select_preset('filament', $choice); }); }); # initialize selection my $i = first { $choice->GetString($_) eq ($Slic3r::GUI::Settings->{presets}{"filament_" . $#$choices} || '') } 0 .. $#presets; $choice->SetSelection($i || 0); } # remove unused choices if any while (@$choices > $num_extruders) { $self->{presets_sizer}->Remove(4 + ($#$choices-1)*2); # label $self->{presets_sizer}->Remove(4 + ($#$choices-1)*2); # wxChoice $choices->[-1]->Destroy; pop @$choices; } $self->Layout; } sub on_config_change { my $self = shift; my ($config) = @_; foreach my $opt_key (@{$self->{config}->diff($config)}) { $self->{config}->set($opt_key, $config->get($opt_key)); if ($opt_key eq 'bed_shape') { $self->{canvas}->update_bed_size; $self->{canvas3D}->update_bed_size if $self->{canvas3D}; $self->{preview3D}->set_bed_shape($self->{config}->bed_shape) if $self->{preview3D}; $self->update; } elsif ($opt_key eq 'serial_port') { if ($config->get('serial_port')) { $self->{btn_print}->Show; } else { $self->{btn_print}->Hide; } $self->Layout; } elsif ($opt_key eq 'octoprint_host') { if ($config->get('octoprint_host')) { $self->{btn_send_gcode}->Show; } else { $self->{btn_send_gcode}->Hide; } $self->Layout; } } return if !$self->GetFrame->is_loaded; # (re)start timer $self->schedule_background_process; } sub list_item_deselected { my ($self, $event) = @_; return if $PreventListEvents; if ($self->{list}->GetFirstSelected == -1) { $self->select_object(undef); $self->refresh_canvases; } } sub list_item_selected { my ($self, $event) = @_; return if $PreventListEvents; my $obj_idx = $event->GetIndex; $self->select_object($obj_idx); $self->refresh_canvases; } sub list_item_activated { my ($self, $event, $obj_idx) = @_; $obj_idx //= $event->GetIndex; $self->object_settings_dialog($obj_idx); } sub object_cut_dialog { my $self = shift; my ($obj_idx) = @_; if (!defined $obj_idx) { ($obj_idx, undef) = $self->selected_object; } if (!$Slic3r::GUI::have_OpenGL) { Slic3r::GUI::show_error($self, "Please install the OpenGL modules to use this feature (see build instructions)."); return; } my $dlg = Slic3r::GUI::Plater::ObjectCutDialog->new($self, object => $self->{objects}[$obj_idx], model_object => $self->{model}->objects->[$obj_idx], ); return unless $dlg->ShowModal == wxID_OK; if (my @new_objects = $dlg->NewModelObjects) { $self->remove($obj_idx); $self->load_model_objects(grep defined($_), @new_objects); $self->arrange; } } sub object_settings_dialog { my $self = shift; my ($obj_idx) = @_; if (!defined $obj_idx) { ($obj_idx, undef) = $self->selected_object; } my $model_object = $self->{model}->objects->[$obj_idx]; # validate config before opening the settings dialog because # that dialog can't be closed if validation fails, but user # can't fix any error which is outside that dialog return unless $self->validate_config; my $dlg = Slic3r::GUI::Plater::ObjectSettingsDialog->new($self, object => $self->{objects}[$obj_idx], model_object => $model_object, ); $self->pause_background_process; $dlg->ShowModal; # update thumbnail since parts may have changed if ($dlg->PartsChanged) { # recenter and re-align to Z = 0 $model_object->center_around_origin; $self->make_thumbnail($obj_idx); } # update print if ($dlg->PartsChanged || $dlg->PartSettingsChanged) { $self->stop_background_process; $self->{print}->reload_object($obj_idx); $self->schedule_background_process; } else { $self->resume_background_process; } } # Called to update various buttons depending on whether there are any objects or # whether background processing (export of a G-code, sending to Octoprint, forced background re-slicing) is active. sub object_list_changed { my $self = shift; # Enable/disable buttons depending on whether there are any objects on the platter. my $have_objects = @{$self->{objects}} ? 1 : 0; my $method = $have_objects ? 'Enable' : 'Disable'; $self->{"btn_$_"}->$method for grep $self->{"btn_$_"}, qw(reset arrange reslice export_gcode export_stl print send_gcode); if ($self->{export_gcode_output_file} || $self->{send_gcode_file}) { $self->{btn_reslice}->Disable; $self->{btn_export_gcode}->Disable; $self->{btn_print}->Disable; $self->{btn_send_gcode}->Disable; } if ($self->{htoolbar}) { $self->{htoolbar}->EnableTool($_, $have_objects) for (TB_RESET, TB_ARRANGE); } } sub selection_changed { my $self = shift; my ($obj_idx, $object) = $self->selected_object; my $have_sel = defined $obj_idx; my $method = $have_sel ? 'Enable' : 'Disable'; $self->{"btn_$_"}->$method for grep $self->{"btn_$_"}, qw(remove increase decrease rotate45cw rotate45ccw changescale split cut settings); if ($self->{htoolbar}) { $self->{htoolbar}->EnableTool($_, $have_sel) for (TB_REMOVE, TB_MORE, TB_FEWER, TB_45CW, TB_45CCW, TB_SCALE, TB_SPLIT, TB_CUT, TB_SETTINGS); } if ($self->{object_info_size}) { # have we already loaded the info pane? if ($have_sel) { my $model_object = $self->{model}->objects->[$obj_idx]; my $model_instance = $model_object->instances->[0]; $self->{object_info_size}->SetLabel(sprintf("%.2f x %.2f x %.2f", @{$model_object->instance_bounding_box(0)->size})); $self->{object_info_materials}->SetLabel($model_object->materials_count); if (my $stats = $model_object->mesh_stats) { $self->{object_info_volume}->SetLabel(sprintf('%.2f', $stats->{volume} * ($model_instance->scaling_factor**3))); $self->{object_info_facets}->SetLabel(sprintf('%d (%d shells)', $model_object->facets_count, $stats->{number_of_parts})); if (my $errors = sum(@$stats{qw(degenerate_facets edges_fixed facets_removed facets_added facets_reversed backwards_edges)})) { $self->{object_info_manifold}->SetLabel(sprintf("Auto-repaired (%d errors)", $errors)); $self->{object_info_manifold_warning_icon}->Show; # we don't show normals_fixed because we never provide normals # to admesh, so it generates normals for all facets my $message = sprintf '%d degenerate facets, %d edges fixed, %d facets removed, %d facets added, %d facets reversed, %d backwards edges', @$stats{qw(degenerate_facets edges_fixed facets_removed facets_added facets_reversed backwards_edges)}; $self->{object_info_manifold}->SetToolTipString($message); $self->{object_info_manifold_warning_icon}->SetToolTipString($message); } else { $self->{object_info_manifold}->SetLabel("Yes"); } } else { $self->{object_info_facets}->SetLabel($object->facets); } } else { $self->{"object_info_$_"}->SetLabel("") for qw(size volume facets materials manifold); $self->{object_info_manifold_warning_icon}->Hide; $self->{object_info_manifold}->SetToolTipString(""); } $self->Layout; } # prepagate the event to the frame (a custom Wx event would be cleaner) $self->GetFrame->on_plater_selection_changed($have_sel); } sub select_object { my ($self, $obj_idx) = @_; $_->selected(0) for @{ $self->{objects} }; if (defined $obj_idx) { $self->{objects}->[$obj_idx]->selected(1); # We use this flag to avoid circular event handling # Select() happens to fire a wxEVT_LIST_ITEM_SELECTED on Windows, # whose event handler calls this method again and again and again $PreventListEvents = 1; $self->{list}->Select($obj_idx, 1); $PreventListEvents = 0; } else { # TODO: deselect all in list } $self->selection_changed(1); } sub selected_object { my $self = shift; my $obj_idx = first { $self->{objects}[$_]->selected } 0..$#{ $self->{objects} }; return undef if !defined $obj_idx; return ($obj_idx, $self->{objects}[$obj_idx]), } sub refresh_canvases { my ($self) = @_; $self->{canvas}->Refresh; $self->{canvas3D}->update if $self->{canvas3D}; $self->{preview3D}->reload_print if $self->{preview3D}; } sub validate_config { my $self = shift; eval { $self->GetFrame->config->validate; }; return 0 if Slic3r::GUI::catch_error($self); return 1; } sub statusbar { my $self = shift; return $self->GetFrame->{statusbar}; } sub object_menu { my ($self) = @_; my $frame = $self->GetFrame; my $menu = Wx::Menu->new; $frame->_append_menu_item($menu, "Delete\tCtrl+Del", 'Remove the selected object', sub { $self->remove; }, undef, 'brick_delete.png'); $frame->_append_menu_item($menu, "Increase copies\tCtrl++", 'Place one more copy of the selected object', sub { $self->increase; }, undef, 'add.png'); $frame->_append_menu_item($menu, "Decrease copies\tCtrl+-", 'Remove one copy of the selected object', sub { $self->decrease; }, undef, 'delete.png'); $frame->_append_menu_item($menu, "Set number of copies…", 'Change the number of copies of the selected object', sub { $self->set_number_of_copies; }, undef, 'textfield.png'); $menu->AppendSeparator(); $frame->_append_menu_item($menu, "Rotate 45° clockwise", 'Rotate the selected object by 45° clockwise', sub { $self->rotate(-45); }, undef, 'arrow_rotate_clockwise.png'); $frame->_append_menu_item($menu, "Rotate 45° counter-clockwise", 'Rotate the selected object by 45° counter-clockwise', sub { $self->rotate(+45); }, undef, 'arrow_rotate_anticlockwise.png'); my $rotateMenu = Wx::Menu->new; my $rotateMenuItem = $menu->AppendSubMenu($rotateMenu, "Rotate", 'Rotate the selected object by an arbitrary angle'); $frame->_set_menu_item_icon($rotateMenuItem, 'textfield.png'); $frame->_append_menu_item($rotateMenu, "Around X axis…", 'Rotate the selected object by an arbitrary angle around X axis', sub { $self->rotate(undef, X); }, undef, 'bullet_red.png'); $frame->_append_menu_item($rotateMenu, "Around Y axis…", 'Rotate the selected object by an arbitrary angle around Y axis', sub { $self->rotate(undef, Y); }, undef, 'bullet_green.png'); $frame->_append_menu_item($rotateMenu, "Around Z axis…", 'Rotate the selected object by an arbitrary angle around Z axis', sub { $self->rotate(undef, Z); }, undef, 'bullet_blue.png'); my $mirrorMenu = Wx::Menu->new; my $mirrorMenuItem = $menu->AppendSubMenu($mirrorMenu, "Mirror", 'Mirror the selected object'); $frame->_set_menu_item_icon($mirrorMenuItem, 'shape_flip_horizontal.png'); $frame->_append_menu_item($mirrorMenu, "Along X axis…", 'Mirror the selected object along the X axis', sub { $self->mirror(X); }, undef, 'bullet_red.png'); $frame->_append_menu_item($mirrorMenu, "Along Y axis…", 'Mirror the selected object along the Y axis', sub { $self->mirror(Y); }, undef, 'bullet_green.png'); $frame->_append_menu_item($mirrorMenu, "Along Z axis…", 'Mirror the selected object along the Z axis', sub { $self->mirror(Z); }, undef, 'bullet_blue.png'); my $scaleMenu = Wx::Menu->new; my $scaleMenuItem = $menu->AppendSubMenu($scaleMenu, "Scale", 'Scale the selected object along a single axis'); $frame->_set_menu_item_icon($scaleMenuItem, 'arrow_out.png'); $frame->_append_menu_item($scaleMenu, "Uniformly…", 'Scale the selected object along the XYZ axes', sub { $self->changescale(undef); }); $frame->_append_menu_item($scaleMenu, "Along X axis…", 'Scale the selected object along the X axis', sub { $self->changescale(X); }, undef, 'bullet_red.png'); $frame->_append_menu_item($scaleMenu, "Along Y axis…", 'Scale the selected object along the Y axis', sub { $self->changescale(Y); }, undef, 'bullet_green.png'); $frame->_append_menu_item($scaleMenu, "Along Z axis…", 'Scale the selected object along the Z axis', sub { $self->changescale(Z); }, undef, 'bullet_blue.png'); my $scaleToSizeMenu = Wx::Menu->new; my $scaleToSizeMenuItem = $menu->AppendSubMenu($scaleToSizeMenu, "Scale to size", 'Scale the selected object along a single axis'); $frame->_set_menu_item_icon($scaleToSizeMenuItem, 'arrow_out.png'); $frame->_append_menu_item($scaleToSizeMenu, "Uniformly…", 'Scale the selected object along the XYZ axes', sub { $self->changescale(undef, 1); }); $frame->_append_menu_item($scaleToSizeMenu, "Along X axis…", 'Scale the selected object along the X axis', sub { $self->changescale(X, 1); }, undef, 'bullet_red.png'); $frame->_append_menu_item($scaleToSizeMenu, "Along Y axis…", 'Scale the selected object along the Y axis', sub { $self->changescale(Y, 1); }, undef, 'bullet_green.png'); $frame->_append_menu_item($scaleToSizeMenu, "Along Z axis…", 'Scale the selected object along the Z axis', sub { $self->changescale(Z, 1); }, undef, 'bullet_blue.png'); $frame->_append_menu_item($menu, "Split", 'Split the selected object into individual parts', sub { $self->split_object; }, undef, 'shape_ungroup.png'); $frame->_append_menu_item($menu, "Cut…", 'Open the 3D cutting tool', sub { $self->object_cut_dialog; }, undef, 'package.png'); $menu->AppendSeparator(); $frame->_append_menu_item($menu, "Settings…", 'Open the object editor dialog', sub { $self->object_settings_dialog; }, undef, 'cog.png'); $menu->AppendSeparator(); $frame->_append_menu_item($menu, "Export object as STL…", 'Export this single object as STL file', sub { $self->export_object_stl; }, undef, 'brick_go.png'); return $menu; } # Set a camera direction, zoom to all objects. sub select_view { my ($self, $direction) = @_; my $idx_page = $self->{preview_notebook}->GetSelection; my $page = ($idx_page == &Wx::wxNOT_FOUND) ? '3D' : $self->{preview_notebook}->GetPageText($idx_page); if ($page eq 'Preview') { $self->{preview3D}->canvas->select_view($direction); $self->{canvas3D}->set_viewport_from_scene($self->{preview3D}->canvas); } else { $self->{canvas3D}->select_view($direction); $self->{preview3D}->canvas->set_viewport_from_scene($self->{canvas3D}); } } package Slic3r::GUI::Plater::DropTarget; use Wx::DND; use base 'Wx::FileDropTarget'; sub new { my $class = shift; my ($window) = @_; my $self = $class->SUPER::new; $self->{window} = $window; return $self; } sub OnDropFiles { my $self = shift; my ($x, $y, $filenames) = @_; # stop scalars leaking on older perl # https://rt.perl.org/rt3/Public/Bug/Display.html?id=70602 @_ = (); # only accept STL, OBJ and AMF files return 0 if grep !/\.(?:stl|obj|amf(?:\.xml)?)$/i, @$filenames; $self->{window}->load_file($_) for @$filenames; } # 2D preview of an object. Each object is previewed by its convex hull. package Slic3r::GUI::Plater::Object; use Moo; use List::Util qw(first); use Slic3r::Geometry qw(X Y Z MIN MAX deg2rad); has 'name' => (is => 'rw', required => 1); has 'thumbnail' => (is => 'rw'); # ExPolygon::Collection in scaled model units with no transforms has 'transformed_thumbnail' => (is => 'rw'); has 'instance_thumbnails' => (is => 'ro', default => sub { [] }); # array of ExPolygon::Collection objects, each one representing the actual placed thumbnail of each instance in pixel units has 'selected' => (is => 'rw', default => sub { 0 }); sub make_thumbnail { my ($self, $model, $obj_idx) = @_; # make method idempotent $self->thumbnail->clear; my $mesh = $model->objects->[$obj_idx]->raw_mesh; if ($mesh->facets_count <= 5000) { # remove polygons with area <= 1mm my $area_threshold = Slic3r::Geometry::scale 1; $self->thumbnail->append( grep $_->area >= $area_threshold, @{ $mesh->horizontal_projection }, # horizontal_projection returns scaled expolygons ); $self->thumbnail->simplify(0.5); } else { my $convex_hull = Slic3r::ExPolygon->new($mesh->convex_hull); $self->thumbnail->append($convex_hull); } return $self->thumbnail; } sub transform_thumbnail { my ($self, $model, $obj_idx) = @_; return unless defined $self->thumbnail; my $model_object = $model->objects->[$obj_idx]; my $model_instance = $model_object->instances->[0]; # the order of these transformations MUST be the same everywhere, including # in Slic3r::Print->add_model_object() my $t = $self->thumbnail->clone; $t->rotate($model_instance->rotation, Slic3r::Point->new(0,0)); $t->scale($model_instance->scaling_factor); $self->transformed_thumbnail($t); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/000077500000000000000000000000001301441720000202565ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/2D.pm000066400000000000000000000335741301441720000210750ustar00rootroot00000000000000# 2D preview on the platter. # 3D objects are visualized by their convex hulls. package Slic3r::GUI::Plater::2D; use strict; use warnings; use utf8; use List::Util qw(min max first); use Slic3r::Geometry qw(X Y scale unscale convex_hull); use Slic3r::Geometry::Clipper qw(offset JT_ROUND intersection_pl); use Wx qw(:misc :pen :brush :sizer :font :cursor wxTAB_TRAVERSAL); use Wx::Event qw(EVT_MOUSE_EVENTS EVT_PAINT EVT_ERASE_BACKGROUND EVT_SIZE); use base 'Wx::Panel'; use constant CANVAS_TEXT => join('-', +(localtime)[3,4]) eq '13-8' ? 'What do you want to print today? â„¢' # Sept. 13, 2006. The first part ever printed by a RepRap to make another RepRap. : 'Drag your objects here'; sub new { my $class = shift; my ($parent, $size, $objects, $model, $config) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, $size, wxTAB_TRAVERSAL); # This has only effect on MacOS. On Windows and Linux/GTK, the background is painted by $self->repaint(). $self->SetBackgroundColour(Wx::wxWHITE); $self->{objects} = $objects; $self->{model} = $model; $self->{config} = $config; $self->{on_select_object} = sub {}; $self->{on_double_click} = sub {}; $self->{on_right_click} = sub {}; $self->{on_instances_moved} = sub {}; $self->{objects_brush} = Wx::Brush->new(Wx::Colour->new(210,210,210), wxSOLID); $self->{selected_brush} = Wx::Brush->new(Wx::Colour->new(255,128,128), wxSOLID); $self->{dragged_brush} = Wx::Brush->new(Wx::Colour->new(128,128,255), wxSOLID); $self->{transparent_brush} = Wx::Brush->new(Wx::Colour->new(0,0,0), wxTRANSPARENT); $self->{grid_pen} = Wx::Pen->new(Wx::Colour->new(230,230,230), 1, wxSOLID); $self->{print_center_pen} = Wx::Pen->new(Wx::Colour->new(200,200,200), 1, wxSOLID); $self->{clearance_pen} = Wx::Pen->new(Wx::Colour->new(0,0,200), 1, wxSOLID); $self->{skirt_pen} = Wx::Pen->new(Wx::Colour->new(150,150,150), 1, wxSOLID); $self->{user_drawn_background} = $^O ne 'darwin'; EVT_PAINT($self, \&repaint); EVT_ERASE_BACKGROUND($self, sub {}) if $self->{user_drawn_background}; EVT_MOUSE_EVENTS($self, \&mouse_event); EVT_SIZE($self, sub { $self->update_bed_size; $self->Refresh; }); return $self; } sub on_select_object { my ($self, $cb) = @_; $self->{on_select_object} = $cb; } sub on_double_click { my ($self, $cb) = @_; $self->{on_double_click} = $cb; } sub on_right_click { my ($self, $cb) = @_; $self->{on_right_click} = $cb; } sub on_instances_moved { my ($self, $cb) = @_; $self->{on_instances_moved} = $cb; } sub repaint { my ($self, $event) = @_; my $dc = Wx::AutoBufferedPaintDC->new($self); my $size = $self->GetSize; my @size = ($size->GetWidth, $size->GetHeight); if ($self->{user_drawn_background}) { # On all systems the AutoBufferedPaintDC() achieves double buffering. # On MacOS the background is erased, on Windows the background is not erased # and on Linux/GTK the background is erased to gray color. # Fill DC with the background on Windows & Linux/GTK. my $brush_background = Wx::Brush->new(Wx::wxWHITE, wxSOLID); $dc->SetPen(wxWHITE_PEN); $dc->SetBrush($brush_background); my $rect = $self->GetUpdateRegion()->GetBox(); $dc->DrawRectangle($rect->GetLeft(), $rect->GetTop(), $rect->GetWidth(), $rect->GetHeight()); } # draw grid $dc->SetPen($self->{grid_pen}); $dc->DrawLine(map @$_, @$_) for @{$self->{grid}}; # draw bed { $dc->SetPen($self->{print_center_pen}); $dc->SetBrush($self->{transparent_brush}); $dc->DrawPolygon($self->scaled_points_to_pixel($self->{bed_polygon}, 1), 0, 0); } # draw print center if (@{$self->{objects}} && $Slic3r::GUI::Settings->{_}{autocenter}) { my $center = $self->unscaled_point_to_pixel($self->{print_center}); $dc->SetPen($self->{print_center_pen}); $dc->DrawLine($center->[X], 0, $center->[X], $size[Y]); $dc->DrawLine(0, $center->[Y], $size[X], $center->[Y]); $dc->SetTextForeground(Wx::Colour->new(0,0,0)); $dc->SetFont(Wx::Font->new(10, wxDEFAULT, wxNORMAL, wxNORMAL)); $dc->DrawLabel("X = " . sprintf('%.0f', $self->{print_center}->[X]), Wx::Rect->new(0, 0, $center->[X]*2, $self->GetSize->GetHeight), wxALIGN_CENTER_HORIZONTAL | wxALIGN_BOTTOM); $dc->DrawRotatedText("Y = " . sprintf('%.0f', $self->{print_center}->[Y]), 0, $center->[Y]+15, 90); } # draw frame if (0) { $dc->SetPen(wxBLACK_PEN); $dc->SetBrush($self->{transparent_brush}); $dc->DrawRectangle(0, 0, @size); } # draw text if plate is empty if (!@{$self->{objects}}) { $dc->SetTextForeground(Wx::Colour->new(150,50,50)); $dc->SetFont(Wx::Font->new(14, wxDEFAULT, wxNORMAL, wxNORMAL)); $dc->DrawLabel(CANVAS_TEXT, Wx::Rect->new(0, 0, $self->GetSize->GetWidth, $self->GetSize->GetHeight), wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL); } # draw thumbnails $dc->SetPen(wxBLACK_PEN); $self->clean_instance_thumbnails; for my $obj_idx (0 .. $#{$self->{objects}}) { my $object = $self->{objects}[$obj_idx]; my $model_object = $self->{model}->objects->[$obj_idx]; next unless defined $object->thumbnail; for my $instance_idx (0 .. $#{$model_object->instances}) { my $instance = $model_object->instances->[$instance_idx]; next if !defined $object->transformed_thumbnail; my $thumbnail = $object->transformed_thumbnail->clone; # in scaled model coordinates $thumbnail->translate(map scale($_), @{$instance->offset}); $object->instance_thumbnails->[$instance_idx] = $thumbnail; if (defined $self->{drag_object} && $self->{drag_object}[0] == $obj_idx && $self->{drag_object}[1] == $instance_idx) { $dc->SetBrush($self->{dragged_brush}); } elsif ($object->selected) { $dc->SetBrush($self->{selected_brush}); } else { $dc->SetBrush($self->{objects_brush}); } foreach my $expolygon (@$thumbnail) { foreach my $points (@{$expolygon->pp}) { $dc->DrawPolygon($self->scaled_points_to_pixel($points, 1), 0, 0); } } if (0) { # draw bounding box for debugging purposes my $bb = $model_object->instance_bounding_box($instance_idx); $bb->scale($self->{scaling_factor}); # no need to translate by instance offset because instance_bounding_box() does that my $points = $bb->polygon->pp; $dc->SetPen($self->{clearance_pen}); $dc->SetBrush($self->{transparent_brush}); $dc->DrawPolygon($self->_y($points), 0, 0); } # if sequential printing is enabled and we have more than one object, draw clearance area if ($self->{config}->complete_objects && (map @{$_->instances}, @{$self->{model}->objects}) > 1) { my ($clearance) = @{offset([$thumbnail->convex_hull], (scale($self->{config}->extruder_clearance_radius) / 2), 1, JT_ROUND, scale(0.1))}; $dc->SetPen($self->{clearance_pen}); $dc->SetBrush($self->{transparent_brush}); $dc->DrawPolygon($self->scaled_points_to_pixel($clearance, 1), 0, 0); } } } # draw skirt if (@{$self->{objects}} && $self->{config}->skirts) { my @points = map @{$_->contour}, map @$_, map @{$_->instance_thumbnails}, @{$self->{objects}}; if (@points >= 3) { my ($convex_hull) = @{offset([convex_hull(\@points)], scale max($self->{config}->brim_width + $self->{config}->skirt_distance), 1, JT_ROUND, scale(0.1))}; $dc->SetPen($self->{skirt_pen}); $dc->SetBrush($self->{transparent_brush}); $dc->DrawPolygon($self->scaled_points_to_pixel($convex_hull, 1), 0, 0); } } $event->Skip; } sub mouse_event { my ($self, $event) = @_; my $pos = $event->GetPosition; my $point = $self->point_to_model_units([ $pos->x, $pos->y ]); #]] if ($event->ButtonDown) { $self->{on_select_object}->(undef); # traverse objects and instances in reverse order, so that if they're overlapping # we get the one that gets drawn last, thus on top (as user expects that to move) OBJECTS: for my $obj_idx (reverse 0 .. $#{$self->{objects}}) { my $object = $self->{objects}->[$obj_idx]; for my $instance_idx (reverse 0 .. $#{ $object->instance_thumbnails }) { my $thumbnail = $object->instance_thumbnails->[$instance_idx]; if (defined first { $_->contour->contains_point($point) } @$thumbnail) { $self->{on_select_object}->($obj_idx); if ($event->LeftDown) { # start dragging my $instance = $self->{model}->objects->[$obj_idx]->instances->[$instance_idx]; my $instance_origin = [ map scale($_), @{$instance->offset} ]; $self->{drag_start_pos} = [ # displacement between the click and the instance origin in scaled model units $point->x - $instance_origin->[X], $point->y - $instance_origin->[Y], #- ]; $self->{drag_object} = [ $obj_idx, $instance_idx ]; } elsif ($event->RightDown) { $self->{on_right_click}->($pos); } last OBJECTS; } } } $self->Refresh; } elsif ($event->LeftUp) { $self->{on_instances_moved}->() if $self->{drag_object}; $self->{drag_start_pos} = undef; $self->{drag_object} = undef; $self->SetCursor(wxSTANDARD_CURSOR); } elsif ($event->LeftDClick) { $self->{on_double_click}->(); } elsif ($event->Dragging) { return if !$self->{drag_start_pos}; # concurrency problems my ($obj_idx, $instance_idx) = @{ $self->{drag_object} }; my $model_object = $self->{model}->objects->[$obj_idx]; $model_object->instances->[$instance_idx]->set_offset( Slic3r::Pointf->new( unscale($point->[X] - $self->{drag_start_pos}[X]), unscale($point->[Y] - $self->{drag_start_pos}[Y]), )); $model_object->update_bounding_box; $self->Refresh; } elsif ($event->Moving) { my $cursor = wxSTANDARD_CURSOR; if (defined first { $_->contour->contains_point($point) } map @$_, map @{$_->instance_thumbnails}, @{ $self->{objects} }) { $cursor = Wx::Cursor->new(wxCURSOR_HAND); } $self->SetCursor($cursor); } } sub update_bed_size { my $self = shift; # when the canvas is not rendered yet, its GetSize() method returns 0,0 my $canvas_size = $self->GetSize; my ($canvas_w, $canvas_h) = ($canvas_size->GetWidth, $canvas_size->GetHeight); return if $canvas_w == 0; # get bed shape polygon $self->{bed_polygon} = my $polygon = Slic3r::Polygon->new_scale(@{$self->{config}->bed_shape}); my $bb = $polygon->bounding_box; my $size = $bb->size; # calculate the scaling factor needed for constraining print bed area inside preview # scaling_factor is expressed in pixel / mm $self->{scaling_factor} = min($canvas_w / unscale($size->x), $canvas_h / unscale($size->y)); #) # calculate the displacement needed to center bed $self->{bed_origin} = [ $canvas_w/2 - (unscale($bb->x_max + $bb->x_min)/2 * $self->{scaling_factor}), $canvas_h - ($canvas_h/2 - (unscale($bb->y_max + $bb->y_min)/2 * $self->{scaling_factor})), ]; # calculate print center my $center = $bb->center; $self->{print_center} = [ unscale($center->x), unscale($center->y) ]; #)) # cache bed contours and grid { my $step = scale 10; # 1cm grid my @polylines = (); for (my $x = $bb->x_min - ($bb->x_min % $step) + $step; $x < $bb->x_max; $x += $step) { push @polylines, Slic3r::Polyline->new([$x, $bb->y_min], [$x, $bb->y_max]); } for (my $y = $bb->y_min - ($bb->y_min % $step) + $step; $y < $bb->y_max; $y += $step) { push @polylines, Slic3r::Polyline->new([$bb->x_min, $y], [$bb->x_max, $y]); } @polylines = @{intersection_pl(\@polylines, [$polygon])}; $self->{grid} = [ map $self->scaled_points_to_pixel([ @$_[0,-1] ], 1), @polylines ]; } } sub clean_instance_thumbnails { my ($self) = @_; foreach my $object (@{ $self->{objects} }) { @{ $object->instance_thumbnails } = (); } } # convert a model coordinate into a pixel coordinate sub unscaled_point_to_pixel { my ($self, $point) = @_; my $canvas_height = $self->GetSize->GetHeight; my $zero = $self->{bed_origin}; return [ $point->[X] * $self->{scaling_factor} + $zero->[X], $canvas_height - $point->[Y] * $self->{scaling_factor} + ($zero->[Y] - $canvas_height), ]; } sub scaled_points_to_pixel { my ($self, $points, $unscale) = @_; my $result = []; foreach my $point (@$points) { $point = [ map unscale($_), @$point ] if $unscale; push @$result, $self->unscaled_point_to_pixel($point); } return $result; } sub point_to_model_units { my ($self, $point) = @_; my $zero = $self->{bed_origin}; return Slic3r::Point->new( scale ($point->[X] - $zero->[X]) / $self->{scaling_factor}, scale ($zero->[Y] - $point->[Y]) / $self->{scaling_factor}, ); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/2DToolpaths.pm000066400000000000000000000737471301441720000230010ustar00rootroot00000000000000# 2D preview of the tool paths of a single layer, using a thin line. # OpenGL is used to render the paths. # Vojtech also added a 2D simulation of under/over extrusion in a single layer. package Slic3r::GUI::Plater::2DToolpaths; use strict; use warnings; use utf8; use Slic3r::Print::State ':steps'; use Wx qw(:misc :sizer :slider :statictext :keycode wxWHITE wxWANTS_CHARS); use Wx::Event qw(EVT_SLIDER EVT_KEY_DOWN); use base qw(Wx::Panel Class::Accessor); __PACKAGE__->mk_accessors(qw(print enabled)); sub new { my $class = shift; my ($parent, $print) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS); $self->SetBackgroundColour(wxWHITE); # init GUI elements my $canvas = $self->{canvas} = Slic3r::GUI::Plater::2DToolpaths::Canvas->new($self, $print); my $slider = $self->{slider} = Wx::Slider->new( $self, -1, 0, # default 0, # min # we set max to a bogus non-zero value because the MSW implementation of wxSlider # will skip drawing the slider if max <= min: 1, # max wxDefaultPosition, wxDefaultSize, wxVERTICAL | wxSL_INVERSE, ); my $z_label = $self->{z_label} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, [40,-1], wxALIGN_CENTRE_HORIZONTAL); $z_label->SetFont($Slic3r::GUI::small_font); my $vsizer = Wx::BoxSizer->new(wxVERTICAL); $vsizer->Add($slider, 1, wxALL | wxEXPAND | wxALIGN_CENTER, 3); $vsizer->Add($z_label, 0, wxALL | wxEXPAND | wxALIGN_CENTER, 3); my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($canvas, 1, wxALL | wxEXPAND, 0); $sizer->Add($vsizer, 0, wxTOP | wxBOTTOM | wxEXPAND, 5); EVT_SLIDER($self, $slider, sub { $self->set_z($self->{layers_z}[$slider->GetValue]) if $self->enabled; }); EVT_KEY_DOWN($canvas, sub { my ($s, $event) = @_; my $key = $event->GetKeyCode; if ($key == ord('D') || $key == WXK_LEFT) { # Keys: 'D' or WXK_LEFT $slider->SetValue($slider->GetValue - 1); $self->set_z($self->{layers_z}[$slider->GetValue]); } elsif ($key == ord('U') || $key == WXK_RIGHT) { # Keys: 'U' or WXK_RIGHT $slider->SetValue($slider->GetValue + 1); $self->set_z($self->{layers_z}[$slider->GetValue]); } elsif ($key >= ord('1') && $key <= ord('3')) { # Keys: '1' to '3' $canvas->set_simulation_mode($key - ord('1')); } }); $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); $sizer->SetSizeHints($self); # init print $self->{print} = $print; $self->reload_print; return $self; } sub reload_print { my ($self) = @_; # we require that there's at least one object and the posSlice step # is performed on all of them (this ensures that _shifted_copies was # populated and we know the number of layers) if (!$self->print->object_step_done(STEP_SLICE)) { $self->enabled(0); $self->{slider}->Hide; $self->{canvas}->Refresh; # clears canvas return; } $self->{canvas}->bb($self->print->total_bounding_box); $self->{canvas}->_dirty(1); my %z = (); # z => 1 foreach my $object (@{$self->{print}->objects}) { foreach my $layer (@{$object->layers}, @{$object->support_layers}) { $z{$layer->print_z} = 1; } } $self->enabled(1); $self->{layers_z} = [ sort { $a <=> $b } keys %z ]; $self->{slider}->SetRange(0, scalar(@{$self->{layers_z}})-1); if ((my $z_idx = $self->{slider}->GetValue) <= $#{$self->{layers_z}}) { $self->set_z($self->{layers_z}[$z_idx]); } else { $self->{slider}->SetValue(0); $self->set_z($self->{layers_z}[0]) if @{$self->{layers_z}}; } $self->{slider}->Show; $self->Layout; } sub set_z { my ($self, $z) = @_; return if !$self->enabled; $self->{z_label}->SetLabel(sprintf '%.2f', $z); $self->{canvas}->set_z($z); } package Slic3r::GUI::Plater::2DToolpaths::Canvas; use Wx::Event qw(EVT_PAINT EVT_SIZE EVT_IDLE EVT_MOUSEWHEEL EVT_MOUSE_EVENTS); use OpenGL qw(:glconstants :glfunctions :glufunctions :gluconstants); use base qw(Wx::GLCanvas Class::Accessor); use Wx::GLCanvas qw(:all); use List::Util qw(min max first); use Slic3r::Geometry qw(scale unscale epsilon X Y); use Slic3r::Print::State ':steps'; __PACKAGE__->mk_accessors(qw( print z layers color init bb _camera_bb _dirty _zoom _camera_target _drag_start_xy _texture_name _texture_size _extrusion_simulator _simulation_mode )); # make OpenGL::Array thread-safe { no warnings 'redefine'; *OpenGL::Array::CLONE_SKIP = sub { 1 }; } sub new { my ($class, $parent, $print) = @_; my $self = (Wx::wxVERSION >= 3.000003) ? # The wxWidgets 3.0.3-beta have a bug, they crash with NULL attribute list. $class->SUPER::new($parent, -1, Wx::wxDefaultPosition, Wx::wxDefaultSize, 0, "", [WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 24, 0]) : $class->SUPER::new($parent); # Immediatelly force creation of the OpenGL context to consume the static variable s_wglContextAttribs. $self->GetContext(); $self->print($print); $self->_zoom(1); # 2D point in model space $self->_camera_target(Slic3r::Pointf->new(0,0)); # Texture for the extrusion simulator. The texture will be allocated / reallocated on Resize. $self->_texture_name(0); $self->_texture_size(Slic3r::Point->new(0,0)); $self->_extrusion_simulator(Slic3r::ExtrusionSimulator->new()); $self->_simulation_mode(0); EVT_PAINT($self, sub { my $dc = Wx::PaintDC->new($self); $self->Render($dc); }); EVT_SIZE($self, sub { $self->_dirty(1) }); EVT_IDLE($self, sub { return unless $self->_dirty; return if !$self->IsShownOnScreen; $self->Resize; $self->Refresh; }); EVT_MOUSEWHEEL($self, sub { my ($self, $e) = @_; return if !$self->GetParent->enabled; my $old_zoom = $self->_zoom; # Calculate the zoom delta and apply it to the current zoom factor my $zoom = $e->GetWheelRotation() / $e->GetWheelDelta(); $zoom = max(min($zoom, 4), -4); $zoom /= 10; $self->_zoom($self->_zoom / (1-$zoom)); $self->_zoom(1) if $self->_zoom > 1; # prevent from zooming out too much { # In order to zoom around the mouse point we need to translate # the camera target. This math is almost there but not perfect yet... my $camera_bb_size = $self->_camera_bb->size; my $size = Slic3r::Pointf->new($self->GetSizeWH); my $pos = Slic3r::Pointf->new($e->GetPositionXY); # calculate the zooming center in pixel coordinates relative to the viewport center my $vec = Slic3r::Pointf->new($pos->x - $size->x/2, $pos->y - $size->y/2); #- # calculate where this point will end up after applying the new zoom my $vec2 = $vec->clone; $vec2->scale($old_zoom / $self->_zoom); # move the camera target by the difference of the two positions $self->_camera_target->translate( -($vec->x - $vec2->x) * $camera_bb_size->x / $size->x, ($vec->y - $vec2->y) * $camera_bb_size->y / $size->y, #// ); } $self->_dirty(1); $self->Refresh; }); EVT_MOUSE_EVENTS($self, \&mouse_event); return $self; } sub Destroy { my ($self) = @_; # Deallocate the OpenGL resources. my $context = $self->GetContext; if ($context and $self->texture_id) { $self->SetCurrent($context); glDeleteTextures(1, ($self->texture_id)); $self->SetCurrent(0); $self->texture_id(0); $self->texture_size(new Slic3r::Point(0, 0)); } return $self->SUPER::Destroy; } sub mouse_event { my ($self, $e) = @_; return if !$self->GetParent->enabled; my $pos = Slic3r::Pointf->new($e->GetPositionXY); if ($e->Entering && &Wx::wxMSW) { # wxMSW needs focus in order to catch mouse wheel events $self->SetFocus; } elsif ($e->Dragging) { if ($e->LeftIsDown || $e->MiddleIsDown || $e->RightIsDown) { # if dragging, translate view if (defined $self->_drag_start_xy) { my $move = $self->_drag_start_xy->vector_to($pos); # in pixels # get viewport and camera size in order to convert pixel to model units my ($x, $y) = $self->GetSizeWH; my $camera_bb_size = $self->_camera_bb->size; # compute translation in model units $self->_camera_target->translate( -$move->x * $camera_bb_size->x / $x, $move->y * $camera_bb_size->y / $y, # /** ); $self->_dirty(1); $self->Refresh; } $self->_drag_start_xy($pos); } } elsif ($e->LeftUp || $e->MiddleUp || $e->RightUp) { $self->_drag_start_xy(undef); } else { $e->Skip(); } } sub set_z { my ($self, $z) = @_; my $print = $self->print; # can we have interlaced layers? my $interlaced = (defined first { $_->config->support_material } @{$print->objects}) || (defined first { $_->config->infill_every_layers > 1 } @{$print->regions}); my $max_layer_height = $print->max_allowed_layer_height; my @layers = (); foreach my $object (@{$print->objects}) { foreach my $layer (@{$object->layers}, @{$object->support_layers}) { if ($interlaced) { push @layers, $layer if $z > ($layer->print_z - $max_layer_height - epsilon) && $z <= $layer->print_z + epsilon; } else { push @layers, $layer if abs($layer->print_z - $z) < epsilon; } } } # reverse layers so that we draw the lowermost (i.e. current) on top $self->z($z); $self->layers([ reverse @layers ]); $self->Refresh; } sub set_simulation_mode { my ($self, $mode) = @_; $self->_simulation_mode($mode); $self->_dirty(1); $self->Refresh; } sub Render { my ($self, $dc) = @_; # prevent calling SetCurrent() when window is not shown yet return unless $self->IsShownOnScreen; return unless my $context = $self->GetContext; $self->SetCurrent($context); $self->InitGL; glClearColor(1, 1, 1, 0); glClear(GL_COLOR_BUFFER_BIT); if (!$self->GetParent->enabled || !$self->layers) { glFlush(); $self->SwapBuffers; return; } glDisable(GL_DEPTH_TEST); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); if ($self->_simulation_mode and $self->_texture_name and $self->_texture_size->x() > 0 and $self->_texture_size->y() > 0) { $self->_simulate_extrusion(); my ($x, $y) = $self->GetSizeWH; glEnable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,GL_REPLACE); glBindTexture(GL_TEXTURE_2D, $self->_texture_name); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D_c(GL_TEXTURE_2D, 0, # level (0 normal, heighr is form mip-mapping) GL_RGBA, # internal format $self->_texture_size->x(), $self->_texture_size->y(), 0, # border GL_RGBA, # format RGBA color data GL_UNSIGNED_BYTE, # unsigned byte data $self->_extrusion_simulator->image_ptr()); # ptr to texture data glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrtho(0, 1, 0, 1, 0, 1); glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex2f(0, 0); glTexCoord2f($x/$self->_texture_size->x(), 0); glVertex2f(1, 0); glTexCoord2f($x/$self->_texture_size->x(), $y/$self->_texture_size->y()); glVertex2f(1, 1); glTexCoord2f(0, $y/$self->_texture_size->y()); glVertex2f(0, 1); glEnd(); glPopMatrix(); glBindTexture(GL_TEXTURE_2D, 0); } # anti-alias if (0) { glEnable(GL_LINE_SMOOTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE); glHint(GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE); } # Tesselator triangulates polygons with holes on the fly for the rendering purposes only. my $tess; if ($self->_simulation_mode() == 0 and !(&Wx::wxMSW && $OpenGL::VERSION < 0.6704)) { # We can't use the GLU tesselator on MSW with older OpenGL versions # because of an upstream bug: # http://sourceforge.net/p/pogl/bugs/16/ $tess = gluNewTess(); gluTessCallback($tess, GLU_TESS_BEGIN, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_END, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_VERTEX, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_COMBINE, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_ERROR, 'DEFAULT'); gluTessCallback($tess, GLU_TESS_EDGE_FLAG, 'DEFAULT'); } foreach my $layer (@{$self->layers}) { my $object = $layer->object; # only draw the slice for the current layer next unless abs($layer->print_z - $self->z) < epsilon; # draw slice contour glLineWidth(1); foreach my $copy (@{ $object->_shifted_copies }) { glPushMatrix(); glTranslatef(@$copy, 0); foreach my $slice (@{$layer->slices}) { glColor3f(0.95, 0.95, 0.95); if ($tess) { gluTessBeginPolygon($tess); foreach my $polygon (@$slice) { gluTessBeginContour($tess); gluTessVertex_p($tess, @$_, 0) for @$polygon; gluTessEndContour($tess); } gluTessEndPolygon($tess); } glColor3f(0.9, 0.9, 0.9); foreach my $polygon (@$slice) { foreach my $line (@{$polygon->lines}) { glBegin(GL_LINES); glVertex2f(@{$line->a}); glVertex2f(@{$line->b}); glEnd(); } } } glPopMatrix(); } } my $skirt_drawn = 0; my $brim_drawn = 0; foreach my $layer (@{$self->layers}) { my $object = $layer->object; my $print_z = $layer->print_z; # draw brim if ($self->print->step_done(STEP_BRIM) && $layer->id == 0 && !$brim_drawn) { $self->color([0, 0, 0]); $self->_draw(undef, $print_z, $_) for @{$self->print->brim}; $brim_drawn = 1; } if ($self->print->step_done(STEP_SKIRT) && ($self->print->has_infinite_skirt() || $self->print->config->skirt_height > $layer->id) && !$skirt_drawn) { $self->color([0, 0, 0]); $self->_draw(undef, $print_z, $_) for @{$self->print->skirt}; $skirt_drawn = 1; } foreach my $layerm (@{$layer->regions}) { if ($object->step_done(STEP_PERIMETERS)) { $self->color([0.7, 0, 0]); $self->_draw($object, $print_z, $_) for map @$_, @{$layerm->perimeters}; } if ($object->step_done(STEP_INFILL)) { $self->color([0, 0, 0.7]); $self->_draw($object, $print_z, $_) for map @$_, @{$layerm->fills}; } } if ($object->step_done(STEP_SUPPORTMATERIAL)) { if ($layer->isa('Slic3r::Layer::Support')) { $self->color([0, 0, 0]); $self->_draw($object, $print_z, $_) for @{$layer->support_fills}; $self->_draw($object, $print_z, $_) for @{$layer->support_interface_fills}; } } } gluDeleteTess($tess) if $tess; glFlush(); $self->SwapBuffers; } sub _draw { my ($self, $object, $print_z, $path) = @_; my @paths = $path->isa('Slic3r::ExtrusionLoop') ? @$path : ($path); $self->_draw_path($object, $print_z, $_) for @paths; } sub _draw_path { my ($self, $object, $print_z, $path) = @_; return if $print_z - $path->height > $self->z - epsilon; if (abs($print_z - $self->z) < epsilon) { glColor3f(@{$self->color}); } else { glColor3f(0.8, 0.8, 0.8); } glLineWidth(1); if (defined $object) { foreach my $copy (@{ $object->_shifted_copies }) { glPushMatrix(); glTranslatef(@$copy, 0); foreach my $line (@{$path->polyline->lines}) { glBegin(GL_LINES); glVertex2f(@{$line->a}); glVertex2f(@{$line->b}); glEnd(); } glPopMatrix(); } } else { foreach my $line (@{$path->polyline->lines}) { glBegin(GL_LINES); glVertex2f(@{$line->a}); glVertex2f(@{$line->b}); glEnd(); } } } sub _simulate_extrusion { my ($self) = @_; $self->_extrusion_simulator->reset_accumulator(); foreach my $layer (@{$self->layers}) { if (abs($layer->print_z - $self->z) < epsilon) { my $object = $layer->object; my @shifts = (defined $object) ? @{$object->_shifted_copies} : (Slic3r::Point->new(0, 0)); foreach my $layerm (@{$layer->regions}) { my @extrusions = (); if ($object->step_done(STEP_PERIMETERS)) { push @extrusions, @$_ for @{$layerm->perimeters}; } if ($object->step_done(STEP_INFILL)) { push @extrusions, @$_ for @{$layerm->fills}; } foreach my $extrusion_entity (@extrusions) { my @paths = $extrusion_entity->isa('Slic3r::ExtrusionLoop') ? @$extrusion_entity : ($extrusion_entity); foreach my $path (@paths) { print "width: ", $path->width, " height: ", $path->height, " mm3_per_mm: ", $path->mm3_per_mm, " height2: ", $path->mm3_per_mm / $path->height, "\n"; $self->_extrusion_simulator->extrude_to_accumulator($path, $_, $self->_simulation_mode()) for @shifts; } } } } } $self->_extrusion_simulator->evaluate_accumulator($self->_simulation_mode()); } sub InitGL { my $self = shift; return if $self->init; return unless $self->GetContext; my $texture_id = 0; ($texture_id) = glGenTextures_p(1); $self->_texture_name($texture_id); $self->init(1); } sub GetContext { my ($self) = @_; if (Wx::wxVERSION >= 2.009) { return $self->{context} ||= Wx::GLContext->new($self); } else { return $self->SUPER::GetContext; } } sub SetCurrent { my ($self, $context) = @_; if (Wx::wxVERSION >= 2.009) { return $self->SUPER::SetCurrent($context); } else { return $self->SUPER::SetCurrent; } } sub Resize { my ($self) = @_; return unless $self->GetContext; return unless $self->bb; $self->_dirty(0); $self->SetCurrent($self->GetContext); my ($x, $y) = $self->GetSizeWH; if ($self->_texture_size->x() < $x or $self->_texture_size->y() < $y) { # Allocate a large enough OpenGL texture with power of 2 dimensions. $self->_texture_size->set_x(1) if ($self->_texture_size->x() == 0); $self->_texture_size->set_y(1) if ($self->_texture_size->y() == 0); $self->_texture_size->set_x($self->_texture_size->x() * 2) while ($self->_texture_size->x() < $x); $self->_texture_size->set_y($self->_texture_size->y() * 2) while ($self->_texture_size->y() < $y); #print "screen size ", $x, "x", $y; #print "texture size ", $self->_texture_size->x(), "x", $self->_texture_size->y(); # Initialize an empty texture. glBindTexture(GL_TEXTURE_2D, $self->_texture_name); if (1) { glTexImage2D_c(GL_TEXTURE_2D, 0, # level (0 normal, heighr is form mip-mapping) GL_RGBA, # internal format $self->_texture_size->x(), $self->_texture_size->y(), 0, # border GL_RGBA, # format RGBA color data GL_UNSIGNED_BYTE, # unsigned byte data 0); # ptr to texture data } glBindTexture(GL_TEXTURE_2D, 0); $self->_extrusion_simulator->set_image_size($self->_texture_size); } $self->_extrusion_simulator->set_viewport(Slic3r::Geometry::BoundingBox->new_from_points( [Slic3r::Point->new(0, 0), Slic3r::Point->new($x, $y)])); glViewport(0, 0, $x, $y); glMatrixMode(GL_PROJECTION); glLoadIdentity(); my $bb = $self->bb->clone; # center bounding box around origin before scaling it my $bb_center = $bb->center; $bb->translate(@{$bb_center->negative}); # scale bounding box according to zoom factor $bb->scale($self->_zoom); # reposition bounding box around original center $bb->translate(@{$bb_center}); # translate camera $bb->translate(@{$self->_camera_target}); # keep camera_bb within total bb # (i.e. prevent user from panning outside the bounding box) { my @translate = (0,0); if ($bb->x_min < $self->bb->x_min) { $translate[X] += $self->bb->x_min - $bb->x_min; } if ($bb->y_min < $self->bb->y_min) { $translate[Y] += $self->bb->y_min - $bb->y_min; } if ($bb->x_max > $self->bb->x_max) { $translate[X] -= $bb->x_max - $self->bb->x_max; } if ($bb->y_max > $self->bb->y_max) { $translate[Y] -= $bb->y_max - $self->bb->y_max; } $self->_camera_target->translate(@translate); $bb->translate(@translate); } # save camera $self->_camera_bb($bb); my ($x1, $y1, $x2, $y2) = ($bb->x_min, $bb->y_min, $bb->x_max, $bb->y_max); if (($x2 - $x1)/($y2 - $y1) > $x/$y) { # adjust Y my $new_y = $y * ($x2 - $x1) / $x; $y1 = ($y2 + $y1)/2 - $new_y/2; $y2 = $y1 + $new_y; } else { my $new_x = $x * ($y2 - $y1) / $y; $x1 = ($x2 + $x1)/2 - $new_x/2; $x2 = $x1 + $new_x; } glOrtho($x1, $x2, $y1, $y2, 0, 1); # Set the adjusted bounding box at the extrusion simulator. #print "Scene bbox ", $bb->x_min, ",", $bb->y_min, " ", $bb->x_max, ",", $bb->y_max, "\n"; #print "Setting simulator bbox ", $x1, ",", $y1, " ", $x2, ",", $y2, "\n"; $self->_extrusion_simulator->set_bounding_box( Slic3r::Geometry::BoundingBox->new_from_points( [Slic3r::Point->new($x1, $y1), Slic3r::Point->new($x2, $y2)])); glMatrixMode(GL_MODELVIEW); } # Thick line drawing is not used anywhere. Probably not tested? sub line { my ( $x1, $y1, $x2, $y2, # coordinates of the line $w, # width/thickness of the line in pixel $Cr, $Cg, $Cb, # RGB color components $Br, $Bg, $Bb, # color of background when alphablend=false # Br=alpha of color when alphablend=true $alphablend, # use alpha blend or not ) = @_; my $t; my $R; my $f = $w - int($w); my $A; if ($alphablend) { $A = $Br; } else { $A = 1; } # determine parameters t,R if ($w >= 0 && $w < 1) { $t = 0.05; $R = 0.48 + 0.32 * $f; if (!$alphablend) { $Cr += 0.88 * (1-$f); $Cg += 0.88 * (1-$f); $Cb += 0.88 * (1-$f); $Cr = 1.0 if ($Cr > 1.0); $Cg = 1.0 if ($Cg > 1.0); $Cb = 1.0 if ($Cb > 1.0); } else { $A *= $f; } } elsif ($w >= 1.0 && $w < 2.0) { $t = 0.05 + $f*0.33; $R = 0.768 + 0.312*$f; } elsif ($w >= 2.0 && $w < 3.0) { $t = 0.38 + $f*0.58; $R = 1.08; } elsif ($w >= 3.0 && $w < 4.0) { $t = 0.96 + $f*0.48; $R = 1.08; } elsif ($w >= 4.0 && $w < 5.0) { $t= 1.44 + $f*0.46; $R = 1.08; } elsif ($w >= 5.0 && $w < 6.0) { $t= 1.9 + $f*0.6; $R = 1.08; } elsif ($w >= 6.0) { my $ff = $w - 6.0; $t = 2.5 + $ff*0.50; $R = 1.08; } #printf( "w=%f, f=%f, C=%.4f\n", $w, $f, $C); # determine angle of the line to horizontal my $tx = 0; my $ty = 0; # core thinkness of a line my $Rx = 0; my $Ry = 0; # fading edge of a line my $cx = 0; my $cy = 0; # cap of a line my $ALW = 0.01; my $dx = $x2 - $x1; my $dy = $y2 - $y1; if (abs($dx) < $ALW) { # vertical $tx = $t; $ty = 0; $Rx = $R; $Ry = 0; if ($w > 0.0 && $w < 1.0) { $tx *= 8; } elsif ($w == 1.0) { $tx *= 10; } } elsif (abs($dy) < $ALW) { #horizontal $tx = 0; $ty = $t; $Rx = 0; $Ry = $R; if ($w > 0.0 && $w < 1.0) { $ty *= 8; } elsif ($w == 1.0) { $ty *= 10; } } else { if ($w < 3) { # approximate to make things even faster my $m = $dy/$dx; # and calculate tx,ty,Rx,Ry if ($m > -0.4142 && $m <= 0.4142) { # -22.5 < $angle <= 22.5, approximate to 0 (degree) $tx = $t * 0.1; $ty = $t; $Rx = $R * 0.6; $Ry = $R; } elsif ($m > 0.4142 && $m <= 2.4142) { # 22.5 < $angle <= 67.5, approximate to 45 (degree) $tx = $t * -0.7071; $ty = $t * 0.7071; $Rx = $R * -0.7071; $Ry = $R * 0.7071; } elsif ($m > 2.4142 || $m <= -2.4142) { # 67.5 < $angle <= 112.5, approximate to 90 (degree) $tx = $t; $ty = $t*0.1; $Rx = $R; $Ry = $R*0.6; } elsif ($m > -2.4142 && $m < -0.4142) { # 112.5 < angle < 157.5, approximate to 135 (degree) $tx = $t * 0.7071; $ty = $t * 0.7071; $Rx = $R * 0.7071; $Ry = $R * 0.7071; } else { # error in determining angle printf("error in determining angle: m=%.4f\n", $m); } } else { # calculate to exact $dx= $y1 - $y2; $dy= $x2 - $x1; my $L = sqrt($dx*$dx + $dy*$dy); $dx /= $L; $dy /= $L; $cx = -0.6*$dy; $cy=0.6*$dx; $tx = $t*$dx; $ty = $t*$dy; $Rx = $R*$dx; $Ry = $R*$dy; } } # draw the line by triangle strip glBegin(GL_TRIANGLE_STRIP); if (!$alphablend) { glColor3f($Br, $Bg, $Bb); } else { glColor4f($Cr, $Cg, $Cb, 0); } glVertex2f($x1 - $tx - $Rx, $y1 - $ty - $Ry); # fading edge glVertex2f($x2 - $tx - $Rx, $y2 - $ty - $Ry); if (!$alphablend) { glColor3f($Cr, $Cg, $Cb); } else { glColor4f($Cr, $Cg, $Cb, $A); } glVertex2f($x1 - $tx, $y1 - $ty); # core glVertex2f($x2 - $tx, $y2 - $ty); glVertex2f($x1 + $tx, $y1 + $ty); glVertex2f($x2 + $tx, $y2 + $ty); if ((abs($dx) < $ALW || abs($dy) < $ALW) && $w <= 1.0) { # printf("skipped one fading edge\n"); } else { if (!$alphablend) { glColor3f($Br, $Bg, $Bb); } else { glColor4f($Cr, $Cg, $Cb, 0); } glVertex2f($x1 + $tx+ $Rx, $y1 + $ty + $Ry); # fading edge glVertex2f($x2 + $tx+ $Rx, $y2 + $ty + $Ry); } glEnd(); # cap if ($w < 3) { # do not draw cap } else { # draw cap glBegin(GL_TRIANGLE_STRIP); if (!$alphablend) { glColor3f($Br, $Bg, $Bb); } else { glColor4f($Cr, $Cg, $Cb, 0); } glVertex2f($x1 - $Rx + $cx, $y1 - $Ry + $cy); glVertex2f($x1 + $Rx + $cx, $y1 + $Ry + $cy); glColor3f($Cr, $Cg, $Cb); glVertex2f($x1 - $tx - $Rx, $y1 - $ty - $Ry); glVertex2f($x1 + $tx + $Rx, $y1 + $ty + $Ry); glEnd(); glBegin(GL_TRIANGLE_STRIP); if (!$alphablend) { glColor3f($Br, $Bg, $Bb); } else { glColor4f($Cr, $Cg, $Cb, 0); } glVertex2f($x2 - $Rx - $cx, $y2 - $Ry - $cy); glVertex2f($x2 + $Rx - $cx, $y2 + $Ry - $cy); glColor3f($Cr, $Cg, $Cb); glVertex2f($x2 - $tx - $Rx, $y2 - $ty - $Ry); glVertex2f($x2 + $tx + $Rx, $y2 + $ty + $Ry); glEnd(); } } package Slic3r::GUI::Plater::2DToolpaths::Dialog; use Wx qw(:dialog :id :misc :sizer); use Wx::Event qw(EVT_CLOSE); use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent, $print) = @_; my $self = $class->SUPER::new($parent, -1, "Toolpaths", wxDefaultPosition, [500,500], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add(Slic3r::GUI::Plater::2DToolpaths->new($self, $print), 1, wxEXPAND, 0); $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); # needed to actually free memory EVT_CLOSE($self, sub { $self->EndModal(wxID_OK); $self->Destroy; }); return $self; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/3D.pm000066400000000000000000000053461301441720000210720ustar00rootroot00000000000000package Slic3r::GUI::Plater::3D; use strict; use warnings; use utf8; use List::Util qw(); use Slic3r::Geometry qw(); use Slic3r::Geometry::Clipper qw(); use Wx qw(:misc :pen :brush :sizer :font :cursor wxTAB_TRAVERSAL); use Wx::Event qw(); use base qw(Slic3r::GUI::3DScene Class::Accessor); sub new { my $class = shift; my ($parent, $objects, $model, $config) = @_; my $self = $class->SUPER::new($parent); $self->enable_picking(1); $self->enable_moving(1); $self->select_by('object'); $self->drag_by('instance'); $self->{objects} = $objects; $self->{model} = $model; $self->{config} = $config; $self->{on_select_object} = sub {}; $self->{on_instances_moved} = sub {}; $self->on_select(sub { my ($volume_idx) = @_; my $obj_idx = undef; if ($volume_idx != -1) { $obj_idx = $self->object_idx($volume_idx); } $self->{on_select_object}->($obj_idx) if $self->{on_select_object}; }); $self->on_move(sub { my @volume_idxs = @_; my %done = (); # prevent moving instances twice foreach my $volume_idx (@volume_idxs) { my $volume = $self->volumes->[$volume_idx]; my $obj_idx = $self->object_idx($volume_idx); my $instance_idx = $self->instance_idx($volume_idx); next if $done{"${obj_idx}_${instance_idx}"}; $done{"${obj_idx}_${instance_idx}"} = 1; my $model_object = $self->{model}->get_object($obj_idx); $model_object ->instances->[$instance_idx] ->offset ->translate($volume->origin->x, $volume->origin->y); #)) $model_object->invalidate_bounding_box; } $self->{on_instances_moved}->() if $self->{on_instances_moved}; }); return $self; } sub set_on_select_object { my ($self, $cb) = @_; $self->{on_select_object} = $cb; } sub set_on_double_click { my ($self, $cb) = @_; $self->on_double_click($cb); } sub set_on_right_click { my ($self, $cb) = @_; $self->on_right_click($cb); } sub set_on_instances_moved { my ($self, $cb) = @_; $self->{on_instances_moved} = $cb; } sub update { my ($self) = @_; $self->reset_objects; $self->update_bed_size; foreach my $obj_idx (0..$#{$self->{model}->objects}) { my @volume_idxs = $self->load_object($self->{model}, $obj_idx); if ($self->{objects}[$obj_idx]->selected) { $self->select_volume($_) for @volume_idxs; } } } sub update_bed_size { my ($self) = @_; $self->set_bed_shape($self->{config}->bed_shape); } 1;Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/3DPreview.pm000066400000000000000000000204151301441720000224260ustar00rootroot00000000000000package Slic3r::GUI::Plater::3DPreview; use strict; use warnings; use utf8; use Slic3r::Print::State ':steps'; use Wx qw(:misc :sizer :slider :statictext :keycode wxWHITE); use Wx::Event qw(EVT_SLIDER EVT_KEY_DOWN EVT_CHECKBOX); use base qw(Wx::Panel Class::Accessor); __PACKAGE__->mk_accessors(qw(print enabled _loaded canvas slider_low slider_high single_layer)); sub new { my $class = shift; my ($parent, $print) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition); # init GUI elements my $canvas = Slic3r::GUI::3DScene->new($self); $self->canvas($canvas); my $slider_low = Wx::Slider->new( $self, -1, 0, # default 0, # min # we set max to a bogus non-zero value because the MSW implementation of wxSlider # will skip drawing the slider if max <= min: 1, # max wxDefaultPosition, wxDefaultSize, wxVERTICAL | wxSL_INVERSE, ); $self->slider_low($slider_low); my $slider_high = Wx::Slider->new( $self, -1, 0, # default 0, # min # we set max to a bogus non-zero value because the MSW implementation of wxSlider # will skip drawing the slider if max <= min: 1, # max wxDefaultPosition, wxDefaultSize, wxVERTICAL | wxSL_INVERSE, ); $self->slider_high($slider_high); my $z_label_low = $self->{z_label_low} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, [40,-1], wxALIGN_CENTRE_HORIZONTAL); $z_label_low->SetFont($Slic3r::GUI::small_font); my $z_label_high = $self->{z_label_high} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, [40,-1], wxALIGN_CENTRE_HORIZONTAL); $z_label_high->SetFont($Slic3r::GUI::small_font); $self->single_layer(0); my $checkbox_singlelayer = $self->{checkbox_singlelayer} = Wx::CheckBox->new($self, -1, "1 Layer"); my $hsizer = Wx::BoxSizer->new(wxHORIZONTAL); my $vsizer = Wx::BoxSizer->new(wxVERTICAL); my $vsizer_outer = Wx::BoxSizer->new(wxVERTICAL); $vsizer->Add($slider_low, 3, 0, 0); $vsizer->Add($z_label_low, 0, 0, 0); $hsizer->Add($vsizer, 0, wxEXPAND, 0); $vsizer = Wx::BoxSizer->new(wxVERTICAL); $vsizer->Add($slider_high, 3, 0, 0); $vsizer->Add($z_label_high, 0, 0, 0); $hsizer->Add($vsizer, 0, wxEXPAND, 0); $vsizer_outer->Add($hsizer, 3, wxALIGN_CENTER_HORIZONTAL, 0); $vsizer_outer->Add($checkbox_singlelayer, 0, wxTOP | wxALIGN_CENTER_HORIZONTAL, 5); my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($canvas, 1, wxALL | wxEXPAND, 0); $sizer->Add($vsizer_outer, 0, wxTOP | wxBOTTOM | wxEXPAND, 5); EVT_SLIDER($self, $slider_low, sub { $slider_high->SetValue($slider_low->GetValue) if $self->single_layer; $self->set_z_idx_low ($slider_low ->GetValue) }); EVT_SLIDER($self, $slider_high, sub { $slider_low->SetValue($slider_high->GetValue) if $self->single_layer; $self->set_z_idx_high($slider_high->GetValue) }); EVT_KEY_DOWN($canvas, sub { my ($s, $event) = @_; my $key = $event->GetKeyCode; if ($key == ord('U') || $key == WXK_RIGHT) { $slider_high->SetValue($slider_high->GetValue + 1); $slider_low->SetValue($slider_high->GetValue) if ($event->ShiftDown()); $self->set_z_idx_high($slider_high->GetValue); } elsif ($key == ord('D') || $key == WXK_LEFT) { $slider_high->SetValue($slider_high->GetValue - 1); $slider_low->SetValue($slider_high->GetValue) if ($event->ShiftDown()); $self->set_z_idx_high($slider_high->GetValue); } elsif ($key == ord('S')) { $checkbox_singlelayer->SetValue(! $checkbox_singlelayer->GetValue()); $self->single_layer($checkbox_singlelayer->GetValue()); if ($self->single_layer) { $slider_low->SetValue($slider_high->GetValue); $self->set_z_idx_high($slider_high->GetValue); } } }); EVT_CHECKBOX($self, $checkbox_singlelayer, sub { $self->single_layer($checkbox_singlelayer->GetValue()); if ($self->single_layer) { $slider_low->SetValue($slider_high->GetValue); $self->set_z_idx_high($slider_high->GetValue); } }); $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); $sizer->SetSizeHints($self); # init canvas $self->print($print); $self->reload_print; return $self; } sub reload_print { my ($self) = @_; $self->canvas->reset_objects; $self->_loaded(0); $self->load_print; } sub load_print { my ($self) = @_; return if $self->_loaded; # we require that there's at least one object and the posSlice step # is performed on all of them (this ensures that _shifted_copies was # populated and we know the number of layers) my $n_layers = 0; if ($self->print->object_step_done(STEP_SLICE)) { my %z = (); # z => 1 foreach my $object (@{$self->{print}->objects}) { foreach my $layer (@{$object->layers}, @{$object->support_layers}) { $z{$layer->print_z} = 1; } } $self->{layers_z} = [ sort { $a <=> $b } keys %z ]; $n_layers = scalar(@{$self->{layers_z}}); } if ($n_layers == 0) { $self->enabled(0); $self->set_z_range(0,0); $self->slider_low->Hide; $self->slider_high->Hide; $self->canvas->Refresh; # clears canvas return; } my $z_idx_low = $self->slider_low->GetValue; my $z_idx_high = $self->slider_high->GetValue; $self->enabled(1); $self->slider_low->SetRange(0, $n_layers - 1); $self->slider_high->SetRange(0, $n_layers - 1); if ($z_idx_high < $n_layers && ($self->single_layer || $z_idx_high != 0)) { # use $z_idx } else { # Out of range. Disable 'single layer' view. $self->single_layer(0); $self->{checkbox_singlelayer}->SetValue(0); $z_idx_low = 0; $z_idx_high = $n_layers - 1; } if ($self->single_layer) { $z_idx_low = $z_idx_high; } elsif ($z_idx_low > $z_idx_high) { $z_idx_low = 0; } $self->slider_low->SetValue($z_idx_low); $self->slider_high->SetValue($z_idx_high); $self->slider_low->Show; $self->slider_high->Show; $self->Layout; if ($self->IsShown) { # load skirt and brim $self->canvas->load_print_toolpaths($self->print); foreach my $object (@{$self->print->objects}) { $self->canvas->load_print_object_toolpaths($object); # Show the objects in very transparent color. #my @volume_ids = $self->canvas->load_object($object->model_object); #$self->canvas->volumes->[$_]->color->[3] = 0.2 for @volume_ids; } $self->canvas->zoom_to_volumes; $self->_loaded(1); } $self->set_z_range($self->{layers_z}[$z_idx_low], $self->{layers_z}[$z_idx_high]); } sub set_z_range { my ($self, $z_low, $z_high) = @_; return if !$self->enabled; $self->{z_label_low}->SetLabel(sprintf '%.2f', $z_low); $self->{z_label_high}->SetLabel(sprintf '%.2f', $z_high); $self->canvas->set_toolpaths_range($z_low - 1e-6, $z_high + 1e-6); $self->canvas->Refresh if $self->IsShown; } sub set_z_idx_low { my ($self, $idx_low) = @_; if ($self->enabled) { my $idx_high = $self->slider_high->GetValue; if ($idx_low >= $idx_high) { $idx_high = $idx_low; $self->slider_high->SetValue($idx_high); } $self->set_z_range($self->{layers_z}[$idx_low], $self->{layers_z}[$idx_high]); } } sub set_z_idx_high { my ($self, $idx_high) = @_; if ($self->enabled) { my $idx_low = $self->slider_low->GetValue; if ($idx_low > $idx_high) { $idx_low = $idx_high; $self->slider_low->SetValue($idx_low); } $self->set_z_range($self->{layers_z}[$idx_low], $self->{layers_z}[$idx_high]); } } sub set_bed_shape { my ($self, $bed_shape) = @_; $self->canvas->set_bed_shape($bed_shape); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/3DToolpaths.pm000066400000000000000000000110461301441720000227620ustar00rootroot00000000000000package Slic3r::GUI::Plater::3DToolpaths; use strict; use warnings; use utf8; use Slic3r::Print::State ':steps'; use Wx qw(:misc :sizer :slider :statictext wxWHITE); use Wx::Event qw(EVT_SLIDER EVT_KEY_DOWN); use base qw(Wx::Panel Class::Accessor); __PACKAGE__->mk_accessors(qw(print enabled _loaded canvas slider)); sub new { my $class = shift; my ($parent, $print) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition); # init GUI elements my $canvas = Slic3r::GUI::3DScene->new($self); $self->canvas($canvas); my $slider = Wx::Slider->new( $self, -1, 0, # default 0, # min # we set max to a bogus non-zero value because the MSW implementation of wxSlider # will skip drawing the slider if max <= min: 1, # max wxDefaultPosition, wxDefaultSize, wxVERTICAL | wxSL_INVERSE, ); $self->slider($slider); my $z_label = $self->{z_label} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, [40,-1], wxALIGN_CENTRE_HORIZONTAL); $z_label->SetFont($Slic3r::GUI::small_font); my $vsizer = Wx::BoxSizer->new(wxVERTICAL); $vsizer->Add($slider, 1, wxALL | wxEXPAND | wxALIGN_CENTER, 3); $vsizer->Add($z_label, 0, wxALL | wxEXPAND | wxALIGN_CENTER, 3); my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($canvas, 1, wxALL | wxEXPAND, 0); $sizer->Add($vsizer, 0, wxTOP | wxBOTTOM | wxEXPAND, 5); EVT_SLIDER($self, $slider, sub { $self->set_z($self->{layers_z}[$slider->GetValue]) if $self->enabled; }); EVT_KEY_DOWN($canvas, sub { my ($s, $event) = @_; my $key = $event->GetKeyCode; if ($key == 85 || $key == 315) { $slider->SetValue($slider->GetValue + 1); $self->set_z($self->{layers_z}[$slider->GetValue]); } elsif ($key == 68 || $key == 317) { $slider->SetValue($slider->GetValue - 1); $self->set_z($self->{layers_z}[$slider->GetValue]); } }); $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); $sizer->SetSizeHints($self); # init canvas $self->print($print); $self->reload_print; return $self; } sub reload_print { my ($self) = @_; $self->canvas->reset_objects; $self->_loaded(0); $self->load_print; } sub load_print { my ($self) = @_; return if $self->_loaded; # we require that there's at least one object and the posSlice step # is performed on all of them (this ensures that _shifted_copies was # populated and we know the number of layers) if (!$self->print->object_step_done(STEP_SLICE)) { $self->enabled(0); $self->slider->Hide; $self->canvas->Refresh; # clears canvas return; } my $z_idx; { my %z = (); # z => 1 foreach my $object (@{$self->{print}->objects}) { foreach my $layer (@{$object->layers}, @{$object->support_layers}) { $z{$layer->print_z} = 1; } } $self->enabled(1); $self->{layers_z} = [ sort { $a <=> $b } keys %z ]; $self->slider->SetRange(0, scalar(@{$self->{layers_z}})-1); if (($z_idx = $self->slider->GetValue) <= $#{$self->{layers_z}} && $self->slider->GetValue != 0) { # use $z_idx } else { $self->slider->SetValue(scalar(@{$self->{layers_z}})-1); $z_idx = @{$self->{layers_z}} ? -1 : undef; } $self->slider->Show; $self->Layout; } if ($self->IsShown) { # load skirt and brim $self->canvas->load_print_toolpaths($self->print); foreach my $object (@{$self->print->objects}) { $self->canvas->load_print_object_toolpaths($object); # Show the objects in very transparent color. #my @volume_ids = $self->canvas->load_object($object->model_object); #$self->canvas->volumes->[$_]->color->[3] = 0.2 for @volume_ids; } $self->canvas->zoom_to_volumes; $self->_loaded(1); } $self->set_z($self->{layers_z}[$z_idx]); } sub set_z { my ($self, $z) = @_; return if !$self->enabled; $self->{z_label}->SetLabel(sprintf '%.2f', $z); $self->canvas->set_toolpaths_range(0, $z); $self->canvas->Refresh if $self->IsShown; } sub set_bed_shape { my ($self, $bed_shape) = @_; $self->canvas->set_bed_shape($bed_shape); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/ObjectCutDialog.pm000066400000000000000000000252211301441720000236200ustar00rootroot00000000000000# Cut an object at a Z position, keep either the top or the bottom of the object. # This dialog gets opened with the "Cut..." button above the platter. package Slic3r::GUI::Plater::ObjectCutDialog; use strict; use warnings; use utf8; use Slic3r::Geometry qw(PI X); use Wx qw(wxTheApp :dialog :id :misc :sizer wxTAB_TRAVERSAL); use Wx::Event qw(EVT_CLOSE EVT_BUTTON); use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, $params{object}->name, wxDefaultPosition, [500,500], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); $self->{model_object_idx} = $params{model_object_idx}; $self->{model_object} = $params{model_object}; $self->{new_model_objects} = []; # Mark whether the mesh cut is valid. # If not, it needs to be recalculated by _update() on wxTheApp->CallAfter() or on exit of the dialog. $self->{mesh_cut_valid} = 0; # Note whether the window was already closed, so a pending update is not executed. $self->{already_closed} = 0; # cut options $self->{cut_options} = { z => 0, keep_upper => 1, keep_lower => 1, rotate_lower => 1, # preview => 1, # Disabled live preview by default as it is not stable and/or the calculation takes too long for interactive usage. preview => 0, }; my $optgroup; $optgroup = $self->{optgroup} = Slic3r::GUI::OptionsGroup->new( parent => $self, title => 'Cut', on_change => sub { my ($opt_id) = @_; # There seems to be an issue with wxWidgets 3.0.2/3.0.3, where the slider # genates tens of events for a single value change. # Only trigger the recalculation if the value changes # or a live preview was activated and the mesh cut is not valid yet. if ($self->{cut_options}{$opt_id} != $optgroup->get_value($opt_id) || ! $self->{mesh_cut_valid} && $self->_life_preview_active()) { $self->{cut_options}{$opt_id} = $optgroup->get_value($opt_id); $self->{mesh_cut_valid} = 0; wxTheApp->CallAfter(sub { $self->_update; }); } }, label_width => 120, ); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'z', type => 'slider', label => 'Z', default => $self->{cut_options}{z}, min => 0, max => $self->{model_object}->bounding_box->size->z, full_width => 1, )); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Keep', ); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'keep_upper', type => 'bool', label => 'Upper part', default => $self->{cut_options}{keep_upper}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'keep_lower', type => 'bool', label => 'Lower part', default => $self->{cut_options}{keep_lower}, )); $optgroup->append_line($line); } $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'rotate_lower', label => 'Rotate lower part upwards', type => 'bool', tooltip => 'If enabled, the lower part will be rotated by 180° so that the flat cut surface lies on the print bed.', default => $self->{cut_options}{rotate_lower}, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'preview', label => 'Show preview', type => 'bool', tooltip => 'If enabled, object will be cut in real time.', default => $self->{cut_options}{preview}, )); { my $cut_button_sizer = Wx::BoxSizer->new(wxVERTICAL); $self->{btn_cut} = Wx::Button->new($self, -1, "Perform cut", wxDefaultPosition, wxDefaultSize); $cut_button_sizer->Add($self->{btn_cut}, 0, wxALIGN_RIGHT | wxALL, 10); $optgroup->append_line(Slic3r::GUI::OptionsGroup::Line->new( sizer => $cut_button_sizer, )); } # left pane with tree my $left_sizer = Wx::BoxSizer->new(wxVERTICAL); $left_sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); # right pane with preview canvas my $canvas; if ($Slic3r::GUI::have_OpenGL) { $canvas = $self->{canvas} = Slic3r::GUI::3DScene->new($self); $canvas->load_object($self->{model_object}, undef, [0]); $canvas->set_auto_bed_shape; $canvas->SetSize([500,500]); $canvas->SetMinSize($canvas->GetSize); $canvas->zoom_to_volumes; } $self->{sizer} = Wx::BoxSizer->new(wxHORIZONTAL); $self->{sizer}->Add($left_sizer, 0, wxEXPAND | wxTOP | wxBOTTOM, 10); $self->{sizer}->Add($canvas, 1, wxEXPAND | wxALL, 0) if $canvas; $self->SetSizer($self->{sizer}); $self->SetMinSize($self->GetSize); $self->{sizer}->SetSizeHints($self); EVT_BUTTON($self, $self->{btn_cut}, sub { # Recalculate the cut if the preview was not active. $self->_perform_cut() unless $self->{mesh_cut_valid}; # Adjust position / orientation of the split object halves. if ($self->{new_model_objects}{lower}) { if ($self->{cut_options}{rotate_lower}) { $self->{new_model_objects}{lower}->rotate(PI, X); $self->{new_model_objects}{lower}->center_around_origin; # align to Z = 0 } } if ($self->{new_model_objects}{upper}) { $self->{new_model_objects}{upper}->center_around_origin; # align to Z = 0 } # Note that the window was already closed, so a pending update will not be executed. $self->{already_closed} = 1; $self->EndModal(wxID_OK); $self->Destroy(); }); EVT_CLOSE($self, sub { # Note that the window was already closed, so a pending update will not be executed. $self->{already_closed} = 1; $self->EndModal(wxID_CANCEL); $self->Destroy(); }); $self->_update; return $self; } # scale Z down to original size since we're using the transformed mesh for 3D preview # and cut dialog but ModelObject::cut() needs Z without any instance transformation sub _mesh_slice_z_pos { my ($self) = @_; return $self->{cut_options}{z} / $self->{model_object}->instances->[0]->scaling_factor; } # Only perform live preview if just a single part of the object shall survive. sub _life_preview_active { my ($self) = @_; return $self->{cut_options}{preview} && ($self->{cut_options}{keep_upper} != $self->{cut_options}{keep_lower}); } # Slice the mesh, keep the top / bottom part. sub _perform_cut { my ($self) = @_; # Early exit. If the cut is valid, don't recalculate it. return if $self->{mesh_cut_valid}; my $z = $self->_mesh_slice_z_pos(); my ($new_model) = $self->{model_object}->cut($z); my ($upper_object, $lower_object) = @{$new_model->objects}; $self->{new_model} = $new_model; $self->{new_model_objects} = {}; if ($self->{cut_options}{keep_upper} && $upper_object->volumes_count > 0) { $self->{new_model_objects}{upper} = $upper_object; } if ($self->{cut_options}{keep_lower} && $lower_object->volumes_count > 0) { $self->{new_model_objects}{lower} = $lower_object; } $self->{mesh_cut_valid} = 1; } sub _update { my ($self) = @_; # Don't update if the window was already closed. # We are not sure whether the action planned by wxTheApp->CallAfter() may be triggered after the window is closed. # Probably not, but better be safe than sorry, which is espetially true on multiple platforms. return if $self->{already_closed}; # Only recalculate the cut, if the live cut preview is active. my $life_preview_active = $self->_life_preview_active(); $self->_perform_cut() if $life_preview_active; { # scale Z down to original size since we're using the transformed mesh for 3D preview # and cut dialog but ModelObject::cut() needs Z without any instance transformation my $z = $self->_mesh_slice_z_pos(); # update canvas if ($self->{canvas}) { # get volumes to render my @objects = (); if ($life_preview_active) { push @objects, values %{$self->{new_model_objects}}; } else { push @objects, $self->{model_object}; } # get section contour my @expolygons = (); foreach my $volume (@{$self->{model_object}->volumes}) { next if !$volume->mesh; next if $volume->modifier; my $expp = $volume->mesh->slice([ $z + $volume->mesh->bounding_box->z_min ])->[0]; push @expolygons, @$expp; } foreach my $expolygon (@expolygons) { $self->{model_object}->instances->[0]->transform_polygon($_) for @$expolygon; $expolygon->translate(map Slic3r::Geometry::scale($_), @{ $self->{model_object}->instances->[0]->offset }); } $self->{canvas}->reset_objects; $self->{canvas}->load_object($_, undef, [0]) for @objects; $self->{canvas}->SetCuttingPlane( $self->{cut_options}{z}, [@expolygons], ); $self->{canvas}->Render; } } # update controls { my $z = $self->{cut_options}{z}; my $optgroup = $self->{optgroup}; $optgroup->get_field('keep_upper')->toggle(my $have_upper = abs($z - $optgroup->get_option('z')->max) > 0.1); $optgroup->get_field('keep_lower')->toggle(my $have_lower = $z > 0.1); $optgroup->get_field('rotate_lower')->toggle($z > 0 && $self->{cut_options}{keep_lower}); # Disabled live preview by default as it is not stable and/or the calculation takes too long for interactive usage. # $optgroup->get_field('preview')->toggle($self->{cut_options}{keep_upper} != $self->{cut_options}{keep_lower}); # update cut button if (($self->{cut_options}{keep_upper} && $have_upper) || ($self->{cut_options}{keep_lower} && $have_lower)) { $self->{btn_cut}->Enable; } else { $self->{btn_cut}->Disable; } } } sub NewModelObjects { my ($self) = @_; return values %{ $self->{new_model_objects} }; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/ObjectPartsPanel.pm000066400000000000000000000267671301441720000240360ustar00rootroot00000000000000# Configuration of mesh modifiers and their parameters. # This panel is inserted into ObjectSettingsDialog. package Slic3r::GUI::Plater::ObjectPartsPanel; use strict; use warnings; use utf8; use File::Basename qw(basename); use Wx qw(:misc :sizer :treectrl :button wxTAB_TRAVERSAL wxSUNKEN_BORDER wxBITMAP_TYPE_PNG wxTheApp); use Wx::Event qw(EVT_BUTTON EVT_TREE_ITEM_COLLAPSING EVT_TREE_SEL_CHANGED); use base 'Wx::Panel'; use constant ICON_OBJECT => 0; use constant ICON_SOLIDMESH => 1; use constant ICON_MODIFIERMESH => 2; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL); my $object = $self->{model_object} = $params{model_object}; # create TreeCtrl my $tree = $self->{tree} = Wx::TreeCtrl->new($self, -1, wxDefaultPosition, [300, 100], wxTR_NO_BUTTONS | wxSUNKEN_BORDER | wxTR_HAS_VARIABLE_ROW_HEIGHT | wxTR_SINGLE | wxTR_NO_BUTTONS); { $self->{tree_icons} = Wx::ImageList->new(16, 16, 1); $tree->AssignImageList($self->{tree_icons}); $self->{tree_icons}->Add(Wx::Bitmap->new($Slic3r::var->("brick.png"), wxBITMAP_TYPE_PNG)); # ICON_OBJECT $self->{tree_icons}->Add(Wx::Bitmap->new($Slic3r::var->("package.png"), wxBITMAP_TYPE_PNG)); # ICON_SOLIDMESH $self->{tree_icons}->Add(Wx::Bitmap->new($Slic3r::var->("plugin.png"), wxBITMAP_TYPE_PNG)); # ICON_MODIFIERMESH my $rootId = $tree->AddRoot("Object", ICON_OBJECT); $tree->SetPlData($rootId, { type => 'object' }); } # buttons $self->{btn_load_part} = Wx::Button->new($self, -1, "Load part…", wxDefaultPosition, wxDefaultSize, wxBU_LEFT); $self->{btn_load_modifier} = Wx::Button->new($self, -1, "Load modifier…", wxDefaultPosition, wxDefaultSize, wxBU_LEFT); $self->{btn_delete} = Wx::Button->new($self, -1, "Delete part", wxDefaultPosition, wxDefaultSize, wxBU_LEFT); if ($Slic3r::GUI::have_button_icons) { $self->{btn_load_part}->SetBitmap(Wx::Bitmap->new($Slic3r::var->("brick_add.png"), wxBITMAP_TYPE_PNG)); $self->{btn_load_modifier}->SetBitmap(Wx::Bitmap->new($Slic3r::var->("brick_add.png"), wxBITMAP_TYPE_PNG)); $self->{btn_delete}->SetBitmap(Wx::Bitmap->new($Slic3r::var->("brick_delete.png"), wxBITMAP_TYPE_PNG)); } # buttons sizer my $buttons_sizer = Wx::BoxSizer->new(wxHORIZONTAL); $buttons_sizer->Add($self->{btn_load_part}, 0); $buttons_sizer->Add($self->{btn_load_modifier}, 0); $buttons_sizer->Add($self->{btn_delete}, 0); $self->{btn_load_part}->SetFont($Slic3r::GUI::small_font); $self->{btn_load_modifier}->SetFont($Slic3r::GUI::small_font); $self->{btn_delete}->SetFont($Slic3r::GUI::small_font); # part settings panel $self->{settings_panel} = Slic3r::GUI::Plater::OverrideSettingsPanel->new($self, on_change => sub { $self->{part_settings_changed} = 1; }); my $settings_sizer = Wx::StaticBoxSizer->new($self->{staticbox} = Wx::StaticBox->new($self, -1, "Part Settings"), wxVERTICAL); $settings_sizer->Add($self->{settings_panel}, 1, wxEXPAND | wxALL, 0); # left pane with tree my $left_sizer = Wx::BoxSizer->new(wxVERTICAL); $left_sizer->Add($tree, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 10); $left_sizer->Add($buttons_sizer, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 10); $left_sizer->Add($settings_sizer, 1, wxEXPAND | wxALL, 0); # right pane with preview canvas my $canvas; if ($Slic3r::GUI::have_OpenGL) { $canvas = $self->{canvas} = Slic3r::GUI::3DScene->new($self); $canvas->enable_picking(1); $canvas->select_by('volume'); $canvas->on_select(sub { my ($volume_idx) = @_; # convert scene volume to model object volume $self->reload_tree($canvas->volume_idx($volume_idx)); }); $canvas->load_object($self->{model_object}, undef, [0]); $canvas->set_auto_bed_shape; $canvas->SetSize([500,500]); $canvas->zoom_to_volumes; } $self->{sizer} = Wx::BoxSizer->new(wxHORIZONTAL); $self->{sizer}->Add($left_sizer, 0, wxEXPAND | wxALL, 0); $self->{sizer}->Add($canvas, 1, wxEXPAND | wxALL, 0) if $canvas; $self->SetSizer($self->{sizer}); $self->{sizer}->SetSizeHints($self); # attach events EVT_TREE_ITEM_COLLAPSING($self, $tree, sub { my ($self, $event) = @_; $event->Veto; }); EVT_TREE_SEL_CHANGED($self, $tree, sub { my ($self, $event) = @_; return if $self->{disable_tree_sel_changed_event}; $self->selection_changed; }); EVT_BUTTON($self, $self->{btn_load_part}, sub { $self->on_btn_load(0) }); EVT_BUTTON($self, $self->{btn_load_modifier}, sub { $self->on_btn_load(1) }); EVT_BUTTON($self, $self->{btn_delete}, \&on_btn_delete); $self->reload_tree; return $self; } sub reload_tree { my ($self, $selected_volume_idx) = @_; $selected_volume_idx //= -1; my $object = $self->{model_object}; my $tree = $self->{tree}; my $rootId = $tree->GetRootItem; # despite wxWidgets states that DeleteChildren "will not generate any events unlike Delete() method", # the MSW implementation of DeleteChildren actually calls Delete() for each item, so # EVT_TREE_SEL_CHANGED is being called, with bad effects (the event handler is called; this # subroutine is never continued; an invisible EndModal is called on the dialog causing Plater # to continue its logic and rescheduling the background process etc. GH #2774) $self->{disable_tree_sel_changed_event} = 1; $tree->DeleteChildren($rootId); $self->{disable_tree_sel_changed_event} = 0; my $selectedId = $rootId; foreach my $volume_id (0..$#{$object->volumes}) { my $volume = $object->volumes->[$volume_id]; my $icon = $volume->modifier ? ICON_MODIFIERMESH : ICON_SOLIDMESH; my $itemId = $tree->AppendItem($rootId, $volume->name || $volume_id, $icon); if ($volume_id == $selected_volume_idx) { $selectedId = $itemId; } $tree->SetPlData($itemId, { type => 'volume', volume_id => $volume_id, }); } $tree->ExpandAll; Slic3r::GUI->CallAfter(sub { $self->{tree}->SelectItem($selectedId); # SelectItem() should trigger EVT_TREE_SEL_CHANGED as per wxWidgets docs, # but in fact it doesn't if the given item is already selected (this happens # on first load) $self->selection_changed; }); } sub get_selection { my ($self) = @_; my $nodeId = $self->{tree}->GetSelection; if ($nodeId->IsOk) { return $self->{tree}->GetPlData($nodeId); } return undef; } sub selection_changed { my ($self) = @_; # deselect all meshes if ($self->{canvas}) { $_->selected(0) for @{$self->{canvas}->volumes}; } # disable things as if nothing is selected $self->{btn_delete}->Disable; $self->{settings_panel}->disable; $self->{settings_panel}->set_config(undef); if (my $itemData = $self->get_selection) { my ($config, @opt_keys); if ($itemData->{type} eq 'volume') { # select volume in 3D preview if ($self->{canvas}) { $self->{canvas}->volumes->[ $itemData->{volume_id} ]{selected} = 1; } $self->{btn_delete}->Enable; # attach volume config to settings panel my $volume = $self->{model_object}->volumes->[ $itemData->{volume_id} ]; $config = $volume->config; $self->{staticbox}->SetLabel('Part Settings'); # get default values @opt_keys = @{Slic3r::Config::PrintRegion->new->get_keys}; } elsif ($itemData->{type} eq 'object') { # select nothing in 3D preview # attach object config to settings panel $self->{staticbox}->SetLabel('Object Settings'); @opt_keys = (map @{$_->get_keys}, Slic3r::Config::PrintObject->new, Slic3r::Config::PrintRegion->new); $config = $self->{model_object}->config; } # get default values my $default_config = Slic3r::Config->new_from_defaults(@opt_keys); # append default extruder push @opt_keys, 'extruder'; $default_config->set('extruder', 0); $config->set_ifndef('extruder', 0); $self->{settings_panel}->set_default_config($default_config); $self->{settings_panel}->set_config($config); $self->{settings_panel}->set_opt_keys(\@opt_keys); $self->{settings_panel}->set_fixed_options([qw(extruder)]); $self->{settings_panel}->enable; } $self->{canvas}->Render if $self->{canvas}; } sub on_btn_load { my ($self, $is_modifier) = @_; my @input_files = wxTheApp->open_model($self); foreach my $input_file (@input_files) { my $model = eval { Slic3r::Model->read_from_file($input_file) }; if ($@) { Slic3r::GUI::show_error($self, $@); next; } foreach my $object (@{$model->objects}) { foreach my $volume (@{$object->volumes}) { my $new_volume = $self->{model_object}->add_volume($volume); $new_volume->set_modifier($is_modifier); $new_volume->set_name(basename($input_file)); # apply the same translation we applied to the object $new_volume->mesh->translate(@{$self->{model_object}->origin_translation}); # set a default extruder value, since user can't add it manually $new_volume->config->set_ifndef('extruder', 0); $self->{parts_changed} = 1; } } } $self->_parts_changed; } sub on_btn_delete { my ($self) = @_; my $itemData = $self->get_selection; if ($itemData && $itemData->{type} eq 'volume') { my $volume = $self->{model_object}->volumes->[$itemData->{volume_id}]; # if user is deleting the last solid part, throw error if (!$volume->modifier && scalar(grep !$_->modifier, @{$self->{model_object}->volumes}) == 1) { Slic3r::GUI::show_error($self, "You can't delete the last solid part from this object."); return; } $self->{model_object}->delete_volume($itemData->{volume_id}); $self->{parts_changed} = 1; } $self->_parts_changed; } sub _parts_changed { my ($self) = @_; $self->reload_tree; if ($self->{canvas}) { $self->{canvas}->reset_objects; $self->{canvas}->load_object($self->{model_object}); $self->{canvas}->zoom_to_volumes; $self->{canvas}->Render; } } sub CanClose { my $self = shift; return 1; # skip validation for now # validate options before allowing user to dismiss the dialog # the validate method only works on full configs so we have # to merge our settings with the default ones my $config = Slic3r::Config->merge($self->GetParent->GetParent->GetParent->GetParent->GetParent->config, $self->model_object->config); eval { $config->validate; }; return 0 if Slic3r::GUI::catch_error($self); return 1; } sub PartsChanged { my ($self) = @_; return $self->{parts_changed}; } sub PartSettingsChanged { my ($self) = @_; return $self->{part_settings_changed}; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/ObjectSettingsDialog.pm000066400000000000000000000136261301441720000246730ustar00rootroot00000000000000# This dialog opens up when double clicked on an object line in the list at the right side of the platter. # One may load additional STLs and additional modifier STLs, # one may change the properties of the print per each modifier mesh or a Z-span. package Slic3r::GUI::Plater::ObjectSettingsDialog; use strict; use warnings; use utf8; use Wx qw(:dialog :id :misc :sizer :systemsettings :notebook wxTAB_TRAVERSAL); use Wx::Event qw(EVT_BUTTON); use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, "Settings for " . $params{object}->name, wxDefaultPosition, [700,500], wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); $self->{$_} = $params{$_} for keys %params; $self->{tabpanel} = Wx::Notebook->new($self, -1, wxDefaultPosition, wxDefaultSize, wxNB_TOP | wxTAB_TRAVERSAL); $self->{tabpanel}->AddPage($self->{parts} = Slic3r::GUI::Plater::ObjectPartsPanel->new($self->{tabpanel}, model_object => $params{model_object}), "Parts"); $self->{tabpanel}->AddPage($self->{layers} = Slic3r::GUI::Plater::ObjectDialog::LayersTab->new($self->{tabpanel}), "Layers"); my $buttons = $self->CreateStdDialogButtonSizer(wxOK); EVT_BUTTON($self, wxID_OK, sub { # validate user input return if !$self->{parts}->CanClose; return if !$self->{layers}->CanClose; # notify tabs $self->{layers}->Closing; $self->EndModal(wxID_OK); $self->Destroy; }); my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($self->{tabpanel}, 1, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 10); $sizer->Add($buttons, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); $self->SetSizer($sizer); $self->SetMinSize($self->GetSize); return $self; } sub PartsChanged { my ($self) = @_; return $self->{parts}->PartsChanged; } sub PartSettingsChanged { my ($self) = @_; return $self->{parts}->PartSettingsChanged || $self->{layers}->LayersChanged; } package Slic3r::GUI::Plater::ObjectDialog::BaseTab; use base 'Wx::Panel'; sub model_object { my ($self) = @_; return $self->GetParent->GetParent->{model_object}; } package Slic3r::GUI::Plater::ObjectDialog::LayersTab; use Wx qw(:dialog :id :misc :sizer :systemsettings); use Wx::Grid; use Wx::Event qw(EVT_GRID_CELL_CHANGED); use base 'Slic3r::GUI::Plater::ObjectDialog::BaseTab'; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize); my $sizer = Wx::BoxSizer->new(wxVERTICAL); { my $label = Wx::StaticText->new($self, -1, "You can use this section to override the default layer height for parts of this object. Set layer height to zero to skip portions of the input file.", wxDefaultPosition, [-1, 40]); $label->SetFont(Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); $sizer->Add($label, 0, wxEXPAND | wxALL, 10); } my $grid = $self->{grid} = Wx::Grid->new($self, -1, wxDefaultPosition, wxDefaultSize); $sizer->Add($grid, 1, wxEXPAND | wxALL, 10); $grid->CreateGrid(0, 3); $grid->DisableDragRowSize; $grid->HideRowLabels if &Wx::wxVERSION_STRING !~ / 2\.8\./; $grid->SetColLabelValue(0, "Min Z (mm)"); $grid->SetColLabelValue(1, "Max Z (mm)"); $grid->SetColLabelValue(2, "Layer height (mm)"); $grid->SetColSize($_, 135) for 0..2; $grid->SetDefaultCellAlignment(wxALIGN_CENTRE, wxALIGN_CENTRE); # load data foreach my $range (@{ $self->model_object->layer_height_ranges }) { $grid->AppendRows(1); my $i = $grid->GetNumberRows-1; $grid->SetCellValue($i, $_, $range->[$_]) for 0..2; } $grid->AppendRows(1); # append one empty row EVT_GRID_CELL_CHANGED($grid, sub { my ($grid, $event) = @_; # remove any non-numeric character my $value = $grid->GetCellValue($event->GetRow, $event->GetCol); $value =~ s/,/./g; $value =~ s/[^0-9.]//g; $grid->SetCellValue($event->GetRow, $event->GetCol, $value); # if there's no empty row, let's append one for my $i (0 .. $grid->GetNumberRows) { if ($i == $grid->GetNumberRows) { # if we're here then we found no empty row $grid->AppendRows(1); last; } if (!grep $grid->GetCellValue($i, $_), 0..2) { # exit loop if this row is empty last; } } $self->{layers_changed} = 1; }); $self->SetSizer($sizer); $sizer->SetSizeHints($self); return $self; } sub CanClose { my $self = shift; # validate ranges before allowing user to dismiss the dialog foreach my $range ($self->_get_ranges) { my ($min, $max, $height) = @$range; if ($max <= $min) { Slic3r::GUI::show_error($self, "Invalid Z range $min-$max."); return 0; } if ($min < 0 || $max < 0) { Slic3r::GUI::show_error($self, "Invalid Z range $min-$max."); return 0; } if ($height < 0) { Slic3r::GUI::show_error($self, "Invalid layer height $height."); return 0; } # TODO: check for overlapping ranges } return 1; } sub Closing { my $self = shift; # save ranges into the plater object $self->model_object->set_layer_height_ranges([ $self->_get_ranges ]); } sub _get_ranges { my $self = shift; my @ranges = (); for my $i (0 .. $self->{grid}->GetNumberRows-1) { my ($min, $max, $height) = map $self->{grid}->GetCellValue($i, $_), 0..2; next if $min eq '' || $max eq '' || $height eq ''; push @ranges, [ $min, $max, $height ]; } return sort { $a->[0] <=> $b->[0] } @ranges; } sub LayersChanged { my ($self) = @_; return $self->{layers_changed}; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Plater/OverrideSettingsPanel.pm000066400000000000000000000125241301441720000251000ustar00rootroot00000000000000# Included in ObjectSettingsDialog -> ObjectPartsPanel. # Maintains, displays, adds and removes overrides of slicing parameters for an object and its modifier mesh. package Slic3r::GUI::Plater::OverrideSettingsPanel; use strict; use warnings; use utf8; use List::Util qw(first); use Wx qw(:misc :sizer :button wxTAB_TRAVERSAL wxSUNKEN_BORDER wxBITMAP_TYPE_PNG wxTheApp); use Wx::Event qw(EVT_BUTTON EVT_LEFT_DOWN EVT_MENU); use base 'Wx::ScrolledWindow'; use constant ICON_MATERIAL => 0; use constant ICON_SOLIDMESH => 1; use constant ICON_MODIFIERMESH => 2; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL); $self->{default_config} = Slic3r::Config->new; $self->{config} = Slic3r::Config->new; $self->{on_change} = $params{on_change}; $self->{fixed_options} = {}; $self->{sizer} = Wx::BoxSizer->new(wxVERTICAL); $self->{options_sizer} = Wx::BoxSizer->new(wxVERTICAL); $self->{sizer}->Add($self->{options_sizer}, 0, wxEXPAND | wxALL, 0); # option selector { # create the button my $btn = $self->{btn_add} = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("add.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, Wx::wxBORDER_NONE); EVT_LEFT_DOWN($btn, sub { my $menu = Wx::Menu->new; foreach my $opt_key (@{$self->{options}}) { my $id = &Wx::NewId(); $menu->Append($id, $self->{option_labels}{$opt_key}); EVT_MENU($menu, $id, sub { $self->{config}->set($opt_key, $self->{default_config}->get($opt_key)); $self->update_optgroup; $self->{on_change}->() if $self->{on_change}; }); } $self->PopupMenu($menu, $btn->GetPosition); $menu->Destroy; }); my $h_sizer = Wx::BoxSizer->new(wxHORIZONTAL); $h_sizer->Add($btn, 0, wxALL, 0); $self->{sizer}->Add($h_sizer, 0, wxEXPAND | wxBOTTOM, 10); } $self->SetSizer($self->{sizer}); $self->SetScrollbars(0, 1, 0, 1); $self->set_opt_keys($params{opt_keys}) if $params{opt_keys}; $self->update_optgroup; return $self; } sub set_default_config { my ($self, $config) = @_; $self->{default_config} = $config; } sub set_config { my ($self, $config) = @_; $self->{config} = $config; $self->update_optgroup; } sub set_opt_keys { my ($self, $opt_keys) = @_; # sort options by category+label $self->{option_labels} = { map { $_ => sprintf('%s > %s', $Slic3r::Config::Options->{$_}{category}, $Slic3r::Config::Options->{$_}{full_label} // $Slic3r::Config::Options->{$_}{label}) } @$opt_keys }; $self->{options} = [ sort { $self->{option_labels}{$a} cmp $self->{option_labels}{$b} } @$opt_keys ]; } sub set_fixed_options { my ($self, $opt_keys) = @_; $self->{fixed_options} = { map {$_ => 1} @$opt_keys }; $self->update_optgroup; } sub update_optgroup { my $self = shift; $self->{options_sizer}->Clear(1); return if !defined $self->{config}; my %categories = (); foreach my $opt_key (@{$self->{config}->get_keys}) { my $category = $Slic3r::Config::Options->{$opt_key}{category}; $categories{$category} ||= []; push @{$categories{$category}}, $opt_key; } foreach my $category (sort keys %categories) { my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new( parent => $self, title => $category, config => $self->{config}, full_labels => 1, label_font => $Slic3r::GUI::small_font, sidetext_font => $Slic3r::GUI::small_font, label_width => 120, on_change => sub { $self->{on_change}->() if $self->{on_change} }, extra_column => sub { my ($line) = @_; my $opt_key = $line->get_options->[0]->opt_id; # we assume that we have one option per line # disallow deleting fixed options return undef if $self->{fixed_options}{$opt_key}; my $btn = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("delete.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, Wx::wxBORDER_NONE); EVT_BUTTON($self, $btn, sub { $self->{config}->erase($opt_key); $self->{on_change}->() if $self->{on_change}; wxTheApp->CallAfter(sub { $self->update_optgroup }); }); return $btn; }, ); foreach my $opt_key (sort @{$categories{$category}}) { $optgroup->append_single_option_line($opt_key); } $self->{options_sizer}->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM, 0); } $self->GetParent->Layout; # we need this for showing scrollbars } # work around a wxMAC bug causing controls not being disabled when calling Disable() on a Window sub enable { my ($self) = @_; $self->{btn_add}->Enable; $self->Enable; } sub disable { my ($self) = @_; $self->{btn_add}->Disable; $self->Disable; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Preferences.pm000066400000000000000000000112711301441720000216300ustar00rootroot00000000000000# Preferences dialog, opens from Menu: File->Preferences package Slic3r::GUI::Preferences; use Wx qw(:dialog :id :misc :sizer :systemsettings wxTheApp); use Wx::Event qw(EVT_BUTTON EVT_TEXT_ENTER); use base 'Wx::Dialog'; sub new { my ($class, $parent) = @_; my $self = $class->SUPER::new($parent, -1, "Preferences", wxDefaultPosition, wxDefaultSize); $self->{values} = {}; my $optgroup; $optgroup = Slic3r::GUI::OptionsGroup->new( parent => $self, title => 'General', on_change => sub { my ($opt_id) = @_; $self->{values}{$opt_id} = $optgroup->get_value($opt_id); }, label_width => 200, ); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'mode', type => 'select', label => 'Mode', tooltip => 'Choose between a simpler, basic mode and an expert mode with more options and more complicated interface.', labels => ['Simple','Expert'], values => ['simple','expert'], default => $Slic3r::GUI::Settings->{_}{mode}, width => 100, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'version_check', type => 'bool', label => 'Check for updates', tooltip => 'If this is enabled, Slic3r will check for updates daily and display a reminder if a newer version is available.', default => $Slic3r::GUI::Settings->{_}{version_check} // 1, readonly => !wxTheApp->have_version_check, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'remember_output_path', type => 'bool', label => 'Remember output directory', tooltip => 'If this is enabled, Slic3r will prompt the last output directory instead of the one containing the input files.', default => $Slic3r::GUI::Settings->{_}{remember_output_path}, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'autocenter', type => 'bool', label => 'Auto-center parts', tooltip => 'If this is enabled, Slic3r will auto-center objects around the print bed center.', default => $Slic3r::GUI::Settings->{_}{autocenter}, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'background_processing', type => 'bool', label => 'Background processing', tooltip => 'If this is enabled, Slic3r will pre-process objects as soon as they\'re loaded in order to save time when exporting G-code.', default => $Slic3r::GUI::Settings->{_}{background_processing}, readonly => !$Slic3r::have_threads, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'no_controller', type => 'bool', label => 'Disable USB/serial connection', tooltip => 'Disable communication with the printer over a serial / USB cable. This simplifies the user interface in case the printer is never attached to the computer.', default => $Slic3r::GUI::Settings->{_}{no_controller}, )); $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'no_defaults', type => 'bool', label => 'Suppress "- default -" presets', tooltip => 'Suppress "- default -" presets in the Print / Filament / Printer selections once there are any other valid presets available.', default => $Slic3r::GUI::Settings->{_}{no_defaults}, )); my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); my $buttons = $self->CreateStdDialogButtonSizer(wxOK | wxCANCEL); EVT_BUTTON($self, wxID_OK, sub { $self->_accept }); $sizer->Add($buttons, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); $self->SetSizer($sizer); $sizer->SetSizeHints($self); return $self; } sub _accept { my $self = shift; if ($self->{values}{mode} || defined($self->{values}{no_controller})) { Slic3r::GUI::warning_catcher($self)->("You need to restart Slic3r to make the changes effective."); } $Slic3r::GUI::Settings->{_}{$_} = $self->{values}{$_} for keys %{$self->{values}}; wxTheApp->save_settings; $self->EndModal(wxID_OK); $self->Close; # needed on Linux # Nothify the UI to update itself from the ini file. wxTheApp->update_ui_from_settings; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/ProgressStatusBar.pm000066400000000000000000000061071301441720000230260ustar00rootroot00000000000000# Status bar at the bottom of the main screen. package Slic3r::GUI::ProgressStatusBar; use strict; use warnings; use Wx qw(:gauge :misc); use base 'Wx::StatusBar'; sub new { my $class = shift; my $self = $class->SUPER::new(@_); $self->{busy} = 0; $self->{timer} = Wx::Timer->new($self); $self->{prog} = Wx::Gauge->new($self, wxGA_HORIZONTAL, 100, wxDefaultPosition, wxDefaultSize); $self->{prog}->Hide; $self->{cancelbutton} = Wx::Button->new($self, -1, "Cancel", wxDefaultPosition, wxDefaultSize); $self->{cancelbutton}->Hide; $self->SetFieldsCount(3); $self->SetStatusWidths(-1, 150, 155); Wx::Event::EVT_TIMER($self, \&OnTimer, $self->{timer}); Wx::Event::EVT_SIZE($self, \&OnSize); Wx::Event::EVT_BUTTON($self, $self->{cancelbutton}, sub { $self->{cancel_cb}->(); $self->{cancelbutton}->Hide; }); return $self; } sub DESTROY { my $self = shift; $self->{timer}->Stop if $self->{timer} && $self->{timer}->IsRunning; } sub OnSize { my ($self, $event) = @_; my %fields = ( # 0 is reserved for status text 1 => $self->{cancelbutton}, 2 => $self->{prog}, ); foreach (keys %fields) { my $rect = $self->GetFieldRect($_); my $offset = &Wx::wxGTK ? 1 : 0; # add a cosmetic 1 pixel offset on wxGTK my $pos = [$rect->GetX + $offset, $rect->GetY + $offset]; $fields{$_}->Move($pos); $fields{$_}->SetSize($rect->GetWidth - $offset, $rect->GetHeight); } $event->Skip; } sub OnTimer { my ($self, $event) = @_; if ($self->{prog}->IsShown) { $self->{timer}->Stop; } $self->{prog}->Pulse if $self->{_busy}; } sub SetCancelCallback { my $self = shift; my ($cb) = @_; $self->{cancel_cb} = $cb; $cb ? $self->{cancelbutton}->Show : $self->{cancelbutton}->Hide; } sub Run { my $self = shift; my $rate = shift || 100; if (!$self->{timer}->IsRunning) { $self->{timer}->Start($rate); } } sub GetProgress { my $self = shift; return $self->{prog}->GetValue; } sub SetProgress { my $self = shift; my ($val) = @_; if (!$self->{prog}->IsShown) { $self->ShowProgress(1); } if ($val == $self->{prog}->GetRange) { $self->{prog}->SetValue(0); $self->ShowProgress(0); } else { $self->{prog}->SetValue($val); } } sub SetRange { my $self = shift; my ($val) = @_; if ($val != $self->{prog}->GetRange) { $self->{prog}->SetRange($val); } } sub ShowProgress { my $self = shift; my ($show) = @_; $self->{prog}->Show($show); $self->{prog}->Pulse; } sub StartBusy { my $self = shift; my $rate = shift || 100; $self->{_busy} = 1; $self->ShowProgress(1); if (!$self->{timer}->IsRunning) { $self->{timer}->Start($rate); } } sub StopBusy { my $self = shift; $self->{timer}->Stop; $self->ShowProgress(0); $self->{prog}->SetValue(0); $self->{_busy} = 0; } sub IsBusy { my $self = shift; return $self->{_busy}; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Projector.pm000066400000000000000000000762711301441720000213510ustar00rootroot00000000000000# DLP Projector screen for the SLA (stereolitography) print process package Slic3r::GUI::Projector; use strict; use warnings; use Wx qw(:dialog :id :misc :sizer :systemsettings :bitmap :button :icon wxTheApp); use Wx::Event qw(EVT_BUTTON EVT_TEXT_ENTER EVT_SPINCTRL EVT_SLIDER); use base qw(Wx::Dialog Class::Accessor); use utf8; __PACKAGE__->mk_accessors(qw(config config2 screen controller _optgroups)); sub new { my ($class, $parent) = @_; my $self = $class->SUPER::new($parent, -1, "Projector for DLP", wxDefaultPosition, wxDefaultSize); $self->config2({ display => 0, show_bed => 1, invert_y => 0, zoom => 100, exposure_time => 2, bottom_exposure_time => 7, settle_time => 1.5, bottom_layers => 3, z_lift => 5, z_lift_speed => 8, offset => [0,0], }); my $ini = eval { Slic3r::Config->read_ini("$Slic3r::GUI::datadir/DLP.ini") }; if ($ini) { foreach my $opt_id (keys %{$ini->{_}}) { my $value = $ini->{_}{$opt_id}; if ($opt_id eq 'offset') { $value = [ split /,/, $value ]; } $self->config2->{$opt_id} = $value; } } my $sizer = Wx::BoxSizer->new(wxVERTICAL); $self->config(Slic3r::Config->new_from_defaults( qw(serial_port serial_speed bed_shape start_gcode end_gcode z_offset) )); $self->config->apply(wxTheApp->{mainframe}->config); my @optgroups = (); { push @optgroups, my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new( parent => $self, title => 'USB/Serial connection', config => $self->config, label_width => 200, ); $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Serial port', ); my $serial_port = $optgroup->get_option('serial_port'); $serial_port->side_widget(sub { my ($parent) = @_; my $btn = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("arrow_rotate_clockwise.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, &Wx::wxBORDER_NONE); $btn->SetToolTipString("Rescan serial ports") if $btn->can('SetToolTipString'); EVT_BUTTON($self, $btn, sub { $optgroup->get_field('serial_port')->set_values([ wxTheApp->scan_serial_ports ]); }); return $btn; }); my $serial_test = sub { my ($parent) = @_; my $btn = $self->{serial_test_btn} = Wx::Button->new($parent, -1, "Test", wxDefaultPosition, wxDefaultSize, wxBU_LEFT | wxBU_EXACTFIT); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("wrench.png"), wxBITMAP_TYPE_PNG)); } EVT_BUTTON($self, $btn, sub { my $sender = Slic3r::GCode::Sender->new; my $res = $sender->connect( $self->{config}->serial_port, $self->{config}->serial_speed, ); if ($res && $sender->wait_connected) { Slic3r::GUI::show_info($self, "Connection to printer works correctly.", "Success!"); } else { Slic3r::GUI::show_error($self, "Connection failed."); } }); return $btn; }; $line->append_option($serial_port); $line->append_option($optgroup->get_option('serial_speed')); $line->append_widget($serial_test); $optgroup->append_line($line); } } { push @optgroups, my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new( parent => $self, title => 'G-code', config => $self->config, label_width => 200, ); $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); { my $option = $optgroup->get_option('start_gcode'); $option->height(50); $option->full_width(1); $optgroup->append_single_option_line($option); } { my $option = $optgroup->get_option('end_gcode'); $option->height(50); $option->full_width(1); $optgroup->append_single_option_line($option); } } my $on_change = sub { my ($opt_id, $value) = @_; $self->config2->{$opt_id} = $value; $self->screen->reposition; $self->show_print_time; my $serialized = {}; foreach my $opt_id (keys %{$self->config2}) { my $value = $self->config2->{$opt_id}; if (ref($value) eq 'ARRAY') { $value = join ',', @$value; } $serialized->{$opt_id} = $value; } Slic3r::Config->write_ini( "$Slic3r::GUI::datadir/DLP.ini", { _ => $serialized }); }; { push @optgroups, my $optgroup = Slic3r::GUI::OptionsGroup->new( parent => $self, title => 'Projection', on_change => $on_change, label_width => 200, ); $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Display', ); my @displays = 0 .. (Wx::Display::GetCount()-1); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'display', type => 'select', label => 'Display', tooltip => '', labels => [@displays], values => [@displays], default => $self->config2->{display}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'zoom', type => 'percent', label => 'Zoom %', tooltip => '', default => $self->config2->{zoom}, min => 0.1, max => 100, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'offset', type => 'point', label => 'Offset', tooltip => '', default => $self->config2->{offset}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'invert_y', type => 'bool', label => 'Invert Y', tooltip => '', default => $self->config2->{invert_y}, )); $optgroup->append_line($line); } $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'show_bed', type => 'bool', label => 'Show bed', tooltip => '', default => $self->config2->{show_bed}, )); } { push @optgroups, my $optgroup = Slic3r::GUI::OptionsGroup->new( parent => $self, title => 'Print', on_change => $on_change, label_width => 200, ); $sizer->Add($optgroup->sizer, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Time (seconds)', ); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'bottom_exposure_time', type => 'f', label => 'Bottom exposure', tooltip => '', default => $self->config2->{bottom_exposure_time}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'exposure_time', type => 'f', label => 'Exposure', tooltip => '', default => $self->config2->{exposure_time}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'settle_time', type => 'f', label => 'Settle', tooltip => '', default => $self->config2->{settle_time}, )); $optgroup->append_line($line); } $optgroup->append_single_option_line(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'bottom_layers', type => 'i', label => 'Bottom layers', tooltip => '', default => $self->config2->{bottom_layers}, )); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Z Lift', ); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'z_lift', type => 'f', label => 'Distance', sidetext => 'mm', tooltip => '', default => $self->config2->{z_lift}, )); $line->append_option(Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'z_lift_speed', type => 'f', label => 'Speed', sidetext => 'mm/s', tooltip => '', default => $self->config2->{z_lift_speed}, )); $optgroup->append_line($line); } } $self->_optgroups([@optgroups]); { my $sizer1 = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($sizer1, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); { my $btn = $self->{btn_manual_control} = Wx::Button->new($self, -1, 'Manual Control', wxDefaultPosition, wxDefaultSize); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG)); } $sizer1->Add($btn, 0); EVT_BUTTON($self, $btn, sub { my $sender = Slic3r::GCode::Sender->new; my $res = $sender->connect( $self->config->serial_port, $self->config->serial_speed, ); if (!$res || !$sender->wait_connected) { Slic3r::GUI::show_error(undef, "Connection failed. Check serial port and speed."); return; } my $dlg = Slic3r::GUI::Controller::ManualControlDialog->new ($self, $self->config, $sender); $dlg->ShowModal; $sender->disconnect; }); } { my $btn = $self->{btn_print} = Wx::Button->new($self, -1, 'Print', wxDefaultPosition, wxDefaultSize); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_play.png"), wxBITMAP_TYPE_PNG)); } $sizer1->Add($btn, 0); EVT_BUTTON($self, $btn, sub { $self->controller->start_print; $self->_update_buttons; $self->_set_status(''); }); } { my $btn = $self->{btn_stop} = Wx::Button->new($self, -1, 'Stop/Black', wxDefaultPosition, wxDefaultSize); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("control_stop.png"), wxBITMAP_TYPE_PNG)); } $sizer1->Add($btn, 0); EVT_BUTTON($self, $btn, sub { $self->controller->stop_print; $self->_update_buttons; $self->_set_status(''); }); } { { my $text = Wx::StaticText->new($self, -1, "Layer:", wxDefaultPosition, wxDefaultSize); $text->SetFont($Slic3r::GUI::small_font); $sizer1->Add($text, 0, wxEXPAND | wxLEFT, 10); } { my $spin = $self->{layers_spinctrl} = Wx::SpinCtrl->new($self, -1, 0, wxDefaultPosition, [60,-1], 0, 0, 300, 0); $sizer1->Add($spin, 0); EVT_SPINCTRL($self, $spin, sub { my $value = $spin->GetValue; $self->{layers_slider}->SetValue($value); $self->controller->project_layer($value); $self->_update_buttons; }); } { my $slider = $self->{layers_slider} = Wx::Slider->new( $self, -1, 0, # default 0, # min 300, # max wxDefaultPosition, wxDefaultSize, ); $sizer1->Add($slider, 1); EVT_SLIDER($self, $slider, sub { my $value = $slider->GetValue; $self->{layers_spinctrl}->SetValue($value); $self->controller->project_layer($value); $self->_update_buttons; }); } } my $sizer2 = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($sizer2, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); { $self->{status_text} = Wx::StaticText->new($self, -1, "", wxDefaultPosition, wxDefaultSize); $self->{status_text}->SetFont($Slic3r::GUI::small_font); $sizer2->Add($self->{status_text}, 1 | wxEXPAND); } } { my $buttons = $self->CreateStdDialogButtonSizer(wxOK); EVT_BUTTON($self, wxID_CLOSE, sub { $self->_close; }); $sizer->Add($buttons, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); } $self->SetSizer($sizer); $sizer->SetSizeHints($self); # reuse existing screen if any if ($Slic3r::GUI::DLP_projection_screen) { $self->screen($Slic3r::GUI::DLP_projection_screen); $self->screen->config($self->config); $self->screen->config2($self->config2); } else { $self->screen(Slic3r::GUI::Projector::Screen->new($parent, $self->config, $self->config2)); $Slic3r::GUI::DLP_projection_screen = $self->screen; } $self->screen->reposition; $self->screen->Show; wxTheApp->{mainframe}->Hide; # initialize controller $self->controller(Slic3r::GUI::Projector::Controller->new( config => $self->config, config2 => $self->config2, screen => $self->screen, on_project_layer => sub { my ($layer_num) = @_; $self->{layers_spinctrl}->SetValue($layer_num); $self->{layers_slider}->SetValue($layer_num); my $duration = $self->controller->remaining_print_time; $self->_set_status(sprintf "Printing layer %d/%d (z = %.2f); %d minutes and %d seconds left", $layer_num, $self->controller->layer_count, $self->controller->current_layer_height, int($duration/60), ($duration - int($duration/60)*60)); # % truncates to integer }, on_print_completed => sub { $self->_update_buttons; $self->_set_status(''); Wx::Bell(); }, )); { my $max = $self->controller->layer_count-1; $self->{layers_spinctrl}->SetRange(0, $max); $self->{layers_slider}->SetRange(0, $max); } $self->_update_buttons; $self->show_print_time; return $self; } sub _update_buttons { my ($self) = @_; my $is_printing = $self->controller->is_printing; my $is_projecting = $self->controller->is_projecting; $self->{btn_manual_control}->Show(!$is_printing); $self->{btn_print}->Show(!$is_printing && !$is_projecting); $self->{btn_stop}->Show($is_printing || $is_projecting); $self->{layers_spinctrl}->Enable(!$is_printing); $self->{layers_slider}->Enable(!$is_printing); if ($is_printing) { $_->disable for @{$self->_optgroups}; } else { $_->enable for @{$self->_optgroups}; } $self->Layout; } sub _set_status { my ($self, $status) = @_; $self->{status_text}->SetLabel($status // ''); $self->{status_text}->Wrap($self->{status_text}->GetSize->GetWidth); $self->{status_text}->Refresh; $self->Layout; } sub show_print_time { my ($self) = @_; my $duration = $self->controller->print_time; $self->_set_status(sprintf "Estimated print time: %d minutes and %d seconds", int($duration/60), ($duration - int($duration/60)*60)); # % truncates to integer } sub _close { my $self = shift; # if projection screen is not on the same display as our dialog, # ask the user whether they want to keep it open my $keep_screen = 0; my $display_area = Wx::Display->new($self->config2->{display})->GetGeometry; if (!$display_area->Contains($self->GetScreenPosition)) { my $res = Wx::MessageDialog->new($self, "Do you want to keep the black screen open?", 'Black screen', wxYES_NO | wxYES_DEFAULT | wxICON_QUESTION)->ShowModal; $keep_screen = ($res == wxID_YES); } if ($keep_screen) { $self->screen->config(undef); $self->screen->config2(undef); $self->screen->Refresh; } else { $self->screen->Destroy; $self->screen(undef); $Slic3r::GUI::DLP_projection_screen = undef; } wxTheApp->{mainframe}->Show; my $printer_tab = wxTheApp->{mainframe}{options_tabs}{printer}; $printer_tab->load_config($self->config); $self->EndModal(wxID_OK); } package Slic3r::GUI::Projector::Controller; use Moo; use Wx qw(wxTheApp :id :timer); use Wx::Event qw(EVT_TIMER); use Slic3r::Print::State ':steps'; use Time::HiRes qw(gettimeofday tv_interval); has 'config' => (is => 'ro', required => 1); has 'config2' => (is => 'ro', required => 1); has 'screen' => (is => 'ro', required => 1); has 'on_project_layer' => (is => 'rw'); has 'on_print_completed' => (is => 'rw'); has 'sender' => (is => 'rw'); has 'timer' => (is => 'rw'); has 'is_printing' => (is => 'rw', default => sub { 0 }); has '_print' => (is => 'rw'); has '_layers' => (is => 'rw'); has '_heights' => (is => 'rw'); has '_layer_num' => (is => 'rw'); has '_timer_cb' => (is => 'rw'); sub BUILD { my ($self) = @_; Slic3r::GUI::disable_screensaver(); $self->set_print(wxTheApp->{mainframe}->{plater}->{print}); # projection timer my $timer_id = &Wx::NewId(); $self->timer(Wx::Timer->new($self->screen, $timer_id)); EVT_TIMER($self->screen, $timer_id, sub { my $cb = $self->_timer_cb; $self->_timer_cb(undef); $cb->(); }); } sub delay { my ($self, $wait, $cb) = @_; $self->_timer_cb($cb); $self->timer->Start($wait * 1000, wxTIMER_ONE_SHOT); } sub set_print { my ($self, $print) = @_; # make sure layers were sliced { my $progress_dialog; foreach my $object (@{$print->objects}) { next if $object->step_done(STEP_SLICE); $progress_dialog //= Wx::ProgressDialog->new('Slicing…', "Processing layers…", 100, undef, 0); $progress_dialog->Pulse; $object->slice; } $progress_dialog->Destroy if $progress_dialog; } $self->_print($print); # sort layers by Z my %layers = (); foreach my $layer (map { @{$_->layers}, @{$_->support_layers} } @{$print->objects}) { my $height = $layer->print_z; $layers{$height} //= []; push @{$layers{$height}}, $layer; } $self->_layers({ %layers }); $self->_heights([ sort { $a <=> $b } keys %layers ]); } sub layer_count { my ($self) = @_; return scalar @{$self->_heights}; } sub current_layer_height { my ($self) = @_; return $self->_heights->[$self->_layer_num]; } sub start_print { my ($self) = @_; { $self->sender(Slic3r::GCode::Sender->new); my $res = $self->sender->connect( $self->config->serial_port, $self->config->serial_speed, ); if (!$res || !$self->sender->wait_connected) { Slic3r::GUI::show_error(undef, "Connection failed. Check serial port and speed."); return; } Slic3r::debugf "connected to " . $self->config->serial_port . "\n"; # send custom start G-code $self->sender->send($_, 1) for grep !/^;/, split /\n/, $self->config->start_gcode; } $self->is_printing(1); # TODO: block until the G1 command has been performed # we could do this with M400 + M115 but maybe it's not portable $self->delay(5, sub { # start with black Slic3r::debugf "starting black projection\n"; $self->_layer_num(-1); $self->screen->project_layers(undef); $self->delay($self->config2->{settle_time}, sub { $self->project_next_layer; }); }); } sub stop_print { my ($self) = @_; if ($self->sender) { $self->sender->disconnect; } $self->is_printing(0); $self->timer->Stop; $self->_timer_cb(undef); $self->screen->project_layers(undef); } sub print_completed { my ($self) = @_; # send custom end G-code if ($self->sender) { $self->sender->send($_, 1) for grep !/^;/, split /\n/, $self->config->end_gcode; } # call this before the on_print_completed callback otherwise buttons # won't be updated correctly $self->stop_print; $self->on_print_completed->() if $self->is_printing && $self->on_print_completed; } sub is_projecting { my ($self) = @_; return defined $self->screen->layers; } sub project_layer { my ($self, $layer_num) = @_; if (!defined $layer_num || $layer_num >= $self->layer_count) { $self->screen->project_layers(undef); return; } my @layers = @{ $self->_layers->{ $self->_heights->[$layer_num] } }; $self->screen->project_layers([ @layers ]); } sub project_next_layer { my ($self) = @_; $self->_layer_num($self->_layer_num + 1); Slic3r::debugf "projecting layer %d\n", $self->_layer_num; if ($self->_layer_num >= $self->layer_count) { $self->print_completed; return; } $self->on_project_layer->($self->_layer_num) if $self->on_project_layer; if ($self->sender) { my $z = $self->current_layer_height + $self->config->z_offset; my $F = $self->config2->{z_lift_speed} * 60; if ($self->config2->{z_lift} != 0) { $self->sender->send(sprintf("G1 Z%.5f F%d", $z + $self->config2->{z_lift}, $F), 1); } $self->sender->send(sprintf("G1 Z%.5f F%d", $z, $F), 1); } # TODO: we should block until G1 commands have been performed, see note below $self->delay($self->config2->{settle_time}, sub { $self->project_layer($self->_layer_num); # get exposure time my $time = $self->config2->{exposure_time}; if ($self->_layer_num < $self->config2->{bottom_layers}) { $time = $self->config2->{bottom_exposure_time}; } $self->delay($time, sub { $self->screen->project_layers(undef); $self->project_next_layer; }); }); } sub remaining_print_time { my ($self) = @_; my $remaining_layers = @{$self->_heights} - $self->_layer_num; my $remaining_bottom_layers = $self->_layer_num >= $self->config2->{bottom_layers} ? 0 : $self->config2->{bottom_layers} - $self->_layer_num; return $remaining_bottom_layers * $self->config2->{bottom_exposure_time} + ($remaining_layers - $remaining_bottom_layers) * $self->config2->{exposure_time} + $remaining_layers * $self->config2->{settle_time}; } sub print_time { my ($self) = @_; return $self->config2->{bottom_layers} * $self->config2->{bottom_exposure_time} + (@{$self->_heights} - $self->config2->{bottom_layers}) * $self->config2->{exposure_time} + @{$self->_heights} * $self->config2->{settle_time}; } sub DESTROY { my ($self) = @_; $self->timer->Stop if $self->timer; $self->sender->disconnect if $self->sender; Slic3r::GUI::enable_screensaver(); } package Slic3r::GUI::Projector::Screen; use Wx qw(:dialog :id :misc :sizer :colour :pen :brush :font wxBG_STYLE_CUSTOM); use Wx::Event qw(EVT_PAINT EVT_SIZE); use base qw(Wx::Dialog Class::Accessor); use List::Util qw(min); use Slic3r::Geometry qw(X Y unscale scale); use Slic3r::Geometry::Clipper qw(intersection_pl); __PACKAGE__->mk_accessors(qw(config config2 scaling_factor bed_origin layers)); sub new { my ($class, $parent, $config, $config2) = @_; my $self = $class->SUPER::new($parent, -1, "Projector", wxDefaultPosition, wxDefaultSize, 0); $self->config($config); $self->config2($config2); $self->SetBackgroundStyle(wxBG_STYLE_CUSTOM); EVT_SIZE($self, \&_resize); EVT_PAINT($self, \&_repaint); $self->_resize; return $self; } sub reposition { my ($self) = @_; my $display = Wx::Display->new($self->config2->{display}); my $area = $display->GetGeometry; $self->Move($area->GetPosition); # ShowFullScreen doesn't use the right screen #$self->ShowFullScreen($self->config2->{fullscreen}); $self->SetSize($area->GetSize); $self->_resize; $self->Refresh; } sub _resize { my ($self) = @_; return if !$self->config; my ($cw, $ch) = $self->GetSizeWH; # get bed shape polygon my $bed_polygon = Slic3r::Polygon->new_scale(@{$self->config->bed_shape}); my $bb = $bed_polygon->bounding_box; my $size = $bb->size; my $center = $bb->center; # calculate the scaling factor needed for constraining print bed area inside preview # scaling_factor is expressed in pixel / mm $self->scaling_factor(min($cw / unscale($size->x), $ch / unscale($size->y))); #) # apply zoom to scaling factor if ($self->config2->{zoom} != 0) { # TODO: make sure min and max in the option config are enforced $self->scaling_factor($self->scaling_factor * ($self->config2->{zoom}/100)); } # calculate the displacement needed for centering bed on screen $self->bed_origin([ $cw/2 - (unscale($center->x) - $self->config2->{offset}->[X]) * $self->scaling_factor, $ch/2 - (unscale($center->y) - $self->config2->{offset}->[Y]) * $self->scaling_factor, #)) ]); $self->Refresh; } sub project_layers { my ($self, $layers) = @_; $self->layers($layers); $self->Refresh; } sub _repaint { my ($self) = @_; my $dc = Wx::AutoBufferedPaintDC->new($self); my ($cw, $ch) = $self->GetSizeWH; return if $cw == 0; # when canvas is not rendered yet, size is 0,0 $dc->SetPen(Wx::Pen->new(wxBLACK, 1, wxSOLID)); $dc->SetBrush(Wx::Brush->new(wxBLACK, wxSOLID)); $dc->DrawRectangle(0, 0, $cw, $ch); return if !$self->config; # turn size into max visible coordinates # TODO: or should we use ClientArea? $cw--; $ch--; # draw bed if ($self->config2->{show_bed}) { $dc->SetPen(Wx::Pen->new(wxRED, 2, wxSOLID)); $dc->SetBrush(Wx::Brush->new(wxWHITE, wxTRANSPARENT)); # draw contour my $bed_polygon = Slic3r::Polygon->new_scale(@{$self->config->bed_shape}); $dc->DrawPolygon($self->scaled_points_to_pixel($bed_polygon), 0, 0); # draw grid $dc->SetPen(Wx::Pen->new(wxRED, 1, wxSOLID)); { my $bb = $bed_polygon->bounding_box; my $step = scale 10; # 1cm grid my @polylines = (); for (my $x = $bb->x_min - ($bb->x_min % $step) + $step; $x < $bb->x_max; $x += $step) { push @polylines, Slic3r::Polyline->new([$x, $bb->y_min], [$x, $bb->y_max]); } for (my $y = $bb->y_min - ($bb->y_min % $step) + $step; $y < $bb->y_max; $y += $step) { push @polylines, Slic3r::Polyline->new([$bb->x_min, $y], [$bb->x_max, $y]); } $dc->DrawLine(map @$_, @$_) for map $self->scaled_points_to_pixel([ @$_[0,-1] ]), @{intersection_pl(\@polylines, [$bed_polygon])}; } # draw axes orientation $dc->SetPen(Wx::Pen->new(wxWHITE, 4, wxSOLID)); { foreach my $endpoint ([10, 0], [0, 10]) { $dc->DrawLine( map @{$self->unscaled_point_to_pixel($_)}, [0,0], $endpoint ); } $dc->SetTextForeground(wxWHITE); $dc->SetFont(Wx::Font->new(20, wxDEFAULT, wxNORMAL, wxNORMAL)); $dc->DrawText("X", @{$self->unscaled_point_to_pixel([10, -2])}); $dc->DrawText("Y", @{$self->unscaled_point_to_pixel([-2, 10])}); } } return if !defined $self->layers; # get layers at this height # draw layers $dc->SetPen(Wx::Pen->new(wxWHITE, 1, wxSOLID)); foreach my $layer (@{$self->layers}) { my @polygons = sort { $a->contains_point($b->first_point) ? -1 : 1 } map @$_, @{ $layer->slices }; foreach my $copy (@{$layer->object->_shifted_copies}) { foreach my $polygon (@polygons) { $polygon = $polygon->clone; $polygon->translate(@$copy); if ($polygon->is_counter_clockwise) { $dc->SetBrush(Wx::Brush->new(wxWHITE, wxSOLID)); } else { $dc->SetBrush(Wx::Brush->new(wxBLACK, wxSOLID)); } $dc->DrawPolygon($self->scaled_points_to_pixel($polygon->pp), 0, 0); } } } } # convert a model coordinate into a pixel coordinate sub unscaled_point_to_pixel { my ($self, $point) = @_; my $zero = $self->bed_origin; my $p = [ $point->[X] * $self->scaling_factor + $zero->[X], $point->[Y] * $self->scaling_factor + $zero->[Y], ]; if (!$self->config2->{invert_y}) { my $ch = $self->GetSize->GetHeight; $p->[Y] = $ch - $p->[Y]; } return $p; } sub scaled_points_to_pixel { my ($self, $points) = @_; return [ map $self->unscaled_point_to_pixel($_), map Slic3r::Pointf->new_unscale(@$_), @$points ]; } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/SimpleTab.pm000066400000000000000000000246231301441720000212540ustar00rootroot00000000000000# The "Simple" Print Settings tab. # The "Simple" mode is enabled by File->Preferences dialog. package Slic3r::GUI::SimpleTab; use strict; use warnings; use utf8; use File::Basename qw(basename); use List::Util qw(first); use Wx qw(:bookctrl :dialog :keycode :icon :id :misc :panel :sizer :window :systemsettings); use Wx::Event qw(EVT_BUTTON EVT_CHOICE EVT_KEY_DOWN); use base 'Wx::ScrolledWindow'; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL); $self->SetScrollbars(1, 1, 1, 1); $self->{config} = Slic3r::Config->new; $self->{optgroups} = []; $self->{vsizer} = Wx::BoxSizer->new(wxVERTICAL); $self->SetSizer($self->{vsizer}); $self->build; $self->_update; { my $label = Wx::StaticText->new($self, -1, "Want more options? Switch to the Expert Mode.", wxDefaultPosition, wxDefaultSize); $label->SetFont(Wx::SystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); $self->{vsizer}->Add($label, 0, wxEXPAND | wxALL, 10); } return $self; } sub init_config_options { my ($self, @opt_keys) = @_; $self->{config}->apply(Slic3r::Config->new_from_defaults(@opt_keys)); } sub new_optgroup { my ($self, $title, %params) = @_; my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new( parent => $self, title => $title, config => $self->{config}, label_width => $params{label_width} // 200, on_change => sub { $self->_on_value_change(@_) }, ); push @{$self->{optgroups}}, $optgroup; $self->{vsizer}->Add($optgroup->sizer, 0, wxEXPAND | wxALL, 10); return $optgroup; } sub load_config_file { my $self = shift; my ($file) = @_; my $config = Slic3r::Config->load($file); $self->load_config($config); } sub load_config { my $self = shift; my ($config) = @_; foreach my $opt_key (@{$self->{config}->get_keys}) { next unless $config->has($opt_key); $self->{config}->set($opt_key, $config->get($opt_key)); } $_->reload_config for @{$self->{optgroups}}; $self->_update; } sub load_presets {} sub is_dirty { 0 } sub config { $_[0]->{config}->clone } sub _update {} sub on_value_change { my ($self, $cb) = @_; $self->{on_value_change} = $cb; } sub on_presets_changed {} # propagate event to the parent sub _on_value_change { my $self = shift; $self->{on_value_change}->(@_) if $self->{on_value_change}; $self->_update; } sub get_field { my ($self, $opt_key, $opt_index) = @_; foreach my $optgroup (@{ $self->{optgroups} }) { my $field = $optgroup->get_fieldc($opt_key, $opt_index); return $field if defined $field; } return undef; } package Slic3r::GUI::SimpleTab::Print; use base 'Slic3r::GUI::SimpleTab'; use Wx qw(:sizer); sub name { 'print' } sub title { 'Print Settings' } sub build { my $self = shift; $self->init_config_options(qw( layer_height perimeters top_solid_layers bottom_solid_layers fill_density fill_pattern external_fill_pattern support_material support_material_spacing raft_layers support_material_contact_distance support_material_buildplate_only dont_support_bridges perimeter_speed infill_speed travel_speed brim_width xy_size_compensation )); { my $optgroup = $self->new_optgroup('General'); $optgroup->append_single_option_line('layer_height'); $optgroup->append_single_option_line('perimeters'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Solid layers', ); $line->append_option($optgroup->get_option('top_solid_layers')); $line->append_option($optgroup->get_option('bottom_solid_layers')); $optgroup->append_line($line); } { my $optgroup = $self->new_optgroup('Infill'); $optgroup->append_single_option_line('fill_density'); $optgroup->append_single_option_line('fill_pattern'); $optgroup->append_single_option_line('external_fill_pattern'); } { my $optgroup = $self->new_optgroup('Support material'); $optgroup->append_single_option_line('support_material'); $optgroup->append_single_option_line('support_material_spacing'); $optgroup->append_single_option_line('support_material_contact_distance'); $optgroup->append_single_option_line('support_material_buildplate_only'); $optgroup->append_single_option_line('dont_support_bridges'); $optgroup->append_single_option_line('raft_layers'); } { my $optgroup = $self->new_optgroup('Speed'); $optgroup->append_single_option_line('perimeter_speed'); $optgroup->append_single_option_line('infill_speed'); $optgroup->append_single_option_line('travel_speed'); } { my $optgroup = $self->new_optgroup('Brim'); $optgroup->append_single_option_line('brim_width'); } { my $optgroup = $self->new_optgroup('Other'); $optgroup->append_single_option_line('xy_size_compensation'); } } sub _update { my ($self) = @_; my $config = $self->{config}; my $have_perimeters = $config->perimeters > 0; $self->get_field($_)->toggle($have_perimeters) for qw(perimeter_speed); my $have_infill = $config->fill_density > 0; my $have_solid_infill = $config->top_solid_layers > 0 || $config->bottom_solid_layers > 0; $self->get_field($_)->toggle($have_infill) for qw(fill_pattern); $self->get_field($_)->toggle($have_solid_infill) for qw(external_fill_pattern); $self->get_field($_)->toggle($have_infill || $have_solid_infill) for qw(infill_speed); my $have_support_material = $config->support_material || $config->raft_layers > 0; $self->get_field($_)->toggle($have_support_material) for qw(support_material_spacing dont_support_bridges support_material_contact_distance); } package Slic3r::GUI::SimpleTab::Filament; use base 'Slic3r::GUI::SimpleTab'; sub name { 'filament' } sub title { 'Filament Settings' } sub build { my $self = shift; $self->init_config_options(qw( filament_diameter extrusion_multiplier temperature first_layer_temperature bed_temperature first_layer_bed_temperature )); { my $optgroup = $self->new_optgroup('Filament'); $optgroup->append_single_option_line('filament_diameter', 0); $optgroup->append_single_option_line('extrusion_multiplier', 0); } { my $optgroup = $self->new_optgroup('Temperature (°C)'); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Extruder', ); $line->append_option($optgroup->get_option('first_layer_temperature', 0)); $line->append_option($optgroup->get_option('temperature', 0)); $optgroup->append_line($line); } { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Bed', ); $line->append_option($optgroup->get_option('first_layer_bed_temperature')); $line->append_option($optgroup->get_option('bed_temperature')); $optgroup->append_line($line); } } } package Slic3r::GUI::SimpleTab::Printer; use base 'Slic3r::GUI::SimpleTab'; use Wx qw(:sizer :button :bitmap :misc :id); use Wx::Event qw(EVT_BUTTON); sub name { 'printer' } sub title { 'Printer Settings' } sub build { my $self = shift; $self->init_config_options(qw( bed_shape z_offset gcode_flavor nozzle_diameter retract_length retract_lift wipe start_gcode end_gcode )); { my $bed_shape_widget = sub { my ($parent) = @_; my $btn = Wx::Button->new($parent, -1, "Set…", wxDefaultPosition, wxDefaultSize, wxBU_LEFT); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG)); } my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($btn); EVT_BUTTON($self, $btn, sub { my $dlg = Slic3r::GUI::BedShapeDialog->new($self, $self->{config}->bed_shape); if ($dlg->ShowModal == wxID_OK) { my $value = $dlg->GetValue; $self->{config}->set('bed_shape', $value); $self->_on_value_change('bed_shape', $value); } }); return $sizer; }; my $optgroup = $self->new_optgroup('Size and coordinates'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Bed shape', widget => $bed_shape_widget, ); $optgroup->append_line($line); $optgroup->append_single_option_line('z_offset'); } { my $optgroup = $self->new_optgroup('Firmware'); $optgroup->append_single_option_line('gcode_flavor'); } { my $optgroup = $self->new_optgroup('Extruder'); $optgroup->append_single_option_line('nozzle_diameter', 0); } { my $optgroup = $self->new_optgroup('Retraction'); $optgroup->append_single_option_line('retract_length', 0); $optgroup->append_single_option_line('retract_lift', 0); $optgroup->append_single_option_line('wipe', 0); } { my $optgroup = $self->new_optgroup('Start G-code', label_width => 0, ); my $option = $optgroup->get_option('start_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } { my $optgroup = $self->new_optgroup('End G-code', label_width => 0, ); my $option = $optgroup->get_option('end_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } } sub _update { my ($self) = @_; my $config = $self->{config}; my $have_retraction = $config->retract_length->[0] > 0; $self->get_field($_, 0)->toggle($have_retraction) for qw(retract_lift wipe); } 1; Slic3r-version_1.31.6/lib/Slic3r/GUI/Tab.pm000066400000000000000000002061301301441720000200750ustar00rootroot00000000000000# The "Expert" tab at the right of the main tabbed window. # The "Expert" is enabled by File->Preferences dialog. # This file implements following packages: # Slic3r::GUI::Tab; # Slic3r::GUI::Tab::Print; # Slic3r::GUI::Tab::Filament; # Slic3r::GUI::Tab::Printer; # Slic3r::GUI::Tab::Page # - Option page: For example, the Slic3r::GUI::Tab::Print has option pages "Layers and perimeters", "Infill", "Skirt and brim" ... # Slic3r::GUI::SavePresetWindow # - Dialog to select a new preset name to store the configuration. # Slic3r::GUI::Tab::Preset; # - Single preset item: name, file is default or external. package Slic3r::GUI::Tab; use strict; use warnings; use utf8; use File::Basename qw(basename); use List::Util qw(first); use Wx qw(:bookctrl :dialog :keycode :icon :id :misc :panel :sizer :treectrl :window :button wxTheApp); use Wx::Event qw(EVT_BUTTON EVT_CHOICE EVT_KEY_DOWN EVT_TREE_SEL_CHANGED); use base qw(Wx::Panel Class::Accessor); # Index of the currently active preset. __PACKAGE__->mk_accessors(qw(current_preset)); sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL); # horizontal sizer $self->{sizer} = Wx::BoxSizer->new(wxHORIZONTAL); $self->{sizer}->SetSizeHints($self); $self->SetSizer($self->{sizer}); # left vertical sizer my $left_sizer = Wx::BoxSizer->new(wxVERTICAL); $self->{sizer}->Add($left_sizer, 0, wxEXPAND | wxLEFT | wxTOP | wxBOTTOM, 3); my $left_col_width = 150; # preset chooser { # choice menu $self->{presets_choice} = Wx::Choice->new($self, -1, wxDefaultPosition, [$left_col_width, -1], []); $self->{presets_choice}->SetFont($Slic3r::GUI::small_font); # buttons $self->{btn_save_preset} = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("disk.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, wxBORDER_NONE); $self->{btn_delete_preset} = Wx::BitmapButton->new($self, -1, Wx::Bitmap->new($Slic3r::var->("delete.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, wxBORDER_NONE); $self->{btn_save_preset}->SetToolTipString("Save current " . lc($self->title)); $self->{btn_delete_preset}->SetToolTipString("Delete this preset"); $self->{btn_delete_preset}->Disable; ### These cause GTK warnings: ###my $box = Wx::StaticBox->new($self, -1, "Presets:", wxDefaultPosition, [$left_col_width, 50]); ###my $hsizer = Wx::StaticBoxSizer->new($box, wxHORIZONTAL); my $hsizer = Wx::BoxSizer->new(wxHORIZONTAL); $left_sizer->Add($hsizer, 0, wxEXPAND | wxBOTTOM, 5); $hsizer->Add($self->{presets_choice}, 1, wxRIGHT | wxALIGN_CENTER_VERTICAL, 3); $hsizer->Add($self->{btn_save_preset}, 0, wxALIGN_CENTER_VERTICAL); $hsizer->Add($self->{btn_delete_preset}, 0, wxALIGN_CENTER_VERTICAL); } # tree $self->{treectrl} = Wx::TreeCtrl->new($self, -1, wxDefaultPosition, [$left_col_width, -1], wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_SINGLE | wxTR_NO_LINES | wxBORDER_SUNKEN | wxWANTS_CHARS); $left_sizer->Add($self->{treectrl}, 1, wxEXPAND); $self->{icons} = Wx::ImageList->new(16, 16, 1); $self->{treectrl}->AssignImageList($self->{icons}); $self->{iconcount} = -1; $self->{treectrl}->AddRoot("root"); $self->{pages} = []; $self->{treectrl}->SetIndent(0); $self->{disable_tree_sel_changed_event} = 0; EVT_TREE_SEL_CHANGED($parent, $self->{treectrl}, sub { return if $self->{disable_tree_sel_changed_event}; my $page = first { $_->{title} eq $self->{treectrl}->GetItemText($self->{treectrl}->GetSelection) } @{$self->{pages}} or return; $_->Hide for @{$self->{pages}}; $page->Show; $self->{sizer}->Layout; $self->Refresh; }); EVT_KEY_DOWN($self->{treectrl}, sub { my ($treectrl, $event) = @_; if ($event->GetKeyCode == WXK_TAB) { $treectrl->Navigate($event->ShiftDown ? &Wx::wxNavigateBackward : &Wx::wxNavigateForward); } else { $event->Skip; } }); EVT_CHOICE($parent, $self->{presets_choice}, sub { $self->on_select_preset; $self->_on_presets_changed; }); EVT_BUTTON($self, $self->{btn_save_preset}, sub { $self->save_preset }); EVT_BUTTON($self, $self->{btn_delete_preset}, sub { my $i = $self->current_preset; # Don't let the user delete the '- default -' configuration. # This shall not happen as the 'delete' button is disabled for the '- default -' entry, # but better be safe than sorry. return if ($i == 0 && $self->get_current_preset->{default}); my $res = Wx::MessageDialog->new($self, "Are you sure you want to delete the selected preset?", 'Delete Preset', wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION)->ShowModal; return unless $res == wxID_YES; # Delete the file. my $path = Slic3r::encode_path($self->{presets}[$i]->file); if (-e $path && ! unlink $path) { # Cannot delete the file, therefore the item will not be removed from the selection. Slic3r::GUI::show_error($self, "Cannot delete file $path : $!"); return; } # Delete the preset. splice @{$self->{presets}}, $i, 1; # Delete the item from the UI component. $self->{presets_choice}->Delete($i - $self->{default_suppressed}); $self->current_preset(undef); if ($self->{default_suppressed} && scalar(@{$self->{presets}}) == 1) { # Empty selection. Add the '- default -' item into the drop down selection. $self->{presets_choice}->Append($self->{presets}->[0]->name); # and remember that the '- default -' is shown. $self->{default_suppressed} = 0; } # Select the 0th item. If default is suppressed, select the first valid. $self->select_preset($self->{default_suppressed}); $self->_on_presets_changed; }); # C++ instance DynamicPrintConfig $self->{config} = Slic3r::Config->new; # Initialize the DynamicPrintConfig by default keys/values. # Possible %params keys: no_controller $self->build(%params); $self->update_tree; $self->_update; if ($self->hidden_options) { $self->{config}->apply(Slic3r::Config->new_from_defaults($self->hidden_options)); } return $self; } # Are the '- default -' selections suppressed by the Slic3r GUI preferences? sub no_defaults { return $Slic3r::GUI::Settings->{_}{no_defaults} ? 1 : 0; } # Get a currently active preset (Perl class Slic3r::GUI::Tab::Preset). sub get_current_preset { my $self = shift; return $self->get_preset($self->current_preset); } # Get a preset (Perl class Slic3r::GUI::Tab::Preset) with an index $i. sub get_preset { my ($self, $i) = @_; return $self->{presets}[$i]; } sub save_preset { my ($self, $name) = @_; # since buttons (and choices too) don't get focus on Mac, we set focus manually # to the treectrl so that the EVT_* events are fired for the input field having # focus currently. is there anything better than this? $self->{treectrl}->SetFocus; if (!defined $name) { my $preset = $self->get_current_preset; my $default_name = $preset->default ? 'Untitled' : $preset->name; $default_name =~ s/\.ini$//i; my $dlg = Slic3r::GUI::SavePresetWindow->new($self, title => lc($self->title), default => $default_name, values => [ map $_->name, grep !$_->default && !$_->external, @{$self->{presets}} ], ); return unless $dlg->ShowModal == wxID_OK; $name = $dlg->get_name; } $self->config->save(sprintf "$Slic3r::GUI::datadir/%s/%s.ini", $self->name, $name); $self->load_presets; $self->select_preset_by_name($name); $self->_on_presets_changed; } sub on_value_change { my ($self, $cb) = @_; $self->{on_value_change} = $cb; } sub on_presets_changed { my ($self, $cb) = @_; $self->{on_presets_changed} = $cb; } # This method is supposed to be called whenever new values are loaded # or changed by user (so also when a preset is loaded). # propagate event to the parent sub _on_value_change { my $self = shift; $self->{on_value_change}->(@_) if $self->{on_value_change}; $self->_update; } sub _update {} sub _on_presets_changed { my $self = shift; $self->{on_presets_changed}->( $self->{presets}, $self->{default_suppressed}, scalar($self->{presets_choice}->GetSelection) + $self->{default_suppressed}, $self->is_dirty, ) if $self->{on_presets_changed}; } sub on_preset_loaded {} sub hidden_options {} sub config { $_[0]->{config}->clone } sub select_default_preset { my $self = shift; $self->select_preset(0); } sub select_preset { my ($self, $i) = @_; if ($self->{default_suppressed} && $i == 0) { # Selecting the '- default -'. Add it to the combo box. $self->{default_suppressed} = 0; $self->{presets_choice}->Insert($self->{presets}->[0]->name, 0); } elsif ($self->no_defaults && ! $self->{default_suppressed} && $i > 0) { # The user wants to hide the '- default -' items and a non-default item has been added to the presets. # Hide the '- default -' item. $self->{presets_choice}->Delete(0); $self->{default_suppressed} = 1; } $self->{presets_choice}->SetSelection($i - $self->{default_suppressed}); $self->on_select_preset; } sub select_preset_by_name { my ($self, $name) = @_; $name = Unicode::Normalize::NFC($name); $self->select_preset(first { $self->{presets}[$_]->name eq $name } 0 .. $#{$self->{presets}}); } sub on_select_preset { my $self = shift; if ($self->is_dirty) { # Display a dialog showing the dirty options in a human readable form. my $old_preset = $self->get_current_preset; my $name = $old_preset->default ? 'Default preset' : "Preset \"" . $old_preset->name . "\""; my @option_names = (); foreach my $opt_key (@{$self->dirty_options}) { my $opt = $Slic3r::Config::Options->{$opt_key}; my $name = $opt->{full_label} // $opt->{label}; if ($opt->{category}) { $name = $opt->{category} . " > $name"; } push @option_names, $name; } my $changes = join "\n", map "- $_", @option_names; my $confirm = Wx::MessageDialog->new($self, "$name has unsaved changes:\n$changes\n\nDiscard changes and continue anyway?", 'Unsaved Changes', wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION); if ($confirm->ShowModal == wxID_NO) { $self->{presets_choice}->SetSelection($self->current_preset - $self->{default_suppressed}); # trigger the on_presets_changed event so that we also restore the previous value # in the plater selector $self->_on_presets_changed; return; } } $self->current_preset($self->{presets_choice}->GetSelection + $self->{default_suppressed}); my $preset = $self->get_current_preset; my $preset_config = $self->get_preset_config($preset); eval { local $SIG{__WARN__} = Slic3r::GUI::warning_catcher($self); foreach my $opt_key (@{$self->{config}->get_keys}) { $self->{config}->set($opt_key, $preset_config->get($opt_key)) if $preset_config->has($opt_key); } ($preset->default || $preset->external) ? $self->{btn_delete_preset}->Disable : $self->{btn_delete_preset}->Enable; $self->_update; $self->on_preset_loaded; $self->reload_config; $Slic3r::GUI::Settings->{presets}{$self->name} = $preset->file ? basename($preset->file) : ''; }; if ($@) { $@ = "I was unable to load the selected config file: $@"; Slic3r::GUI::catch_error($self); $self->select_default_preset; } # use CallAfter because some field triggers schedule on_change calls using CallAfter, # and we don't want them to be called after this update_dirty() as they would mark the # preset dirty again # (not sure this is true anymore now that update_dirty is idempotent) wxTheApp->CallAfter(sub { $self->_on_presets_changed; $self->update_dirty; }); wxTheApp->save_settings; } sub init_config_options { my ($self, @opt_keys) = @_; $self->{config}->apply(Slic3r::Config->new_from_defaults(@opt_keys)); } sub add_options_page { my $self = shift; my ($title, $icon, %params) = @_; if ($icon) { my $bitmap = Wx::Bitmap->new($Slic3r::var->($icon), wxBITMAP_TYPE_PNG); $self->{icons}->Add($bitmap); $self->{iconcount}++; } my $page = Slic3r::GUI::Tab::Page->new($self, $title, $self->{iconcount}); $page->Hide; $self->{sizer}->Add($page, 1, wxEXPAND | wxLEFT, 5); push @{$self->{pages}}, $page; return $page; } sub reload_config { my $self = shift; $_->reload_config for @{$self->{pages}}; } sub update_tree { my ($self) = @_; # get label of the currently selected item my $selected = $self->{treectrl}->GetItemText($self->{treectrl}->GetSelection); my $rootItem = $self->{treectrl}->GetRootItem; $self->{treectrl}->DeleteChildren($rootItem); my $have_selection = 0; foreach my $page (@{$self->{pages}}) { my $itemId = $self->{treectrl}->AppendItem($rootItem, $page->{title}, $page->{iconID}); if ($page->{title} eq $selected) { $self->{disable_tree_sel_changed_event} = 1; $self->{treectrl}->SelectItem($itemId); $self->{disable_tree_sel_changed_event} = 0; $have_selection = 1; } } if (!$have_selection) { # this is triggered on first load, so we don't disable the sel change event $self->{treectrl}->SelectItem($self->{treectrl}->GetFirstChild($rootItem)); } } sub update_dirty { my $self = shift; foreach my $i ($self->{default_suppressed}..$#{$self->{presets}}) { my $preset = $self->get_preset($i); $self->{presets_choice}->SetString( $i - $self->{default_suppressed}, ($i == $self->current_preset && $self->is_dirty) ? $preset->name . " (modified)" : $preset->name); } $self->{presets_choice}->SetSelection($self->current_preset - $self->{default_suppressed}); # http://trac.wxwidgets.org/ticket/13769 $self->_on_presets_changed; } sub is_dirty { my $self = shift; return @{$self->dirty_options} > 0; } sub dirty_options { my $self = shift; return [] if !defined $self->current_preset; # happens during initialization return $self->get_preset_config($self->get_current_preset)->diff($self->{config}); } sub load_presets { my $self = shift; $self->{presets} = [ Slic3r::GUI::Tab::Preset->new( default => 1, name => '- default -', ), ]; my %presets = wxTheApp->presets($self->name); foreach my $preset_name (sort keys %presets) { push @{$self->{presets}}, Slic3r::GUI::Tab::Preset->new( name => $preset_name, file => $presets{$preset_name}, ); } $self->current_preset(undef); $self->{default_suppressed} = Slic3r::GUI::Tab->no_defaults && scalar(@{$self->{presets}}) > 1; $self->{presets_choice}->Clear; foreach my $preset (@{$self->{presets}}) { next if ($preset->default && $self->{default_suppressed}); $self->{presets_choice}->Append($preset->name); } { # load last used preset my $i = first { basename($self->{presets}[$_]->file) eq ($Slic3r::GUI::Settings->{presets}{$self->name} || '') } 1 .. $#{$self->{presets}}; $self->select_preset($i || $self->{default_suppressed}); } $self->_on_presets_changed; } sub load_config_file { my $self = shift; my ($file) = @_; # look for the loaded config among the existing menu items my $i = first { $self->{presets}[$_]{file} eq $file && $self->{presets}[$_]{external} } 1..$#{$self->{presets}}; if (!$i) { my $preset_name = basename($file); # keep the .ini suffix push @{$self->{presets}}, Slic3r::GUI::Tab::Preset->new( file => $file, name => $preset_name, external => 1, ); $self->{presets_choice}->Append($preset_name); $i = $#{$self->{presets}}; } $self->{presets_choice}->SetSelection($i - $self->{default_suppressed}); $self->on_select_preset; $self->_on_presets_changed; } sub load_config { my $self = shift; my ($config) = @_; foreach my $opt_key (@{$self->{config}->diff($config)}) { $self->{config}->set($opt_key, $config->get($opt_key)); $self->update_dirty; } $self->reload_config; $self->_update; } sub get_preset_config { my ($self, $preset) = @_; return $preset->config($self->{config}->get_keys); } sub get_field { my ($self, $opt_key, $opt_index) = @_; foreach my $page (@{ $self->{pages} }) { my $field = $page->get_field($opt_key, $opt_index); return $field if defined $field; } return undef; } sub set_value { my $self = shift; my ($opt_key, $value) = @_; my $changed = 0; foreach my $page (@{ $self->{pages} }) { $changed = 1 if $page->set_value($opt_key, $value); } return $changed; } package Slic3r::GUI::Tab::Print; use base 'Slic3r::GUI::Tab'; use List::Util qw(first); use Wx qw(:icon :dialog :id); sub name { 'print' } sub title { 'Print Settings' } sub build { my $self = shift; $self->init_config_options(qw( layer_height first_layer_height perimeters spiral_vase top_solid_layers bottom_solid_layers extra_perimeters ensure_vertical_shell_thickness avoid_crossing_perimeters thin_walls overhangs seam_position external_perimeters_first fill_density fill_pattern external_fill_pattern infill_every_layers infill_only_where_needed solid_infill_every_layers fill_angle solid_infill_below_area only_retract_when_crossing_perimeters infill_first max_print_speed max_volumetric_speed max_volumetric_extrusion_rate_slope_positive max_volumetric_extrusion_rate_slope_negative perimeter_speed small_perimeter_speed external_perimeter_speed infill_speed solid_infill_speed top_solid_infill_speed support_material_speed support_material_interface_speed bridge_speed gap_fill_speed travel_speed first_layer_speed perimeter_acceleration infill_acceleration bridge_acceleration first_layer_acceleration default_acceleration skirts skirt_distance skirt_height min_skirt_length brim_width support_material support_material_threshold support_material_enforce_layers raft_layers support_material_pattern support_material_with_sheath support_material_spacing support_material_angle support_material_interface_layers support_material_interface_spacing support_material_contact_distance support_material_buildplate_only dont_support_bridges notes complete_objects extruder_clearance_radius extruder_clearance_height gcode_comments output_filename_format post_process perimeter_extruder infill_extruder solid_infill_extruder support_material_extruder support_material_interface_extruder ooze_prevention standby_temperature_delta interface_shells extrusion_width first_layer_extrusion_width perimeter_extrusion_width external_perimeter_extrusion_width infill_extrusion_width solid_infill_extrusion_width top_infill_extrusion_width support_material_extrusion_width infill_overlap bridge_flow_ratio xy_size_compensation threads resolution )); $self->{config}->set('print_settings_id', ''); { my $page = $self->add_options_page('Layers and perimeters', 'layers.png'); { my $optgroup = $page->new_optgroup('Layer height'); $optgroup->append_single_option_line('layer_height'); $optgroup->append_single_option_line('first_layer_height'); } { my $optgroup = $page->new_optgroup('Vertical shells'); $optgroup->append_single_option_line('perimeters'); $optgroup->append_single_option_line('spiral_vase'); } { my $optgroup = $page->new_optgroup('Horizontal shells'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Solid layers', ); $line->append_option($optgroup->get_option('top_solid_layers')); $line->append_option($optgroup->get_option('bottom_solid_layers')); $optgroup->append_line($line); } { my $optgroup = $page->new_optgroup('Quality (slower slicing)'); $optgroup->append_single_option_line('extra_perimeters'); $optgroup->append_single_option_line('ensure_vertical_shell_thickness'); $optgroup->append_single_option_line('avoid_crossing_perimeters'); $optgroup->append_single_option_line('thin_walls'); $optgroup->append_single_option_line('overhangs'); } { my $optgroup = $page->new_optgroup('Advanced'); $optgroup->append_single_option_line('seam_position'); $optgroup->append_single_option_line('external_perimeters_first'); } } { my $page = $self->add_options_page('Infill', 'infill.png'); { my $optgroup = $page->new_optgroup('Infill'); $optgroup->append_single_option_line('fill_density'); $optgroup->append_single_option_line('fill_pattern'); $optgroup->append_single_option_line('external_fill_pattern'); } { my $optgroup = $page->new_optgroup('Reducing printing time'); $optgroup->append_single_option_line('infill_every_layers'); $optgroup->append_single_option_line('infill_only_where_needed'); } { my $optgroup = $page->new_optgroup('Advanced'); $optgroup->append_single_option_line('solid_infill_every_layers'); $optgroup->append_single_option_line('fill_angle'); $optgroup->append_single_option_line('solid_infill_below_area'); $optgroup->append_single_option_line('only_retract_when_crossing_perimeters'); $optgroup->append_single_option_line('infill_first'); } } { my $page = $self->add_options_page('Skirt and brim', 'box.png'); { my $optgroup = $page->new_optgroup('Skirt'); $optgroup->append_single_option_line('skirts'); $optgroup->append_single_option_line('skirt_distance'); $optgroup->append_single_option_line('skirt_height'); $optgroup->append_single_option_line('min_skirt_length'); } { my $optgroup = $page->new_optgroup('Brim'); $optgroup->append_single_option_line('brim_width'); } } { my $page = $self->add_options_page('Support material', 'building.png'); { my $optgroup = $page->new_optgroup('Support material'); $optgroup->append_single_option_line('support_material'); $optgroup->append_single_option_line('support_material_threshold'); $optgroup->append_single_option_line('support_material_enforce_layers'); } { my $optgroup = $page->new_optgroup('Raft'); $optgroup->append_single_option_line('raft_layers'); } { my $optgroup = $page->new_optgroup('Options for support material and raft'); $optgroup->append_single_option_line('support_material_contact_distance'); $optgroup->append_single_option_line('support_material_pattern'); $optgroup->append_single_option_line('support_material_with_sheath'); $optgroup->append_single_option_line('support_material_spacing'); $optgroup->append_single_option_line('support_material_angle'); $optgroup->append_single_option_line('support_material_interface_layers'); $optgroup->append_single_option_line('support_material_interface_spacing'); $optgroup->append_single_option_line('support_material_buildplate_only'); $optgroup->append_single_option_line('dont_support_bridges'); } } { my $page = $self->add_options_page('Speed', 'time.png'); { my $optgroup = $page->new_optgroup('Speed for print moves'); $optgroup->append_single_option_line('perimeter_speed'); $optgroup->append_single_option_line('small_perimeter_speed'); $optgroup->append_single_option_line('external_perimeter_speed'); $optgroup->append_single_option_line('infill_speed'); $optgroup->append_single_option_line('solid_infill_speed'); $optgroup->append_single_option_line('top_solid_infill_speed'); $optgroup->append_single_option_line('support_material_speed'); $optgroup->append_single_option_line('support_material_interface_speed'); $optgroup->append_single_option_line('bridge_speed'); $optgroup->append_single_option_line('gap_fill_speed'); } { my $optgroup = $page->new_optgroup('Speed for non-print moves'); $optgroup->append_single_option_line('travel_speed'); } { my $optgroup = $page->new_optgroup('Modifiers'); $optgroup->append_single_option_line('first_layer_speed'); } { my $optgroup = $page->new_optgroup('Acceleration control (advanced)'); $optgroup->append_single_option_line('perimeter_acceleration'); $optgroup->append_single_option_line('infill_acceleration'); $optgroup->append_single_option_line('bridge_acceleration'); $optgroup->append_single_option_line('first_layer_acceleration'); $optgroup->append_single_option_line('default_acceleration'); } { my $optgroup = $page->new_optgroup('Autospeed (advanced)'); $optgroup->append_single_option_line('max_print_speed'); $optgroup->append_single_option_line('max_volumetric_speed'); $optgroup->append_single_option_line('max_volumetric_extrusion_rate_slope_positive'); $optgroup->append_single_option_line('max_volumetric_extrusion_rate_slope_negative'); } } { my $page = $self->add_options_page('Multiple Extruders', 'funnel.png'); { my $optgroup = $page->new_optgroup('Extruders'); $optgroup->append_single_option_line('perimeter_extruder'); $optgroup->append_single_option_line('infill_extruder'); $optgroup->append_single_option_line('solid_infill_extruder'); $optgroup->append_single_option_line('support_material_extruder'); $optgroup->append_single_option_line('support_material_interface_extruder'); } { my $optgroup = $page->new_optgroup('Ooze prevention'); $optgroup->append_single_option_line('ooze_prevention'); $optgroup->append_single_option_line('standby_temperature_delta'); } { my $optgroup = $page->new_optgroup('Advanced'); $optgroup->append_single_option_line('interface_shells'); } } { my $page = $self->add_options_page('Advanced', 'wrench.png'); { my $optgroup = $page->new_optgroup('Extrusion width', label_width => 180, ); $optgroup->append_single_option_line('extrusion_width'); $optgroup->append_single_option_line('first_layer_extrusion_width'); $optgroup->append_single_option_line('perimeter_extrusion_width'); $optgroup->append_single_option_line('external_perimeter_extrusion_width'); $optgroup->append_single_option_line('infill_extrusion_width'); $optgroup->append_single_option_line('solid_infill_extrusion_width'); $optgroup->append_single_option_line('top_infill_extrusion_width'); $optgroup->append_single_option_line('support_material_extrusion_width'); } { my $optgroup = $page->new_optgroup('Overlap'); $optgroup->append_single_option_line('infill_overlap'); } { my $optgroup = $page->new_optgroup('Flow'); $optgroup->append_single_option_line('bridge_flow_ratio'); } { my $optgroup = $page->new_optgroup('Other'); $optgroup->append_single_option_line('xy_size_compensation'); $optgroup->append_single_option_line('threads') if $Slic3r::have_threads; $optgroup->append_single_option_line('resolution'); } } { my $page = $self->add_options_page('Output options', 'page_white_go.png'); { my $optgroup = $page->new_optgroup('Sequential printing'); $optgroup->append_single_option_line('complete_objects'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Extruder clearance (mm)', ); foreach my $opt_key (qw(extruder_clearance_radius extruder_clearance_height)) { my $option = $optgroup->get_option($opt_key); $option->width(60); $line->append_option($option); } $optgroup->append_line($line); } { my $optgroup = $page->new_optgroup('Output file'); $optgroup->append_single_option_line('gcode_comments'); { my $option = $optgroup->get_option('output_filename_format'); $option->full_width(1); $optgroup->append_single_option_line($option); } } { my $optgroup = $page->new_optgroup('Post-processing scripts', label_width => 0, ); my $option = $optgroup->get_option('post_process'); $option->full_width(1); $option->height(50); $optgroup->append_single_option_line($option); } } { my $page = $self->add_options_page('Notes', 'note.png'); { my $optgroup = $page->new_optgroup('Notes', label_width => 0, ); my $option = $optgroup->get_option('notes'); $option->full_width(1); $option->height(250); $optgroup->append_single_option_line($option); } } } sub _update { my ($self) = @_; my $config = $self->{config}; if ($config->spiral_vase && !($config->perimeters == 1 && $config->top_solid_layers == 0 && $config->fill_density == 0)) { my $dialog = Wx::MessageDialog->new($self, "The Spiral Vase mode requires:\n" . "- one perimeter\n" . "- no top solid layers\n" . "- 0% fill density\n" . "- no support material\n" . "\nShall I adjust those settings in order to enable Spiral Vase?", 'Spiral Vase', wxICON_WARNING | wxYES | wxNO); if ($dialog->ShowModal() == wxID_YES) { my $new_conf = Slic3r::Config->new; $new_conf->set("perimeters", 1); $new_conf->set("top_solid_layers", 0); $new_conf->set("fill_density", 0); $new_conf->set("support_material", 0); $self->load_config($new_conf); } else { my $new_conf = Slic3r::Config->new; $new_conf->set("spiral_vase", 0); $self->load_config($new_conf); } } if ($config->support_material) { # Ask only once. if (! $self->{support_material_overhangs_queried}) { $self->{support_material_overhangs_queried} = 1; if ($config->overhangs != 1) { my $dialog = Wx::MessageDialog->new($self, "Supports work better, if the following feature is enabled:\n" . "- Detect bridging perimeters\n" . "\nShall I adjust those settings for supports?", 'Support Generator', wxICON_WARNING | wxYES | wxNO | wxCANCEL); my $answer = $dialog->ShowModal(); my $new_conf = Slic3r::Config->new; if ($answer == wxID_YES) { # Enable "detect bridging perimeters". $new_conf->set("overhangs", 1); } elsif ($answer == wxID_NO) { # Do nothing, leave supports on and "detect bridging perimeters" off. } elsif ($answer == wxID_CANCEL) { # Disable supports. $new_conf->set("support_material", 0); $self->{support_material_overhangs_queried} = 0; } $self->load_config($new_conf); } } } else { $self->{support_material_overhangs_queried} = 0; } if ($config->fill_density == 100 && !first { $_ eq $config->fill_pattern } @{$Slic3r::Config::Options->{external_fill_pattern}{values}}) { my $dialog = Wx::MessageDialog->new($self, "The " . $config->fill_pattern . " infill pattern is not supposed to work at 100% density.\n" . "\nShall I switch to rectilinear fill pattern?", 'Infill', wxICON_WARNING | wxYES | wxNO); my $new_conf = Slic3r::Config->new; if ($dialog->ShowModal() == wxID_YES) { $new_conf->set("fill_pattern", 'rectilinear'); $new_conf->set("fill_density", 100); } else { $new_conf->set("fill_density", 40); } $self->load_config($new_conf); } my $have_perimeters = $config->perimeters > 0; $self->get_field($_)->toggle($have_perimeters) for qw(extra_perimeters ensure_vertical_shell_thickness thin_walls overhangs seam_position external_perimeters_first external_perimeter_extrusion_width perimeter_speed small_perimeter_speed external_perimeter_speed); my $have_infill = $config->fill_density > 0; # infill_extruder uses the same logic as in Print::extruders() $self->get_field($_)->toggle($have_infill) for qw(fill_pattern infill_every_layers infill_only_where_needed solid_infill_every_layers solid_infill_below_area infill_extruder); my $have_solid_infill = ($config->top_solid_layers > 0) || ($config->bottom_solid_layers > 0); # solid_infill_extruder uses the same logic as in Print::extruders() $self->get_field($_)->toggle($have_solid_infill) for qw(external_fill_pattern infill_first solid_infill_extruder solid_infill_extrusion_width solid_infill_speed); $self->get_field($_)->toggle($have_infill || $have_solid_infill) for qw(fill_angle infill_extrusion_width infill_speed bridge_speed); $self->get_field('gap_fill_speed')->toggle($have_perimeters && $have_infill); my $have_top_solid_infill = $config->top_solid_layers > 0; $self->get_field($_)->toggle($have_top_solid_infill) for qw(top_infill_extrusion_width top_solid_infill_speed); my $have_default_acceleration = $config->default_acceleration > 0; $self->get_field($_)->toggle($have_default_acceleration) for qw(perimeter_acceleration infill_acceleration bridge_acceleration first_layer_acceleration); my $have_skirt = $config->skirts > 0 || $config->min_skirt_length > 0; $self->get_field($_)->toggle($have_skirt) for qw(skirt_distance skirt_height); my $have_brim = $config->brim_width > 0; # perimeter_extruder uses the same logic as in Print::extruders() $self->get_field('perimeter_extruder')->toggle($have_perimeters || $have_brim); my $have_support_material = $config->support_material || $config->raft_layers > 0; my $have_support_interface = $config->support_material_interface_layers > 0; $self->get_field($_)->toggle($have_support_material) for qw(support_material_threshold support_material_pattern support_material_with_sheath support_material_spacing support_material_angle support_material_interface_layers dont_support_bridges support_material_extrusion_width support_material_contact_distance); $self->get_field($_)->toggle($have_support_material && $have_support_interface) for qw(support_material_interface_spacing support_material_interface_extruder support_material_interface_speed); $self->get_field('perimeter_extrusion_width')->toggle($have_perimeters || $have_skirt || $have_brim); $self->get_field('support_material_extruder')->toggle($have_support_material || $have_skirt); $self->get_field('support_material_speed')->toggle($have_support_material || $have_brim || $have_skirt); my $have_sequential_printing = $config->complete_objects; $self->get_field($_)->toggle($have_sequential_printing) for qw(extruder_clearance_radius extruder_clearance_height); my $have_ooze_prevention = $config->ooze_prevention; $self->get_field($_)->toggle($have_ooze_prevention) for qw(standby_temperature_delta); } sub hidden_options { !$Slic3r::have_threads ? qw(threads) : () } package Slic3r::GUI::Tab::Filament; use base 'Slic3r::GUI::Tab'; sub name { 'filament' } sub title { 'Filament Settings' } sub build { my $self = shift; $self->init_config_options(qw( filament_colour filament_diameter filament_notes filament_max_volumetric_speed extrusion_multiplier temperature first_layer_temperature bed_temperature first_layer_bed_temperature fan_always_on cooling min_fan_speed max_fan_speed bridge_fan_speed disable_fan_first_layers fan_below_layer_time slowdown_below_layer_time min_print_speed )); $self->{config}->set('filament_settings_id', ''); { my $page = $self->add_options_page('Filament', 'spool.png'); { my $optgroup = $page->new_optgroup('Filament'); $optgroup->append_single_option_line('filament_colour', 0); $optgroup->append_single_option_line('filament_diameter', 0); $optgroup->append_single_option_line('extrusion_multiplier', 0); } { my $optgroup = $page->new_optgroup('Temperature (°C)'); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Extruder', ); $line->append_option($optgroup->get_option('first_layer_temperature', 0)); $line->append_option($optgroup->get_option('temperature', 0)); $optgroup->append_line($line); } { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Bed', ); $line->append_option($optgroup->get_option('first_layer_bed_temperature')); $line->append_option($optgroup->get_option('bed_temperature')); $optgroup->append_line($line); } } } { my $page = $self->add_options_page('Cooling', 'hourglass.png'); { my $optgroup = $page->new_optgroup('Enable'); $optgroup->append_single_option_line('fan_always_on'); $optgroup->append_single_option_line('cooling'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => '', full_width => 1, widget => sub { my ($parent) = @_; return $self->{description_line} = Slic3r::GUI::OptionsGroup::StaticText->new($parent); }, ); $optgroup->append_line($line); } { my $optgroup = $page->new_optgroup('Fan settings'); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Fan speed', ); $line->append_option($optgroup->get_option('min_fan_speed')); $line->append_option($optgroup->get_option('max_fan_speed')); $optgroup->append_line($line); } $optgroup->append_single_option_line('bridge_fan_speed'); $optgroup->append_single_option_line('disable_fan_first_layers'); } { my $optgroup = $page->new_optgroup('Cooling thresholds', label_width => 250, ); $optgroup->append_single_option_line('fan_below_layer_time'); $optgroup->append_single_option_line('slowdown_below_layer_time'); $optgroup->append_single_option_line('min_print_speed'); } } { my $page = $self->add_options_page('Advanced', 'wrench.png'); { my $optgroup = $page->new_optgroup('Print speed override'); $optgroup->append_single_option_line('filament_max_volumetric_speed', 0); } } { my $page = $self->add_options_page('Notes', 'note.png'); { my $optgroup = $page->new_optgroup('Notes', label_width => 0, ); my $option = $optgroup->get_option('filament_notes', 0); $option->full_width(1); $option->height(250); $optgroup->append_single_option_line($option); } } } sub _update { my ($self) = @_; $self->_update_description; my $cooling = $self->{config}->cooling; $self->get_field($_)->toggle($cooling) for qw(max_fan_speed fan_below_layer_time slowdown_below_layer_time min_print_speed); $self->get_field($_)->toggle($cooling || $self->{config}->fan_always_on) for qw(min_fan_speed disable_fan_first_layers); } sub _update_description { my $self = shift; my $config = $self->config; my $msg = ""; my $fan_other_layers = $config->fan_always_on ? sprintf "will always run at %d%%%s.", $config->min_fan_speed, ($config->disable_fan_first_layers > 1 ? " except for the first " . $config->disable_fan_first_layers . " layers" : $config->disable_fan_first_layers == 1 ? " except for the first layer" : "") : "will be turned off."; if ($config->cooling) { $msg = sprintf "If estimated layer time is below ~%ds, fan will run at %d%% and print speed will be reduced so that no less than %ds are spent on that layer (however, speed will never be reduced below %dmm/s).", $config->slowdown_below_layer_time, $config->max_fan_speed, $config->slowdown_below_layer_time, $config->min_print_speed; if ($config->fan_below_layer_time > $config->slowdown_below_layer_time) { $msg .= sprintf "\nIf estimated layer time is greater, but still below ~%ds, fan will run at a proportionally decreasing speed between %d%% and %d%%.", $config->fan_below_layer_time, $config->max_fan_speed, $config->min_fan_speed; } $msg .= "\nDuring the other layers, fan $fan_other_layers" } else { $msg = "Fan $fan_other_layers"; } $self->{description_line}->SetText($msg); } package Slic3r::GUI::Tab::Printer; use base 'Slic3r::GUI::Tab'; use Wx qw(wxTheApp :sizer :button :bitmap :misc :id :icon :dialog); use Wx::Event qw(EVT_BUTTON); sub name { 'printer' } sub title { 'Printer Settings' } sub build { my $self = shift; my (%params) = @_; $self->init_config_options(qw( bed_shape z_offset gcode_flavor use_relative_e_distances serial_port serial_speed octoprint_host octoprint_apikey use_firmware_retraction pressure_advance use_volumetric_e start_gcode end_gcode before_layer_gcode layer_gcode toolchange_gcode nozzle_diameter extruder_offset retract_length retract_lift retract_speed retract_restart_extra retract_before_travel retract_layer_change wipe retract_length_toolchange retract_restart_extra_toolchange )); $self->{config}->set('printer_settings_id', ''); my $bed_shape_widget = sub { my ($parent) = @_; my $btn = Wx::Button->new($parent, -1, "Set…", wxDefaultPosition, wxDefaultSize, wxBU_LEFT | wxBU_EXACTFIT); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("cog.png"), wxBITMAP_TYPE_PNG)); } my $sizer = Wx::BoxSizer->new(wxHORIZONTAL); $sizer->Add($btn); EVT_BUTTON($self, $btn, sub { my $dlg = Slic3r::GUI::BedShapeDialog->new($self, $self->{config}->bed_shape); if ($dlg->ShowModal == wxID_OK) { my $value = $dlg->GetValue; $self->{config}->set('bed_shape', $value); $self->update_dirty; $self->_on_value_change('bed_shape', $value); } }); return $sizer; }; $self->{extruders_count} = 1; { my $page = $self->add_options_page('General', 'printer_empty.png'); { my $optgroup = $page->new_optgroup('Size and coordinates'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Bed shape', widget => $bed_shape_widget, ); $optgroup->append_line($line); $optgroup->append_single_option_line('z_offset'); } { my $optgroup = $page->new_optgroup('Capabilities'); { my $option = Slic3r::GUI::OptionsGroup::Option->new( opt_id => 'extruders_count', type => 'i', default => 1, label => 'Extruders', tooltip => 'Number of extruders of the printer.', min => 1, ); $optgroup->append_single_option_line($option); } $optgroup->on_change(sub { my ($opt_id) = @_; if ($opt_id eq 'extruders_count') { wxTheApp->CallAfter(sub { $self->_extruders_count_changed($optgroup->get_value('extruders_count')); }); $self->update_dirty; } }); } if (!$params{no_controller}) { my $optgroup = $page->new_optgroup('USB/Serial connection'); my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Serial port', ); my $serial_port = $optgroup->get_option('serial_port'); $serial_port->side_widget(sub { my ($parent) = @_; my $btn = Wx::BitmapButton->new($parent, -1, Wx::Bitmap->new($Slic3r::var->("arrow_rotate_clockwise.png"), wxBITMAP_TYPE_PNG), wxDefaultPosition, wxDefaultSize, &Wx::wxBORDER_NONE); $btn->SetToolTipString("Rescan serial ports") if $btn->can('SetToolTipString'); EVT_BUTTON($self, $btn, \&_update_serial_ports); return $btn; }); my $serial_test = sub { my ($parent) = @_; my $btn = $self->{serial_test_btn} = Wx::Button->new($parent, -1, "Test", wxDefaultPosition, wxDefaultSize, wxBU_LEFT | wxBU_EXACTFIT); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("wrench.png"), wxBITMAP_TYPE_PNG)); } EVT_BUTTON($self, $btn, sub { my $sender = Slic3r::GCode::Sender->new; my $res = $sender->connect( $self->{config}->serial_port, $self->{config}->serial_speed, ); if ($res && $sender->wait_connected) { Slic3r::GUI::show_info($self, "Connection to printer works correctly.", "Success!"); } else { Slic3r::GUI::show_error($self, "Connection failed."); } }); return $btn; }; $line->append_option($serial_port); $line->append_option($optgroup->get_option('serial_speed')); $line->append_widget($serial_test); $optgroup->append_line($line); } { my $optgroup = $page->new_optgroup('OctoPrint upload'); # append two buttons to the Host line my $octoprint_host_browse = sub { my ($parent) = @_; my $btn = Wx::Button->new($parent, -1, "Browse…", wxDefaultPosition, wxDefaultSize, wxBU_LEFT); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("zoom.png"), wxBITMAP_TYPE_PNG)); } if (!eval "use Net::Bonjour; 1") { $btn->Disable; } EVT_BUTTON($self, $btn, sub { # look for devices my $entries; { my $res = Net::Bonjour->new('http'); $res->discover; $entries = [ $res->entries ]; } if (@{$entries}) { my $dlg = Slic3r::GUI::BonjourBrowser->new($self, $entries); if ($dlg->ShowModal == wxID_OK) { my $value = $dlg->GetValue . ":" . $dlg->GetPort; $self->{config}->set('octoprint_host', $value); $self->update_dirty; $self->_on_value_change('octoprint_host', $value); $self->reload_config; } } else { Wx::MessageDialog->new($self, 'No Bonjour device found', 'Device Browser', wxOK | wxICON_INFORMATION)->ShowModal; } }); return $btn; }; my $octoprint_host_test = sub { my ($parent) = @_; my $btn = $self->{octoprint_host_test_btn} = Wx::Button->new($parent, -1, "Test", wxDefaultPosition, wxDefaultSize, wxBU_LEFT | wxBU_EXACTFIT); $btn->SetFont($Slic3r::GUI::small_font); if ($Slic3r::GUI::have_button_icons) { $btn->SetBitmap(Wx::Bitmap->new($Slic3r::var->("wrench.png"), wxBITMAP_TYPE_PNG)); } EVT_BUTTON($self, $btn, sub { my $ua = LWP::UserAgent->new; $ua->timeout(10); my $res = $ua->get( "http://" . $self->{config}->octoprint_host . "/api/version", 'X-Api-Key' => $self->{config}->octoprint_apikey, ); if ($res->is_success) { Slic3r::GUI::show_info($self, "Connection to OctoPrint works correctly.", "Success!"); } else { Slic3r::GUI::show_error($self, "I wasn't able to connect to OctoPrint (" . $res->status_line . "). " . "Check hostname and OctoPrint version (at least 1.1.0 is required)."); } }); return $btn; }; my $host_line = $optgroup->create_single_option_line('octoprint_host'); $host_line->append_widget($octoprint_host_browse); $host_line->append_widget($octoprint_host_test); $optgroup->append_line($host_line); $optgroup->append_single_option_line('octoprint_apikey'); } { my $optgroup = $page->new_optgroup('Firmware'); $optgroup->append_single_option_line('gcode_flavor'); } { my $optgroup = $page->new_optgroup('Advanced'); $optgroup->append_single_option_line('use_relative_e_distances'); $optgroup->append_single_option_line('use_firmware_retraction'); $optgroup->append_single_option_line('use_volumetric_e'); $optgroup->append_single_option_line('pressure_advance'); } } { my $page = $self->add_options_page('Custom G-code', 'cog.png'); { my $optgroup = $page->new_optgroup('Start G-code', label_width => 0, ); my $option = $optgroup->get_option('start_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } { my $optgroup = $page->new_optgroup('End G-code', label_width => 0, ); my $option = $optgroup->get_option('end_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } { my $optgroup = $page->new_optgroup('Before layer change G-code', label_width => 0, ); my $option = $optgroup->get_option('before_layer_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } { my $optgroup = $page->new_optgroup('After layer change G-code', label_width => 0, ); my $option = $optgroup->get_option('layer_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } { my $optgroup = $page->new_optgroup('Tool change G-code', label_width => 0, ); my $option = $optgroup->get_option('toolchange_gcode'); $option->full_width(1); $option->height(150); $optgroup->append_single_option_line($option); } } $self->{extruder_pages} = []; $self->_build_extruder_pages; $self->_update_serial_ports if (!$params{no_controller}); } sub _update_serial_ports { my ($self) = @_; $self->get_field('serial_port')->set_values([ wxTheApp->scan_serial_ports ]); } sub _extruders_count_changed { my ($self, $extruders_count) = @_; $self->{extruders_count} = $extruders_count; $self->_build_extruder_pages; $self->_on_value_change('extruders_count', $extruders_count); $self->_update; } sub _extruder_options { qw(nozzle_diameter extruder_offset retract_length retract_lift retract_lift_above retract_lift_below retract_speed retract_restart_extra retract_before_travel wipe retract_layer_change retract_length_toolchange retract_restart_extra_toolchange) } sub _build_extruder_pages { my $self = shift; my $default_config = Slic3r::Config::Full->new; foreach my $extruder_idx (@{$self->{extruder_pages}} .. $self->{extruders_count}-1) { # extend options foreach my $opt_key ($self->_extruder_options) { my $values = $self->{config}->get($opt_key); if (!defined $values) { $values = [ $default_config->get_at($opt_key, 0) ]; } else { # use last extruder's settings for the new one my $last_value = $values->[-1]; $values->[$extruder_idx] //= $last_value; } $self->{config}->set($opt_key, $values) or die "Unable to extend $opt_key"; } # build page my $page = $self->{extruder_pages}[$extruder_idx] = $self->add_options_page("Extruder " . ($extruder_idx + 1), 'funnel.png'); { my $optgroup = $page->new_optgroup('Size'); $optgroup->append_single_option_line('nozzle_diameter', $extruder_idx); } { my $optgroup = $page->new_optgroup('Position (for multi-extruder printers)'); $optgroup->append_single_option_line('extruder_offset', $extruder_idx); } { my $optgroup = $page->new_optgroup('Retraction'); $optgroup->append_single_option_line($_, $extruder_idx) for qw(retract_length retract_lift); { my $line = Slic3r::GUI::OptionsGroup::Line->new( label => 'Only lift Z', ); $line->append_option($optgroup->get_option('retract_lift_above', $extruder_idx)); $line->append_option($optgroup->get_option('retract_lift_below', $extruder_idx)); $optgroup->append_line($line); } $optgroup->append_single_option_line($_, $extruder_idx) for qw(retract_speed retract_restart_extra retract_before_travel retract_layer_change wipe); } { my $optgroup = $page->new_optgroup('Retraction when tool is disabled (advanced settings for multi-extruder setups)'); $optgroup->append_single_option_line($_, $extruder_idx) for qw(retract_length_toolchange retract_restart_extra_toolchange); } } # remove extra pages if ($self->{extruders_count} <= $#{$self->{extruder_pages}}) { $_->Destroy for @{$self->{extruder_pages}}[$self->{extruders_count}..$#{$self->{extruder_pages}}]; splice @{$self->{extruder_pages}}, $self->{extruders_count}; } # remove extra config values foreach my $opt_key ($self->_extruder_options) { my $values = $self->{config}->get($opt_key); splice @$values, $self->{extruders_count} if $self->{extruders_count} <= $#$values; $self->{config}->set($opt_key, $values) or die "Unable to truncate $opt_key"; } # rebuild page list @{$self->{pages}} = ( (grep $_->{title} !~ /^Extruder \d+/, @{$self->{pages}}), @{$self->{extruder_pages}}[ 0 .. $self->{extruders_count}-1 ], ); $self->update_tree; } sub _update { my ($self) = @_; my $config = $self->{config}; my $serial_speed = $self->get_field('serial_speed'); if ($serial_speed) { $self->get_field('serial_speed')->toggle($config->get('serial_port')); if ($config->get('serial_speed') && $config->get('serial_port')) { $self->{serial_test_btn}->Enable; } else { $self->{serial_test_btn}->Disable; } } if ($config->get('octoprint_host') && eval "use LWP::UserAgent; 1") { $self->{octoprint_host_test_btn}->Enable; } else { $self->{octoprint_host_test_btn}->Disable; } $self->get_field('octoprint_apikey')->toggle($config->get('octoprint_host')); my $have_multiple_extruders = $self->{extruders_count} > 1; $self->get_field('toolchange_gcode')->toggle($have_multiple_extruders); for my $i (0 .. ($self->{extruders_count}-1)) { my $have_retract_length = $config->get_at('retract_length', $i) > 0; # when using firmware retraction, firmware decides retraction length $self->get_field('retract_length', $i)->toggle(!$config->use_firmware_retraction); # user can customize travel length if we have retraction length or we're using # firmware retraction $self->get_field('retract_before_travel', $i)->toggle($have_retract_length || $config->use_firmware_retraction); # user can customize other retraction options if retraction is enabled my $retraction = ($have_retract_length || $config->use_firmware_retraction); $self->get_field($_, $i)->toggle($retraction) for qw(retract_lift retract_layer_change); # retract lift above/below only applies if using retract lift $self->get_field($_, $i)->toggle($retraction && $config->get_at('retract_lift', $i) > 0) for qw(retract_lift_above retract_lift_below); # some options only apply when not using firmware retraction $self->get_field($_, $i)->toggle($retraction && !$config->use_firmware_retraction) for qw(retract_speed retract_restart_extra wipe); if ($config->use_firmware_retraction && $config->get_at('wipe', $i)) { my $dialog = Wx::MessageDialog->new($self, "The Wipe option is not available when using the Firmware Retraction mode.\n" . "\nShall I disable it in order to enable Firmware Retraction?", 'Firmware Retraction', wxICON_WARNING | wxYES | wxNO); my $new_conf = Slic3r::Config->new; if ($dialog->ShowModal() == wxID_YES) { my $wipe = $config->wipe; $wipe->[$i] = 0; $new_conf->set("wipe", $wipe); } else { $new_conf->set("use_firmware_retraction", 0); } $self->load_config($new_conf); } $self->get_field('retract_length_toolchange', $i)->toggle($have_multiple_extruders); my $toolchange_retraction = $config->get_at('retract_length_toolchange', $i) > 0; $self->get_field('retract_restart_extra_toolchange', $i)->toggle ($have_multiple_extruders && $toolchange_retraction); } } # this gets executed after preset is loaded and before GUI fields are updated sub on_preset_loaded { my $self = shift; # update the extruders count field { # update the GUI field according to the number of nozzle diameters supplied my $extruders_count = scalar @{ $self->{config}->nozzle_diameter }; $self->set_value('extruders_count', $extruders_count); $self->_extruders_count_changed($extruders_count); } } sub load_config_file { my $self = shift; $self->SUPER::load_config_file(@_); Slic3r::GUI::warning_catcher($self)->( "Your configuration was imported. However, Slic3r is currently only able to import settings " . "for the first defined filament. We recommend you don't use exported configuration files " . "for multi-extruder setups and rely on the built-in preset management system instead.") if @{ $self->{config}->nozzle_diameter } > 1; } package Slic3r::GUI::Tab::Page; use Wx qw(wxTheApp :misc :panel :sizer); use base 'Wx::ScrolledWindow'; sub new { my $class = shift; my ($parent, $title, $iconID) = @_; my $self = $class->SUPER::new($parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL); $self->{optgroups} = []; $self->{title} = $title; $self->{iconID} = $iconID; $self->SetScrollbars(1, 1, 1, 1); $self->{vsizer} = Wx::BoxSizer->new(wxVERTICAL); $self->SetSizer($self->{vsizer}); return $self; } sub new_optgroup { my ($self, $title, %params) = @_; my $optgroup = Slic3r::GUI::ConfigOptionsGroup->new( parent => $self, title => $title, config => $self->GetParent->{config}, label_width => $params{label_width} // 200, on_change => sub { my ($opt_key, $value) = @_; wxTheApp->CallAfter(sub { $self->GetParent->update_dirty; $self->GetParent->_on_value_change($opt_key, $value); }); }, ); push @{$self->{optgroups}}, $optgroup; $self->{vsizer}->Add($optgroup->sizer, 0, wxEXPAND | wxALL, 10); return $optgroup; } sub reload_config { my ($self) = @_; $_->reload_config for @{$self->{optgroups}}; } sub get_field { my ($self, $opt_key, $opt_index) = @_; foreach my $optgroup (@{ $self->{optgroups} }) { my $field = $optgroup->get_fieldc($opt_key, $opt_index); return $field if defined $field; } return undef; } sub set_value { my $self = shift; my ($opt_key, $value) = @_; my $changed = 0; foreach my $optgroup (@{$self->{optgroups}}) { $changed = 1 if $optgroup->set_value($opt_key, $value); } return $changed; } package Slic3r::GUI::SavePresetWindow; use Wx qw(:combobox :dialog :id :misc :sizer); use Wx::Event qw(EVT_BUTTON EVT_TEXT_ENTER); use base 'Wx::Dialog'; sub new { my $class = shift; my ($parent, %params) = @_; my $self = $class->SUPER::new($parent, -1, "Save preset", wxDefaultPosition, wxDefaultSize); my @values = @{$params{values}}; my $text = Wx::StaticText->new($self, -1, "Save " . lc($params{title}) . " as:", wxDefaultPosition, wxDefaultSize); $self->{combo} = Wx::ComboBox->new($self, -1, $params{default}, wxDefaultPosition, wxDefaultSize, \@values, wxTE_PROCESS_ENTER); my $buttons = $self->CreateStdDialogButtonSizer(wxOK | wxCANCEL); my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($text, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, 10); $sizer->Add($self->{combo}, 0, wxEXPAND | wxLEFT | wxRIGHT, 10); $sizer->Add($buttons, 0, wxEXPAND | wxBOTTOM | wxLEFT | wxRIGHT, 10); EVT_BUTTON($self, wxID_OK, \&accept); EVT_TEXT_ENTER($self, $self->{combo}, \&accept); $self->SetSizer($sizer); $sizer->SetSizeHints($self); return $self; } sub accept { my ($self, $event) = @_; if (($self->{chosen_name} = $self->{combo}->GetValue)) { if ($self->{chosen_name} !~ /^[^<>:\/\\|?*\"]+$/i) { Slic3r::GUI::show_error($self, "The supplied name is not valid; the following characters are not allowed: <>:/\|?*\""); } elsif ($self->{chosen_name} eq '- default -') { Slic3r::GUI::show_error($self, "The supplied name is not available."); } else { $self->EndModal(wxID_OK); } } } sub get_name { my $self = shift; return $self->{chosen_name}; } package Slic3r::GUI::Tab::Preset; use Moo; has 'default' => (is => 'ro', default => sub { 0 }); has 'external' => (is => 'ro', default => sub { 0 }); has 'name' => (is => 'rw', required => 1); has 'file' => (is => 'rw'); sub config { my ($self, $keys) = @_; if ($self->default) { # Perl class Slic3r::Config extends the C++ class Slic3r::DynamicPrintConfig return Slic3r::Config->new_from_defaults(@$keys); } else { if (!-e Slic3r::encode_path($self->file)) { Slic3r::GUI::show_error(undef, "The selected preset does not exist anymore (" . $self->file . ")."); return undef; } # apply preset values on top of defaults my $config = Slic3r::Config->new_from_defaults(@$keys); my $external_config = Slic3r::Config->load($self->file); $config->set($_, $external_config->get($_)) for grep $external_config->has($_), @$keys; return $config; } } 1; Slic3r-version_1.31.6/lib/Slic3r/Geometry.pm000066400000000000000000000446101301441720000205410ustar00rootroot00000000000000package Slic3r::Geometry; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our @EXPORT_OK = qw( PI X Y Z A B X1 Y1 X2 Y2 Z1 Z2 MIN MAX epsilon slope line_point_belongs_to_segment points_coincide distance_between_points normalize tan move_points_3D point_in_polygon point_in_segment segment_in_segment polyline_lines polygon_lines point_along_segment polygon_segment_having_point polygon_has_subsegment deg2rad rad2deg rotate_points move_points dot perp line_intersection bounding_box bounding_box_intersect angle3points chained_path chained_path_from collinear scale unscale rad2deg_dir bounding_box_center line_intersects_any douglas_peucker polyline_remove_short_segments normal triangle_normal polygon_is_convex scaled_epsilon bounding_box_3D size_3D size_2D convex_hull directions_parallel directions_parallel_within ); use constant PI => 4 * atan2(1, 1); use constant A => 0; use constant B => 1; use constant X1 => 0; use constant Y1 => 1; use constant X2 => 2; use constant Y2 => 3; use constant Z1 => 4; use constant Z2 => 5; use constant MIN => 0; use constant MAX => 1; our $parallel_degrees_limit = abs(deg2rad(0.1)); sub epsilon () { 1E-4 } sub scaled_epsilon () { epsilon / &Slic3r::SCALING_FACTOR } sub scale ($) { $_[0] / &Slic3r::SCALING_FACTOR } sub unscale ($) { $_[0] * &Slic3r::SCALING_FACTOR } sub tan { my ($angle) = @_; return (sin $angle) / (cos $angle); } sub slope { my ($line) = @_; return undef if abs($line->[B][X] - $line->[A][X]) < epsilon; # line is vertical return ($line->[B][Y] - $line->[A][Y]) / ($line->[B][X] - $line->[A][X]); } # this subroutine checks whether a given point may belong to a given # segment given the hypothesis that it belongs to the line containing # the segment sub line_point_belongs_to_segment { my ($point, $segment) = @_; #printf " checking whether %f,%f may belong to segment %f,%f - %f,%f\n", # @$point, map @$_, @$segment; my @segment_extents = ( [ sort { $a <=> $b } map $_->[X], @$segment ], [ sort { $a <=> $b } map $_->[Y], @$segment ], ); return 0 if $point->[X] < ($segment_extents[X][0] - epsilon) || $point->[X] > ($segment_extents[X][1] + epsilon); return 0 if $point->[Y] < ($segment_extents[Y][0] - epsilon) || $point->[Y] > ($segment_extents[Y][1] + epsilon); return 1; } sub points_coincide { my ($p1, $p2) = @_; return 1 if abs($p2->[X] - $p1->[X]) < epsilon && abs($p2->[Y] - $p1->[Y]) < epsilon; return 0; } sub distance_between_points { my ($p1, $p2) = @_; return sqrt((($p1->[X] - $p2->[X])**2) + ($p1->[Y] - $p2->[Y])**2); } # this will check whether a point is in a polygon regardless of polygon orientation sub point_in_polygon { my ($point, $polygon) = @_; my ($x, $y) = @$point; my $n = @$polygon; my @x = map $_->[X], @$polygon; my @y = map $_->[Y], @$polygon; # Derived from the comp.graphics.algorithms FAQ, # courtesy of Wm. Randolph Franklin my ($i, $j); my $side = 0; # 0 = outside; 1 = inside for ($i = 0, $j = $n - 1; $i < $n; $j = $i++) { if ( # If the y is between the (y-) borders... ($y[$i] <= $y && $y < $y[$j]) || ($y[$j] <= $y && $y < $y[$i]) and # ...the (x,y) to infinity line crosses the edge # from the ith point to the jth point... ($x < ($x[$j] - $x[$i]) * ($y - $y[$i]) / ($y[$j] - $y[$i]) + $x[$i]) ) { $side = not $side; # Jump the fence } } # if point is not in polygon, let's check whether it belongs to the contour if (!$side && 0) { return 1 if polygon_segment_having_point($polygon, $point); } return $side; } sub point_in_segment { my ($point, $line) = @_; my ($x, $y) = @$point; my $line_p = $line->pp; my @line_x = sort { $a <=> $b } $line_p->[A][X], $line_p->[B][X]; my @line_y = sort { $a <=> $b } $line_p->[A][Y], $line_p->[B][Y]; # check whether the point is in the segment bounding box return 0 unless $x >= ($line_x[0] - epsilon) && $x <= ($line_x[1] + epsilon) && $y >= ($line_y[0] - epsilon) && $y <= ($line_y[1] + epsilon); # if line is vertical, check whether point's X is the same as the line if ($line_p->[A][X] == $line_p->[B][X]) { return abs($x - $line_p->[A][X]) < epsilon ? 1 : 0; } # calculate the Y in line at X of the point my $y3 = $line_p->[A][Y] + ($line_p->[B][Y] - $line_p->[A][Y]) * ($x - $line_p->[A][X]) / ($line_p->[B][X] - $line_p->[A][X]); return abs($y3 - $y) < epsilon ? 1 : 0; } sub segment_in_segment { my ($needle, $haystack) = @_; # a segment is contained in another segment if its endpoints are contained return point_in_segment($needle->[A], $haystack) && point_in_segment($needle->[B], $haystack); } sub polyline_lines { my ($polyline) = @_; my @points = @$polyline; return map Slic3r::Line->new(@points[$_, $_+1]), 0 .. $#points-1; } sub polygon_lines { my ($polygon) = @_; return polyline_lines([ @$polygon, $polygon->[0] ]); } # given a segment $p1-$p2, get the point at $distance from $p1 along segment sub point_along_segment { my ($p1, $p2, $distance) = @_; my $point = [ @$p1 ]; my $line_length = sqrt( (($p2->[X] - $p1->[X])**2) + (($p2->[Y] - $p1->[Y])**2) ); for (X, Y) { if ($p1->[$_] != $p2->[$_]) { $point->[$_] = $p1->[$_] + ($p2->[$_] - $p1->[$_]) * $distance / $line_length; } } return Slic3r::Point->new(@$point); } # given a $polygon, return the (first) segment having $point sub polygon_segment_having_point { my ($polygon, $point) = @_; foreach my $line (@{ $polygon->lines }) { return $line if point_in_segment($point, $line); } return undef; } # return true if the given segment is contained in any edge of the polygon sub polygon_has_subsegment { my ($polygon, $segment) = @_; foreach my $line (polygon_lines($polygon)) { return 1 if segment_in_segment($segment, $line); } return 0; } # polygon must be simple (non complex) and ccw sub polygon_is_convex { my ($points) = @_; for (my $i = 0; $i <= $#$points; $i++) { my $angle = angle3points($points->[$i-1], $points->[$i-2], $points->[$i]); return 0 if $angle < PI; } return 1; } sub rotate_points { my ($radians, $center, @points) = @_; $center //= [0,0]; return map { [ $center->[X] + cos($radians) * ($_->[X] - $center->[X]) - sin($radians) * ($_->[Y] - $center->[Y]), $center->[Y] + cos($radians) * ($_->[Y] - $center->[Y]) + sin($radians) * ($_->[X] - $center->[X]), ] } @points; } sub move_points { my ($shift, @points) = @_; return map { my @p = @$_; Slic3r::Point->new($shift->[X] + $p[X], $shift->[Y] + $p[Y]); } @points; } sub move_points_3D { my ($shift, @points) = @_; return map [ $shift->[X] + $_->[X], $shift->[Y] + $_->[Y], $shift->[Z] + $_->[Z], ], @points; } sub normal { my ($line1, $line2) = @_; return [ ($line1->[Y] * $line2->[Z]) - ($line1->[Z] * $line2->[Y]), -($line2->[Z] * $line1->[X]) + ($line2->[X] * $line1->[Z]), ($line1->[X] * $line2->[Y]) - ($line1->[Y] * $line2->[X]), ]; } sub triangle_normal { my ($v1, $v2, $v3) = @_; my $u = [ map +($v2->[$_] - $v1->[$_]), (X,Y,Z) ]; my $v = [ map +($v3->[$_] - $v1->[$_]), (X,Y,Z) ]; return normal($u, $v); } sub normalize { my ($line) = @_; my $len = sqrt( ($line->[X]**2) + ($line->[Y]**2) + ($line->[Z]**2) ) or return [0, 0, 0]; # to avoid illegal division by zero return [ map $_ / $len, @$line ]; } # 2D dot product sub dot { my ($u, $v) = @_; return $u->[X] * $v->[X] + $u->[Y] * $v->[Y]; } # 2D perp product sub perp { my ($u, $v) = @_; return $u->[X] * $v->[Y] - $u->[Y] * $v->[X]; } sub line_intersects_any { my ($line, $lines) = @_; for (@$lines) { return 1 if line_intersection($line, $_, 1); } return 0; } sub line_intersection { my ($line1, $line2, $require_crossing) = @_; $require_crossing ||= 0; my $intersection = _line_intersection(map @$_, @$line1, @$line2); return (ref $intersection && $intersection->[1] == $require_crossing) ? $intersection->[0] : undef; } sub collinear { my ($line1, $line2, $require_overlapping) = @_; my $intersection = _line_intersection(map @$_, @$line1, @$line2); return 0 unless !ref($intersection) && ($intersection eq 'parallel collinear' || ($intersection eq 'parallel vertical' && abs($line1->[A][X] - $line2->[A][X]) < epsilon)); if ($require_overlapping) { my @box_a = bounding_box([ $line1->[0], $line1->[1] ]); my @box_b = bounding_box([ $line2->[0], $line2->[1] ]); return 0 unless bounding_box_intersect( 2, @box_a, @box_b ); } return 1; } sub _line_intersection { my ( $x0, $y0, $x1, $y1, $x2, $y2, $x3, $y3 ) = @_; my ($x, $y); # The as-yet-undetermined intersection point. my $dy10 = $y1 - $y0; # dyPQ, dxPQ are the coordinate differences my $dx10 = $x1 - $x0; # between the points P and Q. my $dy32 = $y3 - $y2; my $dx32 = $x3 - $x2; my $dy10z = abs( $dy10 ) < epsilon; # Is the difference $dy10 "zero"? my $dx10z = abs( $dx10 ) < epsilon; my $dy32z = abs( $dy32 ) < epsilon; my $dx32z = abs( $dx32 ) < epsilon; my $dyx10; # The slopes. my $dyx32; $dyx10 = $dy10 / $dx10 unless $dx10z; $dyx32 = $dy32 / $dx32 unless $dx32z; # Now we know all differences and the slopes; # we can detect horizontal/vertical special cases. # E.g., slope = 0 means a horizontal line. unless ( defined $dyx10 or defined $dyx32 ) { return "parallel vertical"; } elsif ( $dy10z and not $dy32z ) { # First line horizontal. $y = $y0; $x = $x2 + ( $y - $y2 ) * $dx32 / $dy32; } elsif ( not $dy10z and $dy32z ) { # Second line horizontal. $y = $y2; $x = $x0 + ( $y - $y0 ) * $dx10 / $dy10; } elsif ( $dx10z and not $dx32z ) { # First line vertical. $x = $x0; $y = $y2 + $dyx32 * ( $x - $x2 ); } elsif ( not $dx10z and $dx32z ) { # Second line vertical. $x = $x2; $y = $y0 + $dyx10 * ( $x - $x0 ); } elsif ( abs( $dyx10 - $dyx32 ) < epsilon ) { # The slopes are suspiciously close to each other. # Either we have parallel collinear or just parallel lines. # The bounding box checks have already weeded the cases # "parallel horizontal" and "parallel vertical" away. my $ya = $y0 - $dyx10 * $x0; my $yb = $y2 - $dyx32 * $x2; return "parallel collinear" if abs( $ya - $yb ) < epsilon; return "parallel"; } else { # None of the special cases matched. # We have a "honest" line intersection. $x = ($y2 - $y0 + $dyx10*$x0 - $dyx32*$x2)/($dyx10 - $dyx32); $y = $y0 + $dyx10 * ($x - $x0); } my $h10 = $dx10 ? ($x - $x0) / $dx10 : ($dy10 ? ($y - $y0) / $dy10 : 1); my $h32 = $dx32 ? ($x - $x2) / $dx32 : ($dy32 ? ($y - $y2) / $dy32 : 1); return [Slic3r::Point->new($x, $y), $h10 >= 0 && $h10 <= 1 && $h32 >= 0 && $h32 <= 1]; } # http://paulbourke.net/geometry/lineline2d/ sub _line_intersection2 { my ($line1, $line2) = @_; my $denom = ($line2->[B][Y] - $line2->[A][Y]) * ($line1->[B][X] - $line1->[A][X]) - ($line2->[B][X] - $line2->[A][X]) * ($line1->[B][Y] - $line1->[A][Y]); my $numerA = ($line2->[B][X] - $line2->[A][X]) * ($line1->[A][Y] - $line2->[A][Y]) - ($line2->[B][Y] - $line2->[A][Y]) * ($line1->[A][X] - $line2->[A][X]); my $numerB = ($line1->[B][X] - $line1->[A][X]) * ($line1->[A][Y] - $line2->[A][Y]) - ($line1->[B][Y] - $line1->[A][Y]) * ($line1->[A][X] - $line2->[A][X]); # are the lines coincident? if (abs($numerA) < epsilon && abs($numerB) < epsilon && abs($denom) < epsilon) { return Slic3r::Point->new( ($line1->[A][X] + $line1->[B][X]) / 2, ($line1->[A][Y] + $line1->[B][Y]) / 2, ); } # are the lines parallel? if (abs($denom) < epsilon) { return undef; } # is the intersection along the segments? my $muA = $numerA / $denom; my $muB = $numerB / $denom; if ($muA < 0 || $muA > 1 || $muB < 0 || $muB > 1) { return undef; } return Slic3r::Point->new( $line1->[A][X] + $muA * ($line1->[B][X] - $line1->[A][X]), $line1->[A][Y] + $muA * ($line1->[B][Y] - $line1->[A][Y]), ); } # 2D sub bounding_box { my ($points) = @_; my @x = map $_->x, @$points; my @y = map $_->y, @$points; #,, my @bb = (undef, undef, undef, undef); for (0..$#x) { $bb[X1] = $x[$_] if !defined $bb[X1] || $x[$_] < $bb[X1]; $bb[X2] = $x[$_] if !defined $bb[X2] || $x[$_] > $bb[X2]; $bb[Y1] = $y[$_] if !defined $bb[Y1] || $y[$_] < $bb[Y1]; $bb[Y2] = $y[$_] if !defined $bb[Y2] || $y[$_] > $bb[Y2]; } return @bb[X1,Y1,X2,Y2]; } sub bounding_box_center { my ($bounding_box) = @_; return Slic3r::Point->new( ($bounding_box->[X2] + $bounding_box->[X1]) / 2, ($bounding_box->[Y2] + $bounding_box->[Y1]) / 2, ); } sub size_2D { my @bounding_box = bounding_box(@_); return ( ($bounding_box[X2] - $bounding_box[X1]), ($bounding_box[Y2] - $bounding_box[Y1]), ); } # bounding_box_intersect($d, @a, @b) # Return true if the given bounding boxes @a and @b intersect # in $d dimensions. Used by line_intersection(). sub bounding_box_intersect { my ( $d, @bb ) = @_; # Number of dimensions and box coordinates. my @aa = splice( @bb, 0, 2 * $d ); # The first box. # (@bb is the second one.) # Must intersect in all dimensions. for ( my $i_min = 0; $i_min < $d; $i_min++ ) { my $i_max = $i_min + $d; # The index for the maximum. return 0 if ( $aa[ $i_max ] + epsilon ) < $bb[ $i_min ]; return 0 if ( $bb[ $i_max ] + epsilon ) < $aa[ $i_min ]; } return 1; } # 3D sub bounding_box_3D { my ($points) = @_; my @extents = (map [undef, undef], X,Y,Z); foreach my $point (@$points) { for (X,Y,Z) { $extents[$_][MIN] = $point->[$_] if !defined $extents[$_][MIN] || $point->[$_] < $extents[$_][MIN]; $extents[$_][MAX] = $point->[$_] if !defined $extents[$_][MAX] || $point->[$_] > $extents[$_][MAX]; } } return @extents; } sub size_3D { my ($points) = @_; my @extents = bounding_box_3D($points); return map $extents[$_][MAX] - $extents[$_][MIN], (X,Y,Z); } # this assumes a CCW rotation from $p2 to $p3 around $p1 sub angle3points { my ($p1, $p2, $p3) = @_; # p1 is the center my $angle = atan2($p2->[X] - $p1->[X], $p2->[Y] - $p1->[Y]) - atan2($p3->[X] - $p1->[X], $p3->[Y] - $p1->[Y]); # we only want to return only positive angles return $angle <= 0 ? $angle + 2*PI() : $angle; } sub polyline_remove_short_segments { my ($points, $min_length, $isPolygon) = @_; for (my $i = $isPolygon ? 0 : 1; $i < $#$points; $i++) { if (distance_between_points($points->[$i-1], $points->[$i]) < $min_length) { # we can remove $points->[$i] splice @$points, $i, 1; $i--; } } } sub douglas_peucker { my ($points, $tolerance) = @_; no warnings "recursion"; my $results = []; my $dmax = 0; my $index = 0; for my $i (1..$#$points) { my $d = $points->[$i]->distance_to(Slic3r::Line->new($points->[0], $points->[-1])); if ($d > $dmax) { $index = $i; $dmax = $d; } } if ($dmax >= $tolerance) { my $dp1 = douglas_peucker([ @$points[0..$index] ], $tolerance); $results = [ @$dp1[0..($#$dp1-1)], @{douglas_peucker([ @$points[$index..$#$points] ], $tolerance)}, ]; } else { $results = [ $points->[0], $points->[-1] ]; } return $results; } sub douglas_peucker2 { my ($points, $tolerance) = @_; my $anchor = 0; my $floater = $#$points; my @stack = (); my %keep = (); push @stack, [$anchor, $floater]; while (@stack) { ($anchor, $floater) = @{pop @stack}; # initialize line segment my ($anchor_x, $anchor_y, $seg_len); if (grep $points->[$floater][$_] != $points->[$anchor][$_], X, Y) { $anchor_x = $points->[$floater][X] - $points->[$anchor][X]; $anchor_y = $points->[$floater][Y] - $points->[$anchor][Y]; $seg_len = sqrt(($anchor_x ** 2) + ($anchor_y ** 2)); # get the unit vector $anchor_x /= $seg_len; $anchor_y /= $seg_len; } else { $anchor_x = $anchor_y = $seg_len = 0; } # inner loop: my $max_dist = 0; my $farthest = $anchor + 1; for my $i (($anchor + 1) .. $floater) { my $dist_to_seg = 0; # compare to anchor my $vecX = $points->[$i][X] - $points->[$anchor][X]; my $vecY = $points->[$i][Y] - $points->[$anchor][Y]; $seg_len = sqrt(($vecX ** 2) + ($vecY ** 2)); # dot product: my $proj = $vecX * $anchor_x + $vecY * $anchor_y; if ($proj < 0) { $dist_to_seg = $seg_len; } else { # compare to floater $vecX = $points->[$i][X] - $points->[$floater][X]; $vecY = $points->[$i][Y] - $points->[$floater][Y]; $seg_len = sqrt(($vecX ** 2) + ($vecY ** 2)); # dot product: $proj = $vecX * (-$anchor_x) + $vecY * (-$anchor_y); if ($proj < 0) { $dist_to_seg = $seg_len } else { # calculate perpendicular distance to line (pythagorean theorem): $dist_to_seg = sqrt(abs(($seg_len ** 2) - ($proj ** 2))); } if ($max_dist < $dist_to_seg) { $max_dist = $dist_to_seg; $farthest = $i; } } } if ($max_dist <= $tolerance) { # use line segment $keep{$_} = 1 for $anchor, $floater; } else { push @stack, [$anchor, $farthest]; push @stack, [$farthest, $floater]; } } return [ map $points->[$_], sort keys %keep ]; } 1; Slic3r-version_1.31.6/lib/Slic3r/Geometry/000077500000000000000000000000001301441720000201765ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/Geometry/Clipper.pm000066400000000000000000000006111301441720000221300ustar00rootroot00000000000000package Slic3r::Geometry::Clipper; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our @EXPORT_OK = qw(offset offset_ex diff_ex diff union_ex intersection_ex xor_ex JT_ROUND JT_MITER JT_SQUARE is_counter_clockwise union_pt offset2 offset2_ex intersection intersection_pl diff_pl union CLIPPER_OFFSET_SCALE union_pt_chained diff_ppl intersection_ppl); 1; Slic3r-version_1.31.6/lib/Slic3r/Layer.pm000066400000000000000000000013071301441720000200160ustar00rootroot00000000000000# Extends the C++ class Slic3r::Layer. package Slic3r::Layer; use strict; use warnings; # the following two were previously generated by Moo sub print { my $self = shift; return $self->object->print; } sub config { my $self = shift; return $self->object->config; } sub region { my $self = shift; my ($region_id) = @_; while ($self->region_count <= $region_id) { $self->add_region($self->object->print->get_region($self->region_count)); } return $self->get_region($region_id); } sub regions { my ($self) = @_; return [ map $self->get_region($_), 0..($self->region_count-1) ]; } package Slic3r::Layer::Support; our @ISA = qw(Slic3r::Layer); 1; Slic3r-version_1.31.6/lib/Slic3r/Line.pm000066400000000000000000000005571301441720000176370ustar00rootroot00000000000000package Slic3r::Line; use strict; use warnings; # a line is a two-points line use parent 'Slic3r::Polyline'; sub intersection { my $self = shift; my ($line, $require_crossing) = @_; return Slic3r::Geometry::line_intersection($self, $line, $require_crossing); } sub grow { my $self = shift; return Slic3r::Polyline->new(@$self)->grow(@_); } 1; Slic3r-version_1.31.6/lib/Slic3r/Model.pm000066400000000000000000000156141301441720000200100ustar00rootroot00000000000000# extends C++ class Slic3r::Model package Slic3r::Model; use List::Util qw(first max any); use Slic3r::Geometry qw(X Y Z move_points); sub read_from_file { my $class = shift; my ($input_file) = @_; my $model = $input_file =~ /\.stl$/i ? Slic3r::Format::STL->read_file($input_file) : $input_file =~ /\.obj$/i ? Slic3r::Format::OBJ->read_file($input_file) : $input_file =~ /\.amf(\.xml)?$/i ? Slic3r::Format::AMF->read_file($input_file) : die "Input file must have .stl, .obj or .amf(.xml) extension\n"; die "The supplied file couldn't be read because it's empty.\n" if $model->objects_count == 0; $_->set_input_file($input_file) for @{$model->objects}; return $model; } sub merge { my $class = shift; my @models = @_; my $new_model = ref($class) ? $class : $class->new; $new_model->add_object($_) for map @{$_->objects}, @models; return $new_model; } sub add_object { my $self = shift; if (@_ == 1) { # we have a Model::Object my ($object) = @_; return $self->_add_object_clone($object); } else { my (%args) = @_; my $new_object = $self->_add_object; $new_object->set_name($args{name}) if defined $args{name}; $new_object->set_input_file($args{input_file}) if defined $args{input_file}; $new_object->config->apply($args{config}) if defined $args{config}; $new_object->set_layer_height_ranges($args{layer_height_ranges}) if defined $args{layer_height_ranges}; $new_object->set_origin_translation($args{origin_translation}) if defined $args{origin_translation}; return $new_object; } } sub set_material { my $self = shift; my ($material_id, $attributes) = @_; my $material = $self->add_material($material_id); $material->apply($attributes // {}); return $material; } sub print_info { my $self = shift; $_->print_info for @{$self->objects}; } sub looks_like_multipart_object { my ($self) = @_; return 0 if $self->objects_count == 1; return 0 if any { $_->volumes_count > 1 } @{$self->objects}; return 0 if any { @{$_->config->get_keys} > 1 } @{$self->objects}; my %heights = map { $_ => 1 } map $_->mesh->bounding_box->z_min, map @{$_->volumes}, @{$self->objects}; return scalar(keys %heights) > 1; } sub convert_multipart_object { my ($self) = @_; my @objects = @{$self->objects}; my $object = $self->add_object( input_file => $objects[0]->input_file, ); foreach my $v (map @{$_->volumes}, @objects) { my $volume = $object->add_volume($v); $volume->set_name($v->object->name); } $object->add_instance($_) for map @{$_->instances}, @objects; $self->delete_object($_) for reverse 0..($self->objects_count-2); } # Extends C++ class Slic3r::ModelMaterial package Slic3r::Model::Material; sub apply { my ($self, $attributes) = @_; $self->set_attribute($_, $attributes{$_}) for keys %$attributes; } # Extends C++ class Slic3r::ModelObject package Slic3r::Model::Object; use File::Basename qw(basename); use List::Util qw(first sum); use Slic3r::Geometry qw(X Y Z rad2deg); sub add_volume { my $self = shift; my $new_volume; if (@_ == 1) { # we have a Model::Volume my ($volume) = @_; $new_volume = $self->_add_volume_clone($volume); if ($volume->material_id ne '') { # merge material attributes and config (should we rename materials in case of duplicates?) if (my $material = $volume->object->model->get_material($volume->material_id)) { my %attributes = %{ $material->attributes }; if ($self->model->has_material($volume->material_id)) { %attributes = (%attributes, %{ $self->model->get_material($volume->material_id)->attributes }) } my $new_material = $self->model->set_material($volume->material_id, {%attributes}); $new_material->config->apply($material->config); } } } else { my %args = @_; $new_volume = $self->_add_volume($args{mesh}); $new_volume->set_name($args{name}) if defined $args{name}; $new_volume->set_material_id($args{material_id}) if defined $args{material_id}; $new_volume->set_modifier($args{modifier}) if defined $args{modifier}; $new_volume->config->apply($args{config}) if defined $args{config}; } if ($new_volume->material_id ne '' && !defined $self->model->get_material($new_volume->material_id)) { # TODO: this should be a trigger on Volume::material_id $self->model->set_material($new_volume->material_id); } $self->invalidate_bounding_box; return $new_volume; } sub add_instance { my $self = shift; my %params = @_; if (@_ == 1) { # we have a Model::Instance my ($instance) = @_; return $self->_add_instance_clone($instance); } else { my (%args) = @_; my $new_instance = $self->_add_instance; $new_instance->set_rotation($args{rotation}) if defined $args{rotation}; $new_instance->set_scaling_factor($args{scaling_factor}) if defined $args{scaling_factor}; $new_instance->set_offset($args{offset}) if defined $args{offset}; return $new_instance; } } sub mesh_stats { my $self = shift; # TODO: sum values from all volumes return $self->volumes->[0]->mesh->stats; } sub print_info { my $self = shift; printf "Info about %s:\n", basename($self->input_file); printf " size: x=%.3f y=%.3f z=%.3f\n", @{$self->raw_mesh->bounding_box->size}; if (my $stats = $self->mesh_stats) { printf " number of facets: %d\n", $stats->{number_of_facets}; printf " number of shells: %d\n", $stats->{number_of_parts}; printf " volume: %.3f\n", $stats->{volume}; if ($self->needed_repair) { printf " needed repair: yes\n"; printf " degenerate facets: %d\n", $stats->{degenerate_facets}; printf " edges fixed: %d\n", $stats->{edges_fixed}; printf " facets removed: %d\n", $stats->{facets_removed}; printf " facets added: %d\n", $stats->{facets_added}; printf " facets reversed: %d\n", $stats->{facets_reversed}; printf " backwards edges: %d\n", $stats->{backwards_edges}; } else { printf " needed repair: no\n"; } } else { printf " number of facets: %d\n", scalar(map @{$_->facets}, grep !$_->modifier, @{$self->volumes}); } } 1; Slic3r-version_1.31.6/lib/Slic3r/Point.pm000066400000000000000000000010501301441720000200260ustar00rootroot00000000000000package Slic3r::Point; use strict; use warnings; sub new_scale { my $class = shift; return $class->new(map Slic3r::Geometry::scale($_), @_); } sub dump_perl { my $self = shift; return sprintf "[%s,%s]", @$self; } package Slic3r::Pointf; use strict; use warnings; sub new_unscale { my $class = shift; return $class->new(map Slic3r::Geometry::unscale($_), @_); } package Slic3r::Pointf3; use strict; use warnings; sub new_unscale { my $class = shift; return $class->new(map Slic3r::Geometry::unscale($_), @_); } 1; Slic3r-version_1.31.6/lib/Slic3r/Polygon.pm000066400000000000000000000017201301441720000203700ustar00rootroot00000000000000package Slic3r::Polygon; use strict; use warnings; # a polygon is a closed polyline. use parent 'Slic3r::Polyline'; use Slic3r::Geometry qw(PI); sub grow { my $self = shift; return $self->split_at_first_point->grow(@_); } # this method subdivides the polygon segments to that no one of them # is longer than the length provided sub subdivide { my $self = shift; my ($max_length) = @_; my @points = @$self; push @points, $points[0]; # append first point as this is a polygon my @new_points = shift @points; while (@points) { while ($new_points[-1]->distance_to($points[0]) > $max_length) { push @new_points, map Slic3r::Point->new(@$_), Slic3r::Geometry::point_along_segment($new_points[-1], $points[0], $max_length); } push @new_points, shift @points; } pop @new_points; # remove last point as it coincides with first one return Slic3r::Polygon->new(@new_points); } 1;Slic3r-version_1.31.6/lib/Slic3r/Polyline.pm000066400000000000000000000006431301441720000205370ustar00rootroot00000000000000package Slic3r::Polyline; use strict; use warnings; use Slic3r::Geometry qw(X Y); sub new_scale { my $class = shift; my @points = map { ref($_) eq 'Slic3r::Point' ? $_->pp : $_ } @_; return $class->new(map [ Slic3r::Geometry::scale($_->[X]), Slic3r::Geometry::scale($_->[Y]) ], @points); } sub dump_perl { my $self = shift; return sprintf "[%s]", join ',', map "[$_->[0],$_->[1]]", @$self; } 1; Slic3r-version_1.31.6/lib/Slic3r/Print.pm000066400000000000000000000437161301441720000200500ustar00rootroot00000000000000# The slicing work horse. # Extends C++ class Slic3r::Print package Slic3r::Print; use strict; use warnings; use File::Basename qw(basename fileparse); use File::Spec; use List::Util qw(min max first sum); use Slic3r::ExtrusionLoop ':roles'; use Slic3r::ExtrusionPath ':roles'; use Slic3r::Flow ':roles'; use Slic3r::Geometry qw(X Y Z X1 Y1 X2 Y2 MIN MAX PI scale unscale convex_hull); use Slic3r::Geometry::Clipper qw(diff_ex union_ex intersection_ex intersection offset offset2 union union_pt_chained JT_ROUND JT_SQUARE); use Slic3r::Print::State ':steps'; our $status_cb; sub set_status_cb { my ($class, $cb) = @_; $status_cb = $cb; } sub status_cb { return $status_cb // sub {}; } # this value is not supposed to be compared with $layer->id # since they have different semantics sub total_layer_count { my $self = shift; return max(map $_->total_layer_count, @{$self->objects}); } sub size { my $self = shift; return $self->bounding_box->size; } sub process { my ($self) = @_; $_->make_perimeters for @{$self->objects}; $_->infill for @{$self->objects}; $_->generate_support_material for @{$self->objects}; $self->make_skirt; $self->make_brim; # must come after make_skirt # time to make some statistics if (0) { eval "use Devel::Size"; print "MEMORY USAGE:\n"; printf " meshes = %.1fMb\n", List::Util::sum(map Devel::Size::total_size($_->meshes), @{$self->objects})/1024/1024; printf " layer slices = %.1fMb\n", List::Util::sum(map Devel::Size::total_size($_->slices), map @{$_->layers}, @{$self->objects})/1024/1024; printf " region slices = %.1fMb\n", List::Util::sum(map Devel::Size::total_size($_->slices), map @{$_->regions}, map @{$_->layers}, @{$self->objects})/1024/1024; printf " perimeters = %.1fMb\n", List::Util::sum(map Devel::Size::total_size($_->perimeters), map @{$_->regions}, map @{$_->layers}, @{$self->objects})/1024/1024; printf " fills = %.1fMb\n", List::Util::sum(map Devel::Size::total_size($_->fills), map @{$_->regions}, map @{$_->layers}, @{$self->objects})/1024/1024; printf " print object = %.1fMb\n", Devel::Size::total_size($self)/1024/1024; } if (0) { eval "use Slic3r::Test::SectionCut"; Slic3r::Test::SectionCut->new(print => $self)->export_svg("section_cut.svg"); } } sub export_gcode { my $self = shift; my %params = @_; # prerequisites $self->process; # output everything to a G-code file my $output_file = $self->expanded_output_filepath($params{output_file}); $self->status_cb->(90, "Exporting G-code" . ($output_file ? " to $output_file" : "")); $self->write_gcode($params{output_fh} || $output_file); # run post-processing scripts if (@{$self->config->post_process}) { $self->status_cb->(95, "Running post-processing scripts"); $self->config->setenv; for my $script (@{$self->config->post_process}) { Slic3r::debugf " '%s' '%s'\n", $script, $output_file; # -x doesn't return true on Windows except for .exe files if (($^O eq 'MSWin32') ? !(-e $script) : !(-x $script)) { die "The configured post-processing script is not executable: check permissions. ($script)\n"; } system($script, $output_file); } } } # Export SVG slices for the offline SLA printing. sub export_svg { my $self = shift; my %params = @_; $_->slice for @{$self->objects}; my $fh = $params{output_fh}; if (!$fh) { my $output_file = $self->expanded_output_filepath($params{output_file}); $output_file =~ s/\.gcode$/.svg/i; Slic3r::open(\$fh, ">", $output_file) or die "Failed to open $output_file for writing\n"; print "Exporting to $output_file..." unless $params{quiet}; } my $print_bb = $self->bounding_box; my $print_size = $print_bb->size; print $fh sprintf <<"EOF", unscale($print_size->[X]), unscale($print_size->[Y]); EOF my $print_polygon = sub { my ($polygon, $type) = @_; printf $fh qq{ \n}, $type, (join ' ', map { join ',', map unscale $_, @$_ } @$polygon), ($type eq 'contour' ? 'white' : 'black'); }; my @layers = sort { $a->print_z <=> $b->print_z } map { @{$_->layers}, @{$_->support_layers} } @{$self->objects}; my $layer_id = -1; my @previous_layer_slices = (); for my $layer (@layers) { $layer_id++; if ($layer->slice_z == -1) { printf $fh qq{ \n}, $layer_id; } else { printf $fh qq{ \n}, $layer_id, unscale($layer->slice_z); } my @current_layer_slices = (); # sort slices so that the outermost ones come first my @slices = sort { $a->contour->contains_point($b->contour->first_point) ? 0 : 1 } @{$layer->slices}; foreach my $copy (@{$layer->object->_shifted_copies}) { foreach my $slice (@slices) { my $expolygon = $slice->clone; $expolygon->translate(@$copy); $expolygon->translate(-$print_bb->x_min, -$print_bb->y_min); $print_polygon->($expolygon->contour, 'contour'); $print_polygon->($_, 'hole') for @{$expolygon->holes}; push @current_layer_slices, $expolygon; } } # generate support material if ($self->has_support_material && $layer->id > 0) { my (@supported_slices, @unsupported_slices) = (); foreach my $expolygon (@current_layer_slices) { my $intersection = intersection_ex( [ map @$_, @previous_layer_slices ], [ @$expolygon ], ); @$intersection ? push @supported_slices, $expolygon : push @unsupported_slices, $expolygon; } my @supported_points = map @$_, @$_, @supported_slices; foreach my $expolygon (@unsupported_slices) { # look for the nearest point to this island among all # supported points my $contour = $expolygon->contour; my $support_point = $contour->first_point->nearest_point(\@supported_points) or next; my $anchor_point = $support_point->nearest_point([ @$contour ]); printf $fh qq{ \n}, map @$_, $support_point, $anchor_point; } } print $fh qq{ \n}; @previous_layer_slices = @current_layer_slices; } print $fh "\n"; close $fh; print "Done.\n" unless $params{quiet}; } sub make_skirt { my $self = shift; # prerequisites $_->make_perimeters for @{$self->objects}; $_->infill for @{$self->objects}; $_->generate_support_material for @{$self->objects}; return if $self->step_done(STEP_SKIRT); $self->set_step_started(STEP_SKIRT); # since this method must be idempotent, we clear skirt paths *before* # checking whether we need to generate them $self->skirt->clear; if (!$self->has_skirt) { $self->set_step_done(STEP_SKIRT); return; } $self->status_cb->(88, "Generating skirt"); # First off we need to decide how tall the skirt must be. # The skirt_height option from config is expressed in layers, but our # object might have different layer heights, so we need to find the print_z # of the highest layer involved. # Note that unless has_infinite_skirt() == true # the actual skirt might not reach this $skirt_height_z value since the print # order of objects on each layer is not guaranteed and will not generally # include the thickest object first. It is just guaranteed that a skirt is # prepended to the first 'n' layers (with 'n' = skirt_height). # $skirt_height_z in this case is the highest possible skirt height for safety. my $skirt_height_z = -1; foreach my $object (@{$self->objects}) { my $skirt_height = $self->has_infinite_skirt ? $object->layer_count : min($self->config->skirt_height, $object->layer_count); my $highest_layer = $object->get_layer($skirt_height - 1); $skirt_height_z = max($skirt_height_z, $highest_layer->print_z); } # collect points from all layers contained in skirt height my @points = (); foreach my $object (@{$self->objects}) { my @object_points = (); # get object layers up to $skirt_height_z foreach my $layer (@{$object->layers}) { last if $layer->print_z > $skirt_height_z; push @object_points, map @$_, map @$_, @{$layer->slices}; } # get support layers up to $skirt_height_z foreach my $layer (@{$object->support_layers}) { last if $layer->print_z > $skirt_height_z; push @object_points, map @{$_->polyline}, @{$layer->support_fills} if $layer->support_fills; push @object_points, map @{$_->polyline}, @{$layer->support_interface_fills} if $layer->support_interface_fills; } # repeat points for each object copy foreach my $copy (@{$object->_shifted_copies}) { my @copy_points = map $_->clone, @object_points; $_->translate(@$copy) for @copy_points; push @points, @copy_points; } } return if @points < 3; # at least three points required for a convex hull # find out convex hull my $convex_hull = convex_hull(\@points); my @extruded_length = (); # for each extruder # skirt may be printed on several layers, having distinct layer heights, # but loops must be aligned so can't vary width/spacing # TODO: use each extruder's own flow my $first_layer_height = $self->skirt_first_layer_height; my $flow = $self->skirt_flow; my $spacing = $flow->spacing; my $mm3_per_mm = $flow->mm3_per_mm; my @extruders_e_per_mm = (); my $extruder_idx = 0; my $skirts = $self->config->skirts; $skirts ||= 1 if $self->has_infinite_skirt; # draw outlines from outside to inside # loop while we have less skirts than required or any extruder hasn't reached the min length if any my $distance = scale max($self->config->skirt_distance, $self->config->brim_width); for (my $i = $skirts; $i > 0; $i--) { $distance += scale $spacing; my $loop = offset([$convex_hull], $distance, 1, JT_ROUND, scale(0.1))->[0]; my $eloop = Slic3r::ExtrusionLoop->new_from_paths( Slic3r::ExtrusionPath->new( polyline => Slic3r::Polygon->new(@$loop)->split_at_first_point, role => EXTR_ROLE_SKIRT, mm3_per_mm => $mm3_per_mm, # this will be overridden at G-code export time width => $flow->width, height => $first_layer_height, # this will be overridden at G-code export time ), ); $eloop->role(EXTRL_ROLE_SKIRT); $self->skirt->append($eloop); if ($self->config->min_skirt_length > 0) { $extruded_length[$extruder_idx] ||= 0; if (!$extruders_e_per_mm[$extruder_idx]) { my $config = Slic3r::Config::GCode->new; $config->apply_static($self->config); my $extruder = Slic3r::Extruder->new($extruder_idx, $config); $extruders_e_per_mm[$extruder_idx] = $extruder->e_per_mm($mm3_per_mm); } $extruded_length[$extruder_idx] += unscale $loop->length * $extruders_e_per_mm[$extruder_idx]; $i++ if defined first { ($extruded_length[$_] // 0) < $self->config->min_skirt_length } 0 .. $#{$self->extruders}; if ($extruded_length[$extruder_idx] >= $self->config->min_skirt_length) { if ($extruder_idx < $#{$self->extruders}) { $extruder_idx++; next; } } } } $self->skirt->reverse; $self->set_step_done(STEP_SKIRT); } sub make_brim { my $self = shift; # prerequisites $_->make_perimeters for @{$self->objects}; $_->infill for @{$self->objects}; $_->generate_support_material for @{$self->objects}; $self->make_skirt; return if $self->step_done(STEP_BRIM); $self->set_step_started(STEP_BRIM); # since this method must be idempotent, we clear brim paths *before* # checking whether we need to generate them $self->brim->clear; if ($self->config->brim_width == 0) { $self->set_step_done(STEP_BRIM); return; } $self->status_cb->(88, "Generating brim"); # brim is only printed on first layer and uses perimeter extruder my $first_layer_height = $self->skirt_first_layer_height; my $flow = $self->brim_flow; my $mm3_per_mm = $flow->mm3_per_mm; my $grow_distance = $flow->scaled_width / 2; my @islands = (); # array of polygons foreach my $obj_idx (0 .. ($self->object_count - 1)) { my $object = $self->objects->[$obj_idx]; my $layer0 = $object->get_layer(0); my @object_islands = ( (map $_->contour, @{$layer0->slices}), ); if (@{ $object->support_layers }) { my $support_layer0 = $object->support_layers->[0]; push @object_islands, (map @{$_->polyline->grow($grow_distance)}, @{$support_layer0->support_fills}) if $support_layer0->support_fills; push @object_islands, (map @{$_->polyline->grow($grow_distance)}, @{$support_layer0->support_interface_fills}) if $support_layer0->support_interface_fills; } foreach my $copy (@{$object->_shifted_copies}) { push @islands, map { $_->translate(@$copy); $_ } map $_->clone, @object_islands; } } my @loops = (); my $num_loops = sprintf "%.0f", $self->config->brim_width / $flow->width; for my $i (reverse 1 .. $num_loops) { # JT_SQUARE ensures no vertex is outside the given offset distance # -0.5 because islands are not represented by their centerlines # (first offset more, then step back - reverse order than the one used for # perimeters because here we're offsetting outwards) push @loops, @{offset2(\@islands, ($i + 0.5) * $flow->scaled_spacing, -1.0 * $flow->scaled_spacing, 100000, JT_SQUARE)}; } $self->brim->append(map Slic3r::ExtrusionLoop->new_from_paths( Slic3r::ExtrusionPath->new( polyline => Slic3r::Polygon->new(@$_)->split_at_first_point, role => EXTR_ROLE_SKIRT, mm3_per_mm => $mm3_per_mm, width => $flow->width, height => $first_layer_height, ), ), reverse @{union_pt_chained(\@loops)}); $self->set_step_done(STEP_BRIM); } sub write_gcode { my $self = shift; my ($file) = @_; # open output gcode file if we weren't supplied a file-handle my $fh; if (ref $file eq 'IO::Scalar') { $fh = $file; } else { Slic3r::open(\$fh, ">", $file) or die "Failed to open $file for writing\n"; # enable UTF-8 output since user might have entered Unicode characters in fields like notes binmode $fh, ':utf8'; } my $exporter = Slic3r::Print::GCode->new( print => $self, fh => $fh, ); $exporter->export; # close our gcode file close $fh; } # this method will return the supplied input file path after expanding its # format variables with their values sub expanded_output_filepath { my $self = shift; my ($path) = @_; return undef if !@{$self->objects}; my $input_file = first { defined $_ } map $_->model_object->input_file, @{$self->objects}; return undef if !defined $input_file; my $filename = my $filename_base = basename($input_file); $filename_base =~ s/\.[^.]+$//; # without suffix # set filename in placeholder parser so that it's available also in custom G-code $self->placeholder_parser->set(input_filename => $filename); $self->placeholder_parser->set(input_filename_base => $filename_base); # set other variables from model object $self->placeholder_parser->set_multiple( scale => [ map $_->model_object->instances->[0]->scaling_factor * 100 . "%", @{$self->objects} ], ); if ($path && -d $path) { # if output path is an existing directory, we take that and append # the specified filename format $path = File::Spec->join($path, $self->config->output_filename_format); } elsif (!$path) { # if no explicit output file was defined, we take the input # file directory and append the specified filename format $path = (fileparse($input_file))[1] . $self->config->output_filename_format; } else { # path is a full path to a file so we use it as it is } # make sure we use an up-to-date timestamp $self->placeholder_parser->update_timestamp; return $self->placeholder_parser->process($path); } # Wrapper around the C++ Slic3r::Print::validate() # to produce a Perl exception without a hang-up on some Strawberry perls. sub validate { my $self = shift; my $err = $self->_validate; die $err . "\n" if (defined($err) && $err ne ''); } 1; Slic3r-version_1.31.6/lib/Slic3r/Print/000077500000000000000000000000001301441720000174775ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/Print/GCode.pm000066400000000000000000001016301301441720000210170ustar00rootroot00000000000000package Slic3r::Print::GCode; use Moo; has 'print' => (is => 'ro', required => 1, handles => [qw(objects placeholder_parser config)]); has 'fh' => (is => 'ro', required => 1); has '_gcodegen' => (is => 'rw'); has '_cooling_buffer' => (is => 'rw'); has '_spiral_vase' => (is => 'rw'); has '_arc_fitting' => (is => 'rw'); has '_pressure_regulator' => (is => 'rw'); has '_pressure_equalizer' => (is => 'rw'); has '_skirt_done' => (is => 'rw', default => sub { {} }); # print_z => 1 has '_brim_done' => (is => 'rw'); has '_second_layer_things_done' => (is => 'rw'); has '_last_obj_copy' => (is => 'rw'); use List::Util qw(first sum min max); use Slic3r::ExtrusionPath ':roles'; use Slic3r::Flow ':roles'; use Slic3r::Geometry qw(X Y scale unscale chained_path convex_hull); use Slic3r::Geometry::Clipper qw(JT_SQUARE union_ex offset); sub BUILD { my ($self) = @_; { # estimate the total number of layer changes # TODO: only do this when M73 is enabled my $layer_count; if ($self->config->complete_objects) { $layer_count = sum(map { $_->total_layer_count * @{$_->copies} } @{$self->objects}); } else { # if sequential printing is not enable, all copies of the same object share the same layer change command(s) $layer_count = sum(map { $_->total_layer_count } @{$self->objects}); } # set up our helper object: This is a C++ Slic3r::GCode instance. my $gcodegen = Slic3r::GCode->new; $self->_gcodegen($gcodegen); $gcodegen->set_placeholder_parser($self->placeholder_parser); # Tell the G-code generator, how many times the $gcodegen->change_layer() will be called. # $gcodegen->change_layer() in turn increments the progress bar status. $gcodegen->set_layer_count($layer_count); $gcodegen->set_enable_cooling_markers(1); $gcodegen->apply_print_config($self->config); $gcodegen->set_extruders($self->print->extruders); # initialize autospeed { # get the minimum cross-section used in the print my @mm3_per_mm = (); foreach my $object (@{$self->print->objects}) { foreach my $region_id (0..$#{$self->print->regions}) { my $region = $self->print->get_region($region_id); foreach my $layer (@{$object->layers}) { my $layerm = $layer->get_region($region_id); if ($region->config->get_abs_value('perimeter_speed') == 0 || $region->config->get_abs_value('small_perimeter_speed') == 0 || $region->config->get_abs_value('external_perimeter_speed') == 0 || $region->config->get_abs_value('bridge_speed') == 0) { push @mm3_per_mm, $layerm->perimeters->min_mm3_per_mm; } if ($region->config->get_abs_value('infill_speed') == 0 || $region->config->get_abs_value('solid_infill_speed') == 0 || $region->config->get_abs_value('top_solid_infill_speed') == 0 || $region->config->get_abs_value('bridge_speed') == 0) { push @mm3_per_mm, $layerm->fills->min_mm3_per_mm; } } } if ($object->config->get_abs_value('support_material_speed') == 0 || $object->config->get_abs_value('support_material_interface_speed') == 0) { foreach my $layer (@{$object->support_layers}) { push @mm3_per_mm, $layer->support_fills->min_mm3_per_mm; push @mm3_per_mm, $layer->support_interface_fills->min_mm3_per_mm; } } } # filter out 0-width segments @mm3_per_mm = grep $_ > 0.000001, @mm3_per_mm; if (@mm3_per_mm) { my $min_mm3_per_mm = min(@mm3_per_mm); # In order to honor max_print_speed we need to find a target volumetric # speed that we can use throughout the print. So we define this target # volumetric speed as the volumetric speed produced by printing the # smallest cross-section at the maximum speed: any larger cross-section # will need slower feedrates. my $volumetric_speed = $min_mm3_per_mm * $self->config->max_print_speed; # limit such volumetric speed with max_volumetric_speed if set if ($self->config->max_volumetric_speed > 0) { $volumetric_speed = min( $volumetric_speed, $self->config->max_volumetric_speed, ); } $gcodegen->set_volumetric_speed($volumetric_speed); } } } $self->_cooling_buffer(Slic3r::GCode::CoolingBuffer->new( config => $self->config, gcodegen => $self->_gcodegen, )); $self->_spiral_vase(Slic3r::GCode::SpiralVase->new(config => $self->config)) if $self->config->spiral_vase; $self->_arc_fitting(Slic3r::GCode::ArcFitting->new(config => $self->config)) if $self->config->gcode_arcs; $self->_pressure_regulator(Slic3r::GCode::PressureRegulator->new(config => $self->config)) if $self->config->pressure_advance > 0; $self->_pressure_equalizer(Slic3r::GCode::PressureEqualizer->new($self->config)) if ($self->config->max_volumetric_extrusion_rate_slope_positive > 0 || $self->config->max_volumetric_extrusion_rate_slope_negative > 0); $self->_gcodegen->set_enable_extrusion_role_markers(defined $self->_pressure_equalizer); } # Export a G-code for the complete print. sub export { my ($self) = @_; my $fh = $self->fh; my $gcodegen = $self->_gcodegen; # Write information on the generator. my @lt = localtime; printf $fh "; generated by Slic3r $Slic3r::VERSION on %04d-%02d-%02d at %02d:%02d:%02d\n\n", $lt[5] + 1900, $lt[4]+1, $lt[3], $lt[2], $lt[1], $lt[0]; # Write notes (content of the Print Settings tab -> Notes) print $fh "; $_\n" foreach split /\R/, $self->config->notes; print $fh "\n" if $self->config->notes; # Write some terse information on the slicing parameters. my $first_object = $self->objects->[0]; my $layer_height = $first_object->config->layer_height; for my $region_id (0..$#{$self->print->regions}) { my $region = $self->print->regions->[$region_id]; printf $fh "; external perimeters extrusion width = %.2fmm\n", $region->flow(FLOW_ROLE_EXTERNAL_PERIMETER, $layer_height, 0, 0, -1, $first_object)->width; printf $fh "; perimeters extrusion width = %.2fmm\n", $region->flow(FLOW_ROLE_PERIMETER, $layer_height, 0, 0, -1, $first_object)->width; printf $fh "; infill extrusion width = %.2fmm\n", $region->flow(FLOW_ROLE_INFILL, $layer_height, 0, 0, -1, $first_object)->width; printf $fh "; solid infill extrusion width = %.2fmm\n", $region->flow(FLOW_ROLE_SOLID_INFILL, $layer_height, 0, 0, -1, $first_object)->width; printf $fh "; top infill extrusion width = %.2fmm\n", $region->flow(FLOW_ROLE_TOP_SOLID_INFILL, $layer_height, 0, 0, -1, $first_object)->width; printf $fh "; support material extrusion width = %.2fmm\n", $self->objects->[0]->support_material_flow->width if $self->print->has_support_material; printf $fh "; first layer extrusion width = %.2fmm\n", $region->flow(FLOW_ROLE_PERIMETER, $layer_height, 0, 1, -1, $self->objects->[0])->width if $region->config->first_layer_extrusion_width; print $fh "\n"; } # prepare the helper object for replacing placeholders in custom G-code and output filename $self->placeholder_parser->update_timestamp; # disable fan print $fh $gcodegen->writer->set_fan(0, 1) if $self->config->cooling && $self->config->disable_fan_first_layers; # set bed temperature if ((my $temp = $self->config->first_layer_bed_temperature) && $self->config->start_gcode !~ /M(?:190|140)/i) { printf $fh $gcodegen->writer->set_bed_temperature($temp, 1); } # set extruder(s) temperature before and after start G-code $self->_print_first_layer_temperature(0); printf $fh "%s\n", $gcodegen->placeholder_parser->process($self->config->start_gcode); $self->_print_first_layer_temperature(1); # set other general things print $fh $gcodegen->preamble; # initialize a motion planner for object-to-object travel moves if ($self->config->avoid_crossing_perimeters) { my $distance_from_objects = scale 1; # compute the offsetted convex hull for each object and repeat it for each copy. my @islands_p = (); foreach my $object (@{$self->objects}) { # discard objects only containing thin walls (offset would fail on an empty polygon) my @polygons = map $_->contour, map @{$_->slices}, @{$object->layers}; next if !@polygons; # translate convex hull for each object copy and append it to the islands array foreach my $copy (@{ $object->_shifted_copies }) { my @copy_islands_p = map $_->clone, @polygons; $_->translate(@$copy) for @copy_islands_p; push @islands_p, @copy_islands_p; } } $gcodegen->avoid_crossing_perimeters->init_external_mp(union_ex(\@islands_p)); } # calculate wiping points if needed if ($self->config->ooze_prevention) { my @skirt_points = map @$_, map @$_, @{$self->print->skirt}; if (@skirt_points) { my $outer_skirt = convex_hull(\@skirt_points); my @skirts = (); foreach my $extruder_id (@{$self->print->extruders}) { my $extruder_offset = $self->config->get_at('extruder_offset', $extruder_id); push @skirts, my $s = $outer_skirt->clone; $s->translate(-scale($extruder_offset->x), -scale($extruder_offset->y)); #) } my $convex_hull = convex_hull([ map @$_, @skirts ]); $gcodegen->ooze_prevention->set_enable(1); $gcodegen->ooze_prevention->set_standby_points( [ map @{$_->equally_spaced_points(scale 10)}, @{offset([$convex_hull], scale 3)} ] ); if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output( "ooze_prevention.svg", red_polygons => \@skirts, polygons => [$outer_skirt], points => $gcodegen->ooze_prevention->standby_points, ); } } } # set initial extruder only after custom start G-code print $fh $gcodegen->set_extruder($self->print->extruders->[0]); # do all objects for each layer if ($self->config->complete_objects) { # print objects from the smallest to the tallest to avoid collisions # when moving onto next object starting point my @obj_idx = sort { $self->objects->[$a]->size->z <=> $self->objects->[$b]->size->z } 0..($self->print->object_count - 1); my $finished_objects = 0; for my $obj_idx (@obj_idx) { my $object = $self->objects->[$obj_idx]; for my $copy (@{ $self->objects->[$obj_idx]->_shifted_copies }) { # move to the origin position for the copy we're going to print. # this happens before Z goes down to layer 0 again, so that # no collision happens hopefully. if ($finished_objects > 0) { $gcodegen->set_origin(Slic3r::Pointf->new(map unscale $copy->[$_], X,Y)); $gcodegen->set_enable_cooling_markers(0); # we're not filtering these moves through CoolingBuffer $gcodegen->avoid_crossing_perimeters->set_use_external_mp_once(1); print $fh $gcodegen->retract; print $fh $gcodegen->travel_to( Slic3r::Point->new(0,0), EXTR_ROLE_NONE, 'move to origin position for next object', ); $gcodegen->set_enable_cooling_markers(1); # disable motion planner when traveling to first object point $gcodegen->avoid_crossing_perimeters->set_disable_once(1); } my @layers = sort { $a->print_z <=> $b->print_z } @{$object->layers}, @{$object->support_layers}; for my $layer (@layers) { # if we are printing the bottom layer of an object, and we have already finished # another one, set first layer temperatures. this happens before the Z move # is triggered, so machine has more time to reach such temperatures if ($layer->id == 0 && $finished_objects > 0) { printf $fh $gcodegen->writer->set_bed_temperature($self->config->first_layer_bed_temperature), if $self->config->first_layer_bed_temperature; $self->_print_first_layer_temperature(0); } $self->process_layer($layer, [$copy]); } $self->flush_filters; $finished_objects++; $self->_second_layer_things_done(0); } } } else { # order objects using a nearest neighbor search my @obj_idx = @{chained_path([ map Slic3r::Point->new(@{$_->_shifted_copies->[0]}), @{$self->objects} ])}; # sort layers by Z # All extrusion moves with the same top layer height are extruded uninterrupted, # object extrusion moves are performed first, then the support. my %layers = (); # print_z => [ [layers], [layers], [layers] ] by obj_idx foreach my $obj_idx (0 .. ($self->print->object_count - 1)) { my $object = $self->objects->[$obj_idx]; foreach my $layer (@{$object->layers}, @{$object->support_layers}) { $layers{ $layer->print_z } ||= []; $layers{ $layer->print_z }[$obj_idx] ||= []; push @{$layers{ $layer->print_z }[$obj_idx]}, $layer; } } foreach my $print_z (sort { $a <=> $b } keys %layers) { foreach my $obj_idx (@obj_idx) { foreach my $layer (@{ $layers{$print_z}[$obj_idx] // [] }) { $self->process_layer($layer, $layer->object->_shifted_copies); } } } $self->flush_filters; } # write end commands to file print $fh $gcodegen->retract; # TODO: process this retract through PressureRegulator in order to discharge fully print $fh $gcodegen->writer->set_fan(0); printf $fh "%s\n", $gcodegen->placeholder_parser->process($self->config->end_gcode); print $fh $gcodegen->writer->update_progress($gcodegen->layer_count, $gcodegen->layer_count, 1); # 100% print $fh $gcodegen->writer->postamble; # get filament stats $self->print->clear_filament_stats; $self->print->total_used_filament(0); $self->print->total_extruded_volume(0); foreach my $extruder (@{$gcodegen->writer->extruders}) { my $used_filament = $extruder->used_filament; my $extruded_volume = $extruder->extruded_volume; $self->print->set_filament_stats($extruder->id, $used_filament); printf $fh "; filament used = %.1fmm (%.1fcm3)\n", $used_filament, $extruded_volume/1000; $self->print->total_used_filament($self->print->total_used_filament + $used_filament); $self->print->total_extruded_volume($self->print->total_extruded_volume + $extruded_volume); } # append full config print $fh "\n"; foreach my $config ($self->print->config, $self->print->default_object_config, $self->print->default_region_config) { foreach my $opt_key (sort @{$config->get_keys}) { next if $Slic3r::Config::Options->{$opt_key}{shortcut}; printf $fh "; %s = %s\n", $opt_key, $config->serialize($opt_key); } } } sub _print_first_layer_temperature { my ($self, $wait) = @_; return if $self->config->start_gcode =~ /M(?:109|104)/i; for my $t (@{$self->print->extruders}) { my $temp = $self->config->get_at('first_layer_temperature', $t); $temp += $self->config->standby_temperature_delta if $self->config->ooze_prevention; printf {$self->fh} $self->_gcodegen->writer->set_temperature($temp, $wait, $t) if $temp > 0; } } # Called per object's layer. # First a $gcode string is collected, # then filtered and finally written to a file $fh. #FIXME If printing multiple objects at once, this incorrectly applies cooling logic to a single object's layer instead # of all the objects printed. sub process_layer { my $self = shift; my ($layer, $object_copies) = @_; my $gcode = ""; my $object = $layer->object; $self->_gcodegen->config->apply_static($object->config); # check whether we're going to apply spiralvase logic if (defined $self->_spiral_vase) { $self->_spiral_vase->enable( ($layer->id > 0 || $self->print->config->brim_width == 0) && ($layer->id >= $self->print->config->skirt_height && !$self->print->has_infinite_skirt) && !defined(first { $_->region->config->bottom_solid_layers > $layer->id } @{$layer->regions}) && !defined(first { $_->perimeters->items_count > 1 } @{$layer->regions}) && !defined(first { $_->fills->items_count > 0 } @{$layer->regions}) ); } # if we're going to apply spiralvase to this layer, disable loop clipping $self->_gcodegen->set_enable_loop_clipping(!defined $self->_spiral_vase || !$self->_spiral_vase->enable); if (!$self->_second_layer_things_done && $layer->id == 1) { for my $extruder (@{$self->_gcodegen->writer->extruders}) { my $temperature = $self->config->get_at('temperature', $extruder->id); $gcode .= $self->_gcodegen->writer->set_temperature($temperature, 0, $extruder->id) if $temperature && $temperature != $self->config->get_at('first_layer_temperature', $extruder->id); } $gcode .= $self->_gcodegen->writer->set_bed_temperature($self->print->config->bed_temperature) if $self->print->config->bed_temperature && $self->print->config->bed_temperature != $self->print->config->first_layer_bed_temperature; $self->_second_layer_things_done(1); } # set new layer - this will change Z and force a retraction if retract_layer_change is enabled if ($self->print->config->before_layer_gcode) { my $pp = $self->_gcodegen->placeholder_parser->clone; $pp->set('layer_num' => $self->_gcodegen->layer_index + 1); $pp->set('layer_z' => $layer->print_z); $gcode .= $pp->process($self->print->config->before_layer_gcode) . "\n"; } $gcode .= $self->_gcodegen->change_layer($layer->as_layer); # this will increase $self->_gcodegen->layer_index if ($self->print->config->layer_gcode) { my $pp = $self->_gcodegen->placeholder_parser->clone; $pp->set('layer_num' => $self->_gcodegen->layer_index); $pp->set('layer_z' => $layer->print_z); $gcode .= $pp->process($self->print->config->layer_gcode) . "\n"; } # extrude skirt along raft layers and normal object layers # (not along interlaced support material layers) if (((values %{$self->_skirt_done}) < $self->print->config->skirt_height || $self->print->has_infinite_skirt) && !$self->_skirt_done->{$layer->print_z} && (!$layer->isa('Slic3r::Layer::Support') || $layer->id < $object->config->raft_layers)) { $self->_gcodegen->set_origin(Slic3r::Pointf->new(0,0)); $self->_gcodegen->avoid_crossing_perimeters->set_use_external_mp(1); my @extruder_ids = map { $_->id } @{$self->_gcodegen->writer->extruders}; $gcode .= $self->_gcodegen->set_extruder($extruder_ids[0]); # skip skirt if we have a large brim if ($layer->id < $self->print->config->skirt_height || $self->print->has_infinite_skirt) { my $skirt_flow = $self->print->skirt_flow; # distribute skirt loops across all extruders my @skirt_loops = @{$self->print->skirt}; for my $i (0 .. $#skirt_loops) { # when printing layers > 0 ignore 'min_skirt_length' and # just use the 'skirts' setting; also just use the current extruder last if ($layer->id > 0) && ($i >= $self->print->config->skirts); my $extruder_id = $extruder_ids[($i/@extruder_ids) % @extruder_ids]; $gcode .= $self->_gcodegen->set_extruder($extruder_id) if $layer->id == 0; # adjust flow according to this layer's layer height my $loop = $skirt_loops[$i]->clone; { my $layer_skirt_flow = $skirt_flow->clone; $layer_skirt_flow->set_height($layer->height); my $mm3_per_mm = $layer_skirt_flow->mm3_per_mm; foreach my $path (@$loop) { $path->height($layer->height); $path->mm3_per_mm($mm3_per_mm); } } $gcode .= $self->_gcodegen->extrude_loop($loop, 'skirt', $object->config->support_material_speed); } } $self->_skirt_done->{$layer->print_z} = 1; $self->_gcodegen->avoid_crossing_perimeters->set_use_external_mp(0); # allow a straight travel move to the first object point if this is the first layer # (but don't in next layers) if ($layer->id == 0) { $self->_gcodegen->avoid_crossing_perimeters->set_disable_once(1); } } # extrude brim if (!$self->_brim_done) { $gcode .= $self->_gcodegen->set_extruder($self->print->regions->[0]->config->perimeter_extruder-1); $self->_gcodegen->set_origin(Slic3r::Pointf->new(0,0)); $self->_gcodegen->avoid_crossing_perimeters->set_use_external_mp(1); $gcode .= $self->_gcodegen->extrude_loop($_, 'brim', $object->config->support_material_speed) for @{$self->print->brim}; $self->_brim_done(1); $self->_gcodegen->avoid_crossing_perimeters->set_use_external_mp(0); # allow a straight travel move to the first object point $self->_gcodegen->avoid_crossing_perimeters->set_disable_once(1); } for my $copy (@$object_copies) { # when starting a new object, use the external motion planner for the first travel move $self->_gcodegen->avoid_crossing_perimeters->set_use_external_mp_once(1) if ($self->_last_obj_copy // '') ne "$copy"; $self->_last_obj_copy("$copy"); $self->_gcodegen->set_origin(Slic3r::Pointf->new(map unscale $copy->[$_], X,Y)); # extrude support material before other things because it might use a lower Z # and also because we avoid travelling on other things when printing it if ($layer->isa('Slic3r::Layer::Support')) { if ($layer->support_interface_fills->count > 0) { $gcode .= $self->_gcodegen->set_extruder($object->config->support_material_interface_extruder-1); $gcode .= $self->_gcodegen->extrude_path($_, 'support material interface', $object->config->get_abs_value('support_material_interface_speed')) for @{$layer->support_interface_fills->chained_path_from($self->_gcodegen->last_pos, 0)}; } if ($layer->support_fills->count > 0) { $gcode .= $self->_gcodegen->set_extruder($object->config->support_material_extruder-1); $gcode .= $self->_gcodegen->extrude_path($_, 'support material', $object->config->get_abs_value('support_material_speed')) for @{$layer->support_fills->chained_path_from($self->_gcodegen->last_pos, 0)}; } } # We now define a strategy for building perimeters and fills. The separation # between regions doesn't matter in terms of printing order, as we follow # another logic instead: # - we group all extrusions by extruder so that we minimize toolchanges # - we start from the last used extruder # - for each extruder, we group extrusions by island # - for each island, we extrude perimeters first, unless user set the infill_first # option # (Still, we have to keep track of regions because we need to apply their config) # group extrusions by extruder and then by island my %by_extruder = (); # extruder_id => [ { perimeters => \@perimeters, infill => \@infill } ] my $n_slices = $#{$layer->slices}; my @layer_surface_bboxes = (); for my $i (0 .. $n_slices) { push @layer_surface_bboxes, $layer->slices->[$i]->contour->bounding_box; } my $point_inside_surface = sub { my ($i, $point) = @_; my $bbox = $layer_surface_bboxes[$i]; return $point->x >= $bbox->x_min && $point->x < $bbox->x_max && $point->y >= $bbox->y_min && $point->y < $bbox->y_max && $layer->slices->[$i]->contour->contains_point($point); }; foreach my $region_id (0..($self->print->region_count-1)) { my $layerm = $layer->regions->[$region_id] or next; my $region = $self->print->get_region($region_id); # process perimeters { my $extruder_id = $region->config->perimeter_extruder-1; foreach my $perimeter_coll (@{$layerm->perimeters}) { next if $perimeter_coll->empty; # this shouldn't happen but first_point() would fail # init by_extruder item only if we actually use the extruder $by_extruder{$extruder_id} //= []; # $perimeter_coll is an ExtrusionPath::Collection object representing a single slice for my $i (0 .. $n_slices) { if ( # $perimeter_coll->first_point does not fit inside any slice $i == $n_slices # $perimeter_coll->first_point fits inside ith slice || $point_inside_surface->($i, $perimeter_coll->first_point)) { $by_extruder{$extruder_id}[$i] //= { perimeters => {} }; $by_extruder{$extruder_id}[$i]{perimeters}{$region_id} //= []; push @{ $by_extruder{$extruder_id}[$i]{perimeters}{$region_id} }, @$perimeter_coll; last; } } } } # process infill # $layerm->fills is a collection of Slic3r::ExtrusionPath::Collection objects (C++ class ExtrusionEntityCollection), # each one containing the ExtrusionPath objects of a certain infill "group" (also called "surface" # throughout the code). We can redefine the order of such Collections but we have to # do each one completely at once. foreach my $fill (@{$layerm->fills}) { next if $fill->empty; # this shouldn't happen but first_point() would fail # init by_extruder item only if we actually use the extruder my $extruder_id = $fill->[0]->is_solid_infill ? $region->config->solid_infill_extruder-1 : $region->config->infill_extruder-1; $by_extruder{$extruder_id} //= []; # $fill is an ExtrusionPath::Collection object for my $i (0 .. $n_slices) { if ($i == $n_slices || $point_inside_surface->($i, $fill->first_point)) { $by_extruder{$extruder_id}[$i] //= { infill => {} }; $by_extruder{$extruder_id}[$i]{infill}{$region_id} //= []; push @{ $by_extruder{$extruder_id}[$i]{infill}{$region_id} }, $fill; last; } } } } # for regions # tweak extruder ordering to save toolchanges my @extruders = sort keys %by_extruder; if (@extruders > 1) { my $last_extruder_id = $self->_gcodegen->writer->extruder->id; if (exists $by_extruder{$last_extruder_id}) { @extruders = ( $last_extruder_id, grep $_ != $last_extruder_id, @extruders, ); } } foreach my $extruder_id (@extruders) { $gcode .= $self->_gcodegen->set_extruder($extruder_id); foreach my $island (@{ $by_extruder{$extruder_id} }) { if ($self->print->config->infill_first) { $gcode .= $self->_extrude_infill($island->{infill} // {}); $gcode .= $self->_extrude_perimeters($island->{perimeters} // {}); } else { $gcode .= $self->_extrude_perimeters($island->{perimeters} // {}); $gcode .= $self->_extrude_infill($island->{infill} // {}); } } } } # for object copies # apply spiral vase post-processing if this layer contains suitable geometry # (we must feed all the G-code into the post-processor, including the first # bottom non-spiral layers otherwise it will mess with positions) # we apply spiral vase at this stage because it requires a full layer $gcode = $self->_spiral_vase->process_layer($gcode) if defined $self->_spiral_vase; # apply cooling logic; this may alter speeds $gcode = $self->_cooling_buffer->append( $gcode, $layer->object->ptr . ref($layer), # differentiate $obj_id between normal layers and support layers $layer->id, $layer->print_z, ) if defined $self->_cooling_buffer; $gcode = $self->filter($gcode); print {$self->fh} $gcode if defined($gcode); } # Extrude perimeters: Decide where to put seams (hide or align seams). sub _extrude_perimeters { my ($self, $entities_by_region) = @_; my $gcode = ""; foreach my $region_id (sort keys %$entities_by_region) { $self->_gcodegen->config->apply_static($self->print->get_region($region_id)->config); $gcode .= $self->_gcodegen->extrude($_, 'perimeter', -1) for @{ $entities_by_region->{$region_id} }; } return $gcode; } # Chain the paths hierarchically by a greedy algorithm to minimize a travel distance. sub _extrude_infill { my ($self, $entities_by_region) = @_; my $gcode = ""; foreach my $region_id (sort keys %$entities_by_region) { $self->_gcodegen->config->apply_static($self->print->get_region($region_id)->config); my $collection = Slic3r::ExtrusionPath::Collection->new(@{ $entities_by_region->{$region_id} }); for my $fill (@{$collection->chained_path_from($self->_gcodegen->last_pos, 0)}) { if ($fill->isa('Slic3r::ExtrusionPath::Collection')) { $gcode .= $self->_gcodegen->extrude($_, 'infill', -1) for @{$fill->chained_path_from($self->_gcodegen->last_pos, 0)}; } else { $gcode .= $self->_gcodegen->extrude($fill, 'infill', -1) ; } } } return $gcode; } sub flush_filters { my ($self) = @_; print {$self->fh} $self->filter($self->_cooling_buffer->flush, 1); } sub filter { my ($self, $gcode, $flush) = @_; $flush //= 0; # apply pressure regulation if enabled; # this depends on actual speeds $gcode = $self->_pressure_regulator->process($gcode, $flush) if defined $self->_pressure_regulator; # apply pressure equalization if enabled; # print "G-code before filter:\n", $gcode; $gcode = $self->_pressure_equalizer->process($gcode, $flush) if defined $self->_pressure_equalizer; # print "G-code after filter:\n", $gcode; # apply arc fitting if enabled; # this does not depend on speeds but changes G1 XY commands into G2/G2 IJ $gcode = $self->_arc_fitting->process($gcode) if defined $self->_arc_fitting; return $gcode; } 1; Slic3r-version_1.31.6/lib/Slic3r/Print/Object.pm000066400000000000000000001522701301441720000212520ustar00rootroot00000000000000package Slic3r::Print::Object; # extends c++ class Slic3r::PrintObject (Print.xsp) use strict; use warnings; use List::Util qw(min max sum first); use Slic3r::Flow ':roles'; use Slic3r::Geometry qw(X Y Z PI scale unscale chained_path epsilon); use Slic3r::Geometry::Clipper qw(diff diff_ex intersection intersection_ex union union_ex offset offset_ex offset2 offset2_ex intersection_ppl CLIPPER_OFFSET_SCALE JT_MITER); use Slic3r::Print::State ':steps'; use Slic3r::Surface ':types'; # If enabled, phases of prepare_infill will be written into SVG files to an "out" directory. our $SLIC3R_DEBUG_SLICE_PROCESSING = 0; sub region_volumes { my $self = shift; return [ map $self->get_region_volumes($_), 0..($self->region_count - 1) ]; } sub layers { my $self = shift; return [ map $self->get_layer($_), 0..($self->layer_count - 1) ]; } sub support_layers { my $self = shift; return [ map $self->get_support_layer($_), 0..($self->support_layer_count - 1) ]; } # 1) Decides Z positions of the layers, # 2) Initializes layers and their regions # 3) Slices the object meshes # 4) Slices the modifier meshes and reclassifies the slices of the object meshes by the slices of the modifier meshes # 5) Applies size compensation (offsets the slices in XY plane) # 6) Replaces bad slices by the slices reconstructed from the upper/lower layer # Resulting expolygons of layer regions are marked as Internal. # # this should be idempotent sub slice { my $self = shift; return if $self->step_done(STEP_SLICE); $self->set_step_started(STEP_SLICE); $self->print->status_cb->(10, "Processing triangulated mesh"); # init layers { $self->clear_layers; # make layers taking custom heights into account my $id = 0; my $print_z = 0; my $first_object_layer_height = -1; my $first_object_layer_distance = -1; # add raft layers if ($self->config->raft_layers > 0) { # Reserve object layers for the raft. Last layer of the raft is the contact layer. $id += $self->config->raft_layers; # Raise first object layer Z by the thickness of the raft itself # plus the extra distance required by the support material logic. #FIXME The last raft layer is the contact layer, which shall be printed with a bridging flow for ease of separation. Currently it is not the case. my $first_layer_height = $self->config->get_value('first_layer_height'); $print_z += $first_layer_height; # Use as large as possible layer height for the intermediate raft layers. my $support_material_layer_height; { my @nozzle_diameters = ( map $self->print->config->get_at('nozzle_diameter', $_), $self->config->support_material_extruder-1, $self->config->support_material_interface_extruder-1, ); $support_material_layer_height = 0.75 * min(@nozzle_diameters); } $print_z += $support_material_layer_height * ($self->config->raft_layers - 1); # compute the average of all nozzles used for printing the object #FIXME It is expected, that the 1st layer of the object is printed with a bridging flow over a full raft. Shall it not be vice versa? my $nozzle_diameter; { my @nozzle_diameters = ( map $self->print->config->get_at('nozzle_diameter', $_), @{$self->print->object_extruders} ); $nozzle_diameter = sum(@nozzle_diameters)/@nozzle_diameters; } $first_object_layer_distance = $self->_support_material->contact_distance($self->config->layer_height, $nozzle_diameter); # force first layer print_z according to the contact distance # (the loop below will raise print_z by such height) $first_object_layer_height = $first_object_layer_distance - $self->config->support_material_contact_distance; } # loop until we have at least one layer and the max slice_z reaches the object height my $slice_z = 0; my $height = 0; my $max_z = unscale($self->size->z); while (($slice_z - $height) <= $max_z) { # assign the default height to the layer according to the general settings $height = ($id == 0) ? $self->config->get_value('first_layer_height') : $self->config->layer_height; # look for an applicable custom range if (my $range = first { $_->[0] <= $slice_z && $_->[1] > $slice_z } @{$self->layer_height_ranges}) { $height = $range->[2]; # if user set custom height to zero we should just skip the range and resume slicing over it if ($height == 0) { $slice_z += $range->[1] - $range->[0]; next; } } if ($first_object_layer_height != -1 && !@{$self->layers}) { $height = $first_object_layer_height; $print_z += ($first_object_layer_distance - $height); } $print_z += $height; $slice_z += $height/2; ### Slic3r::debugf "Layer %d: height = %s; slice_z = %s; print_z = %s\n", $id, $height, $slice_z, $print_z; $self->add_layer($id, $height, $print_z, $slice_z); if ($self->layer_count >= 2) { my $lc = $self->layer_count; $self->get_layer($lc - 2)->set_upper_layer($self->get_layer($lc - 1)); $self->get_layer($lc - 1)->set_lower_layer($self->get_layer($lc - 2)); } $id++; $slice_z += $height/2; # add the other half layer } } # make sure all layers contain layer region objects for all regions my $regions_count = $self->print->region_count; foreach my $layer (@{ $self->layers }) { $layer->region($_) for 0 .. ($regions_count-1); } # get array of Z coordinates for slicing my @z = map $_->slice_z, @{$self->layers}; # slice all non-modifier volumes for my $region_id (0..($self->region_count - 1)) { my $expolygons_by_layer = $self->_slice_region($region_id, \@z, 0); for my $layer_id (0..$#$expolygons_by_layer) { my $layerm = $self->get_layer($layer_id)->regions->[$region_id]; $layerm->slices->clear; foreach my $expolygon (@{ $expolygons_by_layer->[$layer_id] }) { $layerm->slices->append(Slic3r::Surface->new( expolygon => $expolygon, surface_type => S_TYPE_INTERNAL, )); } } } # then slice all modifier volumes if ($self->region_count > 1) { for my $region_id (0..$self->region_count) { my $expolygons_by_layer = $self->_slice_region($region_id, \@z, 1); # loop through the other regions and 'steal' the slices belonging to this one for my $other_region_id (0..$self->region_count) { next if $other_region_id == $region_id; for my $layer_id (0..$#$expolygons_by_layer) { my $layerm = $self->get_layer($layer_id)->regions->[$region_id]; my $other_layerm = $self->get_layer($layer_id)->regions->[$other_region_id]; next if !defined $other_layerm; my $other_slices = [ map $_->p, @{$other_layerm->slices} ]; # Polygons my $my_parts = intersection_ex( $other_slices, [ map @$_, @{ $expolygons_by_layer->[$layer_id] } ], ); next if !@$my_parts; # append new parts to our region foreach my $expolygon (@$my_parts) { $layerm->slices->append(Slic3r::Surface->new( expolygon => $expolygon, surface_type => S_TYPE_INTERNAL, )); } # remove such parts from original region $other_layerm->slices->clear; $other_layerm->slices->append(Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNAL, )) for @{ diff_ex($other_slices, [ map @$_, @$my_parts ]) }; } } } } # remove last layer(s) if empty $self->delete_layer($self->layer_count - 1) while $self->layer_count && (!map @{$_->slices}, @{$self->get_layer($self->layer_count - 1)->regions}); foreach my $layer (@{ $self->layers }) { # apply size compensation if ($self->config->xy_size_compensation != 0) { my $delta = scale($self->config->xy_size_compensation); if (@{$layer->regions} == 1) { # single region my $layerm = $layer->regions->[0]; my $slices = [ map $_->p, @{$layerm->slices} ]; $layerm->slices->clear; $layerm->slices->append(Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNAL, )) for @{offset_ex($slices, $delta)}; } else { if ($delta < 0) { # multiple regions, shrinking # we apply the offset to the combined shape, then intersect it # with the original slices for each region my $slices = union([ map $_->p, map @{$_->slices}, @{$layer->regions} ]); $slices = offset($slices, $delta); foreach my $layerm (@{$layer->regions}) { my $this_slices = intersection_ex( $slices, [ map $_->p, @{$layerm->slices} ], ); $layerm->slices->clear; $layerm->slices->append(Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNAL, )) for @$this_slices; } } else { # multiple regions, growing # this is an ambiguous case, since it's not clear how to grow regions where they are going to overlap # so we give priority to the first one and so on for my $i (0..$#{$layer->regions}) { my $layerm = $layer->regions->[$i]; my $slices = offset_ex([ map $_->p, @{$layerm->slices} ], $delta); if ($i > 0) { $slices = diff_ex( [ map @$_, @$slices ], [ map $_->p, map @{$_->slices}, map $layer->regions->[$_], 0..($i-1) ], # slices of already processed regions ); } $layerm->slices->clear; $layerm->slices->append(Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNAL, )) for @$slices; } } } } # Merge all regions' slices to get islands, chain them by a shortest path. $layer->make_slices; } # detect slicing errors my $warning_thrown = 0; for my $i (0 .. ($self->layer_count - 1)) { my $layer = $self->get_layer($i); next unless $layer->slicing_errors; if (!$warning_thrown) { warn "The model has overlapping or self-intersecting facets. I tried to repair it, " . "however you might want to check the results or repair the input file and retry.\n"; $warning_thrown = 1; } # try to repair the layer surfaces by merging all contours and all holes from # neighbor layers Slic3r::debugf "Attempting to repair layer %d\n", $i; foreach my $region_id (0 .. ($layer->region_count - 1)) { my $layerm = $layer->region($region_id); my (@upper_surfaces, @lower_surfaces); for (my $j = $i+1; $j < $self->layer_count; $j++) { if (!$self->get_layer($j)->slicing_errors) { @upper_surfaces = @{$self->get_layer($j)->region($region_id)->slices}; last; } } for (my $j = $i-1; $j >= 0; $j--) { if (!$self->get_layer($j)->slicing_errors) { @lower_surfaces = @{$self->get_layer($j)->region($region_id)->slices}; last; } } my $union = union_ex([ map $_->expolygon->contour, @upper_surfaces, @lower_surfaces, ]); my $diff = diff_ex( [ map @$_, @$union ], [ map @{$_->expolygon->holes}, @upper_surfaces, @lower_surfaces, ], ); $layerm->slices->clear; $layerm->slices->append($_) for map Slic3r::Surface->new (expolygon => $_, surface_type => S_TYPE_INTERNAL), @$diff; } # update layer slices after repairing the single regions $layer->make_slices; } # remove empty layers from bottom while (@{$self->layers} && !@{$self->get_layer(0)->slices}) { $self->delete_layer(0); for (my $i = 0; $i <= $#{$self->layers}; $i++) { $self->get_layer($i)->set_id( $self->get_layer($i)->id-1 ); } } # simplify slices if required if ($self->print->config->resolution) { $self->_simplify_slices(scale($self->print->config->resolution)); } die "No layers were detected. You might want to repair your STL file(s) or check their size or thickness and retry.\n" if !@{$self->layers}; $self->set_typed_slices(0); $self->set_step_done(STEP_SLICE); } # called from slice() sub _slice_region { my ($self, $region_id, $z, $modifier) = @_; return [] if !@{$self->get_region_volumes($region_id)}; # compose mesh my $mesh; foreach my $volume_id (@{ $self->get_region_volumes($region_id) }) { my $volume = $self->model_object->volumes->[$volume_id]; next if $volume->modifier && !$modifier; next if !$volume->modifier && $modifier; if (defined $mesh) { $mesh->merge($volume->mesh); } else { $mesh = $volume->mesh->clone; } } return if !defined $mesh; # transform mesh # we ignore the per-instance transformations currently and only # consider the first one $self->model_object->instances->[0]->transform_mesh($mesh, 1); # align mesh to Z = 0 (it should be already aligned actually) and apply XY shift $mesh->translate((map unscale(-$_), @{$self->_copies_shift}), -$self->model_object->bounding_box->z_min); # perform actual slicing return $mesh->slice($z); } # 1) Merges typed region slices into stInternal type. # 2) Increases an "extra perimeters" counter at region slices where needed. # 3) Generates perimeters, gap fills and fill regions (fill regions of type stInternal). sub make_perimeters { my $self = shift; # prerequisites $self->slice; return if $self->step_done(STEP_PERIMETERS); $self->set_step_started(STEP_PERIMETERS); $self->print->status_cb->(20, "Generating perimeters"); # Merge region slices if they were split into types. # FIXME this is using a safety offset, so the region slices will be slightly bigger with each iteration. if ($self->typed_slices) { $_->merge_slices for @{$self->layers}; $self->set_typed_slices(0); $self->invalidate_step(STEP_PREPARE_INFILL); } # compare each layer to the one below, and mark those slices needing # one additional inner perimeter, like the top of domed objects- # this algorithm makes sure that at least one perimeter is overlapping # but we don't generate any extra perimeter if fill density is zero, as they would be floating # inside the object - infill_only_where_needed should be the method of choice for printing # hollow objects for my $region_id (0 .. ($self->print->region_count-1)) { my $region = $self->print->regions->[$region_id]; my $region_perimeters = $region->config->perimeters; next if !$region->config->extra_perimeters; next if $region_perimeters == 0; next if $region->config->fill_density == 0; for my $i (0 .. ($self->layer_count - 2)) { my $layerm = $self->get_layer($i)->get_region($region_id); my $upper_layerm = $self->get_layer($i+1)->get_region($region_id); my $upper_layerm_polygons = [ map $_->p, @{$upper_layerm->slices} ]; # Filter upper layer polygons in intersection_ppl by their bounding boxes? # my $upper_layerm_poly_bboxes= [ map $_->bounding_box, @{$upper_layerm_polygons} ]; my $total_loop_length = sum(map $_->length, @$upper_layerm_polygons) // 0; my $perimeter_spacing = $layerm->flow(FLOW_ROLE_PERIMETER)->scaled_spacing; my $ext_perimeter_flow = $layerm->flow(FLOW_ROLE_EXTERNAL_PERIMETER); my $ext_perimeter_width = $ext_perimeter_flow->scaled_width; my $ext_perimeter_spacing = $ext_perimeter_flow->scaled_spacing; foreach my $slice (@{$layerm->slices}) { while (1) { # compute the total thickness of perimeters my $perimeters_thickness = $ext_perimeter_width/2 + $ext_perimeter_spacing/2 + ($region_perimeters-1 + $slice->extra_perimeters) * $perimeter_spacing; # define a critical area where we don't want the upper slice to fall into # (it should either lay over our perimeters or outside this area) my $critical_area_depth = $perimeter_spacing*1.5; my $critical_area = diff( offset($slice->expolygon->arrayref, -$perimeters_thickness), offset($slice->expolygon->arrayref, -($perimeters_thickness + $critical_area_depth)), ); # check whether a portion of the upper slices falls inside the critical area my $intersection = intersection_ppl( $upper_layerm_polygons, $critical_area, ); # only add an additional loop if at least 30% of the slice loop would benefit from it my $total_intersection_length = sum(map $_->length, @$intersection) // 0; last unless $total_intersection_length > $total_loop_length*0.3; if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output( "extra.svg", no_arrows => 1, expolygons => union_ex($critical_area), polylines => [ map $_->split_at_first_point, map $_->p, @{$upper_layerm->slices} ], ); } $slice->extra_perimeters($slice->extra_perimeters + 1); } Slic3r::debugf " adding %d more perimeter(s) at layer %d\n", $slice->extra_perimeters, $layerm->layer->id if $slice->extra_perimeters > 0; } } } Slic3r::parallelize( threads => $self->print->config->threads, items => sub { 0 .. ($self->layer_count - 1) }, thread_cb => sub { my $q = shift; while (defined (my $i = $q->dequeue)) { $self->get_layer($i)->make_perimeters; } }, no_threads_cb => sub { $_->make_perimeters for @{$self->layers}; }, ); # simplify slices (both layer and region slices), # we only need the max resolution for perimeters ### This makes this method not-idempotent, so we keep it disabled for now. ###$self->_simplify_slices(&Slic3r::SCALED_RESOLUTION); $self->set_step_done(STEP_PERIMETERS); } sub prepare_infill { my ($self) = @_; # prerequisites $self->make_perimeters; return if $self->step_done(STEP_PREPARE_INFILL); $self->set_step_started(STEP_PREPARE_INFILL); $self->print->status_cb->(30, "Preparing infill"); # This will assign a type (top/bottom/internal) to $layerm->slices. # Then the classifcation of $layerm->slices is transfered onto # the $layerm->fill_surfaces by clipping $layerm->fill_surfaces # by the cummulative area of the previous $layerm->fill_surfaces. $self->detect_surfaces_type; # Mark the object to have the region slices classified (typed, which also means they are split based on whether they are supported, bridging, top layers etc.) $self->set_typed_slices(1); # Decide what surfaces are to be filled. # Here the S_TYPE_TOP / S_TYPE_BOTTOMBRIDGE / S_TYPE_BOTTOM infill is turned to just S_TYPE_INTERNAL if zero top / bottom infill layers are configured. # Also tiny S_TYPE_INTERNAL surfaces are turned to S_TYPE_INTERNAL_SOLID. $_->prepare_fill_surfaces for map @{$_->regions}, @{$self->layers}; # this will detect bridges and reverse bridges # and rearrange top/bottom/internal surfaces # It produces enlarged overlapping bridging areas. # # 1) S_TYPE_BOTTOMBRIDGE / S_TYPE_BOTTOM infill is grown by 3mm and clipped by the total infill area. Bridges are detected. The areas may overlap. # 2) S_TYPE_TOP is grown by 3mm and clipped by the grown bottom areas. The areas may overlap. # 3) Clip the internal surfaces by the grown top/bottom surfaces. # 4) Merge surfaces with the same style. This will mostly get rid of the overlaps. #FIXME This does not likely merge surfaces, which are supported by a material with different colors, but same properties. $self->process_external_surfaces; # Add solid fills to ensure the shell vertical thickness. $self->discover_vertical_shells; # Debugging output. if ($SLIC3R_DEBUG_SLICE_PROCESSING) { for my $region_id (0 .. ($self->print->region_count-1)) { for (my $i = 0; $i < $self->layer_count; $i++) { my $layerm = $self->get_layer($i)->regions->[$region_id]; $layerm->export_region_slices_to_svg_debug("6_discover_vertical_shells-final"); $layerm->export_region_fill_surfaces_to_svg_debug("6_discover_vertical_shells-final"); } # for each layer } # for each region } # Detect, which fill surfaces are near external layers. # They will be split in internal and internal-solid surfaces. # The purpose is to add a configurable number of solid layers to support the TOP surfaces # and to add a configurable number of solid layers above the BOTTOM / BOTTOMBRIDGE surfaces # to close these surfaces reliably. #FIXME Vojtech: Is this a good place to add supporting infills below sloping perimeters? $self->discover_horizontal_shells; if ($SLIC3R_DEBUG_SLICE_PROCESSING) { # Debugging output. for my $region_id (0 .. ($self->print->region_count-1)) { for (my $i = 0; $i < $self->layer_count; $i++) { my $layerm = $self->get_layer($i)->regions->[$region_id]; $layerm->export_region_slices_to_svg_debug("7_discover_horizontal_shells-final"); $layerm->export_region_fill_surfaces_to_svg_debug("7_discover_horizontal_shells-final"); } # for each layer } # for each region } # Only active if config->infill_only_where_needed. This step trims the sparse infill, # so it acts as an internal support. It maintains all other infill types intact. # Here the internal surfaces and perimeters have to be supported by the sparse infill. #FIXME The surfaces are supported by a sparse infill, but the sparse infill is only as large as the area to support. # Likely the sparse infill will not be anchored correctly, so it will not work as intended. # Also one wishes the perimeters to be supported by a full infill. $self->clip_fill_surfaces; if ($SLIC3R_DEBUG_SLICE_PROCESSING) { # Debugging output. for my $region_id (0 .. ($self->print->region_count-1)) { for (my $i = 0; $i < $self->layer_count; $i++) { my $layerm = $self->get_layer($i)->regions->[$region_id]; $layerm->export_region_slices_to_svg_debug("8_clip_surfaces-final"); $layerm->export_region_fill_surfaces_to_svg_debug("8_clip_surfaces-final"); } # for each layer } # for each region } # the following step needs to be done before combination because it may need # to remove only half of the combined infill $self->bridge_over_infill; # combine fill surfaces to honor the "infill every N layers" option $self->combine_infill; # Debugging output. if ($SLIC3R_DEBUG_SLICE_PROCESSING) { for my $region_id (0 .. ($self->print->region_count-1)) { for (my $i = 0; $i < $self->layer_count; $i++) { my $layerm = $self->get_layer($i)->regions->[$region_id]; $layerm->export_region_slices_to_svg_debug("9_prepare_infill-final"); $layerm->export_region_fill_surfaces_to_svg_debug("9_prepare_infill-final"); } # for each layer } # for each region for (my $i = 0; $i < $self->layer_count; $i++) { my $layer = $self->get_layer($i); $layer->export_region_slices_to_svg_debug("9_prepare_infill-final"); $layer->export_region_fill_surfaces_to_svg_debug("9_prepare_infill-final"); } # for each layer } $self->set_step_done(STEP_PREPARE_INFILL); } sub infill { my ($self) = @_; # prerequisites $self->prepare_infill; return if $self->step_done(STEP_INFILL); $self->set_step_started(STEP_INFILL); $self->print->status_cb->(70, "Infilling layers"); Slic3r::parallelize( threads => $self->print->config->threads, items => sub { 0..$#{$self->layers} }, thread_cb => sub { my $q = shift; while (defined (my $i = $q->dequeue)) { $self->get_layer($i)->make_fills; } }, no_threads_cb => sub { foreach my $layer (@{$self->layers}) { $layer->make_fills; } }, ); ### we could free memory now, but this would make this step not idempotent ### Vojtech: Cannot release the fill_surfaces, they are used by the support generator. ### $_->fill_surfaces->clear for map @{$_->regions}, @{$object->layers}; $self->set_step_done(STEP_INFILL); } sub generate_support_material { my $self = shift; # prerequisites $self->slice; return if $self->step_done(STEP_SUPPORTMATERIAL); $self->set_step_started(STEP_SUPPORTMATERIAL); $self->clear_support_layers; if ((!$self->config->support_material && $self->config->raft_layers == 0) || scalar(@{$self->layers}) < 2) { $self->set_step_done(STEP_SUPPORTMATERIAL); return; } $self->print->status_cb->(85, "Generating support material"); $self->_support_material->generate($self); $self->set_step_done(STEP_SUPPORTMATERIAL); } sub _support_material { my ($self) = @_; my $first_layer_flow = Slic3r::Flow->new_from_width( width => ($self->print->config->first_layer_extrusion_width || $self->config->support_material_extrusion_width), role => FLOW_ROLE_SUPPORT_MATERIAL, nozzle_diameter => $self->print->config->nozzle_diameter->[ $self->config->support_material_extruder-1 ] // $self->print->config->nozzle_diameter->[0], layer_height => $self->config->get_abs_value('first_layer_height'), bridge_flow_ratio => 0, ); if (1) { # Old supports, Perl implementation. return Slic3r::Print::SupportMaterial->new( print_config => $self->print->config, object_config => $self->config, first_layer_flow => $first_layer_flow, flow => $self->support_material_flow, interface_flow => $self->support_material_flow(FLOW_ROLE_SUPPORT_MATERIAL_INTERFACE), ); } else { # New supports, C++ implementation. return Slic3r::Print::SupportMaterial2->new($self); } } # Idempotence of this method is guaranteed by the fact that we don't remove things from # fill_surfaces but we only turn them into VOID surfaces, thus preserving the boundaries. sub clip_fill_surfaces { my $self = shift; return unless $self->config->infill_only_where_needed; # We only want infill under ceilings; this is almost like an # internal support material. # proceed top-down skipping bottom layer my $upper_internal = []; for my $layer_id (reverse 1..($self->layer_count - 1)) { my $layer = $self->get_layer($layer_id); my $lower_layer = $self->get_layer($layer_id-1); # detect things that we need to support my $overhangs = []; # Polygons # we need to support any solid surface push @$overhangs, map $_->p, grep $_->is_solid, map @{$_->fill_surfaces}, @{$layer->regions}; # we also need to support perimeters when there's at least one full # unsupported loop { # get perimeters area as the difference between slices and fill_surfaces my $perimeters = diff( [ map @$_, @{$layer->slices} ], [ map $_->p, map @{$_->fill_surfaces}, @{$layer->regions} ], ); # only consider the area that is not supported by lower perimeters $perimeters = intersection( $perimeters, [ map $_->p, map @{$_->fill_surfaces}, @{$lower_layer->regions} ], 1, ); # only consider perimeter areas that are at least one extrusion width thick #FIXME Offset2 eats out from both sides, while the perimeters are create outside in. #Should the $pw not be half of the current value? my $pw = min(map $_->flow(FLOW_ROLE_PERIMETER)->scaled_width, @{$layer->regions}); $perimeters = offset2($perimeters, -$pw, +$pw); # append such thick perimeters to the areas that need support push @$overhangs, @$perimeters; } # find new internal infill $upper_internal = my $new_internal = intersection( [ @$overhangs, @$upper_internal, ], [ # our current internal fill boundaries map $_->p, grep $_->surface_type == S_TYPE_INTERNAL || $_->surface_type == S_TYPE_INTERNALVOID, map @{$_->fill_surfaces}, @{$lower_layer->regions} ], ); # apply new internal infill to regions foreach my $layerm (@{$lower_layer->regions}) { my (@internal, @other) = (); foreach my $surface (map $_->clone, @{$layerm->fill_surfaces}) { if ($surface->surface_type == S_TYPE_INTERNAL || $surface->surface_type == S_TYPE_INTERNALVOID) { push @internal, $surface; } else { push @other, $surface; } } my @new = map Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNAL, ), @{intersection_ex( [ map $_->p, @internal ], $new_internal, 1, )}; push @other, map Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNALVOID, ), @{diff_ex( [ map $_->p, @internal ], $new_internal, 1, )}; # If there are voids it means that our internal infill is not adjacent to # perimeters. In this case it would be nice to add a loop around infill to # make it more robust and nicer. TODO. $layerm->fill_surfaces->clear; $layerm->fill_surfaces->append($_) for (@new, @other); if ($SLIC3R_DEBUG_SLICE_PROCESSING) { $layerm->export_region_fill_surfaces_to_svg_debug("6_clip_fill_surfaces"); } } } } sub discover_horizontal_shells { my $self = shift; Slic3r::debugf "==> DISCOVERING HORIZONTAL SHELLS\n"; for my $region_id (0 .. ($self->print->region_count-1)) { for (my $i = 0; $i < $self->layer_count; $i++) { my $layerm = $self->get_layer($i)->regions->[$region_id]; if ($layerm->region->config->solid_infill_every_layers && $layerm->region->config->fill_density > 0 && ($i % $layerm->region->config->solid_infill_every_layers) == 0) { # This is the layer to put the sparse infill in. Mark S_TYPE_INTERNAL surfaces as S_TYPE_INTERNALSOLID or S_TYPE_INTERNALBRIDGE. # If the sparse infill is not active, the internal surfaces are of type S_TYPE_INTERNAL. my $type = $layerm->region->config->fill_density == 100 ? S_TYPE_INTERNALSOLID : S_TYPE_INTERNALBRIDGE; $_->surface_type($type) for @{$layerm->fill_surfaces->filter_by_type(S_TYPE_INTERNAL)}; } # If ensure_vertical_shell_thickness, then the rest has already been performed by discover_vertical_shells(). next if ($layerm->region->config->ensure_vertical_shell_thickness); EXTERNAL: foreach my $type (S_TYPE_TOP, S_TYPE_BOTTOM, S_TYPE_BOTTOMBRIDGE) { # find slices of current type for current layer # use slices instead of fill_surfaces because they also include the perimeter area # which needs to be propagated in shells; we need to grow slices like we did for # fill_surfaces though. Using both ungrown slices and grown fill_surfaces will # not work in some situations, as there won't be any grown region in the perimeter # area (this was seen in a model where the top layer had one extra perimeter, thus # its fill_surfaces were thinner than the lower layer's infill), however it's the best # solution so far. Growing the external slices by EXTERNAL_INFILL_MARGIN will put # too much solid infill inside nearly-vertical slopes. my $solid = [ # Surfaces including the area of perimeters. Everything, that is visible from the top / bottom # (not covered by a layer above / below). # This does not contain the areas covered by perimeters! (map $_->p, @{$layerm->slices->filter_by_type($type)}), # Infill areas (slices without the perimeters). (map $_->p, @{$layerm->fill_surfaces->filter_by_type($type)}), ]; next if !@$solid; Slic3r::debugf "Layer %d has %s surfaces\n", $i, ($type == S_TYPE_TOP) ? 'top' : 'bottom'; my $solid_layers = ($type == S_TYPE_TOP) ? $layerm->region->config->top_solid_layers : $layerm->region->config->bottom_solid_layers; NEIGHBOR: for (my $n = ($type == S_TYPE_TOP) ? $i-1 : $i+1; abs($n - $i) < $solid_layers; ($type == S_TYPE_TOP) ? $n-- : $n++) { next if $n < 0 || $n >= $self->layer_count; Slic3r::debugf " looking for neighbors on layer %d...\n", $n; # Reference to the lower layer of a TOP surface, or an upper layer of a BOTTOM surface. my $neighbor_layerm = $self->get_layer($n)->regions->[$region_id]; # Reference to the neighbour fill surfaces. my $neighbor_fill_surfaces = $neighbor_layerm->fill_surfaces; # Clone because we will use these surfaces even after clearing the collection. my @neighbor_fill_surfaces = map $_->clone, @$neighbor_fill_surfaces; # find intersection between neighbor and current layer's surfaces # intersections have contours and holes # we update $solid so that we limit the next neighbor layer to the areas that were # found on this one - in other words, solid shells on one layer (for a given external surface) # are always a subset of the shells found on the previous shell layer # this approach allows for DWIM in hollow sloping vases, where we want bottom # shells to be generated in the base but not in the walls (where there are many # narrow bottom surfaces): reassigning $solid will consider the 'shadow' of the # upper perimeter as an obstacle and shell will not be propagated to more upper layers #FIXME How does it work for S_TYPE_INTERNALBRIDGE? This is set for sparse infill. Likely this does not work. my $new_internal_solid = $solid = intersection( $solid, [ map $_->p, grep { ($_->surface_type == S_TYPE_INTERNAL) || ($_->surface_type == S_TYPE_INTERNALSOLID) } @neighbor_fill_surfaces ], 1, ); next EXTERNAL if !@$new_internal_solid; if ($layerm->region->config->fill_density == 0) { # if we're printing a hollow object we discard any solid shell thinner # than a perimeter width, since it's probably just crossing a sloping wall # and it's not wanted in a hollow print even if it would make sense when # obeying the solid shell count option strictly (DWIM!) my $margin = $neighbor_layerm->flow(FLOW_ROLE_EXTERNAL_PERIMETER)->scaled_width; my $regularized = offset2($new_internal_solid, -$margin, +$margin, CLIPPER_OFFSET_SCALE, JT_MITER, 5); my $too_narrow = diff( $new_internal_solid, $regularized, 1, ); # Trim the regularized region by the original region. $new_internal_solid = $solid = intersection( $new_internal_solid, $regularized, ) if @$too_narrow; } # make sure the new internal solid is wide enough, as it might get collapsed # when spacing is added in Fill.pm if ($layerm->region->config->ensure_vertical_shell_thickness) { # The possible thin sickles of top / bottom surfaces on steeply sloping surfaces touch # the projections of top / bottom perimeters, therefore they will be sufficiently inflated by # merging them with the projections of the top / bottom perimeters. } else { #FIXME Vojtech: Disable this and you will be sorry. # https://github.com/prusa3d/Slic3r/issues/26 bottom my $margin = 3 * $layerm->flow(FLOW_ROLE_SOLID_INFILL)->scaled_width; # require at least this size # we use a higher miterLimit here to handle areas with acute angles # in those cases, the default miterLimit would cut the corner and we'd # get a triangle in $too_narrow; if we grow it below then the shell # would have a different shape from the external surface and we'd still # have the same angle, so the next shell would be grown even more and so on. my $too_narrow = diff( $new_internal_solid, offset2($new_internal_solid, -$margin, +$margin, CLIPPER_OFFSET_SCALE, JT_MITER, 5), 1, ); if (@$too_narrow) { # grow the collapsing parts and add the extra area to the neighbor layer # as well as to our original surfaces so that we support this # additional area in the next shell too # make sure our grown surfaces don't exceed the fill area my @grown = @{intersection( offset($too_narrow, +$margin), # Discard bridges as they are grown for anchoring and we can't # remove such anchors. (This may happen when a bridge is being # anchored onto a wall where little space remains after the bridge # is grown, and that little space is an internal solid shell so # it triggers this too_narrow logic.) [ map $_->p, grep { $_->is_internal && !$_->is_bridge } @neighbor_fill_surfaces ], )}; $new_internal_solid = $solid = [ @grown, @$new_internal_solid ]; } } # internal-solid are the union of the existing internal-solid surfaces # and new ones my $internal_solid = union_ex([ ( map $_->p, grep $_->surface_type == S_TYPE_INTERNALSOLID, @neighbor_fill_surfaces ), @$new_internal_solid, ]); # subtract intersections from layer surfaces to get resulting internal surfaces my $internal = diff_ex( [ map $_->p, grep $_->surface_type == S_TYPE_INTERNAL, @neighbor_fill_surfaces ], [ map @$_, @$internal_solid ], 1, ); Slic3r::debugf " %d internal-solid and %d internal surfaces found\n", scalar(@$internal_solid), scalar(@$internal); # assign resulting internal surfaces to layer $neighbor_fill_surfaces->clear; $neighbor_fill_surfaces->append($_) for map Slic3r::Surface->new(expolygon => $_, surface_type => S_TYPE_INTERNAL), @$internal; # assign new internal-solid surfaces to layer $neighbor_fill_surfaces->append($_) for map Slic3r::Surface->new(expolygon => $_, surface_type => S_TYPE_INTERNALSOLID), @$internal_solid; # assign top and bottom surfaces to layer foreach my $s (@{Slic3r::Surface::Collection->new(grep { ($_->surface_type == S_TYPE_TOP) || $_->is_bottom } @neighbor_fill_surfaces)->group}) { my $solid_surfaces = diff_ex( [ map $_->p, @$s ], [ map @$_, @$internal_solid, @$internal ], 1, ); $neighbor_fill_surfaces->append($_) for map $s->[0]->clone(expolygon => $_), @$solid_surfaces; } } } # foreach my $type (S_TYPE_TOP, S_TYPE_BOTTOM, S_TYPE_BOTTOMBRIDGE) } # for each layer } # for each region # Debugging output. if ($SLIC3R_DEBUG_SLICE_PROCESSING) { for my $region_id (0 .. ($self->print->region_count-1)) { for (my $i = 0; $i < $self->layer_count; $i++) { my $layerm = $self->get_layer($i)->regions->[$region_id]; $layerm->export_region_slices_to_svg_debug("5_discover_horizontal_shells"); $layerm->export_region_fill_surfaces_to_svg_debug("5_discover_horizontal_shells"); } # for each layer } # for each region } } # combine fill surfaces across layers to honor the "infill every N layers" option # Idempotence of this method is guaranteed by the fact that we don't remove things from # fill_surfaces but we only turn them into VOID surfaces, thus preserving the boundaries. sub combine_infill { my $self = shift; # define the type used for voids my %voidtype = ( &S_TYPE_INTERNAL() => S_TYPE_INTERNALVOID, ); # work on each region separately for my $region_id (0 .. ($self->print->region_count-1)) { my $region = $self->print->get_region($region_id); my $every = $region->config->infill_every_layers; next unless $every > 1 && $region->config->fill_density > 0; # limit the number of combined layers to the maximum height allowed by this regions' nozzle my $nozzle_diameter = min( $self->print->config->get_at('nozzle_diameter', $region->config->infill_extruder-1), $self->print->config->get_at('nozzle_diameter', $region->config->solid_infill_extruder-1), ); # define the combinations my %combine = (); # layer_idx => number of additional combined lower layers { my $current_height = my $layers = 0; for my $layer_idx (0 .. ($self->layer_count-1)) { my $layer = $self->get_layer($layer_idx); next if $layer->id == 0; # skip first print layer (which may not be first layer in array because of raft) my $height = $layer->height; # check whether the combination of this layer with the lower layers' buffer # would exceed max layer height or max combined layer count if ($current_height + $height >= $nozzle_diameter + epsilon || $layers >= $every) { # append combination to lower layer $combine{$layer_idx-1} = $layers; $current_height = $layers = 0; } $current_height += $height; $layers++; } # append lower layers (if any) to uppermost layer $combine{$self->layer_count-1} = $layers; } # loop through layers to which we have assigned layers to combine for my $layer_idx (sort keys %combine) { next unless $combine{$layer_idx} > 1; # get all the LayerRegion objects to be combined my @layerms = map $self->get_layer($_)->get_region($region_id), ($layer_idx - ($combine{$layer_idx}-1) .. $layer_idx); # only combine internal infill for my $type (S_TYPE_INTERNAL) { # we need to perform a multi-layer intersection, so let's split it in pairs # initialize the intersection with the candidates of the lowest layer my $intersection = [ map $_->expolygon, @{$layerms[0]->fill_surfaces->filter_by_type($type)} ]; # start looping from the second layer and intersect the current intersection with it for my $layerm (@layerms[1 .. $#layerms]) { $intersection = intersection_ex( [ map @$_, @$intersection ], [ map @{$_->expolygon}, @{$layerm->fill_surfaces->filter_by_type($type)} ], ); } my $area_threshold = $layerms[0]->infill_area_threshold; @$intersection = grep $_->area > $area_threshold, @$intersection; next if !@$intersection; Slic3r::debugf " combining %d %s regions from layers %d-%d\n", scalar(@$intersection), ($type == S_TYPE_INTERNAL ? 'internal' : 'internal-solid'), $layer_idx-($every-1), $layer_idx; # $intersection now contains the regions that can be combined across the full amount of layers # so let's remove those areas from all layers my @intersection_with_clearance = map @{$_->offset( $layerms[-1]->flow(FLOW_ROLE_SOLID_INFILL)->scaled_width / 2 + $layerms[-1]->flow(FLOW_ROLE_PERIMETER)->scaled_width / 2 # Because fill areas for rectilinear and honeycomb are grown # later to overlap perimeters, we need to counteract that too. + (($type == S_TYPE_INTERNALSOLID || $region->config->fill_pattern =~ /(rectilinear|grid|line|honeycomb)/) ? $layerms[-1]->flow(FLOW_ROLE_SOLID_INFILL)->scaled_width : 0) )}, @$intersection; foreach my $layerm (@layerms) { my @this_type = @{$layerm->fill_surfaces->filter_by_type($type)}; my @other_types = map $_->clone, grep $_->surface_type != $type, @{$layerm->fill_surfaces}; my @new_this_type = map Slic3r::Surface->new(expolygon => $_, surface_type => $type), @{diff_ex( [ map $_->p, @this_type ], [ @intersection_with_clearance ], )}; # apply surfaces back with adjusted depth to the uppermost layer if ($layerm->layer->id == $self->get_layer($layer_idx)->id) { push @new_this_type, map Slic3r::Surface->new( expolygon => $_, surface_type => $type, thickness => sum(map $_->layer->height, @layerms), thickness_layers => scalar(@layerms), ), @$intersection; } else { # save void surfaces push @new_this_type, map Slic3r::Surface->new(expolygon => $_, surface_type => $voidtype{$type}), @{intersection_ex( [ map @{$_->expolygon}, @this_type ], [ @intersection_with_clearance ], )}; } $layerm->fill_surfaces->clear; $layerm->fill_surfaces->append($_) for (@new_this_type, @other_types); } } } } } # Simplify the sliced model, if "resolution" configuration parameter > 0. # The simplification is problematic, because it simplifies the slices independent from each other, # which makes the simplified discretization visible on the object surface. sub _simplify_slices { my ($self, $distance) = @_; foreach my $layer (@{$self->layers}) { $layer->slices->simplify($distance); $_->slices->simplify($distance) for @{$layer->regions}; } } sub support_material_flow { my ($self, $role) = @_; $role //= FLOW_ROLE_SUPPORT_MATERIAL; my $extruder = ($role == FLOW_ROLE_SUPPORT_MATERIAL) ? $self->config->support_material_extruder : $self->config->support_material_interface_extruder; # we use a bogus layer_height because we use the same flow for all # support material layers return Slic3r::Flow->new_from_width( width => $self->config->support_material_extrusion_width || $self->config->extrusion_width, role => $role, nozzle_diameter => $self->print->config->nozzle_diameter->[$extruder-1] // $self->print->config->nozzle_diameter->[0], layer_height => $self->config->layer_height, bridge_flow_ratio => 0, ); } 1; Slic3r-version_1.31.6/lib/Slic3r/Print/Simple.pm000066400000000000000000000065111301441720000212710ustar00rootroot00000000000000# A simple wrapper to quickly print a single model without a GUI. # Used by the command line slic3r.pl, by command line utilities pdf-slic3s.pl and view-toolpaths.pl, # and by the quick slice menu of the Slic3r GUI. # # It creates and owns an instance of Slic3r::Print to perform the slicing # and it accepts an instance of Slic3r::Model from the outside. package Slic3r::Print::Simple; use Moo; use Slic3r::Geometry qw(X Y); has '_print' => ( is => 'ro', default => sub { Slic3r::Print->new }, handles => [qw(apply_config extruders expanded_output_filepath total_used_filament total_extruded_volume placeholder_parser process)], ); has 'duplicate' => ( is => 'rw', default => sub { 1 }, ); has 'scale' => ( is => 'rw', default => sub { 1 }, ); has 'rotate' => ( is => 'rw', default => sub { 0 }, ); has 'duplicate_grid' => ( is => 'rw', default => sub { [1,1] }, ); has 'status_cb' => ( is => 'rw', default => sub { sub {} }, ); has 'print_center' => ( is => 'rw', default => sub { Slic3r::Pointf->new(100,100) }, ); has 'dont_arrange' => ( is => 'rw', default => sub { 0 }, ); has 'output_file' => ( is => 'rw', ); sub set_model { # $model is of type Slic3r::Model my ($self, $model) = @_; # make method idempotent so that the object is reusable $self->_print->clear_objects; # make sure all objects have at least one defined instance my $need_arrange = $model->add_default_instances && ! $self->dont_arrange; # apply scaling and rotation supplied from command line if any foreach my $instance (map @{$_->instances}, @{$model->objects}) { $instance->set_scaling_factor($instance->scaling_factor * $self->scale); $instance->set_rotation($instance->rotation + $self->rotate); } if ($self->duplicate_grid->[X] > 1 || $self->duplicate_grid->[Y] > 1) { $model->duplicate_objects_grid($self->duplicate_grid->[X], $self->duplicate_grid->[Y], $self->_print->config->duplicate_distance); } elsif ($need_arrange) { $model->duplicate_objects($self->duplicate, $self->_print->config->min_object_distance); } elsif ($self->duplicate > 1) { # if all input objects have defined position(s) apply duplication to the whole model $model->duplicate($self->duplicate, $self->_print->config->min_object_distance); } $_->translate(0,0,-$_->bounding_box->z_min) for @{$model->objects}; $model->center_instances_around_point($self->print_center) if (! $self->dont_arrange); foreach my $model_object (@{$model->objects}) { $self->_print->auto_assign_extruders($model_object); $self->_print->add_model_object($model_object); } } sub _before_export { my ($self) = @_; $self->_print->set_status_cb($self->status_cb); $self->_print->validate; } sub _after_export { my ($self) = @_; $self->_print->set_status_cb(undef); } sub export_gcode { my ($self) = @_; $self->_before_export; $self->_print->export_gcode(output_file => $self->output_file); $self->_after_export; } sub export_svg { my ($self) = @_; $self->_before_export; $self->_print->export_svg(output_file => $self->output_file); $self->_after_export; } 1; Slic3r-version_1.31.6/lib/Slic3r/Print/State.pm000066400000000000000000000005451301441720000211210ustar00rootroot00000000000000# Wraps C++ enums Slic3r::PrintStep and Slic3r::PrintObjectStep package Slic3r::Print::State; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our @EXPORT_OK = qw(STEP_SLICE STEP_PERIMETERS STEP_PREPARE_INFILL STEP_INFILL STEP_SUPPORTMATERIAL STEP_SKIRT STEP_BRIM); our %EXPORT_TAGS = (steps => \@EXPORT_OK); 1; Slic3r-version_1.31.6/lib/Slic3r/Print/SupportMaterial.pm000066400000000000000000001334211301441720000231740ustar00rootroot00000000000000# Instantiated by Slic3r::Print::Object->_support_material() # only generate() and contact_distance() are called from the outside of this module. package Slic3r::Print::SupportMaterial; use Moo; use List::Util qw(sum min max); use Slic3r::ExtrusionPath ':roles'; use Slic3r::Flow ':roles'; use Slic3r::Geometry qw(epsilon scale scaled_epsilon PI rad2deg deg2rad convex_hull); use Slic3r::Geometry::Clipper qw(offset diff union union_ex intersection offset_ex offset2 intersection_pl offset2_ex diff_pl CLIPPER_OFFSET_SCALE JT_MITER JT_ROUND); use Slic3r::Surface ':types'; has 'print_config' => (is => 'rw', required => 1); has 'object_config' => (is => 'rw', required => 1); has 'flow' => (is => 'rw', required => 1); has 'first_layer_flow' => (is => 'rw', required => 1); has 'interface_flow' => (is => 'rw', required => 1); use constant DEBUG_CONTACT_ONLY => 0; # increment used to reach MARGIN in steps to avoid trespassing thin objects use constant MARGIN_STEP => MARGIN/3; # generate a tree-like structure to save material use constant PILLAR_SIZE => 2.5; use constant PILLAR_SPACING => 10; sub generate { # $object is Slic3r::Print::Object my ($self, $object) = @_; # Determine the top surfaces of the support, defined as: # contact = overhangs - clearance + margin # This method is responsible for identifying what contact surfaces # should the support material expose to the object in order to guarantee # that it will be effective, regardless of how it's built below. my ($contact, $overhang) = $self->contact_area($object); # Determine the top surfaces of the object. We need these to determine # the layer heights of support material and to clip support to the object # silhouette. my ($top) = $self->object_top($object, $contact); # We now know the upper and lower boundaries for our support material object # (@$contact_z and @$top_z), so we can generate intermediate layers. my $support_z = $self->support_layers_z( [ sort keys %$contact ], [ sort keys %$top ], max(map $_->height, @{$object->layers}) ); # If we wanted to apply some special logic to the first support layers lying on # object's top surfaces this is the place to detect them my $shape = []; if ($self->object_config->support_material_pattern eq 'pillars') { $self->generate_pillars_shape($contact, $support_z, $shape); } # Propagate contact layers downwards to generate interface layers my ($interface) = $self->generate_top_interface_layers($support_z, $contact, $top); $self->clip_with_object($interface, $support_z, $object); $self->clip_with_shape($interface, $shape) if @$shape; # Propagate contact layers and interface layers downwards to generate # the main support layers. my ($base) = $self->generate_base_layers($support_z, $contact, $interface, $top); $self->clip_with_object($base, $support_z, $object); $self->clip_with_shape($base, $shape) if @$shape; # Detect what part of base support layers are "reverse interfaces" because they # lie above object's top surfaces. $self->generate_bottom_interface_layers($support_z, $base, $top, $interface); # Install support layers into object. for my $i (0 .. $#$support_z) { $object->add_support_layer( $i, # id ($i == 0) ? $support_z->[$i] : ($support_z->[$i] - $support_z->[$i-1]), # height $support_z->[$i], # print_z ); if ($i >= 1) { $object->support_layers->[-2]->set_upper_layer($object->support_layers->[-1]); $object->support_layers->[-1]->set_lower_layer($object->support_layers->[-2]); } } # Generate the actual toolpaths and save them into each layer. $self->generate_toolpaths($object, $overhang, $contact, $interface, $base); } sub contact_area { # $object is Slic3r::Print::Object my ($self, $object) = @_; # if user specified a custom angle threshold, convert it to radians my $threshold_rad; if ($self->object_config->support_material_threshold) { $threshold_rad = deg2rad($self->object_config->support_material_threshold + 1); # +1 makes the threshold inclusive Slic3r::debugf "Threshold angle = %d°\n", rad2deg($threshold_rad); } # Build support on a build plate only? If so, then collect top surfaces into $buildplate_only_top_surfaces # and subtract $buildplate_only_top_surfaces from the contact surfaces, so # there is no contact surface supported by a top surface. my $buildplate_only = $self->object_config->support_material && $self->object_config->support_material_buildplate_only; my $buildplate_only_top_surfaces = []; # determine contact areas my %contact = (); # contact_z => [ polygons ] my %overhang = (); # contact_z => [ polygons ] - this stores the actual overhang supported by each contact layer for my $layer_id (0 .. $#{$object->layers}) { # note $layer_id might != $layer->id when raft_layers > 0 # so $layer_id == 0 means first object layer # and $layer->id == 0 means first print layer (including raft) if ($self->object_config->raft_layers == 0) { next if $layer_id == 0; } elsif (!$self->object_config->support_material) { # if we are only going to generate raft just check # the 'overhangs' of the first object layer last if $layer_id > 0; } my $layer = $object->get_layer($layer_id); if ($buildplate_only) { # Collect the top surfaces up to this layer and merge them. my $projection_new = []; push @$projection_new, ( map $_->p, map @{$_->slices->filter_by_type(S_TYPE_TOP)}, @{$layer->regions} ); if (@$projection_new) { # Merge the new top surfaces with the preceding top surfaces. # Apply the safety offset to the newly added polygons, so they will connect # with the polygons collected before, # but don't apply the safety offset during the union operation as it would # inflate the polygons over and over. push @$buildplate_only_top_surfaces, @{ offset($projection_new, scale(0.01)) }; $buildplate_only_top_surfaces = union($buildplate_only_top_surfaces, 0); } } # detect overhangs and contact areas needed to support them my (@overhang, @contact) = (); if ($layer_id == 0) { # this is the first object layer, so we're here just to get the object # footprint for the raft # we only consider contours and discard holes to get a more continuous raft push @overhang, map $_->clone, map $_->contour, @{$layer->slices}; # Extend by SUPPORT_MATERIAL_MARGIN, which is 1.5mm # MARGIN is the C++ Slic3r::SUPPORT_MATERIAL_MARGIN constant. push @contact, @{offset(\@overhang, scale +MARGIN)}; } else { my $lower_layer = $object->get_layer($layer_id-1); foreach my $layerm (@{$layer->regions}) { # Extrusion width accounts for the roundings of the extrudates. # It is the maximum widh of the extrudate. my $fw = $layerm->flow(FLOW_ROLE_EXTERNAL_PERIMETER)->scaled_width; my $diff; # If a threshold angle was specified, use a different logic for detecting overhangs. if (defined $threshold_rad || $layer_id < $self->object_config->support_material_enforce_layers || ($self->object_config->raft_layers > 0 && $layer_id == 0)) { my $d = defined $threshold_rad ? scale $lower_layer->height * ((cos $threshold_rad) / (sin $threshold_rad)) : 0; # Shrinking the supported layer by layer_height/atan(threshold_rad). $diff = diff( offset([ map $_->p, @{$layerm->slices} ], -$d), [ map @$_, @{$lower_layer->slices} ], ); # only enforce spacing from the object ($fw/2) if the threshold angle # is not too high: in that case, $d will be very small (as we need to catch # very short overhangs), and such contact area would be eaten by the # enforced spacing, resulting in high threshold angles to be almost ignored $diff = diff( offset($diff, $d - $fw/2), [ map @$_, @{$lower_layer->slices} ], ) if $d > $fw/2; } else { # Automatic overhang detection. $diff = diff( [ map $_->p, @{$layerm->slices} ], offset([ map @$_, @{$lower_layer->slices} ], #FIXME Vojtech: Why 2x extrusion width? Isn't this too much? Should it not be /2? +$fw/2), ); # collapse very tiny spots $diff = offset2($diff, -$fw/10, +$fw/10); # $diff now contains the ring or stripe comprised between the boundary of # lower slices and the centerline of the last perimeter in this overhanging layer. # Void $diff means that there's no upper perimeter whose centerline is # outside the lower slice boundary, thus no overhang } if ($self->object_config->dont_support_bridges) { # compute the area of bridging perimeters # Note: this is duplicate code from GCode.pm, we need to refactor my $bridged_perimeters; # Polygons { my $bridge_flow = $layerm->flow(FLOW_ROLE_PERIMETER, 1); my $nozzle_diameter = $self->print_config->get_at('nozzle_diameter', $layerm->region->config->perimeter_extruder-1); my $lower_grown_slices = offset([ map @$_, @{$lower_layer->slices} ], +scale($nozzle_diameter/2)); # TODO: split_at_first_point() could split a bridge mid-way my @overhang_perimeters = map { $_->isa('Slic3r::ExtrusionLoop') ? $_->polygon->split_at_first_point : $_->polyline->clone } map @$_, @{$layerm->perimeters}; # workaround for Clipper bug, see Slic3r::Polygon::clip_as_polyline() $_->[0]->translate(1,0) for @overhang_perimeters; @overhang_perimeters = @{diff_pl( \@overhang_perimeters, $lower_grown_slices, )}; # only consider straight overhangs @overhang_perimeters = grep $_->is_straight, @overhang_perimeters; # only consider overhangs having endpoints inside layer's slices foreach my $polyline (@overhang_perimeters) { $polyline->extend_start($fw); $polyline->extend_end($fw); } @overhang_perimeters = grep { $layer->slices->contains_point($_->first_point) && $layer->slices->contains_point($_->last_point) } @overhang_perimeters; # convert bridging polylines into polygons by inflating them with their thickness { # since we're dealing with bridges, we can't assume width is larger than spacing, # so we take the largest value and also apply safety offset to be ensure no gaps # are left in between my $w = max($bridge_flow->scaled_width, $bridge_flow->scaled_spacing); $bridged_perimeters = union([ map @{$_->grow($w/2 + 10)}, @overhang_perimeters ]); } } if (1) { # remove the entire bridges and only support the unsupported edges my @bridges = map $_->expolygon, grep $_->bridge_angle != -1, @{$layerm->fill_surfaces->filter_by_type(S_TYPE_BOTTOMBRIDGE)}; $diff = diff( $diff, [ (map @$_, @bridges), @$bridged_perimeters, ], 1, ); push @$diff, @{intersection( [ map @{$_->grow(+scale MARGIN)}, @{$layerm->unsupported_bridge_edges} ], [ map @$_, @bridges ], )}; } else { # just remove bridged areas $diff = diff( $diff, $layerm->bridged, 1, ); } } # if ($self->object_config->dont_support_bridges) if ($buildplate_only) { # Don't support overhangs above the top surfaces. # This step is done before the contact surface is calcuated by growing the overhang region. $diff = diff($diff, $buildplate_only_top_surfaces); } next if !@$diff; push @overhang, @$diff; # NOTE: this is not the full overhang as it misses the outermost half of the perimeter width! # Let's define the required contact area by using a max gap of half the upper # extrusion width and extending the area according to the configured margin. # We increment the area in steps because we don't want our support to overflow # on the other side of the object (if it's very thin). { my $slices_margin = offset([ map @$_, @{$lower_layer->slices} ], +$fw/2); if ($buildplate_only) { # Trim the inflated contact surfaces by the top surfaces as well. push @$slices_margin, map $_->clone, @{$buildplate_only_top_surfaces}; $slices_margin = union($slices_margin); } for ($fw/2, map {scale MARGIN_STEP} 1..(MARGIN / MARGIN_STEP)) { $diff = diff( offset( $diff, $_, CLIPPER_OFFSET_SCALE, JT_ROUND, scale(0.05)*CLIPPER_OFFSET_SCALE), $slices_margin ); } } push @contact, @$diff; } } next if !@contact; # now apply the contact areas to the layer were they need to be made { # get the average nozzle diameter used on this layer my @nozzle_diameters = map $self->print_config->get_at('nozzle_diameter', $_), map { $_->config->perimeter_extruder-1, $_->config->infill_extruder-1, $_->config->solid_infill_extruder-1 } map $_->region, @{$layer->regions}; my $nozzle_diameter = sum(@nozzle_diameters)/@nozzle_diameters; my $contact_z = $layer->print_z - $self->contact_distance($layer->height, $nozzle_diameter); # Ignore this contact area if it's too low. #FIXME Better to control the thickness of the interface layer printed, but that would # require having attributes (extrusion width / height, bridge flow etc) per island. next if $contact_z < $self->object_config->get_value('first_layer_height') - epsilon; $contact{$contact_z} = [ @contact ]; $overhang{$contact_z} = [ @overhang ]; if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output(Slic3r::DEBUG_OUT_PATH_PREFIX . "contact_" . $contact_z . ".svg", green_expolygons => union_ex($buildplate_only_top_surfaces), blue_expolygons => union_ex(\@contact), red_expolygons => union_ex(\@overhang), ); } } } return (\%contact, \%overhang); } sub object_top { my ($self, $object, $contact) = @_; # find object top surfaces # we'll use them to clip our support and detect where does it stick my %top = (); # print_z => [ expolygons ] return \%top if ($self->object_config->support_material_buildplate_only); # Sum of unsupported contact areas above the current $layer->print_z. my $projection = []; foreach my $layer (reverse @{$object->layers}) { if (my @top = map @{$_->slices->filter_by_type(S_TYPE_TOP)}, @{$layer->regions}) { # compute projection of the contact areas above this top layer # first add all the 'new' contact areas to the current projection # ('new' means all the areas that are lower than the last top layer # we considered) my $min_top = min(keys %top) // max(keys %$contact); # use <= instead of just < because otherwise we'd ignore any contact regions # having the same Z of top layers push @$projection, map @{$contact->{$_}}, grep { $_ > $layer->print_z && $_ <= $min_top } keys %$contact; # Now find whether any projection of the contact surfaces above $layer->print_z not yet supported by any top surfaces above $layer->z falls onto this top surface. # $touching are the contact surfaces supported exclusively by this @top surfaaces. my $touching = intersection($projection, [ map $_->p, @top ]); if (@$touching) { # grow top surfaces so that interface and support generation are generated # with some spacing from object - it looks we don't need the actual # top shapes so this can be done here $top{ $layer->print_z } = offset($touching, $self->flow->scaled_width); } # remove the areas that touched from the projection that will continue on # next, lower, top surfaces $projection = diff($projection, $touching); } } return \%top; } sub support_layers_z { my ($self, $contact_z, $top_z, $max_object_layer_height) = @_; # quick table to check whether a given Z is a top surface my %top = map { $_ => 1 } @$top_z; # determine layer height for any non-contact layer # we use max() to prevent many ultra-thin layers to be inserted in case # layer_height > nozzle_diameter * 0.75 my $nozzle_diameter = $self->print_config->get_at('nozzle_diameter', $self->object_config->support_material_extruder-1); my $support_material_height = max($max_object_layer_height, $nozzle_diameter * 0.75); my $contact_distance = $self->contact_distance($support_material_height, $nozzle_diameter); # initialize known, fixed, support layers my @z = sort { $a <=> $b } @$contact_z, # TODO: why we have this? # Vojtech: To detect the bottom interface layers by finding a Z value in the $top_z. @$top_z, # Top surfaces of the bottom interface layers. (map $_ + $contact_distance, @$top_z); # enforce first layer height my $first_layer_height = $self->object_config->get_value('first_layer_height'); shift @z while @z && $z[0] <= $first_layer_height; unshift @z, $first_layer_height; # add raft layers by dividing the space between first layer and # first contact layer evenly if ($self->object_config->raft_layers > 1 && @z >= 2) { # $z[1] is last raft layer (contact layer for the first layer object) my $height = ($z[1] - $z[0]) / ($self->object_config->raft_layers - 1); # since we already have two raft layers ($z[0] and $z[1]) we need to insert # raft_layers-2 more splice @z, 1, 0, map { sprintf "%.2f", $_ } map { $z[0] + $height * $_ } 1..($self->object_config->raft_layers - 2); } # create other layers (skip raft layers as they're already done and use thicker layers) for (my $i = $#z; $i >= $self->object_config->raft_layers; $i--) { my $target_height = $support_material_height; if ($i > 0 && $top{ $z[$i-1] }) { # Bridge flow? #FIXME We want to enforce not only the bridge flow height, but also the interface gap! # This will introduce an additional layer if the gap is set to an extreme value! $target_height = $nozzle_diameter; } # enforce first layer height #FIXME better to split the layers regularly, than to bite a constant height one at a time, # and then be left with a very thin layer at the end. if (($i == 0 && $z[$i] > $target_height + $first_layer_height) || ($z[$i] - $z[$i-1] > $target_height + Slic3r::Geometry::epsilon)) { splice @z, $i, 0, ($z[$i] - $target_height); $i++; } } # remove duplicates and make sure all 0.x values have the leading 0 { my %sl = map { 1 * $_ => 1 } @z; @z = sort { $a <=> $b } keys %sl; } return \@z; } sub generate_top_interface_layers { my ($self, $support_z, $contact, $top) = @_; # If no interface layers are allowed, don't generate top interface layers. return if $self->object_config->support_material_interface_layers == 0; # let's now generate interface layers below contact areas my %interface = (); # layer_id => [ polygons ] my $interface_layers_num = $self->object_config->support_material_interface_layers; for my $layer_id (0 .. $#$support_z) { my $z = $support_z->[$layer_id]; my $this = $contact->{$z} // next; # count contact layer as interface layer for (my $i = $layer_id-1; $i >= 0 && $i > $layer_id-$interface_layers_num; $i--) { $z = $support_z->[$i]; my @overlapping_layers = $self->overlapping_layers($i, $support_z); my @overlapping_z = map $support_z->[$_], @overlapping_layers; # Compute interface area on this layer as diff of upper contact area # (or upper interface area) and layer slices. # This diff is responsible of the contact between support material and # the top surfaces of the object. We should probably offset the top # surfaces vertically before performing the diff, but this needs # investigation. $this = $interface{$i} = diff( [ @$this, # clipped projection of the current contact regions @{ $interface{$i} || [] }, # interface regions already applied to this layer ], [ (map @$_, map $top->{$_}, grep exists $top->{$_}, @overlapping_z), # top slices on this layer (map @$_, map $contact->{$_}, grep exists $contact->{$_}, @overlapping_z), # contact regions on this layer ], 1, ); } } return \%interface; } sub generate_bottom_interface_layers { my ($self, $support_z, $base, $top, $interface) = @_; # If no interface layers are allowed, don't generate bottom interface layers. return if $self->object_config->support_material_interface_layers == 0; my $area_threshold = $self->interface_flow->scaled_spacing ** 2; # loop through object's top surfaces foreach my $top_z (sort keys %$top) { my $this = $top->{$top_z}; # keep a count of the interface layers we generated for this top surface my $interface_layers = 0; # loop through support layers until we find the one(s) right above the top # surface foreach my $layer_id (0 .. $#$support_z) { my $z = $support_z->[$layer_id]; next unless $z > $top_z; if ($base->{$layer_id}) { # get the support material area that should be considered interface my $interface_area = intersection( $base->{$layer_id}, $this, ); # discard too small areas $interface_area = [ grep abs($_->area) >= $area_threshold, @$interface_area ]; # subtract new interface area from base $base->{$layer_id} = diff( $base->{$layer_id}, $interface_area, ); # add new interface area to interface push @{$interface->{$layer_id}}, @$interface_area; } $interface_layers++; last if $interface_layers == $self->object_config->support_material_interface_layers; } } } sub generate_base_layers { my ($self, $support_z, $contact, $interface, $top) = @_; # let's now generate support layers under interface layers my $base = {}; # layer_id => [ polygons ] { my $fillet_radius_scaled = scale($self->object_config->support_material_spacing); for my $i (reverse 0 .. $#$support_z-1) { my $z = $support_z->[$i]; my @overlapping_layers = $self->overlapping_layers($i, $support_z); my @overlapping_z = map $support_z->[$_], @overlapping_layers; # in case we have no interface layers, look at upper contact # (1 interface layer means we only have contact layer, so $interface->{$i+1} is empty) my @upper_contact = (); if ($self->object_config->support_material_interface_layers <= 1) { @upper_contact = @{ $contact->{$support_z->[$i+1]} || [] }; } my $trim_polygons = [ (map @$_, map $top->{$_}, grep exists $top->{$_}, @overlapping_z), # top slices on this layer (map @$_, map $interface->{$_}, grep exists $interface->{$_}, @overlapping_layers), # interface regions on this layer (map @$_, map $contact->{$_}, grep exists $contact->{$_}, @overlapping_z), # contact regions on this layer ]; $base->{$i} = diff( [ @{ $base->{$i+1} || [] }, # support regions on upper layer @{ $interface->{$i+1} || [] }, # interface regions on upper layer @upper_contact, # contact regions on upper layer ], $trim_polygons, 1, # safety offset to merge the touching source polygons ); if (0) { # Fillet the base polygons and trim them again with the top, interface and contact layers. $base->{$i} = diff( offset2( $base->{$i}, $fillet_radius_scaled, -$fillet_radius_scaled, # Use a geometric offsetting for filleting. CLIPPER_OFFSET_SCALE, JT_ROUND, 0.2*$fillet_radius_scaled*CLIPPER_OFFSET_SCALE), $trim_polygons, 0); # don't apply the safety offset. } } } return $base; } # This method removes object silhouette from support material # (it's used with interface and base only). It removes a bit more, # leaving a thin gap between object and support in the XY plane. sub clip_with_object { my ($self, $support, $support_z, $object) = @_; foreach my $i (keys %$support) { next if !@{$support->{$i}}; my $zmax = $support_z->[$i]; my $zmin = ($i == 0) ? 0 : $support_z->[$i-1]; my @layers = grep { $_->print_z > $zmin && ($_->print_z - $_->height) < $zmax } @{$object->layers}; # $layer->slices contains the full shape of layer, thus including # perimeter's width. $support contains the full shape of support # material, thus including the width of its foremost extrusion. # We leave a gap equal to a full extrusion width. $support->{$i} = diff( $support->{$i}, offset([ map @$_, map @{$_->slices}, @layers ], +$self->flow->scaled_width), ); } } sub generate_toolpaths { my ($self, $object, $overhang, $contact, $interface, $base) = @_; my $flow = $self->flow; my $interface_flow = $self->interface_flow; # shape of contact area my $contact_loops = 1; my $circle_radius = 1.5 * $interface_flow->scaled_width; my $circle_distance = 3 * $circle_radius; my $circle = Slic3r::Polygon->new(map [ $circle_radius * cos $_, $circle_radius * sin $_ ], (5*PI/3, 4*PI/3, PI, 2*PI/3, PI/3, 0)); Slic3r::debugf "Generating patterns\n"; # prepare fillers my $pattern = $self->object_config->support_material_pattern; my $with_sheath = $self->object_config->support_material_with_sheath; my @angles = ($self->object_config->support_material_angle); if ($pattern eq 'rectilinear-grid') { $pattern = 'rectilinear'; push @angles, $angles[0] + 90; } elsif ($pattern eq 'pillars') { $pattern = 'honeycomb'; } my $interface_angle = $self->object_config->support_material_angle + 90; my $interface_spacing = $self->object_config->support_material_interface_spacing + $interface_flow->spacing; my $interface_density = $interface_spacing == 0 ? 1 : $interface_flow->spacing / $interface_spacing; my $support_spacing = $self->object_config->support_material_spacing + $flow->spacing; my $support_density = $support_spacing == 0 ? 1 : $flow->spacing / $support_spacing; my $process_layer = sub { my ($layer_id) = @_; my $layer = $object->support_layers->[$layer_id]; my $z = $layer->print_z; # we redefine flows locally by applying this layer's height my $_flow = $flow->clone; my $_interface_flow = $interface_flow->clone; $_flow->set_height($layer->height); $_interface_flow->set_height($layer->height); my $overhang = $overhang->{$z} || []; my $contact = $contact->{$z} || []; my $interface = $interface->{$layer_id} || []; my $base = $base->{$layer_id} || []; if (DEBUG_CONTACT_ONLY) { $interface = []; $base = []; } if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output(Slic3r::DEBUG_OUT_PATH_PREFIX . "layer_" . $z . ".svg", blue_expolygons => union_ex($base), red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), ); } # islands $layer->support_islands->append(@{union_ex([ @$interface, @$base, @$contact ])}); # contact my $contact_infill = []; if ($self->object_config->support_material_interface_layers == 0) { # if no interface layers were requested we treat the contact layer # exactly as a generic base layer push @$base, @$contact; } elsif (@$contact && $contact_loops > 0) { # generate the outermost loop # find centerline of the external loop (or any other kind of extrusions should the loop be skipped) $contact = offset($contact, -$_interface_flow->scaled_width/2); my @loops0 = (); { # find centerline of the external loop of the contours my @external_loops = @$contact; # only consider the loops facing the overhang { my $overhang_with_margin = offset($overhang, +$_interface_flow->scaled_width/2); @external_loops = grep { @{intersection_pl( [ $_->split_at_first_point ], $overhang_with_margin, )} } @external_loops; } # apply a pattern to the loop my @positions = map @{Slic3r::Polygon->new(@$_)->equally_spaced_points($circle_distance)}, @external_loops; @loops0 = @{diff( [ @external_loops ], [ map { my $c = $circle->clone; $c->translate(@$_); $c } @positions ], )}; } # make more loops my @loops = @loops0; for my $i (2..$contact_loops) { my $d = ($i-1) * $_interface_flow->scaled_spacing; push @loops, @{offset2(\@loops0, -$d -0.5*$_interface_flow->scaled_spacing, +0.5*$_interface_flow->scaled_spacing)}; } # clip such loops to the side oriented towards the object @loops = @{intersection_pl( [ map $_->split_at_first_point, @loops ], offset($overhang, +scale MARGIN), )}; # add the contact infill area to the interface area # note that growing loops by $circle_radius ensures no tiny # extrusions are left inside the circles; however it creates # a very large gap between loops and contact_infill, so maybe another # solution should be found to achieve both goals $contact_infill = diff( $contact, [ map @{$_->grow($circle_radius*1.1)}, @loops ], ); # transform loops into ExtrusionPath objects my $mm3_per_mm = $_interface_flow->mm3_per_mm; @loops = map Slic3r::ExtrusionPath->new( polyline => $_, role => EXTR_ROLE_SUPPORTMATERIAL_INTERFACE, mm3_per_mm => $mm3_per_mm, width => $_interface_flow->width, height => $layer->height, ), @loops; $layer->support_interface_fills->append(@loops); } # Allocate the fillers exclusively in the worker threads! Don't allocate them at the main thread, # as Perl copies the C++ pointers by default, so then the C++ objects are shared between threads! my %fillers = ( interface => Slic3r::Filler->new_from_type('rectilinear'), support => Slic3r::Filler->new_from_type($pattern), ); my $bounding_box = $object->bounding_box; $fillers{interface}->set_bounding_box($object->bounding_box); $fillers{support}->set_bounding_box($object->bounding_box); # interface and contact infill if (@$interface || @$contact_infill) { $fillers{interface}->set_angle($interface_angle); $fillers{interface}->set_spacing($_interface_flow->spacing); # find centerline of the external loop $interface = offset2($interface, +scaled_epsilon, -(scaled_epsilon + $_interface_flow->scaled_width/2)); # join regions by offsetting them to ensure they're merged $interface = offset([ @$interface, @$contact_infill ], scaled_epsilon); # turn base support into interface when it's contained in our holes # (this way we get wider interface anchoring) { my @p = @$interface; @$interface = (); foreach my $p (@p) { if ($p->is_clockwise) { my $p2 = $p->clone; $p2->make_counter_clockwise; next if !@{diff([$p2], $base, 1)}; } push @$interface, $p; } } $base = diff($base, $interface); my @paths = (); foreach my $expolygon (@{union_ex($interface)}) { my $polylines = $fillers{interface}->fill_surface( Slic3r::Surface->new(expolygon => $expolygon, surface_type => S_TYPE_INTERNAL), density => $interface_density, layer_height => $layer->height, complete => 1, ); my $mm3_per_mm = $_interface_flow->mm3_per_mm; push @paths, map Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new(@$_), role => EXTR_ROLE_SUPPORTMATERIAL_INTERFACE, mm3_per_mm => $mm3_per_mm, width => $_interface_flow->width, height => $layer->height, ), @$polylines, } $layer->support_interface_fills->append(@paths); } # support or flange if (@$base) { my $filler = $fillers{support}; $filler->set_angle($angles[ ($layer_id) % @angles ]); # We don't use $base_flow->spacing because we need a constant spacing # value that guarantees that all layers are correctly aligned. $filler->set_spacing($flow->spacing); my $density = $support_density; my $base_flow = $_flow; # find centerline of the external loop/extrusions my $to_infill = offset2_ex($base, +scaled_epsilon, -(scaled_epsilon + $_flow->scaled_width/2)); if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output(Slic3r::DEBUG_OUT_PATH_PREFIX . "to_infill_base" . $z . ".svg", red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), blue_expolygons => $to_infill, ); } my @paths = (); # base flange if ($layer_id == 0) { $filler = $fillers{interface}; $filler->set_angle($self->object_config->support_material_angle + 90); $density = 0.5; $base_flow = $self->first_layer_flow; # use the proper spacing for first layer as we don't need to align # its pattern to the other layers $filler->set_spacing($base_flow->spacing); } elsif ($with_sheath) { # draw a perimeter all around support infill # TODO: use brim ordering algorithm my $mm3_per_mm = $_flow->mm3_per_mm; push @paths, map Slic3r::ExtrusionPath->new( polyline => $_->split_at_first_point, role => EXTR_ROLE_SUPPORTMATERIAL, mm3_per_mm => $mm3_per_mm, width => $_flow->width, height => $layer->height, ), map @$_, @$to_infill; # TODO: use offset2_ex() $to_infill = offset_ex([ map @$_, @$to_infill ], -$_flow->scaled_spacing); } foreach my $expolygon (@$to_infill) { my $polylines = $filler->fill_surface( Slic3r::Surface->new(expolygon => $expolygon, surface_type => S_TYPE_INTERNAL), density => $density, layer_height => $layer->height, complete => 1, ); push @paths, map Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new(@$_), role => EXTR_ROLE_SUPPORTMATERIAL, mm3_per_mm => $base_flow->mm3_per_mm, width => $base_flow->width, height => $layer->height, ), @$polylines; } $layer->support_fills->append(@paths); } if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("islands_" . $z . ".svg", red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), green_polylines => [ map $_->unpack->polyline, @{$layer->support_contact_fills} ], polylines => [ map $_->unpack->polyline, @{$layer->support_fills} ], ); } }; Slic3r::parallelize( threads => $self->print_config->threads, items => [ 0 .. $#{$object->support_layers} ], thread_cb => sub { my $q = shift; while (defined (my $layer_id = $q->dequeue)) { $process_layer->($layer_id); } }, no_threads_cb => sub { $process_layer->($_) for 0 .. $#{$object->support_layers}; }, ); } sub generate_pillars_shape { my ($self, $contact, $support_z, $shape) = @_; # this prevents supplying an empty point set to BoundingBox constructor return if !%$contact; my $pillar_size = scale PILLAR_SIZE; my $pillar_spacing = scale PILLAR_SPACING; # A regular grid of pillars, filling the 2D bounding box. # arrayref of polygons my $grid; # arrayref of polygons { # Rectangle with a side of 2.5x2.5mm. my $pillar = Slic3r::Polygon->new( [0,0], [$pillar_size, 0], [$pillar_size, $pillar_size], [0, $pillar_size], ); # A regular grid of pillars, filling the 2D bounding box. my @pillars = (); # 2D bounding box of the projection of all contact polygons. my $bb = Slic3r::Geometry::BoundingBox->new_from_points([ map @$_, map @$_, values %$contact ]); for (my $x = $bb->x_min; $x <= $bb->x_max-$pillar_size; $x += $pillar_spacing) { for (my $y = $bb->y_min; $y <= $bb->y_max-$pillar_size; $y += $pillar_spacing) { push @pillars, my $p = $pillar->clone; $p->translate($x, $y); } } $grid = union(\@pillars); } # add pillars to every layer for my $i (0..$#$support_z) { $shape->[$i] = [ @$grid ]; } # build capitals for my $i (0..$#$support_z) { my $z = $support_z->[$i]; my $capitals = intersection( $grid, $contact->{$z} // [], ); # work on one pillar at time (if any) to prevent the capitals from being merged # but store the contact area supported by the capital because we need to make # sure nothing is left my $contact_supported_by_capitals = []; foreach my $capital (@$capitals) { # enlarge capital tops $capital = offset([$capital], +($pillar_spacing - $pillar_size)/2); push @$contact_supported_by_capitals, @$capital; for (my $j = $i-1; $j >= 0; $j--) { my $jz = $support_z->[$j]; $capital = offset($capital, -$self->interface_flow->scaled_width/2); last if !@$capitals; push @{ $shape->[$j] }, @$capital; } } # Capitals will not generally cover the whole contact area because there will be # remainders. For now we handle this situation by projecting such unsupported # areas to the ground, just like we would do with a normal support. my $contact_not_supported_by_capitals = diff( $contact->{$z} // [], $contact_supported_by_capitals, ); if (@$contact_not_supported_by_capitals) { for (my $j = $i-1; $j >= 0; $j--) { push @{ $shape->[$j] }, @$contact_not_supported_by_capitals; } } } } sub clip_with_shape { my ($self, $support, $shape) = @_; foreach my $i (keys %$support) { # don't clip bottom layer with shape so that we # can generate a continuous base flange # also don't clip raft layers next if $i == 0; next if $i < $self->object_config->raft_layers; $support->{$i} = intersection( $support->{$i}, $shape->[$i], ); } } # this method returns the indices of the layers overlapping with the given one sub overlapping_layers { my ($self, $i, $support_z) = @_; my $zmax = $support_z->[$i]; my $zmin = ($i == 0) ? 0 : $support_z->[$i-1]; return grep { my $zmax2 = $support_z->[$_]; my $zmin2 = ($_ == 0) ? 0 : $support_z->[$_-1]; $zmax > $zmin2 && $zmin < $zmax2; } 0..$#$support_z; } sub contact_distance { my ($self, $layer_height, $nozzle_diameter) = @_; my $extra = $self->object_config->support_material_contact_distance; if ($extra == 0) { return $layer_height; } else { return $nozzle_diameter + $extra; } } 1; Slic3r-version_1.31.6/lib/Slic3r/SVG.pm000066400000000000000000000101601301441720000173760ustar00rootroot00000000000000package Slic3r::SVG; use strict; use warnings; use SVG; use constant X => 0; use constant Y => 1; our $filltype = 'evenodd'; sub factor { return &Slic3r::SCALING_FACTOR * 10; } sub svg { my $svg = SVG->new(width => 200 * 10, height => 200 * 10); my $marker_end = $svg->marker( id => "endArrow", viewBox => "0 0 10 10", refX => "1", refY => "5", markerUnits => "strokeWidth", orient => "auto", markerWidth => "10", markerHeight => "8", ); $marker_end->polyline( points => "0,0 10,5 0,10 1,5", fill => "darkblue", ); return $svg; } sub output { my ($filename, @things) = @_; my $svg = svg(); my $arrows = 1; while (my $type = shift @things) { my $value = shift @things; if ($type eq 'no_arrows') { $arrows = 0; } elsif ($type =~ /^(?:(.+?)_)?expolygons$/) { my $colour = $1; $value = [ map $_->pp, @$value ]; my $g = $svg->group( style => { 'stroke-width' => 0, 'stroke' => $colour || 'black', 'fill' => ($type !~ /polygons/ ? 'none' : ($colour || 'grey')), 'fill-type' => $filltype, }, ); foreach my $expolygon (@$value) { my $points = join ' ', map "M $_ z", map join(" ", reverse map $_->[0]*factor() . " " . $_->[1]*factor(), @$_), @$expolygon; $g->path( d => $points, ); } } elsif ($type =~ /^(?:(.+?)_)?(polygon|polyline)s$/) { my ($colour, $method) = ($1, $2); $value = [ map $_->pp, @$value ]; my $g = $svg->group( style => { 'stroke-width' => ($method eq 'polyline') ? 1 : 0, 'stroke' => $colour || 'black', 'fill' => ($type !~ /polygons/ ? 'none' : ($colour || 'grey')), }, ); foreach my $polygon (@$value) { my $path = $svg->get_path( 'x' => [ map($_->[X] * factor(), @$polygon) ], 'y' => [ map($_->[Y] * factor(), @$polygon) ], -type => 'polygon', ); $g->$method( %$path, 'marker-end' => !$arrows ? "" : "url(#endArrow)", ); } } elsif ($type =~ /^(?:(.+?)_)?points$/) { my $colour = $1 // 'black'; my $r = $colour eq 'black' ? 1 : 3; $value = [ map $_->pp, @$value ]; my $g = $svg->group( style => { 'stroke-width' => 2, 'stroke' => $colour, 'fill' => $colour, }, ); foreach my $point (@$value) { $g->circle( cx => $point->[X] * factor(), cy => $point->[Y] * factor(), r => $r, ); } } elsif ($type =~ /^(?:(.+?)_)?lines$/) { my $colour = $1; $value = [ map $_->pp, @$value ]; my $g = $svg->group( style => { 'stroke-width' => 2, }, ); foreach my $line (@$value) { $g->line( x1 => $line->[0][X] * factor(), y1 => $line->[0][Y] * factor(), x2 => $line->[1][X] * factor(), y2 => $line->[1][Y] * factor(), style => { 'stroke' => $colour || 'black', }, 'marker-end' => !$arrows ? "" : "url(#endArrow)", ); } } } write_svg($svg, $filename); } sub write_svg { my ($svg, $filename) = @_; Slic3r::open(\my $fh, '>', $filename); print $fh $svg->xmlify; close $fh; printf "SVG written to %s\n", $filename; } 1; Slic3r-version_1.31.6/lib/Slic3r/Surface.pm000066400000000000000000000005421301441720000203320ustar00rootroot00000000000000package Slic3r::Surface; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our @EXPORT_OK = qw(S_TYPE_TOP S_TYPE_BOTTOM S_TYPE_BOTTOMBRIDGE S_TYPE_INTERNAL S_TYPE_INTERNALSOLID S_TYPE_INTERNALBRIDGE S_TYPE_INTERNALVOID); our %EXPORT_TAGS = (types => \@EXPORT_OK); sub p { my $self = shift; return @{$self->polygons}; } 1; Slic3r-version_1.31.6/lib/Slic3r/Test.pm000066400000000000000000002742241301441720000176730ustar00rootroot00000000000000package Slic3r::Test; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our @EXPORT_OK = qw(_eq); use IO::Scalar; use List::Util qw(first); use Slic3r::Geometry qw(epsilon X Y Z); my %cuboids = ( '20mm_cube' => [20,20,20], '2x20x10' => [2, 20,10], ); sub mesh { my ($name, %params) = @_; my ($vertices, $facets); if ($cuboids{$name}) { my ($x, $y, $z) = @{ $cuboids{$name} }; $vertices = [ [$x,$y,0], [$x,0,0], [0,0,0], [0,$y,0], [$x,$y,$z], [0,$y,$z], [0,0,$z], [$x,0,$z], ]; $facets = [ [0,1,2], [0,2,3], [4,5,6], [4,6,7], [0,4,7], [0,7,1], [1,7,6], [1,6,2], [2,6,5], [2,5,3], [4,0,3], [4,3,5], ], } elsif ($name eq 'cube_with_hole') { $vertices = [ [0,0,0],[0,0,10],[0,20,0],[0,20,10],[20,0,0],[20,0,10],[5,5,0],[15,5,0],[5,15,0],[20,20,0],[15,15,0],[20,20,10],[5,5,10],[5,15,10],[15,5,10],[15,15,10] ]; $facets = [ [0,1,2],[2,1,3],[1,0,4],[5,1,4],[6,7,4],[8,2,9],[0,2,8],[10,8,9],[0,8,6],[0,6,4],[4,7,9],[7,10,9],[2,3,9],[9,3,11],[12,1,5],[13,3,12],[14,12,5],[3,1,12],[11,3,13],[11,15,5],[11,13,15],[15,14,5],[5,4,9],[11,5,9],[8,13,12],[6,8,12],[10,15,13],[8,10,13],[15,10,14],[14,10,7],[14,7,12],[12,7,6] ], } elsif ($name eq 'cube_with_concave_hole') { $vertices = [ [-10,-10,-5],[-10,-10,5],[-10,10,-5],[-10,10,5],[10,-10,-5],[10,-10,5],[-5,-5,-5],[5,-5,-5],[5,5,-5],[5,10,-5],[-5,5,-5],[3.06161699911402e-16,5,-5],[5,0,-5],[0,0,-5],[10,5,-5],[5,10,5],[-5,-5,5],[5,0,5],[5,-5,5],[-5,5,5],[10,5,5],[5,5,5],[3.06161699911402e-16,5,5],[0,0,5] ]; $facets = [ [0,1,2],[2,1,3],[1,0,4],[5,1,4],[6,7,4],[8,2,9],[10,2,11],[11,12,13],[0,2,10],[0,10,6],[0,6,4],[11,2,8],[4,7,12],[4,12,8],[12,11,8],[14,4,8],[2,3,9],[9,3,15],[16,1,5],[17,18,5],[19,3,16],[20,21,5],[18,16,5],[3,1,16],[22,3,19],[21,3,22],[21,17,5],[21,22,17],[21,15,3],[23,17,22],[5,4,14],[20,5,14],[20,14,21],[21,14,8],[9,15,21],[8,9,21],[10,19,16],[6,10,16],[11,22,19],[10,11,19],[13,23,11],[11,23,22],[23,13,12],[17,23,12],[17,12,18],[18,12,7],[18,7,16],[16,7,6] ], } elsif ($name eq 'V') { $vertices = [ [-14,0,20],[-14,15,20],[0,0,0],[0,15,0],[-4,0,20],[-4,15,20],[5,0,7.14286],[10,0,0],[24,0,20],[14,0,20],[10,15,0],[5,15,7.14286],[14,15,20],[24,15,20] ]; $facets = [ [0,1,2],[2,1,3],[1,0,4],[5,1,4],[4,0,2],[6,4,2],[7,6,2],[8,9,7],[9,6,7],[2,3,7],[7,3,10],[1,5,3],[3,5,11],[11,12,13],[11,13,3],[3,13,10],[5,4,6],[11,5,6],[6,9,11],[11,9,12],[12,9,8],[13,12,8],[8,7,10],[13,8,10] ], } elsif ($name eq 'L') { $vertices = [ [0,10,0],[0,10,10],[0,20,0],[0,20,10],[10,10,0],[10,10,10],[20,20,0],[20,0,0],[10,0,0],[20,20,10],[10,0,10],[20,0,10] ]; $facets = [ [0,1,2],[2,1,3],[4,5,1],[0,4,1],[0,2,4],[4,2,6],[4,6,7],[4,7,8],[2,3,6],[6,3,9],[3,1,5],[9,3,5],[10,11,5],[11,9,5],[5,4,10],[10,4,8],[10,8,7],[11,10,7],[11,7,6],[9,11,6] ], } elsif ($name eq 'overhang') { $vertices = [ [1364.68505859375,614.398010253906,20.002498626709],[1389.68505859375,614.398010253906,20.002498626709],[1377.18505859375,589.398986816406,20.002498626709],[1389.68505859375,589.398986816406,20.002498626709],[1389.68505859375,564.398986816406,20.0014991760254],[1364.68505859375,589.398986816406,20.002498626709],[1364.68505859375,564.398986816406,20.0014991760254],[1360.93505859375,589.398986816406,17.0014991760254],[1360.93505859375,585.64697265625,17.0014991760254],[1357.18505859375,564.398986816406,17.0014991760254],[1364.68505859375,589.398986816406,17.0014991760254],[1364.68505859375,571.899963378906,17.0014991760254],[1364.68505859375,564.398986816406,17.0014991760254],[1348.43603515625,564.398986816406,17.0014991760254],[1352.80908203125,589.398986816406,17.0014991760254],[1357.18408203125,589.398986816406,17.0014991760254],[1357.18310546875,614.398010253906,17.0014991760254],[1364.68505859375,606.89599609375,17.0014991760254],[1364.68505859375,614.398010253906,17.0014991760254],[1352.18603515625,564.398986816406,20.0014991760254],[1363.65405273438,589.398986816406,23.3004989624023],[1359.46704101562,589.398986816406,23.3004989624023],[1358.37109375,564.398986816406,23.3004989624023],[1385.56103515625,564.398986816406,23.3004989624023],[1373.06311035156,589.398986816406,23.3004989624023],[1368.80810546875,564.398986816406,23.3004989624023],[1387.623046875,589.398986816406,23.3004989624023],[1387.623046875,585.276000976562,23.3004989624023],[1389.68505859375,589.398986816406,23.3004989624023],[1389.68505859375,572.64599609375,23.3004989624023],[1389.68505859375,564.398986816406,23.3004989624023],[1367.77709960938,589.398986816406,23.3004989624023],[1366.7470703125,564.398986816406,23.3004989624023],[1354.31201171875,589.398986816406,23.3004989624023],[1352.18603515625,564.398986816406,23.3004989624023],[1389.68505859375,614.398010253906,23.3004989624023],[1377.31701660156,614.398010253906,23.3004989624023],[1381.43908691406,589.398986816406,23.3004989624023],[1368.80700683594,614.398010253906,23.3004989624023],[1368.80810546875,589.398986816406,23.3004989624023],[1356.43908691406,614.398010253906,23.3004989624023],[1357.40502929688,589.398986816406,23.3004989624023],[1360.56201171875,614.398010253906,23.3004989624023],[1348.705078125,614.398010253906,23.3004989624023],[1350.44506835938,589.398986816406,23.3004989624023],[1389.68505859375,606.153015136719,23.3004989624023],[1347.35205078125,589.398986816406,23.3004989624023],[1346.56005859375,589.398986816406,23.3004989624023],[1346.56005859375,594.159912109375,17.0014991760254],[1346.56005859375,589.398986816406,17.0014991760254],[1346.56005859375,605.250427246094,23.3004989624023],[1346.56005859375,614.398010253906,23.3004989624023],[1346.56005859375,614.398010253906,20.8258285522461],[1346.56005859375,614.398010253906,17.0014991760254],[1346.56005859375,564.398986816406,19.10133934021],[1346.56005859375,567.548583984375,23.3004989624023],[1346.56005859375,564.398986816406,17.0020332336426],[1346.56005859375,564.398986816406,23.0018501281738],[1346.56005859375,564.398986816406,23.3004989624023],[1346.56005859375,575.118957519531,17.0014991760254],[1346.56005859375,574.754028320312,23.3004989624023] ]; $facets = [ [0,1,2],[2,3,4],[2,5,0],[4,6,2],[2,6,5],[2,1,3],[7,8,9],[10,9,8],[11,9,10],[12,9,11],[9,13,14],[7,15,16],[10,17,0],[10,0,5],[12,11,6],[18,16,0],[6,19,13],[6,13,9],[9,12,6],[17,18,0],[11,10,5],[11,5,6],[14,16,15],[17,7,18],[16,18,7],[14,15,9],[7,9,15],[7,17,8],[10,8,17],[20,21,22],[23,24,25],[26,23,27],[28,27,23],[29,28,23],[30,29,23],[25,31,32],[22,33,34],[35,36,37],[24,38,39],[21,40,41],[38,42,20],[33,43,44],[6,4,23],[6,23,25],[36,35,1],[1,0,38],[1,38,36],[29,30,4],[25,32,6],[40,42,0],[35,45,1],[4,3,28],[4,28,29],[3,1,45],[3,45,28],[22,34,19],[19,6,32],[19,32,22],[42,38,0],[30,23,4],[0,16,43],[0,43,40],[24,37,36],[38,24,36],[24,23,37],[37,23,26],[22,32,20],[20,32,31],[33,41,40],[43,33,40],[45,35,26],[37,26,35],[33,44,34],[44,43,46],[20,42,21],[40,21,42],[31,39,38],[20,31,38],[33,22,41],[21,41,22],[31,25,39],[24,39,25],[26,27,45],[28,45,27],[47,48,49],[47,50,48],[51,48,50],[52,48,51],[53,48,52],[54,55,56],[57,55,54],[58,55,57],[49,59,47],[60,56,55],[59,56,60],[60,47,59],[48,53,16],[56,13,19],[54,56,19],[56,59,13],[59,49,14],[59,14,13],[49,48,16],[49,16,14],[44,46,60],[44,60,55],[51,50,43],[19,34,58],[19,58,57],[53,52,16],[43,16,52],[43,52,51],[57,54,19],[47,60,46],[55,58,34],[55,34,44],[50,47,46],[50,46,43] ], } elsif ($name eq '40x10') { $vertices = [ [12.8680295944214,29.5799007415771,12],[11.7364797592163,29.8480796813965,12],[11.1571502685547,29.5300102233887,12],[10.5814504623413,29.9830799102783,12],[10,29.6000003814697,12],[9.41855144500732,29.9830799102783,12],[8.84284687042236,29.5300102233887,12],[8.26351833343506,29.8480796813965,12],[7.70256900787354,29.3210391998291,12],[7.13196802139282,29.5799007415771,12],[6.59579277038574,28.9761600494385,12],[6.03920221328735,29.1821594238281,12],[5.53865718841553,28.5003795623779,12],[5,28.6602592468262,12],[4.54657793045044,27.9006500244141,12],[4.02841377258301,28.0212306976318,12],[3.63402199745178,27.1856994628906,12],[3.13758301734924,27.2737407684326,12],[2.81429696083069,26.3659801483154,12],[2.33955597877502,26.4278793334961,12],[2.0993549823761,25.4534206390381,12],[1.64512205123901,25.4950904846191,12],[1.49962198734283,24.4613399505615,12],[1.0636739730835,24.4879894256592,12],[1.02384400367737,23.4042091369629,12],[0.603073298931122,23.4202003479004,12],[0.678958415985107,22.2974300384521,12],[0.269550800323486,22.3061599731445,12],[0.469994693994522,21.1571502685547,12],[0.067615881562233,21.1609306335449,12],[0.399999290704727,20,12],[0,20,12],[0.399999290704727,5,12],[0,5,12],[0.456633001565933,4.2804012298584,12],[0.0615576282143593,4.21782684326172,12],[0.625140011310577,3.5785219669342,12],[0.244717106223106,3.45491504669189,12],[0.901369392871857,2.91164398193359,12],[0.544967114925385,2.73004698753357,12],[1.27852201461792,2.29618692398071,12],[0.954914808273315,2.06107401847839,12],[1.74730801582336,1.74730801582336,12],[1.46446597576141,1.46446597576141,12],[2.29618692398071,1.27852201461792,12],[2.06107401847839,0.954914808273315,12],[2.91164398193359,0.901369392871857,12],[2.73004698753357,0.544967114925385,12],[3.5785219669342,0.625140011310577,12],[3.45491504669189,0.244717106223106,12],[4.2804012298584,0.456633001565933,12],[4.21782684326172,0.0615576282143593,12],[5,0.399999290704727,12],[5,0,12],[19.6000003814697,0.399999290704727,12],[20,0,12],[19.6000003814697,20,12],[20,20,12],[19.5300102233887,21.1571502685547,12],[19.9323806762695,21.1609306335449,12],[19.3210391998291,22.2974300384521,12],[19.7304496765137,22.3061599731445,12],[18.9761600494385,23.4042091369629,12],[19.3969306945801,23.4202003479004,12],[18.5003795623779,24.4613399505615,12],[18.9363307952881,24.4879894256592,12],[17.9006500244141,25.4534206390381,12],[18.3548793792725,25.4950904846191,12],[17.1856994628906,26.3659801483154,12],[17.6604404449463,26.4278793334961,12],[16.3659801483154,27.1856994628906,12],[16.862419128418,27.2737407684326,12],[15.4534196853638,27.9006500244141,12],[15.9715900421143,28.0212306976318,12],[14.4613399505615,28.5003795623779,12],[15,28.6602592468262,12],[13.4042100906372,28.9761600494385,12],[13.9608001708984,29.1821594238281,12],[12.2974300384521,29.3210391998291,12],[7.13196802139282,29.5799007415771,0],[8.26351833343506,29.8480796813965,0],[8.84284687042236,29.5300102233887,0],[9.41855144500732,29.9830799102783,0],[10,29.6000003814697,0],[10.5814504623413,29.9830799102783,0],[11.1571502685547,29.5300102233887,0],[11.7364797592163,29.8480796813965,0],[12.2974300384521,29.3210391998291,0],[12.8680295944214,29.5799007415771,0],[13.4042100906372,28.9761600494385,0],[13.9608001708984,29.1821594238281,0],[14.4613399505615,28.5003795623779,0],[15,28.6602592468262,0],[15.4534196853638,27.9006500244141,0],[15.9715900421143,28.0212306976318,0],[16.3659801483154,27.1856994628906,0],[16.862419128418,27.2737407684326,0],[17.1856994628906,26.3659801483154,0],[17.6604404449463,26.4278793334961,0],[17.9006500244141,25.4534206390381,0],[18.3548793792725,25.4950904846191,0],[18.5003795623779,24.4613399505615,0],[18.9363307952881,24.4879894256592,0],[18.9761600494385,23.4042091369629,0],[19.3969306945801,23.4202003479004,0],[19.3210391998291,22.2974300384521,0],[19.7304496765137,22.3061599731445,0],[19.5300102233887,21.1571502685547,0],[19.9323806762695,21.1609306335449,0],[19.6000003814697,20,0],[20,20,0],[19.6000003814697,0.399999290704727,0],[20,0,0],[5,0.399999290704727,0],[5,0,0],[4.2804012298584,0.456633001565933,0],[4.21782684326172,0.0615576282143593,0],[3.5785219669342,0.625140011310577,0],[3.45491504669189,0.244717106223106,0],[2.91164398193359,0.901369392871857,0],[2.73004698753357,0.544967114925385,0],[2.29618692398071,1.27852201461792,0],[2.06107401847839,0.954914808273315,0],[1.74730801582336,1.74730801582336,0],[1.46446597576141,1.46446597576141,0],[1.27852201461792,2.29618692398071,0],[0.954914808273315,2.06107401847839,0],[0.901369392871857,2.91164398193359,0],[0.544967114925385,2.73004698753357,0],[0.625140011310577,3.5785219669342,0],[0.244717106223106,3.45491504669189,0],[0.456633001565933,4.2804012298584,0],[0.0615576282143593,4.21782684326172,0],[0.399999290704727,5,0],[0,5,0],[0.399999290704727,20,0],[0,20,0],[0.469994693994522,21.1571502685547,0],[0.067615881562233,21.1609306335449,0],[0.678958415985107,22.2974300384521,0],[0.269550800323486,22.3061599731445,0],[1.02384400367737,23.4042091369629,0],[0.603073298931122,23.4202003479004,0],[1.49962198734283,24.4613399505615,0],[1.0636739730835,24.4879894256592,0],[2.0993549823761,25.4534206390381,0],[1.64512205123901,25.4950904846191,0],[2.81429696083069,26.3659801483154,0],[2.33955597877502,26.4278793334961,0],[3.63402199745178,27.1856994628906,0],[3.13758301734924,27.2737407684326,0],[4.54657793045044,27.9006500244141,0],[4.02841377258301,28.0212306976318,0],[5.53865718841553,28.5003795623779,0],[5,28.6602592468262,0],[6.59579277038574,28.9761600494385,0],[6.03920221328735,29.1821594238281,0],[7.70256900787354,29.3210391998291,0] ]; $facets = [ [0,1,2],[2,1,3],[2,3,4],[4,3,5],[4,5,6],[6,5,7],[6,7,8],[8,7,9],[8,9,10],[10,9,11],[10,11,12],[12,11,13],[12,13,14],[14,13,15],[14,15,16],[16,15,17],[16,17,18],[18,17,19],[18,19,20],[20,19,21],[20,21,22],[22,21,23],[22,23,24],[24,23,25],[24,25,26],[26,25,27],[26,27,28],[28,27,29],[28,29,30],[30,29,31],[30,31,32],[32,31,33],[32,33,34],[34,33,35],[34,35,36],[36,35,37],[36,37,38],[38,37,39],[38,39,40],[40,39,41],[40,41,42],[42,41,43],[42,43,44],[44,43,45],[44,45,46],[46,45,47],[46,47,48],[48,47,49],[48,49,50],[50,49,51],[50,51,52],[52,51,53],[52,53,54],[54,53,55],[54,55,56],[56,55,57],[56,57,58],[58,57,59],[58,59,60],[60,59,61],[60,61,62],[62,61,63],[62,63,64],[64,63,65],[64,65,66],[66,65,67],[66,67,68],[68,67,69],[68,69,70],[70,69,71],[70,71,72],[72,71,73],[72,73,74],[74,73,75],[74,75,76],[76,75,77],[76,77,78],[78,77,0],[78,0,2],[79,80,81],[81,80,82],[81,82,83],[83,82,84],[83,84,85],[85,84,86],[85,86,87],[87,86,88],[87,88,89],[89,88,90],[89,90,91],[91,90,92],[91,92,93],[93,92,94],[93,94,95],[95,94,96],[95,96,97],[97,96,98],[97,98,99],[99,98,100],[99,100,101],[101,100,102],[101,102,103],[103,102,104],[103,104,105],[105,104,106],[105,106,107],[107,106,108],[107,108,109],[109,108,110],[109,110,111],[111,110,112],[111,112,113],[113,112,114],[113,114,115],[115,114,116],[115,116,117],[117,116,118],[117,118,119],[119,118,120],[119,120,121],[121,120,122],[121,122,123],[123,122,124],[123,124,125],[125,124,126],[125,126,127],[127,126,128],[127,128,129],[129,128,130],[129,130,131],[131,130,132],[131,132,133],[133,132,134],[133,134,135],[135,134,136],[135,136,137],[137,136,138],[137,138,139],[139,138,140],[139,140,141],[141,140,142],[141,142,143],[143,142,144],[143,144,145],[145,144,146],[145,146,147],[147,146,148],[147,148,149],[149,148,150],[149,150,151],[151,150,152],[151,152,153],[153,152,154],[153,154,155],[155,154,156],[155,156,157],[157,156,79],[157,79,81],[57,110,108],[57,108,59],[59,108,106],[59,106,61],[61,106,104],[61,104,63],[63,104,102],[63,102,65],[65,102,100],[65,100,67],[67,100,98],[67,98,69],[69,98,96],[69,96,71],[71,96,94],[71,94,73],[73,94,92],[73,92,75],[75,92,90],[75,90,77],[77,90,88],[77,88,0],[0,88,86],[0,86,1],[1,86,84],[1,84,3],[3,84,82],[3,82,5],[5,82,80],[5,80,7],[7,80,79],[7,79,9],[9,79,156],[9,156,11],[11,156,154],[11,154,13],[13,154,152],[13,152,15],[15,152,150],[15,150,17],[17,150,148],[17,148,19],[19,148,146],[19,146,21],[21,146,144],[21,144,23],[23,144,142],[23,142,25],[25,142,140],[25,140,27],[27,140,138],[27,138,29],[29,138,136],[29,136,31],[33,31,134],[134,31,136],[33,134,132],[33,132,35],[35,132,130],[35,130,37],[37,130,128],[37,128,39],[39,128,126],[39,126,41],[41,126,124],[41,124,43],[43,124,122],[43,122,45],[45,122,120],[45,120,47],[47,120,118],[47,118,49],[49,118,116],[49,116,51],[51,116,114],[51,114,53],[55,53,112],[112,53,114],[57,55,110],[110,55,112],[30,135,137],[30,137,28],[28,137,139],[28,139,26],[26,139,141],[26,141,24],[24,141,143],[24,143,22],[22,143,145],[22,145,20],[20,145,147],[20,147,18],[18,147,149],[18,149,16],[16,149,151],[16,151,14],[14,151,153],[14,153,12],[12,153,155],[12,155,10],[10,155,157],[10,157,8],[8,157,81],[8,81,6],[6,81,83],[6,83,4],[4,83,85],[4,85,2],[2,85,87],[2,87,78],[78,87,89],[78,89,76],[76,89,91],[76,91,74],[74,91,93],[74,93,72],[72,93,95],[72,95,70],[70,95,97],[70,97,68],[68,97,99],[68,99,66],[66,99,101],[66,101,64],[64,101,103],[64,103,62],[62,103,105],[62,105,60],[60,105,107],[60,107,58],[58,107,109],[58,109,56],[30,32,135],[135,32,133],[52,113,115],[52,115,50],[50,115,117],[50,117,48],[48,117,119],[48,119,46],[46,119,121],[46,121,44],[44,121,123],[44,123,42],[42,123,125],[42,125,40],[40,125,127],[40,127,38],[38,127,129],[38,129,36],[36,129,131],[36,131,34],[34,131,133],[34,133,32],[52,54,113],[113,54,111],[54,56,111],[111,56,109] ], } elsif ($name eq 'sloping_hole') { $vertices = [ [-20,-20,-5],[-20,-20,5],[-20,20,-5],[-20,20,5],[20,-20,-5],[20,-20,5],[4.46294021606445,7.43144989013672,-5],[20,20,-5],[-19.1420993804932,0,-5],[-18.8330993652344,-2.07911992073059,-5],[-17.9195003509521,-4.06736993789673,-5],[-16.4412002563477,-5.87785005569458,-5],[-14.4629001617432,-7.43144989013672,-5],[-12.0711002349854,-8.66024971008301,-5],[-9.37016010284424,-9.51056003570557,-5],[-3.5217399597168,-9.94521999359131,-5],[-6.4782600402832,-9.94521999359131,-5],[-0.629840016365051,-9.51056003570557,-5],[2.07106995582581,-8.66024971008301,-5],[6.44122982025146,-5.87785005569458,-5],[4.46294021606445,-7.43144989013672,-5],[-12.0711002349854,8.66024971008301,-5],[-9.37016010284424,9.51056003570557,-5],[7.91947984695435,-4.06736993789673,-5],[8.83310031890869,-2.07911992073059,-5],[-6.4782600402832,9.94521999359131,-5],[-0.629840016365051,9.51056003570557,-5],[2.07106995582581,8.66024971008301,-5],[9.14214038848877,0,-5],[8.83310031890869,2.07911992073059,-5],[-3.5217399597168,9.94521999359131,-5],[7.91947984695435,4.06736993789673,-5],[6.44122982025146,5.87785005569458,-5],[-14.4629001617432,7.43144989013672,-5],[-16.4412002563477,5.87785005569458,-5],[-17.9195003509521,4.06736993789673,-5],[-18.8330993652344,2.07911992073059,-5],[20,20,5],[3.5217399597168,-9.94521999359131,5],[-8.83310031890869,-2.07911992073059,5],[-9.14214038848877,0,5],[-8.83310031890869,2.07911992073059,5],[6.4782600402832,-9.94521999359131,5],[-7.91947984695435,4.06736993789673,5],[-6.44122982025146,5.87785005569458,5],[-4.46294021606445,7.43144989013672,5],[-2.07106995582581,8.66024971008301,5],[0.629840016365051,9.51056003570557,5],[12.0711002349854,-8.66024971008301,5],[9.37016010284424,-9.51056003570557,5],[3.5217399597168,9.94521999359131,5],[6.4782600402832,9.94521999359131,5],[9.37016010284424,9.51056003570557,5],[12.0711002349854,8.66024971008301,5],[14.4629001617432,7.43144989013672,5],[16.4412002563477,-5.87785005569458,5],[14.4629001617432,-7.43144989013672,5],[16.4412002563477,5.87785005569458,5],[17.9195003509521,4.06736993789673,5],[18.8330993652344,-2.07911992073059,5],[17.9195003509521,-4.06736993789673,5],[18.8330993652344,2.07911992073059,5],[19.1420993804932,0,5],[0.629840016365051,-9.51056003570557,5],[-2.07106995582581,-8.66024971008301,5],[-4.46294021606445,-7.43144989013672,5],[-6.44122982025146,-5.87785005569458,5],[-7.91947984695435,-4.06736993789673,5] ]; $facets = [ [0,1,2],[2,1,3],[1,0,4],[5,1,4],[6,2,7],[0,2,8],[0,8,9],[0,9,10],[0,10,11],[0,11,12],[0,12,13],[0,13,4],[13,14,4],[15,4,16],[17,4,15],[18,4,17],[19,4,20],[18,20,4],[21,2,22],[4,19,23],[4,23,7],[23,24,7],[22,2,25],[26,2,27],[28,29,7],[25,2,30],[29,31,7],[30,2,26],[31,32,7],[27,2,6],[32,6,7],[28,7,24],[33,2,21],[34,2,33],[35,2,34],[36,2,35],[8,2,36],[16,4,14],[2,3,7],[7,3,37],[38,1,5],[3,1,39],[3,39,40],[3,40,41],[42,38,5],[3,41,43],[3,43,44],[37,3,45],[37,45,46],[37,46,47],[48,49,5],[37,47,50],[49,42,5],[37,50,51],[37,51,52],[37,52,53],[37,53,54],[55,56,5],[37,54,57],[37,57,58],[59,60,5],[37,58,61],[37,62,5],[37,61,62],[62,59,5],[60,55,5],[63,1,38],[64,1,63],[65,1,64],[66,1,65],[67,1,66],[39,1,67],[44,45,3],[56,48,5],[5,4,7],[37,5,7],[41,40,36],[36,40,8],[39,9,40],[40,9,8],[43,41,35],[35,41,36],[44,43,34],[34,43,35],[33,45,44],[34,33,44],[21,46,45],[33,21,45],[22,47,46],[21,22,46],[25,50,47],[22,25,47],[30,51,50],[25,30,50],[26,52,51],[30,26,51],[27,53,52],[26,27,52],[6,54,53],[27,6,53],[32,57,54],[6,32,54],[31,58,57],[32,31,57],[29,61,58],[31,29,58],[28,62,61],[29,28,61],[59,62,28],[24,59,28],[60,59,24],[23,60,24],[55,60,23],[19,55,23],[55,19,56],[56,19,20],[56,20,48],[48,20,18],[48,18,49],[49,18,17],[49,17,42],[42,17,15],[42,15,38],[38,15,16],[38,16,63],[63,16,14],[63,14,64],[64,14,13],[64,13,65],[65,13,12],[65,12,66],[66,12,11],[66,11,67],[67,11,10],[67,10,39],[39,10,9] ], } elsif ($name eq 'ipadstand') { $vertices = [ [17.4344673156738,-2.69879599481136e-16,9.5],[14.2814798355103,10,9.5],[0,0,9.5],[31.7159481048584,10,9.5],[62.2344741821289,2.06667568800577e-16,20],[31.7159481048584,10,20],[17.4344673156738,-2.69879599481136e-16,20],[62.2344741821289,10,20],[98.2079696655273,10,0],[98.2079696655273,8.56525380796383e-16,10],[98.2079696655273,0,0],[98.2079696655273,10,20],[98.2079696655273,0,20],[81.6609649658203,-4.39753856997999e-16,10],[90.0549850463867,10,10],[78.5079803466797,10,10],[93.2079696655273,8.56525380796383e-16,10],[14.2814798355103,10,20],[0,0,20],[87.4344711303711,2.81343962782118e-15,20],[84.2814788818359,10,20],[0,10,20],[0,0,0],[0,10,0],[62.2344741821289,2.06667568800577e-16,30],[66.9609756469727,10,30],[62.2344741821289,10,30],[70.1139602661133,8.5525763717214e-16,30],[67.7053375244141,10,28.7107200622559],[71.6787109375,1.24046736339707e-15,27.2897701263428] ]; $facets = [ [0,1,2],[1,0,3],[4,5,6],[5,4,7],[8,9,10],[9,11,12],[11,9,8],[13,14,15],[14,13,16],[17,2,1],[2,17,18],[19,11,20],[11,19,12],[17,21,18],[21,2,18],[2,21,22],[22,21,23],[8,22,23],[22,8,10],[24,25,26],[25,24,27],[23,1,8],[1,23,21],[1,21,17],[5,15,3],[15,5,7],[15,7,28],[28,7,26],[28,26,25],[8,14,11],[14,8,3],[3,8,1],[14,3,15],[11,14,20],[26,4,24],[4,26,7],[12,16,9],[16,12,19],[29,4,13],[4,29,24],[24,29,27],[9,22,10],[22,9,0],[0,9,16],[0,16,13],[0,13,6],[6,13,4],[2,22,0],[19,14,16],[14,19,20],[15,29,13],[29,25,27],[25,29,15],[25,15,28],[6,3,0],[3,6,5] ]; } elsif ($name eq 'A') { $vertices = [ [513.075988769531,51.6074333190918,36.0009002685547],[516.648803710938,51.7324333190918,36.0009002685547],[513.495178222656,51.7324333190918,36.0009002685547],[489.391204833984,51.4824333190918,24.0011005401611],[488.928588867188,51.7324333190918,24.0011005401611],[492.06201171875,51.7324333190918,24.0011005401611],[496.840393066406,51.2324333190918,24.0011005401611],[495.195404052734,51.7324333190918,24.0011005401611],[498.981994628906,51.7324333190918,24.0011005401611],[506.966613769531,51.6074333190918,24.0011005401611],[510.342010498047,51.7324333190918,24.0011005401611],[507.163818359375,51.6074333190918,24.0011005401611],[512.515380859375,54.7190322875977,36.0009002685547],[514.161987304688,54.5058326721191,36.0009002685547],[493.06201171875,54.7190322875977,36.0009002685547],[495.195404052734,51.7324333190918,36.0009002685547],[496.195404052734,54.7190322875977,36.0009002685547],[497.195404052734,57.7058334350586,36.0009002685547],[500.851989746094,60.2658309936523,36.0009002685547],[498.915405273438,62.8258323669434,36.0009002685547],[506.701995849609,62.8258323669434,36.0009002685547],[503.648590087891,60.2658309936523,36.0009002685547],[508.381805419922,57.7058334350586,36.0009002685547],[496.418792724609,60.052433013916,36.0009002685547],[506.515197753906,72.2124328613281,36.0009002685547],[502.808807373047,74.5324325561523,36.0009002685547],[503.781982421875,71.6058349609375,36.0009002685547],[515.358764648438,55.4658317565918,36.0009002685547],[499.375183105469,76.9058380126953,36.0009002685547],[501.168792724609,78.0658340454102,36.0009002685547],[504.568786621094,78.0658340454102,36.0009002685547],[506.32861328125,81.599235534668,36.0009002685547],[502.928588867188,81.599235534668,36.0009002685547],[499.528594970703,81.599235534668,36.0009002685547],[498.20361328125,77.8658294677734,36.0009002685547],[495.195404052734,51.7324333190918,30.0011005401611],[498.981994628906,51.7324333190918,27.0011005401611],[506.555206298828,51.7324333190918,33.0009002685547],[506.555206298828,51.7324333190918,36.0009002685547],[510.342010498047,51.7324333190918,36.0009002685547],[512.515380859375,54.7190322875977,24.0011005401611],[509.361999511719,54.7190322875977,24.0011005401611],[508.381805419922,57.7058334350586,24.0011005401611],[506.701995849609,62.8258323669434,24.0011005401611],[509.188812255859,60.052433013916,24.0011005401611],[493.06201171875,54.7190322875977,24.0011005401611],[503.648590087891,60.2658309936523,24.0011005401611],[500.851989746094,60.2658309936523,24.0011005401611],[498.915405273438,62.8258323669434,24.0011005401611],[502.808807373047,62.8258323669434,24.0011005401611],[491.425201416016,54.5058326721191,24.0011005401611],[506.421813964844,76.9058380126953,24.0011005401611],[502.808807373047,74.5324325561523,24.0011005401611],[504.568786621094,78.0658340454102,24.0011005401611],[506.32861328125,81.599235534668,24.0011005401611],[507.618804931641,77.8658294677734,24.0011005401611],[499.221801757812,72.2124328613281,24.0011005401611],[501.835388183594,71.6058349609375,24.0011005401611],[501.168792724609,78.0658340454102,24.0011005401611],[499.528594970703,81.599235534668,24.0011005401611],[502.048583984375,79.8324356079102,24.0011005401611],[490.253601074219,55.4658317565918,24.0011005401611],[488.928588867188,51.7324333190918,30.0011005401611],[488.928588867188,51.7324333190918,36.0009002685547],[490.253601074219,55.4658317565918,31.5009002685547],[498.20361328125,77.8658294677734,34.5009002685547],[508.381805419922,57.7058334350586,30.0011005401611],[505.585388183594,57.7058334350586,27.0011005401611],[502.788818359375,57.7058334350586,36.0009002685547],[499.992004394531,57.7058334350586,33.0009002685547],[509.851989746094,53.2258338928223,33.0009002685547],[509.361999511719,54.7190322875977,36.0009002685547],[508.871795654297,56.2124328613281,27.0011005401611],[496.695404052734,56.2124328613281,33.0009002685547],[495.695404052734,53.2258338928223,27.0011005401611],[506.32861328125,81.599235534668,30.0011005401611],[507.618804931641,77.8658294677734,25.5011005401611],[515.358764648438,55.4658317565918,34.5009002685547],[501.228607177734,81.599235534668,33.0009002685547],[504.628601074219,81.599235534668,27.0011005401611],[503.781982421875,71.6058349609375,33.0009002685547],[502.808807373047,74.5324325561523,30.0011005401611],[498.915405273438,62.8258323669434,30.0011005401611],[500.861999511719,62.8258323669434,27.0011005401611],[502.808807373047,62.8258323669434,36.0009002685547],[504.755187988281,62.8258323669434,33.0009002685547],[501.835388183594,71.6058349609375,33.0009002685547],[499.888793945312,65.7524337768555,33.0009002685547],[499.888793945312,65.7524337768555,36.0009002685547],[513.128601074219,51.4824333190918,36.0009002685547],[513.075988769531,51.6074333190918,24.0011005401611],[516.648803710938,51.7324333190918,24.0011005401611],[513.128601074219,51.4824333190918,24.0011005401611],[513.495178222656,51.7324333190918,24.0011005401611],[506.966613769531,51.6074333190918,36.0009002685547],[507.163818359375,51.6074333190918,36.0009002685547],[490.337799072266,51.4824333190918,24.0011005401611],[489.391204833984,51.4824333190918,36.0009002685547],[492.06201171875,51.7324333190918,36.0009002685547],[490.337799072266,51.4824333190918,36.0009002685547],[513.233764648438,51.2324333190918,24.0011005401611],[513.233764648438,51.2324333190918,36.0009002685547],[504.773803710938,51.4824333190918,36.0009002685547],[504.773803710938,51.4824333190918,24.0011005401611],[489.266998291016,51.2324333190918,24.0011005401611],[489.266998291016,51.2324333190918,36.0009002685547],[490.253601074219,55.4658317565918,25.5011005401611],[499.528594970703,81.599235534668,30.0011005401611],[498.20361328125,77.8658294677734,31.5009002685547],[515.358764648438,55.4658317565918,28.5011005401611],[515.358764648438,55.4658317565918,25.5011005401611],[495.246795654297,61.0124320983887,36.0009002685547],[490.253601074219,55.4658317565918,34.5009002685547],[490.253601074219,55.4658317565918,36.0009002685547],[494.228607177734,66.6658325195312,24.0011005401611],[499.068786621094,67.5192337036133,24.0011005401611],[498.20361328125,77.8658294677734,25.5011005401611],[498.20361328125,77.8658294677734,24.0011005401611],[506.608795166016,67.5192337036133,36.0009002685547],[509.09521484375,64.7458343505859,36.0009002685547],[507.618804931641,77.8658294677734,34.5009002685547],[507.618804931641,77.8658294677734,36.0009002685547],[510.385406494141,61.0124320983887,24.0011005401611],[515.358764648438,55.4658317565918,24.0011005401611],[489.32861328125,47.7324333190918,31.5009002685547],[492.95361328125,47.7324333190918,33.5634994506836],[489.32861328125,47.7324333190918,34.5009002685547],[489.32861328125,47.7324333190918,28.5011005401611],[489.32861328125,47.7324333190918,25.5011005401611],[492.95361328125,47.7324333190918,26.4385013580322],[492.95361328125,47.7324333190918,30.5635013580322],[492.95361328125,47.7324333190918,32.0634994506836],[492.95361328125,47.7324333190918,31.3135013580322],[492.95361328125,47.7324333190918,35.4384994506836],[489.32861328125,47.7324333190918,36.0009002685547],[492.95361328125,47.7324333190918,34.3134994506836],[492.95361328125,47.7324333190918,34.6884994506836],[492.95361328125,47.7324333190918,27.9385013580322],[492.95361328125,47.7324333190918,28.6885013580322],[492.95361328125,47.7324333190918,29.0635013580322],[489.32861328125,47.7324333190918,24.0011005401611],[492.95361328125,47.7324333190918,24.5635013580322],[492.95361328125,47.7324333190918,25.6885013580322],[492.95361328125,47.7324333190918,25.3135013580322],[492.95361328125,47.7324333190918,24.1885013580322],[492.95361328125,47.7324333190918,24.0011005401611],[513.443786621094,50.7324333190918,24.0011005401611],[492.95361328125,47.7324333190918,35.8134994506836],[492.95361328125,47.7324333190918,36.0009002685547],[513.443786621094,50.7324333190918,36.0009002685547],[506.350402832031,51.4824333190918,36.0009002685547],[506.350402832031,51.4824333190918,24.0011005401611],[492.743804931641,48.2324333190918,24.0011005401611],[492.638793945312,48.4824333190918,24.0011005401611],[492.743804931641,48.2324333190918,36.0009002685547],[492.638793945312,48.4824333190918,36.0009002685547],[490.089599609375,50.9824333190918,36.0009002685547],[490.089599609375,50.9824333190918,24.0011005401611],[510.342010498047,51.7324333190918,30.0011005401611],[499.068786621094,67.5192337036133,36.0009002685547],[494.228607177734,66.6658325195312,36.0009002685547],[499.375183105469,76.9058380126953,24.0011005401611],[506.421813964844,76.9058380126953,36.0009002685547],[506.608795166016,67.5192337036133,24.0011005401611],[505.728607177734,65.7524337768555,24.0011005401611],[509.09521484375,64.7458343505859,24.0011005401611],[506.701995849609,62.8258323669434,30.0011005401611],[505.728607177734,65.7524337768555,27.0011005401611],[501.835388183594,71.6058349609375,27.0011005401611],[499.888793945312,65.7524337768555,27.0011005401611],[494.228607177734,66.6658325195312,30.0011005401611],[495.553588867188,70.3992309570312,28.5011005401611],[492.903594970703,62.9324340820312,28.5011005401611],[495.553588867188,70.3992309570312,31.5009002685547],[492.903594970703,62.9324340820312,31.5009002685547],[511.488800048828,66.6658325195312,24.0011005401611],[511.488800048828,66.6658325195312,30.0011005401611],[512.778564453125,62.9324340820312,28.5011005401611],[515.358764648438,55.4658317565918,31.5009002685547],[507.618804931641,77.8658294677734,31.5009002685547],[510.198791503906,70.3992309570312,28.5011005401611],[511.488800048828,66.6658325195312,36.0009002685547],[512.778564453125,62.9324340820312,31.5009002685547],[510.198791503906,70.3992309570312,31.5009002685547],[502.788818359375,57.7058334350586,24.0011005401611],[497.195404052734,57.7058334350586,30.0011005401611],[492.903594970703,62.9324340820312,34.5009002685547],[492.903594970703,62.9324340820312,36.0009002685547],[495.553588867188,70.3992309570312,24.0011005401611],[496.725189208984,69.4392318725586,24.0011005401611],[495.553588867188,70.3992309570312,25.5011005401611],[495.246795654297,61.0124320983887,24.0011005401611],[492.903594970703,62.9324340820312,25.5011005401611],[492.903594970703,62.9324340820312,24.0011005401611],[495.553588867188,70.3992309570312,36.0009002685547],[496.725189208984,69.4392318725586,36.0009002685547],[495.553588867188,70.3992309570312,34.5009002685547],[510.198791503906,70.3992309570312,36.0009002685547],[509.002014160156,69.4392318725586,36.0009002685547],[510.198791503906,70.3992309570312,34.5009002685547],[512.778564453125,62.9324340820312,25.5011005401611],[512.778564453125,62.9324340820312,24.0011005401611],[510.198791503906,70.3992309570312,24.0011005401611],[509.002014160156,69.4392318725586,24.0011005401611],[510.198791503906,70.3992309570312,25.5011005401611],[510.385406494141,61.0124320983887,36.0009002685547],[512.778564453125,62.9324340820312,34.5009002685547],[512.778564453125,62.9324340820312,36.0009002685547],[496.840393066406,51.2324333190918,36.0009002685547],[498.981994628906,51.7324333190918,36.0009002685547],[498.981994628906,51.7324333190918,33.0009002685547],[506.555206298828,51.7324333190918,24.0011005401611],[506.555206298828,51.7324333190918,27.0011005401611],[503.82861328125,47.7324333190918,30.7509002685547],[507.45361328125,47.7324333190918,32.8134994506836],[503.82861328125,47.7324333190918,33.7509002685547],[503.82861328125,47.7324333190918,29.2511005401611],[503.82861328125,47.7324333190918,26.2511005401611],[507.45361328125,47.7324333190918,27.1885013580322],[493.921813964844,57.2792320251465,36.0009002685547],[491.425201416016,54.5058326721191,36.0009002685547],[497.195404052734,57.7058334350586,24.0011005401611],[496.418792724609,60.052433013916,24.0011005401611],[509.188812255859,60.052433013916,36.0009002685547],[511.675415039062,57.2792320251465,24.0011005401611],[514.161987304688,54.5058326721191,24.0011005401611],[507.45361328125,47.7324333190918,34.3134994506836],[503.82861328125,47.7324333190918,35.2509002685547],[507.45361328125,47.7324333190918,25.6885013580322],[503.82861328125,47.7324333190918,24.7511005401611],[500.20361328125,47.7324333190918,31.6885013580322],[500.20361328125,47.7324333190918,28.3135013580322],[500.20361328125,47.7324333190918,30.1885013580322],[507.45361328125,47.7324333190918,29.8135013580322],[507.45361328125,47.7324333190918,31.3135013580322],[507.45361328125,47.7324333190918,30.5635013580322],[503.82861328125,47.7324333190918,36.0009002685547],[507.45361328125,47.7324333190918,35.4384994506836],[507.45361328125,47.7324333190918,35.0634994506836],[507.45361328125,47.7324333190918,28.6885013580322],[507.45361328125,47.7324333190918,29.4385013580322],[503.82861328125,47.7324333190918,24.0011005401611],[507.45361328125,47.7324333190918,24.5635013580322],[507.45361328125,47.7324333190918,24.9385013580322],[500.20361328125,47.7324333190918,34.6884994506836],[500.20361328125,47.7324333190918,33.1884994506836],[500.20361328125,47.7324333190918,33.9384994506836],[500.20361328125,47.7324333190918,25.3135013580322],[500.20361328125,47.7324333190918,26.8135013580322],[500.20361328125,47.7324333190918,26.0635013580322],[500.20361328125,47.7324333190918,30.9385013580322],[500.20361328125,47.7324333190918,35.0634994506836],[500.20361328125,47.7324333190918,35.4384994506836],[500.20361328125,47.7324333190918,29.0635013580322],[500.20361328125,47.7324333190918,29.4385013580322],[500.20361328125,47.7324333190918,24.9385013580322],[500.20361328125,47.7324333190918,24.5635013580322],[507.45361328125,47.7324333190918,24.1885013580322],[507.45361328125,47.7324333190918,24.0011005401611],[513.86376953125,49.7324333190918,24.0011005401611],[507.45361328125,47.7324333190918,35.8134994506836],[507.45361328125,47.7324333190918,36.0009002685547],[513.86376953125,49.7324333190918,36.0009002685547],[500.20361328125,47.7324333190918,24.1885013580322],[500.20361328125,47.7324333190918,24.0011005401611],[502.988800048828,49.7324333190918,24.0011005401611],[500.20361328125,47.7324333190918,35.8134994506836],[500.20361328125,47.7324333190918,36.0009002685547],[502.988800048828,49.7324333190918,36.0009002685547],[504.755187988281,62.8258323669434,27.0011005401611],[499.205383300781,51.2324333190918,36.0009002685547],[498.786193847656,51.1074333190918,36.0009002685547],[502.358795166016,51.2324333190918,36.0009002685547],[499.205383300781,51.2324333190918,24.0011005401611],[502.358795166016,51.2324333190918,24.0011005401611],[498.786193847656,51.1074333190918,24.0011005401611],[502.568786621094,50.7324333190918,24.0011005401611],[505.931213378906,51.3574333190918,24.0011005401611],[509.503601074219,51.4824333190918,24.0011005401611],[502.568786621094,50.7324333190918,36.0009002685547],[505.931213378906,51.3574333190918,36.0009002685547],[509.503601074219,51.4824333190918,36.0009002685547],[499.048583984375,50.4824333190918,36.0009002685547],[492.428588867188,48.9824333190918,36.0009002685547],[499.048583984375,50.4824333190918,24.0011005401611],[492.428588867188,48.9824333190918,24.0011005401611],[506.088806152344,50.9824333190918,24.0011005401611],[506.036010742188,51.1074333190918,24.0011005401611],[506.088806152344,50.9824333190918,36.0009002685547],[506.036010742188,51.1074333190918,36.0009002685547],[498.891204833984,50.8574333190918,36.0009002685547],[498.943786621094,50.7324333190918,36.0009002685547],[498.891204833984,50.8574333190918,24.0011005401611],[498.943786621094,50.7324333190918,24.0011005401611],[499.573608398438,49.2324333190918,24.0011005401611],[499.783813476562,48.7324333190918,24.0011005401611],[499.573608398438,49.2324333190918,36.0009002685547],[499.783813476562,48.7324333190918,36.0009002685547],[506.403594970703,50.2324333190918,24.0011005401611],[506.298797607422,50.4824333190918,24.0011005401611],[506.403594970703,50.2324333190918,36.0009002685547],[506.298797607422,50.4824333190918,36.0009002685547],[501.228607177734,81.599235534668,27.0011005401611],[502.928588867188,81.599235534668,24.0011005401611],[499.2587890625,49.9824333190918,36.0009002685547],[499.363800048828,49.7324333190918,36.0009002685547],[499.2587890625,49.9824333190918,24.0011005401611],[499.363800048828,49.7324333190918,24.0011005401611],[496.695404052734,56.2124328613281,27.0011005401611],[496.195404052734,54.7190322875977,24.0011005401611],[509.851989746094,53.2258338928223,27.0011005401611],[493.464782714844,51.1074333190918,36.0009002685547],[493.464782714844,51.1074333190918,24.0011005401611],[502.768798828125,51.7324333190918,24.0011005401611],[500.215789794922,51.3574333190918,24.0011005401611],[497.628601074219,51.2324333190918,24.0011005401611],[502.768798828125,51.7324333190918,36.0009002685547],[500.215789794922,51.3574333190918,36.0009002685547],[497.628601074219,51.2324333190918,36.0009002685547],[507.033813476562,48.7324333190918,24.0011005401611],[506.823791503906,49.2324333190918,24.0011005401611],[507.033813476562,48.7324333190918,36.0009002685547],[506.823791503906,49.2324333190918,36.0009002685547],[494.4501953125,51.1074333190918,24.0011005401611],[494.4501953125,51.1074333190918,36.0009002685547],[500.807006835938,51.3574333190918,36.0009002685547],[503.591186523438,51.4824333190918,36.0009002685547],[503.591186523438,51.4824333190918,24.0011005401611],[500.807006835938,51.3574333190918,24.0011005401611],[505.728607177734,65.7524337768555,36.0009002685547],[505.728607177734,65.7524337768555,33.0009002685547],[499.221801757812,72.2124328613281,36.0009002685547],[501.835388183594,71.6058349609375,36.0009002685547],[506.515197753906,72.2124328613281,24.0011005401611],[503.781982421875,71.6058349609375,24.0011005401611],[503.781982421875,71.6058349609375,27.0011005401611],[499.888793945312,65.7524337768555,24.0011005401611],[495.695404052734,53.2258338928223,33.0009002685547],[516.648803710938,51.7324333190918,30.0011005401611],[498.20361328125,77.8658294677734,28.5011005401611],[505.585388183594,57.7058334350586,33.0009002685547],[508.871795654297,56.2124328613281,33.0009002685547],[499.992004394531,57.7058334350586,27.0011005401611],[504.628601074219,81.599235534668,33.0009002685547],[500.861999511719,62.8258323669434,33.0009002685547],[496.878601074219,74.1324310302734,27.0011005401611],[496.878601074219,74.1324310302734,33.0009002685547],[491.57861328125,59.199031829834,27.0011005401611],[490.253601074219,55.4658317565918,28.5011005401611],[491.57861328125,59.199031829834,33.0009002685547],[514.068786621094,59.199031829834,27.0011005401611],[514.068786621094,59.199031829834,33.0009002685547],[508.908813476562,74.1324310302734,27.0011005401611],[507.618804931641,77.8658294677734,28.5011005401611],[508.908813476562,74.1324310302734,33.0009002685547],[491.271789550781,50.9824333190918,36.0009002685547],[490.877807617188,50.9824333190918,36.0009002685547],[491.271789550781,50.9824333190918,24.0011005401611],[490.877807617188,50.9824333190918,24.0011005401611],[495.213806152344,50.9824333190918,36.0009002685547],[493.636993408203,50.9824333190918,36.0009002685547],[495.213806152344,50.9824333190918,24.0011005401611],[493.636993408203,50.9824333190918,24.0011005401611],[503.985412597656,51.4824333190918,36.0009002685547],[503.985412597656,51.4824333190918,24.0011005401611],[511.675415039062,57.2792320251465,36.0009002685547],[493.921813964844,57.2792320251465,24.0011005401611],[502.768798828125,51.7324333190918,30.0011005401611],[506.555206298828,51.7324333190918,30.0011005401611],[498.981994628906,51.7324333190918,30.0011005401611],[492.848815917969,50.9824333190918,24.0011005401611],[492.848815917969,50.9824333190918,36.0009002685547],[500.861999511719,68.6792297363281,36.0009002685547],[500.861999511719,68.6792297363281,24.0011005401611],[496.878601074219,74.1324310302734,24.0011005401611],[496.878601074219,74.1324310302734,36.0009002685547],[504.755187988281,68.6792297363281,24.0011005401611],[504.755187988281,68.6792297363281,36.0009002685547],[508.908813476562,74.1324310302734,36.0009002685547],[508.908813476562,74.1324310302734,24.0011005401611],[505.728607177734,65.7524337768555,30.0011005401611],[504.755187988281,68.6792297363281,30.0011005401611],[503.781982421875,71.6058349609375,30.0011005401611],[500.861999511719,68.6792297363281,30.0011005401611],[499.888793945312,65.7524337768555,30.0011005401611],[501.835388183594,71.6058349609375,30.0011005401611],[491.57861328125,59.199031829834,24.0011005401611],[491.57861328125,59.199031829834,36.0009002685547],[514.068786621094,59.199031829834,36.0009002685547],[514.068786621094,59.199031829834,24.0011005401611],[511.07861328125,47.7324333190918,34.8759002685547],[511.07861328125,47.7324333190918,31.8759002685547],[514.70361328125,47.7324333190918,33.9384994506836],[511.07861328125,47.7324333190918,25.1261005401611],[514.70361328125,47.7324333190918,26.0635013580322],[511.07861328125,47.7324333190918,28.1261005401611],[502.788818359375,57.7058334350586,30.0011005401611],[502.048583984375,79.8324356079102,36.0009002685547],[514.70361328125,47.7324333190918,30.9385013580322],[511.07861328125,47.7324333190918,30.3759002685547],[514.70361328125,47.7324333190918,29.0635013580322],[511.07861328125,47.7324333190918,29.6261005401611],[496.57861328125,47.7324333190918,31.1259002685547],[496.57861328125,47.7324333190918,32.6259002685547],[496.57861328125,47.7324333190918,34.1259002685547],[496.57861328125,47.7324333190918,28.8761005401611],[496.57861328125,47.7324333190918,27.3761005401611],[496.57861328125,47.7324333190918,25.8761005401611],[496.57861328125,47.7324333190918,29.6261005401611],[514.70361328125,47.7324333190918,35.4384994506836],[511.07861328125,47.7324333190918,35.6259002685547],[514.70361328125,47.7324333190918,24.5635013580322],[511.07861328125,47.7324333190918,24.3761005401611],[496.57861328125,47.7324333190918,34.8759002685547],[496.57861328125,47.7324333190918,25.1261005401611],[496.57861328125,47.7324333190918,35.6259002685547],[496.57861328125,47.7324333190918,24.3761005401611],[511.07861328125,47.7324333190918,36.0009002685547],[511.07861328125,47.7324333190918,24.0011005401611],[514.70361328125,47.7324333190918,30.1885013580322],[514.70361328125,47.7324333190918,35.8134994506836],[514.70361328125,47.7324333190918,29.8135013580322],[514.70361328125,47.7324333190918,24.1885013580322],[496.57861328125,47.7324333190918,36.0009002685547],[496.57861328125,47.7324333190918,24.0011005401611],[510.238800048828,49.7324333190918,24.0011005401611],[510.238800048828,49.7324333190918,36.0009002685547],[514.70361328125,47.7324333190918,24.0011005401611],[514.70361328125,47.7324333190918,36.0009002685547],[496.158813476562,48.7324333190918,36.0009002685547],[496.158813476562,48.7324333190918,24.0011005401611],[502.808807373047,62.8258323669434,30.0011005401611],[509.608795166016,51.2324333190918,24.0011005401611],[509.608795166016,51.2324333190918,36.0009002685547],[491.641204833984,50.8574333190918,24.0011005401611],[495.423797607422,50.4824333190918,36.0009002685547],[495.423797607422,50.4824333190918,24.0011005401611],[491.641204833984,50.8574333190918,36.0009002685547],[495.528594970703,50.2324333190918,24.0011005401611],[492.0087890625,49.9824333190918,24.0011005401611],[509.818786621094,50.7324333190918,24.0011005401611],[495.948608398438,49.2324333190918,36.0009002685547],[495.528594970703,50.2324333190918,36.0009002685547],[495.948608398438,49.2324333190918,24.0011005401611],[509.818786621094,50.7324333190918,36.0009002685547],[492.0087890625,49.9824333190918,36.0009002685547],[491.956207275391,50.1074333190918,24.0011005401611],[491.956207275391,50.1074333190918,36.0009002685547],[502.928588867188,81.599235534668,30.0011005401611],[491.851013183594,50.3574333190918,36.0009002685547],[491.851013183594,50.3574333190918,24.0011005401611],[496.195404052734,54.7190322875977,30.0011005401611],[509.361999511719,54.7190322875977,30.0011005401611],[488.632598876953,51.7256317138672,30.0011005401611],[488.632598876953,51.7256317138672,29.5091018676758],[488.632598876953,51.7188339233398,24.0011005401611],[488.632598876953,51.7256317138672,27.4929008483887],[488.632598876953,51.7324333190918,30.0011005401611],[488.632598876953,51.7324333190918,29.0175018310547],[488.632598876953,51.7324333190918,24.9847011566162],[488.632598876953,51.7324333190918,24.0011005401611],[488.632598876953,51.7188339233398,30.0011005401611],[488.632598876953,51.7176322937012,24.0011005401611],[488.632598876953,51.7182312011719,30.0011005401611],[488.632598876953,51.7176322937012,30.0011005401611],[488.632598876953,51.715030670166,24.0011005401611],[488.632598876953,51.7162322998047,30.0011005401611],[488.632598876953,50.761833190918,24.0011005401611],[488.632598876953,50.7578315734863,24.0011005401611],[488.632598876953,50.7598342895508,30.0011005401611],[488.632598876953,50.7522315979004,24.0011005401611],[488.632598876953,49.7838325500488,24.0011005401611],[488.632598876953,50.2680320739746,30.0011005401611],[488.632598876953,51.7046318054199,24.0011005401611],[488.632598876953,51.709831237793,30.0011005401611],[488.632598876953,50.9120330810547,24.0011005401611],[488.632598876953,50.8882331848145,24.0011005401611],[488.632598876953,50.9002304077148,30.0011005401611],[488.632598876953,47.7324333190918,24.0370998382568],[488.632598876953,48.5612335205078,30.0011005401611],[488.632598876953,47.7324333190918,24.0011005401611],[488.632598876953,47.7324333190918,24.1091003417969],[488.632598876953,48.5612335205078,30.0189018249512],[488.632598876953,47.7324333190918,25.3211002349854],[488.632598876953,48.5612335205078,30.0551013946533],[488.632598876953,47.7324333190918,25.4651012420654],[488.632598876953,48.5612335205078,30.6609001159668],[488.632598876953,47.7324333190918,25.5371017456055],[488.632598876953,48.5612335205078,30.7329006195068],[488.632598876953,47.7324333190918,25.6091003417969],[488.632598876953,48.5612335205078,30.7689018249512],[488.632598876953,47.7324333190918,25.8971004486084],[488.632598876953,48.5612335205078,30.8051013946533],[488.632598876953,47.7324333190918,28.321102142334],[488.632598876953,48.5612335205078,30.9491004943848],[488.632598876953,47.7324333190918,28.4651012420654],[488.632598876953,48.5612335205078,32.1609001159668],[488.632598876953,47.7324333190918,28.5371017456055],[488.632598876953,48.5612335205078,32.2329025268555],[488.632598876953,47.7324333190918,28.6811008453369],[488.632598876953,48.5612335205078,32.2689018249512],[488.632598876953,47.7324333190918,31.1049003601074],[488.632598876953,48.5612335205078,32.3411026000977],[488.632598876953,47.7324333190918,31.3929004669189],[488.632598876953,49.3900299072266,36.0009002685547],[488.632598876953,47.7324333190918,31.536901473999],[488.632598876953,47.7324333190918,31.6809005737305],[488.632598876953,47.7324333190918,34.1049003601074],[488.632598876953,47.7324333190918,34.3929023742676],[488.632598876953,47.7324333190918,34.464900970459],[488.632598876953,47.7324333190918,34.5369033813477],[488.632598876953,47.7324333190918,34.6809005737305],[488.632598876953,47.7324333190918,35.8929023742676],[488.632598876953,47.7324333190918,35.964900970459],[488.632598876953,47.7324333190918,36.0009002685547],[488.632598876953,50.8816299438477,24.0011005401611],[488.632598876953,50.8850326538086,30.0011005401611],[488.632598876953,49.7480316162109,24.0011005401611],[488.632598876953,49.7426300048828,24.0011005401611],[488.632598876953,49.745231628418,30.0011005401611],[488.632598876953,49.7592315673828,24.0011005401611],[488.632598876953,49.7536315917969,30.0011005401611],[488.632598876953,49.3900299072266,24.0011005401611],[488.632598876953,49.5664329528809,30.0011005401611],[488.632598876953,50.8786315917969,24.0011005401611],[488.632598876953,50.7764320373535,24.0011005401611],[488.632598876953,50.8274307250977,30.0011005401611],[488.632598876953,50.7550315856934,30.0011005401611],[488.632598876953,50.7692337036133,30.0011005401611],[488.632598876953,50.9284324645996,24.0011005401611],[488.632598876953,50.9202308654785,30.0011005401611],[488.632598876953,51.1788330078125,24.0011005401611],[488.632598876953,51.139232635498,24.0011005401611],[488.632598876953,51.1590309143066,30.0011005401611],[488.632598876953,51.2324333190918,24.0011005401611],[488.632598876953,51.2056312561035,30.0011005401611],[488.632598876953,51.4340324401855,24.0011005401611],[488.632598876953,51.3946304321289,24.0011005401611],[488.632598876953,51.4142303466797,30.0011005401611],[488.632598876953,51.4498329162598,24.0011005401611],[488.632598876953,51.5772323608398,30.0011005401611],[488.632598876953,51.4418334960938,30.0011005401611],[488.632598876953,51.3136329650879,30.0011005401611],[488.632598876953,49.7714309692383,30.0011005401611],[488.632598876953,51.0338325500488,30.0011005401611],[488.632598876953,50.8816299438477,30.0011005401611],[488.632598876953,50.8800315856934,30.0011005401611],[488.632598876953,51.7188339233398,36.0009002685547],[488.632598876953,51.7176322937012,36.0009002685547],[488.632598876953,49.3900299072266,30.0011005401611],[488.632598876953,50.7522315979004,30.0011005401611],[488.632598876953,50.7522315979004,36.0009002685547],[488.632598876953,49.7426300048828,30.0011005401611],[488.632598876953,49.7426300048828,36.0009002685547],[488.632598876953,49.7480316162109,30.0011005401611],[488.632598876953,49.7480316162109,36.0009002685547],[488.632598876953,51.715030670166,30.0011005401611],[488.632598876953,51.715030670166,36.0009002685547],[488.632598876953,50.7578315734863,30.0011005401611],[488.632598876953,50.7578315734863,36.0009002685547],[488.632598876953,50.761833190918,30.0011005401611],[488.632598876953,50.761833190918,36.0009002685547],[488.632598876953,50.8882331848145,30.0011005401611],[488.632598876953,50.8882331848145,36.0009002685547],[488.632598876953,49.7592315673828,30.0011005401611],[488.632598876953,49.7592315673828,36.0009002685547],[488.632598876953,51.1788330078125,30.0011005401611],[488.632598876953,51.1788330078125,36.0009002685547],[488.632598876953,50.9120330810547,30.0011005401611],[488.632598876953,50.9120330810547,36.0009002685547],[488.632598876953,51.4498329162598,30.0011005401611],[488.632598876953,51.4498329162598,36.0009002685547],[488.632598876953,51.7046318054199,30.0011005401611],[488.632598876953,51.7046318054199,36.0009002685547],[488.632598876953,51.2324333190918,30.0011005401611],[488.632598876953,51.2324333190918,36.0009002685547],[488.632598876953,51.3946304321289,30.0011005401611],[488.632598876953,51.3946304321289,36.0009002685547],[488.632598876953,51.4340324401855,30.0011005401611],[488.632598876953,51.4340324401855,36.0009002685547],[488.632598876953,49.7838325500488,30.0011005401611],[488.632598876953,49.7838325500488,36.0009002685547],[488.632598876953,50.7764320373535,30.0011005401611],[488.632598876953,50.7764320373535,36.0009002685547],[488.632598876953,51.139232635498,30.0011005401611],[488.632598876953,51.139232635498,36.0009002685547],[488.632598876953,50.9284324645996,30.0011005401611],[488.632598876953,50.9284324645996,36.0009002685547],[488.632598876953,50.8816299438477,36.0009002685547],[488.632598876953,50.8786315917969,30.0011005401611],[488.632598876953,50.8786315917969,36.0009002685547],[488.632598876953,51.7324333190918,35.0173034667969],[488.632598876953,51.7324333190918,36.0009002685547],[488.632598876953,51.7324333190918,30.9847011566162],[517.188415527344,51.7140884399414,24.0011005401611],[517.188415527344,51.7140884399414,36.0009002685547],[517.188415527344,50.4475173950195,24.0011005401611],[517.188415527344,51.7324333190918,35.3734130859375],[517.188415527344,51.7324333190918,36.0009002685547],[517.188415527344,51.7324333190918,34.1185760498047],[517.188415527344,51.7324333190918,31.88330078125],[517.188415527344,51.7324333190918,30.0011005401611],[517.188415527344,51.7324333190918,28.1187744140625],[517.188415527344,51.7324333190918,25.8834266662598],[517.188415527344,51.7324333190918,24.6285915374756],[517.188415527344,51.7324333190918,24.0011005401611],[517.188415527344,47.7324333190918,24.0600452423096],[517.188415527344,47.7324333190918,24.0011005401611],[517.188415527344,50.4475173950195,36.0009002685547],[517.188415527344,47.7324333190918,24.1779975891113],[517.188415527344,47.7324333190918,24.6498031616211],[517.188415527344,47.7324333190918,28.7625770568848],[517.188415527344,47.7324333190918,29.7061901092529],[517.188415527344,47.7324333190918,29.9420928955078],[517.188415527344,47.7324333190918,30.0600452423096],[517.188415527344,47.7324333190918,30.2959480285645],[517.188415527344,47.7324333190918,31.2395629882812],[517.188415527344,47.7324333190918,35.3521995544434],[517.188415527344,47.7324333190918,35.8240051269531],[517.188415527344,47.7324333190918,35.9419555664062],[517.188415527344,47.7324333190918,36.0009002685547] ]; $facets = [ [0,1,2],[3,4,5],[6,7,8],[9,10,11],[12,2,1],[12,1,13],[14,15,16],[17,18,19],[20,21,22],[17,19,23],[24,25,26],[27,13,1],[28,25,29],[30,31,32],[28,33,34],[35,36,7],[37,38,39],[40,10,41],[42,43,44],[45,5,4],[46,47,48],[46,48,49],[45,4,50],[51,52,53],[51,54,55],[56,52,57],[58,59,60],[61,50,4],[62,63,64],[65,34,33],[66,67,42],[68,17,69],[70,71,22],[66,42,72],[73,16,15],[35,7,74],[75,76,54],[77,27,1],[78,32,31],[75,54,79],[80,26,25],[81,80,25],[82,83,48],[84,20,85],[81,25,86],[87,88,19],[0,89,1],[90,91,92],[90,10,93],[38,94,39],[94,95,39],[3,7,96],[97,15,98],[97,99,15],[92,91,100],[89,101,1],[102,39,95],[103,11,10],[104,96,7],[105,15,99],[106,61,4],[107,108,33],[76,55,54],[109,91,110],[111,23,19],[112,63,113],[114,115,48],[116,59,117],[118,20,119],[120,31,121],[122,44,43],[110,91,123],[124,125,126],[127,128,129],[127,130,124],[131,124,132],[126,133,134],[135,136,126],[137,138,127],[139,127,138],[128,140,141],[142,128,143],[144,140,145],[100,91,146],[147,148,134],[101,149,1],[102,150,39],[103,10,151],[145,140,152],[152,140,153],[148,154,134],[154,155,134],[156,15,105],[157,104,7],[36,8,7],[158,37,39],[159,19,88],[160,19,159],[161,59,58],[161,117,59],[162,31,30],[162,121,31],[163,43,164],[163,165,43],[166,167,43],[167,164,43],[168,57,52],[82,48,169],[114,170,171],[108,65,33],[64,63,112],[114,172,170],[160,173,170],[171,170,173],[172,174,170],[160,170,174],[175,176,177],[178,77,1],[179,31,120],[175,180,176],[181,182,176],[177,176,182],[180,183,176],[181,176,183],[184,42,67],[185,69,17],[160,111,19],[186,187,160],[188,189,114],[190,188,114],[114,48,191],[192,114,193],[194,160,195],[196,160,194],[197,198,181],[199,197,181],[122,43,165],[200,201,175],[202,175,203],[204,175,202],[205,119,20],[206,181,207],[208,209,15],[210,15,209],[211,10,9],[212,10,211],[213,214,215],[216,217,218],[219,14,17],[113,63,220],[221,222,48],[191,48,222],[22,223,20],[205,20,223],[224,40,42],[123,91,225],[214,226,215],[227,215,226],[218,217,228],[229,228,217],[215,230,213],[125,135,126],[217,216,231],[129,128,142],[216,213,232],[130,132,124],[213,216,233],[234,213,235],[236,227,237],[238,237,227],[239,240,216],[233,216,240],[241,242,229],[243,229,242],[215,227,244],[245,215,246],[217,247,229],[248,249,217],[232,213,250],[230,250,213],[133,147,134],[244,227,251],[236,252,227],[251,227,252],[231,216,253],[254,253,216],[141,140,144],[247,255,229],[241,229,256],[255,256,229],[257,241,258],[259,146,91],[260,261,236],[262,1,149],[263,264,241],[265,241,264],[266,236,267],[268,267,236],[49,48,83],[166,43,269],[270,271,272],[273,274,275],[276,274,277],[278,151,10],[279,280,272],[281,39,150],[272,282,279],[155,283,134],[274,276,284],[153,140,285],[286,276,287],[265,276,286],[288,289,279],[268,288,279],[290,291,272],[271,290,272],[292,274,293],[275,274,292],[294,265,295],[276,265,294],[296,297,268],[279,296,268],[241,265,298],[298,265,299],[236,300,268],[300,301,268],[107,33,78],[302,303,59],[304,305,279],[282,304,279],[306,276,307],[284,276,306],[185,17,73],[308,309,221],[158,39,70],[310,41,10],[15,311,208],[7,6,312],[313,314,6],[315,6,314],[316,208,317],[318,317,208],[258,241,319],[319,241,320],[261,321,236],[321,322,236],[6,315,323],[208,324,318],[270,325,318],[326,318,325],[327,328,315],[273,315,328],[118,329,20],[330,20,329],[331,332,25],[86,25,332],[333,334,52],[335,52,334],[115,336,48],[169,48,336],[62,106,4],[35,15,210],[35,337,15],[158,10,212],[158,310,10],[338,178,1],[339,59,116],[107,302,59],[66,22,340],[66,341,22],[185,221,342],[185,308,221],[75,31,179],[75,343,31],[166,20,330],[166,85,20],[81,52,335],[81,168,52],[82,19,344],[82,87,19],[108,339,345],[346,108,345],[64,347,348],[349,347,64],[178,109,350],[351,178,350],[179,352,353],[354,352,179],[355,208,356],[356,208,311],[357,358,6],[358,312,6],[68,22,21],[68,340,22],[221,48,47],[184,342,221],[359,270,360],[318,360,270],[361,362,273],[315,273,362],[272,102,270],[363,270,102],[274,273,103],[364,103,273],[21,19,18],[21,20,84],[184,46,42],[43,42,46],[12,22,71],[365,22,12],[14,98,15],[14,220,63],[40,93,10],[40,225,91],[45,221,309],[366,221,45],[313,367,212],[212,367,368],[36,369,367],[313,36,367],[316,37,367],[37,368,367],[210,367,369],[316,367,210],[362,370,315],[370,323,315],[360,318,371],[371,318,324],[372,331,159],[159,195,160],[373,115,56],[115,114,189],[52,56,161],[374,161,56],[25,28,331],[375,331,28],[376,333,163],[163,203,175],[377,118,24],[118,181,198],[25,24,162],[378,162,24],[52,51,333],[379,333,51],[167,380,381],[376,167,381],[377,381,330],[330,381,380],[335,381,382],[376,381,335],[373,383,169],[169,383,384],[168,385,383],[373,168,383],[372,87,383],[87,384,383],[377,80,381],[80,382,381],[86,383,385],[372,383,86],[106,348,347],[386,106,347],[375,65,346],[108,346,65],[64,112,349],[387,349,112],[171,190,114],[346,345,171],[374,190,345],[171,345,190],[349,172,347],[172,114,192],[386,347,192],[172,192,347],[173,160,196],[171,173,346],[375,346,196],[173,196,346],[172,349,174],[174,186,160],[387,186,349],[174,349,186],[64,348,62],[106,62,348],[108,107,339],[59,339,107],[374,345,116],[339,116,345],[76,353,352],[379,76,352],[388,77,351],[178,351,77],[179,120,354],[378,354,120],[177,200,175],[351,350,177],[389,200,350],[177,350,200],[354,180,352],[180,175,204],[379,352,204],[180,204,352],[182,181,206],[177,182,351],[388,351,206],[182,206,351],[180,354,183],[183,199,181],[378,199,354],[183,354,199],[91,109,338],[178,338,109],[76,75,353],[179,353,75],[389,350,110],[109,110,350],[390,391,392],[393,394,395],[224,122,389],[122,175,201],[365,388,205],[205,207,181],[66,340,396],[68,396,340],[184,396,342],[185,342,396],[66,396,67],[184,67,396],[68,69,396],[185,396,69],[219,111,387],[111,160,187],[366,386,191],[191,193,114],[150,272,280],[102,272,150],[151,277,274],[103,151,274],[161,374,117],[116,117,374],[366,61,386],[106,386,61],[111,187,387],[186,387,187],[56,188,374],[190,374,188],[191,386,193],[192,193,386],[331,375,194],[196,194,375],[28,34,375],[65,375,34],[219,387,113],[112,113,387],[224,389,123],[110,123,389],[51,55,379],[76,379,55],[24,197,378],[199,378,197],[122,201,389],[200,389,201],[333,379,202],[204,202,379],[205,388,207],[206,207,388],[365,27,388],[77,388,27],[162,378,121],[120,121,378],[162,30,25],[30,29,25],[51,53,54],[303,60,59],[28,29,33],[29,397,33],[161,58,52],[53,52,58],[21,84,19],[84,344,19],[46,49,43],[49,269,43],[208,316,209],[210,209,316],[327,313,211],[212,211,313],[36,35,369],[210,369,35],[37,158,368],[212,368,158],[6,8,313],[36,313,8],[326,38,316],[37,316,38],[392,391,398],[399,398,391],[394,400,395],[401,395,400],[390,214,391],[214,213,234],[393,395,218],[218,239,216],[402,230,403],[230,215,245],[125,124,131],[404,125,403],[405,406,231],[231,248,217],[129,137,127],[407,406,129],[130,127,139],[402,130,408],[194,195,331],[159,331,195],[115,189,56],[188,56,189],[14,219,220],[113,220,219],[45,50,366],[61,366,50],[221,366,222],[191,222,366],[17,23,219],[111,219,23],[118,198,24],[197,24,198],[202,203,333],[163,333,203],[40,224,225],[123,225,224],[12,13,365],[27,365,13],[22,365,223],[205,223,365],[42,44,224],[122,224,44],[399,391,234],[214,234,391],[401,239,395],[218,395,239],[214,390,226],[226,238,227],[218,228,393],[228,229,243],[401,399,233],[233,235,213],[392,409,390],[410,390,409],[394,393,411],[412,411,393],[402,403,131],[125,131,403],[405,137,406],[129,406,137],[405,408,139],[130,139,408],[230,245,403],[404,403,245],[231,406,248],[407,248,406],[232,254,216],[402,408,232],[413,404,244],[244,246,215],[414,247,407],[247,217,249],[133,126,136],[415,133,413],[141,143,128],[416,414,141],[410,238,390],[226,390,238],[412,393,243],[228,243,393],[233,399,235],[234,235,399],[237,260,236],[238,410,237],[417,260,410],[237,410,260],[239,401,240],[233,240,401],[242,241,257],[243,242,412],[418,412,257],[242,257,412],[401,419,399],[398,399,419],[417,410,420],[409,420,410],[400,421,401],[419,401,421],[418,422,412],[411,412,422],[413,135,404],[125,404,135],[414,407,142],[129,142,407],[130,402,132],[131,132,402],[133,136,413],[135,413,136],[423,147,415],[133,415,147],[137,405,138],[139,138,405],[141,414,143],[142,143,414],[424,416,144],[141,144,416],[405,254,408],[232,408,254],[244,404,246],[245,246,404],[247,249,407],[248,407,249],[232,250,402],[230,402,250],[415,413,251],[244,251,413],[252,236,266],[251,252,415],[423,415,266],[252,266,415],[231,253,405],[254,405,253],[416,255,414],[247,414,255],[256,263,241],[255,416,256],[424,263,416],[256,416,263],[257,258,418],[425,418,258],[260,417,261],[426,261,417],[422,418,427],[427,259,91],[420,428,417],[428,1,262],[147,423,148],[429,148,423],[263,424,264],[264,295,265],[266,267,423],[267,268,297],[144,145,424],[430,424,145],[49,431,269],[166,269,431],[82,431,83],[49,83,431],[84,85,431],[166,431,85],[82,344,431],[84,431,344],[432,278,90],[10,90,278],[433,0,281],[39,281,0],[362,361,434],[435,271,359],[270,359,271],[436,361,275],[273,275,361],[360,437,359],[277,287,276],[151,278,277],[280,279,289],[150,280,281],[436,438,439],[439,285,140],[90,92,432],[440,432,92],[282,272,291],[441,282,442],[284,293,274],[443,438,284],[278,432,286],[286,299,265],[281,288,433],[288,268,301],[0,433,89],[444,89,433],[435,445,442],[445,134,283],[439,446,436],[361,436,446],[442,290,435],[271,435,290],[438,436,292],[275,292,436],[445,435,447],[359,447,435],[286,287,278],[277,278,287],[288,281,289],[280,289,281],[145,152,430],[443,430,152],[148,429,154],[441,154,429],[424,430,294],[294,307,276],[423,296,429],[296,279,305],[425,440,100],[92,100,440],[290,442,291],[282,291,442],[292,293,438],[284,438,293],[298,320,241],[432,440,298],[300,236,322],[433,300,444],[426,101,444],[89,444,101],[107,448,302],[302,79,54],[78,31,343],[107,78,448],[75,79,448],[302,448,79],[78,343,448],[75,448,343],[427,418,259],[425,259,418],[428,262,417],[426,417,262],[437,449,359],[447,359,449],[434,361,450],[446,450,361],[32,33,397],[78,33,32],[53,303,54],[302,54,303],[152,153,443],[438,443,153],[429,304,441],[282,441,304],[430,443,306],[284,306,443],[154,441,155],[442,155,441],[298,299,432],[286,432,299],[300,433,301],[288,301,433],[185,451,308],[308,74,7],[73,15,337],[185,73,451],[35,74,451],[308,451,74],[73,337,451],[35,451,337],[158,452,310],[310,72,42],[70,22,341],[158,70,452],[66,72,452],[310,452,72],[70,341,452],[66,452,341],[313,327,314],[315,314,327],[316,317,326],[318,326,317],[15,156,311],[356,311,156],[7,312,157],[358,157,312],[211,9,327],[364,327,9],[38,326,94],[363,94,326],[294,295,424],[264,424,295],[296,423,297],[267,297,423],[262,149,426],[101,426,149],[258,319,425],[440,425,319],[261,426,321],[444,321,426],[259,425,146],[100,146,425],[306,307,430],[294,430,307],[304,429,305],[296,305,429],[319,320,440],[298,440,320],[321,444,322],[300,322,444],[445,283,442],[155,442,283],[439,438,285],[153,285,438],[17,68,18],[21,18,68],[46,184,47],[221,47,184],[102,95,363],[94,363,95],[9,11,364],[103,364,11],[6,323,357],[370,357,323],[371,324,355],[208,355,324],[270,363,325],[326,325,363],[327,364,328],[273,328,364],[0,2,39],[12,39,2],[90,93,91],[40,91,93],[14,16,17],[73,17,16],[45,309,7],[308,7,309],[12,71,39],[70,39,71],[40,41,42],[310,42,41],[97,98,63],[14,63,98],[3,5,7],[45,7,5],[118,377,329],[330,329,377],[331,372,332],[86,332,372],[333,376,334],[335,334,376],[115,373,336],[169,336,373],[167,166,380],[330,380,166],[80,81,382],[335,382,81],[86,385,81],[168,81,385],[169,384,82],[87,82,384],[159,88,372],[87,372,88],[163,164,376],[167,376,164],[24,26,377],[80,377,26],[56,57,373],[168,373,57],[32,397,30],[29,30,397],[58,60,53],[303,53,60],[205,181,119],[118,119,181],[163,175,165],[122,165,175],[453,454,455],[454,456,455],[457,455,456],[458,455,457],[459,455,458],[460,455,459],[461,462,463],[464,465,466],[467,468,469],[470,471,472],[465,473,474],[475,476,477],[478,479,480],[481,482,478],[483,484,481],[485,486,483],[487,488,485],[489,490,487],[491,492,489],[493,494,491],[495,496,493],[497,498,495],[499,500,497],[501,502,499],[503,504,501],[505,504,503],[506,504,505],[507,504,506],[508,504,507],[509,504,508],[510,504,509],[511,504,510],[512,504,511],[513,504,512],[514,504,513],[476,515,516],[517,518,519],[520,517,521],[518,522,523],[522,480,479],[524,525,526],[468,470,527],[525,467,528],[529,475,530],[531,532,533],[534,531,535],[536,537,538],[473,539,540],[539,536,541],[537,534,542],[471,520,543],[532,529,544],[545,524,546],[453,461,547],[463,464,548],[523,549,504],[527,550,551],[519,552,553],[521,554,555],[466,556,557],[469,558,559],[528,560,561],[477,562,563],[543,564,565],[535,566,567],[530,568,569],[540,570,571],[474,572,573],[542,574,575],[538,576,577],[541,578,579],[472,580,581],[526,582,583],[533,584,585],[544,586,587],[516,545,588],[588,589,590],[455,460,4],[591,592,63],[462,455,4],[592,547,63],[547,548,63],[465,462,4],[548,557,63],[127,124,501],[127,501,499],[505,503,124],[124,126,507],[124,507,506],[509,508,126],[126,134,512],[126,512,511],[510,509,126],[128,127,493],[128,493,491],[497,495,127],[489,487,128],[140,128,483],[140,483,481],[487,485,128],[478,480,140],[480,522,140],[514,513,134],[504,514,134],[551,581,437],[471,470,434],[445,447,555],[445,555,553],[134,445,553],[134,553,504],[446,439,518],[446,518,517],[439,140,522],[439,522,518],[515,476,358],[563,588,356],[557,573,63],[473,465,4],[437,360,559],[437,559,551],[360,371,561],[360,561,559],[362,434,470],[362,470,468],[370,362,468],[370,468,467],[499,497,127],[506,505,124],[495,493,127],[513,512,134],[481,478,140],[447,449,565],[447,565,555],[450,446,517],[450,517,520],[356,156,569],[356,569,563],[157,358,476],[157,476,475],[357,370,467],[357,467,525],[371,355,583],[371,583,561],[460,459,4],[63,62,593],[63,593,591],[62,4,459],[62,459,458],[532,531,104],[531,534,104],[567,585,105],[575,567,105],[4,3,539],[4,539,473],[536,539,3],[97,63,573],[97,573,571],[571,579,97],[99,97,579],[99,579,577],[105,99,577],[105,577,575],[96,104,534],[96,534,537],[3,96,537],[3,537,536],[503,501,124],[508,507,126],[491,489,128],[511,510,126],[485,483,128],[434,450,520],[434,520,471],[449,437,581],[449,581,565],[156,105,585],[156,585,587],[587,569,156],[104,157,529],[104,529,532],[475,529,157],[590,583,355],[355,356,588],[355,588,590],[358,357,524],[358,524,515],[525,524,357],[458,457,62],[457,593,62],[479,478,482],[479,504,549],[479,482,504],[482,481,484],[472,551,550],[581,551,472],[482,484,504],[484,483,486],[523,553,552],[504,553,523],[540,573,572],[571,573,540],[544,585,584],[587,585,544],[542,577,576],[575,577,542],[526,590,589],[583,590,526],[535,575,574],[567,575,535],[533,567,566],[585,567,533],[538,579,578],[577,579,538],[543,581,580],[565,581,543],[477,569,568],[563,569,477],[530,587,586],[569,587,530],[541,571,570],[579,571,541],[528,583,582],[561,583,528],[591,453,592],[547,592,453],[521,565,564],[555,565,521],[474,557,556],[573,557,474],[516,563,562],[588,563,516],[519,555,554],[553,555,519],[527,559,558],[551,559,527],[469,561,560],[559,561,469],[462,461,455],[453,455,461],[461,463,547],[548,547,463],[465,464,462],[463,462,464],[464,466,548],[557,548,466],[469,560,467],[528,467,560],[472,550,470],[527,470,550],[474,556,465],[466,465,556],[477,568,475],[530,475,568],[516,562,476],[477,476,562],[519,554,517],[521,517,554],[521,564,520],[543,520,564],[523,552,518],[519,518,552],[479,549,522],[523,522,549],[526,589,524],[589,546,524],[527,558,468],[469,468,558],[528,582,525],[526,525,582],[530,586,529],[544,529,586],[533,566,531],[535,531,566],[535,574,534],[542,534,574],[538,578,536],[541,536,578],[540,572,473],[474,473,572],[541,570,539],[540,539,570],[542,576,537],[538,537,576],[543,580,471],[472,471,580],[544,584,532],[533,532,584],[524,545,515],[516,515,545],[545,546,588],[589,588,546],[453,591,454],[593,454,591],[484,486,504],[486,485,488],[486,488,504],[488,487,490],[488,490,504],[490,489,492],[490,492,504],[492,491,494],[492,494,504],[494,493,496],[494,496,504],[496,495,498],[496,498,504],[498,497,500],[498,500,504],[500,499,502],[500,502,504],[501,504,502],[454,593,456],[457,456,593],[594,595,596],[597,598,594],[599,597,594],[600,599,594],[601,600,594],[602,601,594],[603,602,594],[604,603,594],[605,604,594],[606,607,608],[609,606,608],[610,609,608],[611,610,608],[612,611,608],[613,612,608],[614,613,608],[615,614,608],[616,615,608],[617,616,608],[618,617,608],[619,618,608],[620,619,608],[596,608,607],[595,594,598],[608,596,595],[605,594,91],[91,338,602],[91,602,603],[598,597,1],[594,596,91],[608,595,1],[595,598,1],[616,617,392],[610,611,394],[419,421,613],[419,613,614],[422,427,607],[422,607,606],[427,91,596],[427,596,607],[428,420,619],[428,619,620],[1,428,620],[1,620,608],[420,409,618],[420,618,619],[411,422,606],[411,606,609],[398,419,614],[398,614,615],[421,400,612],[421,612,613],[409,392,617],[409,617,618],[394,411,609],[394,609,610],[604,605,91],[338,1,599],[338,599,600],[392,398,615],[392,615,616],[400,394,611],[400,611,612],[603,604,91],[601,602,338],[597,599,1],[600,601,338] ]; } elsif ($name eq 'gt2_teeth') { $vertices = [ [15.8899993896484,19.444055557251,2.67489433288574],[15.9129991531372,19.1590557098389,2.67489433288574],[15.9039993286133,19.1500549316406,2.67489433288574],[15.9489994049072,19.2490558624268,2.67489433288574],[15.9579992294312,19.3570556640625,2.67489433288574],[15.8819999694824,18.690055847168,2.67489433288574],[15.8319997787476,17.7460556030273,2.67489433288574],[15.8489999771118,18.819055557251,2.67489433288574],[15.8589992523193,17.7190551757812,2.67489433288574],[15.8769998550415,19.0490550994873,2.67489433288574],[15.7529993057251,17.8080558776855,2.67489433288574],[15.7869997024536,19.5010547637939,2.67489433288574],[14.0329990386963,18.7170543670654,2.67489433288574],[13.9599990844727,18.7460556030273,2.67489433288574],[13.9869995117188,20.2840557098389,2.67489433288574],[14.2029991149902,20.149055480957,2.67489433288574],[14.1939992904663,19.9560546875,2.67489433288574],[14.1939992904663,20.1670551300049,2.67489433288574],[14.2119998931885,20.0590553283691,2.67489433288574],[12.1899995803833,19.1840553283691,2.67489433288574],[12.096999168396,19.1950550079346,2.67489433288574],[12.1099996566772,20.6690559387207,2.67489433288574],[11.382999420166,19.9750556945801,2.67489433288574],[11.2599992752075,19.2490558624268,2.67489433288574],[11.2369995117188,19.9320545196533,2.67489433288574],[11.5349998474121,20.0640544891357,2.67489433288574],[11.6259994506836,20.1550559997559,2.67489433288574],[11.6829986572266,20.2390556335449,2.67489433288574],[11.7369995117188,20.3570556640625,2.67489433288574],[11.8449993133545,20.645055770874,2.67489433288574],[11.7729988098145,20.4640560150146,2.67489433288574],[11.7799987792969,20.5370559692383,9.41389465332031],[11.7639999389648,20.4470558166504,2.67489433288574],[11.9559993743896,20.6810550689697,2.67489433288574],[12.3079996109009,20.6020545959473,2.67489433288574],[12.1959991455078,19.1860542297363,2.67489433288574],[12.2059993743896,20.6540546417236,2.67489433288574],[12.3489990234375,20.3740558624268,2.67489433288574],[12.3579998016357,20.2750549316406,2.67489433288574],[12.3669996261597,20.266056060791,2.67489433288574],[12.3849992752075,20.1670551300049,2.67489433288574],[12.4269990921021,20.0680541992188,2.67489433288574],[12.5029993057251,19.9540557861328,2.67489433288574],[12.6169996261597,19.8550548553467,2.67489433288574],[12.7449989318848,19.7800559997559,2.67489433288574],[12.7629995346069,19.7800559997559,2.67489433288574],[12.8799991607666,19.7350559234619,2.67489433288574],[13.0369997024536,19.7250556945801,2.67489433288574],[13.0149993896484,19.0340557098389,2.67489433288574],[11.1699991226196,19.2580547332764,2.67489433288574],[11.0959987640381,19.2580547332764,2.67489433288574],[11.1209993362427,19.9230556488037,2.67489433288574],[13.0599994659424,19.024055480957,2.67489433288574],[14.9049997329712,18.3170547485352,2.67489433288574],[14.8779993057251,18.3400554656982,2.67489433288574],[14.8779993057251,19.149055480957,2.67489433288574],[13.3039989471436,19.77805519104,2.67489433288574],[13.1589994430542,18.9890556335449,2.67489433288574],[13.1559991836548,19.7350559234619,2.67489433288574],[13.4269990921021,19.8600559234619,2.67489433288574],[13.5339994430542,19.9700546264648,2.67389440536499],[13.6359996795654,20.1220550537109,2.67489433288574],[13.6359996795654,20.1400547027588,2.67489433288574],[13.6719989776611,20.2210559844971,2.67489433288574],[13.6899995803833,20.2300548553467,2.67489433288574],[13.7509994506836,20.3010559082031,2.67489433288574],[13.8539991378784,20.3180541992188,2.67489433288574],[14.8329992294312,18.3580551147461,2.67489433288574],[14.1849994659424,19.8530559539795,2.67489433288574],[14.0769996643066,18.7000541687012,2.67489433288574],[14.1099996566772,20.2400550842285,2.67489433288574],[14.2009992599487,19.6230545043945,2.67489433288574],[14.2729997634888,19.4670543670654,2.67489433288574],[14.3379993438721,19.3790550231934,2.67489433288574],[14.4549999237061,19.2770557403564,2.67489433288574],[14.5899991989136,19.2040557861328,2.67489433288574],[14.6079998016357,19.2040557861328,2.67489433288574],[14.7209997177124,19.1600551605225,2.67489433288574],[15.1379995346069,19.210054397583,2.67489433288574],[14.9949998855591,18.2680549621582,2.67489433288574],[15.0029993057251,19.1580543518066,2.67489433288574],[15.2369995117188,19.2760543823242,2.67489433288574],[15.3779993057251,19.4060554504395,2.67489433288574],[15.4539995193481,19.520055770874,2.67489433288574],[15.471999168396,19.52805519104,2.67489433288574],[15.5449991226196,19.5830554962158,2.67489433288574],[15.6529998779297,19.573055267334,2.67489433288574],[15.7059993743896,17.8360557556152,2.67489433288574],[15.9449996948242,18.5560550689697,2.67489433288574],[15.8589992523193,18.9380550384521,2.67489433288574],[14.9589996337891,18.2950553894043,2.67489433288574],[15.7779998779297,19.5100555419922,2.67489433288574],[14.0049991607666,20.2750549316406,2.67489433288574],[12.3489990234375,20.5000553131104,2.67489433288574],[13.0689992904663,19.0150547027588,2.67489433288574],[13.0999994277954,19.0100555419922,2.67489433288574],[15.9489994049072,19.3670558929443,9.41489505767822],[15.9489994049072,19.2490558624268,9.41489505767822],[15.75,17.8080558776855,9.41489505767822],[15.6639995574951,19.5710544586182,9.41489505767822],[15.5709991455078,17.9260559082031,9.41489505767822],[15.8769998550415,18.690055847168,9.41489505767822],[15.8499994277954,18.8170547485352,9.41489505767822],[15.9459991455078,18.5520553588867,9.41489505767822],[15.914999961853,17.6890544891357,9.41489505767822],[15.3999996185303,19.4290542602539,9.41489505767822],[15.3099994659424,19.339054107666,9.41489505767822],[15.3729991912842,18.0440559387207,9.41489505767822],[15.4579992294312,19.5170555114746,9.41489505767822],[15.5469999313354,19.5820541381836,9.41489505767822],[13.2309989929199,19.7610549926758,9.41489505767822],[13.168999671936,19.7360553741455,9.41489505767822],[13.096999168396,19.0140552520752,9.41489505767822],[13.1999988555908,18.9870548248291,9.41489505767822],[15.1399993896484,19.2080554962158,9.41489505767822],[15.0159997940063,19.1600551605225,9.41489505767822],[14.9859991073608,18.2770557403564,9.41489505767822],[15.1749992370605,18.1690559387207,9.41489505767822],[15.9039993286133,19.1320552825928,9.41489505767822],[15.8949995040894,19.4460544586182,9.41489505767822],[15.8769998550415,19.0420551300049,9.41489505767822],[12.2169990539551,20.6500549316406,9.41489505767822],[11.9379997253418,20.6810550689697,9.41489505767822],[11.8629989624023,19.2130546569824,9.41489505767822],[12.096999168396,19.1950550079346,9.41489505767822],[14.1669998168945,18.6640548706055,9.41489505767822],[14.1039991378784,20.2460556030273,9.41489505767822],[13.9849996566772,18.7360553741455,9.41489505767822],[14.7349996566772,19.1590557098389,9.41489505767822],[14.5849990844727,19.2050552368164,9.41489505767822],[14.5719995498657,18.4850559234619,9.41489505767822],[14.1939992904663,19.6760559082031,9.41489505767822],[14.1849994659424,19.9330558776855,9.41489505767822],[14.1759996414185,18.6640548706055,9.41489505767822],[14.261999130249,19.4890556335449,9.41489505767822],[14.3539991378784,19.3610553741455,9.41489505767822],[14.3559989929199,18.5830554962158,9.41489505767822],[11.6039991378784,20.1250553131104,9.41489505767822],[11.5209999084473,20.0520553588867,9.41489505767822],[11.4209995269775,19.2480545043945,9.41489505767822],[11.6989994049072,20.2690544128418,9.41389465332031],[11.7609996795654,20.4310550689697,9.41489505767822],[11.8359994888306,19.2130546569824,9.41489505767822],[14.1889991760254,20.1710548400879,9.41489505767822],[13.9689998626709,20.2840557098389,9.41489505767822],[13.8739995956421,20.315055847168,9.41489505767822],[13.7799997329712,18.8080558776855,9.41489505767822],[13.9869995117188,20.2750549316406,9.41489505767822],[12.3129997253418,20.5980548858643,9.41489505767822],[12.3399991989136,20.5090560913086,9.41489505767822],[12.3489990234375,20.3830547332764,9.41489505767822],[12.3599996566772,20.2680549621582,9.41489505767822],[12.3849992752075,20.1850547790527,9.41489505767822],[12.3849992752075,20.1670551300049,9.41489505767822],[12.4249992370605,20.065055847168,9.41489505767822],[12.4729995727539,19.1350555419922,9.41489505767822],[14.4399995803833,19.2900543212891,9.41489505767822],[14.3649997711182,18.5740547180176,9.41489505767822],[13.5729999542236,20.0310554504395,9.41489505767822],[13.4889993667603,19.9140548706055,9.41489505767822],[13.5639991760254,18.8710556030273,9.41489505767822],[13.6389999389648,20.1310558319092,9.41489505767822],[13.6719989776611,20.2130546569824,9.41489505767822],[13.75,20.3020553588867,9.41489505767822],[12.7399997711182,19.7810554504395,9.41489505767822],[12.6189994812012,19.8520545959473,9.41489505767822],[12.5799999237061,19.1200542449951,9.41489505767822],[12.8349990844727,19.069055557251,9.41489505767822],[11.2669992446899,19.9350547790527,9.41489505767822],[11.1029987335205,19.9230556488037,9.41489505767822],[11.0209999084473,19.2600555419922,9.41489505767822],[11.3819999694824,19.9710559844971,9.41489505767822],[13.418999671936,19.8530559539795,9.41489505767822],[13.4329996109009,18.9160556793213,9.41489505767822],[11.8399991989136,20.6430549621582,9.41489505767822],[13.3119993209839,19.7800559997559,9.41489505767822],[15.2189998626709,19.2600555419922,9.41489505767822],[15.1839990615845,18.1600551605225,9.41489505767822],[15.3639993667603,18.0520553588867,9.41489505767822],[13.0189990997314,19.7250556945801,9.41489505767822],[12.8949995040894,19.7350559234619,9.41489505767822],[15.9039993286133,19.1500549316406,9.41489505767822],[15.7699995040894,19.5140552520752,9.41489505767822],[15.8589992523193,18.9340553283691,9.41489505767822],[14.1939992904663,19.9510555267334,9.41489505767822],[14.2119998931885,20.0630550384521,9.41489505767822],[14.8589992523193,19.149055480957,9.41489505767822],[14.8159999847412,18.3670558929443,9.41489505767822],[14.8959999084473,18.3220558166504,9.41489505767822],[12.5189990997314,19.9360542297363,9.41489505767822],[11.0209999084473,19.9290542602539,9.41489505767822],[11.0209999084473,19.2530555725098,2.67489433288574],[11.0209999084473,19.9300556182861,2.67489433288574],[15.9799995422363,18.505931854248,5.58724021911621],[15.9799995422363,18.5044555664062,9.41489505767822],[15.9799995422363,18.5041732788086,2.67489433288574],[15.9799995422363,18.1684837341309,2.67489433288574],[15.9799995422363,18.1288299560547,9.41489505767822],[15.9799995422363,17.9876575469971,2.67489433288574],[15.9799995422363,17.6247596740723,3.91620373725891],[15.9799995422363,17.6247596740723,2.67489433288574],[15.9799995422363,17.6254329681396,4.32245063781738],[15.9799995422363,17.8920269012451,9.41489505767822],[15.9799995422363,17.8795108795166,2.67489433288574],[15.9799995422363,17.629810333252,4.58585262298584],[15.9799995422363,17.6336059570312,5.27938556671143],[15.9799995422363,17.8311748504639,2.67489433288574],[15.9799995422363,17.638355255127,9.41489505767822],[15.9799995422363,17.6346111297607,5.98653984069824],[15.9799995422363,17.8728256225586,2.67489433288574],[15.9799995422363,18.2221603393555,2.67489433288574] ]; $facets = [ [0,1,2],[0,3,1],[0,4,3],[5,6,7],[8,6,5],[2,9,0],[6,10,11],[12,13,14],[15,16,17],[18,16,15],[19,20,21],[22,23,24],[25,23,22],[26,23,25],[27,23,26],[28,23,27],[29,30,31],[29,32,30],[29,28,32],[33,28,29],[33,23,28],[21,23,33],[20,23,21],[34,35,36],[37,35,34],[38,35,37],[39,35,38],[40,35,39],[41,35,40],[42,35,41],[43,35,42],[44,35,43],[45,35,44],[46,35,45],[47,35,46],[48,35,47],[49,50,51],[52,48,47],[23,49,24],[53,54,55],[56,57,58],[59,57,56],[60,57,59],[61,57,60],[62,57,61],[63,57,62],[64,57,63],[65,57,64],[66,57,65],[13,57,66],[54,67,55],[68,69,70],[71,69,68],[72,69,71],[73,69,72],[74,69,73],[75,69,74],[76,69,75],[77,69,76],[67,69,77],[70,16,68],[70,17,16],[78,79,80],[81,79,78],[82,79,81],[83,79,82],[84,79,83],[85,79,84],[86,79,85],[87,79,86],[88,8,5],[11,7,6],[11,89,7],[11,9,89],[11,0,9],[55,90,53],[55,79,90],[55,80,79],[91,11,10],[92,69,12],[92,70,69],[34,93,37],[47,94,52],[47,95,94],[47,57,95],[47,58,57],[51,24,49],[21,35,19],[21,36,35],[14,92,12],[86,10,87],[86,91,10],[77,55,67],[66,14,13],[96,97,4],[98,99,100],[101,102,98],[103,101,98],[104,103,98],[105,106,107],[108,105,107],[109,108,107],[100,109,107],[110,111,112],[113,110,112],[114,115,116],[117,114,116],[118,119,120],[121,122,123],[124,121,123],[125,126,127],[128,129,130],[131,132,133],[71,131,133],[134,71,133],[135,134,133],[136,135,133],[137,138,139],[140,137,139],[141,140,139],[142,31,141],[142,141,139],[143,126,132],[144,145,146],[147,144,146],[127,147,146],[148,121,124],[149,148,124],[150,149,124],[151,150,124],[152,151,124],[153,152,124],[154,153,124],[155,154,124],[129,156,157],[130,129,157],[158,159,160],[161,158,160],[162,161,160],[163,162,160],[146,163,160],[164,165,166],[167,164,166],[168,169,170],[171,168,170],[139,171,170],[159,172,173],[123,174,142],[175,110,113],[173,175,113],[106,176,177],[178,106,177],[179,180,167],[112,179,167],[175,173,172],[119,118,181],[119,181,97],[119,97,96],[182,98,102],[182,102,183],[182,183,120],[182,120,119],[143,132,184],[184,185,143],[147,127,126],[174,123,122],[159,173,160],[126,125,133],[126,133,132],[186,187,188],[186,188,116],[186,116,115],[99,98,182],[109,100,99],[106,178,107],[114,117,177],[114,177,176],[128,130,187],[128,187,186],[135,136,157],[135,157,156],[163,146,145],[164,167,180],[179,112,111],[171,139,138],[189,155,166],[189,166,165],[149,150,93],[154,155,189],[31,142,174],[114,176,78],[81,78,176],[7,89,183],[89,9,120],[89,120,183],[78,80,114],[176,106,81],[88,5,103],[183,102,7],[118,120,9],[9,2,181],[9,181,118],[115,114,80],[82,81,106],[101,103,5],[102,101,5],[5,7,102],[97,181,2],[2,1,97],[1,3,97],[80,55,115],[172,159,59],[59,56,172],[3,4,97],[4,0,96],[105,108,82],[186,115,55],[82,106,105],[83,82,108],[60,59,159],[175,172,56],[119,96,0],[0,11,119],[108,109,84],[84,83,108],[55,77,186],[56,58,110],[56,110,175],[60,159,158],[11,91,182],[182,119,11],[91,86,182],[85,84,109],[86,85,99],[128,186,77],[58,111,110],[158,161,60],[26,25,137],[138,137,25],[99,182,86],[109,99,85],[77,76,128],[58,47,111],[61,60,161],[137,140,26],[27,26,140],[25,22,138],[129,128,76],[76,75,129],[75,74,129],[74,73,156],[73,72,135],[68,16,184],[68,184,132],[16,18,185],[161,162,62],[62,61,161],[179,111,47],[171,138,22],[156,129,74],[135,156,73],[134,135,72],[72,71,134],[68,132,131],[185,184,16],[18,15,185],[63,62,162],[28,27,140],[22,24,171],[71,68,131],[15,17,143],[15,143,185],[17,70,143],[70,92,126],[162,163,64],[64,63,162],[180,179,47],[47,46,180],[140,141,28],[168,171,24],[126,143,70],[92,14,147],[147,126,92],[14,66,144],[14,144,147],[65,64,163],[66,65,145],[46,45,180],[32,28,141],[24,51,168],[145,144,66],[163,145,65],[164,180,45],[45,44,164],[44,43,164],[43,42,165],[38,37,151],[150,151,37],[37,93,150],[141,31,30],[30,32,141],[169,168,51],[165,164,43],[189,165,42],[42,41,189],[40,39,152],[40,152,153],[151,152,39],[39,38,151],[93,34,149],[154,189,41],[153,154,41],[41,40,153],[148,149,34],[34,36,148],[36,21,121],[31,174,29],[121,148,36],[21,33,122],[21,122,121],[33,29,122],[174,122,29],[116,188,53],[104,98,10],[87,10,98],[98,100,87],[79,87,100],[79,100,107],[90,79,107],[90,107,178],[178,177,90],[53,90,177],[53,177,117],[117,116,53],[54,53,188],[54,188,187],[67,54,187],[67,187,130],[69,67,130],[69,130,157],[12,69,157],[12,157,136],[136,133,12],[12,133,125],[125,127,12],[13,12,127],[127,146,13],[57,13,146],[57,146,160],[95,57,160],[95,160,173],[173,113,95],[94,95,113],[113,112,94],[52,94,112],[48,52,112],[112,167,48],[35,48,167],[35,167,166],[19,35,166],[139,170,50],[50,49,139],[166,155,19],[20,19,155],[155,124,20],[23,20,124],[23,124,123],[49,23,123],[49,123,142],[142,139,49],[190,191,170],[192,191,190],[191,192,51],[191,51,50],[170,169,190],[169,51,192],[169,192,190],[170,191,50],[193,194,195],[196,197,198],[199,200,201],[198,202,203],[204,201,200],[205,204,200],[206,207,208],[206,208,205],[206,205,200],[207,206,209],[207,209,203],[207,203,202],[202,198,197],[197,196,210],[197,210,195],[197,195,194],[8,88,195],[8,195,210],[210,196,8],[196,198,8],[198,203,8],[203,209,8],[209,206,8],[206,200,8],[202,197,104],[207,202,104],[103,104,197],[103,197,194],[193,195,88],[88,103,194],[88,194,193],[200,199,8],[199,201,8],[204,205,6],[6,8,201],[6,201,204],[10,6,205],[10,205,208],[104,10,208],[104,208,207] ]; } elsif ($name eq 'pyramid') { $vertices = [ [10,10,40],[0,0,0],[20,0,0],[20,20,0],[0,20,0], ]; $facets = [ [0,1,2],[0,3,4],[3,1,4],[1,3,2],[3,0,2],[4,1,0], ]; } elsif ($name eq 'two_hollow_squares') { $vertices = [ [66.7133483886719,104.286666870117,0],[66.7133483886719,95.7133331298828,0],[65.6666870117188,94.6666717529297,0],[75.2866821289062,95.7133331298828,0],[76.3333435058594,105.333335876465,0],[76.3333435058594,94.6666717529297,0],[65.6666870117188,105.33332824707,0],[75.2866821289062,104.286666870117,0],[71.1066818237305,104.58666229248,2.79999995231628],[66.4133529663086,104.58666229248,2.79999995231628],[75.5866851806641,104.58666229248,2.79999995231628],[66.4133529663086,99.8933334350586,2.79999995231628],[66.4133529663086,95.4133377075195,2.79999995231628],[71.1066818237305,95.4133377075195,2.79999995231628],[75.5866851806641,95.4133377075195,2.79999995231628],[75.5866851806641,100.106666564941,2.79999995231628],[74.5400161743164,103.540000915527,2.79999995231628],[70.0320129394531,103.540000915527,2.79999995231628],[67.4600067138672,103.540000915527,2.79999995231628],[67.4600067138672,100.968002319336,2.79999995231628],[67.4600067138672,96.4599990844727,2.79999995231628],[74.5400161743164,99.0319976806641,2.79999995231628],[74.5400161743164,96.4599990844727,2.79999995231628],[70.0320129394531,96.4599990844727,2.79999995231628],[123.666717529297,94.6666717529297,0],[134.333312988281,94.6666717529297,0],[124.413360595703,95.4133377075195,2.79999995231628],[129.106674194336,95.4133377075195,2.79999995231628],[133.586669921875,95.4133377075195,2.79999995231628],[123.666717529297,105.33332824707,0],[124.413360595703,104.58666229248,2.79999995231628],[124.413360595703,99.8933334350586,2.79999995231628],[134.333312988281,105.33332824707,0],[129.106674194336,104.58666229248,2.79999995231628],[133.586669921875,104.58666229248,2.79999995231628],[133.586669921875,100.106666564941,2.79999995231628],[124.713317871094,104.286666870117,0],[124.713317871094,95.7133331298828,0],[133.286712646484,95.7133331298828,0],[133.286712646484,104.286666870117,0],[132.540023803711,103.540000915527,2.79999995231628],[128.032028198242,103.540008544922,2.79999995231628],[125.460006713867,103.540000915527,2.79999995231628],[125.460006713867,100.968002319336,2.79999995231628],[125.460006713867,96.4599990844727,2.79999995231628],[132.540023803711,99.0319976806641,2.79999995231628],[132.540023803711,96.4599990844727,2.79999995231628],[128.032028198242,96.4599990844727,2.79999995231628], ]; $facets = [ [0,1,2],[3,4,5],[6,4,0],[6,0,2],[2,1,5],[7,4,3],[1,3,5],[0,4,7],[4,6,8],[6,9,8],[4,8,10],[6,2,9],[2,11,9],[2,12,11],[2,5,12],[5,13,12],[5,14,13],[4,10,15],[5,4,14],[4,15,14],[7,16,17],[0,7,18],[7,17,18],[1,19,20],[1,0,19],[0,18,19],[7,3,21],[3,22,21],[7,21,16],[3,23,22],[3,1,23],[1,20,23],[24,25,26],[25,27,26],[25,28,27],[29,24,30],[24,31,30],[24,26,31],[32,29,33],[29,30,33],[32,33,34],[32,34,35],[25,32,28],[32,35,28],[36,37,24],[38,32,25],[29,32,36],[29,36,24],[24,37,25],[39,32,38],[37,38,25],[36,32,39],[39,40,41],[36,39,42],[39,41,42],[37,43,44],[37,36,43],[36,42,43],[39,38,45],[38,46,45],[39,45,40],[38,47,46],[38,37,47],[37,44,47],[16,8,9],[16,10,8],[10,16,15],[15,16,21],[22,15,21],[15,22,14],[22,23,14],[23,20,14],[17,16,9],[18,17,9],[19,18,9],[19,9,11],[19,11,20],[13,14,20],[20,11,12],[13,20,12],[41,40,30],[42,41,30],[43,42,30],[43,30,31],[43,31,44],[27,28,44],[44,31,26],[27,44,26],[40,33,30],[40,34,33],[34,40,35],[35,40,45],[46,35,45],[35,46,28],[46,47,28],[47,44,28], ]; } elsif ($name eq 'small_dorito') { $vertices = [ [6.00058937072754,-22.9982089996338,0],[22.0010242462158,-49.9998741149902,0],[-9.99957847595215,-49.999870300293,0],[6.00071382522583,-32.2371635437012,28.0019245147705],[11.1670551300049,-37.9727020263672,18.9601669311523],[6.00060224533081,-26.5392456054688,10.7321853637695] ]; $facets = [ [0,1,2],[3,4,5],[2,1,4],[2,4,3],[2,3,5],[2,5,0],[5,4,1],[5,1,0] ]; } elsif ($name eq 'bridge') { $vertices = [ [75,84.5,8],[125,84.5,8],[75,94.5,8],[120,84.5,5],[125,94.5,8],[75,84.5,0],[80,84.5,5],[125,84.5,0],[125,94.5,0],[80,94.5,5],[75,94.5,0],[120,94.5,5],[120,84.5,0],[80,94.5,0],[80,84.5,0],[120,94.5,0] ]; $facets = [ [0,1,2],[1,0,3],[2,1,4],[2,5,0],[0,6,3],[1,3,7],[1,8,4],[4,9,2],[10,5,2],[5,6,0],[6,11,3],[3,12,7],[7,8,1],[4,8,11],[4,11,9],[9,10,2],[10,13,5],[14,6,5],[9,11,6],[11,12,3],[12,8,7],[11,8,15],[13,10,9],[5,13,14],[14,13,6],[6,13,9],[15,12,11],[15,8,12] ]; } else { return undef; } my $mesh = Slic3r::TriangleMesh->new; $mesh->ReadFromPerl($vertices, $facets); $mesh->repair; $mesh->scale_xyz(Slic3r::Pointf3->new(@{$params{scale_xyz}})) if $params{scale_xyz}; $mesh->translate(@{$params{translate}}) if $params{translate}; return $mesh; } sub model { my ($model_name, %params) = @_; my $input_file = "${model_name}.stl"; my $mesh = mesh($model_name, %params); # $mesh->write_ascii("out/$input_file"); my $model = Slic3r::Model->new; my $object = $model->add_object(input_file => $input_file); $model->set_material($model_name); $object->add_volume(mesh => $mesh, material_id => $model_name); $object->add_instance( offset => Slic3r::Pointf->new(0,0), rotation => $params{rotation} // 0, scaling_factor => $params{scale} // 1, ); return $model; } sub init_print { my ($models, %params) = @_; my $config = Slic3r::Config->new; $config->apply($params{config}) if $params{config}; $config->set('gcode_comments', 1) if $ENV{SLIC3R_TESTS_GCODE}; my $print = Slic3r::Print->new; $print->apply_config($config); $models = [$models] if ref($models) ne 'ARRAY'; $models = [ map { ref($_) ? $_ : model($_, %params) } @$models ]; for my $model (@$models) { die "Unknown model in test" if !defined $model; if (defined $params{duplicate} && $params{duplicate} > 1) { $model->duplicate($params{duplicate} // 1, $print->config->min_object_distance); } $model->arrange_objects($print->config->min_object_distance); $model->center_instances_around_point($params{print_center} ? Slic3r::Pointf->new(@{$params{print_center}}) : Slic3r::Pointf->new(100,100)); foreach my $model_object (@{$model->objects}) { $print->auto_assign_extruders($model_object); $print->add_model_object($model_object); } } $print->validate; # We return a proxy object in order to keep $models alive as required by the Print API. return Slic3r::Test::Print->new( print => $print, models => $models, ); } sub gcode { my ($print) = @_; $print = $print->print if $print->isa('Slic3r::Test::Print'); my $fh = IO::Scalar->new(\my $gcode); $print->process; $print->export_gcode(output_fh => $fh, quiet => 1); $fh->close; return $gcode; } sub _eq { my ($a, $b) = @_; return abs($a - $b) < epsilon; } sub add_facet { my ($facet, $vertices, $facets) = @_; push @$facets, []; for my $i (0..2) { my $v = first { $vertices->[$_][X] == $facet->[$i][X] && $vertices->[$_][Y] == $facet->[$i][Y] && $vertices->[$_][Z] == $facet->[$i][Z] } 0..$#$vertices; if (!defined $v) { push @$vertices, [ @{$facet->[$i]}[X,Y,Z] ]; $v = $#$vertices; } $facets->[-1][$i] = $v; } } package Slic3r::Test::Print; use Moo; has 'print' => (is => 'ro', required => 1, handles => [qw(process apply_config)]); has 'models' => (is => 'ro', required => 1); 1; Slic3r-version_1.31.6/lib/Slic3r/Test/000077500000000000000000000000001301441720000173225ustar00rootroot00000000000000Slic3r-version_1.31.6/lib/Slic3r/Test/SectionCut.pm000066400000000000000000000164321301441720000217460ustar00rootroot00000000000000# 2D cut in the XZ plane through the toolpaths. # For debugging purposes. package Slic3r::Test::SectionCut; use Moo; use List::Util qw(first min max); use Slic3r::Geometry qw(unscale); use Slic3r::Geometry::Clipper qw(intersection_pl); use SVG; use Slic3r::SVG; has 'print' => (is => 'ro', required => 1); has 'scale' => (is => 'ro', default => sub { 30 }); has 'y_percent' => (is => 'ro', default => sub { 0.5 }); # Y coord of section line expressed as factor has 'line' => (is => 'rw'); has '_height' => (is => 'rw'); has '_svg' => (is => 'rw'); has '_svg_style' => (is => 'rw', default => sub { {} }); sub BUILD { my $self = shift; # calculate the Y coordinate of the section line my $bb = $self->print->bounding_box; my $y = ($bb->y_min + $bb->y_max) * $self->y_percent; # store our section line $self->line(Slic3r::Line->new([ $bb->x_min, $y ], [ $bb->x_max, $y ])); } sub export_svg { my $self = shift; my ($filename) = @_; # get bounding box of print and its height # (Print should return a BoundingBox3 object instead) my $bb = $self->print->bounding_box; my $print_size = $bb->size; $self->_height(max(map $_->print_z, map @{$_->layers}, @{$self->print->objects})); # initialize the SVG canvas $self->_svg(my $svg = SVG->new( width => $self->scale * unscale($print_size->x), height => $self->scale * $self->_height, )); # set default styles $self->_svg_style->{'stroke-width'} = 1; $self->_svg_style->{'fill-opacity'} = 0.5; $self->_svg_style->{'stroke-opacity'} = 0.2; # plot perimeters $self->_svg_style->{'stroke'} = '#EE0000'; $self->_svg_style->{'fill'} = '#FF0000'; $self->_plot_group(sub { map @{$_->perimeters}, @{$_[0]->regions} }); # plot infill $self->_svg_style->{'stroke'} = '#444444'; $self->_svg_style->{'fill'} = '#454545'; $self->_plot_group(sub { map @{$_->fills}, @{$_[0]->regions} }); # plot support material $self->_svg_style->{'stroke'} = '#12EF00'; $self->_svg_style->{'fill'} = '#22FF00'; $self->_plot_group(sub { $_[0]->isa('Slic3r::Layer::Support') ? ($_[0]->support_fills, $_[0]->support_interface_fills) : () }); Slic3r::open(\my $fh, '>', $filename); print $fh $svg->xmlify; close $fh; printf "Section cut SVG written to %s\n", $filename; } sub _plot_group { my $self = shift; my ($filter) = @_; my $bb = $self->print->bounding_box; my $g = $self->_svg->group(style => { %{$self->_svg_style} }); foreach my $object (@{$self->print->objects}) { foreach my $copy (@{$object->_shifted_copies}) { foreach my $layer (@{$object->layers}, @{$object->support_layers}) { # get all ExtrusionPath objects my @paths = map $_->clone, map { ($_->isa('Slic3r::ExtrusionLoop') || $_->isa('Slic3r::ExtrusionPath::Collection')) ? @$_ : $_ } grep defined $_, $filter->($layer); # move paths to location of copy $_->polyline->translate(@$copy) for @paths; if (0) { # export plan with section line and exit require "Slic3r/SVG.pm"; Slic3r::SVG::output( "line.svg", no_arrows => 1, lines => [ $self->line ], red_polylines => [ map $_->polyline, @paths ], ); exit; } foreach my $path (@paths) { foreach my $line (@{$path->lines}) { my @intersections = @{intersection_pl( [ $self->line->as_polyline ], $line->grow(Slic3r::Geometry::scale $path->width/2), )}; die "Intersection has more than two points!\n" if defined first { @$_ > 2 } @intersections; # turn intersections to lines my @lines = map Slic3r::Line->new(@$_), @intersections; # align intersections to canvas $_->translate(-$bb->x_min, 0) for @lines; # we want lines oriented from left to right in order to draw # rectangles correctly foreach my $line (@lines) { $line->reverse if $line->a->x > $line->b->x; } if ($path->is_bridge) { foreach my $line (@lines) { my $radius = $path->width / 2; my $width = unscale abs($line->b->x - $line->a->x); if ((10 * $radius) < $width) { # we're cutting the path in the longitudinal direction, so we've got a rectangle $g->rectangle( 'x' => $self->scale * unscale($line->a->x), 'y' => $self->scale * $self->_y($layer->print_z), 'width' => $self->scale * $width, 'height' => $self->scale * $radius * 2, 'rx' => $self->scale * $radius * 0.35, 'ry' => $self->scale * $radius * 0.35, ); } else { $g->circle( 'cx' => $self->scale * (unscale($line->a->x) + $radius), 'cy' => $self->scale * $self->_y($layer->print_z - $radius), 'r' => $self->scale * $radius, ); } } } else { foreach my $line (@lines) { my $height = $path->height; $height = $layer->height if $height == -1; $g->rectangle( 'x' => $self->scale * unscale($line->a->x), 'y' => $self->scale * $self->_y($layer->print_z), 'width' => $self->scale * unscale($line->b->x - $line->a->x), 'height' => $self->scale * $height, 'rx' => $self->scale * $height * 0.5, 'ry' => $self->scale * $height * 0.5, ); } } } } } } } } sub _y { my $self = shift; my ($y) = @_; return $self->_height - $y; } 1; Slic3r-version_1.31.6/slic3r.pl000077500000000000000000000713201301441720000162400ustar00rootroot00000000000000#!/usr/bin/env perl use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/lib"; } use File::Basename qw(basename); use Getopt::Long qw(:config no_auto_abbrev); use List::Util qw(first); use POSIX qw(setlocale LC_NUMERIC); use Slic3r; use Time::HiRes qw(gettimeofday tv_interval); $|++; binmode STDOUT, ':utf8'; our %opt = (); my %cli_options = (); { my %options = ( 'help' => sub { usage() }, 'version' => sub { print "$Slic3r::VERSION\n"; exit 0 }, 'debug' => \$Slic3r::debug, 'gui' => \$opt{gui}, 'o|output=s' => \$opt{output}, 'save=s' => \$opt{save}, 'load=s@' => \$opt{load}, 'autosave=s' => \$opt{autosave}, 'ignore-nonexistent-config' => \$opt{ignore_nonexistent_config}, 'no-controller' => \$opt{no_controller}, 'no-plater' => \$opt{no_plater}, 'gui-mode=s' => \$opt{gui_mode}, 'datadir=s' => \$opt{datadir}, 'export-svg' => \$opt{export_svg}, 'merge|m' => \$opt{merge}, 'repair' => \$opt{repair}, 'cut=f' => \$opt{cut}, 'split' => \$opt{split}, 'info' => \$opt{info}, 'scale=f' => \$opt{scale}, 'rotate=i' => \$opt{rotate}, 'duplicate=i' => \$opt{duplicate}, 'duplicate-grid=s' => \$opt{duplicate_grid}, 'print-center=s' => \$opt{print_center}, 'dont-arrange' => \$opt{dont_arrange}, ); foreach my $opt_key (keys %{$Slic3r::Config::Options}) { my $cli = $Slic3r::Config::Options->{$opt_key}->{cli} or next; # allow both the dash-separated option name and the full opt_key $options{ "$opt_key|$cli" } = \$cli_options{$opt_key}; } @ARGV = grep !/^-psn_\d/, @ARGV if $^O eq 'darwin'; GetOptions(%options) or usage(1); } # load configuration files my @external_configs = (); if ($opt{load}) { foreach my $configfile (@{$opt{load}}) { $configfile = Slic3r::decode_path($configfile); if (-e $configfile) { push @external_configs, Slic3r::Config->load($configfile); } elsif (-e "$FindBin::Bin/$configfile") { printf STDERR "Loading $FindBin::Bin/$configfile\n"; push @external_configs, Slic3r::Config->load("$FindBin::Bin/$configfile"); } else { $opt{ignore_nonexistent_config} or die "Cannot find specified configuration file ($configfile).\n"; } } } # process command line options my $cli_config = Slic3r::Config->new; foreach my $c (@external_configs, Slic3r::Config->new_from_cli(%cli_options)) { $c->normalize; # expand shortcuts before applying, otherwise destination values would be already filled with defaults $cli_config->apply($c); } # save configuration if ($opt{save}) { if (@{$cli_config->get_keys} > 0) { $cli_config->save($opt{save}); } else { Slic3r::Config->new_from_defaults->save($opt{save}); } } # apply command line config on top of default config my $config = Slic3r::Config->new_from_defaults; $config->apply($cli_config); # launch GUI my $gui; if ((!@ARGV || $opt{gui}) && !$opt{save} && eval "require Slic3r::GUI; 1") { { no warnings 'once'; $Slic3r::GUI::datadir = Slic3r::decode_path($opt{datadir} // ''); $Slic3r::GUI::no_controller = $opt{no_controller}; $Slic3r::GUI::no_plater = $opt{no_plater}; $Slic3r::GUI::mode = $opt{gui_mode}; $Slic3r::GUI::autosave = $opt{autosave}; } $gui = Slic3r::GUI->new; setlocale(LC_NUMERIC, 'C'); $gui->{mainframe}->load_config_file($_) for @{$opt{load}}; $gui->{mainframe}->load_config($cli_config); foreach my $input_file (@ARGV) { $input_file = Slic3r::decode_path($input_file); $gui->{mainframe}{plater}->load_file($input_file) unless $opt{no_plater}; } $gui->MainLoop; exit; } die $@ if $@ && $opt{gui}; if (@ARGV) { # slicing from command line $config->validate; if ($opt{repair}) { foreach my $file (@ARGV) { $file = Slic3r::decode_path($file); die "Repair is currently supported only on STL files\n" if $file !~ /\.stl$/i; my $output_file = $file; $output_file =~ s/\.(stl)$/_fixed.obj/i; my $tmesh = Slic3r::TriangleMesh->new; $tmesh->ReadSTLFile($file); $tmesh->repair; $tmesh->WriteOBJFile($output_file); } exit; } if ($opt{cut}) { foreach my $file (@ARGV) { $file = Slic3r::decode_path($file); my $model = Slic3r::Model->read_from_file($file); $model->add_default_instances; my $mesh = $model->mesh; $mesh->translate(0, 0, -$mesh->bounding_box->z_min); my $upper = Slic3r::TriangleMesh->new; my $lower = Slic3r::TriangleMesh->new; $mesh->cut($opt{cut}, $upper, $lower); $upper->repair; $lower->repair; $upper->write_ascii("${file}_upper.stl") if $upper->facets_count > 0; $lower->write_ascii("${file}_lower.stl") if $lower->facets_count > 0; } exit; } if ($opt{split}) { foreach my $file (@ARGV) { $file = Slic3r::decode_path($file); my $model = Slic3r::Model->read_from_file($file); $model->add_default_instances; my $mesh = $model->mesh; $mesh->repair; my $part_count = 0; foreach my $new_mesh (@{$mesh->split}) { my $output_file = sprintf '%s_%02d.stl', $file, ++$part_count; printf "Writing to %s\n", basename($output_file); Slic3r::Format::STL->write_file($output_file, $new_mesh, binary => 1); } } exit; } while (my $input_file = shift @ARGV) { $input_file = Slic3r::decode_path($input_file); my $model; if ($opt{merge}) { my @models = map Slic3r::Model->read_from_file($_), $input_file, (splice @ARGV, 0); $model = Slic3r::Model->merge(@models); } else { $model = Slic3r::Model->read_from_file($input_file); } if ($opt{info}) { $model->print_info; next; } if (defined $opt{duplicate_grid}) { $opt{duplicate_grid} = [ split /[,x]/, $opt{duplicate_grid}, 2 ]; } if (defined $opt{print_center}) { $opt{print_center} = Slic3r::Pointf->new(split /[,x]/, $opt{print_center}, 2); } my $sprint = Slic3r::Print::Simple->new( scale => $opt{scale} // 1, rotate => $opt{rotate} // 0, duplicate => $opt{duplicate} // 1, duplicate_grid => $opt{duplicate_grid} // [1,1], print_center => $opt{print_center} // Slic3r::Pointf->new(100,100), dont_arrange => $opt{dont_arrange} // 0, status_cb => sub { my ($percent, $message) = @_; printf "=> %s\n", $message; }, output_file => $opt{output}, ); $sprint->apply_config($config); $sprint->set_model($model); if ($opt{export_svg}) { $sprint->export_svg; } else { my $t0 = [gettimeofday]; $sprint->export_gcode; # output some statistics { my $duration = tv_interval($t0); printf "Done. Process took %d minutes and %.3f seconds\n", int($duration/60), ($duration - int($duration/60)*60); # % truncates to integer } printf "Filament required: %.1fmm (%.1fcm3)\n", $sprint->total_used_filament, $sprint->total_extruded_volume/1000; } } } else { usage(1) unless $opt{save}; } sub usage { my ($exit_code) = @_; my $config = Slic3r::Config->new_from_defaults->as_hash; my $j = ''; if ($Slic3r::have_threads) { $j = <<"EOF"; -j, --threads Number of threads to use (1+, default: $config->{threads}) EOF } print <<"EOF"; Slic3r $Slic3r::VERSION is a STL-to-GCODE translator for RepRap 3D printers written by Alessandro Ranellucci - http://slic3r.org/ Usage: slic3r.pl [ OPTIONS ] [ file.stl ] [ file2.stl ] ... --help Output this usage screen and exit --version Output the version of Slic3r and exit --save Save configuration to the specified file --load Load configuration from the specified file. It can be used more than once to load options from multiple files. -o, --output File to output gcode to (by default, the file will be saved into the same directory as the input file using the --output-filename-format to generate the filename.) If a directory is specified for this option, the output will be saved under that directory, and the filename will be generated by --output-filename-format. Non-slicing actions (no G-code will be generated): --repair Repair given STL files and save them as _fixed.obj --cut Cut given input files at given Z (relative) and export them as _upper.stl and _lower.stl --split Split the shells contained in given STL file into several STL files --info Output information about the supplied file(s) and exit $j GUI options: --gui Forces the GUI launch instead of command line slicing (if you supply a model file, it will be loaded into the plater) --no-plater Disable the plater tab --gui-mode Overrides the configured mode (simple/expert) --autosave Automatically export current configuration to the specified file Output options: --output-filename-format Output file name format; all config options enclosed in brackets will be replaced by their values, as well as [input_filename_base] and [input_filename] (default: $config->{output_filename_format}) --post-process Generated G-code will be processed with the supplied script; call this more than once to process through multiple scripts. --export-svg Export a SVG file containing slices instead of G-code. -m, --merge If multiple files are supplied, they will be composed into a single print rather than processed individually. Printer options: --nozzle-diameter Diameter of nozzle in mm (default: $config->{nozzle_diameter}->[0]) --print-center Coordinates in mm of the point to center the print around (default: 100,100) --z-offset Additional height in mm to add to vertical coordinates (+/-, default: $config->{z_offset}) --gcode-flavor The type of G-code to generate (reprap/teacup/makerware/sailfish/mach3/machinekit/no-extrusion, default: $config->{gcode_flavor}) --use-relative-e-distances Enable this to get relative E values (default: no) --use-firmware-retraction Enable firmware-controlled retraction using G10/G11 (default: no) --use-volumetric-e Express E in cubic millimeters and prepend M200 (default: no) --gcode-arcs Use G2/G3 commands for native arcs (experimental, not supported by all firmwares) --gcode-comments Make G-code verbose by adding comments (default: no) --pressure-advance Adjust pressure using the experimental advance algorithm (K constant, set zero to disable; default: $config->{pressure_advance}) Filament options: --filament-diameter Diameter in mm of your raw filament (default: $config->{filament_diameter}->[0]) --extrusion-multiplier Change this to alter the amount of plastic extruded. There should be very little need to change this value, which is only useful to compensate for filament packing (default: $config->{extrusion_multiplier}->[0]) --temperature Extrusion temperature in degree Celsius, set 0 to disable (default: $config->{temperature}->[0]) --first-layer-temperature Extrusion temperature for the first layer, in degree Celsius, set 0 to disable (default: same as --temperature) --bed-temperature Heated bed temperature in degree Celsius, set 0 to disable (default: $config->{bed_temperature}) --first-layer-bed-temperature Heated bed temperature for the first layer, in degree Celsius, set 0 to disable (default: same as --bed-temperature) Speed options: --travel-speed Speed of non-print moves in mm/s (default: $config->{travel_speed}) --perimeter-speed Speed of print moves for perimeters in mm/s (default: $config->{perimeter_speed}) --small-perimeter-speed Speed of print moves for small perimeters in mm/s or % over perimeter speed (default: $config->{small_perimeter_speed}) --external-perimeter-speed Speed of print moves for the external perimeter in mm/s or % over perimeter speed (default: $config->{external_perimeter_speed}) --infill-speed Speed of print moves in mm/s (default: $config->{infill_speed}) --solid-infill-speed Speed of print moves for solid surfaces in mm/s or % over infill speed (default: $config->{solid_infill_speed}) --top-solid-infill-speed Speed of print moves for top surfaces in mm/s or % over solid infill speed (default: $config->{top_solid_infill_speed}) --support-material-speed Speed of support material print moves in mm/s (default: $config->{support_material_speed}) --support-material-interface-speed Speed of support material interface print moves in mm/s or % over support material speed (default: $config->{support_material_interface_speed}) --bridge-speed Speed of bridge print moves in mm/s (default: $config->{bridge_speed}) --gap-fill-speed Speed of gap fill print moves in mm/s (default: $config->{gap_fill_speed}) --first-layer-speed Speed of print moves for bottom layer, expressed either as an absolute value or as a percentage over normal speeds (default: $config->{first_layer_speed}) Acceleration options: --perimeter-acceleration Overrides firmware's default acceleration for perimeters. (mm/s^2, set zero to disable; default: $config->{perimeter_acceleration}) --infill-acceleration Overrides firmware's default acceleration for infill. (mm/s^2, set zero to disable; default: $config->{infill_acceleration}) --bridge-acceleration Overrides firmware's default acceleration for bridges. (mm/s^2, set zero to disable; default: $config->{bridge_acceleration}) --first-layer-acceleration Overrides firmware's default acceleration for first layer. (mm/s^2, set zero to disable; default: $config->{first_layer_acceleration}) --default-acceleration Acceleration will be reset to this value after the specific settings above have been applied. (mm/s^2, set zero to disable; default: $config->{default_acceleration}) Accuracy options: --layer-height Layer height in mm (default: $config->{layer_height}) --first-layer-height Layer height for first layer (mm or %, default: $config->{first_layer_height}) --infill-every-layers Infill every N layers (default: $config->{infill_every_layers}) --solid-infill-every-layers Force a solid layer every N layers (default: $config->{solid_infill_every_layers}) Print options: --perimeters Number of perimeters/horizontal skins (range: 0+, default: $config->{perimeters}) --top-solid-layers Number of solid layers to do for top surfaces (range: 0+, default: $config->{top_solid_layers}) --bottom-solid-layers Number of solid layers to do for bottom surfaces (range: 0+, default: $config->{bottom_solid_layers}) --solid-layers Shortcut for setting the two options above at once --fill-density Infill density (range: 0%-100%, default: $config->{fill_density}%) --fill-angle Infill angle in degrees (range: 0-90, default: $config->{fill_angle}) --fill-pattern Pattern to use to fill non-solid layers (default: $config->{fill_pattern}) --external-fill-pattern Pattern to use to fill solid layers (default: $config->{external_fill_pattern}) --start-gcode Load initial G-code from the supplied file. This will overwrite the default command (home all axes [G28]). --end-gcode Load final G-code from the supplied file. This will overwrite the default commands (turn off temperature [M104 S0], home X axis [G28 X], disable motors [M84]). --before-layer-gcode Load before-layer-change G-code from the supplied file (default: nothing). --layer-gcode Load layer-change G-code from the supplied file (default: nothing). --toolchange-gcode Load tool-change G-code from the supplied file (default: nothing). --seam-position Position of loop starting points (random/nearest/aligned, default: $config->{seam_position}). --external-perimeters-first Reverse perimeter order. (default: no) --spiral-vase Experimental option to raise Z gradually when printing single-walled vases (default: no) --only-retract-when-crossing-perimeters Disable retraction when travelling between infill paths inside the same island. (default: no) --solid-infill-below-area Force solid infill when a region has a smaller area than this threshold (mm^2, default: $config->{solid_infill_below_area}) --infill-only-where-needed Only infill under ceilings (default: no) --infill-first Make infill before perimeters (default: no) Quality options (slower slicing): --extra-perimeters Add more perimeters when needed (default: yes) --ensure-vertical-shell-thickness Add solid infill near sloping surfaces to guarantee the vertical shell thickness (top+bottom solid layers). (default: no) --avoid-crossing-perimeters Optimize travel moves so that no perimeters are crossed (default: no) --thin-walls Detect single-width walls (default: yes) --overhangs Experimental option to use bridge flow, speed and fan for overhangs (default: yes) Support material options: --support-material Generate support material for overhangs --support-material-threshold Overhang threshold angle (range: 0-90, set 0 for automatic detection, default: $config->{support_material_threshold}) --support-material-pattern Pattern to use for support material (default: $config->{support_material_pattern}) --support-material-with-sheath Add a sheath (a single perimeter line) around the base support. This makes the support more reliable, but also more difficult to remove. (default: yes) --support-material-spacing Spacing between pattern lines (mm, default: $config->{support_material_spacing}) --support-material-angle Support material angle in degrees (range: 0-90, default: $config->{support_material_angle}) --support-material-contact-distance Vertical distance between object and support material (0+, default: $config->{support_material_contact_distance}) --support-material-interface-layers Number of perpendicular layers between support material and object (0+, default: $config->{support_material_interface_layers}) --support-material-interface-spacing Spacing between interface pattern lines (mm, set 0 to get a solid layer, default: $config->{support_material_interface_spacing}) --raft-layers Number of layers to raise the printed objects by (range: 0+, default: $config->{raft_layers}) --support-material-enforce-layers Enforce support material on the specified number of layers from bottom, regardless of --support-material and threshold (0+, default: $config->{support_material_enforce_layers}) --support-material-buildplate-only Only create support if it lies on a build plate. Don't create support on a print. (default: no) --dont-support-bridges Experimental option for preventing support material from being generated under bridged areas (default: yes) Retraction options: --retract-length Length of retraction in mm when pausing extrusion (default: $config->{retract_length}[0]) --retract-speed Speed for retraction in mm/s (default: $config->{retract_speed}[0]) --retract-restart-extra Additional amount of filament in mm to push after compensating retraction (default: $config->{retract_restart_extra}[0]) --retract-before-travel Only retract before travel moves of this length in mm (default: $config->{retract_before_travel}[0]) --retract-lift Lift Z by the given distance in mm when retracting (default: $config->{retract_lift}[0]) --retract-lift-above Only lift Z when above the specified height (default: $config->{retract_lift_above}[0]) --retract-lift-below Only lift Z when below the specified height (default: $config->{retract_lift_below}[0]) --retract-layer-change Enforce a retraction before each Z move (default: no) --wipe Wipe the nozzle while doing a retraction (default: no) Retraction options for multi-extruder setups: --retract-length-toolchange Length of retraction in mm when disabling tool (default: $config->{retract_length_toolchange}[0]) --retract-restart-extra-toolchange Additional amount of filament in mm to push after switching tool (default: $config->{retract_restart_extra_toolchange}[0]) Cooling options: --cooling Enable fan and cooling control --min-fan-speed Minimum fan speed (default: $config->{min_fan_speed}%) --max-fan-speed Maximum fan speed (default: $config->{max_fan_speed}%) --bridge-fan-speed Fan speed to use when bridging (default: $config->{bridge_fan_speed}%) --fan-below-layer-time Enable fan if layer print time is below this approximate number of seconds (default: $config->{fan_below_layer_time}) --slowdown-below-layer-time Slow down if layer print time is below this approximate number of seconds (default: $config->{slowdown_below_layer_time}) --min-print-speed Minimum print speed (mm/s, default: $config->{min_print_speed}) --disable-fan-first-layers Disable fan for the first N layers (default: $config->{disable_fan_first_layers}) --fan-always-on Keep fan always on at min fan speed, even for layers that don't need cooling Skirt options: --skirts Number of skirts to draw (0+, default: $config->{skirts}) --skirt-distance Distance in mm between innermost skirt and object (default: $config->{skirt_distance}) --skirt-height Height of skirts to draw (expressed in layers, 0+, default: $config->{skirt_height}) --min-skirt-length Generate no less than the number of loops required to consume this length of filament on the first layer, for each extruder (mm, 0+, default: $config->{min_skirt_length}) --brim-width Width of the brim that will get added to each object to help adhesion (mm, default: $config->{brim_width}) Transform options: --scale Factor for scaling input object (default: 1) --rotate Rotation angle in degrees (0-360, default: 0) --duplicate Number of items with auto-arrange (1+, default: 1) --duplicate-grid Number of items with grid arrangement (default: 1,1) --duplicate-distance Distance in mm between copies (default: $config->{duplicate_distance}) --dont-arrange Don't arrange the objects on the build plate. The model coordinates define the absolute positions on the build plate. The option --print-center will be ignored. --xy-size-compensation Grow/shrink objects by the configured absolute distance (mm, default: $config->{xy_size_compensation}) Sequential printing options: --complete-objects When printing multiple objects and/or copies, complete each one before starting the next one; watch out for extruder collisions (default: no) --extruder-clearance-radius Radius in mm above which extruder won't collide with anything (default: $config->{extruder_clearance_radius}) --extruder-clearance-height Maximum vertical extruder depth; i.e. vertical distance from extruder tip and carriage bottom (default: $config->{extruder_clearance_height}) Miscellaneous options: --notes Notes to be added as comments to the output file --resolution Minimum detail resolution (mm, set zero for full resolution, default: $config->{resolution}) Flow options (advanced): --extrusion-width Set extrusion width manually; it accepts either an absolute value in mm (like 0.65) or a percentage over layer height (like 200%) --first-layer-extrusion-width Set a different extrusion width for first layer --perimeter-extrusion-width Set a different extrusion width for perimeters --external-perimeter-extrusion-width Set a different extrusion width for external perimeters --infill-extrusion-width Set a different extrusion width for infill --solid-infill-extrusion-width Set a different extrusion width for solid infill --top-infill-extrusion-width Set a different extrusion width for top infill --support-material-extrusion-width Set a different extrusion width for support material --infill-overlap Overlap between infill and perimeters (default: $config->{infill_overlap}) --bridge-flow-ratio Multiplier for extrusion when bridging (> 0, default: $config->{bridge_flow_ratio}) Multiple extruder options: --extruder-offset Offset of each extruder, if firmware doesn't handle the displacement (can be specified multiple times, default: 0x0) --perimeter-extruder Extruder to use for perimeters and brim (1+, default: $config->{perimeter_extruder}) --infill-extruder Extruder to use for infill (1+, default: $config->{infill_extruder}) --solid-infill-extruder Extruder to use for solid infill (1+, default: $config->{solid_infill_extruder}) --support-material-extruder Extruder to use for support material, raft and skirt (1+, default: $config->{support_material_extruder}) --support-material-interface-extruder Extruder to use for support material interface (1+, default: $config->{support_material_interface_extruder}) --ooze-prevention Drop temperature and park extruders outside a full skirt for automatic wiping (default: no) --standby-temperature-delta Temperature difference to be applied when an extruder is not active and --ooze-prevention is enabled (default: $config->{standby_temperature_delta}) EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/slic3r.sublime-project000066400000000000000000000064721301441720000207340ustar00rootroot00000000000000{ "build_systems": [ { "name": "List", //"file_regex": " at ([^-\\s]*) line ([0-9]*)", // "file_regex": " at (D\\:\\/src\\/Slic3r\\/.*?) line ([0-9]*)", "shell_cmd": "ls -l" }, { "name": "Run", "working_dir": "$project_path", "file_regex": " at (.*?) line ([0-9]*)", "shell_cmd": "chdir & perl slic3r.pl --DataDir \"C:\\Users\\Public\\Documents\\Prusa3D\\Slic3r settings MK2\" --gui \"..\\Slic3r-tests\\gap fill torture 20 -rt.stl\"" }, { "name": "full", "file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$", "shell_cmd": "chdir & perl Build.pl" }, { "name": "xs", "working_dir": "$project_path/xs", // for Visual Studio: "file_regex": "^(..[^:]*)\\(([0-9]+)\\)(.*)$", // For GCC: // "file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$", "shell_cmd": "chdir & perl Build install", "env": { // "PATH": "C:\\Program Files (x86)\\MSBuild\\12.0\\bin\\amd64;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\BIN\\amd64;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\Common7\\IDE;C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\Common7\\Tools;%PATH%;c:\\wperl64d\\site\\bin;c:\\wperl64d\\bin", // "PERL_CPANM_HOME": "c:\\wperl64d\\cpanm", // "WXDIR": "D:\\src-perl\\wxWidgets-3.0.3-beta1", // "BOOST_DIR": "D:\\src-perl\\boost_1_61_0", // "BOOST_INCLUDEDIR": "D:\\src-perl\\boost_1_61_0", // "BOOST_LIBRARYDIR": "D:\\src-perl\\boost_1_61_0\\stage\\x64\\lib", // "SLIC3R_STATIC": "1" } }, { "name": "xs & run", "working_dir": "$project_path/xs", "file_regex": "^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$", "shell_cmd": "chdir & perl Build install & cd .. & perl slic3r.pl --gui \"..\\Slic3r-tests\\star3-big2.stl\"" } ], "folders": [ { "path": ".", // "folder_exclude_patterns": [".svn", "._d", ".metadata", ".settings"], "file_exclude_patterns": ["XS.c"] } ], "settings": { "sublimegdb_workingdir": "${folder:${project_path:run}}", // NOTE: You MUST provide --interpreter=mi for the plugin to work // "sublimegdb_commandline": "D:\\Qt\\Tools\\mingw492_32\\bin\\gdb.exe --interpreter=mi -ex 'target localhost:2345'", // "sublimegdb_commandline": "D:\\Qt\\Tools\\mingw492_32\\bin\\gdb.exe --interpreter=mi perl --args perl slic3r.pl", // "sublimegdb_commandline": "D:\\Qt\\Tools\\mingw492_32\\bin\\gdb.exe --interpreter=mi perl --args slic3r.pl ", // "sublimegdb_commandline": "D:\\Qt\\Tools\\mingw492_32\\bin\\gdb.exe --interpreter=mi -e C:\\Strawberry\\perl\\bin\\perl.exe -s C:\\Strawberry\\perl\\site\\lib\\auto\\Slic3r\\XS\\XS.xs.dll --args perl slic3r.pl -j 1 --gui D:\\src\\Slic3r-tests\\star3-big.stl", "sublimegdb_commandline": "D:\\Qt\\Tools\\mingw492_32\\bin\\gdb.exe --interpreter=mi perl.exe --args perl slic3r.pl -j 1 --gui", // D:\\src\\Slic3r-tests\\star3-big.stl", // "sublimegdb_commandline": "D:\\Qt\\Tools\\mingw492_32\\bin\\gdb.exe --interpreter=mi -x slic3r.gdb", // "arguments": "slic3r -j 1 --gui ../Slic3r-tests/star3-big.stl", // "arguments": "../slic3r.pl -j 1 --gui", // "sublimegdb_exec_cmd": "-exec-continue", // Add "pending breakpoints" for symbols that are dynamically loaded from // external shared libraries "debug_ext" : true, "run_after_init": false, "close_views": false } } Slic3r-version_1.31.6/t/000077500000000000000000000000001301441720000147415ustar00rootroot00000000000000Slic3r-version_1.31.6/t/angles.t000066400000000000000000000057461301441720000164130ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 34; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Geometry qw(rad2deg_dir angle3points PI); #========================================================== { is line_atan([ [0, 0], [10, 0] ]), (0), 'E atan2'; is line_atan([ [10, 0], [0, 0] ]), (PI), 'W atan2'; is line_atan([ [0, 0], [0, 10] ]), (PI/2), 'N atan2'; is line_atan([ [0, 10], [0, 0] ]), -(PI/2), 'S atan2'; is line_atan([ [10, 10], [0, 0] ]), -(PI*3/4), 'SW atan2'; is line_atan([ [0, 0], [10, 10] ]), (PI*1/4), 'NE atan2'; is line_atan([ [0, 10], [10, 0] ]), -(PI*1/4), 'SE atan2'; is line_atan([ [10, 0], [0, 10] ]), (PI*3/4), 'NW atan2'; } #========================================================== { is line_orientation([ [0, 0], [10, 0] ]), (0), 'E orientation'; is line_orientation([ [0, 0], [0, 10] ]), (PI/2), 'N orientation'; is line_orientation([ [10, 0], [0, 0] ]), (PI), 'W orientation'; is line_orientation([ [0, 10], [0, 0] ]), (PI*3/2), 'S orientation'; is line_orientation([ [0, 0], [10, 10] ]), (PI*1/4), 'NE orientation'; is line_orientation([ [10, 0], [0, 10] ]), (PI*3/4), 'NW orientation'; is line_orientation([ [10, 10], [0, 0] ]), (PI*5/4), 'SW orientation'; is line_orientation([ [0, 10], [10, 0] ]), (PI*7/4), 'SE orientation'; } #========================================================== { is line_direction([ [0, 0], [10, 0] ]), (0), 'E direction'; is line_direction([ [10, 0], [0, 0] ]), (0), 'W direction'; is line_direction([ [0, 0], [0, 10] ]), (PI/2), 'N direction'; is line_direction([ [0, 10], [0, 0] ]), (PI/2), 'S direction'; is line_direction([ [10, 10], [0, 0] ]), (PI*1/4), 'SW direction'; is line_direction([ [0, 0], [10, 10] ]), (PI*1/4), 'NE direction'; is line_direction([ [0, 10], [10, 0] ]), (PI*3/4), 'SE direction'; is line_direction([ [10, 0], [0, 10] ]), (PI*3/4), 'NW direction'; } #========================================================== { is rad2deg_dir(0), 90, 'E (degrees)'; is rad2deg_dir(PI), 270, 'W (degrees)'; is rad2deg_dir(PI/2), 0, 'N (degrees)'; is rad2deg_dir(-(PI/2)), 180, 'S (degrees)'; is rad2deg_dir(PI*1/4), 45, 'NE (degrees)'; is rad2deg_dir(PI*3/4), 135, 'NW (degrees)'; is rad2deg_dir(PI/6), 60, '30°'; is rad2deg_dir(PI/6*2), 30, '60°'; } #========================================================== { is angle3points([0,0], [10,0], [0,10]), PI/2, 'CW angle3points'; is angle3points([0,0], [0,10], [10,0]), PI/2*3, 'CCW angle3points'; } #========================================================== sub line_atan { my ($l) = @_; return Slic3r::Line->new(@$l)->atan2_; } sub line_orientation { my ($l) = @_; return Slic3r::Line->new(@$l)->orientation; } sub line_direction { my ($l) = @_; return Slic3r::Line->new(@$l)->direction; }Slic3r-version_1.31.6/t/arcs.t000066400000000000000000000120201301441720000160510ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 24; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::ExtrusionPath ':roles'; use Slic3r::Geometry qw(scaled_epsilon epsilon scale unscale X Y deg2rad); { my $angle = deg2rad(4); foreach my $ccw (1, 0) { my $polyline = Slic3r::Polyline->new_scale([0,0], [0,10]); { my $p3 = Slic3r::Point->new_scale(0, 20); $p3->rotate($angle * ($ccw ? 1 : -1), $polyline->[-1]); is $ccw, ($p3->[X] < $polyline->[-1][X]) ? 1 : 0, 'third point is rotated correctly'; $polyline->append($p3); } ok abs($polyline->length - scale(20)) < scaled_epsilon, 'curved polyline length'; is $ccw, ($polyline->[2]->ccw(@$polyline[0,1]) > 0) ? 1 : 0, 'curved polyline has wanted orientation'; ok my $arc = Slic3r::GCode::ArcFitting::polyline_to_arc($polyline), 'arc is detected'; is $ccw, $arc->is_ccw, 'arc orientation is correct'; ok abs($arc->angle - $angle) < epsilon, 'arc relative angle is correct'; ok $arc->start->coincides_with($polyline->[0]), 'arc start point is correct'; ok $arc->end->coincides_with($polyline->[-1]), 'arc end point is correct'; # since first polyline segment is vertical we expect arc center to have same Y as its first point is $arc->center->[Y], 0, 'arc center has correct Y'; my $s1 = Slic3r::Line->new(@$polyline[0,1]); my $s2 = Slic3r::Line->new(@$polyline[1,2]); ok abs($arc->center->distance_to($s1->midpoint) - $arc->center->distance_to($s2->midpoint)) < scaled_epsilon, 'arc center is equidistant from both segments\' midpoints'; } } #========================================================== { my $path = Slic3r::Polyline->new_scale( [13.532242,2.665496], [18.702911,9.954623], [22.251514,9.238193], [25.800116,9.954623], [28.697942,11.908391], [30.65171,14.806217], [31.36814,18.35482], [30.65171,21.903423], [28.697942,24.801249], [25.800116,26.755017], [22.251514,27.471447], [18.702911,26.755017], [15.805085,24.801249], [13.851317,21.903423], [13.134887,18.35482], [86948.77,175149.09], [119825.35,100585], ); if (0) { require "Slic3r::SVG"; Slic3r::SVG::output( "arc.svg", polylines => [$path], ); } my $af = Slic3r::GCode::ArcFitting->new(max_relative_angle => deg2rad(30)); my @chunks = $af->detect_arcs($path); is scalar(@chunks), 3, 'path collection now contains three paths'; isa_ok $chunks[0], 'Slic3r::Polyline', 'first one is polyline'; isa_ok $chunks[1], 'Slic3r::GCode::ArcFitting::Arc', 'second one is arc'; isa_ok $chunks[2], 'Slic3r::Polyline', 'third one is polyline'; } exit; #========================================================== { my @points = map [ scale $_->[0], scale $_->[1] ], ( [10,20], [10.7845909572784,19.9691733373313], [11.5643446504023,19.8768834059514], [12.3344536385591,19.7236992039768], [13.0901699437495,19.5105651629515], [13.8268343236509,19.2387953251129], [14.5399049973955,18.9100652418837], [15.2249856471595,18.5264016435409], [15.8778525229247,18.0901699437495], [16.4944804833018,17.6040596560003] ); my $path1 = Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new(@points), role => EXTR_ROLE_FILL, mm3_per_mm => 0.5, ); my $path2 = Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new(reverse @points), role => EXTR_ROLE_FILL, mm3_per_mm => 0.5, ); my @paths1 = $path1->detect_arcs(10, scale 1); my @paths2 = $path2->detect_arcs(10, scale 1); is scalar(@paths1), 1, 'path collection now contains one path'; is scalar(@paths2), 1, 'path collection now contains one path'; isa_ok $paths1[0], 'Slic3r::ExtrusionPath::Arc', 'path'; isa_ok $paths2[0], 'Slic3r::ExtrusionPath::Arc', 'path'; my $expected_length = scale 7.06858347057701; ok abs($paths1[0]->length - $expected_length) < scaled_epsilon, 'cw oriented arc has correct length'; ok abs($paths2[0]->length - $expected_length) < scaled_epsilon, 'ccw oriented arc has correct length'; is $paths1[0]->orientation, 'cw', 'cw orientation was correctly detected'; is $paths2[0]->orientation, 'ccw', 'ccw orientation was correctly detected'; is $paths1[0]->flow_spacing, $path1->flow_spacing, 'flow spacing was correctly preserved'; my $center1 = [ map sprintf('%.0f', $_), @{ $paths1[0]->center } ]; ok abs($center1->[X] - scale 10) < scaled_epsilon && abs($center1->[Y] - scale 10) < scaled_epsilon, 'center was correctly detected'; my $center2 = [ map sprintf('%.0f', $_), @{ $paths2[0]->center } ]; ok abs($center2->[X] - scale 10) < scaled_epsilon && abs($center1->[Y] - scale 10) < scaled_epsilon, 'center was correctly detected'; } #========================================================== Slic3r-version_1.31.6/t/avoid_crossing_perimeters.t000066400000000000000000000007601301441720000224010ustar00rootroot00000000000000use Test::More tests => 1; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first sum); use Slic3r; use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('avoid_crossing_perimeters', 2); my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); ok my $gcode = Slic3r::Test::gcode($print), "no crash with avoid_crossing_perimeters and multiple objects"; } __END__ Slic3r-version_1.31.6/t/bridges.t000066400000000000000000000111121301441720000165410ustar00rootroot00000000000000use Test::More tests => 16; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first sum); use Slic3r; use Slic3r::Geometry qw(scale epsilon deg2rad rad2deg PI); use Slic3r::Test; { my $test = sub { my ($bridge_size, $rotate, $expected_angle, $tolerance) = @_; my ($x, $y) = @$bridge_size; my $lower = Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([-2,-2], [$x+2,-2], [$x+2,$y+2], [-2,$y+2]), Slic3r::Polygon->new_scale([0,0], [0,$y], [$x,$y], [$x,0]), ); $lower->translate(scale 20, scale 20); # avoid negative coordinates for easier SVG preview $lower->rotate(deg2rad($rotate), [$x/2,$y/2]); my $bridge = $lower->[1]->clone; $bridge->reverse; $bridge = Slic3r::ExPolygon->new($bridge); ok check_angle([$lower], $bridge, $expected_angle, $tolerance), 'correct bridge angle for O-shaped overhang'; }; $test->([20,10], 0, 90); $test->([10,20], 0, 0); $test->([20,10], 45, 135, 20); $test->([20,10], 135, 45, 20); } { my $bridge = Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [20,0], [20,10], [0,10]), ); my $lower = [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([-2,0], [0,0], [0,10], [-2,10]), ), ]; $_->translate(scale 20, scale 20) for $bridge, @$lower; # avoid negative coordinates for easier SVG preview $lower->[1] = $lower->[0]->clone; $lower->[1]->translate(scale 22, 0); ok check_angle($lower, $bridge, 0), 'correct bridge angle for two-sided bridge'; } { my $bridge = Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [20,0], [10,10], [0,10]), ); my $lower = [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [0,10], [10,10], [10,12], [-2,12], [-2,-2], [22,-2], [22,0]), ), ]; $_->translate(scale 20, scale 20) for $bridge, @$lower; # avoid negative coordinates for easier SVG preview ok check_angle($lower, $bridge, 135), 'correct bridge angle for C-shaped overhang'; } { my $bridge = Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([10,10],[20,10],[20,20], [10,20]), ); my $lower = [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([10,10],[10,20],[20,20],[30,30],[0,30],[0,0]), ), ]; $_->translate(scale 20, scale 20) for $bridge, @$lower; # avoid negative coordinates for easier SVG preview ok check_angle($lower, $bridge, 45, undef, $bridge->area/2), 'correct bridge angle for square overhang with L-shaped anchors'; } sub check_angle { my ($lower, $bridge, $expected, $tolerance, $expected_coverage) = @_; if (ref($lower) eq 'ARRAY') { $lower = Slic3r::ExPolygon::Collection->new(@$lower); } $expected_coverage //= -1; $expected_coverage = $bridge->area if $expected_coverage == -1; my $bd = Slic3r::BridgeDetector->new($bridge, $lower, scale 0.5); $tolerance //= rad2deg($bd->resolution) + epsilon; $bd->detect_angle; my $result = $bd->angle; my $coverage = $bd->coverage; is sum(map $_->area, @$coverage), $expected_coverage, 'correct coverage area'; # our epsilon is equal to the steps used by the bridge detection algorithm ###use XXX; YYY [ rad2deg($result), $expected ]; # returned value must be non-negative, check for that too my $delta=rad2deg($result) - $expected; $delta-=180 if $delta>=180 - epsilon; return defined $result && $result>=0 && abs($delta) < $tolerance; } { my $config = Slic3r::Config->new_from_defaults; $config->set('top_solid_layers', 0); # to prevent bridging on sparse infill $config->set('bridge_speed', 99); my $print = Slic3r::Test::init_print('bridge', config => $config); my %extrusions = (); # angle => length Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && ($args->{F} // $self->F)/60 == $config->bridge_speed) { my $line = Slic3r::Line->new_scale( [ $self->X, $self->Y ], [ $info->{new_X}, $info->{new_Y} ], ); my $angle = $line->direction; $extrusions{$angle} //= 0; $extrusions{$angle} += $line->length; } }); ok !!%extrusions, "bridge is generated"; my ($main_angle) = sort { $extrusions{$b} <=> $extrusions{$a} } keys %extrusions; is $main_angle, 0, "bridge has the expected direction"; } __END__ Slic3r-version_1.31.6/t/clean_polylines.t000066400000000000000000000106671301441720000203200ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 6; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; { my $polyline = Slic3r::Polyline->new( [0,0],[1,0],[2,0],[2,1],[2,2],[1,2],[0,2],[0,1],[0,0], ); $polyline->simplify(1); is_deeply $polyline->pp, [ [0, 0], [2, 0], [2, 2], [0, 2], [0, 0] ], 'Douglas-Peucker'; } { my $polyline = Slic3r::Polyline->new( [0,0], [50,50], [100,0], [125,-25], [150,50], ); $polyline->simplify(25); is_deeply $polyline->pp, [ [0, 0], [50, 50], [125, -25], [150, 50] ], 'Douglas-Peucker'; } { my $gear = Slic3r::Polygon->new_scale( [144.9694,317.1543], [145.4181,301.5633], [146.3466,296.921], [131.8436,294.1643], [131.7467,294.1464], [121.7238,291.5082], [117.1631,290.2776], [107.9198,308.2068], [100.1735,304.5101], [104.9896,290.3672], [106.6511,286.2133], [93.453,279.2327], [81.0065,271.4171], [67.7886,286.5055], [60.7927,280.1127], [69.3928,268.2566], [72.7271,264.9224], [61.8152,253.9959], [52.2273,242.8494], [47.5799,245.7224], [34.6577,252.6559], [30.3369,245.2236], [42.1712,236.3251], [46.1122,233.9605], [43.2099,228.4876], [35.0862,211.5672], [33.1441,207.0856], [13.3923,212.1895], [10.6572,203.3273], [6.0707,204.8561], [7.2775,204.4259], [29.6713,196.3631], [25.9815,172.1277], [25.4589,167.2745], [19.8337,167.0129], [5.0625,166.3346], [5.0625,156.9425], [5.3701,156.9282], [21.8636,156.1628], [25.3713,156.4613], [25.4243,155.9976], [29.3432,155.8157], [30.3838,149.3549], [26.3596,147.8137], [27.1085,141.2604], [29.8466,126.8337], [24.5841,124.9201], [10.6664,119.8989], [13.4454,110.9264], [33.1886,116.0691], [38.817,103.1819], [45.8311,89.8133], [30.4286,76.81], [35.7686,70.0812], [48.0879,77.6873], [51.564,81.1635], [61.9006,69.1791], [72.3019,58.7916], [60.5509,42.5416], [68.3369,37.1532], [77.9524,48.1338], [80.405,52.2215], [92.5632,44.5992], [93.0123,44.3223], [106.3561,37.2056], [100.8631,17.4679], [108.759,14.3778], [107.3148,11.1283], [117.0002,32.8627], [140.9109,27.3974], [145.7004,26.4994], [145.1346,6.1011], [154.502,5.4063], [156.9398,25.6501], [171.0557,26.2017], [181.3139,27.323], [186.2377,27.8532], [191.6031,8.5474], [200.6724,11.2756], [197.2362,30.2334], [220.0789,39.1906], [224.3261,41.031], [236.3506,24.4291], [243.6897,28.6723], [234.2956,46.7747], [245.6562,55.1643], [257.2523,65.0901], [261.4374,61.5679], [273.1709,52.8031], [278.555,59.5164], [268.4334,69.8001], [264.1615,72.3633], [268.2763,77.9442], [278.8488,93.5305], [281.4596,97.6332], [286.4487,95.5191], [300.2821,90.5903], [303.4456,98.5849], [286.4523,107.7253], [293.7063,131.1779], [294.9748,135.8787], [314.918,133.8172], [315.6941,143.2589], [300.9234,146.1746], [296.6419,147.0309], [297.1839,161.7052], [296.6136,176.3942], [302.1147,177.4857], [316.603,180.3608], [317.1658,176.7341], [315.215,189.6589], [315.1749,189.6548], [294.9411,187.5222], [291.13,201.7233], [286.2615,215.5916], [291.1944,218.2545], [303.9158,225.1271], [299.2384,233.3694], [285.7165,227.6001], [281.7091,225.1956], [273.8981,237.6457], [268.3486,245.2248], [267.4538,246.4414], [264.8496,250.0221], [268.6392,253.896], [278.5017,265.2131], [272.721,271.4403], [257.2776,258.3579], [234.4345,276.5687], [242.6222,294.8315], [234.9061,298.5798], [227.0321,286.2841], [225.2505,281.8301], [211.5387,287.8187], [202.3025,291.0935], [197.307,292.831], [199.808,313.1906], [191.5298,315.0787], [187.3082,299.8172], [186.4201,295.3766], [180.595,296.0487], [161.7854,297.4248], [156.8058,297.6214], [154.3395,317.8592], ); my $num_points = scalar @$gear; my $simplified = $gear->simplify(1000); ok @$simplified == 1, 'gear simplified to a single polygon'; ###note sprintf "original points: %d\nnew points: %d", $num_points, scalar(@{$simplified->[0]}); ok @{$simplified->[0]} < $num_points, 'gear was further simplified using Douglas-Peucker'; } { my $hole_in_square = Slic3r::Polygon->new( # cw [140, 140], [140, 160], [160, 160], [160, 140], ); my $simplified = $hole_in_square->simplify(2); is scalar(@$simplified), 1, 'hole simplification returns one polygon'; ok $simplified->[0]->is_counter_clockwise, 'hole simplification turns cw polygon into ccw polygon'; } Slic3r-version_1.31.6/t/clipper.t000066400000000000000000000044001301441720000165620ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 6; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(sum); use Slic3r; use Slic3r::Geometry::Clipper qw(intersection_ex union_ex diff_ex diff_pl); { my $square = [ # ccw [10, 10], [20, 10], [20, 20], [10, 20], ]; my $hole_in_square = [ # cw [14, 14], [14, 16], [16, 16], [16, 14], ]; my $square2 = [ # ccw [5, 12], [25, 12], [25, 18], [5, 18], ]; my $intersection = intersection_ex([ $square, $hole_in_square ], [ $square2 ]); is sum(map $_->area, @$intersection), Slic3r::ExPolygon->new( [ [20, 18], [10, 18], [10, 12], [20, 12], ], [ [14, 16], [16, 16], [16, 14], [14, 14], ], )->area, 'hole is preserved after intersection'; } #========================================================== { my $contour1 = [ [0,0], [40,0], [40,40], [0,40] ]; # ccw my $contour2 = [ [10,10], [30,10], [30,30], [10,30] ]; # ccw my $hole = [ [15,15], [15,25], [25,25], [25,15] ]; # cw my $union = union_ex([ $contour1, $contour2, $hole ]); is_deeply [ map $_->pp, @$union ], [[ [ [40,40], [0,40], [0,0], [40,0] ] ]], 'union of two ccw and one cw is a contour with no holes'; my $diff = diff_ex([ $contour1, $contour2 ], [ $hole ]); is sum(map $_->area, @$diff), Slic3r::ExPolygon->new([ [40,40], [0,40], [0,0], [40,0] ], [ [15,25], [25,25], [25,15], [15,15] ])->area, 'difference of a cw from two ccw is a contour with one hole'; } #========================================================== { my $square = Slic3r::Polygon->new_scale( # ccw [10, 10], [20, 10], [20, 20], [10, 20], ); my $square_pl = $square->split_at_first_point; my $res = diff_pl([$square_pl], []); is scalar(@$res), 1, 'no-op diff_pl returns the right number of polylines'; isa_ok $res->[0], 'Slic3r::Polyline', 'no-op diff_pl result'; is scalar(@{$res->[0]}), scalar(@$square_pl), 'no-op diff_pl returns the unmodified input polyline'; } __END__ Slic3r-version_1.31.6/t/collinear.t000066400000000000000000000041411301441720000170760ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 11; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Geometry qw(collinear); #========================================================== { my @lines = ( Slic3r::Line->new([0,4], [4,2]), Slic3r::Line->new([2,3], [8,0]), Slic3r::Line->new([6,1], [8,0]), ); is collinear($lines[0], $lines[1]), 1, 'collinear'; is collinear($lines[1], $lines[2]), 1, 'collinear'; is collinear($lines[0], $lines[2]), 1, 'collinear'; } #========================================================== { # horizontal my @lines = ( Slic3r::Line->new([0,1], [5,1]), Slic3r::Line->new([2,1], [8,1]), ); is collinear($lines[0], $lines[1]), 1, 'collinear'; } #========================================================== { # vertical my @lines = ( Slic3r::Line->new([1,0], [1,5]), Slic3r::Line->new([1,2], [1,8]), ); is collinear($lines[0], $lines[1]), 1, 'collinear'; } #========================================================== { # non overlapping my @lines = ( Slic3r::Line->new([0,1], [5,1]), Slic3r::Line->new([7,1], [10,1]), ); is collinear($lines[0], $lines[1], 1), 0, 'non overlapping'; is collinear($lines[0], $lines[1], 0), 1, 'overlapping'; } #========================================================== { # with one common point my @lines = ( Slic3r::Line->new([0,4], [4,2]), Slic3r::Line->new([4,2], [8,0]), ); is collinear($lines[0], $lines[1], 1), 1, 'one common point'; is collinear($lines[0], $lines[1], 0), 1, 'one common point'; } #========================================================== { # not collinear my @lines = ( Slic3r::Line->new([290000000,690525600], [285163380,684761540]), Slic3r::Line->new([285163380,684761540], [193267599,575244400]), ); is collinear($lines[0], $lines[1], 0), 0, 'not collinear'; is collinear($lines[0], $lines[1], 1), 0, 'not collinear'; } #========================================================== Slic3r-version_1.31.6/t/combineinfill.t000066400000000000000000000142401301441720000177410ustar00rootroot00000000000000use Test::More; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Surface ':types'; use Slic3r::Test; plan tests => 8; { my $test = sub { my ($config) = @_; my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok my $gcode = Slic3r::Test::gcode($print), "infill_every_layers does not crash"; my $tool = undef; my %layers = (); # layer_z => 1 my %layer_infill = (); # layer_z => has_infill Slic3r::GCode::Reader->new->parse($gcode, sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0 && $tool != $config->support_material_extruder-1) { $layer_infill{$self->Z} //= 0; if ($tool == $config->infill_extruder-1) { $layer_infill{$self->Z} = 1; } } $layers{$args->{Z}} = 1 if $cmd eq 'G1' && $info->{dist_Z} > 0; }); my $layers_with_perimeters = scalar(keys %layer_infill); my $layers_with_infill = grep $_ > 0, values %layer_infill; is scalar(keys %layers), $layers_with_perimeters+$config->raft_layers, 'expected number of layers'; # first infill layer is never combined, so we don't consider it $layers_with_infill--; $layers_with_perimeters--; # we expect that infill is generated for half the number of combined layers # plus for each single layer that was not combined (remainder) is $layers_with_infill, int($layers_with_perimeters/$config->infill_every_layers) + ($layers_with_perimeters % $config->infill_every_layers), 'infill is only present in correct number of layers'; }; my $config = Slic3r::Config->new_from_defaults; $config->set('layer_height', 0.2); $config->set('first_layer_height', 0.2); $config->set('nozzle_diameter', [0.5]); $config->set('infill_every_layers', 2); $config->set('perimeter_extruder', 1); $config->set('infill_extruder', 2); $config->set('support_material_extruder', 3); $config->set('support_material_interface_extruder', 3); $config->set('top_solid_layers', 0); $config->set('bottom_solid_layers', 0); $test->($config); $config->set('skirts', 0); # prevent usage of perimeter_extruder in raft layers $config->set('raft_layers', 5); $test->($config); } { my $config = Slic3r::Config->new_from_defaults; $config->set('layer_height', 0.2); $config->set('first_layer_height', 0.2); $config->set('nozzle_diameter', [0.5]); $config->set('infill_every_layers', 2); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); $print->process; ok defined(first { @{$_->get_region(0)->fill_surfaces->filter_by_type(S_TYPE_INTERNALVOID)} > 0 } @{$print->print->get_object(0)->layers}), 'infill combination produces internal void surfaces'; # we disable combination after infill has been generated $config->set('infill_every_layers', 1); $print->apply_config($config); $print->process; ok !(defined first { @{$_->get_region(0)->fill_surfaces} == 0 } @{$print->print->get_object(0)->layers}), 'infill combination is idempotent'; } # the following needs to be adapted to the new API if (0) { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('solid_layers', 0); $config->set('bottom_solid_layers', 0); $config->set('top_solid_layers', 0); $config->set('infill_every_layers', 6); $config->set('layer_height', 0.06); $config->set('perimeters', 1); my $test = sub { my ($shift) = @_; my $self = Slic3r::Test::init_print('20mm_cube', config => $config); $shift /= &Slic3r::SCALING_FACTOR; my $scale = 4; # make room for fat infill lines with low layer height # Put a slope on the box's sides by shifting x and y coords by $tilt * (z / boxheight). # The test here is to put such a slight slope on the walls that it should # not trigger any extra fill on fill layers that should be empty when # combine infill is enabled. $_->[0] += $shift * ($_->[2] / (20 / &Slic3r::SCALING_FACTOR)) for @{$self->objects->[0]->meshes->[0]->vertices}; $_->[1] += $shift * ($_->[2] / (20 / &Slic3r::SCALING_FACTOR)) for @{$self->objects->[0]->meshes->[0]->vertices}; $_ = [$_->[0]*$scale, $_->[1]*$scale, $_->[2]] for @{$self->objects->[0]->meshes->[0]->vertices}; # copy of Print::export_gcode() up to the point # after fill surfaces are combined $_->slice for @{$self->objects}; $_->make_perimeters for @{$self->objects}; $_->detect_surfaces_type for @{$self->objects}; $_->prepare_fill_surfaces for map @{$_->regions}, map @{$_->layers}, @{$self->objects}; $_->process_external_surfaces for map @{$_->regions}, map @{$_->layers}, @{$self->objects}; $_->discover_horizontal_shells for @{$self->objects}; $_->combine_infill for @{$self->objects}; # Only layers with id % 6 == 0 should have fill. my $spurious_infill = 0; foreach my $layer (map @{$_->layers}, @{$self->objects}) { ++$spurious_infill if ($layer->id % 6 && grep @{$_->fill_surfaces} > 0, @{$layer->regions}); } $spurious_infill -= scalar(@{$self->objects->[0]->layers} - 1) % 6; fail "spurious fill surfaces found on layers that should have none (walls " . sprintf("%.4f", Slic3r::Geometry::rad2deg(atan2($shift, 20/&Slic3r::SCALING_FACTOR))) . " degrees off vertical)" unless $spurious_infill == 0; 1; }; # Test with mm skew offsets for the top of the 20mm-high box for my $shift (0, 0.0001, 1) { ok $test->($shift), "no spurious fill surfaces with box walls " . sprintf("%.4f",Slic3r::Geometry::rad2deg(atan2($shift, 20))) . " degrees off of vertical"; } } __END__ Slic3r-version_1.31.6/t/config.t000066400000000000000000000005171301441720000163760ustar00rootroot00000000000000use Test::More tests => 1; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('perimeter_extrusion_width', '250%'); ok $config->validate, 'percent extrusion width is validated'; } __END__ Slic3r-version_1.31.6/t/cooling.t000066400000000000000000000117641301441720000165710ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 11; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Test; sub buffer { my $config = shift || Slic3r::Config->new; my $print_config = Slic3r::Config::Print->new; $print_config->apply_dynamic($config); my $gcodegen = Slic3r::GCode->new; $gcodegen->apply_print_config($print_config); $gcodegen->set_layer_count(10); my $buffer = Slic3r::GCode::CoolingBuffer->new( config => $print_config, gcodegen => $gcodegen, ); return $buffer; } my $config = Slic3r::Config->new_from_defaults; $config->set('disable_fan_first_layers', 0); { my $buffer = buffer($config); $buffer->gcodegen->set_elapsed_time($buffer->config->slowdown_below_layer_time + 1); my $gcode = $buffer->append('G1 F3000;_EXTRUDE_SET_SPEED\nG1 X100 E1', 0, 0, 0.4) . $buffer->flush; like $gcode, qr/F3000/, 'speed is not altered when elapsed time is greater than slowdown threshold'; } { my $buffer = buffer($config); $buffer->gcodegen->set_elapsed_time($buffer->config->slowdown_below_layer_time - 1); my $gcode = $buffer->append( "G1 X50 F2500\n" . "G1 F3000;_EXTRUDE_SET_SPEED\n" . "G1 X100 E1\n" . "G1 E4 F400", 0, 0, 0.4 ) . $buffer->flush; unlike $gcode, qr/F3000/, 'speed is altered when elapsed time is lower than slowdown threshold'; like $gcode, qr/F2500/, 'speed is not altered for travel moves'; like $gcode, qr/F400/, 'speed is not altered for extruder-only moves'; } { my $buffer = buffer($config); $buffer->gcodegen->set_elapsed_time($buffer->config->fan_below_layer_time + 1); my $gcode = $buffer->append('G1 X100 E1 F3000', 0, 0, 0.4) . $buffer->flush; unlike $gcode, qr/M106/, 'fan is not activated when elapsed time is greater than fan threshold'; } { my $buffer = buffer($config); my $gcode = ""; for my $obj_id (0 .. 1) { # use an elapsed time which is < the slowdown threshold but greater than it when summed twice $buffer->gcodegen->set_elapsed_time($buffer->config->slowdown_below_layer_time - 1); $gcode .= $buffer->append("G1 X100 E1 F3000\n", $obj_id, 0, 0.4); } $gcode .= $buffer->flush; like $gcode, qr/F3000/, 'slowdown is computed on all objects printing at same Z'; } { my $buffer = buffer($config); my $gcode = ""; for my $layer_id (0 .. 1) { for my $obj_id (0 .. 1) { # use an elapsed time which is < the threshold but greater than it when summed twice $buffer->gcodegen->set_elapsed_time($buffer->config->fan_below_layer_time - 1); $gcode .= $buffer->append("G1 X100 E1 F3000\n", $obj_id, $layer_id, 0.4 + 0.4*$layer_id + 0.1*$obj_id); # print same layer at distinct heights } } $gcode .= $buffer->flush; unlike $gcode, qr/M106/, 'fan activation is computed on all objects printing at different Z'; } { my $buffer = buffer($config); my $gcode = ""; for my $layer_id (0 .. 1) { for my $obj_id (0 .. 1) { # use an elapsed time which is < the threshold even when summed twice $buffer->gcodegen->set_elapsed_time($buffer->config->fan_below_layer_time/2 - 1); $gcode .= $buffer->append("G1 X100 E1 F3000\n", $obj_id, $layer_id, 0.4 + 0.4*$layer_id + 0.1*$obj_id); # print same layer at distinct heights } } $gcode .= $buffer->flush; like $gcode, qr/M106/, 'fan activation is computed on all objects printing at different Z'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('cooling', 1); $config->set('bridge_fan_speed', 100); $config->set('fan_below_layer_time', 0); $config->set('slowdown_below_layer_time', 0); $config->set('bridge_speed', 99); $config->set('top_solid_layers', 1); # internal bridges use solid_infil speed $config->set('bottom_solid_layers', 1); # internal bridges use solid_infil speed my $print = Slic3r::Test::init_print('overhang', config => $config); my $fan = 0; my $fan_with_incorrect_speeds = my $fan_with_incorrect_print_speeds = 0; my $bridge_with_no_fan = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'M106') { $fan = $args->{S}; $fan_with_incorrect_speeds++ if $fan != 255; } elsif ($cmd eq 'M107') { $fan = 0; } elsif ($info->{extruding} && $info->{dist_XY} > 0) { $fan_with_incorrect_print_speeds++ if ($fan > 0) && ($args->{F} // $self->F) != 60*$config->bridge_speed; $bridge_with_no_fan++ if !$fan && ($args->{F} // $self->F) == 60*$config->bridge_speed; } }); ok !$fan_with_incorrect_speeds, 'bridge fan speed is applied correctly'; ok !$fan_with_incorrect_print_speeds, 'bridge fan is only turned on for bridges'; ok !$bridge_with_no_fan, 'bridge fan is turned on for all bridges'; } __END__ Slic3r-version_1.31.6/t/custom_gcode.t000066400000000000000000000117651301441720000176130ustar00rootroot00000000000000use Test::More tests => 15; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; my $test = sub { my ($conf) = @_; $conf ||= $config; my $print = Slic3r::Test::init_print('2x20x10', config => $conf); my $last_move_was_z_change = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($last_move_was_z_change && $cmd ne $config->layer_gcode) { fail 'custom layer G-code was not applied after Z change'; } if (!$last_move_was_z_change && $cmd eq $config->layer_gcode) { fail 'custom layer G-code was not applied after Z change'; } $last_move_was_z_change = (defined $info->{dist_Z} && $info->{dist_Z} > 0); }); 1; }; $config->set('start_gcode', '_MY_CUSTOM_START_GCODE_'); # to avoid dealing with the nozzle lift in start G-code $config->set('layer_gcode', '_MY_CUSTOM_LAYER_GCODE_'); ok $test->(), "custom layer G-code is applied after Z move and before other moves"; } #========================================================== { my $parser = Slic3r::GCode::PlaceholderParser->new; $parser->apply_config(my $config = Slic3r::Config->new_from_defaults); $parser->set('foo' => '0'); is $parser->process('[temperature_[foo]]'), $config->temperature->[0], "nested config options"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('output_filename_format', 'ts_[travel_speed]_lh_[layer_height].gcode'); $config->set('start_gcode', "TRAVEL:[travel_speed] HEIGHT:[layer_height]\n"); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $output_file = $print->print->expanded_output_filepath; my ($t, $h) = map $config->$_, qw(travel_speed layer_height); ok $output_file =~ /ts_${t}_/, 'print config options are replaced in output filename'; ok $output_file =~ /lh_$h\./, 'region config options are replaced in output filename'; my $gcode = Slic3r::Test::gcode($print); ok $gcode =~ /TRAVEL:$t/, 'print config options are replaced in custom G-code'; ok $gcode =~ /HEIGHT:$h/, 'region config options are replaced in custom G-code'; } { my $config = Slic3r::Config->new; $config->set('extruder', 2); $config->set('first_layer_temperature', [200,205]); { my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $gcode = Slic3r::Test::gcode($print); ok $gcode =~ /M104 S205 T1/, 'temperature set correctly for non-zero yet single extruder'; ok $gcode !~ /M104 S\d+ T0/, 'unused extruder correctly ignored'; } $config->set('infill_extruder', 1); { my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $gcode = Slic3r::Test::gcode($print); ok $gcode =~ /M104 S200 T0/, 'temperature set correctly for first extruder'; ok $gcode =~ /M104 S205 T1/, 'temperature set correctly for second extruder'; } $config->set('start_gcode', qq! ;__temp0:[first_layer_temperature_0]__ ;__temp1:[first_layer_temperature_1]__ ;__temp2:[first_layer_temperature_2]__ !); { my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $gcode = Slic3r::Test::gcode($print); # we use the [infill_extruder] placeholder to make sure this test doesn't # catch a false positive caused by the unparsed start G-code option itself # being embedded in the G-code ok $gcode =~ /temp0:200/, 'temperature placeholder for first extruder correctly populated'; ok $gcode =~ /temp1:205/, 'temperature placeholder for second extruder correctly populated'; ok $gcode =~ /temp2:200/, 'temperature placeholder for unused extruder populated with first value'; } } { my $config = Slic3r::Config->new_from_defaults; $config->set('before_layer_gcode', ';BEFORE [layer_num]'); $config->set('layer_gcode', ';CHANGE [layer_num]'); $config->set('support_material', 1); $config->set('layer_height', 0.2); my $print = Slic3r::Test::init_print('overhang', config => $config); my $gcode = Slic3r::Test::gcode($print); my @before = (); my @change = (); foreach my $line (split /\R+/, $gcode) { if ($line =~ /;BEFORE (\d+)/) { push @before, $1; } elsif ($line =~ /;CHANGE (\d+)/) { push @change, $1; fail 'inconsistent layer_num before and after layer change' if $1 != $before[-1]; } } is_deeply \@before, \@change, 'layer_num is consistent before and after layer changes'; ok !defined(first { $change[$_] != $change[$_-1]+1 } 1..$#change), 'layer_num grows continously'; # i.e. no duplicates or regressions } __END__ Slic3r-version_1.31.6/t/dynamic.t000066400000000000000000000060741301441720000165610ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan skip_all => 'variable-width paths are currently disabled'; plan tests => 20; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Geometry qw(X Y scale epsilon); use Slic3r::Surface ':types'; sub scale_points (@) { map [scale $_->[X], scale $_->[Y]], @_ } { my $square = Slic3r::ExPolygon->new([ scale_points [0,0], [10,0], [10,10], [0,10], ]); my @offsets = @{$square->noncollapsing_offset_ex(- scale 5)}; is scalar @offsets, 1, 'non-collapsing offset'; } { local $Slic3r::Config = Slic3r::Config->new( perimeters => 3, ); my $w = 0.7; my $perimeter_flow = Slic3r::Flow->new( nozzle_diameter => 0.5, layer_height => 0.4, width => $w, ); my $print = Slic3r::Print->new; my $region = Slic3r::Print::Region->new( print => $print, flows => { perimeter => $perimeter_flow }, ); push @{$print->regions}, $region; my $object = Slic3r::Print::Object->new( print => $print, size => [1,1], ); my $make_layer = sub { my ($width) = @_; my $layer = Slic3r::Layer->new( object => $object, id => 1, slices => [ Slic3r::Surface->new( surface_type => S_TYPE_INTERNAL, expolygon => Slic3r::ExPolygon->new([ scale_points [0,0], [50,0], [50,$width], [0,$width] ]), ), ], thin_walls => [], ); my $layerm = $layer->region(0); $layer->make_perimeters; return $layerm; }; my %widths = ( 1 * $w => { perimeters => 1, gaps => 0 }, 1.3 * $w => { perimeters => 1, gaps => 1, gap_flow_spacing => $perimeter_flow->clone(width => 0.2 * $w)->spacing }, 1.5 * $w => { perimeters => 1, gaps => 1, gap_flow_spacing => $perimeter_flow->clone(width => 0.5 * $w)->spacing }, 2 * $w => { perimeters => 1, gaps => 1, gap_flow_spacing => $perimeter_flow->spacing }, 2.5 * $w => { perimeters => 1, gaps => 1, gap_flow_spacing => $perimeter_flow->clone(width => 1.5 * $w)->spacing }, 3 * $w => { perimeters => 2, gaps => 0 }, 4 * $w => { perimeters => 2, gaps => 1, gap_flow_spacing => $perimeter_flow->spacing }, ); foreach my $width (sort keys %widths) { my $layerm = $make_layer->($width); is scalar @{$layerm->perimeters}, $widths{$width}{perimeters}, 'right number of perimeters'; is scalar @{$layerm->thin_fills} ? 1 : 0, $widths{$width}{gaps}, ($widths{$width}{gaps} ? 'gaps were filled' : 'no gaps detected'); # TODO: we should check the exact number of gaps, but we need a better medial axis algorithm my @gaps = map $_, @{$layerm->thin_fills}; if (@gaps) { ok +(!first { abs($_->flow_spacing - $widths{$width}{gap_flow_spacing}) > epsilon } @gaps), 'flow spacing was dynamically adjusted'; } } } __END__ Slic3r-version_1.31.6/t/fill.t000066400000000000000000000303571301441720000160640ustar00rootroot00000000000000use Test::More; use strict; use warnings; #plan tests => 43; # Test of a 100% coverage is off. plan tests => 19; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first sum); use Slic3r; use Slic3r::Geometry qw(X Y scale unscale convex_hull); use Slic3r::Geometry::Clipper qw(union diff diff_ex offset offset2_ex); use Slic3r::Surface qw(:types); use Slic3r::Test; sub scale_points (@) { map [scale $_->[X], scale $_->[Y]], @_ } { my $expolygon = Slic3r::ExPolygon->new([ scale_points [0,0], [50,0], [50,50], [0,50] ]); my $filler = Slic3r::Filler->new_from_type('rectilinear'); $filler->set_bounding_box($expolygon->bounding_box); $filler->set_angle(0); my $surface = Slic3r::Surface->new( surface_type => S_TYPE_TOP, expolygon => $expolygon, ); my $flow = Slic3r::Flow->new( width => 0.69, height => 0.4, nozzle_diameter => 0.50, ); $filler->set_spacing($flow->spacing); foreach my $angle (0, 45) { $surface->expolygon->rotate(Slic3r::Geometry::deg2rad($angle), [0,0]); my $paths = $filler->fill_surface($surface, layer_height => 0.4, density => 0.4); is scalar @$paths, 1, 'one continuous path'; } } SKIP: { skip "The FillRectilinear2 does not fill the surface completely", 1; my $test = sub { my ($expolygon, $flow_spacing, $angle, $density) = @_; my $filler = Slic3r::Filler->new_from_type('rectilinear'); $filler->set_bounding_box($expolygon->bounding_box); $filler->set_angle($angle // 0); # Adjust line spacing to fill the region. $filler->set_dont_adjust(0); $filler->set_link_max_length(scale(1.2*$flow_spacing)); my $surface = Slic3r::Surface->new( surface_type => S_TYPE_BOTTOM, expolygon => $expolygon, ); my $flow = Slic3r::Flow->new( width => $flow_spacing, height => 0.4, nozzle_diameter => $flow_spacing, ); $filler->set_spacing($flow->spacing); my $paths = $filler->fill_surface( $surface, layer_height => $flow->height, density => $density // 1, ); # check whether any part was left uncovered my @grown_paths = map @{Slic3r::Polyline->new(@$_)->grow(scale $filler->spacing/2)}, @$paths; my $uncovered = diff_ex([ @$expolygon ], [ @grown_paths ], 1); # ignore very small dots my $uncovered_filtered = [ grep $_->area > (scale $flow_spacing)**2, @$uncovered ]; is scalar(@$uncovered_filtered), 0, 'solid surface is fully filled'; if (0 && @$uncovered_filtered) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("uncovered.svg", no_arrows => 1, expolygons => [ $expolygon ], blue_expolygons => [ @$uncovered ], red_expolygons => [ @$uncovered_filtered ], polylines => [ @$paths ], ); exit; } }; my $expolygon = Slic3r::ExPolygon->new([ [6883102, 9598327.01296997], [6883102, 20327272.01297], [3116896, 20327272.01297], [3116896, 9598327.01296997], ]); $test->($expolygon, 0.55); for (1..20) { $expolygon->scale(1.05); $test->($expolygon, 0.55); } $expolygon = Slic3r::ExPolygon->new( [[59515297,5422499],[59531249,5578697],[59695801,6123186],[59965713,6630228],[60328214,7070685],[60773285,7434379],[61274561,7702115],[61819378,7866770],[62390306,7924789],[62958700,7866744],[63503012,7702244],[64007365,7434357],[64449960,7070398],[64809327,6634999],[65082143,6123325],[65245005,5584454],[65266967,5422499],[66267307,5422499],[66269190,8310081],[66275379,17810072],[66277259,20697500],[65267237,20697500],[65245004,20533538],[65082082,19994444],[64811462,19488579],[64450624,19048208],[64012101,18686514],[63503122,18415781],[62959151,18251378],[62453416,18198442],[62390147,18197355],[62200087,18200576],[61813519,18252990],[61274433,18415918],[60768598,18686517],[60327567,19047892],[59963609,19493297],[59695865,19994587],[59531222,20539379],[59515153,20697500],[58502480,20697500],[58502480,5422499]] ); $test->($expolygon, 0.524341649025257); $expolygon = Slic3r::ExPolygon->new([ scale_points [0,0], [98,0], [98,10], [0,10] ]); $test->($expolygon, 0.5, 45, 0.99); # non-solid infill } { my $collection = Slic3r::Polyline::Collection->new( Slic3r::Polyline->new([0,15], [0,18], [0,20]), Slic3r::Polyline->new([0,10], [0,8], [0,5]), ); is_deeply [ map $_->[Y], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ], [20, 18, 15, 10, 8, 5], 'chained path'; } { my $collection = Slic3r::Polyline::Collection->new( Slic3r::Polyline->new([4,0], [10,0], [15,0]), Slic3r::Polyline->new([10,5], [15,5], [20,5]), ); is_deeply [ map $_->[X], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ], [reverse 4, 10, 15, 10, 15, 20], 'chained path'; } { my $collection = Slic3r::ExtrusionPath::Collection->new( map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1), Slic3r::Polyline->new([0,15], [0,18], [0,20]), Slic3r::Polyline->new([0,10], [0,8], [0,5]), ); is_deeply [ map $_->[Y], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ], [20, 18, 15, 10, 8, 5], 'chained path'; } { my $collection = Slic3r::ExtrusionPath::Collection->new( map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1), Slic3r::Polyline->new([15,0], [10,0], [4,0]), Slic3r::Polyline->new([10,5], [15,5], [20,5]), ); is_deeply [ map $_->[X], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ], [reverse 4, 10, 15, 10, 15, 20], 'chained path'; } for my $pattern (qw(rectilinear honeycomb hilbertcurve concentric)) { my $config = Slic3r::Config->new_from_defaults; $config->set('fill_pattern', $pattern); $config->set('external_fill_pattern', $pattern); $config->set('perimeters', 1); $config->set('skirts', 0); $config->set('fill_density', 20); $config->set('layer_height', 0.05); $config->set('perimeter_extruder', 1); $config->set('infill_extruder', 2); my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale => 2); ok my $gcode = Slic3r::Test::gcode($print), "successful $pattern infill generation"; my $tool = undef; my @perimeter_points = my @infill_points = (); Slic3r::GCode::Reader->new->parse($gcode, sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { if ($tool == $config->perimeter_extruder-1) { push @perimeter_points, Slic3r::Point->new_scale($args->{X}, $args->{Y}); } elsif ($tool == $config->infill_extruder-1) { push @infill_points, Slic3r::Point->new_scale($args->{X}, $args->{Y}); } } }); my $convex_hull = convex_hull(\@perimeter_points); ok !(defined first { !$convex_hull->contains_point($_) } @infill_points), "infill does not exceed perimeters ($pattern)"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('infill_only_where_needed', 1); $config->set('bottom_solid_layers', 0); $config->set('infill_extruder', 2); $config->set('infill_extrusion_width', 0.5); $config->set('fill_density', 40); $config->set('cooling', 0); # for preventing speeds from being altered $config->set('first_layer_speed', '100%'); # for preventing speeds from being altered my $test = sub { my $print = Slic3r::Test::init_print('pyramid', config => $config); my $tool = undef; my @infill_extrusions = (); # array of polylines Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { if ($tool == $config->infill_extruder-1) { push @infill_extrusions, Slic3r::Line->new_scale( [ $self->X, $self->Y ], [ $info->{new_X}, $info->{new_Y} ], ); } } }); return 0 if !@infill_extrusions; # prevent calling convex_hull() with no points my $convex_hull = convex_hull([ map $_->pp, map @$_, @infill_extrusions ]); return unscale unscale sum(map $_->area, @{offset([$convex_hull], scale(+$config->infill_extrusion_width/2))}); }; my $tolerance = 5; # mm^2 $config->set('solid_infill_below_area', 0); ok $test->() < $tolerance, 'no infill is generated when using infill_only_where_needed on a pyramid'; $config->set('solid_infill_below_area', 70); ok abs($test->() - $config->solid_infill_below_area) < $tolerance, 'infill is only generated under the forced solid shells'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeters', 1); $config->set('fill_density', 0); $config->set('top_solid_layers', 0); $config->set('bottom_solid_layers', 0); $config->set('solid_infill_below_area', 20000000); $config->set('solid_infill_every_layers', 2); $config->set('perimeter_speed', 99); $config->set('external_perimeter_speed', 99); $config->set('cooling', 0); $config->set('first_layer_speed', '100%'); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my %layers_with_extrusion = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && $info->{dist_XY} > 0 && $info->{extruding}) { if (($args->{F} // $self->F) != $config->perimeter_speed*60) { $layers_with_extrusion{$self->Z} = ($args->{F} // $self->F); } } }); ok !%layers_with_extrusion, "solid_infill_below_area and solid_infill_every_layers are ignored when fill_density is 0"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeters', 3); $config->set('fill_density', 0); $config->set('layer_height', 0.2); $config->set('first_layer_height', 0.2); $config->set('nozzle_diameter', [0.35]); $config->set('infill_extruder', 2); $config->set('solid_infill_extruder', 2); $config->set('infill_extrusion_width', 0.52); $config->set('solid_infill_extrusion_width', 0.52); $config->set('first_layer_extrusion_width', 0); my $print = Slic3r::Test::init_print('A', config => $config); my %infill = (); # Z => [ Line, Line ... ] my $tool = undef; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { if ($tool == $config->infill_extruder-1) { my $z = 1 * $self->Z; $infill{$z} ||= []; push @{$infill{$z}}, Slic3r::Line->new_scale( [ $self->X, $self->Y ], [ $info->{new_X}, $info->{new_Y} ], ); } } }); my $grow_d = scale($config->infill_extrusion_width)/2; my $layer0_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.2} } ]); my $layer1_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.4} } ]); my $diff = diff($layer0_infill, $layer1_infill); $diff = offset2_ex($diff, -$grow_d, +$grow_d); $diff = [ grep { $_->area > 2*(($grow_d*2)**2) } @$diff ]; is scalar(@$diff), 0, 'no missing parts in solid shell when fill_density is 0'; } __END__ Slic3r-version_1.31.6/t/flow.t000066400000000000000000000055141301441720000161020ustar00rootroot00000000000000use Test::More tests => 6; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first sum); use Slic3r; use Slic3r::Geometry qw(scale PI); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 1); $config->set('brim_width', 2); $config->set('perimeters', 3); $config->set('fill_density', 0.4); $config->set('bottom_solid_layers', 1); $config->set('first_layer_extrusion_width', 2); $config->set('first_layer_height', '100%'); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my @E_per_mm = (); Slic3r::GCode::Reader->new->parse(my $gcode = Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($self->Z == $config->layer_height) { # only consider first layer if ($info->{extruding} && $info->{dist_XY} > 0) { push @E_per_mm, $info->{dist_E} / $info->{dist_XY}; } } }); my $E_per_mm_avg = sum(@E_per_mm) / @E_per_mm; # allow some tolerance because solid rectilinear infill might be adjusted/stretched ok !(defined first { abs($_ - $E_per_mm_avg) > 0.015 } @E_per_mm), 'first_layer_extrusion_width applies to everything on first layer'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('bridge_speed', 99); $config->set('bridge_flow_ratio', 1); $config->set('cooling', 0); # to prevent speeds from being altered $config->set('first_layer_speed', '100%'); # to prevent speeds from being altered my $test = sub { my $print = Slic3r::Test::init_print('overhang', config => $config); my @E_per_mm = (); Slic3r::GCode::Reader->new->parse(my $gcode = Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { if (($args->{F} // $self->F) == $config->bridge_speed*60) { push @E_per_mm, $info->{dist_E} / $info->{dist_XY}; } } }); my $expected_mm3_per_mm = ($config->nozzle_diameter->[0]**2) * PI/4 * $config->bridge_flow_ratio; my $expected_E_per_mm = $expected_mm3_per_mm / ((($config->filament_diameter->[0]/2)**2)*PI); ok !(defined first { abs($_ - $expected_E_per_mm) > 0.01 } @E_per_mm), 'expected flow when using bridge_flow_ratio = ' . $config->bridge_flow_ratio; }; $config->set('bridge_flow_ratio', 0.5); $test->(); $config->set('bridge_flow_ratio', 2); $test->(); $config->set('extrusion_width', 0.4); $config->set('bridge_flow_ratio', 1); $test->(); $config->set('bridge_flow_ratio', 0.5); $test->(); $config->set('bridge_flow_ratio', 2); $test->(); } __END__ Slic3r-version_1.31.6/t/gaps.t000066400000000000000000000040761301441720000160670ustar00rootroot00000000000000use Test::More tests => 1; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Flow ':roles'; use Slic3r::Geometry qw(PI scale unscale convex_hull); use Slic3r::Geometry::Clipper qw(); use Slic3r::Surface ':types'; use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeter_speed', 66); $config->set('external_perimeter_speed', 66); $config->set('small_perimeter_speed', 66); $config->set('gap_fill_speed', 99); $config->set('perimeters', 1); $config->set('cooling', 0); # to prevent speeds from being altered $config->set('first_layer_speed', '100%'); # to prevent speeds from being altered $config->set('perimeter_extrusion_width', 0.35); $config->set('first_layer_extrusion_width', 0.35); my $print = Slic3r::Test::init_print('two_hollow_squares', config => $config); my @perimeter_points = (); my $last = ''; # perimeter | gap my $gap_fills_outside_last_perimeters = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { my $F = $args->{F} // $self->F; my $point = Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y}); if ($F == $config->perimeter_speed*60) { if ($last eq 'gap') { @perimeter_points = (); } push @perimeter_points, $point; $last = 'perimeter'; } elsif ($F == $config->gap_fill_speed*60) { my $convex_hull = convex_hull(\@perimeter_points); if (!$convex_hull->contains_point($point)) { $gap_fills_outside_last_perimeters++; } $last = 'gap'; } } }); is $gap_fills_outside_last_perimeters, 0, 'gap fills are printed before leaving islands'; } __END__ Slic3r-version_1.31.6/t/gcode.t000066400000000000000000000175261301441720000162220ustar00rootroot00000000000000use Test::More tests => 23; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Geometry qw(scale convex_hull); use Slic3r::Test; { my $gcodegen = Slic3r::GCode->new(); $gcodegen->set_layer_count(1); $gcodegen->set_origin(Slic3r::Pointf->new(10, 10)); is_deeply $gcodegen->last_pos->arrayref, [scale -10, scale -10], 'last_pos is shifted correctly'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('wipe', [1]); $config->set('retract_layer_change', [0]); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $have_wipe = 0; my @retract_speeds = (); my $extruded_on_this_layer = 0; my $wiping_on_new_layer = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{travel} && $info->{dist_Z}) { # changing layer $extruded_on_this_layer = 0; } elsif ($info->{extruding} && $info->{dist_XY}) { $extruded_on_this_layer = 1; } elsif ($info->{retracting} && $info->{dist_XY} > 0) { $have_wipe = 1; $wiping_on_new_layer = 1 if !$extruded_on_this_layer; my $move_time = $info->{dist_XY} / ($args->{F} // $self->F); push @retract_speeds, abs($info->{dist_E}) / $move_time; } }); ok $have_wipe, "wipe"; ok !defined (first { abs($_ - $config->retract_speed->[0]*60) < 5 } @retract_speeds), 'wipe moves don\'t retract faster than configured speed'; ok !$wiping_on_new_layer, 'no wiping after layer change'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('z_offset', 5); $config->set('start_gcode', ''); my $test = sub { my ($comment) = @_; my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $moves_below_z_offset = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{travel} && exists $args->{Z}) { $moves_below_z_offset++ if $args->{Z} < $config->z_offset; } }); is $moves_below_z_offset, 0, "no Z moves below Z offset ($comment)"; }; $test->("no lift"); $config->set('retract_lift', [3]); $test->("lift < z_offset"); $config->set('retract_lift', [6]); $test->("lift > z_offset"); } { # This tests the following behavior: # - complete objects does not crash # - no hard-coded "E" are generated # - Z moves are correctly generated for both objects # - no travel moves go outside skirt # - temperatures are set correctly my $config = Slic3r::Config->new_from_defaults; $config->set('gcode_comments', 1); $config->set('complete_objects', 1); $config->set('extrusion_axis', 'A'); $config->set('start_gcode', ''); # prevent any default extra Z move $config->set('layer_height', 0.4); $config->set('first_layer_height', 0.4); $config->set('temperature', [200]); $config->set('first_layer_temperature', [210]); my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); ok my $gcode = Slic3r::Test::gcode($print), "complete_objects"; my @z_moves = (); my @travel_moves = (); # array of scaled points my @extrusions = (); # array of scaled points my @temps = (); Slic3r::GCode::Reader->new->parse($gcode, sub { my ($self, $cmd, $args, $info) = @_; fail 'unexpected E argument' if defined $args->{E}; if (defined $args->{Z}) { push @z_moves, $args->{Z}; } if ($info->{dist_XY}) { if ($info->{extruding} || $args->{A}) { push @extrusions, Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y}); } else { push @travel_moves, Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y}) if @extrusions; # skip initial travel move to first skirt point } } elsif ($cmd eq 'M104' || $cmd eq 'M109') { push @temps, $args->{S} if !@temps || $args->{S} != $temps[-1]; } }); my $layer_count = 20/0.4; # cube is 20mm tall is scalar(@z_moves), 2*$layer_count, 'complete_objects generates the correct number of Z moves'; is_deeply [ @z_moves[0..($layer_count-1)] ], [ @z_moves[$layer_count..$#z_moves] ], 'complete_objects generates the correct Z moves'; my $convex_hull = convex_hull(\@extrusions); ok !(defined first { !$convex_hull->contains_point($_) } @travel_moves), 'all travel moves happen within skirt'; is_deeply \@temps, [210, 200, 210, 200, 0], 'expected temperature changes'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('retract_length', [1000000]); $config->set('use_relative_e_distances', 1); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); Slic3r::Test::gcode($print); ok $print->print->total_used_filament > 0, 'final retraction is not considered in total used filament'; } { my $test = sub { my ($print, $comment) = @_; my @percent = (); my $got_100 = 0; my $extruding_after_100 = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'M73') { push @percent, $args->{P}; $got_100 = 1 if $args->{P} eq '100'; } if ($info->{extruding} && $got_100) { $extruding_after_100 = 1; } }); # the extruder heater is turned off when M73 P100 is reached ok !(defined first { $_ > 100 } @percent), "M73 is never given more than 100% ($comment)"; ok !$extruding_after_100, "no extrusions after M73 P100 ($comment)"; }; { my $config = Slic3r::Config->new_from_defaults; $config->set('gcode_flavor', 'sailfish'); $config->set('raft_layers', 3); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); $test->($print, 'single object'); } { my $config = Slic3r::Config->new_from_defaults; $config->set('gcode_flavor', 'sailfish'); my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); $test->($print, 'two copies of single object'); } { my $config = Slic3r::Config->new_from_defaults; $config->set('gcode_flavor', 'sailfish'); my $print = Slic3r::Test::init_print(['20mm_cube','20mm_cube'], config => $config); $test->($print, 'two objects'); } { my $config = Slic3r::Config->new_from_defaults; $config->set('gcode_flavor', 'sailfish'); my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale_xyz => [1,1, 1/(20/$config->layer_height) ]); $test->($print, 'one layer object'); } } { my $config = Slic3r::Config->new_from_defaults; $config->set('start_gcode', 'START:[input_filename]'); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $gcode = Slic3r::Test::gcode($print); like $gcode, qr/START:20mm_cube/, '[input_filename] is also available in custom G-code'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('spiral_vase', 1); my $print = Slic3r::Test::init_print('cube_with_hole', config => $config); my $spiral = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && exists $args->{E} && exists $args->{Z}) { $spiral = 1; } }); ok !$spiral, 'spiral vase is correctly disabled on layers with multiple loops'; } __END__ Slic3r-version_1.31.6/t/geometry.t000066400000000000000000000234471301441720000167730ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 42; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Geometry qw(PI polygon_is_convex chained_path_from epsilon scale); { # this test was failing on Windows (GH #1950) my $polygon = Slic3r::Polygon->new( [207802834,-57084522],[196528149,-37556190],[173626821,-25420928],[171285751,-21366123], [118673592,-21366123],[116332562,-25420928],[93431208,-37556191],[82156517,-57084523], [129714478,-84542120],[160244873,-84542120], ); my $point = Slic3r::Point->new(95706562, -57294774); ok $polygon->contains_point($point), 'contains_point'; } #========================================================== my $line1 = [ [5, 15], [30, 15] ]; my $line2 = [ [10, 20], [10, 10] ]; is_deeply Slic3r::Geometry::line_intersection($line1, $line2, 1)->arrayref, [10, 15], 'line_intersection'; #========================================================== $line1 = [ [73.6310778185108/0.0000001, 371.74239268924/0.0000001], [73.6310778185108/0.0000001, 501.74239268924/0.0000001] ]; $line2 = [ [75/0.0000001, 437.9853/0.0000001], [62.7484/0.0000001, 440.4223/0.0000001] ]; isnt Slic3r::Geometry::line_intersection($line1, $line2, 1), undef, 'line_intersection'; #========================================================== { my $polygon = Slic3r::Polygon->new( [45919000, 515273900], [14726100, 461246400], [14726100, 348753500], [33988700, 315389800], [43749700, 343843000], [45422300, 352251500], [52362100, 362637800], [62748400, 369577600], [75000000, 372014700], [87251500, 369577600], [97637800, 362637800], [104577600, 352251500], [107014700, 340000000], [104577600, 327748400], [97637800, 317362100], [87251500, 310422300], [82789200, 309534700], [69846100, 294726100], [254081000, 294726100], [285273900, 348753500], [285273900, 461246400], [254081000, 515273900], ); # this points belongs to $polyline # note: it's actually a vertex, while we should better check an intermediate point my $point = Slic3r::Point->new(104577600, 327748400); local $Slic3r::Geometry::epsilon = 1E-5; is_deeply Slic3r::Geometry::polygon_segment_having_point($polygon, $point)->pp, [ [107014700, 340000000], [104577600, 327748400] ], 'polygon_segment_having_point'; } #========================================================== { my $point = Slic3r::Point->new(736310778.185108, 5017423926.8924); my $line = Slic3r::Line->new([627484000, 3695776000], [750000000, 3720147000]); is Slic3r::Geometry::point_in_segment($point, $line), 0, 'point_in_segment'; } #========================================================== { my $point = Slic3r::Point->new(736310778.185108, 5017423926.8924); my $line = Slic3r::Line->new([627484000, 3695776000], [750000000, 3720147000]); is Slic3r::Geometry::point_in_segment($point, $line), 0, 'point_in_segment'; } #========================================================== my $polygons = [ Slic3r::Polygon->new( # contour, ccw [45919000, 515273900], [14726100, 461246400], [14726100, 348753500], [33988700, 315389800], [43749700, 343843000], [45422300, 352251500], [52362100, 362637800], [62748400, 369577600], [75000000, 372014700], [87251500, 369577600], [97637800, 362637800], [104577600, 352251500], [107014700, 340000000], [104577600, 327748400], [97637800, 317362100], [87251500, 310422300], [82789200, 309534700], [69846100, 294726100], [254081000, 294726100], [285273900, 348753500], [285273900, 461246400], [254081000, 515273900], ), Slic3r::Polygon->new( # hole, cw [75000000, 502014700], [87251500, 499577600], [97637800, 492637800], [104577600, 482251500], [107014700, 470000000], [104577600, 457748400], [97637800, 447362100], [87251500, 440422300], [75000000, 437985300], [62748400, 440422300], [52362100, 447362100], [45422300, 457748400], [42985300, 470000000], [45422300, 482251500], [52362100, 492637800], [62748400, 499577600], ), ]; #========================================================== { my $p1 = [10, 10]; my $p2 = [10, 20]; my $p3 = [10, 30]; my $p4 = [20, 20]; my $p5 = [0, 20]; is Slic3r::Geometry::angle3points($p2, $p3, $p1), PI(), 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p1, $p3), PI(), 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p3, $p4), PI()/2*3, 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p4, $p3), PI()/2, 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p1, $p4), PI()/2, 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p1, $p5), PI()/2*3, 'angle3points'; } { my $p1 = [30, 30]; my $p2 = [20, 20]; my $p3 = [10, 10]; my $p4 = [30, 10]; is Slic3r::Geometry::angle3points($p2, $p1, $p3), PI(), 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p1, $p4), PI()/2*3, 'angle3points'; is Slic3r::Geometry::angle3points($p2, $p1, $p1), 2*PI(), 'angle3points'; } #========================================================== { my $cw_square = [ [0,0], [0,10], [10,10], [10,0] ]; is polygon_is_convex($cw_square), 0, 'cw square is not convex'; is polygon_is_convex([ reverse @$cw_square ]), 1, 'ccw square is convex'; my $convex1 = [ [0,0], [10,0], [10,10], [0,10], [0,6], [4,6], [4,4], [0,4] ]; is polygon_is_convex($convex1), 0, 'concave polygon'; } #========================================================== { my $polyline = Slic3r::Polyline->new([0, 0], [10, 0], [20, 0]); is_deeply [ map $_->pp, @{$polyline->lines} ], [ [ [0, 0], [10, 0] ], [ [10, 0], [20, 0] ], ], 'polyline_lines'; } #========================================================== { my $polygon = Slic3r::Polygon->new([0, 0], [10, 0], [5, 5]); my $result = $polygon->split_at_index(1); is ref($result), 'Slic3r::Polyline', 'split_at_index returns polyline'; is_deeply $result->pp, [ [10, 0], [5, 5], [0, 0], [10, 0] ], 'split_at_index'; } #========================================================== { my $bb = Slic3r::Geometry::BoundingBox->new_from_points([ map Slic3r::Point->new(@$_), [0, 1], [10, 2], [20, 2] ]); $bb->scale(2); is_deeply [ $bb->min_point->pp, $bb->max_point->pp ], [ [0,2], [40,4] ], 'bounding box is scaled correctly'; } #========================================================== { my $line = Slic3r::Line->new([10,10], [20,10]); is $line->grow(5)->[0]->area, Slic3r::Polygon->new([10,5], [20,5], [20,15], [10,15])->area, 'grow line'; } #========================================================== { # if chained_path() works correctly, these points should be joined with no diagonal paths # (thus 26 units long) my @points = map Slic3r::Point->new_scale(@$_), [26,26],[52,26],[0,26],[26,52],[26,0],[0,52],[52,52],[52,0]; my @ordered = @points[@{chained_path_from(\@points, $points[0])}]; ok !(grep { abs($ordered[$_]->distance_to($ordered[$_+1]) - scale 26) > epsilon } 0..$#ordered-1), 'chained_path'; } #========================================================== { my $line = Slic3r::Line->new([0, 0], [20, 0]); is +Slic3r::Point->new(10, 10)->distance_to_line($line), 10, 'distance_to'; is +Slic3r::Point->new(50, 0)->distance_to_line($line), 30, 'distance_to'; is +Slic3r::Point->new(0, 0)->distance_to_line($line), 0, 'distance_to'; is +Slic3r::Point->new(20, 0)->distance_to_line($line), 0, 'distance_to'; is +Slic3r::Point->new(10, 0)->distance_to_line($line), 0, 'distance_to'; } #========================================================== { my $square = Slic3r::Polygon->new_scale( [100,100], [200,100], [200,200], [100,200], ); is scalar(@{$square->concave_points(PI*4/3)}), 0, 'no concave vertices detected in ccw square'; is scalar(@{$square->convex_points(PI*2/3)}), 4, 'four convex vertices detected in ccw square'; $square->make_clockwise; is scalar(@{$square->concave_points(PI*4/3)}), 4, 'fuor concave vertices detected in cw square'; is scalar(@{$square->convex_points(PI*2/3)}), 0, 'no convex vertices detected in cw square'; } { my $square = Slic3r::Polygon->new_scale( [150,100], [200,100], [200,200], [100,200], [100,100], ); is scalar(@{$square->concave_points(PI*4/3)}), 0, 'no concave vertices detected in convex polygon'; is scalar(@{$square->convex_points(PI*2/3)}), 4, 'four convex vertices detected in square'; } { my $square = Slic3r::Polygon->new_scale( [200,200], [100,200], [100,100], [150,100], [200,100], ); is scalar(@{$square->concave_points(PI*4/3)}), 0, 'no concave vertices detected in convex polygon'; is scalar(@{$square->convex_points(PI*2/3)}), 4, 'four convex vertices detected in square'; } { my $triangle = Slic3r::Polygon->new( [16000170,26257364], [714223,461012], [31286371,461008], ); is scalar(@{$triangle->concave_points(PI*4/3)}), 0, 'no concave vertices detected in triangle'; is scalar(@{$triangle->convex_points(PI*2/3)}), 3, 'three convex vertices detected in triangle'; } { my $triangle = Slic3r::Polygon->new( [16000170,26257364], [714223,461012], [20000000,461012], [31286371,461012], ); is scalar(@{$triangle->concave_points(PI*4/3)}), 0, 'no concave vertices detected in triangle having collinear point'; is scalar(@{$triangle->convex_points(PI*2/3)}), 3, 'three convex vertices detected in triangle having collinear point'; } { my $triangle = Slic3r::Polygon->new( [16000170,26257364], [714223,461012], [31286371,461008], ); my $simplified = $triangle->simplify(250000)->[0]; is scalar(@$simplified), 3, 'triangle is never simplified to less than 3 points'; } __END__ Slic3r-version_1.31.6/t/layers.t000066400000000000000000000042261301441720000164310ustar00rootroot00000000000000use Test::More tests => 5; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Test qw(_eq); { my $config = Slic3r::Config->new_from_defaults; my $test = sub { my ($conf) = @_; $conf ||= $config; my $print = Slic3r::Test::init_print('20mm_cube', config => $conf); my @z = (); my @increments = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{dist_Z}) { push @z, 1*$args->{Z}; push @increments, $info->{dist_Z}; } }); fail 'wrong first layer height' if $z[0] ne $config->get_value('first_layer_height') + $config->z_offset; fail 'wrong second layer height' if $z[1] ne $config->get_value('first_layer_height') + $config->get_value('layer_height') + $config->z_offset; fail 'wrong layer height' if first { !_eq($_, $config->layer_height) } @increments[1..$#increments]; 1; }; $config->set('start_gcode', ''); # to avoid dealing with the nozzle lift in start G-code $config->set('layer_height', 0.3); $config->set('first_layer_height', 0.2); ok $test->(), "absolute first layer height"; $config->set('first_layer_height', '60%'); ok $test->(), "relative first layer height"; $config->set('z_offset', 0.9); ok $test->(), "positive Z offset"; $config->set('z_offset', -0.8); ok $test->(), "negative Z offset"; } { my $config = Slic3r::Config->new; $config->set('fill_density', 0); # just for making the test faster my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale => 2); my @z = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{dist_Z}) { push @z, 1*$args->{Z}; } }); ok $z[-1] > 20*1.8 && $z[-1] < 20*2.2, 'resulting G-code has reasonable height'; } __END__ Slic3r-version_1.31.6/t/loops.t000066400000000000000000000037541301441720000162730ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan skip_all => 'temporarily disabled'; plan tests => 4; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Test; { # We only need to slice at one height, so we'll build a non-manifold mesh # that still produces complete loops at that height. Triangular walls are # enough for this purpose. # Basically we want to check what happens when three concentric loops happen # to be at the same height, the two external ones being ccw and the other being # a hole, thus cw. my (@vertices, @facets) = (); Slic3r::Test::add_facet($_, \@vertices, \@facets) for # external surface below the slicing Z [ [0,0,0], [20,0,10], [0,0,10] ], [ [20,0,0], [20,20,10], [20,0,10] ], [ [20,20,0], [0,20,10], [20,20,10] ], [ [0,20,0], [0,0,10], [0,20,10] ], # external insetted surface above the slicing Z [ [2,2,10], [18,2,10], [2,2,20] ], [ [18,2,10], [18,18,10], [18,2,20] ], [ [18,18,10], [2,18,10], [18,18,20] ], [ [2,18,10], [2,2,10], [2,18,20] ], # insetted hole below the slicing Z [ [15,5,0], [5,5,10], [15,5,10] ], [ [15,15,0], [15,5,10], [15,15,10] ], [ [5,15,0], [15,15,10], [5,15,10] ], [ [5,5,0], [5,15,10], [5,5,10] ]; my $mesh = Slic3r::TriangleMesh->new; $mesh->ReadFromPerl(\@vertices, \@facets); $mesh->analyze; my @lines = map $mesh->intersect_facet($_, 10), 0..$#facets; my $loops = Slic3r::TriangleMesh::make_loops(\@lines); is scalar(@$loops), 3, 'correct number of loops detected'; is scalar(grep $_->is_counter_clockwise, @$loops), 2, 'correct number of ccw loops detected'; my @surfaces = Slic3r::Layer::Region::_merge_loops($loops, 0); is scalar(@surfaces), 1, 'one surface detected'; is scalar(@{$surfaces[0]->expolygon})-1, 1, 'surface has one hole'; } __END__ Slic3r-version_1.31.6/t/multi.t000066400000000000000000000177771301441720000163030ustar00rootroot00000000000000use Test::More tests => 13; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Geometry qw(scale convex_hull); use Slic3r::Geometry::Clipper qw(offset); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('raft_layers', 2); $config->set('infill_extruder', 2); $config->set('solid_infill_extruder', 3); $config->set('support_material_extruder', 4); $config->set('ooze_prevention', 1); $config->set('extruder_offset', [ [0,0], [20,0], [0,20], [20,20] ]); $config->set('temperature', [200, 180, 170, 160]); $config->set('first_layer_temperature', [206, 186, 166, 156]); $config->set('toolchange_gcode', ';toolchange'); # test that it doesn't crash when this is supplied my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $tool = undef; my @tool_temp = (0,0,0,0); my @toolchange_points = (); my @extrusion_points = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { # ignore initial toolchange if (defined $tool) { my $expected_temp = $self->Z == ($config->get_value('first_layer_height') + $config->z_offset) ? $config->first_layer_temperature->[$tool] : $config->temperature->[$tool]; die 'standby temperature was not set before toolchange' if $tool_temp[$tool] != $expected_temp + $config->standby_temperature_delta; push @toolchange_points, my $point = Slic3r::Point->new_scale($self->X, $self->Y); } $tool = $1; } elsif ($cmd eq 'M104' || $cmd eq 'M109') { my $t = $args->{T} // $tool; if ($tool_temp[$t] == 0) { fail 'initial temperature is not equal to first layer temperature + standby delta' unless $args->{S} == $config->first_layer_temperature->[$t] + $config->standby_temperature_delta; } $tool_temp[$t] = $args->{S}; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { push @extrusion_points, my $point = Slic3r::Point->new_scale($args->{X}, $args->{Y}); $point->translate(map +scale($_), @{ $config->extruder_offset->[$tool] }); } }); my $convex_hull = convex_hull(\@extrusion_points); my @t = (); foreach my $point (@toolchange_points) { foreach my $offset (@{$config->extruder_offset}) { push @t, my $p = $point->clone; $p->translate(map +scale($_), @$offset); } } ok !(defined first { $convex_hull->contains_point($_) } @t), 'all nozzles are outside skirt at toolchange'; if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output( "ooze_prevention_test.svg", no_arrows => 1, polygons => [$convex_hull], red_points => \@t, points => \@toolchange_points, ); } # offset the skirt by the maximum displacement between extruders plus a safety extra margin my $delta = scale(20 * sqrt(2) + 1); my $outer_convex_hull = offset([$convex_hull], +$delta)->[0]; ok !(defined first { !$outer_convex_hull->contains_point($_) } @toolchange_points), 'all toolchanges happen within expected area'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('support_material_extruder', 3); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok Slic3r::Test::gcode($print), 'no errors when using non-consecutive extruders'; } { my $config = Slic3r::Config->new; $config->set('extruder', 2); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); like Slic3r::Test::gcode($print), qr/ T1/, 'extruder shortcut'; } { my $config = Slic3r::Config->new; $config->set('perimeter_extruder', 2); $config->set('infill_extruder', 2); $config->set('support_material_extruder', 2); $config->set('support_material_interface_extruder', 2); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok Slic3r::Test::gcode($print), 'no errors when using multiple skirts with a single, non-zero, extruder'; } { my $model = stacked_cubes(); my $lower_config = $model->get_material('lower')->config; my $upper_config = $model->get_material('upper')->config; $lower_config->set('extruder', 1); $lower_config->set('bottom_solid_layers', 0); $lower_config->set('top_solid_layers', 1); $upper_config->set('extruder', 2); $upper_config->set('bottom_solid_layers', 1); $upper_config->set('top_solid_layers', 0); my $config = Slic3r::Config->new_from_defaults; $config->set('fill_density', 0); $config->set('solid_infill_speed', 99); $config->set('top_solid_infill_speed', 99); $config->set('cooling', 0); # for preventing speeds from being altered $config->set('first_layer_speed', '100%'); # for preventing speeds from being altered my $test = sub { my $print = Slic3r::Test::init_print($model, config => $config); my $tool = undef; my %T0_shells = my %T1_shells = (); # Z => 1 Slic3r::GCode::Reader->new->parse(my $gcode = Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { if (($args->{F} // $self->F) == $config->solid_infill_speed*60) { if ($tool == 0) { $T0_shells{$self->Z} = 1; } elsif ($tool == 1) { $T1_shells{$self->Z} = 1; } } } }); return [ sort keys %T0_shells ], [ sort keys %T1_shells ]; }; { my ($t0, $t1) = $test->(); is scalar(@$t0), 0, 'no interface shells'; is scalar(@$t1), 0, 'no interface shells'; } { $config->set('interface_shells', 1); my ($t0, $t1) = $test->(); is scalar(@$t0), $lower_config->top_solid_layers, 'top interface shells'; is scalar(@$t1), $upper_config->bottom_solid_layers, 'bottom interface shells'; } } { my $model = stacked_cubes(); my $object = $model->objects->[0]; my $config = Slic3r::Config->new_from_defaults; $config->set('layer_height', 0.4); $config->set('first_layer_height', '100%'); $config->set('skirts', 0); my $print = Slic3r::Test::init_print($model, config => $config); is $object->volumes->[0]->config->extruder, 1, 'auto_assign_extruders() assigned correct extruder to first volume'; is $object->volumes->[1]->config->extruder, 2, 'auto_assign_extruders() assigned correct extruder to second volume'; my $tool = undef; my %T0 = my %T1 = (); # Z => 1 Slic3r::GCode::Reader->new->parse(my $gcode = Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { if ($tool == 0) { $T0{$self->Z} = 1; } elsif ($tool == 1) { $T1{$self->Z} = 1; } } }); ok !(defined first { $_ > 20 } keys %T0), 'T0 is never used for upper object'; ok !(defined first { $_ < 20 } keys %T1), 'T1 is never used for lower object'; } sub stacked_cubes { my $model = Slic3r::Model->new; my $object = $model->add_object; $object->add_volume(mesh => Slic3r::Test::mesh('20mm_cube'), material_id => 'lower'); $object->add_volume(mesh => Slic3r::Test::mesh('20mm_cube', translate => [0,0,20]), material_id => 'upper'); $object->add_instance(offset => Slic3r::Pointf->new(0,0)); return $model; } __END__ Slic3r-version_1.31.6/t/perimeters.t000066400000000000000000000571211301441720000173130ustar00rootroot00000000000000use Test::More tests => 59; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r::ExtrusionLoop ':roles'; use Slic3r::ExtrusionPath ':roles'; use List::Util qw(first); use Slic3r; use Slic3r::Flow ':roles'; use Slic3r::Geometry qw(PI scale unscale); use Slic3r::Geometry::Clipper qw(union_ex diff union offset); use Slic3r::Surface ':types'; use Slic3r::Test; { my $flow = Slic3r::Flow->new( width => 1, height => 1, nozzle_diameter => 1, ); my $config = Slic3r::Config->new; my $test = sub { my ($expolygons, %expected) = @_; my $slices = Slic3r::Surface::Collection->new; $slices->append(Slic3r::Surface->new( surface_type => S_TYPE_INTERNAL, expolygon => $_, )) for @$expolygons; my ($region_config, $object_config, $print_config, $loops, $gap_fill, $fill_surfaces); my $g = Slic3r::Layer::PerimeterGenerator->new( # input: $slices, 1, # layer height $flow, ($region_config = Slic3r::Config::PrintRegion->new), ($object_config = Slic3r::Config::PrintObject->new), ($print_config = Slic3r::Config::Print->new), # output: ($loops = Slic3r::ExtrusionPath::Collection->new), ($gap_fill = Slic3r::ExtrusionPath::Collection->new), ($fill_surfaces = Slic3r::Surface::Collection->new), ); $g->config->apply_dynamic($config); $g->process; is scalar(@$loops), scalar(@$expolygons), 'expected number of collections'; ok !defined(first { !$_->isa('Slic3r::ExtrusionPath::Collection') } @$loops), 'everything is returned as collections'; my $flattened_loops = $loops->flatten; my @loops = @$flattened_loops; is scalar(@loops), $expected{total}, 'expected number of loops'; is scalar(grep $_->role == EXTR_ROLE_EXTERNAL_PERIMETER, map @$_, @loops), $expected{external}, 'expected number of external loops'; is_deeply [ map { ($_->role == EXTR_ROLE_EXTERNAL_PERIMETER) || 0 } map @$_, @loops ], $expected{ext_order}, 'expected external order'; is scalar(grep $_->role == EXTRL_ROLE_CONTOUR_INTERNAL_PERIMETER, @loops), $expected{cinternal}, 'expected number of internal contour loops'; is scalar(grep $_->polygon->is_counter_clockwise, @loops), $expected{ccw}, 'expected number of ccw loops'; is_deeply [ map $_->polygon->is_counter_clockwise, @loops ], $expected{ccw_order}, 'expected ccw/cw order'; if ($expected{nesting}) { foreach my $nesting (@{ $expected{nesting} }) { for my $i (1..$#$nesting) { ok $loops[$nesting->[$i-1]]->polygon->contains_point($loops[$nesting->[$i]]->first_point), 'expected nesting order'; } } } }; $config->set('perimeters', 3); $test->( [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [100,0], [100,100], [0,100]), ), ], total => 3, external => 1, ext_order => [0,0,1], cinternal => 1, ccw => 3, ccw_order => [1,1,1], nesting => [ [2,1,0] ], ); $test->( [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [100,0], [100,100], [0,100]), Slic3r::Polygon->new_scale([40,40], [40,60], [60,60], [60,40]), ), ], total => 6, external => 2, ext_order => [0,0,1,0,0,1], cinternal => 1, ccw => 3, ccw_order => [0,0,0,1,1,1], nesting => [ [5,4,3,0,1,2] ], ); $test->( [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [200,0], [200,200], [0,200]), Slic3r::Polygon->new_scale([20,20], [20,180], [180,180], [180,20]), ), # nested: Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([50,50], [150,50], [150,150], [50,150]), Slic3r::Polygon->new_scale([80,80], [80,120], [120,120], [120,80]), ), ], total => 4*3, external => 4, ext_order => [0,0,1,0,0,1,0,0,1,0,0,1], cinternal => 2, ccw => 2*3, ccw_order => [0,0,0,1,1,1,0,0,0,1,1,1], ); $config->set('perimeters', 2); $test->( [ Slic3r::ExPolygon->new( Slic3r::Polygon->new_scale([0,0], [50,0], [50,50], [0,50]), Slic3r::Polygon->new_scale([7.5,7.5], [7.5,12.5], [12.5,12.5], [12.5,7.5]), Slic3r::Polygon->new_scale([7.5,17.5], [7.5,22.5], [12.5,22.5], [12.5,17.5]), Slic3r::Polygon->new_scale([7.5,27.5], [7.5,32.5], [12.5,32.5], [12.5,27.5]), Slic3r::Polygon->new_scale([7.5,37.5], [7.5,42.5], [12.5,42.5], [12.5,37.5]), Slic3r::Polygon->new_scale([17.5,7.5], [17.5,12.5], [22.5,12.5], [22.5,7.5]), ), ], total => 12, external => 6, ext_order => [0,1,0,1,0,1,0,1,0,1,0,1], cinternal => 1, ccw => 2, ccw_order => [0,0,0,0,0,0,0,0,0,0,1,1], nesting => [ [0,1],[2,3],[4,5],[6,7],[8,9] ], ); } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('fill_density', 0); $config->set('perimeters', 3); $config->set('top_solid_layers', 0); $config->set('bottom_solid_layers', 0); $config->set('cooling', 0); # to prevent speeds from being altered $config->set('first_layer_speed', '100%'); # to prevent speeds from being altered { my $print = Slic3r::Test::init_print('overhang', config => $config); my $has_cw_loops = 0; my $cur_loop; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { $cur_loop ||= [ [$self->X, $self->Y] ]; push @$cur_loop, [ @$info{qw(new_X new_Y)} ]; } else { if ($cur_loop) { $has_cw_loops = 1 if Slic3r::Polygon->new(@$cur_loop)->is_clockwise; $cur_loop = undef; } } }); ok !$has_cw_loops, 'all perimeters extruded ccw'; } foreach my $model (qw(cube_with_hole cube_with_concave_hole)) { $config->set('external_perimeter_speed', 68); my $print = Slic3r::Test::init_print( $model, config => $config, duplicate => 2, # we test two copies to make sure ExtrusionLoop objects are not modified in-place (the second object would not detect cw loops and thus would calculate wrong inwards moves) ); my $has_cw_loops = my $has_outwards_move = my $starts_on_convex_point = 0; my $cur_loop; my %external_loops = (); # print_z => count of external loops Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { $cur_loop ||= [ [$self->X, $self->Y] ]; push @$cur_loop, [ @$info{qw(new_X new_Y)} ]; } else { if ($cur_loop) { $has_cw_loops = 1 if Slic3r::Polygon->new_scale(@$cur_loop)->is_clockwise; if ($self->F == $config->external_perimeter_speed*60) { my $move_dest = Slic3r::Point->new_scale(@$info{qw(new_X new_Y)}); # reset counter for second object $external_loops{$self->Z} = 0 if defined($external_loops{$self->Z}) && $external_loops{$self->Z} == 2; $external_loops{$self->Z}++; my $is_contour = $external_loops{$self->Z} == 2; my $is_hole = $external_loops{$self->Z} == 1; my $loop = Slic3r::Polygon->new_scale(@$cur_loop); my $loop_contains_point = $loop->contains_point($move_dest); $has_outwards_move = 1 if (!$loop_contains_point && $is_contour) # contour should include destination || ($loop_contains_point && $is_hole); # hole should not if ($model eq 'cube_with_concave_hole') { # check that loop starts at a concave vertex my $ccw_angle = $loop->first_point->ccw_angle(@$loop[-2,1]); my $convex = ($ccw_angle > PI); # whether the angle on the *right* side is convex $starts_on_convex_point = 1 if ($convex && $is_contour) || (!$convex && $is_hole); } } $cur_loop = undef; } } }); ok !$has_cw_loops, 'all perimeters extruded ccw'; ok !$has_outwards_move, 'move inwards after completing external loop'; ok !$starts_on_convex_point, 'loops start on concave point if any'; } { $config->set('perimeters', 1); $config->set('perimeter_speed', 77); $config->set('external_perimeter_speed', 66); $config->set('bridge_speed', 99); $config->set('cooling', 1); $config->set('fan_below_layer_time', 0); $config->set('slowdown_below_layer_time', 0); $config->set('bridge_fan_speed', 100); $config->set('bridge_flow_ratio', 33); # arbitrary value $config->set('overhangs', 1); my $print = Slic3r::Test::init_print('overhang', config => $config); my %layer_speeds = (); # print Z => [ speeds ] my $fan_speed = 0; my $bridge_mm_per_mm = ($config->nozzle_diameter->[0]**2) / ($config->filament_diameter->[0]**2) * $config->bridge_flow_ratio; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; $fan_speed = 0 if $cmd eq 'M107'; $fan_speed = $args->{S} if $cmd eq 'M106'; if ($info->{extruding} && $info->{dist_XY} > 0) { $layer_speeds{$self->Z} ||= {}; $layer_speeds{$self->Z}{my $feedrate = $args->{F} // $self->F} = 1; fail 'wrong speed found' if $feedrate != $config->perimeter_speed*60 && $feedrate != $config->external_perimeter_speed*60 && $feedrate != $config->bridge_speed*60; if ($feedrate == $config->bridge_speed*60) { fail 'printing overhang but fan is not enabled or running at wrong speed' if $fan_speed != 255; my $mm_per_mm = $info->{dist_E} / $info->{dist_XY}; fail 'wrong bridge flow' if abs($mm_per_mm - $bridge_mm_per_mm) > 0.01; } else { fail 'fan is running when not supposed to' if $fan_speed > 0; } } }); is scalar(grep { keys %$_ > 1 } values %layer_speeds), 1, 'only overhang layer has more than one speed'; } } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeters', 3); $config->set('layer_height', 0.4); $config->set('first_layer_height', 0.35); $config->set('extra_perimeters', 1); $config->set('cooling', 0); # to prevent speeds from being altered $config->set('first_layer_speed', '100%'); # to prevent speeds from being altered $config->set('perimeter_speed', 99); $config->set('external_perimeter_speed', 99); $config->set('small_perimeter_speed', 99); $config->set('thin_walls', 0); my $print = Slic3r::Test::init_print('ipadstand', config => $config); my %perimeters = (); # z => number of loops my $in_loop = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0 && ($args->{F} // $self->F) == $config->perimeter_speed*60) { $perimeters{$self->Z}++ if !$in_loop; $in_loop = 1; } else { $in_loop = 0; } }); ok !(grep { $_ % $config->perimeters } values %perimeters), 'no superfluous extra perimeters'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('nozzle_diameter', [0.4]); $config->set('perimeters', 2); $config->set('perimeter_extrusion_width', 0.4); $config->set('infill_extrusion_width', 0.53); $config->set('solid_infill_extrusion_width', 0.53); # we just need a pre-filled Print object my $print = Slic3r::Test::init_print('20mm_cube', config => $config); # override a layer's slices my $expolygon = Slic3r::ExPolygon->new([[-71974463,-139999376],[-71731792,-139987456],[-71706544,-139985616],[-71682119,-139982639],[-71441248,-139946912],[-71417487,-139942895],[-71379384,-139933984],[-71141800,-139874480],[-71105247,-139862895],[-70873544,-139779984],[-70838592,-139765856],[-70614943,-139660064],[-70581783,-139643567],[-70368368,-139515680],[-70323751,-139487872],[-70122160,-139338352],[-70082399,-139306639],[-69894800,-139136624],[-69878679,-139121327],[-69707992,-138933008],[-69668575,-138887343],[-69518775,-138685359],[-69484336,-138631632],[-69356423,-138418207],[-69250040,-138193296],[-69220920,-138128976],[-69137992,-137897168],[-69126095,-137860255],[-69066568,-137622608],[-69057104,-137582511],[-69053079,-137558751],[-69017352,-137317872],[-69014392,-137293456],[-69012543,-137268207],[-68999369,-137000000],[-63999999,-137000000],[-63705947,-136985551],[-63654984,-136977984],[-63414731,-136942351],[-63364756,-136929840],[-63129151,-136870815],[-62851950,-136771631],[-62585807,-136645743],[-62377483,-136520895],[-62333291,-136494415],[-62291908,-136463728],[-62096819,-136319023],[-62058644,-136284432],[-61878676,-136121328],[-61680968,-135903184],[-61650275,-135861807],[-61505591,-135666719],[-61354239,-135414191],[-61332211,-135367615],[-61228359,-135148063],[-61129179,-134870847],[-61057639,-134585262],[-61014451,-134294047],[-61000000,-134000000],[-61000000,-107999999],[-61014451,-107705944],[-61057639,-107414736],[-61129179,-107129152],[-61228359,-106851953],[-61354239,-106585808],[-61505591,-106333288],[-61680967,-106096816],[-61878675,-105878680],[-62096820,-105680967],[-62138204,-105650279],[-62333292,-105505591],[-62585808,-105354239],[-62632384,-105332207],[-62851951,-105228360],[-62900463,-105211008],[-63129152,-105129183],[-63414731,-105057640],[-63705947,-105014448],[-63999999,-105000000],[-68999369,-105000000],[-69012543,-104731792],[-69014392,-104706544],[-69017352,-104682119],[-69053079,-104441248],[-69057104,-104417487],[-69066008,-104379383],[-69125528,-104141799],[-69137111,-104105248],[-69220007,-103873544],[-69234136,-103838591],[-69339920,-103614943],[-69356415,-103581784],[-69484328,-103368367],[-69512143,-103323752],[-69661647,-103122160],[-69693352,-103082399],[-69863383,-102894800],[-69878680,-102878679],[-70066999,-102707992],[-70112656,-102668576],[-70314648,-102518775],[-70368367,-102484336],[-70581783,-102356424],[-70806711,-102250040],[-70871040,-102220919],[-71102823,-102137992],[-71139752,-102126095],[-71377383,-102066568],[-71417487,-102057104],[-71441248,-102053079],[-71682119,-102017352],[-71706535,-102014392],[-71731784,-102012543],[-71974456,-102000624],[-71999999,-102000000],[-104000000,-102000000],[-104025536,-102000624],[-104268207,-102012543],[-104293455,-102014392],[-104317880,-102017352],[-104558751,-102053079],[-104582512,-102057104],[-104620616,-102066008],[-104858200,-102125528],[-104894751,-102137111],[-105126455,-102220007],[-105161408,-102234136],[-105385056,-102339920],[-105418215,-102356415],[-105631632,-102484328],[-105676247,-102512143],[-105877839,-102661647],[-105917600,-102693352],[-106105199,-102863383],[-106121320,-102878680],[-106292007,-103066999],[-106331424,-103112656],[-106481224,-103314648],[-106515663,-103368367],[-106643575,-103581783],[-106749959,-103806711],[-106779080,-103871040],[-106862007,-104102823],[-106873904,-104139752],[-106933431,-104377383],[-106942896,-104417487],[-106946920,-104441248],[-106982648,-104682119],[-106985607,-104706535],[-106987456,-104731784],[-107000630,-105000000],[-112000000,-105000000],[-112294056,-105014448],[-112585264,-105057640],[-112870848,-105129184],[-112919359,-105146535],[-113148048,-105228360],[-113194624,-105250392],[-113414191,-105354239],[-113666711,-105505591],[-113708095,-105536279],[-113903183,-105680967],[-114121320,-105878679],[-114319032,-106096816],[-114349720,-106138200],[-114494408,-106333288],[-114645760,-106585808],[-114667792,-106632384],[-114771640,-106851952],[-114788991,-106900463],[-114870815,-107129151],[-114942359,-107414735],[-114985551,-107705943],[-115000000,-107999999],[-115000000,-134000000],[-114985551,-134294048],[-114942359,-134585263],[-114870816,-134870847],[-114853464,-134919359],[-114771639,-135148064],[-114645759,-135414192],[-114494407,-135666720],[-114319031,-135903184],[-114121320,-136121327],[-114083144,-136155919],[-113903184,-136319023],[-113861799,-136349712],[-113666711,-136494416],[-113458383,-136619264],[-113414192,-136645743],[-113148049,-136771631],[-112870848,-136870815],[-112820872,-136883327],[-112585264,-136942351],[-112534303,-136949920],[-112294056,-136985551],[-112000000,-137000000],[-107000630,-137000000],[-106987456,-137268207],[-106985608,-137293440],[-106982647,-137317872],[-106946920,-137558751],[-106942896,-137582511],[-106933991,-137620624],[-106874471,-137858208],[-106862888,-137894751],[-106779992,-138126463],[-106765863,-138161424],[-106660080,-138385055],[-106643584,-138418223],[-106515671,-138631648],[-106487855,-138676256],[-106338352,-138877839],[-106306647,-138917600],[-106136616,-139105199],[-106121320,-139121328],[-105933000,-139291999],[-105887344,-139331407],[-105685351,-139481232],[-105631632,-139515663],[-105418216,-139643567],[-105193288,-139749951],[-105128959,-139779072],[-104897175,-139862016],[-104860247,-139873904],[-104622616,-139933423],[-104582511,-139942896],[-104558751,-139946912],[-104317880,-139982656],[-104293463,-139985616],[-104268216,-139987456],[-104025544,-139999376],[-104000000,-140000000],[-71999999,-140000000]],[[-105000000,-138000000],[-105000000,-104000000],[-71000000,-104000000],[-71000000,-138000000]],[[-69000000,-132000000],[-69000000,-110000000],[-64991180,-110000000],[-64991180,-132000000]],[[-111008824,-132000000],[-111008824,-110000000],[-107000000,-110000000],[-107000000,-132000000]]); my $object = $print->print->objects->[0]; $object->slice; my $layer = $object->get_layer(1); my $layerm = $layer->regions->[0]; $layerm->slices->clear; $layerm->slices->append(Slic3r::Surface->new(surface_type => S_TYPE_INTERNAL, expolygon => $expolygon)); # make perimeters $layer->make_perimeters; # compute the covered area my $pflow = $layerm->flow(FLOW_ROLE_PERIMETER); my $iflow = $layerm->flow(FLOW_ROLE_INFILL); my $covered_by_perimeters = union_ex([ (map @{$_->polygon->split_at_first_point->grow($pflow->scaled_width/2)}, map @$_, @{$layerm->perimeters}), ]); my $covered_by_infill = union_ex([ (map $_->p, @{$layerm->fill_surfaces}), (map @{$_->polyline->grow($iflow->scaled_width/2)}, @{$layerm->thin_fills}), ]); # compute the non covered area my $non_covered = diff( [ map @{$_->expolygon}, @{$layerm->slices} ], [ map @$_, (@$covered_by_perimeters, @$covered_by_infill) ], ); if (0) { printf "max non covered = %f\n", List::Util::max(map unscale unscale $_->area, @$non_covered); require "Slic3r/SVG.pm"; Slic3r::SVG::output( "gaps.svg", expolygons => [ map $_->expolygon, @{$layerm->slices} ], red_expolygons => union_ex([ map @$_, (@$covered_by_perimeters, @$covered_by_infill) ]), green_expolygons => union_ex($non_covered), no_arrows => 1, polylines => [ map $_->polygon->split_at_first_point, map @$_, @{$layerm->perimeters}, ], ); } ok !(defined first { $_->area > ($iflow->scaled_width**2) } @$non_covered), 'no gap between perimeters and infill'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeters', 3); $config->set('layer_height', 0.4); $config->set('bridge_speed', 99); $config->set('fill_density', 0); # to prevent bridging over sparse infill $config->set('overhangs', 1); $config->set('cooling', 0); # to prevent speeds from being altered $config->set('first_layer_speed', '100%'); # to prevent speeds from being altered my $test = sub { my ($print) = @_; my %z_with_bridges = (); # z => 1 Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { $z_with_bridges{$self->Z} = 1 if ($args->{F} // $self->F) == $config->bridge_speed*60; } }); return scalar keys %z_with_bridges; }; ok $test->(Slic3r::Test::init_print('V', config => $config)) == 1, 'no overhangs printed with bridge speed'; # except for the first internal solid layers above void ok $test->(Slic3r::Test::init_print('V', config => $config, scale_xyz => [3,1,1])) > 1, 'overhangs printed with bridge speed'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('seam_position', 'random'); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok Slic3r::Test::gcode($print), 'successful generation of G-code with seam_position = random'; } { my $test = sub { my ($model_name) = @_; my $config = Slic3r::Config->new_from_defaults; $config->set('seam_position', 'aligned'); $config->set('skirts', 0); $config->set('perimeters', 1); $config->set('fill_density', 0); $config->set('top_solid_layers', 0); $config->set('bottom_solid_layers', 0); $config->set('retract_layer_change', [0]); my $was_extruding = 0; my @seam_points = (); my $print = Slic3r::Test::init_print($model_name, config => $config); Slic3r::GCode::Reader->new->parse(my $gcode = Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding}) { if (!$was_extruding) { push @seam_points, Slic3r::Point->new_scale($self->X, $self->Y); } $was_extruding = 1; } else { $was_extruding = 0; } }); my @dist = map unscale($_), map $seam_points[$_]->distance_to($seam_points[$_+1]), 0..($#seam_points-1); ok !(defined first { $_ > 3 } @dist), 'seam is aligned'; }; $test->('20mm_cube'); $test->('small_dorito'); } __END__ Slic3r-version_1.31.6/t/polyclip.t000066400000000000000000000145031301441720000167640ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan tests => 18; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Geometry::Clipper qw(intersection_pl); #========================================================== is Slic3r::Geometry::point_in_segment(Slic3r::Point->new(10, 10), Slic3r::Line->new([5, 10], [20, 10])), 1, 'point in horizontal segment'; is Slic3r::Geometry::point_in_segment(Slic3r::Point->new(30, 10), Slic3r::Line->new([5, 10], [20, 10])), 0, 'point not in horizontal segment'; is Slic3r::Geometry::point_in_segment(Slic3r::Point->new(10, 10), Slic3r::Line->new([10, 5], [10, 20])), 1, 'point in vertical segment'; is Slic3r::Geometry::point_in_segment(Slic3r::Point->new(10, 30), Slic3r::Line->new([10, 5], [10, 20])), 0, 'point not in vertical segment'; is Slic3r::Geometry::point_in_segment(Slic3r::Point->new(15, 15), Slic3r::Line->new([10, 10], [20, 20])), 1, 'point in diagonal segment'; is Slic3r::Geometry::point_in_segment(Slic3r::Point->new(20, 15), Slic3r::Line->new([10, 10], [20, 20])), 0, 'point not in diagonal segment'; #========================================================== my $square = Slic3r::Polygon->new( # ccw [100, 100], [200, 100], [200, 200], [100, 200], ); #========================================================== { my $hole_in_square = [ # cw [140, 140], [140, 160], [160, 160], [160, 140], ]; my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square); #is $expolygon->contains_point(Slic3r::Point->new(100, 100)), 1, 'corner point is recognized'; #is $expolygon->contains_point(Slic3r::Point->new(100, 180)), 1, 'point on contour is recognized'; #is $expolygon->contains_point(Slic3r::Point->new(140, 150)), 1, 'point on hole contour is recognized'; #is $expolygon->contains_point(Slic3r::Point->new(140, 140)), 1, 'point on hole corner is recognized'; { my $intersection = intersection_pl([Slic3r::Polyline->new([150,180], [150,150])], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([150, 180], [150, 160])->length, 'line is clipped to square with hole'; } { my $intersection = intersection_pl([Slic3r::Polyline->new([150,150], [150,120])], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([150, 140], [150, 120])->length, 'line is clipped to square with hole'; } { my $intersection = intersection_pl([Slic3r::Polyline->new([120,180], [180,180])], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([120,180], [180,180])->length, 'line is clipped to square with hole'; } { my $intersection = intersection_pl([Slic3r::Polyline->new([50, 150], [300, 150])], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([100, 150], [140, 150])->length, 'line is clipped to square with hole'; is $intersection->[1]->length, Slic3r::Line->new([160, 150], [200, 150])->length, 'line is clipped to square with hole'; } { my $intersection = intersection_pl([Slic3r::Polyline->new([300, 150], [50, 150])], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([200, 150], [160, 150])->length, 'reverse line is clipped to square with hole'; is $intersection->[1]->length, Slic3r::Line->new([140, 150], [100, 150])->length, 'reverse line is clipped to square with hole'; } { my $intersection = intersection_pl([Slic3r::Polyline->new([100,180], [200,180])], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([100,180], [200,180])->length, 'tangent line is clipped to square with hole'; } } #========================================================== { my $large_circle = Slic3r::Polygon->new_scale( # ccw [151.8639,288.1192], [133.2778,284.6011], [115.0091,279.6997], [98.2859,270.8606], [82.2734,260.7933], [68.8974,247.4181], [56.5622,233.0777], [47.7228,216.3558], [40.1617,199.0172], [36.6431,180.4328], [34.932,165.2312], [37.5567,165.1101], [41.0547,142.9903], [36.9056,141.4295], [40.199,124.1277], [47.7776,106.7972], [56.6335,90.084], [68.9831,75.7557], [82.3712,62.3948], [98.395,52.3429], [115.1281,43.5199], [133.4004,38.6374], [151.9884,35.1378], [170.8905,35.8571], [189.6847,37.991], [207.5349,44.2488], [224.8662,51.8273], [240.0786,63.067], [254.407,75.4169], [265.6311,90.6406], [275.6832,106.6636], [281.9225,124.52], [286.8064,142.795], [287.5061,161.696], [286.7874,180.5972], [281.8856,198.8664], [275.6283,216.7169], [265.5604,232.7294], [254.3211,247.942], [239.9802,260.2776], [224.757,271.5022], [207.4179,279.0635], [189.5605,285.3035], [170.7649,287.4188], ); ok $large_circle->is_counter_clockwise, "contour is counter-clockwise"; my $small_circle = Slic3r::Polygon->new_scale( # cw [158.227,215.9007], [164.5136,215.9007], [175.15,214.5007], [184.5576,210.6044], [190.2268,207.8743], [199.1462,201.0306], [209.0146,188.346], [213.5135,177.4829], [214.6979,168.4866], [216.1025,162.3325], [214.6463,151.2703], [213.2471,145.1399], [209.0146,134.9203], [199.1462,122.2357], [189.8944,115.1366], [181.2504,111.5567], [175.5684,108.8205], [164.5136,107.3655], [158.2269,107.3655], [147.5907,108.7656], [138.183,112.6616], [132.5135,115.3919], [123.5943,122.2357], [113.7259,134.92], [109.2269,145.7834], [108.0426,154.7799], [106.638,160.9339], [108.0941,171.9957], [109.4933,178.1264], [113.7259,188.3463], [123.5943,201.0306], [132.8461,208.1296], [141.4901,211.7094], [147.172,214.4458], ); ok $small_circle->is_clockwise, "hole is clockwise"; my $expolygon = Slic3r::ExPolygon->new($large_circle, $small_circle); my $line = Slic3r::Polyline->new_scale([152.742,288.086671142818], [152.742,34.166466971035]); my $intersection = intersection_pl([$line], \@$expolygon); is $intersection->[0]->length, Slic3r::Line->new([152742000, 288086661], [152742000, 215178843])->length, 'line is clipped to square with hole'; is $intersection->[1]->length, Slic3r::Line->new([152742000, 108087507], [152742000, 35166477])->length, 'line is clipped to square with hole'; } #========================================================== Slic3r-version_1.31.6/t/pressure.t000066400000000000000000000015771301441720000170100ustar00rootroot00000000000000use Test::More tests => 1; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(); use Slic3r; use Slic3r::Geometry qw(epsilon); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('pressure_advance', 10); $config->set('retract_length', [1]); my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); my $retracted = $config->retract_length->[0]; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && !$info->{dist_XY}) { $retracted += $info->{dist_E}; } elsif ($info->{retracting}) { $retracted += $info->{dist_E}; } }); ok abs($retracted) < 0.01, 'all retractions are compensated'; } __END__ Slic3r-version_1.31.6/t/print.t000066400000000000000000000044711301441720000162700ustar00rootroot00000000000000use Test::More tests => 6; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Geometry qw(epsilon unscale X Y); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; my $print_center = [100,100]; my $print = Slic3r::Test::init_print('20mm_cube', config => $config, print_center => $print_center); my @extrusion_points = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) { push @extrusion_points, my $point = Slic3r::Point->new_scale($args->{X}, $args->{Y}); } }); my $bb = Slic3r::Geometry::BoundingBox->new_from_points(\@extrusion_points); my $center = $bb->center; ok abs(unscale($center->[X]) - $print_center->[X]) < epsilon, 'print is centered around print_center (X)'; ok abs(unscale($center->[Y]) - $print_center->[Y]) < epsilon, 'print is centered around print_center (Y)'; } { # this represents the aggregate config from presets my $config = Slic3r::Config->new_from_defaults; # user adds one object to the plater my $print = Slic3r::Test::init_print(my $model = Slic3r::Test::model('20mm_cube'), config => $config); # user sets a per-region option $print->print->objects->[0]->model_object->config->set('fill_density', 100); $print->print->reload_object(0); is $print->print->regions->[0]->config->fill_density, 100, 'region config inherits model object config'; # user exports G-code, thus the default config is reapplied $print->print->apply_config($config); is $print->print->regions->[0]->config->fill_density, 100, 'apply_config() does not override per-object settings'; # user assigns object extruders $print->print->objects->[0]->model_object->config->set('extruder', 3); $print->print->objects->[0]->model_object->config->set('perimeter_extruder', 2); $print->print->reload_object(0); is $print->print->regions->[0]->config->infill_extruder, 3, 'extruder setting is correctly expanded'; is $print->print->regions->[0]->config->perimeter_extruder, 2, 'extruder setting does not override explicitely specified extruders'; } __END__ Slic3r-version_1.31.6/t/retraction.t000066400000000000000000000235061301441720000173060ustar00rootroot00000000000000use Test::More tests => 26; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(any); use Slic3r; use Slic3r::Test qw(_eq); { my $config = Slic3r::Config->new_from_defaults; my $duplicate = 1; my $test = sub { my ($conf) = @_; $conf ||= $config; my $print = Slic3r::Test::init_print('20mm_cube', config => $conf, duplicate => $duplicate); my $tool = 0; my @toolchange_count = (); # track first usages so that we don't expect retract_length_toolchange when extruders are used for the first time my @retracted = (1); # ignore the first travel move from home to first point my @retracted_length = (0); my $lifted = 0; my $lift_dist = 0; # track lifted distance for toolchanges and extruders with different retract_lift values my $changed_tool = 0; my $wait_for_toolchange = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; $changed_tool = 1; $wait_for_toolchange = 0; $toolchange_count[$tool] //= 0; $toolchange_count[$tool]++; } elsif ($cmd =~ /^G[01]$/ && !$args->{Z}) { # ignore lift taking place after retraction fail 'toolchange happens right after retraction' if $wait_for_toolchange; } if ($info->{dist_Z}) { # lift move or lift + change layer if (_eq($info->{dist_Z}, $print->print->config->get_at('retract_lift', $tool)) || (_eq($info->{dist_Z}, $conf->layer_height + $print->print->config->get_at('retract_lift', $tool)) && $print->print->config->get_at('retract_lift', $tool) > 0)) { fail 'only lifting while retracted' if !$retracted[$tool]; fail 'double lift' if $lifted; $lifted = 1; $lift_dist = $info->{dist_Z}; } if ($info->{dist_Z} < 0) { fail 'going down only after lifting' if !$lifted; fail 'going down by the same amount of the lift or by the amount needed to get to next layer' if !_eq($info->{dist_Z}, -$lift_dist) && !_eq($info->{dist_Z}, -lift_dist + $conf->layer_height); $lift_dist = 0; $lifted = 0; } fail 'move Z at travel speed' if ($args->{F} // $self->F) != $conf->travel_speed * 60; } if ($info->{retracting}) { $retracted[$tool] = 1; $retracted_length[$tool] += -$info->{dist_E}; if (_eq($retracted_length[$tool], $print->print->config->get_at('retract_length', $tool))) { # okay } elsif (_eq($retracted_length[$tool], $print->print->config->get_at('retract_length_toolchange', $tool))) { $wait_for_toolchange = 1; } else { fail 'retracted by the correct amount'; } } if ($info->{extruding}) { fail 'only extruding while not lifted' if $lifted; if ($retracted[$tool]) { my $expected_amount = $retracted_length[$tool] + $print->print->config->get_at('retract_restart_extra', $tool); if ($changed_tool && $toolchange_count[$tool] > 1) { $expected_amount = $print->print->config->get_at('retract_length_toolchange', $tool) + $print->print->config->get_at('retract_restart_extra_toolchange', $tool); $changed_tool = 0; } fail 'unretracted by the correct amount' && exit if !_eq($info->{dist_E}, $expected_amount); $retracted[$tool] = 0; $retracted_length[$tool] = 0; } } if ($info->{travel} && $info->{dist_XY} >= $print->print->config->get_at('retract_before_travel', $tool)) { fail 'retracted before long travel move' if !$retracted[$tool]; } }); 1; }; $config->set('first_layer_height', $config->layer_height); $config->set('first_layer_speed', '100%'); $config->set('start_gcode', ''); # to avoid dealing with the nozzle lift in start G-code $config->set('retract_length', [1.5]); $config->set('retract_before_travel', [3]); $config->set('only_retract_when_crossing_perimeters', 0); my $retract_tests = sub { my ($descr) = @_; ok $test->(), "retraction$descr"; my $conf = $config->clone; $conf->set('retract_restart_extra', [1]); ok $test->($conf), "restart extra length$descr"; $conf->set('retract_restart_extra', [-1]); ok $test->($conf), "negative restart extra length$descr"; $conf->set('retract_lift', [1, 2]); ok $test->($conf), "lift$descr"; }; $retract_tests->(''); $duplicate = 2; $retract_tests->(' (duplicate)'); $duplicate = 1; $config->set('infill_extruder', 2); $config->set('skirts', 4); $config->set('skirt_height', 3); $retract_tests->(' (dual extruder with multiple skirt layers)'); } { my $config = Slic3r::Config->new_from_defaults; $config->set('start_gcode', ''); # prevent any default priming Z move from affecting our lift detection $config->set('retract_length', [0]); $config->set('retract_layer_change', [0]); $config->set('retract_lift', [0.2]); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $retracted = 0; my $layer_changes_with_retraction = 0; my $retractions = my $z_restores = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{retracting}) { $retracted = 1; $retractions++; } elsif ($info->{extruding} && $retracted) { $retracted = 0; } if ($info->{dist_Z} && $retracted) { $layer_changes_with_retraction++; } if ($info->{dist_Z} && $args->{Z} < $self->Z) { $z_restores++; } }); is $layer_changes_with_retraction, 0, 'no retraction on layer change'; is $retractions, 0, 'no retractions'; is $z_restores, 0, 'no lift'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('use_firmware_retraction', 1); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $retracted = 0; my $double_retractions = my $double_unretractions = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G10') { $double_retractions++ if $retracted; $retracted = 1; } elsif ($cmd eq 'G11') { $double_unretractions++ if !$retracted; $retracted = 0; } }); is $double_retractions, 0, 'no double retractions'; is $double_unretractions, 0, 'no double unretractions'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('use_firmware_retraction', 1); $config->set('retract_length', [0]); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $retracted = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G10') { $retracted = 1; } }); ok $retracted, 'retracting also when --retract-length is 0 but --use-firmware-retraction is enabled'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('start_gcode', ''); $config->set('retract_lift', [3, 4]); my @lifted_at = (); my $test = sub { my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2); @lifted_at = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && $info->{dist_Z} < 0) { push @lifted_at, $info->{new_Z}; } }); }; $config->set('retract_lift_above', [0, 0]); $config->set('retract_lift_below', [0, 0]); $test->(); ok !!@lifted_at, 'lift takes place when above/below == 0'; $config->set('retract_lift_above', [5, 6]); $config->set('retract_lift_below', [15, 13]); $test->(); ok !!@lifted_at, 'lift takes place when above/below != 0'; ok !(any { $_ < $config->get_at('retract_lift_above', 0) } @lifted_at), 'Z is not lifted below the configured value'; ok !(any { $_ > $config->get_at('retract_lift_below', 0) } @lifted_at), 'Z is not lifted above the configured value'; # check lifting with different values for 2. extruder $config->set('perimeter_extruder', 2); $config->set('infill_extruder', 2); $config->set('retract_lift_above', [0, 0]); $config->set('retract_lift_below', [0, 0]); $test->(); ok !!@lifted_at, 'lift takes place when above/below == 0 for 2. extruder'; $config->set('retract_lift_above', [5, 6]); $config->set('retract_lift_below', [15, 13]); $test->(); ok !!@lifted_at, 'lift takes place when above/below != 0 for 2. extruder'; ok !(any { $_ < $config->get_at('retract_lift_above', 1) } @lifted_at), 'Z is not lifted below the configured value for 2. extruder'; ok !(any { $_ > $config->get_at('retract_lift_below', 1) } @lifted_at), 'Z is not lifted above the configured value for 2. extruder'; } __END__Slic3r-version_1.31.6/t/shells.t000066400000000000000000000326111301441720000164230ustar00rootroot00000000000000use Test::More tests => 21; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first sum); use Slic3r; use Slic3r::Geometry qw(epsilon); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeters', 0); $config->set('solid_infill_speed', 99); $config->set('top_solid_infill_speed', 99); $config->set('bridge_speed', 72); $config->set('first_layer_speed', '100%'); $config->set('cooling', 0); my $test = sub { my ($conf) = @_; $conf ||= $config; my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my %z = (); # Z => 1 my %layers_with_solid_infill = (); # Z => $count my %layers_with_bridge_infill = (); # Z => $count Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($self->Z > 0) { $z{ $self->Z } = 1; if ($info->{extruding} && $info->{dist_XY} > 0) { my $F = $args->{F} // $self->F; $layers_with_solid_infill{$self->Z} = 1 if $F == $config->solid_infill_speed*60; $layers_with_bridge_infill{$self->Z} = 1 if $F == $config->bridge_speed*60; } } }); my @z = sort { $a <=> $b } keys %z; my @shells = map $layers_with_solid_infill{$_} || $layers_with_bridge_infill{$_}, @z; fail "insufficient number of bottom solid layers" unless !defined(first { !$_ } @shells[0..$config->bottom_solid_layers-1]); fail "excessive number of bottom solid layers" unless scalar(grep $_, @shells[0 .. $#shells/2]) == $config->bottom_solid_layers; fail "insufficient number of top solid layers" unless !defined(first { !$_ } @shells[-$config->top_solid_layers..-1]); fail "excessive number of top solid layers" unless scalar(grep $_, @shells[($#shells/2)..$#shells]) == $config->top_solid_layers; if ($config->top_solid_layers > 0) { fail "unexpected solid infill speed in first solid layer over sparse infill" if $layers_with_solid_infill{ $z[-$config->top_solid_layers] }; die "bridge speed not used in first solid layer over sparse infill" if !$layers_with_bridge_infill{ $z[-$config->top_solid_layers] }; } 1; }; $config->set('top_solid_layers', 3); $config->set('bottom_solid_layers', 3); ok $test->(), "proper number of shells is applied"; $config->set('top_solid_layers', 0); $config->set('bottom_solid_layers', 0); ok $test->(), "no shells are applied when both top and bottom are set to zero"; $config->set('perimeters', 1); $config->set('top_solid_layers', 3); $config->set('bottom_solid_layers', 3); $config->set('fill_density', 0); ok $test->(), "proper number of shells is applied even when fill density is none"; } # issue #1161 { my $config = Slic3r::Config->new_from_defaults; $config->set('layer_height', 0.3); $config->set('first_layer_height', '100%'); $config->set('bottom_solid_layers', 0); $config->set('top_solid_layers', 3); $config->set('cooling', 0); $config->set('bridge_speed', 99); $config->set('solid_infill_speed', 99); $config->set('top_solid_infill_speed', 99); $config->set('first_layer_speed', '100%'); my $print = Slic3r::Test::init_print('V', config => $config); my %layers_with_solid_infill = (); # Z => 1 Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; $layers_with_solid_infill{$self->Z} = 1 if $info->{extruding} && ($args->{F} // $self->F) == $config->solid_infill_speed*60; }); is scalar(map $layers_with_solid_infill{$_}, grep $_ <= 7.2, keys %layers_with_solid_infill), 3, "correct number of top solid shells is generated in V-shaped object"; } { my $config = Slic3r::Config->new_from_defaults; # we need to check against one perimeter because this test is calibrated # (shape, extrusion_width) so that perimeters cover the bottom surfaces of # their lower layer - the test checks that shells are not generated on the # above layers (thus 'across' the shadow perimeter) # the test is actually calibrated to leave a narrow bottom region for each # layer - we test that in case of fill_density = 0 such narrow shells are # discarded instead of grown $config->set('perimeters', 1); $config->set('fill_density', 0); $config->set('cooling', 0); # prevent speed alteration $config->set('first_layer_speed', '100%'); # prevent speed alteration $config->set('layer_height', 0.4); $config->set('first_layer_height', '100%'); $config->set('extrusion_width', 0.55); $config->set('bottom_solid_layers', 3); $config->set('top_solid_layers', 0); $config->set('solid_infill_speed', 99); my $print = Slic3r::Test::init_print('V', config => $config); my %layers = (); # Z => 1 Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; $layers{$self->Z} = 1 if $info->{extruding} && ($args->{F} // $self->F) == $config->solid_infill_speed*60; }); is scalar(keys %layers), $config->bottom_solid_layers, "shells are not propagated across perimeters of the neighbor layer"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('perimeters', 3); $config->set('cooling', 0); # prevent speed alteration $config->set('first_layer_speed', '100%'); # prevent speed alteration $config->set('layer_height', 0.4); $config->set('first_layer_height', '100%'); $config->set('bottom_solid_layers', 3); $config->set('top_solid_layers', 3); $config->set('solid_infill_speed', 99); $config->set('top_solid_infill_speed', 99); $config->set('bridge_speed', 99); my $print = Slic3r::Test::init_print('sloping_hole', config => $config); my %solid_layers = (); # Z => 1 Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; $solid_layers{$self->Z} = 1 if $info->{extruding} && ($args->{F} // $self->F) == $config->solid_infill_speed*60; }); is scalar(keys %solid_layers), $config->bottom_solid_layers + $config->top_solid_layers, "no superfluous shells are generated"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('perimeters', 1); $config->set('fill_density', 0); $config->set('top_solid_layers', 0); $config->set('spiral_vase', 1); $config->set('bottom_solid_layers', 0); $config->set('skirts', 0); $config->set('first_layer_height', '100%'); $config->set('start_gcode', ''); $config->set('temperature', [200]); $config->set('first_layer_temperature', [205]); # TODO: this needs to be tested with a model with sloping edges, where starting # points of each layer are not aligned - in that case we would test that no # travel moves are left to move to the new starting point - in a cube, end # points coincide with next layer starting points (provided there's no clipping) my $test = sub { my ($model_name, $description) = @_; my $print = Slic3r::Test::init_print($model_name, config => $config); my $travel_moves_after_first_extrusion = 0; my $started_extruding = 0; my $first_layer_temperature_set = 0; my $temperature_set = 0; my @z_steps = (); Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1') { $started_extruding = 1 if $info->{extruding}; push @z_steps, $info->{dist_Z} if $started_extruding && $info->{dist_Z} > 0; $travel_moves_after_first_extrusion++ if $info->{travel} && $info->{dist_XY} > 0 && $started_extruding && !exists $args->{Z}; } elsif ($cmd eq 'M104') { $first_layer_temperature_set = 1 if $args->{S} == 205; $temperature_set = 1 if $args->{S} == 200; } }); ok $first_layer_temperature_set, 'first layer temperature is preserved'; ok $temperature_set, 'temperature is preserved'; # we allow one travel move after first extrusion: i.e. when moving to the first # spiral point after moving to second layer (bottom layer had loop clipping, so # we're slightly distant from the starting point of the loop) ok $travel_moves_after_first_extrusion <= 1, "no gaps in spiral vase ($description)"; ok !(grep { $_ > $config->layer_height + epsilon } @z_steps), "no gaps in Z ($description)"; }; $test->('20mm_cube', 'solid model'); $config->set('z_offset', -10); $test->('20mm_cube', 'solid model with negative z-offset'); ### Disabled because the current unreliable medial axis code doesn't ### always produce valid loops. ###$test->('40x10', 'hollow model with negative z-offset'); } { my $config = Slic3r::Config->new_from_defaults; $config->set('spiral_vase', 1); $config->set('perimeters', 1); $config->set('fill_density', 0); $config->set('top_solid_layers', 0); $config->set('bottom_solid_layers', 0); $config->set('retract_layer_change', [0]); $config->set('skirts', 0); $config->set('first_layer_height', '100%'); $config->set('layer_height', 0.4); $config->set('start_gcode', ''); $config->validate; my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $z_moves = 0; my @this_layer = (); # [ dist_Z, dist_XY ], ... my $bottom_layer_not_flat = 0; my $null_z_moves_not_layer_changes = 0; my $null_z_moves_not_multiples_of_layer_height = 0; my $sum_of_partial_z_equals_to_layer_height = 0; my $all_layer_segments_have_same_slope = 0; my $horizontal_extrusions = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1') { if ($z_moves < 2) { # skip everything up to the second Z move # (i.e. start of second layer) if (exists $args->{Z}) { $z_moves++; $bottom_layer_not_flat = 1 if $info->{dist_Z} > 0 && $info->{dist_Z} != $config->layer_height; } } elsif ($info->{dist_Z} == 0 && $args->{Z}) { $null_z_moves_not_layer_changes = 1 if $info->{dist_XY} != 0; # % doesn't work easily with floats $null_z_moves_not_multiples_of_layer_height = 1 if abs(($args->{Z} / $config->layer_height) * $config->layer_height - $args->{Z}) > epsilon; my $total_dist_XY = sum(map $_->[1], @this_layer); $sum_of_partial_z_equals_to_layer_height = 1 if abs(sum(map $_->[0], @this_layer) - $config->layer_height) > epsilon; foreach my $segment (@this_layer) { # check that segment's dist_Z is proportioned to its dist_XY $all_layer_segments_have_same_slope = 1 if abs($segment->[0]*$total_dist_XY/$config->layer_height - $segment->[1]) > 0.2; } @this_layer = (); } elsif ($info->{extruding} && $info->{dist_XY} > 0) { $horizontal_extrusions = 1 if $info->{dist_Z} == 0; push @this_layer, [ $info->{dist_Z}, $info->{dist_XY} ]; } } }); ok !$bottom_layer_not_flat, 'bottom layer is flat when using spiral vase'; ok !$null_z_moves_not_layer_changes, 'null Z moves are layer changes'; ok !$null_z_moves_not_multiples_of_layer_height, 'null Z moves are multiples of layer height'; ok !$sum_of_partial_z_equals_to_layer_height, 'sum of partial Z increments equals to a full layer height'; ok !$all_layer_segments_have_same_slope, 'all layer segments have the same slope'; ok !$horizontal_extrusions, 'no horizontal extrusions'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('perimeters', 1); $config->set('fill_density', 0); $config->set('top_solid_layers', 0); $config->set('spiral_vase', 1); $config->set('bottom_solid_layers', 0); $config->set('skirts', 0); $config->set('first_layer_height', '100%'); $config->set('start_gcode', ''); my $print = Slic3r::Test::init_print('two_hollow_squares', config => $config); my $diagonal_moves = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1') { if ($info->{extruding} && $info->{dist_XY} > 0) { if ($info->{dist_Z} > 0) { $diagonal_moves++; } } } }); is $diagonal_moves, 0, 'no spiral moves on two-island object'; } __END__ Slic3r-version_1.31.6/t/skirt_brim.t000066400000000000000000000125041301441720000172750ustar00rootroot00000000000000use Test::More tests => 6; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Geometry qw(unscale convex_hull); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 1); $config->set('skirt_height', 2); $config->set('perimeters', 0); $config->set('support_material_speed', 99); $config->set('cooling', 0); # to prevent speeds to be altered $config->set('first_layer_speed', '100%'); # to prevent speeds to be altered my $test = sub { my ($conf) = @_; $conf ||= $config; my $print = Slic3r::Test::init_print(['20mm_cube','20mm_cube'], config => $config); my %layers_with_skirt = (); # Z => $count Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if (defined $self->Z) { $layers_with_skirt{$self->Z} //= 0; $layers_with_skirt{$self->Z} = 1 if $info->{extruding} && ($args->{F} // $self->F) == $config->support_material_speed*60; } }); fail "wrong number of layers with skirt" unless (grep $_, values %layers_with_skirt) == $config->skirt_height; }; ok $test->(), "skirt_height is honored when printing multiple objects too"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('perimeters', 0); $config->set('top_solid_layers', 0); # to prevent solid shells and their speeds $config->set('bottom_solid_layers', 0); # to prevent solid shells and their speeds $config->set('brim_width', 5); $config->set('support_material_speed', 99); $config->set('cooling', 0); # to prevent speeds to be altered $config->set('first_layer_speed', '100%'); # to prevent speeds to be altered my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my %layers_with_brim = (); # Z => $count Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if (defined $self->Z) { $layers_with_brim{$self->Z} //= 0; $layers_with_brim{$self->Z} = 1 if $info->{extruding} && $info->{dist_XY} > 0 && ($args->{F} // $self->F) != $config->infill_speed*60; } }); is scalar(grep $_, values %layers_with_brim), 1, "brim is generated"; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 1); $config->set('brim_width', 10); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok Slic3r::Test::gcode($print), 'successful G-code generation when skirt is smaller than brim width'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 1); $config->set('skirt_height', 0); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok Slic3r::Test::gcode($print), 'successful G-code generation when skirt_height = 0 and skirts > 0'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('layer_height', 0.4); $config->set('first_layer_height', 0.4); $config->set('skirts', 1); $config->set('skirt_distance', 0); $config->set('support_material_speed', 99); $config->set('perimeter_extruder', 1); $config->set('support_material_extruder', 2); $config->set('cooling', 0); # to prevent speeds to be altered $config->set('first_layer_speed', '100%'); # to prevent speeds to be altered my $print = Slic3r::Test::init_print('overhang', config => $config); $print->process; # we enable support material after skirt has been generated $config->set('support_material', 1); $print->apply_config($config); my $skirt_length = 0; my @extrusion_points = (); my $tool = undef; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif (defined $self->Z && $self->Z == $config->first_layer_height) { # we're on first layer if ($info->{extruding} && $info->{dist_XY} > 0) { my $speed = ($args->{F} // $self->F) / 60; if ($speed == $config->support_material_speed && $tool == $config->perimeter_extruder-1) { # skirt uses support material speed but first object's extruder $skirt_length += $info->{dist_XY}; } else { push @extrusion_points, my $point = Slic3r::Point->new_scale($args->{X}, $args->{Y}); } } } }); my $convex_hull = convex_hull(\@extrusion_points); my $hull_perimeter = unscale($convex_hull->split_at_first_point->length); ok $skirt_length > $hull_perimeter, 'skirt lenght is large enough to contain object with support'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('min_skirt_length', 20); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok Slic3r::Test::gcode($print), 'no crash when using min_skirt_length'; } __END__ Slic3r-version_1.31.6/t/slice.t000066400000000000000000000112171301441720000162270ustar00rootroot00000000000000use Test::More; use strict; use warnings; plan skip_all => 'temporarily disabled'; plan tests => 16; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } # temporarily disable compilation errors due to constant not being exported anymore sub Slic3r::TriangleMesh::I_B {} sub Slic3r::TriangleMesh::I_FACET_EDGE {} sub Slic3r::TriangleMesh::FE_BOTTOM { sub Slic3r::TriangleMesh::FE_TOP {}} use Slic3r; use Slic3r::Geometry qw(X Y Z A B); my @lines; my $z = 20; my @points = ([3, 4], [8, 5], [1, 9]); # XY coordinates of the facet vertices # NOTE: # the first point of the intersection lines is replaced by -1 because TriangleMesh.pm # is saving memory and doesn't store point A anymore since it's not actually needed. # We disable this test because intersect_facet() now assumes we never feed a horizontal # facet to it. # is_deeply lines(20, 20, 20), [ # [ -1, $points[1] ], # $points[0] # [ -1, $points[2] ], # $points[1] # [ -1, $points[0] ], # $points[2] # ], 'horizontal'; is_deeply lines(22, 20, 20), [ [ -1, $points[2] ] ], 'lower edge on layer'; # $points[1] is_deeply lines(20, 20, 22), [ [ -1, $points[1] ] ], 'lower edge on layer'; # $points[0] is_deeply lines(20, 22, 20), [ [ -1, $points[0] ] ], 'lower edge on layer'; # $points[2] is_deeply lines(20, 20, 10), [ [ -1, $points[0] ] ], 'upper edge on layer'; # $points[1] is_deeply lines(10, 20, 20), [ [ -1, $points[1] ] ], 'upper edge on layer'; # $points[2] is_deeply lines(20, 10, 20), [ [ -1, $points[2] ] ], 'upper edge on layer'; # $points[0] is_deeply lines(20, 15, 10), [ ], 'upper vertex on layer'; is_deeply lines(28, 20, 30), [ ], 'lower vertex on layer'; { my @z = (24, 10, 16); is_deeply lines(@z), [ [ -1, # line_plane_intersection([ vertices(@z)->[0], vertices(@z)->[1] ]), line_plane_intersection([ vertices(@z)->[2], vertices(@z)->[0] ]), ] ], 'two edges intersect'; } { my @z = (16, 24, 10); is_deeply lines(@z), [ [ -1, # line_plane_intersection([ vertices(@z)->[1], vertices(@z)->[2] ]), line_plane_intersection([ vertices(@z)->[0], vertices(@z)->[1] ]), ] ], 'two edges intersect'; } { my @z = (10, 16, 24); is_deeply lines(@z), [ [ -1, # line_plane_intersection([ vertices(@z)->[2], vertices(@z)->[0] ]), line_plane_intersection([ vertices(@z)->[1], vertices(@z)->[2] ]), ] ], 'two edges intersect'; } { my @z = (24, 10, 20); is_deeply lines(@z), [ [ -1, # line_plane_intersection([ vertices(@z)->[0], vertices(@z)->[1] ]), $points[2], ] ], 'one vertex on plane and one edge intersects'; } { my @z = (10, 20, 24); is_deeply lines(@z), [ [ -1, # line_plane_intersection([ vertices(@z)->[2], vertices(@z)->[0] ]), $points[1], ] ], 'one vertex on plane and one edge intersects'; } { my @z = (20, 24, 10); is_deeply lines(@z), [ [ -1, # line_plane_intersection([ vertices(@z)->[1], vertices(@z)->[2] ]), $points[0], ] ], 'one vertex on plane and one edge intersects'; } my @lower = intersect(22, 20, 20); my @upper = intersect(20, 20, 10); is $lower[0][Slic3r::TriangleMesh::I_FACET_EDGE], Slic3r::TriangleMesh::FE_BOTTOM, 'bottom edge on layer'; is $upper[0][Slic3r::TriangleMesh::I_FACET_EDGE], Slic3r::TriangleMesh::FE_TOP, 'upper edge on layer'; my $mesh; sub intersect { $mesh = Slic3r::TriangleMesh->new( facets => [], vertices => [], ); push @{$mesh->facets}, [ [0,0,0], @{vertices(@_)} ]; $mesh->analyze; return map Slic3r::TriangleMesh::unpack_line($_), $mesh->intersect_facet($#{$mesh->facets}, $z); } sub vertices { push @{$mesh->vertices}, map [ @{$points[$_]}, $_[$_] ], 0..2; [ ($#{$mesh->vertices}-2) .. $#{$mesh->vertices} ] } sub lines { my @lines = intersect(@_); #$_->a->[X] = sprintf('%.0f', $_->a->[X]) for @lines; #$_->a->[Y] = sprintf('%.0f', $_->a->[Y]) for @lines; $_->[Slic3r::TriangleMesh::I_B][X] = sprintf('%.0f', $_->[Slic3r::TriangleMesh::I_B][X]) for @lines; $_->[Slic3r::TriangleMesh::I_B][Y] = sprintf('%.0f', $_->[Slic3r::TriangleMesh::I_B][Y]) for @lines; return [ map [ -1, $_->[Slic3r::TriangleMesh::I_B] ], @lines ]; } sub line_plane_intersection { my ($line) = @_; @$line = map $mesh->vertices->[$_], @$line; return [ map sprintf('%.0f', $_), map +($line->[B][$_] + ($line->[A][$_] - $line->[B][$_]) * ($z - $line->[B][Z]) / ($line->[A][Z] - $line->[B][Z])), (X,Y) ]; } __END__ Slic3r-version_1.31.6/t/support.t000066400000000000000000000242241301441720000166460ustar00rootroot00000000000000use Test::More tests => 27; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Geometry qw(epsilon scale); use Slic3r::Geometry::Clipper qw(diff); use Slic3r::Test; { my $config = Slic3r::Config->new_from_defaults; $config->set('support_material', 1); my @contact_z = my @top_z = (); my $test = sub { my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $flow = $print->print->objects->[0]->support_material_flow; my $support = Slic3r::Print::SupportMaterial->new( object_config => $print->print->objects->[0]->config, print_config => $print->print->config, flow => $flow, interface_flow => $flow, first_layer_flow => $flow, ); my $support_z = $support->support_layers_z(\@contact_z, \@top_z, $config->layer_height); my $expected_top_spacing = $support->contact_distance($config->layer_height, $config->nozzle_diameter->[0]); is $support_z->[0], $config->first_layer_height, 'first layer height is honored'; is scalar(grep { $support_z->[$_]-$support_z->[$_-1] <= 0 } 1..$#$support_z), 0, 'no null or negative support layers'; is scalar(grep { $support_z->[$_]-$support_z->[$_-1] > $config->nozzle_diameter->[0] + epsilon } 1..$#$support_z), 0, 'no layers thicker than nozzle diameter'; my $wrong_top_spacing = 0; foreach my $top_z (@top_z) { # find layer index of this top surface my $layer_id = first { abs($support_z->[$_] - $top_z) < epsilon } 0..$#$support_z; # check that first support layer above this top surface (or the next one) is spaced with nozzle diameter $wrong_top_spacing = 1 if ($support_z->[$layer_id+1] - $support_z->[$layer_id]) != $expected_top_spacing && ($support_z->[$layer_id+2] - $support_z->[$layer_id]) != $expected_top_spacing; } ok !$wrong_top_spacing, 'layers above top surfaces are spaced correctly'; }; $config->set('layer_height', 0.2); $config->set('first_layer_height', 0.3); @contact_z = (1.9); @top_z = (1.1); $test->(); $config->set('first_layer_height', 0.4); $test->(); $config->set('layer_height', $config->nozzle_diameter->[0]); $test->(); } { my $config = Slic3r::Config->new_from_defaults; $config->set('raft_layers', 3); $config->set('brim_width', 0); $config->set('skirts', 0); $config->set('support_material_extruder', 2); $config->set('support_material_interface_extruder', 2); $config->set('layer_height', 0.4); $config->set('first_layer_height', 0.4); my $print = Slic3r::Test::init_print('overhang', config => $config); ok my $gcode = Slic3r::Test::gcode($print), 'no conflict between raft/support and brim'; my $tool = 0; Slic3r::GCode::Reader->new->parse($gcode, sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($info->{extruding}) { if ($self->Z <= ($config->raft_layers * $config->layer_height)) { fail 'not extruding raft with support material extruder' if $tool != ($config->support_material_extruder-1); } else { fail 'support material exceeds raft layers' if $tool == $config->support_material_extruder-1; # TODO: we should test that full support is generated when we use raft too } } }); } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('raft_layers', 3); $config->set('support_material_pattern', 'honeycomb'); $config->set('support_material_extrusion_width', 0.6); $config->set('first_layer_extrusion_width', '100%'); $config->set('bridge_speed', 99); $config->set('cooling', 0); # prevent speed alteration $config->set('first_layer_speed', '100%'); # prevent speed alteration $config->set('start_gcode', ''); # prevent any unexpected Z move my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my $layer_id = -1; # so that first Z move sets this to 0 my @raft = my @first_object_layer = (); my %first_object_layer_speeds = (); # F => 1 Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding} && $info->{dist_XY} > 0) { if ($layer_id <= $config->raft_layers) { # this is a raft layer or the first object layer my $line = Slic3r::Line->new_scale([ $self->X, $self->Y ], [ $info->{new_X}, $info->{new_Y} ]); my @path = @{$line->grow(scale($config->support_material_extrusion_width/2))}; if ($layer_id < $config->raft_layers) { # this is a raft layer push @raft, @path; } else { push @first_object_layer, @path; $first_object_layer_speeds{ $args->{F} // $self->F } = 1; } } } elsif ($cmd eq 'G1' && $info->{dist_Z} > 0) { $layer_id++; } }); ok !@{diff(\@first_object_layer, \@raft)}, 'first object layer is completely supported by raft'; is scalar(keys %first_object_layer_speeds), 1, 'only one speed used in first object layer'; ok +(keys %first_object_layer_speeds)[0] == $config->bridge_speed*60, 'bridge speed used in first object layer'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('layer_height', 0.35); $config->set('first_layer_height', 0.3); $config->set('nozzle_diameter', [0.5]); $config->set('support_material_extruder', 2); $config->set('support_material_interface_extruder', 2); my $test = sub { my ($raft_layers) = @_; $config->set('raft_layers', $raft_layers); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); my %raft_z = (); # z => 1 my $tool = undef; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($info->{extruding} && $info->{dist_XY} > 0) { if ($tool == $config->support_material_extruder-1) { $raft_z{$self->Z} = 1; } } }); is scalar(keys %raft_z), $config->raft_layers, 'correct number of raft layers is generated'; }; $test->(2); $test->(70); $config->set('layer_height', 0.4); $config->set('first_layer_height', 0.35); $test->(3); $test->(70); } { my $config = Slic3r::Config->new_from_defaults; $config->set('brim_width', 0); $config->set('skirts', 0); $config->set('support_material', 1); $config->set('top_solid_layers', 0); # so that we don't have the internal bridge over infill $config->set('bridge_speed', 99); $config->set('cooling', 0); $config->set('first_layer_speed', '100%'); my $test = sub { my $print = Slic3r::Test::init_print('overhang', config => $config); my $has_bridge_speed = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($info->{extruding}) { if (($args->{F} // $self->F) == $config->bridge_speed*60) { $has_bridge_speed = 1; } } }); return $has_bridge_speed; }; $config->set('support_material_contact_distance', 0.2); ok $test->(), 'bridge speed is used when support_material_contact_distance > 0'; $config->set('support_material_contact_distance', 0); ok !$test->(), 'bridge speed is not used when support_material_contact_distance == 0'; $config->set('raft_layers', 5); $config->set('support_material_contact_distance', 0.2); ok $test->(), 'bridge speed is used when raft_layers > 0 and support_material_contact_distance > 0'; $config->set('support_material_contact_distance', 0); ok !$test->(), 'bridge speed is not used when raft_layers > 0 and support_material_contact_distance == 0'; } { my $config = Slic3r::Config->new_from_defaults; $config->set('skirts', 0); $config->set('start_gcode', ''); $config->set('raft_layers', 8); $config->set('nozzle_diameter', [0.4, 1]); $config->set('layer_height', 0.1); $config->set('first_layer_height', 0.8); $config->set('support_material_extruder', 2); $config->set('support_material_interface_extruder', 2); $config->set('support_material_contact_distance', 0); my $print = Slic3r::Test::init_print('20mm_cube', config => $config); ok my $gcode = Slic3r::Test::gcode($print), 'first_layer_height is validated with support material extruder nozzle diameter when using raft layers'; my $tool = undef; my @z = (0); my %layer_heights_by_tool = (); # tool => [ lh, lh... ] Slic3r::GCode::Reader->new->parse($gcode, sub { my ($self, $cmd, $args, $info) = @_; if ($cmd =~ /^T(\d+)/) { $tool = $1; } elsif ($cmd eq 'G1' && exists $args->{Z} && $args->{Z} != $self->Z) { push @z, $args->{Z}; } elsif ($info->{extruding} && $info->{dist_XY} > 0) { $layer_heights_by_tool{$tool} ||= []; push @{ $layer_heights_by_tool{$tool} }, $z[-1] - $z[-2]; } }); ok !defined(first { $_ > $config->nozzle_diameter->[0] + epsilon } @{ $layer_heights_by_tool{$config->perimeter_extruder-1} }), 'no object layer is thicker than nozzle diameter'; ok !defined(first { abs($_ - $config->layer_height) < epsilon } @{ $layer_heights_by_tool{$config->support_material_extruder-1} }), 'no support material layer is as thin as object layers'; } __END__ Slic3r-version_1.31.6/t/svg.t000066400000000000000000000013211301441720000157220ustar00rootroot00000000000000use Test::More tests => 2; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Test; { my $print = Slic3r::Test::init_print('20mm_cube'); eval { my $fh = IO::Scalar->new(\my $gcode); $print->print->export_svg(output_fh => $fh, quiet => 1); $fh->close; }; die $@ if $@; ok !$@, 'successful SVG export'; } { my $print = Slic3r::Test::init_print('two_hollow_squares'); eval { my $fh = IO::Scalar->new(\my $gcode); $print->print->export_svg(output_fh => $fh, quiet => 1); $fh->close; }; die $@ if $@; ok !$@, 'successful SVG export of object with two islands'; } __END__ Slic3r-version_1.31.6/t/thin.t000066400000000000000000000177731301441720000161070ustar00rootroot00000000000000use Test::More tests => 23; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use List::Util qw(first sum none); use Slic3r::Geometry qw(epsilon scale unscale scaled_epsilon Y); use Slic3r::Test; # Disable this until a more robust implementation is provided. It currently # fails on Linux 32bit because some spurious extrudates are generated. if (0) { my $config = Slic3r::Config->new_from_defaults; $config->set('layer_height', 0.2); $config->set('first_layer_height', '100%'); $config->set('extrusion_width', 0.5); $config->set('first_layer_extrusion_width', '200%'); # check this one too $config->set('skirts', 0); $config->set('thin_walls', 1); my $print = Slic3r::Test::init_print('gt2_teeth', config => $config); my %extrusion_paths = (); # Z => count of continuous extrusions my $extruding = 0; Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1') { if ($info->{extruding} && $info->{dist_XY}) { if (!$extruding) { $extrusion_paths{$self->Z} //= 0; $extrusion_paths{$self->Z}++; } $extruding = 1; } else { $extruding = 0; } } }); ok !(first { $_ != 3 } values %extrusion_paths), 'no superfluous thin walls are generated for toothed profile'; } { my $square = Slic3r::Polygon->new_scale( # ccw [100, 100], [200, 100], [200, 200], [100, 200], ); my $hole_in_square = Slic3r::Polygon->new_scale( # cw [140, 140], [140, 160], [160, 160], [160, 140], ); my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square); my $res = $expolygon->medial_axis(scale 40, scale 0.5); is scalar(@$res), 1, 'medial axis of a square shape is a single path'; isa_ok $res->[0], 'Slic3r::Polyline', 'medial axis result is a polyline'; ok $res->[0]->first_point->coincides_with($res->[0]->last_point), 'polyline forms a closed loop'; ok $res->[0]->length > $hole_in_square->length && $res->[0]->length < $square->length, 'medial axis loop has reasonable length'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new_scale( [100, 100], [120, 100], [120, 200], [100, 200], )); my $res = $expolygon->medial_axis(scale 20, scale 0.5); is scalar(@$res), 1, 'medial axis of a narrow rectangle is a single line'; ok unscale($res->[0]->length) >= (200-100 - (120-100)) - epsilon, 'medial axis has reasonable length'; $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new_scale( [100, 100], [120, 100], [120, 200], [105, 200], # extra point in the short side [100, 200], )); my $res2 = $expolygon->medial_axis(scale 1, scale 0.5); is scalar(@$res), 1, 'medial axis of a narrow rectangle with an extra vertex is still a single line'; ok unscale($res->[0]->length) >= (200-100 - (120-100)) - epsilon, 'medial axis has still a reasonable length'; ok !(grep { abs($_ - scale 150) < scaled_epsilon } map $_->[Y], map @$_, @$res2), "extra vertices don't influence medial axis"; } { my $expolygon = Slic3r::ExPolygon->new( Slic3r::Polygon->new([1185881,829367],[1421988,1578184],[1722442,2303558],[2084981,2999998],[2506843,3662186],[2984809,4285086],[3515250,4863959],[4094122,5394400],[4717018,5872368],[5379210,6294226],[6075653,6656769],[6801033,6957229],[7549842,7193328],[8316383,7363266],[9094809,7465751],[9879211,7500000],[10663611,7465750],[11442038,7363265],[12208580,7193327],[12957389,6957228],[13682769,6656768],[14379209,6294227],[15041405,5872366],[15664297,5394401],[16243171,4863960],[16758641,4301424],[17251579,3662185],[17673439,3000000],[18035980,2303556],[18336441,1578177],[18572539,829368],[18750748,0],[19758422,0],[19727293,236479],[19538467,1088188],[19276136,1920196],[18942292,2726179],[18539460,3499999],[18070731,4235755],[17539650,4927877],[16950279,5571067],[16307090,6160437],[15614974,6691519],[14879209,7160248],[14105392,7563079],[13299407,7896927],[12467399,8159255],[11615691,8348082],[10750769,8461952],[9879211,8500000],[9007652,8461952],[8142729,8348082],[7291022,8159255],[6459015,7896927],[5653029,7563079],[4879210,7160247],[4143447,6691519],[3451331,6160437],[2808141,5571066],[2218773,4927878],[1687689,4235755],[1218962,3499999],[827499,2748020],[482284,1920196],[219954,1088186],[31126,236479],[0,0],[1005754,0]), ); my $res = $expolygon->medial_axis(scale 1.324888, scale 0.25); is scalar(@$res), 1, 'medial axis of a semicircumference is a single line'; # check whether turns are all CCW or all CW my @lines = @{$res->[0]->lines}; my @angles = map { $lines[$_-1]->ccw($lines[$_]->b) } 1..$#lines; ok !!(none { $_ < 0 } @angles) || (none { $_ > 0 } @angles), 'all medial axis segments of a semicircumference have the same orientation'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new_scale( [100, 100], [120, 100], [112, 200], [108, 200], )); my $res = $expolygon->medial_axis(scale 20, scale 0.5); is scalar(@$res), 1, 'medial axis of a narrow trapezoid is a single line'; ok unscale($res->[0]->length) >= (200-100 - (120-100)) - epsilon, 'medial axis has reasonable length'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new_scale( [100, 100], [120, 100], [120, 180], [200, 180], [200, 200], [100, 200], )); my $res = $expolygon->medial_axis(scale 20, scale 0.5); is scalar(@$res), 1, 'medial axis of a L shape is a single polyline'; my $len = unscale($res->[0]->length) + 20; # 20 is the thickness of the expolygon, which is subtracted from the ends ok $len > 80*2 && $len < 100*2, 'medial axis has reasonable length'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new( [-203064906,-51459966],[-219312231,-51459966],[-219335477,-51459962],[-219376095,-51459962],[-219412047,-51459966], [-219572094,-51459966],[-219624814,-51459962],[-219642183,-51459962],[-219656665,-51459966],[-220815482,-51459966], [-220815482,-37738966],[-221117540,-37738966],[-221117540,-51762024],[-203064906,-51762024], )); my $polylines = $expolygon->medial_axis(819998, 102499.75); my $perimeter = $expolygon->contour->split_at_first_point->length; ok sum(map $_->length, @$polylines) > $perimeter/2/4*3, 'medial axis has a reasonable length'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new_scale( [50, 100], [1000, 102], [50, 104], )); my $res = $expolygon->medial_axis(scale 4, scale 0.5); is scalar(@$res), 1, 'medial axis of a narrow triangle is a single line'; ok unscale($res->[0]->length) >= (200-100 - (120-100)) - epsilon, 'medial axis has reasonable length'; } { # GH #2474 my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new( [91294454,31032190],[11294481,31032190],[11294481,29967810],[44969182,29967810],[89909960,29967808],[91294454,29967808] )); my $polylines = $expolygon->medial_axis(1871238, 500000); is scalar(@$polylines), 1, 'medial axis is a single polyline'; my $polyline = $polylines->[0]; my $expected_y = $expolygon->bounding_box->center->y; #;; ok abs(sum(map $_->y, @$polyline) / @$polyline - $expected_y) < scaled_epsilon, #,, 'medial axis is horizontal and is centered'; # order polyline from left to right $polyline->reverse if $polyline->first_point->x > $polyline->last_point->x; my $polyline_bb = $polyline->bounding_box; is $polyline->first_point->x, $polyline_bb->x_min, 'expected x_min'; is $polyline->last_point->x, $polyline_bb->x_max, 'expected x_max'; is_deeply [ map $_->x, @$polyline ], [ sort map $_->x, @$polyline ], 'medial axis is not self-overlapping'; } __END__ Slic3r-version_1.31.6/t/threads.t000066400000000000000000000014301301441720000165560ustar00rootroot00000000000000use Test::More; use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use List::Util qw(first); use Slic3r; use Slic3r::Test; if (!$Slic3r::have_threads) { plan skip_all => "this perl is not compiled with threads"; } plan tests => 2; { my $print = Slic3r::Test::init_print('20mm_cube'); { my $thread = threads->create(sub { Slic3r::thread_cleanup(); return 1; }); ok $thread->join, "print survives thread spawning"; } } { my $thread = threads->create(sub { { my $print = Slic3r::Test::init_print('20mm_cube'); Slic3r::Test::gcode($print); } Slic3r::thread_cleanup(); return 1; }); ok $thread->join, "process print in a separate thread"; } __END__ Slic3r-version_1.31.6/utils/000077500000000000000000000000001301441720000156365ustar00rootroot00000000000000Slic3r-version_1.31.6/utils/amf-to-stl.pl000077500000000000000000000017761301441720000201740ustar00rootroot00000000000000#!/usr/bin/perl # This script converts an AMF file to STL use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use File::Basename qw(basename); use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; $|++; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'ascii' => \$opt{ascii}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { my $model = Slic3r::Format::AMF->read_file($ARGV[0]); my $output_file = $ARGV[0]; $output_file =~ s/\.amf(?:\.xml)?$/\.stl/i; printf "Writing to %s\n", basename($output_file); Slic3r::Format::STL->write_file($output_file, $model, binary => !$opt{ascii}); } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: amf-to-stl.pl [ OPTIONS ] file.amf --help Output this usage screen and exit --ascii Generate ASCII STL files (default: binary) EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/config-bundle-to-config.pl000077500000000000000000000024441301441720000226010ustar00rootroot00000000000000#!/usr/bin/perl # This script extracts a full active config from a config bundle. # (Often users reporting issues don't attach plain configs, but # bundles...) use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; use Slic3r::Test; $|++; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'output=s' => \$opt{output}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } ($ARGV[0] && $opt{output}) or usage(1); { my $bundle_ini = Slic3r::Config->read_ini($ARGV[0]) or die "Failed to read $ARGV[0]\n"; my $config_ini = { _ => {} }; foreach my $section (qw(print filament printer)) { my $preset_name = $bundle_ini->{presets}{$section}; $preset_name =~ s/\.ini$//; my $preset = $bundle_ini->{"$section:$preset_name"} or die "Failed to find preset $preset_name in bundle\n"; $config_ini->{_}{$_} = $preset->{$_} for keys %$preset; } Slic3r::Config->write_ini($opt{output}, $config_ini); } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: config-bundle-to-config.pl --output config.ini bundle.ini EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/dump-stl.pl000066400000000000000000000021571301441720000177450ustar00rootroot00000000000000#!/usr/bin/perl # This script dumps a STL file into Perl syntax for writing tests # or dumps a test model into a STL file use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; use Slic3r::Test; $|++; $ARGV[0] or usage(1); if (-e $ARGV[0]) { my $model = Slic3r::Format::STL->read_file($ARGV[0]); $model->objects->[0]->add_instance(offset => Slic3r::Pointf->new(0,0)); my $mesh = $model->mesh; $mesh->repair; printf "VERTICES = %s\n", join ',', map "[$_->[0],$_->[1],$_->[2]]", @{$mesh->vertices}; printf "FACETS = %s\n", join ',', map "[$_->[0],$_->[1],$_->[2]]", @{$mesh->facets}; exit 0; } elsif ((my $model = Slic3r::Test::model($ARGV[0]))) { $ARGV[1] or die "Missing writeable destination as second argument\n"; Slic3r::Format::STL->write_file($ARGV[1], $model); printf "Model $ARGV[0] written to $ARGV[1]\n"; exit 0; } else { die "No such model exists\n"; } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: dump-stl.pl file.stl dump-stl.pl modelname file.stl EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/gcode_sectioncut.pl000066400000000000000000000072331301441720000215210ustar00rootroot00000000000000#!/usr/bin/perl # This script generates section cuts from a given G-Code file use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Getopt::Long qw(:config no_auto_abbrev); use IO::All; use List::Util qw(max); use Slic3r; use Slic3r::Geometry qw(X Y A B X1 Y1 X2 Y2); use Slic3r::Geometry::Clipper qw(JT_SQUARE); use Slic3r::Test; use SVG; my %opt = ( layer_height => 0.2, extrusion_width => 0.5, scale => 30, ); { my %options = ( 'help' => sub { usage() }, 'layer-height|h=f' => \$opt{layer_height}, 'extrusion-width|w=f' => \$opt{extrusion_width}, 'scale|s=i' => \$opt{scale}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { my $input_file = $ARGV[0]; my $output_file = $input_file; $output_file =~ s/\.(?:gcode|gco|ngc|g)$/.svg/; # read paths my %paths = (); # z => [ path, path ... ] Slic3r::GCode::Reader->new->parse(io($input_file)->all, sub { my ($self, $cmd, $args, $info) = @_; if ($cmd eq 'G1' && $info->{extruding}) { $paths{ $self->Z } ||= []; push @{ $paths{ $self->Z } }, Slic3r::Line->new( [ $self->X, $self->Y ], [ $info->{new_X}, $info->{new_Y} ], ); } }); # calculate print extents my $bounding_box = Slic3r::Geometry::BoundingBox->new_from_points([ map @$_, map @$_, values %paths ]); # calculate section line my $section_y = $bounding_box->center->[Y]; my $section_line = [ [ $bounding_box->x_min, $section_y ], [ $bounding_box->x_max, $section_y ], ]; # initialize output my $max_z = max(keys %paths); my $svg = SVG->new( width => $opt{scale} * $bounding_box->size->[X], height => $opt{scale} * $max_z, ); # put everything into a group my $g = $svg->group(style => { 'stroke-width' => 1, 'stroke' => '#444444', 'fill' => 'grey', }); # draw paths foreach my $z (sort keys %paths) { foreach my $line (@{ $paths{$z} }) { my @intersections = @{intersection_pl( [ $section_line ], [ _grow($line, $opt{extrusion_width}/2) ], )}; $g->rectangle( 'x' => $opt{scale} * ($_->[A][X] - $bounding_box->x_min), 'y' => $opt{scale} * ($max_z - $z), 'width' => $opt{scale} * abs($_->[B][X] - $_->[A][X]), 'height' => $opt{scale} * $opt{layer_height}, 'rx' => $opt{scale} * $opt{layer_height} * 0.35, 'ry' => $opt{scale} * $opt{layer_height} * 0.35, ) for @intersections; } } # write output Slic3r::open(\my $fh, '>', $output_file); print $fh $svg->xmlify; close $fh; printf "Section cut SVG written to %s\n", $output_file; } # replace built-in Line->grow method which relies on int_offset() sub _grow { my ($line, $distance) = @_; my $polygon = [ @$line, CORE::reverse @$line[1..($#$line-1)] ]; return @{Math::Clipper::offset([$polygon], $distance, 100000, JT_SQUARE, 2)}; } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: gcode_sectioncut.pl [ OPTIONS ] file.gcode --help Output this usage screen and exit --layer-height, -h Use the specified layer height --extrusion-width, -w Use the specified extrusion width --scale Factor for converting G-code units to SVG units EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/modifier_helpers/000077500000000000000000000000001301441720000211565ustar00rootroot00000000000000Slic3r-version_1.31.6/utils/modifier_helpers/layer_generator.jscad000066400000000000000000000011371301441720000253500ustar00rootroot00000000000000// title: Layer_generator // written by: Joseph Lenox // Used for generating cubes oriented about the center // for making simple modifier meshes. var width = 100; var layer_height = 0.3; var z = 30; function main() { return cube(size=[width,width,layer_height], center=true).translate([0,0,z]); } function getParameterDefinitions() { return [ { name: 'width', type: 'float', initial: 100, caption: "Width of the cube:" }, { name: 'layer_height', type: 'float', initial: 0.3, caption: "Layer height used:" }, { name: 'z', type: 'float', initial: 0, caption: "Z:" } ]; } Slic3r-version_1.31.6/utils/modifier_helpers/solid_layers.scad000066400000000000000000000020531301441720000245030ustar00rootroot00000000000000// Used to generate a modifier mesh to do something every few layers. // Load into OpenSCAD, tweak the variables below, export as STL and load as // a modifier mesh. Then change settings for the modifier mesh. // Written by Joseph Lenox; in public domain. layer_height = 0.3; // set to layer height in slic3r for "best" results. number_of_solid_layers = 2; N = 4; // N > number_of_solid_layers or else the whole thing will be solid model_height = 300.0; model_width = 300.0; // these two should be at least as big as the model model_depth = 300.0; // but bigger isn't a problem initial_offset=0; // don't generate below this position_on_bed=[0,0,0]; // in case you need to move it around // don't touch below unless you know what you are doing. simple_layers = round(model_height/layer_height); translate(position_on_bed) for (i = [initial_offset:N:simple_layers]) { translate([0,0,i*layer_height]) translate([0,0,(layer_height*number_of_solid_layers)/2]) cube([model_width,model_depth,layer_height*number_of_solid_layers], center=true); } Slic3r-version_1.31.6/utils/pdf-slices.pl000077500000000000000000000056011301441720000202310ustar00rootroot00000000000000#!/usr/bin/perl # This script exports model slices to a PDF file as solid fills, one per page use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Getopt::Long qw(:config no_auto_abbrev); use PDF::API2; use Slic3r; use Slic3r::Geometry qw(scale unscale X Y); use constant mm => 25.4 / 72; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'output|o=s' => \$opt{output_file}, 'layer-height|h=f' => \$opt{layer_height}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { # prepare config my $config = Slic3r::Config->new; $config->set('layer_height', $opt{layer_height}) if $opt{layer_height}; # read model my $model = Slic3r::Model->read_from_file(my $input_file = $ARGV[0]); # init print object my $sprint = Slic3r::Print::Simple->new( print_center => [0,0], ); $sprint->apply_config($config); $sprint->set_model($model); my $print = $sprint->_print; # compute sizes my $bb = $print->bounding_box; my $size = $bb->size; my $mediabox = [ map unscale($_)/mm, @{$size} ]; # init PDF my $pdf = PDF::API2->new(); my $color = $pdf->colorspace_separation('RDG_GLOSS', 'darkblue'); # slice and build output geometry $_->slice for @{$print->objects}; foreach my $object (@{ $print->objects }) { my $shift = $object->_shifted_copies->[0]; $shift->translate(map $_/2, @$size); foreach my $layer (@{ $object->layers }) { my $page = $pdf->page(); $page->mediabox(@$mediabox); my $content = $page->gfx; $content->fillcolor($color, 1); foreach my $expolygon (@{$layer->slices}) { $expolygon = $expolygon->clone; $expolygon->translate(@$shift); $content->poly(map { unscale($_->x)/mm, unscale($_->y)/mm } @{$expolygon->contour}); #) $content->close; foreach my $hole (@{$expolygon->holes}) { $content->poly(map { unscale($_->x)/mm, unscale($_->y)/mm } @$hole); #) $content->close; } $content->fill; # non-zero by default } } } # write output file my $output_file = $opt{output_file}; if (!defined $output_file) { $output_file = $input_file; $output_file =~ s/\.(?:stl)$/.pdf/i; } $pdf->saveas($output_file); printf "PDF file written to %s\n", $output_file; } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: pdf-slices.pl [ OPTIONS ] file.stl --help Output this usage screen and exit --output, -o Write to the specified file --layer-height, -h Use the specified layer height EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/post-processing/000077500000000000000000000000001301441720000207755ustar00rootroot00000000000000Slic3r-version_1.31.6/utils/post-processing/decimate.pl000077500000000000000000000015441301441720000231140ustar00rootroot00000000000000#!/usr/bin/perl -i~ use strict; use warnings; my %lastpos = (X => 10000, Y => 10000, Z => 10000, E => 10000, F => 10000); my %pos = (X => 0, Y => 0, Z => 0, E => 0, F => 0); my $mindist = 0.33; my $mindistz = 0.005; my $mindistsq = $mindist * $mindist; sub dist { my $sq = 0; for (qw/X Y Z E/) { $sq += ($pos{$_} - $lastpos{$_}) ** 2; } return $sq; } while (<>) { if (m#\bG[01]\b#) { while (m#([XYZEF])(\d+(\.\d+)?)#gi) { $pos{uc $1} = $2; } if ( ( /X/ && /Y/ && (dist() >= $mindistsq) ) || (abs($pos{Z} - $lastpos{Z}) > $mindistz) || (!/X/ || !/Y/) ) { print; %lastpos = %pos; } elsif (($pos{F} - $lastpos{F}) != 0) { printf "G1 F%s\n", $pos{F}; $lastpos{F} = $pos{F}; } } else { if (m#\bG92\b#) { while (m#([XYZEF])(\d+(\.\d+)?)#gi) { $lastpos{uc $1} = $2; } } print; } } Slic3r-version_1.31.6/utils/post-processing/fan_kickstart.py000066400000000000000000000005061301441720000241730ustar00rootroot00000000000000#!/usr/bin/python import sys import re sea = re.compile("M106 S[1-9]+[0-9]*") rep = re.compile("M106 S255\n\g<0>") out = open(sys.argv[1]+"_fixed", 'w') with open(sys.argv[1]) as f: for r in f: if re.search(sea, r) is not None: out.write(re.sub(sea,"M106 S255\n\g<0>",r)) else: out.write(r) Slic3r-version_1.31.6/utils/post-processing/filament-weight.pl000077500000000000000000000016231301441720000244230ustar00rootroot00000000000000#!/usr/bin/perl -i # # Post-processing script for adding weight and cost of required # filament to G-code output. use strict; use warnings; # example densities, adjust according to filament specifications use constant PLA_P => 1.25; # g/cm3 use constant ABS_P => 1.05; # g/cm3 # example costs, adjust according to filament prices use constant PLA_PRICE => 0.05; # EUR/g use constant ABS_PRICE => 0.02; # EUR/g use constant CURRENCY => "EUR"; while (<>) { if (/^(;\s+filament\s+used\s+=\s.*\((\d+(?:\.\d+)?)cm3)\)/) { my $pla_weight = $2 * PLA_P; my $abs_weight = $2 * ABS_P; my $pla_costs = $pla_weight * PLA_PRICE; my $abs_costs = $abs_weight * ABS_PRICE; printf "%s or %.2fg PLA/%.2fg ABS)\n", $1, $pla_weight, $abs_weight; printf "; costs = %s %.2f (PLA), %s %.2f (ABS)\n", CURRENCY, $pla_costs, CURRENCY, $abs_costs; } else { print; } } Slic3r-version_1.31.6/utils/post-processing/flowrate.pl000077500000000000000000000024761301441720000231710ustar00rootroot00000000000000#!/usr/bin/perl -i # # Post-processing script for calculating flow rate for each move use strict; use warnings; use constant PI => 3.141592653589793238; my @filament_diameter = split /,/, $ENV{SLIC3R_FILAMENT_DIAMETER}; my $E = 0; my $T = 0; my ($X, $Y, $F); while (<>) { if (/^G1.*? F([0-9.]+)/) { $F = $1; } if (/^G1 X([0-9.]+) Y([0-9.]+).*? E([0-9.]+)/) { my ($x, $y, $e) = ($1, $2, $3); my $e_length = $e - $E; if ($e_length > 0 && defined $X && defined $Y) { my $dist = sqrt( (($x-$X)**2) + (($y-$Y)**2) ); if ($dist > 0) { my $mm_per_mm = $e_length / $dist; # dE/dXY my $mm3_per_mm = ($filament_diameter[$T] ** 2) * PI/4 * $mm_per_mm; my $vol_speed = $F/60 * $mm3_per_mm; my $comment = sprintf ' ; dXY = %.3fmm ; dE = %.5fmm ; dE/XY = %.5fmm/mm; volspeed = %.5fmm^3/sec', $dist, $e_length, $mm_per_mm, $vol_speed; s/(\R+)/$comment$1/; } } $E = $e; $X = $x; $Y = $y; } if (/^G1 X([0-9.]+) Y([0-9.]+)/) { $X = $1; $Y = $2; } if (/^G1.*? E([0-9.]+)/) { $E = $1; } if (/^G92 E0/) { $E = 0; } if (/^T(\d+)/) { $T = $1; } print; } __END__ Slic3r-version_1.31.6/utils/post-processing/prowl-notification.pl000077500000000000000000000011501301441720000251610ustar00rootroot00000000000000#!/usr/bin/perl # # Example post-processing script for sending a Prowl notification upon # completion. See http://www.prowlapp.com/ for more info. use strict; use warnings; use File::Basename qw(basename); use WebService::Prowl; # set your Prowl API key here my $apikey = ''; my $file = basename $ARGV[0]; my $prowl = WebService::Prowl->new(apikey => $apikey); my %options = (application => 'Slic3r', event =>'Slicing Done!', description => "$file was successfully generated"); printf STDERR "Error sending Prowl notification: %s\n", $prowl->error unless $prowl->add(%options); Slic3r-version_1.31.6/utils/post-processing/z-every-line.pl000077500000000000000000000011151301441720000236610ustar00rootroot00000000000000#!/usr/bin/perl -i use strict; use warnings; my $z = 0; # read stdin and any/all files passed as parameters one line at a time while (<>) { # if we find a Z word, save it $z = $1 if /Z\s*(\d+(\.\d+)?)/; # if we don't have Z, but we do have X and Y if (!/Z/ && /X/ && /Y/ && $z > 0) { # chop off the end of the line (incl. comments), saving chopped section in $1 s/\s*([\r\n\;\(].*)/" Z$z $1"/es; # print start of line, insert our Z value then re-add the chopped end of line # print "$_ Z$z $1"; } #else { # nothing interesting, print line as-is print or die $!; #} } Slic3r-version_1.31.6/utils/send-gcode.pl000066400000000000000000000012341301441720000202030ustar00rootroot00000000000000#!/usr/bin/env perl use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Slic3r; die "Usage: send-gcode.pl SERIALPORT BAUDRATE GCODE_FILE\n" if @ARGV != 3; my $serial = Slic3r::GCode::Sender->new($ARGV[0], $ARGV[1]); 1 until $serial->is_connected; print "Connected to printer\n"; { local $/ = "\n"; Slic3r::open(\my $fh, '<', $ARGV[2]) or die "Unable to open $ARGV[2]: $!\n"; binmode $fh, ':utf8'; while (<$fh>) { $serial->send($_); } close $fh; } while ((my $queue_size = $serial->queue_size) > 0) { printf "Queue size: %d\n", $queue_size; } $serial->disconnect; __END__ Slic3r-version_1.31.6/utils/split_stl.pl000077500000000000000000000026701301441720000202200ustar00rootroot00000000000000#!/usr/bin/perl # This script splits a STL plate into individual files use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use File::Basename qw(basename); use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; $|++; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'ascii' => \$opt{ascii}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { my $model = Slic3r::Format::STL->read_file($ARGV[0]); my $basename = $ARGV[0]; $basename =~ s/\.stl$//i; my $part_count = 0; my $mesh = $model->objects->[0]->volumes->[0]->mesh; foreach my $new_mesh (@{$mesh->split}) { $new_mesh->repair; my $new_model = Slic3r::Model->new; $new_model ->add_object() ->add_volume(mesh => $new_mesh); $new_model->add_default_instances; my $output_file = sprintf '%s_%02d.stl', $basename, ++$part_count; printf "Writing to %s\n", basename($output_file); Slic3r::Format::STL->write_file($output_file, $new_model, binary => !$opt{ascii}); } } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: split_stl.pl [ OPTIONS ] file.stl --help Output this usage screen and exit --ascii Generate ASCII STL files (default: binary) EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/stl-to-amf.pl000077500000000000000000000034741301441720000201710ustar00rootroot00000000000000#!/usr/bin/perl # This script converts a STL file to AMF use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use File::Basename qw(basename); use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; $|++; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'distinct-materials' => \$opt{distinct_materials}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { my @models = map Slic3r::Format::STL->read_file($_), @ARGV; my $output_file = $ARGV[0]; $output_file =~ s/\.stl$/.amf.xml/i; my $new_model = Slic3r::Model->new; if ($opt{distinct_materials} && @models > 1) { my $new_object = $new_model->add_object; for my $m (0 .. $#models) { my $model = $models[$m]; $new_model->set_material($m, { Name => basename($ARGV[$m]) }); $new_object->add_volume( material_id => $m, facets => $model->objects->[0]->volumes->[0]->facets, vertices => $model->objects->[0]->vertices, ); } } else { foreach my $model (@models) { $new_model->add_object( vertices => $model->objects->[0]->vertices, )->add_volume( facets => $model->objects->[0]->volumes->[0]->facets, ); } } printf "Writing to %s\n", basename($output_file); Slic3r::Format::AMF->write_file($output_file, $new_model); } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: amf-to-stl.pl [ OPTIONS ] file.stl [ file2.stl [ file3.stl ] ] --help Output this usage screen and exit --distinct-materials Assign each STL file to a different material EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/view-mesh.pl000066400000000000000000000035251301441720000201040ustar00rootroot00000000000000#!/usr/bin/perl # This script displays 3D preview of a mesh use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; use Slic3r::GUI; use Slic3r::GUI::3DScene; $|++; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'cut=f' => \$opt{cut}, 'enable-moving' => \$opt{enable_moving}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { my $model = Slic3r::Model->read_from_file($ARGV[0]); # make sure all objects have at least one defined instance $model->add_default_instances; $_->center_around_origin for @{$model->objects}; # and align to Z = 0 my $app = Slic3r::ViewMesh->new; $app->{canvas}->enable_picking(1); $app->{canvas}->enable_moving($opt{enable_moving}); $app->{canvas}->load_object($model, 0); $app->{canvas}->set_auto_bed_shape; $app->{canvas}->zoom_to_volumes; $app->{canvas}->SetCuttingPlane($opt{cut}) if defined $opt{cut}; $app->MainLoop; } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: view-mesh.pl [ OPTIONS ] file.stl --help Output this usage screen and exit --cut Z Display the cutting plane at the given Z EOF exit ($exit_code || 0); } package Slic3r::ViewMesh; use Wx qw(:sizer); use base qw(Wx::App); sub OnInit { my $self = shift; my $frame = Wx::Frame->new(undef, -1, 'Mesh Viewer', [-1, -1], [500, 400]); my $panel = Wx::Panel->new($frame, -1); $self->{canvas} = Slic3r::GUI::3DScene->new($panel); my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($self->{canvas}, 1, wxEXPAND, 0); $panel->SetSizer($sizer); $sizer->SetSizeHints($panel); $frame->Show(1); } __END__ Slic3r-version_1.31.6/utils/view-toolpaths.pl000077500000000000000000000046361301441720000211740ustar00rootroot00000000000000#!/usr/bin/perl # This script displays 3D preview of a mesh use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; use Slic3r::GUI; use Slic3r::GUI::3DScene; $|++; my %opt = (); { my %options = ( 'help' => sub { usage() }, 'load=s' => \$opt{load}, '3D' => \$opt{d3}, 'duplicate=i' => \$opt{duplicate}, ); GetOptions(%options) or usage(1); $ARGV[0] or usage(1); } { # load model my $model = Slic3r::Model->read_from_file($ARGV[0]); # load config my $config = Slic3r::Config->new_from_defaults; if ($opt{load}) { $config->apply(Slic3r::Config->load($opt{load})); } # init print my $sprint = Slic3r::Print::Simple->new; $sprint->duplicate($opt{duplicate} // 1); $sprint->apply_config($config); $sprint->set_model($model); $sprint->process; # visualize toolpaths $Slic3r::ViewToolpaths::print = $sprint->_print; $Slic3r::ViewToolpaths::d3 = $opt{d3}; my $app = Slic3r::ViewToolpaths->new; $app->MainLoop; } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: view-toolpaths.pl [ OPTIONS ] file.stl --help Output this usage screen and exit --load CONFIG Loads the supplied config file EOF exit ($exit_code || 0); } package Slic3r::ViewToolpaths; use Wx qw(:sizer); use base qw(Wx::App Class::Accessor); our $print; our $d3; sub OnInit { my $self = shift; my $frame = Wx::Frame->new(undef, -1, 'Toolpaths', [-1, -1], [500, 500]); my $panel = Wx::Panel->new($frame, -1); my $canvas; if ($d3) { $canvas = Slic3r::GUI::3DScene->new($panel); $canvas->set_bed_shape($print->config->bed_shape); $canvas->load_print_toolpaths($print); foreach my $object (@{$print->objects}) { #$canvas->load_print_object_slices($object); $canvas->load_print_object_toolpaths($object); #$canvas->load_object($object->model_object); } $canvas->zoom_to_volumes; } else { $canvas = Slic3r::GUI::Plater::2DToolpaths->new($panel, $print); } my $sizer = Wx::BoxSizer->new(wxVERTICAL); $sizer->Add($canvas, 1, wxEXPAND, 0); $panel->SetSizer($sizer); $frame->Show(1); } __END__ Slic3r-version_1.31.6/utils/wireframe.pl000066400000000000000000000140461301441720000201610ustar00rootroot00000000000000#!/usr/bin/perl # This script exports experimental G-code for wireframe printing # (inspired by the brilliant WirePrint concept) use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../lib"; } use Getopt::Long qw(:config no_auto_abbrev); use Slic3r; use Slic3r::ExtrusionPath ':roles'; use Slic3r::Geometry qw(scale unscale X Y PI); my %opt = ( step_height => 5, nozzle_angle => 30, nozzle_width => 10, first_layer_height => 0.3, ); { my %options = ( 'help' => sub { usage() }, 'output|o=s' => \$opt{output_file}, 'step-height|h=f' => \$opt{step_height}, 'nozzle-angle|a=f' => \$opt{nozzle_angle}, 'nozzle-width|w=f' => \$opt{nozzle_width}, 'first-layer-height=f' => \$opt{first_layer_height}, ); GetOptions(%options) or usage(1); $opt{output_file} or usage(1); $ARGV[0] or usage(1); } { # load model my $model = Slic3r::Model->read_from_file($ARGV[0]); $model->add_default_instances; $model->center_instances_around_point(Slic3r::Pointf->new(100,100)); my $mesh = $model->mesh; $mesh->translate(0, 0, -$mesh->bounding_box->z_min); # get slices my @z = (); my $z_max = $mesh->bounding_box->z_max; for (my $z = $opt{first_layer_height}; $z <= $z_max; $z += $opt{step_height}) { push @z, $z; } my @slices = @{$mesh->slice(\@z)}; my $flow = Slic3r::Flow->new( width => 0.35, height => 0.35, nozzle_diameter => 0.35, bridge => 1, ); my $config = Slic3r::Config::Print->new; $config->set('gcode_comments', 1); open my $fh, '>', $opt{output_file}; my $gcodegen = Slic3r::GCode->new( enable_loop_clipping => 0, # better bonding ); $gcodegen->apply_print_config($config); $gcodegen->set_extruders([0]); print $fh $gcodegen->set_extruder(0); print $fh $gcodegen->writer->preamble; my $e = $gcodegen->writer->extruder->e_per_mm3 * $flow->mm3_per_mm; foreach my $layer_id (0..$#z) { my $z = $z[$layer_id]; foreach my $island (@{$slices[$layer_id]}) { foreach my $polygon (@$island) { if ($layer_id > 0) { # find the lower polygon that we want to connect to this one my $lower = $slices[$layer_id-1]->[0]->contour; # 't was easy, wasn't it? my $lower_z = $z[$layer_id-1]; { my @points = (); # keep all points with strong angles { my @pp = @$polygon; foreach my $i (0..$#pp) { push @points, $pp[$i-1] if abs($pp[$i-1]->ccw_angle($pp[$i-2], $pp[$i]) - PI) > PI/3; } } $polygon = Slic3r::Polygon->new(@points); } #$polygon = Slic3r::Polygon->new(@{$polygon->split_at_first_point->equally_spaced_points(scale $opt{nozzle_width})}); # find vertical lines my @vertical = (); foreach my $point (@{$polygon}) { push @vertical, Slic3r::Line->new($point->projection_onto_polygon($lower), $point); } next if !@vertical; my @points = (); foreach my $line (@vertical) { push @points, Slic3r::Pointf3->new( unscale($line->a->x), unscale($line->a->y), #)) $lower_z, ); push @points, Slic3r::Pointf3->new( unscale($line->b->x), unscale($line->b->y), #)) $z, ); } # reappend first point as destination of the last diagonal segment push @points, Slic3r::Pointf3->new( unscale($vertical[0]->a->x), unscale($vertical[0]->a->y), #)) $lower_z, ); # move to the position of the first vertical line print $fh $gcodegen->writer->travel_to_xyz(shift @points); # extrude segments foreach my $point (@points) { print $fh $gcodegen->writer->extrude_to_xyz($point, $e * $gcodegen->writer->get_position->distance_to($point)); } } } print $fh $gcodegen->writer->travel_to_z($z); foreach my $polygon (@$island) { #my $polyline = $polygon->split_at_vertex(Slic3r::Point->new_scale(@{$gcodegen->writer->get_position}[0,1])); my $polyline = $polygon->split_at_first_point; print $fh $gcodegen->writer->travel_to_xy(Slic3r::Pointf->new_unscale(@{ $polyline->first_point }), "move to first contour point"); foreach my $line (@{$polyline->lines}) { my $point = Slic3r::Pointf->new_unscale(@{ $line->b }); print $fh $gcodegen->writer->extrude_to_xy($point, $e * unscale($line->length)); } } } } close $fh; } sub usage { my ($exit_code) = @_; print <<"EOF"; Usage: wireframe.pl [ OPTIONS ] file.stl --help Output this usage screen and exit --output, -o Write to the specified file --step-height, -h Use the specified step height --nozzle-angle, -a Max nozzle angle --nozzle-width, -w External nozzle diameter EOF exit ($exit_code || 0); } __END__ Slic3r-version_1.31.6/utils/zsh/000077500000000000000000000000001301441720000164425ustar00rootroot00000000000000Slic3r-version_1.31.6/utils/zsh/README.markdown000066400000000000000000000012541301441720000211450ustar00rootroot00000000000000# ZSH Completions for Slic3r To enable zsh(1) completions for Slic3r, add the following to your ``~/.zshrc`` file, replacing ``/path/to/Slic3r/`` with the actual path to your Slic3r directory: typeset -U fpath if [[ -d /path/to/Slic3r/utils/zsh/functions ]]; then fpath=(/path/to/Slic3r/utils/zsh/functions $fpath) fi autoload -Uz compinit compinit zstyle ':completion:*' verbose true zstyle ':completion:*:descriptions' format '%B%d%b' zstyle ':completion:*:messages' format '%d' zstyle ':completion:*:warnings' format 'No matches for %d' zstyle ':completion:*' group-name '%d' See the zshcompsys(1) man page for further details. Slic3r-version_1.31.6/utils/zsh/functions/000077500000000000000000000000001301441720000204525ustar00rootroot00000000000000Slic3r-version_1.31.6/utils/zsh/functions/_slic3r000066400000000000000000000232551301441720000217420ustar00rootroot00000000000000#compdef -P slic3r(|.pl|.exe) # # Slic3r completions configuration for zsh(1). # Currently undocumented options: # --debug, --gui, --ignore-nonexistent-config # --acceleration, --perimeter-acceleration, --infill-acceleration _arguments -S \ '(- *)--help[output usage screen and exit]' \ '(- *)--version[output the version of Slic3r and exit]' \ '--save[save configuration to file]:config output file:_files -g "*.(#i)ini(-.)"' \ '*--load[load configuration from file]:config input file:_files -g "*.(#i)ini(-.)"' \ '(--output -o)'{--output,-o}'[specify output file]:output file:_files -g "*.(#i)(gcode|svg)(-.)"' \ '(--threads -j)'{--threads,-j}'[specify number of threads to use]:number of threads' \ \ '--output-filename-format[specify output filename format]:output filename format' \ '*--post-process[specify post-processing script]:post-processing script file:_files' \ '--export-svg[export SVG containing slices instead of G-code]' \ '(--merge -m)'{--merge,-m}'[merge multiple input files into a single print]' \ \ '*--nozzle-diameter[specify nozzle diameter]:nozzle diameter in mm' \ '--print-center[specify print center coordinates]:print center coordinates in mm,mm' \ '--z-offset[specify Z-axis offset]:Z-axis offset in mm' \ '--gcode-flavor[specify the type of G-code to generate]:G-code flavor:(reprap teacup makerware sailfish mach3 machinekit no-extrusion)' \ '(--use-relative-e-distances --no-use-relative-e-distances)'--{no-,}use-relative-e-distances'[disable/enable relative E values]' \ '--extrusion-axis[specify letter associated with the extrusion axis]:extrusion axis letter' \ '(--gcode-arcs --no-gcode-arcs)'--{no-,}gcode-arcs'[disable/enable G2/G3 commands for native arcs]' \ '(--gcode-comments --no-gcode-comments)'--{no-,}gcode-comments'[disable/enable verbose G-code comments]' \ \ '*--filament-diameter[specify raw filament diameter]:raw filament diameter in mm' \ '*--extrusion-multiplier[specify multiplier for amount of plastic extruded]:extrusion multiplier' \ '*--temperature[specify extrusion temperature]:extrusion temperature in Celsius' \ '*--first-layer-temperature[specify extrusion temperature for the first layer]:first layer extrusion temperature in Celsius' \ '--bed-temperature[specify heated bed temperature]:heated bed temperature in Celsius' \ '--first-layer-bed-temperature[specify heated bed temperature for the first layer]:first layer heated bed temperature in Celsius' \ \ '--perimeter-extruder[specify extruder to use for printing perimeters]:extruder number' \ '--infill-extruder[specify extruder to use for printing infill]:extruder number' \ '--support-material-extruder[specify extruder to use for printing support material]:extruder number' \ \ '--travel-speed[specify speed of non-print moves]:speed of non-print moves in mm/s' \ '--perimeter-speed[specify speed of print moves for perimeters]:speed of print moves for perimeters in mm/s' \ '--external-perimeter-speed[specify speed of print moves for external perimeters]:speed of print moves for external perimeters in mm/s or % of --perimeter-speed' \ '--small-perimeter-speed[specify speed of print moves for small perimeters]:speed of print moves for small perimeters in mm/s or % of --perimeter-speed' \ '--infill-speed[specify speed of infill print moves]:speed of infill print moves in mm/s' \ '--solid-infill-speed[specify speed of solid surface print moves]:speed of solid surface print moves in mm/s or % of --infill-speed' \ '--top-solid-infill-speed[specify speed of top surface print moves]:speed of top surface print moves in mm/s or % of --solid-infill-speed' \ '--bridge-speed[specify speed of bridge print moves]:speed of bridge print moves in mm/s' \ '--first-layer-speed[specify speed of bottom layer print moves]:speed of bottom layer print moves in mm/s or % of normal speeds' \ \ '--layer-height[specify layer height]:layer height in mm' \ '--first-layer-height[specify layer height for bottom layer]:layer height for bottom layer in mm or % of --layer-height' \ '--infill-every-layers[specify infill for every N layers]:N layers' \ \ '--perimeters[specify number of perimeters]:number of perimeters' \ '--solid-layers[specify number of solid layers to do for top/bottom surfaces]:number of layers for top/bottom surfaces' \ '--fill-density[specify infill density]:infill density in percent' \ '--fill-angle[specify infill angle]:infill angle in degrees' \ '--fill-pattern[specify pattern used for infill]:infill pattern:(rectilinear line concentric honeycomb hilbertcurve archimedeanchords octagramspiral)' \ '--solid-fill-pattern[specify pattern used for solid layers]:solid fill pattern:(rectilinear concentric hilbertcurve archimedeanchords octagramspiral)' \ '--start-gcode[load initial G-code from file]:start G-code file:_files -g "*.(#i)(gcode)(-.)"' \ '--end-gcode[load final G-code from file]:end G-code file:_files -g "*.(#i)(gcode)(-.)"' \ '--layer-gcode[load layer-change G-code from file]:layer-change G-code file:_files -g "*.(#i)(gcode)(-.)"' \ '(--support-material --no-support-material)'--{no-,}support-material'[disable/enable generation of support material for overhangs]' \ '--support-material-threshold[specify support material threshold]:maximum slope angle for generating support material' \ '--support-material-pattern[specify pattern used for support material]:support material pattern:(rectilinear honeycomb)' \ '--support-material-spacing[specify spacing between support material lines]:spacing between support material lines in mm' \ '--support-material-angle[specify support material angle]:support material angle in degrees' \ '(--randomize-start --no-randomize-start)'--{no-,}randomize-start'[disable/enable randomization of starting point across layers]' \ '(--extra-perimeters --no-extra-perimeters)'--{no-,}extra-perimeters'[disable/enable generation of extra perimeters when needed]' \ \ '--retract-length[specify filament retraction length when pausing extrusion]:filament retraction length in mm' \ '--retract-speed[specify filament retraction speed]:filament retraction speed in mm/s' \ '--retract-restart-extra[specify filament length to extrude for compensating retraction]: filament lenght in mm' \ '--retract-before-travel[specify minimum travel length for activating retraction]:minimum travel length for activating retraction in mm' \ '--retract-lift[specify Z-axis lift for use when retracting]:Z-axis lift in mm' \ \ '(--cooling --no-cooling)'--{no-,}cooling'[disable/enable fan and cooling control]' \ '--min-fan-speed[specify minimum fan speed]:minimum fan speed in percent' \ '--max-fan-speed[specify maximum fan speed]:maximum fan speed in percent' \ '--bridge-fan-speed[specify fan speed to use for bridging]:bridging fan speed in percent' \ '--fan-below-layer-time[specify maximum layer print time before activating fan]:maximum layer print time in seconds' \ '--slowdown-below-layer-time[specify maximum layer print time before slowing down printing]:maximum layer print time in seconds' \ '--min-print-speed[specify minimum print speed]:minimum print speed in mm/s' \ '--disable-fan-first-layers[specify number of bottom layers to print before activating fan]:number of bottom layers' \ '(--fan-always-on --no-fan-always-on)'--{no-,}fan-always-on'[disable/enable deactivation of fan]' \ \ '--skirts[specify number of skirts]:number of skirts' \ '--skirt-distance[specify distance between innermost skirt and object]:distance between innermost skirt and object in mm' \ '--skirt-height[specify number of skirt layers]:number of skirt layers' \ '--brim-width[specify brim width]:width of brim in mm' \ \ '--scale[specify object scaling factor]:object scaling factor in percent' \ '--rotate[specify object rotation angle]:object rotation angle in degrees' \ '(--duplicate-grid)--duplicate[specify number of duplicates for auto-arrange]:number of duplicates for auto-arrange' \ '(--duplicate-grid)--bed-size[specify bed size for auto-arrange]:bed size for auto-arrange in mm,mm' \ '(--duplicate --bed-size)--duplicate-grid[specify number of duplicates for grid arrangement]:number of duplicates for grid arrangement as x,y' \ '--duplicate-distance[specify distance between duplicates]:distance between duplicates in mm' \ \ '(--complete-objects --no-complete-objects)'--{no-,}complete-objects'[disable/enable completion of each object before starting a new one]' \ '--extruder-clearance-radius[specify radius above which extruder will not collide with anything]:radius in mm' \ '--extruder-clearance-height[specify maximum vertical extruder depth]:maximum vertical extruder depth in mm' \ \ '--notes[specify notes to be added as comments to the output file]:notes' \ \ '--extrusion-width[specify extrusion width]:extrusion width in mm or % of --layer-height' \ '--first-layer-extrusion-width[specify extrusion width for first layer]:first layer extrusion width in mm or % og --layer-height' \ '--perimeters-extrusion-width[specify extrusion width for perimeters]:perimeter extrusion width in mm or % of --layer-height' \ '--infill-extrusion-width[specify extrusion width for infill]:infill extrusion width in mm or % of --layer-height' \ '--support-material-extrusion-width[specify extrusion width for support material]:support material extrusion width in mm or % of --layer-height' \ '--bridge-flow-ratio[specify multiplier for extrusion when bridging]:bridge extrusion multiplier' \ \ '*:input file:_files -g "*.(#i)(stl|obj|amf|xml)(-.)"' # Local Variables: *** # mode:sh *** # End: *** Slic3r-version_1.31.6/var/000077500000000000000000000000001301441720000152665ustar00rootroot00000000000000Slic3r-version_1.31.6/var/Slic3r-console.ico000066400000000000000000000422061301441720000205650ustar00rootroot0000000000000000 ¨%F  ¨î% ˆ –6 h@(0`  "'+/35799999753/,'" 6IXclsx}€‚„…‡ˆˆˆˆˆˆˆ‡…„‚€}yslcXJ6¢ÿCu…ŒŒŒŒ‘3r°V¿Ôhçínõ÷nõ÷nõ÷nõ÷nõ÷nõ÷nóöcÜåL¨È%Q£ŒŒŒŒŒŒŒŒŒŒŒ†vF ¢ÿ #4CO'bQ²«kíésÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsþþdÝà;‚§yvsnibYPD5#¢ÿ ¢ÿvùYsý×sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿnôÂRµG ¢ÿ¢ÿŽÿ}ÿ«sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿósÿh¢ÿ¢ÿ¢ÿ¢ÿ€ÿ«sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿˆ¢ÿ¢ÿ¢ÿ¢ÿŽÿ7{ÿäsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿŽ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‘ÿ,{ÿåtÿÿvÿÿzÿÿ}ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿÿÿ{ÿÿ wÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿs¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿ,„ÿçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ{ÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿøuÿ:¢ÿ¢ÿ¢ÿ¢ÿœÿ3(Žÿì1ÿÿ0ÿÿ0ÿÿ0ÿÿ0ÿÿ0ÿÿ/Œÿÿ*‰ÿÿ$†ÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿ{ÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÐ~ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ÿšÿ9,ÿî2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿÿ'‡ÿÿƒÿÿÿÿÿÿÿÿÿÿ€ÿÿ wÿÿsÿÿsÿÿsÿÿsÿÿtÿh¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ÿšÿ—ÿM+ÿñ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ+Šÿÿ!„ÿÿÿÿÿÿÿÿÿÿzÿÿsÿÿsÿÿsÿÿsÿÝ€ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ  ÿ šÿ˜ÿ–ÿ6 ”ÿ~)ÿö2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿÿƒÿÿÿÿÿÿÿÿ{ÿÿsÿÿsÿÿsÿÿuÿT¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿœÿ šÿ—ÿ-•ÿP–ÿ¦“ÿß)Žÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ'‡ÿÿÿÿÿÿÿÿ{ÿÿsÿÿsÿÿtÿ¦¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ™ÿ’ÿ’ÿ$’ÿBtÀ¤ÿg²íŠÿë)Œÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿƒÿÿÿÿÿÿ xÿÿsÿÿsÿã¢ÿ¢ÿ¢ÿ¢ÿ¢ÿšÿÿ †ÿ ˆÿ@ávýÿÿd´ïŠÿé)ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ „ÿÿÿÿ€ÿÿuÿÿsÿþ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ…ÿ‚ÿÿ@€ýl '>áÿÿÿ"""ÿv½íœÿç)‘ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ „ÿÿÿÿ|ÿÿsÿÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿ~ÿzÿ2zÿh O‘­ÿ$$$ÿ'''ÿ***ÿ---ÿ000ÿŒÂëµÿç+”ÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ‚ÿÿÿÿvÿÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿzÿ"xÿSoæ„&*0ô'''ÿ'''ÿ(((ÿ+++ÿ///ÿ111ÿ555ÿ¡ÆîÄÿí+•ÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Šÿÿÿÿ|ÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ|ÿwÿ6wÿtBsª'''ÿ'''ÿ'''ÿ***ÿ---ÿ000ÿ444ÿEEEÿNNNÿ(²ÏóÇÿî2—ÿû<“ÿÿ6ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ%†ÿÿ€ÿÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿxÿwÿJwþy *2Ý'''ÿ'''ÿ(((ÿ+++ÿ...ÿ222ÿDDDÿMMMÿRRRÿUUUÿ)²Ñï ¿ÿå<šÿúGšÿÿD˜ÿÿ<”ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿ€ÿÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ€ÿwÿ%vÿ\bÌ„''(ú'''ÿ'''ÿ(((ÿ+++ÿ///ÿAAAÿKKKÿOOOÿSSSÿWWWÿ\\\ÿ,¬Ôä µÿÛ=šÿúGšÿÿGšÿÿF™ÿÿ=”ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ!„ÿÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ|ÿ vÿ-vÿkH‡›'''ÿ'''ÿ'''ÿ)))ÿ,,,ÿ888ÿHHHÿLLLÿPPPÿTTTÿYYYÿ\\\ÿaaaÿ.§ÕÛ ¯ÿ×<™ÿúGšÿÿGšÿÿGšÿÿC—ÿÿ6ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿø¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿzÿvÿ4uÿt8Z²'''ÿ'''ÿ'''ÿ)))ÿ...ÿCCCÿIIIÿLLLÿQQQÿUUUÿZZZÿ]]]ÿcccÿfffÿ,«ÙÝ µÿß>›ÿûGšÿÿGšÿÿGšÿÿE™ÿÿ7‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Žÿ×¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿyÿuÿ:uÿw0EÂ'''ÿ'''ÿ'''ÿ)))ÿ777ÿEEEÿIIIÿMMMÿQQQÿUUUÿZZZÿ^^^ÿcccÿfffÿkkkÿ+µÜæ ¾ÿê>œÿüGšÿÿGšÿÿGšÿÿD˜ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Žÿ•¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿxÿuÿ<uÿw+:Ì'''ÿ'''ÿ'''ÿ***ÿ???ÿEEEÿIIIÿLLLÿQQQÿUUUÿZZZÿ]]]ÿcccÿfffÿkkkÿnnnÿ*¾ßï Âÿð>œÿüGšÿÿGšÿÿGšÿÿ@–ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿú‘ÿB ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿvÿuÿ<uÿw+;Ë'''ÿ'''ÿ'''ÿ///ÿBBBÿEEEÿHHHÿLLLÿPPPÿTTTÿYYYÿ\\\ÿaaaÿeeeÿiiiÿmmmÿoooÿ)Ááñ¾ÿí>šÿüGšÿÿGšÿÿF™ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.Žÿ½™ÿÿ¡ÿ¢ÿ¢ÿ¢ÿvÿuÿ9uÿv/DÀ'''ÿ'''ÿ'''ÿ222ÿAAAÿDDDÿGGGÿKKKÿOOOÿSSSÿWWWÿ\\\ÿ___ÿeeeÿkkkÿsssÿxxxÿ{{{ÿ3¼äì¯ÿèAšÿüGšÿÿE™ÿÿ2Žÿÿ2Žÿÿ2ŽÿúÿQ”ÿšÿ ÿ¢ÿ¢ÿ¢ÿsÿ uÿ3tÿs6Z®'''ÿ'''ÿ'''ÿ666ÿAAAÿCCCÿFFFÿJJJÿMMMÿRRRÿUUUÿ]]]ÿfffÿpppÿuuuÿvvvÿxxxÿzzzÿzz{ÿ2ªäé—ÿéA˜ÿýGšÿÿ2Žÿÿ2Žÿÿ%Œÿ©ˆÿ)ÿ—ÿ žÿ¢ÿ¢ÿ¢ÿsÿuÿ,tÿfI‰•'''ÿ'''ÿ'''ÿ777ÿ@@@ÿBBBÿEEEÿHHHÿLLLÿPPPÿ]]]ÿgggÿlllÿnnnÿqqqÿtttÿuuuÿvvvÿvvvÿuvwÿ/”ãìˆÿî?–ÿý2Žÿÿ'Œÿã€ÿE…ÿ'ÿ”ÿ ›ÿ¢ÿ¢ÿsÿtÿ"tÿXdÑ'''ù'''ÿ'''ÿ888ÿ>>>ÿAAAÿDDDÿFFFÿLLLÿ\\\ÿcccÿeeeÿhhhÿlllÿmmmÿoooÿqqqÿsssÿsssÿsssÿprsÿ-Œæì‡ÿê$‹ÿì €ÿuÿ=„ÿ"‹ÿ’ÿ›ÿ¢ÿ¢ÿsÿsÿtÿGtþu!'0Ø'''ÿ'''ÿ666ÿ===ÿ@@@ÿBBBÿGGGÿXXXÿ]]]ÿ```ÿcccÿeeeÿhhhÿkkkÿmmmÿmmmÿnnnÿnnnÿnnnÿmmmÿlmnþ-ŽäÝ€ÿ„{ÿMÿ0…ÿŒÿ’ÿŸÿ¢ÿsÿ sÿ2tÿr;k¢'''ÿ'''ÿ222ÿ===ÿ>>>ÿAAAÿRRRÿXXXÿ\\\ÿ]]]ÿ```ÿcccÿeeeÿfffÿhhhÿjjjÿkkkÿkkkÿkkkÿjjjÿhhhÿfhjý:ØŸ}ÿ7ÿ!†ÿÿ “ÿ ÿ¢ÿ¢ÿsÿsÿ tÿUiá{%&'ó'''ÿ...ÿ===ÿ===ÿEEEÿUUUÿVVVÿYYYÿ\\\ÿ]]]ÿ___ÿaaaÿdddÿeeeÿeeeÿfffÿfffÿfffÿeeeÿeeeÿdddÿ`cdýG˜Ñ€ƒÿˆÿ •ÿ›ÿ¢ÿ¢ÿ¢ÿ ¢ÿsÿsÿsÿ8sÿu6Y¯'''ÿ)))ÿ<<<ÿ===ÿJJJÿSSSÿUUUÿVVVÿXXXÿ[[[ÿ\\\ÿ^^^ÿ___ÿaaaÿbbbÿcccÿcccÿcccÿbbbÿaaaÿ___ÿ^^^ÿ\^_üN›ÊrŒÿ—ÿ ÿ¢ÿ¢ÿ¢ÿsÿsÿ"sÿTkèz#%'é'''ÿ555ÿ===ÿNNNÿRRRÿSSSÿUUUÿVVVÿXXXÿYYYÿ[[[ÿ\\\ÿ]]]ÿ^^^ÿ^^^ÿ___ÿ^^^ÿ^^^ÿ]]]ÿ\\\ÿ[[[ÿYYYÿW[\ûKšÉmžÿ¢ÿ¢ÿsÿsÿsÿ4sÿlI'''þ+++ÿ===ÿOOOÿQQQÿQQQÿSSSÿTTTÿUUUÿWWWÿXXXÿYYYÿZZZÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ[[[ÿZZZÿYYYÿXXXÿWWWÿUUUÿZ[]ûV¢Îj¢ÿ¢ÿsÿsÿsÿBsÿt2S¯'''ÿ333ÿJJJÿQQQÿQQQÿQQQÿRRRÿSSSÿTTTÿUUUÿVVVÿWWWÿXXXÿXXXÿXXXÿXXXÿXXXÿWWWÿVVVÿUUUÿTTTÿVVVÿ[[[ÿ\_aúX Ïjsÿ sÿ¢ÿsÿsÿ sÿ"sÿMsÿt,@À(((ÿAAAÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿSSSÿTTTÿTTTÿUUUÿUUUÿUUUÿUUUÿUUUÿTTTÿTTTÿSSSÿUUUÿZZZÿZZZÿZZZÿ@DFöx¾]sÿsÿsÿsÿ sÿ)sÿVrüu,A¼,,,ÿKKKÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿRRRÿSSSÿSSSÿSSSÿSSSÿSSSÿRRRÿRRRÿTTTÿZZZÿZZZÿZZZÿEEEÿ'''ÿ'7C܃ÿ(ÿsÿsÿsÿ+sÿTsÿt8a§///úLLLÿRRRÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿVVVÿZZZÿZZZÿZZZÿCCCÿ'''ÿ#:TÓ{ëk‚ÿ2†ÿsÿsÿsÿsÿ(sÿJsÿt P¦‰%*1ÚGGGÿTTTÿRRRÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿUUUÿYYYÿZZZÿZZZÿVVVÿ;;;ÿ''(ú>k¬pövtÿHvÿxÿsÿsÿsÿ sÿsÿ?sÿgpùu?wœ47<áMMMÿVVVÿUUUÿTTTÿTTTÿTTTÿUUUÿWWWÿYYYÿZZZÿZZZÿVVVÿCCCÿ--.ú*:É U¯†sÿqsÿIsÿ&sÿsÿsÿsÿ sÿsÿ0sÿNsÿorüuOžŒ,=S¿@BFæMMMùSSSÿVVVÿWWWÿUUUÿRRRÿHHHÿ999ó)/6Ø4X« [¿‚sÿtsÿZsÿ8sÿsÿ sÿsÿsÿsÿsÿsÿ2sÿJsÿcsÿthãz R§Š?vœ5Zª1N³2P±6_§D— W·„oówsÿtsÿZsÿ>sÿ&sÿsÿsÿsÿsÿsÿ sÿsÿ*sÿ;sÿMsÿ]sÿhsÿosÿssÿssÿnsÿesÿYsÿIsÿ6sÿ$sÿsÿ sÿsÿsÿsÿsÿ sÿsÿsÿ$sÿ,sÿ1sÿ3sÿ2sÿ0sÿ*sÿ"sÿsÿsÿsÿsÿÿÿø?x?x?€ÿ~ÿÿx?ÿyÿ±€ÿÃÀÿçàÿü€ÿüÿüü?þ?þüüüüøüøüüüüüüü?ü?üþ?þþÿÏÿÏÿ€oÿ€?ÿÀ?ÿà?ÿà?ÿð?ÿüÿþÿÿÿ€ÿÿÿàÿ( @ ¢ÿ <[iry}€ƒ„…………„ƒ€}ysi[> ¢ÿ¢ÿ >[g&y/h•S¸ÃkììsÿÿsÿÿsÿÿsÿÿlïïU¼Ê2n¢'Š}zvpg[@¢ÿ ¢ÿ9XyÚqáRqö³sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿmòÅTº_9% ¢ÿ¢ÿ¢ÿ„ÿuÿøsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿüsÿxsÿ ¢ÿ¢ÿ¢ÿ~ÿuÿ÷sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ‰sÿ ¢ÿ¢ÿ€ÿqyÿôzÿÿ|ÿÿÿÿÿÿ€ÿÿÿÿ}ÿÿ{ÿÿ xÿÿvÿÿtÿÿsÿÿsÿÿsÿÿsÿlsÿ.–ÿ{0ÿö.‹ÿÿ,Šÿÿ)‰ÿÿ&‡ÿÿ"…ÿÿƒÿÿ‚ÿÿÿÿ€ÿÿ{ÿÿvÿÿsÿÿsÿÿsÿïuÿ4Šÿ¢ÿ¢ÿ¢ÿMºÿ 2šÿ‰3‘ÿ÷2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ)‰ÿÿ#…ÿÿƒÿÿÿÿÿÿ xÿÿtÿÿsÿÿtÿzÿ¢ÿ¢ÿ¢ÿ›ÿ –ÿ–ÿ4"—ÿÆ0ÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿ%†ÿÿ‚ÿÿÿÿ zÿÿtÿÿsÿôwÿ.¢ÿsÿzÿ}ÿ#‡ÿ?•ÿ‰•ÿÙ‘ÿó0ÿý2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿÿ!„ÿÿÿÿ yÿÿsÿÿuÿd¢ÿ¢ÿsÿsÿvÿ-yÿZ~÷….QãÿWò‘ýñ0ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ#…ÿÿÿÿvÿÿtÿš¢ÿ¢ÿsÿvÿ"vÿ[vú§ T£Ì ÿÿÿr¦ï¨ýï0“ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ"…ÿÿ}ÿÿvÿ¹¢ÿ¢ÿ¢ÿsÿ uÿ5uÿ‚cË´!+òÿÿ$$$ÿ000ÿ0™²ò+¼ýô7˜ÿü:’ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿƒÿÿ yÿâÿ ¢ÿ¢ÿsÿuÿFuÿ B|Âÿÿÿ'''ÿ999ÿJJKÿ4£¸ô+¸þï?šÿû>•ÿÿ7‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿ€ÿ¼¢ÿ ¢ÿ¢ÿsÿuÿRuÿ­+DÖÿÿ!!!ÿ111ÿDDDÿLLLÿTUUÿ<œ»é1°þåGÿûD˜ÿÿ<”ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ…ÿŸ¢ÿ ¢ÿ¢ÿsÿuÿZuÿ­",èÿÿ'''ÿ<<<ÿEEEÿMMMÿUUUÿ\__þ@˜ºã-´þèEÿüGšÿÿ@–ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ‰ÿk¢ÿ ¢ÿ¢ÿsÿtÿ^uÿ­ õÿÿ///ÿ===ÿDDDÿLLLÿTTTÿ\\\ÿdeeþ?¥Àí-¾þôEÿýGšÿÿ=”ÿÿ2Žÿÿ2Žÿÿ3ÿñÿ:¢ÿ ¢ÿ¢ÿsÿtÿatÿ­÷ÿÿ222ÿ<<<ÿBBBÿJJJÿRRRÿZZZÿaaaÿeijþ>¬Áô+ºþôGœÿýF™ÿÿ2Žÿÿ2Žÿÿ1’ÿ¦ “ÿ¡ÿ¢ÿ¢ÿsÿtÿ`tÿ¬"ìÿÿ555ÿ:::ÿ@@@ÿGGGÿPPPÿ]]]ÿiiiÿpppÿqvvþO¥Åï1§þðG›ÿý2Žÿÿ2ÿíÿS•ÿŸÿ¢ÿ¢ÿsÿsÿYtÿ¬".Úÿÿ333ÿ888ÿ===ÿEEEÿUUUÿ```ÿfffÿkkkÿmmmÿlprýHŽÁï3–ÿõ4‘ÿø$ŒÿŸ…ÿ*ÿ›ÿ£ÿsÿsÿMtÿ¬3ZÄÿÿ111ÿ555ÿ===ÿMMMÿWWWÿ\\\ÿ```ÿdddÿeeeÿfffÿdgkýD‚»î …ÿ¢}ÿH…ÿ Žÿ Ÿÿ¢ÿsÿ sÿ;sÿ R¨´úÿ000ÿ222ÿCCCÿNNNÿSSSÿVVVÿZZZÿ\\\ÿ^^^ÿ___ÿ^^^ÿ\^aûF€®Ô“ÿK…ÿÿ ÿ¢ÿ ¢ÿsÿsÿ'sÿmmì¬'=Ñÿ---ÿ111ÿGGGÿJJJÿMMMÿQQQÿSSSÿUUUÿWWWÿXXXÿWWWÿUUUÿSUWûG€¤Ç¥ÿ2ÿ¢ÿ¢ÿsÿsÿsÿGsÿ U²²ñ'''ÿ111ÿFFFÿGGGÿJJJÿLLLÿNNNÿPPPÿQQQÿQQQÿQQQÿPPPÿNNNÿLNPûH€¡Ã"¤ÿ5sÿsÿ¢ÿsÿsÿ(sÿiqû«?{¼ÿ...ÿFFFÿFFFÿFFFÿHHHÿJJJÿJJJÿKKKÿKKKÿKKKÿJJJÿJJJÿIIIÿMQSûO€¢ÀŠû<sÿsÿsÿsÿsÿ7sÿqø«7gÁ###ÿBBBÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿGGGÿFFFÿGGGÿMMMÿOOOÿ>@AýU‹žÿ(sÿ sÿsÿsÿBsÿ†qù«E‡º,-.óEEEÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿHHHÿNNNÿOOOÿ>>>ÿ2Jç n߆vÿ4sÿ sÿsÿsÿBsÿ~rü«bЮ$9SÎ@@@ùIIIÿGGGÿGGGÿGGGÿJJJÿMMMÿOOOÿJJJÿ234ô??ùDsÌ cÑ–sû=sÿsÿsÿsÿLsþ‰mížX«´.NuÑ:RpÝ;Snà/LnÖKˆÁcÔ§rýsÿRsÿsÿsÿsÿsÿsÿ0sÿOsÿnsÿsÿ‡sÿˆsÿƒsÿxsÿ_sÿ7sÿsÿsÿsÿsÿsÿsÿ(sÿ0sÿ1sÿ,sÿ!sÿsÿsÿ   àøààààààààààààààððüüÿ(  ¢ÿ¢ÿ ¢ÿ¢ÿ^+]R¶ÃbÚßbÙà]Î×B‘´‡ymD¢ÿ ‚ÿxtÿÝsÿÿsÿÿsÿÿsÿÿsÿøsÿ sÿ¢ÿ€ÿ| xÿû|ÿÿ}ÿÿ|ÿÿ{ÿÿ wÿÿtÿÿsÿÁsÿyÿsÿ $’ÿz0ÿù-‹ÿÿ*‰ÿÿ$†ÿÿÿÿ{ÿÿtÿÿtÿŽsÿsÿ zÿ&…ÿO”ÿÜ1ÿý2Žÿÿ2Žÿÿ/Œÿÿ&‡ÿÿ~ÿÿtÿé¢ÿsÿsÿtÿC Z ¬"1ûŒâö0‘ÿü2Žÿÿ2Žÿÿ2Žÿÿ*‰ÿÿ|ÿþ¢ÿ¢ÿsÿsÿ%vÿ\#,íÿ%/2ý,³âö;˜ÿû6ÿÿ2Žÿÿ2Žÿÿ'ˆÿÿ¢ÿ ¢ÿsÿ sÿ+wÿjÿ ÿ999ÿELNü4¨áêBœÿú<“ÿÿ2Žÿÿ0ÿú¢ÿ¢ÿsÿ sÿ.vÿmÿ...ÿGGGÿ\\\ÿdhjý3ºäôCÿü2Žÿÿ0ÿÒ ÿ ¢ÿsÿ sÿ3tÿpÿ222ÿMMMÿlllÿ‚‚‚ÿsvxþAŸâô-Žÿø#ÿx•ÿsÿsÿ5sÿtò000ÿOOOÿmmmÿuuuÿmmmÿY\\þ+ƒÏÒ{ÿ={ÿsÿ sÿsÿ sÿ/sÿj'@¸)))ÿJJJÿZZZÿ___ÿZZZÿNNNÿFGHý8ŒÃ´yÿ:xÿsÿ sÿsÿ!sÿRiåy%-ÔAAAÿJJJÿKKKÿJJJÿFFFÿGGGÿMMMÿg­tÿ.uÿsÿsÿsÿ0sÿ_içx%7M»AABõGGGÿGGGÿJJJÿIIIþ7APÙfÑssÿ/sÿsÿsÿsÿsÿ0sÿSsÿqsÿssÿssÿssÿssÿssÿisÿDsÿsÿ ÿ@` À€€€€€€€€€€€Slic3r-version_1.31.6/var/Slic3r.icns000066400000000000000000001226021301441720000173060ustar00rootroot00000000000000icns¥‚is32“‚1ACB=,„=gFG;Z‚M Te€FJb‰ƒÿ"'A€FJj¢Éÿÿ€ ó,6EFJl³ò€ÿ€D,15Dl³øÿ ÿ2(16]«÷‚ÿ ÿH6]ªöƒÿÿô S«ö„ÿÿÿ4H¡ô…ÿ€ÿä¢ò…ÿ€ŠÿŠÿˆÿ‚ WÉö€ÿüËU€s‘})‚1ACB=,„=gFG7B‚8Te€FHXq^¢'A€FI]€Ž¢¢€ š,6EFI^Š’ˆž¢€L3,15B^Ž¼¯Œ¢¢((14M„ƽ‘¡¢¢64M€À½Ÿ¢¢¢›B„Á¹žŽ…¢¢¢¡&4q¼µŽŠ{¢¢€ ¡‰h°µœŽ‰u¢€¢¢œ¶µœ‹…uu¢€¢ µ±–‡‚zss¢¬¢„wvt€sw‚ 8fq€sr](€ 6C9‚1ACB=,„=g‚F/‚Te‚FE'A‚FE1€,6E€F=€€,14?E>55 (€1/,3F3,11-2F72.#,,>422!!3€2+€€3€2*€€ '322,!€ *'# €‚„€‡s8mkP²åðÓ‰¶ÿÿÿÿÿÿðGÂÿÿÿÿÿÿÿÑqÿÿÿÿÿÿÿÖßÿÿÿÿÿÿúp#ÿÿÿÿÿÿû÷ä'9ÿÿÿÿÿüøÿÿ)ÿÿÿÿøòÿÿÿÏ æÿÿýôÿÿÿÿõ ƒÿüöÿÿÿÿÿõ%Õ÷ÿÿÿÿÿÿË¡ÿÿÿÿÿÿÿu|ÿÿÿÿÿÿÿÜ \ÿÿÿÿÿÿÿè,Ÿ÷ÿÿÿýÌK( H\jŠ™“{ojaQ*il32xŠ &:??>;6%!8E„F:"%A‡FE+gÿÿ‰ oÎH…FGKSHJØÿˆ+8”Ä…FHN[p„ÿ†M'?EE„F HPb~œ°ÿÿ…ÿ%0>…F IQf†¨¼ÿÿÿÿ„ÿE"18„FIRh‹¬Æ‚ÿ…ÿ#&11B‚FIRhŒ¯×ƒÿ„ÿè )113C€FIRi°äƒÿ…ÿR)€12>FIRi°ä…ÿƒÿÿ5'‚17IgŽ°ã†ÿƒÿÿ,"14?Y¨àˆÿ‚ÿÿ+0114?Y‚¨Þ‰ÿ‚ÿÿ6€(14?Y‚¨ÛŠÿ‚ ÿÿL3?Zƒ¨Ù‹ÿ‚ ÿÿä0Zƒ¨ÚŒÿ‚€ÿ'*Hz¨Ùÿ‚€ÿ`+HvŸÔŽÿ‚ÿ.;pžÒŽÿƒÿÇm•Ìÿ„ÿÔËÿ„–ÿ„•ÿƒÿ•ÿƒÿÿ€‘ÿ…“ÿˆ‘ÿŠýþþ‰ÿúê.ˆ |×þ„ÿó±*€ƒ€8ŠµÇËÀ£h„ƒ€€Š &:??>;6%!8E„F:"%A‡FE+I¢¢‰ oÎH†FIO=8Œ¢ˆ$8”Ä…FGKTam\¢†8'?EE„F GLXj}†¢¢…¢!0>…F GMZo„ŽŸ¢¢¢„¢3"18„F GN\r‡Œ– ¢¢…¢ &11B‚F HN\s‰Œ†‘›¢¢„¢”)113C€F GN\tŠ£¤}„Žš¢…¢<)€12>FHN\tŠ¨À¾—„Ž™¢¢ƒ¢¢*'‚16EZtŠ²Äź¢“œ¢¢ƒ¢¢%"1 3:Jd}¹ËÅ¿«›‘™Ÿ€¢‚¢¢$0113:Ke|µÎÅ¿°œ“•¢‚¢¢*€(13:Ke}©ËÅ¿²“Ž¢‚¢¢82:Kf}¤ÅÅ¿±œ“ŽŽ‰¢‚¢¢’*Kf}¬Èž­œ“€Žƒ¢‚€¢"$7Y|±ÍÁ¹ªœ“€Žˆ}¢‚¢¢¡C%7Uo¤Ë¾·ª›“€ŽŒw¡€¢‚¢¢ )Ml–þ·ª›“€Žƒ~u€¢ƒ¢¢ ›xE_Š¼¾·©›’€ŽŒƒuu€¢„ ¢¡›˜ˆ»¾·©›’€Ž‰‚ysw¢¢„€¢Ÿ™–´¾·©›“ŽŽŒ…zss¢¢„€¢¡œ¸¾·©›’ŽŠ…€xssu¢¢ƒ¢¢»¾¶©›Š†‚€}u€s|¢¢ƒ¢¢€®µ°¡‘†‚€€{vsv¢¢…€¢ ­®¥”„|zzywuƒsužˆ¢¤­£“‚xt‡suŠ¢¡Š~xt†srnˆ;ct„soR€ƒ€@S[]XK0„ƒ€€Š &:??>;6%!8E„F:"%A‡FE+‰ oÎHˆF,ˆ8”ĉFE†'?EE‰F<…0>ŠF=„"18ˆFG8‚…&11B†FG*ƒ„)113C„FG ‚…)€12>‚FG 5="‚ƒ'‚1 4=DFG!4H;1ƒ"…143HH42.‚‚0ƒ122HH?€2‚€(‚121HHC3€2,‚€0€121HHB32%‚ 1120HE:‚21‚€!1'=7„2'‚€€33„2.‚ 33„20ƒ‚33„2/„ƒ33„2* „ƒ!33ƒ2.! ‚„‚+33‚2+! ‚ƒ.3322.)#€ƒƒ€!!„…€€ …ˆŠŒˆ‰€ƒƒ†ƒ€€l8mk?Š¼ÛåÜÀDbÜÿÿÿÿÿÿÿÿÿßc#ÈÿÿÿÿÿÿÿÿÿÿÿÿÿÂ$=íÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâ4óÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùNâÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúRÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûW)ýÿÿÿÿÿÿÿÿÿÿÿÿÿÿüd –ÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ“. çÿÿÿÿÿÿÿÿÿÿÿÿÿÿë¶I#-ÿÿÿÿÿÿÿÿÿÿÿÿÿÿðøÿ™+Zÿÿÿÿÿÿÿÿÿÿÿÿÿî÷ÿÿøJ nÿÿÿÿÿÿÿÿÿÿÿÿó÷ÿÿÿÿ· pÿÿÿÿÿÿÿÿÿÿÿòøÿÿÿÿÿý4 `ÿÿÿÿÿÿÿÿÿÿéôÿÿÿÿÿÿÿ ;ÿÿÿÿÿÿÿÿÿåìÿÿÿÿÿÿÿÿ¾  ðÿÿÿÿÿÿÿïîÿÿÿÿÿÿÿÿÿä ¨ÿÿÿÿÿÿõõÿÿÿÿÿÿÿÿÿÿô Aþÿÿÿÿóöÿÿÿÿÿÿÿÿÿÿÿô ¸ÿÿÿòòÿÿÿÿÿÿÿÿÿÿÿÿâFðÿõôÿÿÿÿÿÿÿÿÿÿÿÿÿ¹*|èóÿÿÿÿÿÿÿÿÿÿÿÿÿÿv ;¿ÿÿÿÿÿÿÿÿÿÿÿÿÿÿý& ‰ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¯{ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿù,tÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿzrþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ§âÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¡$±ÿÿÿÿÿÿÿÿÿÿÿÿók 2BŠàþÿÿÿÿÿÿÿ÷Èwb\TJ>.>q‡ŠŠ›ºÏÚÝÕÆ­ŒŒŒ‹‹‰†k,)5>FLQUWXYXWTPKE<2' ih32 ˜’  /7;;:73,!ž%6AE„FC7$™0CŠF7—„FHMWhš°Ëù†ÿˆÿÿà %12?‚FHMWh™°Ìú‡ÿˆÿÿg%ƒ1 :EFFHNXh›±Ìûˆÿ‡€ÿ4$„1 4?GMXh€›°ÊûŠÿ†€ÿ2€!„1 23;Keš±Éù‹ÿ†€ÿ+€0‚1 24:EXs©ÇúŒÿ…ÿ'-1 249EXr¨Ãøÿ…ÿ*%€1 249DXs©Âöÿ„ÿ1 /124:EYt‘©Â÷ÿ„ÿ5‚ %24:FYs‘©Àö‘ÿ„ÿR 1:EYt‘©¿ô’ÿ„ÿÖ€ (DZu’©Àõ“ÿ„‚ÿ +$1Ls’©¿õ”ÿ„‚ÿ ?$0Ge‡©¾ó”ÿ…‚ÿ ¼!$2Gg‡¡¹ó•ÿ…ƒÿA/Ge‡ ¶ò–ÿ†‚ÿÃ)4X~žµï—ÿ†ƒÿ¥Wz—®î—ÿˆƒÿ©—¬í˜ÿ‡„ÿüÈé˜ÿ‡£ÿ‡¢ÿ‰¡ÿ†ÿ ÿ†€ÿÿÿ›ÿˆ€ÿšÿŠ€ÿ›ÿŒœÿŽšÿ‘–ÿòô“$Ev¶â÷ÿî³+‚‰ =«í‰ÿã•&‚† ‚ f¬ÕåðõôíâÍžQˆ†ƒ%,+!‚„ˆ‚€‚€„’  /7;;:73,!ž%6AE„FC7$™0CŠF7—„FGKQ\k|Š—“|~ƒ‹—€¢ˆ¢¢%12?‚FGKQ\k|Š˜­²‹}‚‰— ¢¢ˆ¢¢H%ƒ1:EFFGKQ\l|Šš²Â©…ƒ‰—Ÿ¢¢‡€¢*€$„14?FKQ\k|Š›¹ÂÆÁ³˜…‹’™ €¢†€¢(€!„1238EXk|ŠžÆÅÅļ¯ž•œ¡€¢†€¢$€0‚1237>J[n›ÓÉÆÄÀ±¥š’”šž¢…¢"-1236>J[n}–×ÌÆÄ¿¶¥œ•‘ ¢…¢#%€1236=J[n}“ÓÍÅÄ¿¸¨œ•‘Ÿƒ¢„¢(/1237>J\o~‘ÉËÅÄ¿¸ªœ•‘ŽŽ–ƒ¢„¢*‚%237>K\o~Ž¿ÈÆÄ¿¸ªœ•‘Žƒ¢„¢;/7>K\n~Ž»ÅÅÄ¿·©œ•‘€Ž…ƒ¢„¢Š€$=K]o~‘ÅÆÅÿ´¦›•‘Ž‰ƒƒ¢„¢£$ )<[o~ÏËÆü±¥›•‘‚Žƒƒ¢„‚¢0!(7Ja}Ò̾¸¯¥›•‘‚Ž‰y¡¢…¢¡x!)7K_p„ÍË¿¼¸®¤›•‘‚Ž‚€u¡¢…¢¡ž,'7J_o¿Ç¿½¸¯¤›•‘‚Ž„zu‚¢†€¢ œw!:Tk}°Á¿½·¯¤›•‘ƒŽ†€tw‚¢†€¢ œšd7N`p¨¼¿¼·®¤›”‘‚Ž…xsw¢ˆ¢¢ œ™—h`o¨»¿½·¯¤›”‘‚ŽŒ„}ssz¢‡€¢¡œš—•£¼¿½·®¤›”‘‚Ž‰‚~tss€¢‡‚¢Ÿ›™–™µ¾¼·®¤›”‘ŽŒ…€ussuž€¢‡ƒ¢ œš™³¿¼·®¤›”‘€Ž‹†~t€sy€¢‰‚¢Ÿ·¿¼·®¤›”‘ŽŽ‰„‚|t€st†€¢†¢‚¢ §¸¿¼¶®£›”‰…ƒw‚sz€¢†€¢¢¢£¸¾¼¶¬¡–Ž‡ƒ„yt‚su–¢¢ˆ€¢ ¬±±­¥™ˆ„‚‚€|w„st~¢¢Š€¢ ¢¬¯¬¥™Ž…€~€}|zxu‡s{¢¢Œ€¢ ¬¯¬¥š‚zvts|šŽ€¢©«¤˜‚zvts{‘ ¢£¢¢…€zvt‹stp~“.LimsutŠstnT‚‰ Pmu‡suiE‚† ‚ /Qajnppmh^J%ˆ†ƒ ‚„ˆ‚€‚€„’  /7;;:73,!ž%6AE„FC7$™0CŠF7—ŠFG7†ˆ%12?ˆFG7 0…ˆ%ƒ1:E…FG7 ;B/ „‡€€$„14>E‚FG: 9HA3*…†€€!†139AEGH: 9HH>22!„†€€0ˆ126/ 8€H7220ƒ…-ˆ12* 6€HD2&ƒ…%‡12* 5€HG82/ƒ„/…12+ 5€HG=ƒ2ƒ„‚%„12, 4€HG>„2!ƒ„‚.‚12, 4€HG<„20ƒ„ƒ/€12, 3IHH@5…2)ƒ„‚ƒ /12- 0HE@6†21ƒ„‚„0- &<74ˆ2* ‚…‚ƒ !€3ˆ20‚…ƒ € €3ˆ21!ƒ†ƒ €3‰2#ƒ†„€3ˆ21" ƒˆ†€3ˆ2/ „‡‡€3ˆ2)ƒ‡†433‡2-!€„‡…&€3†2-#€„‰„*€3„21*!‚…†‚ +43321.)"‚††€(210/,*&!ƒ †ˆ€…‡Š€ € ŠŒ€•Ž€€”‘€”“‚‰“† „‡Š†„‰„ˆ‚€‚€„h8mk *_‘·ÍØÕǪKgÄóÿÿÿÿÿÿÿÿÿýåŸ>ráÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿü°0=Òÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷€ jñÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ·' ‚ýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ~„þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿŸ bùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ§ *óÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­  ¾ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿª \ýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ²Ìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»" OüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿËA& ¥ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿóQ6  ëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøãåD) 4ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøêúÿè_0kÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿøèùÿÿÿÂ2 Œÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùåøÿÿÿÿþs ¡ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúëøÿÿÿÿÿÿÝ* ©ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûîùÿÿÿÿÿÿÿþp ¥ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúìùÿÿÿÿÿÿÿÿÿË “ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ÷âöÿÿÿÿÿÿÿÿÿÿõ9 wÿÿÿÿÿÿÿÿÿÿÿÿÿÿö×ñÿÿÿÿÿÿÿÿÿÿÿÿo HÿÿÿÿÿÿÿÿÿÿÿÿÿøÔîÿÿÿÿÿÿÿÿÿÿÿÿÿ¬ õÿÿÿÿÿÿÿÿÿÿÿúÞïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÐ »ÿÿÿÿÿÿÿÿÿÿüéóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿç  hþÿÿÿÿÿÿÿÿüî÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿð  Þÿÿÿÿÿÿÿüìöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿð  }ÿÿÿÿÿÿüèôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿå-ÖÿÿÿÿüèóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÍ"bûÿÿüëôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥8 üýìôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿe -R¸àòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿó,  :`ÒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆ '™ýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþd ‚üÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÚyÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ^súÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»oùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿä&oþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñCi÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõReôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëKBÐÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ½% îÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿê‹) *:HU]}Äôÿÿÿÿÿÿÿÿÿÿÿÿyxuqlg_VJ=,Uv‚‡‰‹‹‹Ž­Ìãð÷úùõíßÅ¥ŒŒŒŒŒŒŒŒ‹‹Šˆƒx^" %?P^hpuz}„‰Ž‘‘Ž‰‡…††…„ƒ‚€~zvqj`TB*  &+059<@BCDDEDDB@=:61-'! it32?·¾ç #,39=?A€C B?=93,$ß !0–ÿíZB¡FGHJKMOPSVY^^C@FIJ;µÿ² -DDRæÿùf@ŸFGHIJLMORUX\`djfPPSL£þÿ³E€):G?s‚ÿçSCœF€GHIKLNPTX[_dimrxq\X£ÿÿ³ f%2@G?p‚ÿ£>œF€GHIKMORUY^bgmrx|€…oª€ÿ†ÿÿ§ ±03DGDLÓ€ÿ¸LC›F€GHJKMPSW[`ekqw}‚†Š‰·þÿÿ‡ÿÿ¦Ì€ +27GFFBY¡­€CB›F€GIJLNQTX]bhou|ƒ‰Ž”“½þÿ‡€ÿ¦ A#20E›FGGHIJLNQUY^dkqy€ˆ•››Ãþ€ÿ…ÿ¥s €/20?G¢FGGHIJLORVZ`elt|„Œ“›¡¡Æþÿ…ÿ¤   %210AG¡FGGHIKMORV[ahowˆ™ §¨Éþ‚ÿ„‚ÿ¡ÿë)€.210AG FGGHIKMOSW\biqy‚Š“œ£«¬Äý‚ÿ„ƒÿ ÿÿv €#2110@GŸFGGHIKMOSX]cjr{ƒ–ž§­®Æû‚ÿ…‚ÿ ÿÿº,2110>GžFGGHJKMPTX^eks}†Ž˜¡©°²Çûƒÿ„ƒÿŸ€ÿö7€10:GFGGHIKMPTY^dlt}‡™¢ª±³Åù„ÿƒ„ÿŸÿÿ— (2€105FGGHIKMPTY_emv~ˆ’š£¬²³Èú‡ÿ‚ƒÿžÿë,/2‚1CG™F€GHJKNQUY_fnv€Š“œ¤­´µÉúŠÿ„ÿž€ÿŒ 2‚10=G™FGGHJKNQTZ_fnv€‹”œ¥­´¶ÅùŠÿ„ÿžÿô2%2‚106G—F€GHIKMPTY`fnw€Š•¦®µ¶Å÷”ÿÿ ‚*2ƒ10@G•F€GHIKNQUZ`gox‚Œ– §¯¶¸Æ÷”ÿžÿõ7‚.2ƒ106G•FGGHJKMPUZ_foxŒ•Ÿ¨¯¶¸Äö•ÿÿ·‚0…10>G“FGGHJKNPUZ`goy‚Œ– ¨°·¸È÷•ÿ‚ÿe ‚ 2†12BG‘FGGHIKMQUZ`hoyƒ—¡©±·¸Êø•ÿžÿð+‚"2†105‘FGGHIKMQUZ_gpx‚— ©°·¸Ç÷–ÿ‚ÿ·ƒ%2‡108GGFGGHJKNQUZ`goyƒ— ©±·¸Ìù–ÿž‚ÿo ƒ'2ˆ109FG‹FGGHJKNQVZ`hpy„—¡ª±¸¸Ëú—ÿƒÿú:ƒ(2‰108FG‰FGGHJLNPTZ_gox‚— ª±¸¹Çø™ÿ›ƒÿ؃(2Š107EG‡FGGHJKNQTZ`gpyƒ˜¡ª²¸¹Ëøšÿ›ƒÿ¥ „(2‹104@H…FGGHJLNQUZ`hpy„˜¢ª²¸¹Éùœÿ™„ÿh„(2Œ101BHOW`juŽš¥®¶¹Åò§ÿ”…ÿS†'2Œ1€2357:=CHOW`kv—¡©°²½ò§ÿ”†ÿE†"2Œ1233579>BHOW`kuŒ—¡©°²¹ì©ÿ“†ÿüB‡0‹122357:>BHPWalv‚—¡ª°²½ìªÿ“†ÿüB‡+2‰122367:>CHPXakw‚˜¡ª±³»ñ¬ÿ’†ÿýC‡"2ˆ123357:=BHOWakv‚Œ˜¡©°³¸ê­ÿ‘‡ÿPˆ.2…1€2358:>BHPXalw‚Ž˜¢ª±´»ê®ÿ‘‡ÿOˆ'2…123357:>BHOXalw‚Ž™¢ª±´¹í¯ÿ’†ÿaˆ…123457:=BHOXakv‚˜¢©°´¸ç°ÿ‘‡ÿ| ‰)2‚123367:>CIPXblwƒ˜¢ª±´ºç±ÿ‘‡ÿŽ ‰‚123457:>CHPXalw‚Ž™¢ª±´·ê²ÿ‘‡ÿªŠ)21122357:>CIPXbkw‚˜¢ª°´·ä³ÿ‘ˆÿÌŠ/€2467;>CIQXbmwƒ˜¢«±´¹ä´ÿ‘ˆÿä%Š#€367:>CIPYbmx‚™¢«±´·çµÿ‘ˆÿýB‹-558:>CIPXblw‚Ž™¢ª±´¶â¶ÿ‘ˆÿvŠ 39:>CIQXbmw„™£«±µ¸â¸ÿ‰ÿ¿‰';?CIPYbmxƒ™¢«±µ·ä¸ÿ‘‰ÿá †!#2DIPYblxƒŽ™£ª±µ¶Þ¹ÿ‘‰ÿýP†!$)-@RYcnx„™£«±µ¶ÞºÿŠÿ …!%(.4GR^jw„™¢©®­ÑÁÿ”ÿ]+5?HQ]jvƒ™¢©­­ÏþÁÿ•Œÿ× +KZl|‹˜£ª¯­Îþ¶ÿŠÿ”Žÿ]3>LYguŒ˜¢©ªÌý·ÿ‰ÿ•ŽÿÞ:;KZhuƒŽ—Ÿ¥¤Çý¸ÿˆÿ—Žÿ °BZivƒ˜ ¦¤ÅýÅÿ—Žÿ þˆ^v‚˜Ÿ¤¤ÁûÅÿ˜ÿ ôŽ|˜ ¥¤ÃüºÿˆÿšŽÿïš” ¥¤Âü»ÿ‡ÿšÿæ¡¢¥½ùÇÿš‘ÿé©»ú¼ÿ‡ÿ™”ÿíö½ÿ‡ÿ˜×ÿ†ÿ˜âÿ™Öÿ†ÿšßÿšÖÿ†ÿšßÿœÔÿ…ÿžÜÿ–€ÿ‚ŽÿÀÿ…ÿ—ÿ‚ÿ†ÿÉÿ—ƒÿ€ÿÿÿÁÿ„ÿ—„ÿ€ÿÿ€ÿÿÁÿ„ÿ—†ÿƒÿÿ…Âÿƒÿ˜‡ÿ‹Âÿƒÿ„ÿ†ÿÿÂÿ‚ÿ™ÿ‚„ÿ†ÿÃÿ‚ÿ™ÿƒ†ÿ„Ãÿ‚ÿ¢…ÿÿÃÿÿ¥„ÿ€ÿÃÿ€ÿ¨†ÿÃÿÿ§Íÿ€ÿªËÿÿÿ­Éÿÿ°Çÿÿ²Åÿ¨ÿ‹¿ÿñ¤º½ÿÅ.½ÆËÏÓÜâ€äô¯ÿæs € ¯  (DR]ffe”ã«ÿì„€•ÿ‹ |ì§ÿò!ƒ‚‚€‘ÿˆ  €#~Ñ£ÿâ‰%‡ƒ€€€Žÿ‡ €€€K¯ìÿ÷²V„€€ ˜ ‹~Èñ—ÿ÷Ç~.œ – €‘_ÅëÿèÇ’W%¢€ — “7Ww–«ÀÍÑÖÕÔ˾®”wU3¤ – €ƒ”¥ƒ€ ™ €‹œ‹€ œ€ƒ€…„„„…‚€£€†ƒ‚ƒ†€® €€ ‚€€‚ ›¾ç #,39=?A€C B?=93,$ß !0–ÿíZB¢FGIIJLMOQRUT616890v¢² -DDRæÿùf@ŸF€GIJKLNOQTVY]X=<>;l¥£³3€):G?s‚ÿçSCžFGGHIJKMOQTVY\_bg]DAm¦£³ E%2@G?p‚ÿ£>F€GHIJLNPRUX[_cfikoYp¦£¢†¢¢§ s03DGDLÓ€ÿ¸LCœF€GHIKLNQSVZ]afilorsƒ£¤¢‡¢¢¦„€ +27GFFBY¡­€CBFGGIJKMOQUX\`dinqtxyˆ£¢‡€¢¦ 1#20EFGHIJKMPRUY]bgkqty}~Œ£€¢…¢¥N€/20?G¤FGHIJLNPSWZ_cinsx|‚Ž£¢…¢¤ i%210AG£FGHIJLNQSX\`ekpv{€„†‘¢‚¢„‚¢¡¢—#€.210AG¢FGHIKLNQTX]aflrw}‚†‰¢‚¢„ƒ¢ ¢¢Q€#2110@G¡FGHJKLNQUX]bhmty~„ˆ‹ ‚¢…‚¢ ¢¢y,2110>G FGHJKLORUZ^ciou{€…Šœ‚¢„ƒ¢Ÿ¢¢¤Ÿ+€10:GŸFGHIKLORUY_djpv{†‹Ž™•™ £€¢ƒ„¢Ÿ¢¢d(2€105ŸFGHIKLORVZ_ejpw|‡‹Ž‘’‘–›œŸ¢‚ƒ¢ž€¢¥—%/2‚1CGœFGHJKMPRV[_elrw}‚‡‘ŽŒŠŽ“—–——Ÿ‚¢„¢ž€¢]2‚10=G›FGHIKMOSV[`ekrx}ƒˆ‘†‡Š’“”™›¢„¢ž€¢¥œ)%2‚106GšF GHIKMORV[`flry~ƒ‰’Œƒƒ…ˆŠŒ‘—™—ž£ˆ¢¢h‚*2ƒ10@G˜F!GHJKMPRW[`flsy€„‰Ž“Œƒƒ…‡‰Œ”š–”˜¡‡¢ž€¢¤+‚.2ƒ106G—F#GHIKLPSV[aflsy…‰Ž’‚ƒƒ…ˆŽ––““•£†¢¢w‚0…10>G•F#GIIKMOSV[`flsz…ŠŽ’Ž}€ƒ„‡•’“•š†¢‚¢G‚ 2†12BG“F&GHJKMPSW\afmsz€…Š‘“ˆ||}€€‚„†ŽŽ’”– £ƒ¢ž¢™$‚"2†105“F'GHJKMPRV[afltz€…ŠŽ–š‰|{|}~€ƒ†ŒŒŽ‘”—œ£ƒ¢‚¢wƒ%2‡108GGF'GHIKMPRW[agmsz€…‹Ž˜§¡Ž€{{|~ƒ…ŠŒ‘”™œƒ¢ž‚¢Mƒ'2ˆ109FGF)GHJKMPSW\agntz†Š˜«¬¦ž‡}{|}ƒ…‰Œ’–šœ¡‚¢‚¢¤Ÿ-ƒ(2‰108FG‹F*GHJKLPSV[agmtz€†‹—¬¯«¶·š„||}‚…‡‹Ž’•™› ƒ¢›ƒ¢Šƒ(2Š107EG‰F+HHIKMOSW[agmt{€†‹˜­°®¹Æ¿¯˜|}€ƒ…‡Š‘”—šžƒ¢›ƒ¢m„(2‹104@H†F-GGHIKMPSW\agntz†‹˜¯²¯»ÇÆø¬’}€ƒ…‡Š’”˜š„¢™„¢H„(2Œ101BKV`js{‡‹–ÄÔÍȀƀÅÃÂÀ·²®ª¤Ÿ˜’Ž’”–™›œŸ‡¢•…¢A†,21€234579<@DIOU\dnv†‹Œ™ÊÙÓÌÆÅÄÃÂÀ½²¯«¦¡˜“‘’”–™šœŸˆ¢”…¢<†'2Œ122334579AEJPW_fmty~ƒ…„¯ÓÍÉ€ÆÅÅÄÃÁ¿½º´¬¥¢ž›˜–”“‘€ˆŽ…€¤‹¢‘ˆ¢£¤:…€!$&7GKQX_fntzƒ…„±ÙÒÍÇ€ÆÅÄÃÁÀ½¸±ª¥¢ž›˜–”’‘€ˆŽŒŠ¤‹¢Š¢^„€ $'+/DRW_emtyƒ„‚´ÞØÒÈ€ÆÅÄÿº´®ª¦¢Ÿ›˜–”’‘€‰Ž…€‚£‹¢‘‰¢¨‚ƒ0!#'+06=P`fmty~ƒ…ƒ²áÜÖÉÅÆÆÅÅÿ»¶±®«¦£ž›˜–”’‘€‰ŽŒ€~|¡£Š¢‘‰¢££6€0!#',06>EL^ntzƒ…„²ãàÚÊÅÆÅÿ»¸µ±­ª¦¢ž›˜•“’‘‹Ž…€‚zz¡£Š¢‘Š¢[2!$'+06=EMT\ky€ƒ…‚²åáÜÊÃÃÁ¿½¼º¸µ²®ª¦¢Ÿ›˜–”’‘‹Ž‹€‚ux £Š¢‘Š¢8¥Š!$'+06=EMU\djs‚†ƒ®ãâÝƾ¿¿¾½¼º¸µ²®ª¦¢ž›˜•”’‘ŒŽ „€‚swŸ£‰¢“‰¢7 §Q!$',06>EMU]dkpty¬ààÜƽ¿¿¾½¼º¸µ±­ª¥¡ž›˜–”’‘ŒŽ ‡€‚{qwŸ£‰¢’‰¢5 Ÿ¤‡!$'+16=EMT]djpuwt£ÝÝÛȽ¿¿¾½¼º¸µ²­ª¦¡ž›˜–”’‘€‹Ž‹‚vqx £‰¢’‰¢ ŸŸ¡C!$'+07=EMU]dkpuxuž×ÙØƾ€¿½¼º¸µ²®ª¦¢ž›˜–”’‘€Žƒ€‚}srz¡£‰¢“ˆ¢ŸŸž¢…#%(,16>EMU]dkpuwušÑÓÓž€¿¾¼º¸µ±­©¦¡ž›˜–”’‘€ŒŽ…€€‚wrq|Š¢”ˆ¢Ÿž£8 #+28>ELT]dkptwu–ÊÎΞ€¿½¼º¸µ²­ª¦¡ž›˜•”’‘€ŒŽ‡€€‚ssq£‰¢•†¢¡Ÿžœ¡‚  *7CMV^ekpuxv”ÄÇÈþ€¿½¼º¸µ²®©¦¢ž›˜–”’‘Žˆ€‚wrsqƒ‰¢•†¢ žžœ››¡X '0:GS_iquyw‘¾€Á€¿¾½¼º¸µ±®©¥¡ž›˜•”’‘Ž‰‚‚}rsspŠŠ¢”†¢¡žœ›ššž9 '09BJRYaioq¸¼¼¿¾½¼º¸µ±­ª¦¡ž›˜•”’‘ŽŠƒ‚vrssp‰¢•‡¢Ÿœ›š™…%%09CKS[`ehf„¶¸¸¾€¿¾½¼º¸µ±®©¥¢ž›˜•”’‘Ž‰ƒ‚{r€sr–ˆ¢—…¢.¡žžœ›š™—ži+9CLS[aeigƒµ·µ½À¿¿¾½¼º¸´±®©¥¡ž›˜•“’‘€ŒŽˆƒ‚t€sruœ£ˆ¢—…¢¡žžœ›š™—˜˜T=KSZaehg²·´¼À€¿½¼º·´±­ª¥¡ž›˜•”’‘€Ž‡„‚wr€sqz‰¢˜…¢¡žžœ›š™˜—˜’YOZafig‚µ·´¼À€¿½¼º¸´±­ª¦¡žš˜•”’‘€‹Ž„€ƒ‚{rsq‡ˆ¢š„¢*žœ›š™˜—–˜Žb^figµ¸¶¼À¿¿¾½¼º·´±®©¥¡žš—•“’‘€‹Ž‹ƒ€ƒ‚~ƒsq”‡¢š…¢)Ÿœ›š™˜—–•˜Œggh}³¹¶»À¿¿¾½¼º·´±®ª¥¡ž›—•“’‘€ŠŽˆ…‚€u‚sru£‡¢š…¢ œš™™˜—–•™‘l{³¹·¼€¿¾½¼º·´±­©¥¡ž›˜•”’‘‹ŽŒ…€…€vr‚sq‡¢™‡¢)¡žœœ›š™˜—–••›–¦µµ¼À¿¿¾½¼º·´±­©¥¡ž›˜•“’‘ŠŽŽˆ€†wrƒsp‡¢˜‰¢Ÿœ›šš™——–••§­¸€¿¾½¼º·´±­ª¥¡žš˜–”’‘‰ŽŒ…€†‚yr…sš†¢˜ˆ¢&££¢žœ››š™˜——••–±½¾¿¾½¼º·´±®ª¥¡›˜•”’‘€ˆŽ†€‡yr„sq~£‡¢™ˆ¢££ œ›š™™——–•’«¿€¾½¼º·´±­©¥¡žš˜•”’€‡Ž‡‚€ˆxr…sp†¢šˆ¢#££¢ž›šš™˜—–“¦ÀÀ¿¾½¼º·´²­©¥¡žš˜•“’‘€†Žˆƒ€‡‚xr…sru£…¢šŠ¢!££žœ››™™˜–©ÀÀ¿¾½¼º·´±­©¥¡š—•“’‘€„ŽŒ‡‚€ˆ‚v‡sq‰†¢šŒ¢¡€œ›™–ªÁÀ¿¾½¼¹·´±­©¥ žš˜•“’‘„ŽŽ‹…€‰‚~tr†srvž£…¢œŒ¢ žžœ—§ÀÀ¿¾½»º·´±­©¥¡žš˜•“’‘‚Ž‰„€Š‚|tˆsp†…¢žŒ¢ ŸŸ›©ÀÀ¿¾½¼º·´±­©¤¡›—•”’‘ŽŠ…‚€€Š‚€wrˆsrtœ¤…¢–€¢‚Œ¢£¡«ÁÀ¿¾½»¹·´±­¨¤¡žš˜•“’‘€Ž‰…‚€€‹‚‚|tr‰spˆ…¢—¢‚¢†¢ ¨¿À¿¾½»¹·´°­©¤¡š˜•”’‘‘Ž‹‰…‚€€‚xrŠsrv£„¢—ƒ¢€¢¢¢«¿À¿¾½»º·´°­¨¥¡žš˜•”“‘Œ‰†ƒ€€Ž‚€ytr‹sq‘„¢—„¢€¢¢€¢¢«ÀÀ¿¾½¼º·´±­©¥¢žš—”‘ˆ…ƒ‚€‚€ztrŒsp„¢—†¢ƒ¢¢…ª¿À¿¿½¼º·´°«§¢˜“‹‡…ƒƒ‚‚‚‚zursrt›ƒ¢˜‡¢‹£¶»ºº¸¶³°­©£Ÿš•‘Ž‹ˆ‡…„„‚‚Ž‚‚}xtrspŽƒ¢„¢†¢¢¤€¯°²³±¯«§£ž™–’Ž‹‰‡…„ƒ‚‚Œ‚‚zurrsp„‚¢™¢‚„¢†¢£¯°¯®¬«ª©¨¦£Ÿ›–’Œ‰‡…„„‚‚ˆ‚€~zvsr’sq{¡‚¢™¢ƒ†¢„£¯±¯®­«¨¥¡˜•“‹‰ˆ†…„ƒ‚‚€ƒ‚ €~|ywtsrr“srv›‚¢¢…¢¢£¯±¯¯­«©¦¢˜“ŽŠ…}}||}„~~|zywvts€r–srr•¢¥„¢€¢¢®±¯¯­«©¦¢™”Š†~|ywut‡s‚ršsrs‘€¢¨†¢£®±¯¯­«¨¥¢˜“Š…~{yxvutt§srs’¢§‡¢¤®°¯®­«¨¥¡ž™“ŽŠ…‚~{yxvutt§srq€¢ª…¢¡§°¯®­«¨¥¡œ˜”Š…‚~|yxvutt§sqs¢¢­…¢¡¦®­«¨¤ ›–’Ž‰…‚~{yxvutt§sqv—¢°…¢¡¤ª¨¥Ÿ™•Œ‰…~{yxvutt§spwš§²…¢¡¢¡›•Š‡„~{zwvutt¦suy‰§¨¢‹…¢¡•‡†…„‚|{ywvutt¦sylOº ª¨©¨§¦¥¥¤“|€{zxw€ut¥svz[½~‚„†Œ‘“‰wwutvvuu€t£suzk7€ ¯,5–ÿíZB«FHD!€ ²€-DDRæÿùf@¬FH@³€):G?s‚ÿçSC­FI:³ €%2@G?p‚ÿ£>¯FJ2 †§ 03DGDLÓ€ÿ¸LC¯FK*‡¦€ +27GFFBY¡­€CB¯FK,‡€¦ #20E¯FK+€…¥€/20?GµFGK-…¤ €%210AG´FGL/‚„‚¡€.210AG³FGK3‚„ƒ €#2110@G±FGGL1‚…‚ ‚,2110>G°FGGL2ƒ„ƒŸ€€10:G®F€GL5„ƒ„Ÿ (2€105®F€GL3†‚ƒž/2‚1CG«F€GL4‰„ž€ 2‚10=GªF€GK9‰„ž%2‚106G©F€GL6“ ‚*2ƒ10@G§F€GL7“ž‚.2ƒ106G¦F€GK:” ‚0…10>G¤F€GL8”‚‚ 2†12BG¡FGL9”ž‚"2†105¢F€GK>•‚ ƒ%2‡108GGFGK9”ž‚ƒ'2ˆ109FG›FGK:’„ƒ(2‰108FG™FG K? #D’›ƒ…(2Š107EG—FG K; !KD5’›ƒ „(2‹104@H•FG K= %LJD35’™„„(2Œ101 JIHID€31 ‘˜ƒ…&21008CGGŒFGJA !LIHHID3324)—„…$2‘102:BGG‰FGJCJI€HIB23225‘–„ …!2“1017?EGG…FGJ@IJH I@232231 –„…–10039?E€GF€GJB KJ‚HI<23€24+•…†/2—10049>CEGHJEIJ„H8ƒ26•…†,2™1€0 147953€23š23-Œ‘Š !046)72‚3›2 Œ“ŠŽ€,(6†3š23%Œ’‹Ž‚&7†3š23,Œ’ŒŠ‚'6†3š231Ž“Œ †‚'7†3›23"€ Œ”‚#6†3›23%€Ž• %6†3›24'€‰•Žƒ %7†3›24)Š”†   7†3›23*ƒ‰•ƒ€#6†3›24)ƒ‚ˆ—ƒ#7…3œ23'‚—„7†3š232%ƒŽ˜ƒ!6†3š230!ƒƒˆš” 6†3š24,ƒ…‡š•7†3™233(ƒš“6†3™23/"„„‡™–7…3™233'……‡˜–6†3—233-!… ††˜—64…3–234/$… ‘™•74„3—240%† ‡†š”54„3•2331'‡ ‘š”54…3“233.%‡ˆ†š“64„3’2€3+#ˆ’œ‘54„32€30)!‰‰…ž54„3Ž2€30+#Š ”–€‚Ž64„3Œ2€30)"‹‹…—‚†54„3ˆ231-)"Œ ”—ƒ€44„3…2€320,'# „—„€€64‹320.)# ŽŽ„—†ƒ…55‚4 3210.,*'%"€‘ƒ˜‡‹ #&&$#""!ƒ“ ƒ„†  €€— ’‚™‚„†‚  €”‚™ƒ†„…  ‡  €–‚¢…‡€ €  ˜¥„€††ƒ„ƒ€¨††¹§ˆ†¹€ª††¹­†„¹°†‚¹²†º¨‹Áº¾¾¹€ ±€¬ƒ„€•‹ƒ‚ª…‚‚€‘ˆ €€‚´ƒ€€€Ž‡ €€„¤‘„€€ ˜ Œ – €’—£€ – –Œ¦ — €ƒÀƒ€ ™ €‹œ‹€ œ€ƒ€…„„„…‚€£€†ƒ‚ƒ†€® €€ ‚€€‚ ›t8mk@6OgyŠ•˜š“oU=! Oƒ²×ðÿÿÿÿÿÿÿÿÿÿÿÿÿÿõä»–X-8ŠÈóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüÖ™P%uÀüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿË…2Q¬ôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿú´\^ÏÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÛbLÄÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÃM9°ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¹0ûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñt=Ãÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ²*}úÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿîd   ªÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ *Ëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ²! @æÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÉ-PóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿeSøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿNøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ–>ôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ,éÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿŸ×ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ®ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿŸ|ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ§Gÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ«  Øÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿµ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ²6öÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ´Éÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¼ [ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ·  Øÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿº  \ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÆ   ÊÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÅ"  JÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÊ.  Àÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ×A')"  7þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿØQ870(   ‘ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿærKH?6.%  Ûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿö«r\QF=4+# >þÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöÒ³ˆj\OD:0(! ŠÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùßÕÉÂfXK@5,$ ÈÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüåßÜéÿÍv^QE90' !ôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿúèäãïÿÿÿËhVJ>3*" RÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûéææóÿÿÿÿÿºYNA6-$ Œÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüêççòÿÿÿÿÿÿÿ•KD8/& Ðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûéæçòÿÿÿÿÿÿÿÿ÷u?:0'  ðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûçäåòÿÿÿÿÿÿÿÿÿÿÝI91(! 6ýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýçâãïÿÿÿÿÿÿÿÿÿÿÿÿ˜02)! VÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûæàâîÿÿÿÿÿÿÿÿÿÿÿÿÿôY*)! wÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿüçàáîÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÛ8&" Œÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþëâáìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿˆ" ¢ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýìåäíþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿç4 ²ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýíçæðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ¼ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþðéèïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿë0 Ãÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþñêêðþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ Âÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþðëëòÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿä$ Âÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñêëðþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿn  ·ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþïèéïþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÁ ±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿëãæïþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõ5 žÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿêßâëýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ{ ˆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýæÙÜçüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿº  nÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿáÓ×ãüÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñ, RÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâÏÒÝûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿQ 2üÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþàËÎÙúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‘ êÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÞÉË×úÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖ ÁÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿãËËÔùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿð)  ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþæÎÍÔøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿL @ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçÒÐ×ùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿe  îÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿíØÖÚøÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿŠ  ³ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñÞÛÞùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¡  rÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿòãáâùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿº  5øÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõçåæúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÇ  ¼ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöêèêûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÒ  vÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöëëëúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ×  *íÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöëëìûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÛ  „ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöéêìúÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÜ   1öÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõçèêùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÖ   ¨ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõåæéùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÐ  6ñÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿôãäæùÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿà  ¤ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõââäöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ³  Aõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõãâä÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿœ  „ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿöãâã÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ} '(Àÿÿÿÿÿÿÿÿÿÿÿÿÿ÷åãäõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ_ (+Wóÿÿÿÿÿÿÿÿÿÿÿ÷æåæöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ< &13“ÿÿÿÿÿÿÿÿÿÿøçæç÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿî %/9GÐÿÿÿÿÿÿÿÿùéççõÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÈ #,8C_ãÿÿÿÿÿÿùèèè÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ  *4CJvðÿÿÿÿùèçè÷ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ@ &0>LR’ûÿÿøååæôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿé #+8ES_ŸøöÛàäôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¯  '2=JZi¡ÁÏÛóÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿd  #,6CQ`uœ½èÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿõ$   &/:FR`{Õÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ´    (1" !1@LU]ejotwz}ƒ„…†‡ˆˆ‰‰ŠŠ‹‹‹Š‰‡………†ˆ‹ŒŒŒŠˆ†……†ˆŠ‹ŒŒŒŒŒŒŒŒŒ‹‹‹‹‹‹‹‹‹‹‹ŠŠŠ‰‰ˆ‡‡…„ƒ€~{wtpkf^VMA3# #*2:@GMRX\adhknpsuwyz{}~€‚ƒ„„„„„„„………††††‡‡‡†††††††…………„„ƒƒ‚€~}|zywusqnkhea]XSNHA;3+$  "'+048=@DHKNQTVY[]_acdfghjkllmnooooopppppppooooonmllkjhgfdca`][ZWURNKHEA=951,'#  !$&),.13579;<>?ACDEFGHIIJJKKKKKKKKKJJJIHGFEDCB@>=;97531.,*'$"   !!!!!!!!!!!!!  Slic3r-version_1.31.6/var/Slic3r.ico000066400000000000000000003073661301441720000171400ustar00rootroot00000000000000€€ (f@@ (BŽ00 ¨%¶J  ¨^p ˆ  hŽŠ(€                     !#%&()*,-./011222233333222110/..,+)('%$!      "&*.159<?BEGJLOQRTVWYZ\\]^_```aaaaaaaa```_^]\\[YWVUSQOLJGEB?<962.*'#   ")/5;AGLQUY]acgilnorsuvxyyz{|}}~~€€€€~~}}||zyyxwusrpnligda]YUQMGB<60)"  !/:DNU\bhlqswy|~ƒƒ„…†‡ˆˆˆ‰‰‰‰ŠŠŠŠŠŠŠŠŠŠŠŠ‹‹‹‹ŠŠŠŠŠŠŠŠŠŠŠŠ‰‰‰‰ˆˆˆ‡‡…„ƒƒ~|ywtqlhc]VNE;0$  ¢ÿ¢ÿ¢ÿ 0FXenuz}„…‡ˆ‰ŠŠŠ‹‹‹‹ŒŒŒŒŒŒŒŒŒ ”Až,a©7z²A¼H ÃJ£ÅMªÈL¨ÇJ£ÄD—¿;‚¶0k¬$P£*—ŽŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒ‹‹‹‹ŠŠŠ‰ˆ‡…„‚~zunf[J0 ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ @\oz…‡‰Š‹‹ŒŒŒŒŒŒŒŒŒŒŒŒŒŒ ’&T¤=ˆ¹V¾ÓdÝæmñõrüüsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿoö÷gåì\ÌÛJ£Å1l­/™ŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒ‹‹ŠŠˆ…{r`A ! ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ 7Pcow}€ƒ†‡‰‰Š‹‹‹‹Œ‹ŒŒŒ!•<„¶WÂÕkíñsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿo÷øbÚãI¡Ã#N£ŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒ‹‹‹‹‹‹Š‰‰‡†„}woeS9 ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ  .=IT]diotxz}ƒ„…‡‡,a¥[ÊØlðósÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsþþeßçGÁ"”‹‹‹‹‹‹‹ŠŠŠŠŠ‰‰‰ˆ‡‡†„ƒ}zwtpkd]UJ?0  ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ  &.6<DJPUZ_cgj r?‹ bØÖsþýsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿmñòRµÉ"K˜‚‚€€~~}|zyxvtromifb^[UPJD=6/& ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ  " ' , 1 5 :0EP¯ƒmðÛsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿrüú^ÏÉ4q‹ddba_][YVSQMKGD@<740+&! ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ)A-3O 5Q =^Ae<]hâgqûÕsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿiç½7xS420.,*(%#   ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‡Ôã •ë ˜ïƒïsý‘sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿrýëiès     ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ~ÿ^tÿ×sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsþ»oö7¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ–ÿ2zÿ·sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿøsÿ€Šÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿQyÿÞsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ¥vÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿŠÿiwÿñsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÉuÿ(¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ†ÿ„uÿùsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿätÿA¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ'tÿûsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ÷tÿT¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿƒÿ†tÿýsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿøtÿW¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿƒÿ„tÿýsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿútÿS¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‚ÿ‹sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿöuÿ:¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿ¡sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿuÿÿwÿÿ zÿÿ|ÿÿ~ÿÿÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ~ÿÿ|ÿÿzÿÿ xÿÿuÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÜvÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ€ÿ­sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿÿ xÿÿ|ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ|ÿÿ xÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÆxÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‚ÿ sÿÿsÿÿsÿÿtÿÿ xÿÿ|ÿÿ€ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ}ÿÿ yÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ³¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ~ÿ¨wÿÿ|ÿÿ€ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ}ÿÿ wÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿk¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿ·0ÿÿ0ÿÿ0ÿÿ0ÿÿ0ÿÿ0ÿÿ0Œÿÿ/Œÿÿ.‹ÿÿ-‹ÿÿ+Šÿÿ(ˆÿÿ&‡ÿÿ#…ÿÿ „ÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿzÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿôuÿ.¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ#ÿ¼2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ/Œÿÿ*‰ÿÿ'‡ÿÿ#…ÿÿƒÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ zÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿŇÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ‹ÿÍ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ,Šÿÿ(ˆÿÿ"…ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ yÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿb¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ…ÿ ŽÿÏ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ.‹ÿÿ(ˆÿÿ"…ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ xÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿå}ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¡ÿŸÿ $ÿÊ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ+Šÿÿ$†ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ|ÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿŽ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¡ÿŸÿ žÿ œÿ "ÿÓ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ*‰ÿÿ"…ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿwÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿóxÿ&¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿžÿžÿ žÿ›ÿÿ ‹ÿÝ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ(ˆÿÿ „ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ{ÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿ«¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ ÿÿÿ ›ÿšÿ™ÿ’ÿ+"Œÿâ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿ$†ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ~ÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿûwÿ4¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ ¡ÿÿÿ œÿ ›ÿ™ÿ™ÿ˜ÿ" –ÿ<'Žÿè2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿ#…ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿŸ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿŸÿÿœÿ ›ÿšÿ™ÿ™ÿ!—ÿ)—ÿ2‘ÿS'ÿë2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿ&‡ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿvÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿí~ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¡ÿ žÿ œÿ ›ÿšÿ™ÿ™ÿ ˜ÿ(—ÿ2–ÿ=–ÿH”ÿj"Œÿí2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿ%†ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ wÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿuÿn¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ ¢ÿŸÿÿœÿ ›ÿšÿ™ÿ˜ÿ&˜ÿ/–ÿ:•ÿF•ÿU”ÿj“ÿ—&Žÿó2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Šÿÿ „ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ wÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿÈ—ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¡ÿÿœÿ ›ÿ›ÿšÿ™ÿ"—ÿ+—ÿ4–ÿB•ÿR•ÿe–ÿˆ—ÿ°“ÿÒ&‹ÿù2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ)‰ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿwÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿûzÿ.¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿŸÿ˜ÿ ™ÿ ™ÿ˜ÿ˜ÿ—ÿ'–ÿ2•ÿ=•ÿL”ÿ\”ý€uÄÄ–ÿÈ–ÿÙÿå&Šÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ$†ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿvÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿuÿu¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ™ÿ™ÿ —ÿ•ÿ–ÿ–ÿ#–ÿ.”ÿ:”ÿH”ÿW•ÿpCoÝÿY˜ç”ÿß“ÿäÿé)ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ*‰ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿ¿¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ™ÿ˜ÿ ”ÿ“ÿ“ÿ”ÿ“ÿ+“ÿ6’ÿB“ÿO“ÿdN‚Îÿÿÿ\žì‘ÿåŽÿçÿê)‹ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿÿ!„ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ|ÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿð€ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿšÿšÿ’ÿ ’ÿ‘ÿÿÿ'‘ÿ2ÿ?‘ÿM‘ÿZ^´ÿÿÿÿÿc°îŽÿèŒÿé‰ÿì'‹ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ&‡ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ zÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿwÿN¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿšÿ•ÿ‘ÿÿÿÿ#ÿ/ÿ<ŽÿIÿVp¿ÿÿÿÿÿÿÿe¶î‹ÿèŠÿèˆÿì)Šÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ)‰ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿwÿÿsÿÿsÿÿsÿÿsÿÿsÿÿuÿ†¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿœÿ™ÿ“ÿ ÿŒÿ‰ÿ ‰ÿ*Šÿ7ŠÿE‹ÿT‡ïq ôÿÿÿÿÿÿÿÿf»î‹ÿè‹ÿç ‹ÿì-Œÿþ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ*‰ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿtÿÿsÿÿsÿÿsÿÿsÿÿtÿ¹¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ˜ÿ–ÿ ‘ÿŠÿ‰ÿ†ÿ&‡ÿ2ˆÿBˆÿPŠÿa&BÒÿÿÿÿÿÿÿÿÿÿoÊìŒÿçÿç ‹ÿí-Œÿý2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ{ÿÿsÿÿsÿÿsÿÿsÿÿsÿÝÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ–ÿ•ÿŽÿ ‹ÿ‡ÿ…ÿ#…ÿ/„ÿ;…ÿL…ÿ[T™–ÿÿÿÿÿÿÿÿÿÿÿ ÿnÃì‘ÿæ”ÿå ”ÿê-ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿvÿÿsÿÿsÿÿsÿÿsÿö~ÿ+¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ–ÿ–ÿÿ‰ÿ †ÿƒÿƒÿ)‚ÿ8‚ÿGƒÿXzép ôÿÿÿÿÿÿÿ ÿÿÿÿ!!!ÿ###ÿÓê˜ÿäÿäÿê-ÿý2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿ}ÿÿsÿÿsÿÿsÿÿsÿÿyÿF¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ–ÿŽÿ‹ÿ ˆÿƒÿ‚ÿ#ÿ1ÿ@€ÿQÿc#BÆÿÿÿÿÿ ÿÿÿÿ ÿ!!!ÿ###ÿ$$$ÿ&&&ÿ')+ÿŒÚé£ÿã©ÿä Ÿÿë-Œÿþ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿÿÿÿÿÿÿÿÿÿÿÿÿwÿÿsÿÿsÿÿsÿÿwÿa¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ–ÿŽÿ‡ÿ ƒÿ€ÿ€ÿ*ÿ9ÿIÿ[^¸‚ÿÿÿÿÿÿÿÿÿÿ!!!ÿ"""ÿ$$$ÿ%%%ÿ'''ÿ(((ÿ)+-ÿ—Üè¯ÿãµÿã ¥ÿí-Œÿþ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿÿÿÿÿÿÿÿÿÿÿÿ~ÿÿsÿÿsÿÿsÿÿvÿ|¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿŽÿˆÿ ƒÿÿÿ"~ÿ0~ÿA~ÿS~ÿe-Ñÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ###ÿ%%%ÿ&&&ÿ'''ÿ)))ÿ+++ÿ,.0þ ¤áçºÿä¿ÿå ªÿî0Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿÿÿÿÿÿÿÿÿÿÿvÿÿsÿÿsÿÿuÿ‘¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿŽÿ‡ÿ €ÿÿ~ÿ(|ÿ8}ÿI}ÿ]Q‘ÿÿÿÿÿÿÿÿÿÿ!!!ÿ"""ÿ$$$ÿ%%%ÿ'''ÿ(((ÿ***ÿ,,,ÿ...ÿ-69ý°çèÃÿæÇÿçªÿñ0Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ!„ÿÿÿÿÿÿÿÿÿÿ|ÿÿsÿÿsÿÿuÿž¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿÿˆÿ ƒÿ~ÿ~ÿ"|ÿ/|ÿ?|ÿRuíi")åÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ###ÿ%%%ÿ&&&ÿ'''ÿ)))ÿ+++ÿ---ÿ///ÿ000ÿ1:=ýºéêËÿèÍÿé±ÿñ0Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿƒÿÿÿÿÿÿÿÿÿÿuÿÿsÿÿuÿ©¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ‹ÿ„ÿ €ÿ~ÿ}ÿ'{ÿ5{ÿG{ÿYI‚Žÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ$$$ÿ%%%ÿ'''ÿ(((ÿ***ÿ,,,ÿ...ÿ000ÿ111ÿ555ÿ@JLþ¿éìÐÿêÑÿë±ÿò0Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿÿÿÿÿÿÿÿÿ{ÿÿsÿÿuÿ¬¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ‡ÿÿ ÿ|ÿ{ÿ-{ÿ<zÿOxüa$0Óÿÿÿÿÿÿÿÿÿÿ!!!ÿ###ÿ$$$ÿ&&&ÿ'''ÿ)))ÿ+++ÿ---ÿ///ÿ000ÿ666ÿEEEÿJJJÿFVYýËòíÓÿìÓÿì­ÿô0ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ$†ÿÿÿÿÿÿÿÿ€ÿÿtÿÿuÿ«¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ‹ÿˆÿ €ÿ}ÿ{ÿ#{ÿ2yÿBzÿU Xªxþÿÿÿÿÿÿÿÿÿ ÿ"""ÿ###ÿ%%%ÿ'''ÿ(((ÿ***ÿ,,,ÿ...ÿ000ÿ999ÿFFFÿJJJÿKKKÿMMMÿI`eüÎôíÔÿìÓÿì©ÿôB—ÿÿ?•ÿÿ<“ÿÿ8‘ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ‚ÿÿÿÿÿÿÿÿ wÿÿuÿ©¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ†ÿ„ÿ €ÿ|ÿzÿ'zÿ6yÿIyÿ\0L«ÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ$$$ÿ&&&ÿ'''ÿ(((ÿ***ÿ,,,ÿ///ÿ<<<ÿGGGÿIIIÿJJJÿLLLÿNNNÿPPPÿKdiüÍòíÓÿëÑÿê©ÿóGšÿÿGšÿÿGšÿÿE™ÿÿB—ÿÿ=”ÿÿ8‘ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿÿÿÿÿÿÿ|ÿÿuÿ¦¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ‹ÿÿ ~ÿ{ÿzÿ-yÿ<yÿOvóa!åÿÿÿÿÿÿÿÿÿÿ!!!ÿ###ÿ$$$ÿ&&&ÿ'''ÿ)))ÿ+++ÿ---ÿ999ÿFFFÿHHHÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿLglû ÎøëÑÿèÎÿæ&¯ÿóGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿD˜ÿÿ<”ÿÿ5ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ‚ÿÿÿÿÿÿÿÿuÿ˜¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ…ÿ€ÿ}ÿzÿ"zÿ1yÿAyÿU Y­uþÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ###ÿ%%%ÿ'''ÿ(((ÿ***ÿ,,,ÿ999ÿEEEÿFFFÿIIIÿJJJÿLLLÿMMMÿPPPÿRRRÿSSSÿUUUÿLjqú Ë÷çÌÿäÊÿá%¦ÿòGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿF™ÿÿA–ÿÿ9’ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿÿÿÿÿ€ÿÿvÿ‹¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿƒÿ ÿ|ÿyÿ%yÿ5xÿFxÿZ2R¤ÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ$$$ÿ%%%ÿ'''ÿ(((ÿ***ÿ555ÿDDDÿEEEÿGGGÿIIIÿKKKÿMMMÿNNNÿQQQÿSSSÿTTTÿUUUÿXXXÿNmuú ÇùãÇÿÞÅÿÜ#£ÿñGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿC—ÿÿ:’ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ‚ÿÿÿÿ€ÿÿxÿp¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ†ÿÿ ~ÿ{ÿzÿ)yÿ:xÿKyÿ] )Óÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ$$$ÿ&&&ÿ'''ÿ)))ÿ222ÿBBBÿDDDÿEEEÿHHHÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿVVVÿYYYÿ[[[ÿNwøÄýÛÂÿÙÀÿ×' ÿïGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿC—ÿÿ7‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ$†ÿÿÿÿ€ÿÿ{ÿX¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ†ÿÿ |ÿ{ÿxÿ,xÿ=xÿPpæcîÿÿÿÿÿÿÿÿÿÿ!!!ÿ"""ÿ$$$ÿ&&&ÿ'''ÿ---ÿ???ÿBBBÿEEEÿFFFÿHHHÿJJJÿLLLÿMMMÿPPPÿRRRÿSSSÿUUUÿWWWÿZZZÿ\\\ÿ\\\ÿK|Œó ÁüÕ¾ÿÔ¼ÿÒ(›ÿòGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿF™ÿÿ>•ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Šÿÿÿÿ€ÿûÿ9¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿƒÿ~ÿ {ÿzÿ!yÿ0xÿ@wÿTQ›yÿÿÿÿÿÿÿÿÿÿÿ!!!ÿ###ÿ%%%ÿ&&&ÿ(((ÿ<<<ÿBBBÿCCCÿEEEÿFFFÿIIIÿJJJÿLLLÿNNNÿPPPÿSSSÿTTTÿUUUÿXXXÿZZZÿ\\\ÿ]]]ÿ___ÿQw„ô »úÔ»ÿÏ·ÿÐ*ÿïGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿD˜ÿÿ8’ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ‚ÿÿÿîŠÿ&¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ€ÿ}ÿ{ÿyÿ$xÿ2xÿCxÿX;g”ÿÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ###ÿ%%%ÿ'''ÿ444ÿ@@@ÿBBBÿCCCÿEEEÿGGGÿIIIÿJJJÿMMMÿNNNÿQQQÿSSSÿUUUÿVVVÿXXXÿ[[[ÿ\\\ÿ^^^ÿ```ÿbbbÿQy‡ò ºþиÿ͸ÿÎ-ŸÿîGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ<“ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ$†ÿÿ‚ÿÌ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿÿ|ÿzÿyÿ&xÿ4xÿGwÿ[(<·ÿÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ###ÿ%%%ÿ***ÿ===ÿ@@@ÿBBBÿCCCÿEEEÿGGGÿIIIÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿVVVÿYYYÿ[[[ÿ\\\ÿ^^^ÿ```ÿcccÿeeeÿN‚—îºþ̸ÿιÿÏ/ÿóGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ>•ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿÿ„ÿª¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿ~ÿ {ÿzÿyÿ(wÿ7wÿJxÿ\!*Ïÿÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ###ÿ%%%ÿ666ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿWWWÿYYYÿ\\\ÿ\\\ÿ^^^ÿaaaÿcccÿeeeÿfffÿM†œìºþκÿиÿÔ.›ÿöGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ@–ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ†ÿp¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ†ÿ~ÿ {ÿyÿyÿ*wÿ:wÿMqî_æÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ###ÿ---ÿ===ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿWWWÿYYYÿ\\\ÿ\\\ÿ___ÿaaaÿcccÿeeeÿfffÿhhhÿKŽ¨ë½ÿÒ¾ÿÕ¼ÿÙ-œÿøGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ@–ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿûŒÿ?¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ†ÿ|ÿ zÿyÿxÿ,wÿ<wÿOfÕdðÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ$$$ÿ888ÿ===ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿJJJÿKKKÿMMMÿOOOÿRRRÿSSSÿUUUÿWWWÿYYYÿ\\\ÿ\\\ÿ___ÿaaaÿcccÿeeeÿfffÿhhhÿjjjÿJ¨ìÀþÖÂÿÚÀÿß6ÿùGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ>•ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2ÿÚ  ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿ†ÿ{ÿ xÿyÿ xÿ.wÿ>wÿQ W°qûÿÿÿÿÿÿÿÿÿÿ ÿ"""ÿ+++ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿWWWÿYYYÿ\\\ÿ\\\ÿ___ÿaaaÿcccÿeeeÿfffÿhhhÿjjjÿlllÿJ§ïÅÿÜÇÿàÁÿå4ŸÿøGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ;“ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(Œÿ¤¡ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿƒÿ{ÿ zÿyÿ!wÿ-wÿ?wÿRN˜zþÿÿÿÿÿÿÿÿÿÿ ÿ!!!ÿ444ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿWWWÿYYYÿ\\\ÿ\\\ÿ^^^ÿaaaÿcccÿeeeÿfffÿhhhÿjjjÿlllÿmmmÿFœ´ïÊÿâÌÿåÇÿé5ŸÿúGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿF™ÿÿ6ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿý‰ÿY ÿ¡ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿƒÿ{ÿ xÿwÿ!wÿ/wÿ@vÿSFƒƒÿÿÿÿÿÿÿÿÿÿÿ ÿ'''ÿ999ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿCCCÿEEEÿGGGÿIIIÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿVVVÿYYYÿ[[[ÿ\\\ÿ^^^ÿ```ÿcccÿeeeÿeeeÿgggÿiiiÿkkkÿmmmÿnnnÿ?¤¾ðÎÿçÐÿèÉÿì7žÿûGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿB—ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-ŒÿÝ›ÿŸÿ ÿ¡ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ’ÿƒÿ{ÿ wÿwÿ!wÿ/wÿ@vÿT=pŒÿÿÿÿÿÿÿÿÿÿÿ ÿ///ÿ999ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿCCCÿEEEÿGGGÿIIIÿJJJÿMMMÿNNNÿQQQÿSSSÿUUUÿVVVÿXXXÿ[[[ÿ\\\ÿ^^^ÿ```ÿbbbÿdddÿeeeÿgggÿiiiÿkkkÿlllÿmmmÿnnnÿ:ªÄòÒÿêÓÿëÆÿî6šÿüGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ;“ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ$Šÿ ÿžÿ ÿ ÿ¢ÿ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿƒÿ{ÿ wÿwÿ!wÿ/wÿAvÿT9d“ÿÿÿÿÿÿÿÿÿÿÿ ÿ555ÿ999ÿ;;;ÿ<<<ÿ===ÿ@@@ÿBBBÿCCCÿEEEÿFFFÿIIIÿJJJÿLLLÿNNNÿPPPÿSSSÿTTTÿUUUÿXXXÿZZZÿ\\\ÿ]]]ÿ___ÿaaaÿdddÿeeeÿfffÿhhhÿjjjÿkkkÿmmmÿnnnÿnnnÿ;©ÀôÔÿìÔÿìÅÿï7›ÿüGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿF™ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿ÷ŒÿAœÿÿžÿŸÿ ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿƒÿ{ÿ wÿwÿ!wÿ/wÿAvÿS7a”ÿÿÿÿÿÿÿÿÿÿÿ%%%ÿ888ÿ999ÿ:::ÿ<<<ÿ===ÿ???ÿAAAÿBBBÿEEEÿFFFÿHHHÿJJJÿLLLÿMMMÿPPPÿRRRÿSSSÿUUUÿWWWÿZZZÿ\\\ÿ\\\ÿ^^^ÿaaaÿcccÿeeeÿeeeÿgggÿhhhÿjjjÿlllÿmmmÿnnnÿnnnÿ>«ÂõÔÿìÓÿìÃÿî9žÿûGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ<”ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(‹ÿ¾™ÿ šÿœÿÿŸÿ ÿ ¡ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿƒÿ{ÿ wÿwÿ!wÿ/vÿ?vÿS?rŠÿÿÿÿÿÿÿÿÿÿÿ+++ÿ777ÿ999ÿ:::ÿ<<<ÿ===ÿ???ÿAAAÿBBBÿDDDÿEEEÿHHHÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿUUUÿVVVÿYYYÿ[[[ÿ\\\ÿ]]]ÿ```ÿbbbÿdddÿeeeÿfffÿgggÿiiiÿjjjÿlllÿmmmÿmmmÿnnnÿ4±ËóÒÿëÑÿë Ãÿì<šÿüGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿD˜ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ‰ÿl—ÿ ™ÿšÿœÿžÿŸÿ ¡ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿƒÿ{ÿ xÿvÿ vÿ.vÿ?vÿRDÿÿÿÿÿÿÿÿÿÿÿ000ÿ777ÿ999ÿ:::ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿIIIÿKKKÿMMMÿNNNÿQQQÿSSSÿTTTÿUUUÿXXXÿZZZÿ\\\ÿ\\\ÿ^^^ÿaaaÿbbbÿdddÿeeeÿfffÿgggÿiiiÿjjjÿkkkÿlllÿmmmÿmmmÿ.·ÖðÏÿéÌÿè »ÿë<™ÿüGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ8‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ'ŠÿÏÿ*•ÿ—ÿ™ÿ›ÿœÿžÿ  ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿ|ÿ{ÿ xÿvÿvÿ-vÿ>vÿQPžtþÿÿÿÿÿÿÿÿÿÿ444ÿ777ÿ888ÿ999ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿCCCÿEEEÿFFFÿIIIÿJJJÿLLLÿMMMÿPPPÿRRRÿSSSÿUUUÿWWWÿYYYÿ[[[ÿ\\\ÿ]]]ÿ___ÿaaaÿcccÿeeeÿeeeÿfffÿgggÿjjjÿnnnÿrrrÿtttÿvvvÿxxxÿ9¸ØðÉÿçÄÿæ ³ÿê;˜ÿüGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ?•ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿù‹ÿY‘ÿ&“ÿ•ÿ—ÿšÿœÿÿ Ÿÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿÿ{ÿ xÿvÿvÿ,vÿ<vÿP Y·lùÿÿÿÿÿÿÿÿÿ"""ÿ555ÿ666ÿ888ÿ999ÿ:::ÿ<<<ÿ===ÿ???ÿAAAÿBBBÿDDDÿFFFÿHHHÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿTTTÿVVVÿXXXÿZZZÿ\\\ÿ\\\ÿ^^^ÿ```ÿaaaÿdddÿiiiÿmmmÿrrrÿvvvÿwwwÿxxxÿxxxÿyyyÿyyyÿyyyÿ3±ÖíÁÿä¼ÿä ©ÿé@–ÿþGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿD˜ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+ÿ¼Œÿ-ÿ&‘ÿ“ÿ•ÿ˜ÿ›ÿ œÿ Ÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿÿ|ÿ xÿvÿuÿ*uÿ:uÿMdÔbðÿÿÿÿÿÿÿÿÿ%%%ÿ555ÿ666ÿ777ÿ999ÿ:::ÿ<<<ÿ===ÿ>>>ÿ@@@ÿBBBÿDDDÿEEEÿGGGÿIIIÿJJJÿLLLÿNNNÿPPPÿRRRÿSSSÿUUUÿVVVÿXXXÿZZZÿ\\\ÿ]]]ÿdddÿkkkÿoooÿsssÿtttÿuuuÿuuuÿvvvÿvvvÿvvvÿwwwÿwwwÿwwwÿwwwÿ4®Úë·ÿã²ÿã Ÿÿë@–ÿþGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿF™ÿÿ7‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿõˆÿWŠÿ-Œÿ%ÿ’ÿ”ÿ—ÿ™ÿ œÿ ÿ ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿ~ÿ yÿwÿuÿ(vÿ8vÿKqô[áÿÿÿÿÿÿÿÿÿ(((ÿ555ÿ666ÿ777ÿ999ÿ999ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿCCCÿEEEÿFFFÿHHHÿJJJÿKKKÿMMMÿOOOÿQQQÿSSSÿTTTÿUUUÿWWWÿ\\\ÿeeeÿkkkÿmmmÿnnnÿpppÿqqqÿrrrÿtttÿuuuÿuuuÿuuuÿuuuÿvvvÿvvvÿvvvÿvvvÿvvvÿ1¨Üê«ÿâ¦ÿã›ÿê@—ÿýGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ:’ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ‡ÿ“†ÿ8ˆÿ-‹ÿ%Žÿÿ“ÿ–ÿ˜ÿ ›ÿ ÿŸÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿyÿyÿwÿuÿ&vÿ5vÿHuÿY)Ëÿÿÿÿÿÿÿÿÿ)))ÿ555ÿ555ÿ666ÿ888ÿ999ÿ:::ÿ<<<ÿ===ÿ???ÿAAAÿBBBÿDDDÿEEEÿGGGÿIIIÿJJJÿLLLÿMMMÿOOOÿQQQÿSSSÿXXXÿaaaÿhhhÿjjjÿlllÿmmmÿmmmÿnnnÿoooÿqqqÿrrrÿsssÿtttÿtttÿuuuÿuuuÿuuuÿuuuÿuuuÿuuuÿuuuÿ)¢ãè¡ÿã›ÿä”ÿìC™ÿþGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ<”ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ&‰ÿ؃ÿE„ÿ8‡ÿ-‰ÿ%ŒÿŽÿ‘ÿ”ÿ—ÿ šÿ œÿŸÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿzÿyÿwÿvÿ$uÿ2uÿDuÿX'<°ÿÿÿÿÿÿÿÿÿ,,,ÿ444ÿ555ÿ666ÿ777ÿ999ÿ:::ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿCCCÿEEEÿFFFÿHHHÿJJJÿKKKÿMMMÿNNNÿSSSÿ]]]ÿeeeÿfffÿgggÿhhhÿjjjÿlllÿmmmÿmmmÿnnnÿnnnÿpppÿqqqÿqqqÿrrrÿsssÿsssÿsssÿsssÿsssÿsssÿsssÿotvþ'œéè–ÿå‘ÿçÿðC—ÿþGšÿÿGšÿÿGšÿÿGšÿÿ>•ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿú ÿq‚ÿDƒÿ7†ÿ-ˆÿ$‹ÿÿÿ“ÿ–ÿ ™ÿ›ÿžÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿ{ÿzÿ wÿvÿ"uÿ0uÿ@uÿU7eÿÿÿÿÿÿÿÿÿ///ÿ444ÿ555ÿ555ÿ777ÿ888ÿ999ÿ;;;ÿ<<<ÿ===ÿ???ÿAAAÿBBBÿDDDÿEEEÿGGGÿIIIÿJJJÿNNNÿXXXÿ```ÿbbbÿdddÿeeeÿfffÿgggÿhhhÿjjjÿkkkÿmmmÿmmmÿmmmÿnnnÿnnnÿoooÿpppÿpppÿqqqÿqqqÿqqqÿqqqÿqqqÿpppÿpppÿnprþ'“æêÿçŠÿè‡ÿðC—ÿÿGšÿÿGšÿÿGšÿÿ?•ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ„ÿ¨ÿP€ÿB‚ÿ6„ÿ+‡ÿ#ŠÿŒÿÿ’ÿ–ÿ ˜ÿšÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿwÿ xÿvÿuÿ-uÿ=uÿP P£pýÿÿÿÿÿÿÿÿ000ÿ333ÿ444ÿ555ÿ666ÿ888ÿ999ÿ:::ÿ;;;ÿ===ÿ>>>ÿ@@@ÿBBBÿCCCÿDDDÿEEEÿGGGÿNNNÿ[[[ÿ^^^ÿ___ÿaaaÿcccÿdddÿeeeÿfffÿfffÿhhhÿiiiÿkkkÿlllÿmmmÿmmmÿmmmÿnnnÿnnnÿnnnÿnnnÿoooÿoooÿoooÿnnnÿnnnÿnnnÿnnnÿmnnÿ'Žäì‡ÿè†ÿé‡ÿðD˜ÿÿGšÿÿGšÿÿ?•ÿÿ2Žÿÿ2Žÿÿ‡ÿÑ}ÿ]~ÿL€ÿ@ÿ4„ÿ*†ÿ"Šÿ‹ÿÿ‘ÿ ”ÿ —ÿšÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿxÿ xÿvÿuÿ*uÿ9uÿLjá`íÿÿÿÿÿÿÿÿ000ÿ333ÿ444ÿ555ÿ555ÿ777ÿ888ÿ999ÿ;;;ÿ<<<ÿ===ÿ???ÿAAAÿBBBÿCCCÿEEEÿNNNÿZZZÿ\\\ÿ]]]ÿ^^^ÿ___ÿaaaÿcccÿdddÿeeeÿeeeÿfffÿgggÿiiiÿjjjÿkkkÿlllÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿmmmÿgnrýŒñë„ÿçƒÿçˆÿñD˜ÿÿGšÿÿ=”ÿÿ2Žÿÿ&‰ÿá}ÿr}ÿX~ÿIÿ=ÿ2„ÿ(†ÿ Šÿ‹ÿŽÿ‘ÿ ”ÿ—ÿšÿœÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿvÿwÿuÿ&uÿ5uÿGuÿX)Êÿÿÿÿÿÿÿÿ///ÿ222ÿ333ÿ555ÿ555ÿ666ÿ888ÿ999ÿ:::ÿ;;;ÿ===ÿ>>>ÿ???ÿAAAÿBBBÿOOOÿXXXÿYYYÿ[[[ÿ\\\ÿ]]]ÿ^^^ÿ___ÿaaaÿbbbÿdddÿeeeÿeeeÿfffÿgggÿhhhÿiiiÿjjjÿkkkÿkkkÿlllÿlllÿmmmÿmmmÿmmmÿmmmÿmmmÿlllÿlllÿkkkÿkkkÿjjjÿemuüŠðé„ÿå„ÿä‹ÿïE™ÿÿ<“ÿÿ'‹ÿëÿ€|ÿb|ÿR~ÿDÿ:ÿ/ƒÿ%†ÿ‰ÿ‹ÿŽÿÿ “ÿ–ÿ™ÿžÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿwÿ wÿvÿ#uÿ1tÿAuÿU2U™ÿÿÿÿÿÿÿÿ---ÿ222ÿ333ÿ444ÿ555ÿ555ÿ777ÿ888ÿ999ÿ:::ÿ<<<ÿ===ÿ>>>ÿAAAÿNNNÿUUUÿWWWÿXXXÿZZZÿ[[[ÿ\\\ÿ]]]ÿ^^^ÿ___ÿaaaÿbbbÿcccÿeeeÿeeeÿeeeÿfffÿfffÿgggÿhhhÿiiiÿiiiÿjjjÿjjjÿjjjÿjjjÿjjjÿjjjÿjjjÿiiiÿiiiÿhhhÿgggÿfffÿahpü‰ïå†ÿ߆ÿÛÿå)Œÿì€ÿŽ|ÿi|ÿY|ÿK~ÿ?ÿ5ÿ+ƒÿ"‡ÿŠÿ‹ÿÿ’ÿ •ÿ™ÿšÿ ÿ£ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿ uÿvÿ uÿ-tÿ=uÿP Q§nýÿÿÿÿÿÿÿ***ÿ111ÿ222ÿ333ÿ444ÿ555ÿ666ÿ777ÿ999ÿ999ÿ;;;ÿ<<<ÿ>>>ÿLLLÿSSSÿUUUÿVVVÿWWWÿXXXÿZZZÿ[[[ÿ\\\ÿ]]]ÿ^^^ÿ___ÿ```ÿaaaÿcccÿdddÿeeeÿeeeÿeeeÿfffÿfffÿfffÿgggÿgggÿhhhÿhhhÿhhhÿhhhÿhhhÿgggÿgggÿfffÿfffÿfffÿeeeÿeeeÿ^juúŒõÞ‡ÿÑ…ÿ·€ÿ|ÿq{ÿ_{ÿQ}ÿE~ÿ:€ÿ0ÿ'ƒÿˆÿ‹ÿ‹ÿŽÿ ÿ •ÿ™ÿÿ¡ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿ vÿvÿuÿ)uÿ8tÿIpõYÞÿÿÿÿÿÿÿ'''ÿ111ÿ222ÿ333ÿ444ÿ555ÿ555ÿ666ÿ888ÿ999ÿ:::ÿ;;;ÿJJJÿQQQÿSSSÿTTTÿUUUÿVVVÿWWWÿXXXÿZZZÿ[[[ÿ\\\ÿ\\\ÿ^^^ÿ___ÿ___ÿaaaÿbbbÿcccÿdddÿeeeÿeeeÿeeeÿeeeÿfffÿfffÿfffÿfffÿfffÿfffÿfffÿfffÿfffÿeeeÿeeeÿeeeÿeeeÿdddÿcccÿZhuúŽðÌ…ÿŸÿw{ÿb{ÿU|ÿI}ÿ>ÿ3€ÿ+‚ÿ#…ÿ‰ÿ‹ÿ‹ÿ ÿ ÿ“ÿ—ÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ uÿvÿ$uÿ3tÿCtÿU+G£ÿÿÿÿÿÿÿ%%%ÿ111ÿ111ÿ222ÿ333ÿ444ÿ555ÿ666ÿ777ÿ888ÿ999ÿBBBÿPPPÿQQQÿRRRÿSSSÿTTTÿUUUÿVVVÿWWWÿXXXÿYYYÿ[[[ÿ\\\ÿ\\\ÿ]]]ÿ^^^ÿ___ÿ```ÿaaaÿbbbÿcccÿcccÿdddÿeeeÿeeeÿeeeÿeeeÿeeeÿeeeÿeeeÿeeeÿeeeÿeeeÿeeeÿdddÿcccÿcccÿbbbÿaaaÿ```ÿYenú ñ¡}ÿb{ÿU|ÿJ}ÿ@~ÿ6ÿ-€ÿ&ƒÿ…ÿ‹ÿÿ‹ÿ Žÿ ÿ”ÿ•ÿŸÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿtÿuÿ.tÿ>tÿO Q§nýÿÿÿÿÿÿ"""ÿ111ÿ111ÿ222ÿ222ÿ333ÿ555ÿ555ÿ666ÿ777ÿ;;;ÿMMMÿNNNÿPPPÿQQQÿRRRÿSSSÿTTTÿUUUÿVVVÿWWWÿXXXÿYYYÿZZZÿ\\\ÿ\\\ÿ\\\ÿ]]]ÿ^^^ÿ___ÿ___ÿ```ÿaaaÿbbbÿbbbÿcccÿcccÿcccÿcccÿdddÿcccÿcccÿcccÿcccÿbbbÿbbbÿaaaÿ```ÿ___ÿ___ÿ^^^ÿ]]]ÿVgvó‹ôs|ÿI}ÿB~ÿ8€ÿ0€ÿ&‚ÿ ƒÿ…ÿŒÿ‘ÿŽÿ Žÿ’ÿ”ÿ—ÿ¡ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿ sÿuÿuÿ(uÿ8tÿHsýW"Ôÿÿÿÿÿÿÿ111ÿ111ÿ111ÿ222ÿ333ÿ444ÿ555ÿ555ÿ666ÿEEEÿMMMÿMMMÿOOOÿPPPÿQQQÿRRRÿSSSÿTTTÿUUUÿUUUÿWWWÿXXXÿXXXÿZZZÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ]]]ÿ^^^ÿ___ÿ___ÿ___ÿ```ÿ```ÿaaaÿaaaÿaaaÿaaaÿaaaÿaaaÿaaaÿ```ÿ```ÿ___ÿ___ÿ___ÿ^^^ÿ]]]ÿ\\\ÿ\\\ÿ\\\ÿQeuðña~ÿ7ÿ0ÿ)‚ÿ"‚ÿƒÿ†ÿŒÿ”ÿ”ÿ ‘ÿ“ÿ•ÿšÿ£ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿtÿ"uÿ1tÿAtÿS:k‰ÿÿÿÿÿÿÿ000ÿ111ÿ111ÿ111ÿ222ÿ333ÿ444ÿ555ÿ:::ÿJJJÿLLLÿMMMÿMMMÿOOOÿPPPÿQQQÿRRRÿSSSÿSSSÿUUUÿUUUÿVVVÿWWWÿXXXÿYYYÿZZZÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ]]]ÿ]]]ÿ^^^ÿ^^^ÿ___ÿ___ÿ___ÿ___ÿ___ÿ___ÿ___ÿ___ÿ___ÿ^^^ÿ^^^ÿ]]]ÿ]]]ÿ\\\ÿ\\\ÿ\\\ÿ[[[ÿZZZÿYYYÿQdsï&“òN€ÿ'‚ÿ"ƒÿƒÿ…ÿ‡ÿ‹ÿ •ÿ—ÿ •ÿ’ÿ–ÿžÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿuÿtÿ*uÿ:tÿKmì[åÿÿÿÿÿÿ+++ÿ111ÿ111ÿ111ÿ111ÿ222ÿ333ÿ444ÿDDDÿJJJÿKKKÿLLLÿMMMÿMMMÿOOOÿPPPÿQQQÿQQQÿSSSÿSSSÿTTTÿUUUÿVVVÿWWWÿXXXÿXXXÿYYYÿZZZÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ]]]ÿ]]]ÿ]]]ÿ]]]ÿ]]]ÿ]]]ÿ]]]ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ[[[ÿZZZÿYYYÿXXXÿXXXÿWWWÿPhxè*šõ>‚ÿ„ÿ†ÿ‰ÿ‹ÿ Œÿ “ÿ ˜ÿ —ÿ”ÿ›ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿtÿ$uÿ3tÿCtÿT5]ÿÿÿÿÿÿ&&&ÿ111ÿ111ÿ111ÿ111ÿ222ÿ222ÿ777ÿHHHÿJJJÿJJJÿKKKÿLLLÿMMMÿMMMÿNNNÿPPPÿQQQÿQQQÿRRRÿSSSÿTTTÿUUUÿUUUÿVVVÿWWWÿXXXÿXXXÿYYYÿYYYÿZZZÿ[[[ÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ[[[ÿ[[[ÿZZZÿYYYÿYYYÿXXXÿXXXÿWWWÿVVVÿUUUÿUUUÿMhyå,ž÷/…ÿ‰ÿŠÿÿ ÿ ‘ÿ‘ÿ˜ÿ™ÿ ÿ£ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿtÿ+uÿ<tÿKoóYâÿÿÿÿÿÿ111ÿ111ÿ111ÿ111ÿ111ÿ222ÿ>>>ÿHHHÿIIIÿJJJÿJJJÿKKKÿLLLÿMMMÿMMMÿNNNÿOOOÿPPPÿQQQÿRRRÿSSSÿSSSÿTTTÿUUUÿUUUÿVVVÿWWWÿWWWÿXXXÿXXXÿXXXÿYYYÿYYYÿZZZÿZZZÿZZZÿZZZÿZZZÿZZZÿZZZÿZZZÿZZZÿYYYÿYYYÿXXXÿXXXÿXXXÿWWWÿWWWÿVVVÿUUUÿUUUÿTTTÿSSSÿSSSÿLetÞ7ží&‡ÿ ‹ÿ ‘ÿ •ÿ ”ÿ•ÿ˜ÿžÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿsÿsÿ$sÿ2tÿCtÿT9kˆÿÿÿÿÿÿ///ÿ111ÿ111ÿ111ÿ111ÿ111ÿBBBÿHHHÿIIIÿIIIÿJJJÿJJJÿJJJÿKKKÿMMMÿMMMÿNNNÿOOOÿPPPÿQQQÿQQQÿRRRÿSSSÿSSSÿTTTÿUUUÿUUUÿUUUÿVVVÿWWWÿWWWÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿXXXÿWWWÿWWWÿVVVÿUUUÿUUUÿUUUÿTTTÿSSSÿSSSÿRRRÿQQQÿQQQÿKeuÛ3£ò%‰ÿ ÿ–ÿ™ÿ›ÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿ*tÿ:tÿKp÷XÜÿÿÿÿÿ'''ÿ111ÿ111ÿ111ÿ111ÿ111ÿEEEÿGGGÿHHHÿHHHÿIIIÿJJJÿJJJÿJJJÿKKKÿLLLÿMMMÿMMMÿNNNÿOOOÿPPPÿQQQÿQQQÿRRRÿSSSÿSSSÿSSSÿTTTÿUUUÿUUUÿUUUÿUUUÿVVVÿVVVÿVVVÿWWWÿWWWÿWWWÿWWWÿWWWÿVVVÿVVVÿVVVÿUUUÿUUUÿUUUÿUUUÿTTTÿSSSÿSSSÿSSSÿRRRÿQQQÿQQQÿPPPÿOOOÿNNNÿDh}ס÷#Šÿÿšÿœÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿ#sÿ0tÿAtÿRF‰yþÿÿÿÿÿ111ÿ111ÿ111ÿ111ÿ111ÿFFFÿFFFÿGGGÿHHHÿHHHÿIIIÿJJJÿJJJÿJJJÿKKKÿLLLÿMMMÿMMMÿNNNÿOOOÿOOOÿPPPÿQQQÿQQQÿRRRÿRRRÿSSSÿSSSÿSSSÿTTTÿTTTÿUUUÿUUUÿUUUÿUUUÿUUUÿUUUÿUUUÿUUUÿUUUÿUUUÿUUUÿTTTÿTTTÿSSSÿSSSÿSSSÿRRRÿRRRÿQQQÿQQQÿPPPÿOOOÿOOOÿNNNÿMMMÿMMMÿEiÑ+¤÷„ÿÿ™ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿ(sÿ7tÿHtÿW!/¼ÿÿÿÿÿ,,,ÿ111ÿ111ÿ111ÿ111ÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿIIIÿJJJÿJJJÿJJJÿJJJÿKKKÿLLLÿMMMÿMMMÿNNNÿOOOÿOOOÿPPPÿQQQÿQQQÿQQQÿRRRÿRRRÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿSSSÿRRRÿRRRÿQQQÿQQQÿQQQÿPPPÿOOOÿOOOÿNNNÿMMMÿMMMÿLLLÿKKKÿJJJÿEj€Î)¤÷…ÿˆÿÿ›ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿsÿsÿ!sÿ.sÿ=tÿN^Ëbñÿÿÿÿ###ÿ111ÿ111ÿ111ÿ111ÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿIIIÿJJJÿJJJÿJJJÿJJJÿKKKÿLLLÿLLLÿMMMÿMMMÿNNNÿNNNÿOOOÿPPPÿPPPÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿRRRÿRRRÿRRRÿRRRÿRRRÿRRRÿRRRÿRRRÿQQQÿQQQÿQQQÿQQQÿQQQÿPPPÿPPPÿOOOÿNNNÿNNNÿMMMÿMMMÿLLLÿLLLÿKKKÿJJJÿJJJÿJJJÿJnƒÌ%¥ÿ|ÿ†ÿÿ™ÿŠÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿ&sÿ3sÿBtÿS9h‰þÿÿÿÿ///ÿ111ÿ111ÿ111ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿHHHÿHHHÿIIIÿJJJÿJJJÿJJJÿJJJÿKKKÿLLLÿLLLÿMMMÿMMMÿMMMÿNNNÿNNNÿOOOÿOOOÿPPPÿPPPÿPPPÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿPPPÿPPPÿPPPÿOOOÿOOOÿNNNÿNNNÿMMMÿMMMÿMMMÿLLLÿLLLÿKKKÿJJJÿJJJÿJJJÿJJJÿMMMÿQQQÿKp…×ÿzÿ|ÿ‰ÿÿƒÿsÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿ sÿsÿsÿ*sÿ8sÿGsÿV%6´ÿÿÿÿ"""ÿ111ÿ111ÿ111ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿIIIÿIIIÿJJJÿJJJÿJJJÿJJJÿKKKÿKKKÿLLLÿMMMÿMMMÿMMMÿMMMÿNNNÿNNNÿNNNÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿNNNÿNNNÿNNNÿMMMÿMMMÿMMMÿMMMÿLLLÿKKKÿKKKÿJJJÿJJJÿJJJÿJJJÿIIIÿLLLÿQQQÿPPPÿPPPÿLy’¹•ÿsÿ xÿzÿ}ÿÿsÿsÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿ"sÿ.sÿ<sÿLpùW"Ôÿÿÿÿ+++ÿ111ÿ111ÿEEEÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿHHHÿIIIÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿKKKÿKKKÿLLLÿLLLÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿMMMÿLLLÿLLLÿKKKÿKKKÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿIIIÿIIIÿQQQÿPPPÿPPPÿOOOÿOOOÿK{˜´Šÿsÿ vÿ wÿyÿsÿsÿsÿsÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿ sÿsÿsÿ%sÿ2sÿ@sÿO Xºfîÿÿÿÿ000ÿ111ÿCCCÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿHHHÿIIIÿIIIÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿKKKÿKKKÿKKKÿLLLÿLLLÿLLLÿLLLÿLLLÿMMMÿMMMÿMMMÿLLLÿLLLÿLLLÿLLLÿLLLÿKKKÿKKKÿKKKÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿIIIÿIIIÿHHHÿHHHÿMMMÿPPPÿOOOÿOOOÿOOOÿOOOÿOOOÿGw“¯†ÿuÿsÿ sÿsÿsÿsÿsÿsÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿ sÿsÿsÿ(sÿ4sÿCsÿRF‹wúÿÿÿ'''ÿ111ÿ>>>ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿHHHÿIIIÿIIIÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿKKKÿKKKÿKKKÿKKKÿKKKÿKKKÿKKKÿKKKÿKKKÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿIIIÿIIIÿHHHÿHHHÿGGGÿLLLÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿ?nŒ¥‡ÿ$zÿvÿ sÿ sÿsÿsÿsÿ¢ÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿsÿ*sÿ7sÿEsÿT7j‡ýÿÿÿ,,,ÿ777ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿHHHÿHHHÿIIIÿIIIÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿIIIÿIIIÿHHHÿHHHÿHHHÿGGGÿGGGÿJJJÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿLLLÿ###ÿQv—ˆÿ'|ÿvÿ sÿ sÿsÿsÿ¢ÿsÿsÿsÿsÿsÿ sÿsÿsÿ sÿ,sÿ8sÿFsÿU0T•ÿÿÿÿ111ÿDDDÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿGGGÿHHHÿHHHÿHHHÿIIIÿIIIÿIIIÿIIIÿIIIÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿIIIÿIIIÿIIIÿIIIÿIIIÿHHHÿHHHÿHHHÿGGGÿGGGÿGGGÿFFFÿIIIÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿ...ÿÿÿWƒ…†ÿ#yÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ"sÿ-sÿ:sÿGsÿV1U—þÿÿ###ÿ;;;ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿGGGÿGGGÿHHHÿHHHÿHHHÿHHHÿHHHÿHHHÿHHHÿIIIÿIIIÿIIIÿHHHÿHHHÿHHHÿHHHÿHHHÿHHHÿHHHÿGGGÿGGGÿGGGÿGGGÿFFFÿFFFÿFFFÿJJJÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿ888ÿÿÿÿÿY…uÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ"sÿ.sÿ:sÿHsÿU7j‡úÿÿ%%%ÿCCCÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿKKKÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿ>>>ÿÿÿÿÿÿ'/׈ÿ&yÿ|ÿ xÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ#sÿ.sÿ:sÿGsÿT=w÷ÿÿ///ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿLLLÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿEEEÿÿÿÿÿÿ(3Ó‰íE‰ÿ*ˆÿ‰ÿ…ÿ }ÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ#sÿ-sÿ9sÿFsÿSGŽvçÿÿ666ÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿMMMÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿDDDÿÿÿÿÿÿ->Ç ìMˆÿ7Šÿ-‹ÿ ŽÿŒÿ ŒÿŠÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ"sÿ,sÿ8sÿDsÿQ ]Æc&Éÿÿ555ÿIIIÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿIIIÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿ???ÿÿÿÿÿÿ<_¤÷Nÿ=„ÿ1‡ÿ'ˆÿ‹ÿÿ ŒÿŠÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ!sÿ+sÿ6sÿBsÿNsÿV-O™ûÿ000ÿJJJÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿLLLÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿ999ÿÿÿÿÿ"ðRš}wýL{ÿ@}ÿ3€ÿ(‚ÿƒÿ†ÿ…ÿÿŠÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ sÿ)sÿ3sÿ>sÿJsÿUE‡xÜÿ***ÿGGGÿJJJÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿJJJÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿNNNÿ222ÿÿÿÿÿ&6Æ _ÃgsÿKsÿ>tÿ2vÿ(yÿ|ÿ}ÿ~ÿ zÿÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ&sÿ0sÿ:sÿEsÿPkè[*G ò ÿ>>>ÿNNNÿJJJÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿJJJÿNNNÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿDDDÿ&&&ÿÿÿÿö7d’pùWsÿKsÿ?sÿ4sÿ(sÿsÿsÿvÿ xÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ#sÿ,sÿ6sÿ@sÿJsÿT Yºf$7²ü,,,ÿGGGÿOOOÿLLLÿHHHÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿIIIÿLLLÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿLLLÿ333ÿÿÿÿý#3¹ WµisÿRsÿHsÿ<sÿ2sÿ(sÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿ sÿ(sÿ0sÿ:sÿDsÿMsÿV H’t'Çü888ÿMMMÿOOOÿMMMÿKKKÿIIIÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿIIIÿKKKÿNNNÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿNNNÿ???ÿ"""ÿÿÿÿ$Ð C‡xsÿVsÿLsÿBsÿ8sÿ.sÿ&sÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ#sÿ+sÿ4sÿ<sÿEsÿNsÿVJ”t!0º !!ñ777ÿKKKÿOOOÿOOOÿOOOÿNNNÿMMMÿKKKÿJJJÿJJJÿJJJÿJJJÿJJJÿKKKÿLLLÿMMMÿNNNÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿNNNÿ<<<ÿ&&&ÿÿÿö*Á?z~sÿVsÿNsÿEsÿ<sÿ2sÿ*sÿ"sÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿ&sÿ-sÿ5sÿ=sÿFsÿNsÿV^Ëa3Z‘!'Ò...ûBBBÿNNNÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿDDDÿ555ÿ###ÿÿÿÝ'@¥ V±hsÿVsÿNsÿFsÿ=sÿ4sÿ,sÿ$sÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ sÿ&sÿ.sÿ5sÿ<sÿDsÿKsÿRsÿV P§l&=ª"&)Ü555÷DDDÿLLLÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿNNNÿFFFÿ:::ÿ%%%ÿÿþå!/»A‚zqûWsÿTsÿMsÿEsÿ=sÿ5sÿ.sÿ&sÿ sÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿ sÿ&sÿ,sÿ3sÿ:sÿ@sÿGsÿNsÿTqûWV¶g8j‡+=²+04Õ668ë<<<ùCCCÿFFFÿJJJÿLLLÿLLLÿLLLÿLLLÿKKKÿHHHÿDDDÿ>>>ÿ666ÿ+++ÿ"""ûòÙ!.¼4] G‘tjæ[sÿVsÿOsÿIsÿBsÿ;sÿ4sÿ-sÿ&sÿ sÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿ$sÿ*sÿ0sÿ6sÿ<sÿAsÿFsÿLsÿPsÿUsÿViå\V¶gC…x6dŠ,L›'=©$5²"0º!.¼!1·"1·&;­)D¡5_=w€ P¦m^ËasÿVsÿVsÿRsÿMsÿHsÿCsÿ=sÿ7sÿ1sÿ+sÿ&sÿ sÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿ"sÿ&sÿ+sÿ0sÿ5sÿ:sÿ>sÿBsÿFsÿIsÿLsÿNsÿQsÿRsÿTsÿUsÿVsÿVsÿVsÿVsÿTsÿSsÿRsÿOsÿLsÿJsÿFsÿCsÿ?sÿ:sÿ6sÿ2sÿ,sÿ(sÿ#sÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿ"sÿ&sÿ*sÿ-sÿ0sÿ4sÿ6sÿ9sÿ<sÿ>sÿ?sÿ@sÿBsÿBsÿBsÿBsÿBsÿAsÿ@sÿ>sÿ<sÿ:sÿ8sÿ4sÿ2sÿ.sÿ*sÿ'sÿ#sÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿ"sÿ$sÿ'sÿ)sÿ+sÿ-sÿ.sÿ0sÿ0sÿ1sÿ1sÿ1sÿ0sÿ0sÿ.sÿ-sÿ,sÿ*sÿ(sÿ&sÿ#sÿ sÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ!sÿ"sÿ"sÿ"sÿ"sÿ"sÿ!sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿÿÿÿð?ÿÿÿÿÿüÿÿÿÿÿ€ÿÿÿÿÿÿÿþÿÿ/üÿÿüÿÿüÿÿüÿÿþÿÿÿÿÿÿð?ÿÿÿüÿÿÿÿðÿÿÿÿÿÀÿÿÿÿÿÿ€ÿÿÿÿÿÿÿÿÿÿÿü?ÿÿÿÿüÿÿÿÿüÿÿÿÿüÿÿÿÿø€ÿÿÿÿðÀ?ÿÿÿïà€ÿÿÿ÷àÐÿÿÿÿ€ÿØÿÿÿÿûüÿÿÿþùðÿÿÿÿÄ0ÿÿÿÿ‡‡ÿÿÿσ?ÿÿÿÿ€ÿÿÿÿ€ÿÿÿÿÿÿÿþÿÿÿþÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÀÿÿÿÿàÿÿÿÿðÿÿÿàÿÿÿÀ?ÿÿÿÀ?ÿÿÿÀÿÿÿÀÿÿÿ€ÿÿÿ€ÿÿÿ€ÿÿÿ€ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿþÿÿÿÿÿþÿÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿÿ€ÿÿÿ€ÿÿÿ€ÿÿÿÀÿÿÿÀÿÿÿÀÿÿÿÀ?ÿÿÿÀ?ÿÿÿÀ?ÿÿÿÀÿÿÿàÿÿÿÿàÿÿÿÿàÿÿÿÿàÿÿÿÿàÿÿÿð?ÿÿÿð?ÿÿÿðÿÿÿøÿÿÿø(ÿÿÿø<ÿÿÿü~ÿÿÿü~ÿÿÿþÿÿÿÿþƒÿÿÿÿƒÿÿÿÿÃÿÿÿÿ€Ãÿÿÿÿ€ãÿÿÿÿÀóÿÿÿÿàûÿÿÿÿàÿÿÿÿðÿÿÿÿøÿÿÿÿøÿÿÿÿüÿÿÿÿþÿÿÿÿÿÿÿÿÿÿ€ÿÿÿÿÿÀÿÿÿÿÿÿàÿÿÿÿÿÿðÿÿÿÿÿÿøÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿÿÿÿÿÿà?ÿÿÿÿÿÿÿøÿÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿà?ÿÿÿÿÿÿÿÿÿøÿÿÿÿ(@€   !$&)+,.......,+)'%"   "/:DMU\afknqtuxyzz|||||{zyxvtrolgb]VOF<1% ¢ÿEcs}‚‡‰‹‹ŒŒŒŒCŸ3p¯@»J£ÅN­ÉM«ÉH Ã=ˆ¸-cª5šŒŒŒŒŒŒŒŒŒŒŒŒ‹‰‡ƒ~uhO ¢ÿ¢ÿ¢ÿ Oo}…‰‹ŒŒŒŒ ’6x²V¾Óhæíqûüsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿo÷ùeßçO°Ë+`¨ŒŒŒŒŒŒŒŒŒŒŒŒ‹‰†sZ &¢ÿ¢ÿ ¢ÿ!0>JS]d={P²·lïísÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿfãæE™¶!ˆ~|zwtpke^VLA4%¢ÿ¢ÿ ¢ÿ'; 9XF„lî’rýîsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿpøè\ÊŠ 2,($ ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿÿZtÿÔsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÅsÿ7¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ$„ÿ«sÿýsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿøsÿh¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ$€ÿ×sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿƒÿºsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ ƒÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ…ÿ¯sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ—¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ„ÿµsÿÿsÿÿvÿÿ zÿÿ}ÿÿ€ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ}ÿÿzÿÿvÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿt¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ‡ÿ½ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿzÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿúuÿ;¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿgÇÿ 0šÿÆ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ/Œÿÿ,Šÿÿ(ˆÿÿ$†ÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ|ÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÔ~ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ+±ÿ /™ÿÆ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ+Šÿÿ%†ÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿzÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿˆ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¡ÿÿ§ÿ-˜ÿÍ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ-‹ÿÿ%†ÿÿ‚ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ~ÿÿvÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿóxÿ#¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ ˜ÿšÿ ˜ÿ ÿ)-—ÿÖ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ(ˆÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿ xÿÿsÿÿsÿÿsÿÿsÿÿsÿÿtÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿŸÿžÿÿ•ÿ •ÿ•ÿ –ÿ1˜ÿO+–ÿà2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ*‰ÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿzÿÿsÿÿsÿÿsÿÿsÿÿsÿê~ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ›ÿ›ÿ šÿ –ÿ ÿ ÿ’ÿ“ÿ/”ÿE“ÿa˜ÿ¨(”ÿð2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ(ˆÿÿ‚ÿÿÿÿÿÿÿÿÿÿ zÿÿsÿÿsÿÿsÿÿsÿÿuÿ^¢ÿ¢ÿ¢ÿ¢ÿ”ÿ’ÿŽÿ †ÿ ˆÿÿÿ*‘ÿ@’ÿ[l·¸m¹á”ÿã)”ÿ÷2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿ"…ÿÿÿÿÿÿÿÿÿÿ xÿÿsÿÿsÿÿsÿÿtÿ¯¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿƒÿ…ÿ‚ÿ ƒÿ†ÿ‰ÿ'Œÿ9ÿQwÌšÿÿnÂíŽÿê)‘ÿø2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿÿÿÿÿÿÿÿÿwÿÿsÿÿsÿÿsÿä¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿ‹ÿ|ÿ~ÿ ~ÿÿƒÿ%†ÿ3ŠÿH…ëpùÿÿÿqÎîŒÿé*‘ÿø2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Šÿÿ‚ÿÿÿÿÿÿ€ÿÿtÿÿsÿÿsÿð¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿÿÿzÿ }ÿ~ÿ"€ÿ/„ÿAˆÿW";ÒÿÿÿÿÿsÎë–ÿæ+—ÿö2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿÿ‚ÿÿÿÿÿÿ{ÿÿsÿÿsÿî¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿ|ÿ{ÿ zÿ{ÿ|ÿ,~ÿ<ÿOG†‘ÿÿ ÿÿÿÿ"""ÿŠÖêªÿä+›ÿ÷2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿÿ‚ÿÿÿÿÿÿvÿÿsÿî¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿyÿyÿyÿyÿ%{ÿ5}ÿHqÛe ôÿÿÿÿ ÿ###ÿ&&&ÿ)))ÿ×êÀÿæ, ÿø2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Šÿÿÿÿÿÿ|ÿÿsÿî¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿ|ÿ{ÿ xÿyÿxÿ-yÿ?{ÿS5Sµÿÿÿÿÿ!!!ÿ$$$ÿ'''ÿ+++ÿ///ÿ°ÛíÍÿë,¢ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿÿÿÿÿuÿî¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿ{ÿzÿ wÿxÿ%xÿ6yÿIjÖhôÿÿÿÿÿ"""ÿ&&&ÿ)))ÿ---ÿ777ÿEHIÿÀãðÔÿí,¤ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ „ÿÿÿÿ{ÿï¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿyÿyÿwÿxÿ,xÿ=yÿQ;e›ÿÿÿÿÿ ÿ###ÿ'''ÿ***ÿ999ÿGGGÿJJJÿMSTþÂãñ Ñÿê=§ÿùC—ÿÿ>•ÿÿ8’ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿÿÿÿÿð¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿxÿ xÿwÿ!xÿ1xÿCxÿY!*Ôÿÿÿÿÿ!!!ÿ$$$ÿ'''ÿ666ÿEEEÿHHHÿLLLÿPPPÿSTUÿ½ãìÉÿâB¥ÿ÷GšÿÿGšÿÿD˜ÿÿ>•ÿÿ5ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ$†ÿÿÿñ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿwÿ wÿwÿ%wÿ6wÿIh×fõÿÿÿÿÿ!!!ÿ%%%ÿ111ÿBBBÿEEEÿIIIÿMMMÿQQQÿUUUÿV^_ýºéá¾ÿÛC¤ÿõGšÿÿGšÿÿGšÿÿF™ÿÿ>•ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿ‚ÿñ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿwÿwÿ)wÿ:wÿMJŒÿÿÿÿÿÿ"""ÿ***ÿ???ÿBBBÿFFFÿJJJÿMMMÿRRRÿUUUÿZZZÿ\bdý²éعÿÔC¤ÿóGšÿÿGšÿÿGšÿÿGšÿÿE™ÿÿ9’ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿƒÿñ¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿwÿvÿ+wÿ>wÿQ3V¡ÿÿÿÿÿÿ"""ÿ777ÿ???ÿBBBÿFFFÿJJJÿNNNÿSSSÿVVVÿ[[[ÿ^^^ÿ^fgü°ëÖ¹ÿÖC¤ÿöGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ=”ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ#†ÿó¢ÿ¢ÿ ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿvÿvÿ-wÿ@wÿT';¹ÿÿÿÿÿÿ,,,ÿ<<<ÿ???ÿCCCÿFFFÿJJJÿNNNÿSSSÿVVVÿ[[[ÿ^^^ÿcccÿbknû¶îÛÁÿÞC¥ÿúGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ=”ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ#‡ÿߢÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿvÿvÿ.wÿBwÿV +Íÿÿÿÿÿ ÿ666ÿ<<<ÿ???ÿBBBÿFFFÿJJJÿNNNÿSSSÿVVVÿ[[[ÿ^^^ÿcccÿeeeÿdnqü¾ðäÇÿæB¤ÿúGšÿÿGšÿÿGšÿÿGšÿÿGšÿÿ;“ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ„ÿ£¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿvÿ vÿ0vÿCvÿW#Ûÿÿÿÿÿ'''ÿ999ÿ<<<ÿ???ÿBBBÿFFFÿJJJÿMMMÿRRRÿUUUÿZZZÿ]]]ÿbbbÿeeeÿhhhÿfrvüÊòìÐÿìC¦ÿúGšÿÿGšÿÿGšÿÿGšÿÿF™ÿÿ5ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.ŒÿÿÿQ¡ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿvÿ uÿ0vÿDvÿX âÿÿÿÿÿ///ÿ888ÿ;;;ÿ>>>ÿBBBÿEEEÿIIIÿMMMÿQQQÿUUUÿYYYÿ\\\ÿ```ÿdddÿfffÿjjjÿewzüÎòíÎÿíC¤ÿúGšÿÿGšÿÿGšÿÿGšÿÿ@–ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ#†ÿ×–ÿŸÿ¡ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿvÿvÿ uÿ0vÿCvÿW"Ûÿÿÿÿÿ444ÿ888ÿ:::ÿ===ÿAAAÿEEEÿHHHÿLLLÿPPPÿSSSÿWWWÿ[[[ÿ^^^ÿbbbÿeeeÿgggÿjjjÿfuxýÊôìÈÿíC¢ÿúGšÿÿGšÿÿGšÿÿGšÿÿ5ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿÿ{™ÿÿ ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿuÿuÿ/uÿBvÿW(Íÿÿÿÿ ÿ555ÿ777ÿ999ÿ===ÿ@@@ÿCCCÿGGGÿJJJÿNNNÿRRRÿUUUÿYYYÿ\\\ÿ___ÿeeeÿkkkÿoooÿtttÿl€„üÅõêºÿêD ÿúGšÿÿGšÿÿGšÿÿ<”ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ!…ÿàŒÿ%–ÿšÿžÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿuÿuÿ-tÿ@uÿU%5¹ÿÿÿÿ$$$ÿ444ÿ666ÿ999ÿ<<<ÿ???ÿBBBÿEEEÿIIIÿLLLÿPPPÿSSSÿXXXÿbbbÿjjjÿoooÿrrrÿtttÿuuuÿuuuÿl~…û±ôç©ÿéDÿúGšÿÿGšÿÿ@–ÿÿ2Žÿÿ2Žÿÿ-‹ÿü €ÿkŽÿ “ÿ˜ÿ ÿ¡ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿsÿuÿ+tÿ=uÿQ0PŸÿÿÿÿ'''ÿ333ÿ555ÿ888ÿ:::ÿ===ÿAAAÿDDDÿGGGÿJJJÿPPPÿ\\\ÿeeeÿhhhÿkkkÿmmmÿnnnÿpppÿrrrÿsssÿsssÿizƒúŸöç—ÿìDšÿûGšÿÿC—ÿÿ2Žÿÿ2Žÿÿ„ÿ³…ÿ0Šÿ ÿ–ÿ ›ÿ¡ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿ sÿtÿ'uÿ:uÿNC€ÿÿÿÿ)))ÿ222ÿ555ÿ777ÿ999ÿ<<<ÿ???ÿBBBÿEEEÿQQQÿ]]]ÿ```ÿdddÿeeeÿgggÿjjjÿlllÿmmmÿnnnÿnnnÿnnnÿnnnÿduúŒöéÿîDšÿûD˜ÿÿ2Žÿÿ!‡ÿåÿKƒÿ.ˆÿŽÿ”ÿ ™ÿ ÿ¢ÿ¢ÿ¢ÿsÿsÿsÿ sÿtÿ#uÿ6tÿHaÍdøÿÿÿ)))ÿ222ÿ444ÿ555ÿ888ÿ:::ÿ===ÿBBBÿRRRÿXXXÿ\\\ÿ]]]ÿ```ÿcccÿeeeÿfffÿhhhÿjjjÿkkkÿlllÿlllÿlllÿkkkÿ`q€ú†÷èÿë@˜ÿû&ˆÿözÿpÿ>‚ÿ*ˆÿÿ’ÿ ™ÿ ÿ¢ÿ¢ÿsÿsÿsÿ sÿsÿtÿ0tÿCtÿW#Ôÿÿÿ'''ÿ111ÿ222ÿ555ÿ666ÿ999ÿ===ÿMMMÿTTTÿVVVÿYYYÿ\\\ÿ]]]ÿ___ÿbbbÿdddÿeeeÿfffÿfffÿgggÿgggÿgggÿfffÿfffÿZl{úŒ÷ß‹ÿÈ ~ÿŽ|ÿNÿ6‚ÿ#‰ÿŽÿ’ÿ›ÿ¡ÿ¢ÿ¢ÿsÿsÿsÿsÿsÿsÿ*tÿ>tÿQ/P›ÿÿÿ%%%ÿ111ÿ111ÿ333ÿ555ÿ888ÿIIIÿPPPÿRRRÿTTTÿVVVÿXXXÿ[[[ÿ\\\ÿ^^^ÿ```ÿbbbÿcccÿdddÿeeeÿeeeÿeeeÿdddÿcccÿbbbÿWk{÷ŠõŸ{ÿU}ÿ?€ÿ+‚ÿŠÿŒÿ ’ÿšÿ¢ÿ¢ÿ¢ÿsÿsÿsÿ sÿsÿ$tÿ6tÿI [Àfùÿÿ!!!ÿ111ÿ111ÿ222ÿ444ÿ???ÿLLLÿMMMÿPPPÿRRRÿTTTÿVVVÿXXXÿZZZÿ\\\ÿ\\\ÿ^^^ÿ___ÿ___ÿ```ÿ```ÿ```ÿ___ÿ___ÿ^^^ÿ\\\ÿTguòŽóf~ÿ2€ÿ"‚ÿŒÿÿ “ÿžÿ¢ÿ¢ÿ ¢ÿ¢ÿsÿsÿsÿ sÿsÿsÿ.tÿAtÿU".Àÿÿÿ000ÿ111ÿ111ÿ555ÿHHHÿJJJÿLLLÿMMMÿPPPÿRRRÿSSSÿUUUÿWWWÿXXXÿZZZÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ\\\ÿ[[[ÿZZZÿXXXÿPdsï*”íL€ÿƒÿ‡ÿ ’ÿ ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿsÿsÿsÿsÿsÿsÿ'sÿ8tÿL P¥nûÿÿ---ÿ111ÿ111ÿ;;;ÿHHHÿJJJÿJJJÿLLLÿMMMÿOOOÿQQQÿSSSÿTTTÿUUUÿVVVÿXXXÿXXXÿYYYÿYYYÿYYYÿYYYÿYYYÿXXXÿXXXÿVVVÿUUUÿTTTÿMaoê/™ì=}ÿ†ÿƒÿŒÿ‹ÿsÿ¢ÿ ¢ÿ¢ÿsÿsÿsÿ sÿsÿ sÿ0sÿAtÿU"1¹ÿÿ&&&ÿ111ÿ111ÿAAAÿFFFÿHHHÿIIIÿJJJÿKKKÿMMMÿNNNÿPPPÿQQQÿSSSÿSSSÿTTTÿUUUÿUUUÿUUUÿVVVÿUUUÿUUUÿUUUÿTTTÿSSSÿSSSÿQQQÿPPPÿJ`oç.šï9zÿÿ}ÿsÿsÿsÿÿžÿ ¢ÿsÿsÿsÿsÿsÿsÿ'sÿ8tÿK cÑbðÿÿ000ÿ111ÿDDDÿFFFÿFFFÿGGGÿIIIÿJJJÿJJJÿLLLÿMMMÿNNNÿPPPÿQQQÿQQQÿRRRÿSSSÿSSSÿSSSÿSSSÿSSSÿRRRÿQQQÿQQQÿPPPÿNNNÿMMMÿLLLÿF\hè(˜î:vÿ{ÿsÿ sÿsÿsÿ™ÿÿ¢ÿsÿsÿsÿsÿ sÿsÿsÿ.sÿ>sÿP;mˆÿÿ)))ÿ111ÿEEEÿFFFÿFFFÿFFFÿGGGÿHHHÿJJJÿJJJÿKKKÿLLLÿMMMÿMMMÿNNNÿOOOÿPPPÿPPPÿPPPÿPPPÿPPPÿOOOÿNNNÿMMMÿMMMÿLLLÿKKKÿJJJÿJJJÿKcqæ<¡ô?sÿuÿsÿ sÿsÿ}ÿ•ÿ—ÿsÿsÿsÿsÿsÿsÿ$sÿ4sÿDsÿV%8±ÿÿ000ÿBBBÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿIIIÿJJJÿJJJÿJJJÿKKKÿLLLÿLLLÿMMMÿMMMÿMMMÿMMMÿMMMÿLLLÿLLLÿKKKÿJJJÿJJJÿJJJÿIIIÿKKKÿOOOÿNdqà;ô<sÿsÿsÿ sÿsÿÿ—ÿsÿsÿsÿsÿ sÿsÿsÿ)sÿ8sÿInðZ$Ðÿ$$$ÿ===ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿIIIÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿJJJÿIIIÿHHHÿGGGÿJJJÿOOOÿOOOÿOOOÿK`oÚ ‰õ7sÿsÿsÿ sÿsÿŠÿsÿsÿsÿsÿ sÿsÿsÿ,sÿ<sÿLeÚ^!Öÿ000ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿHHHÿHHHÿIIIÿIIIÿIIIÿIIIÿIIIÿHHHÿHHHÿGGGÿGGGÿFFFÿHHHÿOOOÿOOOÿOOOÿNNNÿ...ÿ3CÊ„ê0sÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ"sÿ.sÿ>sÿLgà]'Èÿ:::ÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿIIIÿOOOÿOOOÿOOOÿOOOÿ666ÿÿÿa˜c{ÿuÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ#sÿ0sÿ=sÿLo÷W#4¶ÿ???ÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿJJJÿOOOÿOOOÿOOOÿOOOÿ666ÿÿüUŒqˆÿ4†ÿ"ÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ#sÿ.sÿ<sÿIsÿV3\‘ñ;;;ÿIIIÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿHHHÿMMMÿOOOÿOOOÿOOOÿMMMÿ111ÿÿ",Õ\¯Zzÿ4~ÿ'~ÿ{ÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿ"sÿ,sÿ8sÿEsÿR [Áe#1º///ûIIIÿJJJÿGGGÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿHHHÿLLLÿOOOÿOOOÿOOOÿOOOÿDDDÿ%%%ÿù,F©gßOsÿ8sÿ*sÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ)sÿ4sÿ?sÿJsÿV Kšr'2Ã999ùLLLÿMMMÿJJJÿIIIÿGGGÿGGGÿGGGÿHHHÿJJJÿLLLÿNNNÿOOOÿOOOÿOOOÿOOOÿGGGÿ111ÿ÷"0¼ P§lsÿKsÿ=sÿ0sÿ#sÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ$sÿ.sÿ8sÿBsÿLsÿVW¶g 4O¥58<áCCCúNNNÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿOOOÿKKKÿ???ÿ---ú!Þ)D¢ Z½esÿSsÿHsÿ<sÿ1sÿ&sÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ'sÿ0sÿ9sÿBsÿJsÿRqûW U¯i!ErŒ,>R°6=EË=@DÜ?ACä?ABè:=@å26;Û*19È.B®7g‰ T¯jpùWsÿRsÿIsÿ@sÿ6sÿ-sÿ$sÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿ sÿ(sÿ/sÿ6sÿ=sÿDsÿJsÿNsÿRsÿVsÿVsÿVsÿVsÿVsÿVsÿVsÿSsÿNsÿJsÿDsÿ=sÿ6sÿ.sÿ&sÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿsÿ%sÿ+sÿ0sÿ5sÿ9sÿ<sÿ@sÿBsÿBsÿCsÿBsÿBsÿ@sÿ<sÿ9sÿ5sÿ0sÿ*sÿ$sÿsÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿsÿsÿsÿsÿ sÿ$sÿ'sÿ*sÿ,sÿ.sÿ/sÿ/sÿ/sÿ.sÿ,sÿ*sÿ'sÿ$sÿ sÿsÿsÿsÿsÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿsÿ sÿ sÿsÿsÿsÿsÿsÿÿøÿÿÿÿÿÿàÿà?ÿÿ€ÿÿÿÿÿÿ0ÿÿœx?ÿøüÿñäÿùÿÿ€ÿÿÿÿÿÿÿÿÀÿÿ€ÿÿÿÿ?þ?þ?þ?ü?ü?üüüüü?ü?ü?ü?ü?üüüüÿüÿüÿþþþ?ÿ?ÿÿÿ€ÿ€ÿÀÿÀÿàÿðÿðÿøÿüÿþ?ÿÿ?ÿÿÀÿÿàÿÿÿøÿ(0`  "'+/35799999753/,'" 6IXclsx}€‚„…‡ˆˆˆˆˆˆˆ‡…„‚€}yslcXJ6¢ÿCu…ŒŒŒŒ‘3r°V¿Ôhçínõ÷nõ÷nõ÷nõ÷nõ÷nõ÷nóöcÜåL¨È%Q£ŒŒŒŒŒŒŒŒŒŒŒ†vF ¢ÿ #4CO'bQ²«kíésÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsþþdÝà;‚§yvsnibYPD5#¢ÿ ¢ÿvùYsý×sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿnôÂRµG ¢ÿ¢ÿŽÿ}ÿ«sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿósÿh¢ÿ¢ÿ¢ÿ¢ÿ€ÿ«sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿˆ¢ÿ¢ÿ¢ÿ¢ÿŽÿ7{ÿäsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿŽ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‘ÿ,{ÿåtÿÿvÿÿzÿÿ}ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿ€ÿÿÿÿ{ÿÿ wÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿs¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿ,„ÿçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿ{ÿÿuÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿøuÿ:¢ÿ¢ÿ¢ÿ¢ÿœÿ3(Žÿì1ÿÿ0ÿÿ0ÿÿ0ÿÿ0ÿÿ0ÿÿ/Œÿÿ*‰ÿÿ$†ÿÿƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿ{ÿÿtÿÿsÿÿsÿÿsÿÿsÿÿsÿÐ~ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ÿšÿ9,ÿî2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.‹ÿÿ'‡ÿÿƒÿÿÿÿÿÿÿÿÿÿ€ÿÿ wÿÿsÿÿsÿÿsÿÿsÿÿtÿh¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ÿšÿ—ÿM+ÿñ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ+Šÿÿ!„ÿÿÿÿÿÿÿÿÿÿzÿÿsÿÿsÿÿsÿÿsÿÝ€ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ ¢ÿ  ÿ šÿ˜ÿ–ÿ6 ”ÿ~)ÿö2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿÿƒÿÿÿÿÿÿÿÿ{ÿÿsÿÿsÿÿsÿÿuÿT¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿœÿ šÿ—ÿ-•ÿP–ÿ¦“ÿß)Žÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ'‡ÿÿÿÿÿÿÿÿ{ÿÿsÿÿsÿÿtÿ¦¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ™ÿ’ÿ’ÿ$’ÿBtÀ¤ÿg²íŠÿë)Œÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿƒÿÿÿÿÿÿ xÿÿsÿÿsÿã¢ÿ¢ÿ¢ÿ¢ÿ¢ÿšÿÿ †ÿ ˆÿ@ávýÿÿd´ïŠÿé)ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ „ÿÿÿÿ€ÿÿuÿÿsÿþ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ…ÿ‚ÿÿ@€ýl '>áÿÿÿ"""ÿv½íœÿç)‘ÿú2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ „ÿÿÿÿ|ÿÿsÿÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿ~ÿzÿ2zÿh O‘­ÿ$$$ÿ'''ÿ***ÿ---ÿ000ÿŒÂëµÿç+”ÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ‚ÿÿÿÿvÿÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿÿzÿ"xÿSoæ„&*0ô'''ÿ'''ÿ(((ÿ+++ÿ///ÿ111ÿ555ÿ¡ÆîÄÿí+•ÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Šÿÿÿÿ|ÿÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ|ÿwÿ6wÿtBsª'''ÿ'''ÿ'''ÿ***ÿ---ÿ000ÿ444ÿEEEÿNNNÿ(²ÏóÇÿî2—ÿû<“ÿÿ6ÿÿ3Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ%†ÿÿ€ÿÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ‹ÿxÿwÿJwþy *2Ý'''ÿ'''ÿ(((ÿ+++ÿ...ÿ222ÿDDDÿMMMÿRRRÿUUUÿ)²Ñï ¿ÿå<šÿúGšÿÿD˜ÿÿ<”ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿ€ÿÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ€ÿwÿ%vÿ\bÌ„''(ú'''ÿ'''ÿ(((ÿ+++ÿ///ÿAAAÿKKKÿOOOÿSSSÿWWWÿ\\\ÿ,¬Ôä µÿÛ=šÿúGšÿÿGšÿÿF™ÿÿ=”ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ!„ÿÿ¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿ¢ÿ|ÿ vÿ-vÿkH‡›'''ÿ'''ÿ'''ÿ)))ÿ,,,ÿ888ÿHHHÿLLLÿPPPÿTTTÿYYYÿ\\\ÿaaaÿ.§ÕÛ ¯ÿ×<™ÿúGšÿÿGšÿÿGšÿÿC—ÿÿ6ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿø¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿzÿvÿ4uÿt8Z²'''ÿ'''ÿ'''ÿ)))ÿ...ÿCCCÿIIIÿLLLÿQQQÿUUUÿZZZÿ]]]ÿcccÿfffÿ,«ÙÝ µÿß>›ÿûGšÿÿGšÿÿGšÿÿE™ÿÿ7‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Žÿ×¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿyÿuÿ:uÿw0EÂ'''ÿ'''ÿ'''ÿ)))ÿ777ÿEEEÿIIIÿMMMÿQQQÿUUUÿZZZÿ^^^ÿcccÿfffÿkkkÿ+µÜæ ¾ÿê>œÿüGšÿÿGšÿÿGšÿÿD˜ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ,Žÿ•¢ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿxÿuÿ<uÿw+:Ì'''ÿ'''ÿ'''ÿ***ÿ???ÿEEEÿIIIÿLLLÿQQQÿUUUÿZZZÿ]]]ÿcccÿfffÿkkkÿnnnÿ*¾ßï Âÿð>œÿüGšÿÿGšÿÿGšÿÿ@–ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿú‘ÿB ÿ¢ÿ ¢ÿ¢ÿ¢ÿ¢ÿvÿuÿ<uÿw+;Ë'''ÿ'''ÿ'''ÿ///ÿBBBÿEEEÿHHHÿLLLÿPPPÿTTTÿYYYÿ\\\ÿaaaÿeeeÿiiiÿmmmÿoooÿ)Ááñ¾ÿí>šÿüGšÿÿGšÿÿF™ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ.Žÿ½™ÿÿ¡ÿ¢ÿ¢ÿ¢ÿvÿuÿ9uÿv/DÀ'''ÿ'''ÿ'''ÿ222ÿAAAÿDDDÿGGGÿKKKÿOOOÿSSSÿWWWÿ\\\ÿ___ÿeeeÿkkkÿsssÿxxxÿ{{{ÿ3¼äì¯ÿèAšÿüGšÿÿE™ÿÿ2Žÿÿ2Žÿÿ2ŽÿúÿQ”ÿšÿ ÿ¢ÿ¢ÿ¢ÿsÿ uÿ3tÿs6Z®'''ÿ'''ÿ'''ÿ666ÿAAAÿCCCÿFFFÿJJJÿMMMÿRRRÿUUUÿ]]]ÿfffÿpppÿuuuÿvvvÿxxxÿzzzÿzz{ÿ2ªäé—ÿéA˜ÿýGšÿÿ2Žÿÿ2Žÿÿ%Œÿ©ˆÿ)ÿ—ÿ žÿ¢ÿ¢ÿ¢ÿsÿuÿ,tÿfI‰•'''ÿ'''ÿ'''ÿ777ÿ@@@ÿBBBÿEEEÿHHHÿLLLÿPPPÿ]]]ÿgggÿlllÿnnnÿqqqÿtttÿuuuÿvvvÿvvvÿuvwÿ/”ãìˆÿî?–ÿý2Žÿÿ'Œÿã€ÿE…ÿ'ÿ”ÿ ›ÿ¢ÿ¢ÿsÿtÿ"tÿXdÑ'''ù'''ÿ'''ÿ888ÿ>>>ÿAAAÿDDDÿFFFÿLLLÿ\\\ÿcccÿeeeÿhhhÿlllÿmmmÿoooÿqqqÿsssÿsssÿsssÿprsÿ-Œæì‡ÿê$‹ÿì €ÿuÿ=„ÿ"‹ÿ’ÿ›ÿ¢ÿ¢ÿsÿsÿtÿGtþu!'0Ø'''ÿ'''ÿ666ÿ===ÿ@@@ÿBBBÿGGGÿXXXÿ]]]ÿ```ÿcccÿeeeÿhhhÿkkkÿmmmÿmmmÿnnnÿnnnÿnnnÿmmmÿlmnþ-ŽäÝ€ÿ„{ÿMÿ0…ÿŒÿ’ÿŸÿ¢ÿsÿ sÿ2tÿr;k¢'''ÿ'''ÿ222ÿ===ÿ>>>ÿAAAÿRRRÿXXXÿ\\\ÿ]]]ÿ```ÿcccÿeeeÿfffÿhhhÿjjjÿkkkÿkkkÿkkkÿjjjÿhhhÿfhjý:ØŸ}ÿ7ÿ!†ÿÿ “ÿ ÿ¢ÿ¢ÿsÿsÿ tÿUiá{%&'ó'''ÿ...ÿ===ÿ===ÿEEEÿUUUÿVVVÿYYYÿ\\\ÿ]]]ÿ___ÿaaaÿdddÿeeeÿeeeÿfffÿfffÿfffÿeeeÿeeeÿdddÿ`cdýG˜Ñ€ƒÿˆÿ •ÿ›ÿ¢ÿ¢ÿ¢ÿ ¢ÿsÿsÿsÿ8sÿu6Y¯'''ÿ)))ÿ<<<ÿ===ÿJJJÿSSSÿUUUÿVVVÿXXXÿ[[[ÿ\\\ÿ^^^ÿ___ÿaaaÿbbbÿcccÿcccÿcccÿbbbÿaaaÿ___ÿ^^^ÿ\^_üN›ÊrŒÿ—ÿ ÿ¢ÿ¢ÿ¢ÿsÿsÿ"sÿTkèz#%'é'''ÿ555ÿ===ÿNNNÿRRRÿSSSÿUUUÿVVVÿXXXÿYYYÿ[[[ÿ\\\ÿ]]]ÿ^^^ÿ^^^ÿ___ÿ^^^ÿ^^^ÿ]]]ÿ\\\ÿ[[[ÿYYYÿW[\ûKšÉmžÿ¢ÿ¢ÿsÿsÿsÿ4sÿlI'''þ+++ÿ===ÿOOOÿQQQÿQQQÿSSSÿTTTÿUUUÿWWWÿXXXÿYYYÿZZZÿ[[[ÿ\\\ÿ\\\ÿ\\\ÿ[[[ÿZZZÿYYYÿXXXÿWWWÿUUUÿZ[]ûV¢Îj¢ÿ¢ÿsÿsÿsÿBsÿt2S¯'''ÿ333ÿJJJÿQQQÿQQQÿQQQÿRRRÿSSSÿTTTÿUUUÿVVVÿWWWÿXXXÿXXXÿXXXÿXXXÿXXXÿWWWÿVVVÿUUUÿTTTÿVVVÿ[[[ÿ\_aúX Ïjsÿ sÿ¢ÿsÿsÿ sÿ"sÿMsÿt,@À(((ÿAAAÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿSSSÿTTTÿTTTÿUUUÿUUUÿUUUÿUUUÿUUUÿTTTÿTTTÿSSSÿUUUÿZZZÿZZZÿZZZÿ@DFöx¾]sÿsÿsÿsÿ sÿ)sÿVrüu,A¼,,,ÿKKKÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿRRRÿSSSÿSSSÿSSSÿSSSÿSSSÿRRRÿRRRÿTTTÿZZZÿZZZÿZZZÿEEEÿ'''ÿ'7C܃ÿ(ÿsÿsÿsÿ+sÿTsÿt8a§///úLLLÿRRRÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿVVVÿZZZÿZZZÿZZZÿCCCÿ'''ÿ#:TÓ{ëk‚ÿ2†ÿsÿsÿsÿsÿ(sÿJsÿt P¦‰%*1ÚGGGÿTTTÿRRRÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿQQQÿRRRÿUUUÿYYYÿZZZÿZZZÿVVVÿ;;;ÿ''(ú>k¬pövtÿHvÿxÿsÿsÿsÿ sÿsÿ?sÿgpùu?wœ47<áMMMÿVVVÿUUUÿTTTÿTTTÿTTTÿUUUÿWWWÿYYYÿZZZÿZZZÿVVVÿCCCÿ--.ú*:É U¯†sÿqsÿIsÿ&sÿsÿsÿsÿ sÿsÿ0sÿNsÿorüuOžŒ,=S¿@BFæMMMùSSSÿVVVÿWWWÿUUUÿRRRÿHHHÿ999ó)/6Ø4X« [¿‚sÿtsÿZsÿ8sÿsÿ sÿsÿsÿsÿsÿsÿ2sÿJsÿcsÿthãz R§Š?vœ5Zª1N³2P±6_§D— W·„oówsÿtsÿZsÿ>sÿ&sÿsÿsÿsÿsÿsÿ sÿsÿ*sÿ;sÿMsÿ]sÿhsÿosÿssÿssÿnsÿesÿYsÿIsÿ6sÿ$sÿsÿ sÿsÿsÿsÿsÿ sÿsÿsÿ$sÿ,sÿ1sÿ3sÿ2sÿ0sÿ*sÿ"sÿsÿsÿsÿsÿÿÿø?x?x?€ÿ~ÿÿx?ÿyÿ±€ÿÃÀÿçàÿü€ÿüÿüü?þ?þüüüüøüøüüüüüüü?ü?üþ?þþÿÏÿÏÿ€oÿ€?ÿÀ?ÿà?ÿà?ÿð?ÿüÿþÿÿÿ€ÿÿÿàÿ( @ ¢ÿ <[iry}€ƒ„…………„ƒ€}ysi[> ¢ÿ¢ÿ >[g&y/h•S¸ÃkììsÿÿsÿÿsÿÿsÿÿlïïU¼Ê2n¢'Š}zvpg[@¢ÿ ¢ÿ9XyÚqáRqö³sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿmòÅTº_9% ¢ÿ¢ÿ¢ÿ„ÿuÿøsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿüsÿxsÿ ¢ÿ¢ÿ¢ÿ~ÿuÿ÷sÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿÿsÿ‰sÿ ¢ÿ¢ÿ€ÿqyÿôzÿÿ|ÿÿÿÿÿÿ€ÿÿÿÿ}ÿÿ{ÿÿ xÿÿvÿÿtÿÿsÿÿsÿÿsÿÿsÿlsÿ.–ÿ{0ÿö.‹ÿÿ,Šÿÿ)‰ÿÿ&‡ÿÿ"…ÿÿƒÿÿ‚ÿÿÿÿ€ÿÿ{ÿÿvÿÿsÿÿsÿÿsÿïuÿ4Šÿ¢ÿ¢ÿ¢ÿMºÿ 2šÿ‰3‘ÿ÷2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ)‰ÿÿ#…ÿÿƒÿÿÿÿÿÿ xÿÿtÿÿsÿÿtÿzÿ¢ÿ¢ÿ¢ÿ›ÿ –ÿ–ÿ4"—ÿÆ0ÿû2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ-‹ÿÿ%†ÿÿ‚ÿÿÿÿ zÿÿtÿÿsÿôwÿ.¢ÿsÿzÿ}ÿ#‡ÿ?•ÿ‰•ÿÙ‘ÿó0ÿý2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ+Šÿÿ!„ÿÿÿÿ yÿÿsÿÿuÿd¢ÿ¢ÿsÿsÿvÿ-yÿZ~÷….QãÿWò‘ýñ0ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0Œÿÿ#…ÿÿÿÿvÿÿtÿš¢ÿ¢ÿsÿvÿ"vÿ[vú§ T£Ì ÿÿÿr¦ï¨ýï0“ÿü2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ0ÿÿ"…ÿÿ}ÿÿvÿ¹¢ÿ¢ÿ¢ÿsÿ uÿ5uÿ‚cË´!+òÿÿ$$$ÿ000ÿ0™²ò+¼ýô7˜ÿü:’ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ/Œÿÿƒÿÿ yÿâÿ ¢ÿ¢ÿsÿuÿFuÿ B|Âÿÿÿ'''ÿ999ÿJJKÿ4£¸ô+¸þï?šÿû>•ÿÿ7‘ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ2Žÿÿ(ˆÿÿ€ÿ¼¢ÿ ¢ÿ¢ÿsÿuÿRuÿ­+DÖÿÿ!!!ÿ111ÿDDDÿLLLÿTUUÿ<œ»é1°þåGÿûD˜ÿÿ<”ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ1ÿÿ…ÿŸ¢ÿ ¢ÿ¢ÿsÿuÿZuÿ­",èÿÿ'''ÿ<<<ÿEEEÿMMMÿUUUÿ\__þ@˜ºã-´þèEÿüGšÿÿ@–ÿÿ4ÿÿ2Žÿÿ2Žÿÿ2Žÿÿ‰ÿk¢ÿ ¢ÿ¢ÿsÿtÿ^uÿ­ õÿÿ///ÿ===ÿDDDÿLLLÿTTTÿ\\\ÿdeeþ?¥Àí-¾þôEÿýGšÿÿ=”ÿÿ2Žÿÿ2Žÿÿ3ÿñÿ:¢ÿ ¢ÿ¢ÿsÿtÿatÿ­÷ÿÿ222ÿ<<<ÿBBBÿJJJÿRRRÿZZZÿaaaÿeijþ>¬Áô+ºþôGœÿýF™ÿÿ2Žÿÿ2Žÿÿ1’ÿ¦ “ÿ¡ÿ¢ÿ¢ÿsÿtÿ`tÿ¬"ìÿÿ555ÿ:::ÿ@@@ÿGGGÿPPPÿ]]]ÿiiiÿpppÿqvvþO¥Åï1§þðG›ÿý2Žÿÿ2ÿíÿS•ÿŸÿ¢ÿ¢ÿsÿsÿYtÿ¬".Úÿÿ333ÿ888ÿ===ÿEEEÿUUUÿ```ÿfffÿkkkÿmmmÿlprýHŽÁï3–ÿõ4‘ÿø$ŒÿŸ…ÿ*ÿ›ÿ£ÿsÿsÿMtÿ¬3ZÄÿÿ111ÿ555ÿ===ÿMMMÿWWWÿ\\\ÿ```ÿdddÿeeeÿfffÿdgkýD‚»î …ÿ¢}ÿH…ÿ Žÿ Ÿÿ¢ÿsÿ sÿ;sÿ R¨´úÿ000ÿ222ÿCCCÿNNNÿSSSÿVVVÿZZZÿ\\\ÿ^^^ÿ___ÿ^^^ÿ\^aûF€®Ô“ÿK…ÿÿ ÿ¢ÿ ¢ÿsÿsÿ'sÿmmì¬'=Ñÿ---ÿ111ÿGGGÿJJJÿMMMÿQQQÿSSSÿUUUÿWWWÿXXXÿWWWÿUUUÿSUWûG€¤Ç¥ÿ2ÿ¢ÿ¢ÿsÿsÿsÿGsÿ U²²ñ'''ÿ111ÿFFFÿGGGÿJJJÿLLLÿNNNÿPPPÿQQQÿQQQÿQQQÿPPPÿNNNÿLNPûH€¡Ã"¤ÿ5sÿsÿ¢ÿsÿsÿ(sÿiqû«?{¼ÿ...ÿFFFÿFFFÿFFFÿHHHÿJJJÿJJJÿKKKÿKKKÿKKKÿJJJÿJJJÿIIIÿMQSûO€¢ÀŠû<sÿsÿsÿsÿsÿ7sÿqø«7gÁ###ÿBBBÿFFFÿFFFÿFFFÿFFFÿFFFÿGGGÿGGGÿGGGÿFFFÿGGGÿMMMÿOOOÿ>@AýU‹žÿ(sÿ sÿsÿsÿBsÿ†qù«E‡º,-.óEEEÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿFFFÿHHHÿNNNÿOOOÿ>>>ÿ2Jç n߆vÿ4sÿ sÿsÿsÿBsÿ~rü«bЮ$9SÎ@@@ùIIIÿGGGÿGGGÿGGGÿJJJÿMMMÿOOOÿJJJÿ234ô??ùDsÌ cÑ–sû=sÿsÿsÿsÿLsþ‰mížX«´.NuÑ:RpÝ;Snà/LnÖKˆÁcÔ§rýsÿRsÿsÿsÿsÿsÿsÿ0sÿOsÿnsÿsÿ‡sÿˆsÿƒsÿxsÿ_sÿ7sÿsÿsÿsÿsÿsÿsÿ(sÿ0sÿ1sÿ,sÿ!sÿsÿsÿ   àøààààààààààààààððüüÿ(  ¢ÿ¢ÿ ¢ÿ¢ÿ^+]R¶ÃbÚßbÙà]Î×B‘´‡ymD¢ÿ ‚ÿxtÿÝsÿÿsÿÿsÿÿsÿÿsÿøsÿ sÿ¢ÿ€ÿ| xÿû|ÿÿ}ÿÿ|ÿÿ{ÿÿ wÿÿtÿÿsÿÁsÿyÿsÿ $’ÿz0ÿù-‹ÿÿ*‰ÿÿ$†ÿÿÿÿ{ÿÿtÿÿtÿŽsÿsÿ zÿ&…ÿO”ÿÜ1ÿý2Žÿÿ2Žÿÿ/Œÿÿ&‡ÿÿ~ÿÿtÿé¢ÿsÿsÿtÿC Z ¬"1ûŒâö0‘ÿü2Žÿÿ2Žÿÿ2Žÿÿ*‰ÿÿ|ÿþ¢ÿ¢ÿsÿsÿ%vÿ\#,íÿ%/2ý,³âö;˜ÿû6ÿÿ2Žÿÿ2Žÿÿ'ˆÿÿ¢ÿ ¢ÿsÿ sÿ+wÿjÿ ÿ999ÿELNü4¨áêBœÿú<“ÿÿ2Žÿÿ0ÿú¢ÿ¢ÿsÿ sÿ.vÿmÿ...ÿGGGÿ\\\ÿdhjý3ºäôCÿü2Žÿÿ0ÿÒ ÿ ¢ÿsÿ sÿ3tÿpÿ222ÿMMMÿlllÿ‚‚‚ÿsvxþAŸâô-Žÿø#ÿx•ÿsÿsÿ5sÿtò000ÿOOOÿmmmÿuuuÿmmmÿY\\þ+ƒÏÒ{ÿ={ÿsÿ sÿsÿ sÿ/sÿj'@¸)))ÿJJJÿZZZÿ___ÿZZZÿNNNÿFGHý8ŒÃ´yÿ:xÿsÿ sÿsÿ!sÿRiåy%-ÔAAAÿJJJÿKKKÿJJJÿFFFÿGGGÿMMMÿg­tÿ.uÿsÿsÿsÿ0sÿ_içx%7M»AABõGGGÿGGGÿJJJÿIIIþ7APÙfÑssÿ/sÿsÿsÿsÿsÿ0sÿSsÿqsÿssÿssÿssÿssÿssÿisÿDsÿsÿ ÿ@` À€€€€€€€€€€€Slic3r-version_1.31.6/var/Slic3r.png000066400000000000000000000401251301441720000171350ustar00rootroot00000000000000‰PNG  IHDRššQÿQgAMA± üa cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFbKGDÿÿÿ ½§“ pHYs  šœ?WIDATxÚí½y´$Wy'øûî%—·/Uõj{µi©’JBH-,/mƒÛ´1à¶c|Ú`slÏÐ ^Ʀ=í¡Í±gÚОÁÇÝÆ046à­ 4±a°@¦´"IH UI¥R-o¹EÄýæ7âFdäö^¾WU²¿s"32"2ò.¿üöûñÇ— •¿û×£øwŸŨAJ‰F£ÕÕU03¤”p]¥R J)¸® fNÎ-//£\.ƒ™ADX__‡çy(—ËÃŽã CT*DQ„ à8ˆD„0 ÁÌh6›¨T*`fÓ²REs&ÇÙ `†ˆæÃ0,I)Ç°RÊ'¢Ž¢¨.„Xˆ¢hÁqœGÂ0\w]÷4WJRJ„a"B(•JÉoµZ-H)ADˆ¢J)ø¾0 ¡”¡Ñh \.@Ò/ó0Rh4[ø›ÿy·e 5¤¹y³êzÚ¹Øعœˆ™¡”šB¼ÀÕ®ë^áûþU¾ïtg¯ã8)%™IB$ߥ¢(BEÃa¢Ñh Õj!Š¢¥Ô³žbæ„O8ADßÄðàpÑèŸÖƒ˜y\)u½”òÆr¹ü/Êåò5•JeoµZ…çyp]7áxñõ=ïi_«”BhµZSkkkSõzýšF£ñªV«¡ëºßaæ$¢/0ó]иØã2(ý3Ð ˆ™G”R· !^[*•^5::ºll Õj5AF$›m3äy|ßÇØؘA`}}+++ÎÚÚÚ•­VëJfþWBåyÞ#ÌügÌü "z@t±Ç«úg eéEBˆŸðêÉÉÉSSS ¸€” ›ò`u˜˜˜@†X]]Åââ"ÖÖÖ3Bü;¿"„xDñ§þÀâżnôOh±Q0BD¯uç§}ßÙôô´O”é­W¯vàI)199‰‰‰ Ôëu,,,`qqaúRÊ륔×ø9)åˆè£J©»6Ëa·‚þI-ØDµZ}«ëº?ëyÞÑ©©)LMM%Þvƒ«[[ p*• ªÕ*¦§§qáÂ,.."Š"!æ…o“R¾-Š¢Ïzž÷^w_ì¶ÛôO hñ„¹®ëþŒ”òÝBˆÃعsg≢KWå1à/—ËØ·o¦¦¦pæ̬¬¬$†â‡+•ÊDQô)f~?3?t±Û âb7`;©\.¿Á󼻥”.—ˇ8€ýû÷Ã÷}DQ´i¥~»Èü!*• <ˆùùy¸®›üI˜ÙB¼Éqœ¯{ž÷a!Äî‹Ý·@#¢„^*•>)„¸avv‡Æøø8”R—Œ˜””R`fLMMáÈ‘#˜žžNŽ3W]×}»”ò"zÝ CfmC¡ç5Ј¨,„øUÇqîPJ½Öu]ÌÏÏcïÞ½R^ÒbrŠ¢žçaÿþýØ·o¤”ÉŸ'Ýa!ħ‰è¿°_Mv¨ ±àñ>aˆ€{ÞMJy³âKBˆ÷)¥FFFFpäÈLLL\Vb²_2œyff‡B¹\.âÔ?#¥s‘|½ €o4ЊÀllÏK I)ßíºî—ÜE¦§§qèÐ!xž÷¼ábÈèn‡ÆØؘþSÅçˆ×á=c#Þ§þ¿úØ©3Î |¡Aæ"š 8:``{Þ™!„˜ý´”òªJ)ÌÍÍaïÞ½™ ô媓õKJ)H)qàÀÌÎÌ@BÁw€²”]`Äî~Òóÿpæ‹ÿ-ÿf”¹ ¶<àŠ8ۆ貚ñ3ß066öE!ÄëÌñÝ»wcnn€Îbˆ¢®ëÂqœç¥ø4DbxáðÁ½Ø37 )8p%0Yaœ[“/x秦þÛg¾Qy=|n€€Ùàâܶ!º¬ýh1C©Tze¥RùSfž5ÎÖÙÙYìܹJ)´Z-ìر¯xÅ+pÕUWa}}wÞy'î¿ÿþ$µæù@‚4Ȥˆ÷ÁDØ·w\X¼p®”ñ5%)±ãßvò£k ñ®Ÿ¸mí#ÈCmÛ¦þ•—=Ð|ßÿ7¥RéƒJ©2 ÅÆøø8víÚ¥šÍ&®½öZüÒ/ý®¸âŠä»·Ür Þÿþ÷ãž{îã\¾Ã ¹Wö ÷B0¤öíÝ WDX]Z€ë H„¤`0Ãýý¯Œpµ)æ~úöÕÿà‚lÀ@\梓ˆÞ à™¹ hàU*ìرRJA€;vàï|gd0==W¾ò•p粡„”sîeƒÍ—Z\ †+ùý{135OF(y–ÎV\‡ð­gý—!IZBèÌ¡ ÎeùWf„¿FD¿cxž‡©©©Ä´WJáÕ¯~5:TxŸ;w&€¼ÔÅ'%/)Ð ÷¢˜; .•œs.Ç8p`Î< lÕá:RPàփͯÿê.¼¡ê«DdëfC¡Ë hB‹"¼;2)%ÆÇÇQ*•’´ëjµŠ[n¹¥ãí.\¸€V«•dÂ^ŠD¹#aq0{s¤›“LÓû nÉÃüü>œ}ú RhE7ìižøÕ¼ðúJIFHÀÐÍòKw„óä÷=BøÏwx¿2Z¢اˆãããp]¾ï'ÇK¥FGG;Þò«_ýj’›)Rd)'­gQ &×ÑïžÙÀwR¼•=À—&ƪطo„ \;×¼ç]ß¿ð•’z!9œ‹õåú¸<8Œÿëo'ßòÔRù}eNFƒ™1::š¤UKµµ5œ>}:qqØtÇwàë_ÿ:\׽ؽëØe³“ÄDÊÑlëRJÀ¡T'seêÆ0›#mQÁ›œÅ®Òâ}?õ‚'Þ8^Uß9YˆÁ€Ö÷?ôÒpïý‹±ïýÜC••™lyž‡jµ f΀†ˆÐjµð'ò'8x𠦦¦’s_úÒ—ð¡}(Yåt©QÈlkÒRþý+0/æn®y)Ð füå‡~äø韜(«GcN6(ÈëÓ%¿Ü®Ìøó¿/ú™ÿwò™kîÔÔ<σR “““ðñÿ<»,oñ³ýB Z­êщu²NJ½ëº—$°l²A&Ì;i½Ìv[kÒ±8˜o8˜ïç7 @¸˜pWûž÷¾~̯ Š´Ÿl ÀXÍH^š@#$ó{ÿrì­_zÔóx9;ÌŒ‘‘H)fÖV^nÎWÝÝtÇÖÉ„%.¥02ÏIåǦçh ÓKÄ(„ƒqgõ;/9ñc£~ýc16,7¹kÀ¾¶KhŸùK÷ûWðË£-µƒLJ‰J¥r±Û9¤Î¦;¶E)(Uü÷…HÅ —˜ïZû1À< w׿múÄëGœúCP‰¸´¾_ÀåEmÏï^j@#HðÊŠ¿ñ™ñß—UQð+—ËB\–Ü+íhöC2Ûª´\6KfùÉl y’à9€%ª=õâɯqk÷odæ;h þ¥´4‹ÓgþàgFîSÞ+'*íÆÐó‰›e|d1ËÇ+ÛÂurNØ<È\Àw(¢>ÕN½xüÄ{ë÷C‘ƒTñ7ã=HÀœæ§ œ6t©MwÄcuï£Þß1òž¼È´Ø,•JÝÌ>w¹p8;7:ÑÉr Ë(ü²]L€•œvIéÀÃúS7ŽÞóúIwí4È…D϶ѯuiØIç¨] @£ø•Ãð›=ö¾Õ&íÌ[™†J¥Rû ˆ’Õ?—j8)í¨isünLP6>™¸,,%? )9YNæ;šëI)á¢~úÆò½o˜«ß@<ÚP°\`ÜÌÜàR B‰ù¿ßW~ùßöÿuÈŒçßÔ<Ë“Rê’Ž[æz›f\XúXÈœÔeQŽVqÓ}½‘ 8Ž„‡Æ³7¹ßxÍ4¯üÖÉC[—Q7Š[Ó«µ…Ül º˜-• ¼º,åû¾0ú[n—™ÌŒ" 13Â0„çy±K½; Êzú3á$JŠ-KßÖǼ\¾%.ýØ•! O5N¿'^;®ž@@e(&OV!„^óDc ›ro–ᙆ8Úź³óÇ¿\yíƒÏ¸/›(«D”ÉÌ(¢ .rw:u0ý÷ô‹"ËÒr¾&œËËêcÆÊ4âÒãÆéë£{þõ4VîÓ$T,,5À"D±Ø^_`‘HA´§u_ÒÆ@v Ÿ?/ä‡ï¨¼³â·›™á8N×lXD7¥4/9àÈlqéÙî #2Û8%Í•€t$¤jž{Aãž7LñòÝ4[— Œ pApAÁ`8N–çjFdÊxßdÛnHtn·ŽÖ¾Õcþè]Õ}âœ{«';·ßó¼žú—R Æ¥Q 1ãr§4—LäÄ¥ÌY–ž“Í+»6Ø(1<©u2©šç¯[»ç'§Âå¡h *˜!€&4D$¤Žfš ë4?öšNÆ&¸°½@k™×Vþì¾Ê/–ÜîíîW÷j6››å­Ë¼#6ãí—–>fƒÌÍYâ”uéJÕ<|íÞ·íPK÷ƒiˆf‚²6A„%¼)źåšoëe6Èlm ºXM“Çü¹K·<|Ú¹Íw:·ˆúÊ3)ܵZí¢YŸyQ',ï#3® ™…#6ÈJ±›C:Žj.\·zï¿Ý.ÞÐ4 'Þ à4p à@m­ …–%Û•hpmz‘ÊÅsoMàîªþ‚#;ëŠýègyªÕjˆ¢hÛÁ–‰[,—¤˜YŽ›%z™ÑÉ['k­_¾ç×v„‹÷4½ºÜ'`Ó@ã˜; 8@¬›™ŠlyÔ(i¾áfF/+ZÛ¹!ÀmÐÚgÜeþÚþ¡{Nºÿ²äto{· ¶Š·kkkÛÔµâÎæ³0Lš[²’c‰J£“y1'sÒ|3!%n­_»vïfƒ¥‡Á4 À÷@––3`P šl-Y˜ÑÕŒgƒ,Â&Afn¼ãn¿k’Àß|ËM­Ec½04è*%óP‡z½¾-+œl%'Y'RG¬½*É‘i¬o».òŠ¿qaq)%|Ñjîý¯;¢…oiŒ|(¸P1Ðs4$û „FRl“jÝ-„ FåæCY¡nh«ÝÅ ÓF}þ¡òkÊ}ä#šªØƒÒÚÚZfÁÊVvÈåöçóŠlªuÆGææ܆“Åœ„€'ƒð¸ß]Sjá™X\.ÇhWÖµcÃ@ ˆâwNÜ´š‹Xi«”bQ ´‹ÊM¯ñÜNŽ–’Ã|ßI÷šÇÏ9·ºNïöohF„.//o‹¾–ÑÉ dãy†— )qé‚J2ˆ®¿÷ñ)ÿB ’vBb „ €r,6u}3† -2Ó’S*“”èlH¸švÞªä\´Æ{~Y–D à¯,ÿH3€×Ïôo”£+tyyyKŠ¹dÄeâo‡”LJudYå?§“ ß ÕõS÷žž(_hBÐ$\žÏSp0 Prc¹ØÌ&À‰î•V "ë]db˜›ò—u¢­Zqš0Uƒð§¼ðúÜöão6ÔˆøÁ]Ã[‘…™çbù„E£s•ó óRF 2_êºé{ÏŽ—š€¨@rÓW܆©ù‚Çã(Cƒ­¨ž68±>u`âè§H¢ ˆýmz/ ¬~ï=iûýhÔcgœ]=çëh6 žØlN–/I×Éò)×½, -Y:™£Aæ ÅÇgî_˜(_h”ÀÄáý˜¾j/¦v¿Ss¯‚Ç#ðÀ ÉØHÝ*’éꥼöe-0C1ÛÔ mÐì¥Xíä0Nœôn[®Ó¬ íóà°-..n¸¨K›uÙ…›%‹y-Ù®‹râˆÍ‰KðdÄÇgï[œ,Ÿk‚ÉaôÐ4Ưž£€2€é=·bjî‡á²²,Î4tdÀ–êd*n¾öT ã.Ù¡éÛ¯£EÀ—õ_.¶V7/$£³---¡^¯$–ÛD% ä¹µ–v¿qc”]dÈéd®T||ö¾Å©êÙXH0FM`ìè Ášõ•0¹çåÛù*H¦¸Z£Y›!µ8ó{F[`¥íu p³&äçÝÛ½é÷›oDœÏ¶²²‚•••¾Diár8ÑCñ·¬ËLÜÒËæùۜ̕Š¯ÝqÿÒdõ\,@#G0zt«OÆwâBkg“{_êäí 6N ›“¥ C\6´ìœ[êÖýÍаVì73Ÿ«³«böܪ8(ÅE|¡^¯cqqF£#wËG›;*þ2».±.­ØeÉ—ÖÚK²kv>¸4=ò\LPŒê*F¥ K¯y—Ç@‰Æçß ¯|ày]Œ2ŽØt~„µŸB®hî†BÛÍÑpjQî^mŠ‰Aö[ælµÜKKKI*x!à:ècEY¥BQi;dSg¬ G2›{pqfìÙ ˆåù F®iCW"ôì¹ (¹UŒÎ¿Ž¬Ä'³|+;(#\í{_@ëÄÍR’À?|×»¡Ö¢¾U´­~ÒœV³ÙÄââ"VVV…!D ¸A@–8d­ì‹²g±”ÖÈA&ãø¾û.ÌN>»®ï¬Ê«¹6 2Ûd•Ã%7ÊcW¢²ûÍh%0£Œ~fkfÈñ0û|·¹í>¿]h{# xjAÔÚÜŽ‡PÝ­^¯caq+«+ÂBÞz€,YHb[•±Èô·?'.©püÀç§'Ÿ‹9™R(Í r´“b*J]«°íx5¼±›AÜLF=ë¢ÍC®Ëåç¬h7@Û›½¡€§—äü qîí|Ú‰ÚI^¯×±´´ˆ••eA D GIíËጸtòNØ4+ÖˈK‚”Œ£º03s2R ÞÞ*J׌iéWÄÉ(”J]« ØpÈEiïÏCŠ2ˆ£Œ)`ö ðDWÖÙ=eÏç ã:äyêÜ^]îwÎ9ûµ8·ëI'¶j&„ž…V«•åE,/-¢¶¾±û‚âÍZoiéd¶ óc—B«FÇŽ<´°sî™5@HÅp÷Tá]7™AVÞGÏZ²"R€¢4ÇŒ¼P€S½ÞžŸ…@3纠 gËÏXû‘¡ÒVs´ôŸ!8ZX“‹51¿ѹÕéÙÉ‚^d30$¤ ° Ñj¬c}uµÕE´ê« n“Œ’K({z+y”„”J6Èdz¯kŽ>¸°s÷Ók`!!Cì¼nR· Èg‡…1ÐDœLŠ¹óMã·ApÃlYšíž5Ñ°^\m Ðz7Š€Õ¦o†42ˆSÞ<Ãi+fƒ È„°%Á+ôà°† ¶„V}ªµ ×á ’ ³n GO’€ ÂÑ£/íÜ÷L R1°g¸nJ·"fOvWmÉÂ@,bÍÑÌfƒM@@îz;‰`ȈÌ"H® Û•F›!•¼>Rƒl2«ÐóeC‡Ò@j()¹ÉzKJÝŽ‚à È `:i‚%ˆI ”€¸úºGWvÍŸ¬¡)$„R窈®‹ë€ÌŽC*hý, ô¾yÜ„y·mRÞ šx9ÄâçAävð¨Ù0Ë/µê@ƒ£õºh´¨ªxðßdæ-]œhd-‹³20’ÊŠVnÙ*~¼••¡ì m]ŠMP¸ÕXET[ÆU×Ü¿:wød JHHDsU4_P ²|²Ž‚ÖÉÂZ@HYn–šîs¿!*ÌV®F'ëw3Ó2ÈÅ[&”ù¥'ÎÉjmLð7›Íá6Ž,å¿ +6Sˆ8R²V)UWG$$H1‚¹ j×O¤©ùÙ`˧!¶ê@Èí ³Á–N\½<óHÔnf‹M3ûQP¤Q—si˜:ZÏ+!•7ÂX™²ö-lÅŸí%£rY±… óÒB+ž›*þ„ã/>¹¶÷ØÙ:"!@ŠÑœ+cõãi)‹˜:éef #Íͺ¬­2Ñì[9¯ÈúÔäøZ~¿õ=ÃZ·ü¥¤ÁJ‘»QÉEÂ0ÜØ—íFu™i­X³îÒdÄzVÜÒ­âeÚÊ,±À57?½¾÷èÙ:‚d%¬\?Îq²<˃,4€ "êÌÅÚ2É ÊÇ F^Áõ\8JÏ % ïÆüÜö¢Ím0öBqᤠÒfËäAf¯RJ@f-‰ór±e/æb W³JÄYIÁ„kn>µ¾ÿš35 d>–n ­¬ê.da4jYåßZ^GËŽ€pæõ°—ž˜™£Ü^ÿóyÑVªSÏOBõ—öTðqëañ£`‡ A‹Kã'kÖ ÒÜÌ«7kãjNü(¢Ñ› ¸™ˆN3K})=›§ÍmD9‚ÏKŽÜ¸ÕEZ­Öà í¦“2‹{íj>™,Œ ØR÷†ïdÅ属Y?vf -@)4f},¾pÊ%PJ˃!²±ŸŒ€ Ð@3"Óæh½Å%N¸&8¸› ´||`£qξ€¸  Œ˜µmÚ V¯×º¾d2ÇÉò·I8™›‚+/.“ø¥H¡•Ÿ£ÇŸY>pôÙeB;ÿê3o…’Y™÷6R™[} UVDª‚ïv[}I Ç^ %'‘.:ó´A¸X_3º]~4€=“jÑ•ll&ï¿Õjõ'>sa¥äI½ÈÌ"ÚÄ¥«•ý² 2[ñæeÄå•Çž]:xìô"D*BsÚÃÒ Ç5'SíÁqó^$.#hÖXZ­¬ÐIùïÄÍ̇¨tÁØ‹’ÌŽ‚”»¡Ï¹E[-:í¾ÒXIµ|Ñf˜3c}}½wã((uÆŠ"Y‰âïÇÍÏŠK;ýZ Jàè±g.¾ê™óh @©ÍË7MNÊÉÒqÈr¡6q @«ÔÙщ“0áø‚öÙ¦sÏŠh-ß­bV¬È™QgG|uFñÆÛoŒ‚n+™2±KÄ\ '“Ò| ¬ËŠ»0¤+È ÈXâèUÏœ;pèÙ³#R!š3>Öo˜ÒOÐ,ðø›÷<È”ÅÉ‚&P_Í‚«›¿¬'È Åg0ò°3§|Í×F&fËu´Á~œA%‡W=ç6«§uåj¹yRÎ3Y²ˆÄdźÙ4ŸRâ„ýd–uéæ@vÅÁ3ç:}iqLúhÜ°ì  C]'3 3a¦ÚŠÖËl7Fžƒ+è:® D¥£*/¡—EÕ—aÚ  u(D Q­ªÖÑ]ÁwƒMæ1š…%y]͈K34v9ÏŒŸÌY&vi»0\Ë…‘ãd¬$ÏŸ9wÅ‘SO#€âá„àÆÝå¹N‘,ÃÉB`}IûÍlWF^Ôp?^Ð’G kusn =Uf«6]¸ÀütôpHyŒkkkÖÓí¬PÎÛo‹KÑd帎".-gl2–¸òÀ³g®:tê$B"D*„šª ºiØ—mœ,¯“%ye°@&´ÀLQ»¸,‘UÇ -1×å‹ã•ìÛº m+­ÎB•sÇhô6¡£%·ŠuµZ­–©Ö©L“óö·Å.­°’m]ú±u™ˆËýgž»âàÓ§t™NŽÀUð óúJ dEa7Å¿¶œr2[\öª Û/\€j ç¥åªàŠÌs_´Æ@çã!Ä˯h)qK áÿD¬¯¯# ƒx5S6—Lˆ¬âßæ'ó²ÊÞOfJ¬;1Èï{îÜ•‡O“CcUˆi3¡‹¸´¹˜™" ªæzdÿ¢Qt £‰œ= î–w54kÓÐ0¶Ôáx{£ÉýSÑs£%µ4ŒüE]-ÂêÊŠN$5Y±&ŸŒ²ùd%; ÃﻌéÄ¢—•Ä¡ýÏ¿êÊ“§â¬F 2çæ# ÈŠ8X'?™"­ì×–Újjäã–ã—d¬€°°ðÐroÚ–ŠÒ­ð£uþ7(ÈÉj´¸{<úvmîOct2)­VëëëfYœÉ'+ˆ]=ÌxýËEr'åḋœ½põU§Nƒ…^VCc#7eAf¨d™ 8­&°¾4é"“|cßÎØ>+ S¯FàÂàO·Û·Òê,tq¸n¼ìŠæÿhnhvÚ5A¯,ªÕÖÐj6ô’¸‚²Q™GÝø¹ÐRdNj]:pvéêc'ÏèL{ÐXò¦# ²ÛQños_ Í)«/µ%maÚ+™ò S¹{æGwP êé w%fÑ}î‡Î݆±fÀ,‰è÷8®Ù<VÒbZÒ3²¤9˜?pnõêã'Ï"‚â4RÝx(gu2ó^èõ'½j©Uמþ¼.–·,ó ÿ¦AFzÁqØL°é^Hø ¡,ÀضXç`’wó|pbvT=© ¦ ™ÍRúAˆ°¾ºA*)n——^6P^Ê…•©Å-‡óÏ­{á“çA 0R†ºéPuûi}¬Uj ÚÓªî!¥"‘9Ðtv¬°¡Á–|æY(.Xž¨Û¯oid`ãÑýΡ¹àÔû[_o0›—VªŒ•~)×!¨¯-‘*Râ+³ô²$¬dÌdûŸ¯»ù© & ZFxã>`ÄM5R¨ø“Þ"[“ @}¥83¶H'ëT9vsÁaÍMmOvКCȳHÖÓÏ/]t÷Fa÷ºž•À û‚;úd÷ )™Zþv¡— ¸… ¾ßQ¨x¤ýc&PnüdNV2«T(±ÿÈùÆ5/~j‰kñH ›wƒG;€,—‚Îéo®j€5V-€Q1Àòá¨zü» \Ø¢)N‚2"T1¸A°aÚ(Ð6®3Ÿ"x?r]ãó^èåO˯ /,´b)þ%¨øMDõ%”Ül¶âoq2×âdóG.4¯¹õ©,&¨ªÚ w@8)Ȭ¤{†öMë@sh.iN–ˆÈ‚dÅN:™=Ryü»:ëöؼˆ4%BAïòîÃâ«Û®£éÆä]3ßzô•W6>WouæÈme LVlÁC"òeÕ«>Á¥&Tc%¢RäIì;|¡yÍmO®±Fª¸X½ijÜÑ©>1°8¢ÐZš \­5BJ±H·n ë–‚½YiKÓæfDú³ tÙx›£mÞ—„1йâ¥GZÿ_§¸gWN–ËŒí”ß?R"ø27ࢅ’'Úýd¡Äžƒ ­k_òäQ<ÛQÙÁÒS*ÔÕ€`h-hÎÕZ‚šöMËRuà^y÷E'q9L™¸fs­]³ ë1'ÆfŸ >Î6¬’\Ôñš€JßwuóK»ÆÔ3«M±Ç±KZ 3ûò"³íÁ]9™„ÅŠO(¹ ÔZ„,ÁsʱNÆP¡Äž‹­ã·?¹J`-j_âì‘1´B œE2뉉u²Lpí {Í3–:lØÖe~Ô5miÚ>!f Šb­Î¢ð~sAú¦í[@œ§îÁ=Á©·¼¸ö×,ñ™_<Vi>9qiJTK@Õ*% WùñZKàÖ2¡ÀÊÁîù¥ÖñÛ¿»"¤b03BOàìá14ÊŽ~˜eÜ5£—Ù³óû;¬_lCS×i&H‡šZëíŽÇ¨©óÝôÒü|NZ·_ïľ[<¬Å)½’ýÿš½•7Ý´þé™jtÎö©Ù™±¶¸´³b;‰Ëjæ´+Ã8n%a å%ìØu®uÝmß]B)DÌ]ÂsGÆÐq ¢´â–Êô«ø['3#Ç 4VŠoتÙÇÝ¿ÊÅ7îú¹'m%Gë\7ƒ{p.|úeGš_¬Y!^»^¬ 2;¿ß€¬’YÕ×ïe/­…á»é÷9”˜Û»Ú¼þ¶'EÈ®GsÄÉäø÷YÈY`Ù•}:­X²ïÛmj7: Õœ;#>¡"íêHDV ZÓIŒnD´fh+K"äÏqÁà½íÖõÿ\õP#"½ÎÒNóÅ K‚â~ .#.} ìSRnݬ»t%À‘ÀÞùzãÆ—-.8Œ-pîÈà ³ë“…è²­´. ‘ÐVf^d±ZÓÕ" 9h‚»r¦~ZÖ7g¦ÕÙßå¯jQéöcÍ?~ÝâGVš1¤i­XѾˆ¤l‰K›‹i€’jضu©anO£yãí ©‚˜“-žDsÔí²|êuȺY—Ý€54‘öç5VÚAf,ЖåO#0¬"­ƒÖ-øÕm·EG3?ÔâcÑY#¢ÒÛo¯}T¶Î/ž}îÖV– Â$±.e^o*^û–âïÛV¦2i,"Ìíj6o¾åÂ9IPÀÂâ‘i´ @f÷,“êÃAÖ­ºÐÝØÅb±¾¤±m§Iƒ,2Ë  :R Ü´çüDÛ·€8m¸m˜nûGÒwÞñ=øãF+Dm} K ç°¼xõµ%pX‡'e—Pñª>r²|ª#¥æv6›7ß´p^ f ¥Àê‘i8YášKtVú{­·Ü´†ÓmèYƒÌR淢ذ~›PƒÄÚ‹"bM^÷F¯Ædõ³ôÿ’žPú…WÒ§ç&pžW°Fˆ°¹Žúêê+gÖ ¢uxÔBÙcT}B¥$PñEZ¦ÀvÆ*ÂΙfëÆëcq tꇦ{›ÒÉú®Q†-âdñÍêËÚQ´Æ•DÌÍ‚ìy‰3XB»Ÿ³ßù˜†½f ·lO_9s$„·ožý£÷9‘#-«ÒJNÉu ¹U?nœ‹pÔ:| à;:5Ès\I`Ø1Ùj½èú ç=7Rh ÖáD¥$v™¶¦È,qÙKéß6ÅfycE… © Pa{t€”ðÜ„£uÒ"{‰Í\[ýœöÆjnO]c4PþÉ—â³?ûú‹V˜f\«r´Œ”‘PvB¸\‹P³Põ³ˆçÀ­%´5ÌŽ¯·n>¾pÁ•ŠPB@™û’‚ ·~A64M'@‚æd­ZÅãÜ\óÐìè§s-Ìï}Æ€ç34l  úà˜¯¥SÀÿåÀGŽïÁiA©U9ƒmÄÏ'T|ãõ\Š TÍÚ*¦+ ÁMÇ=G1” ÃS@d@;ÀŠ@fs²^ÖeȆEdéd]AÖ!:`ÈÅ©Ülô㤵]~´AÑ~mwv Ͻç‡èÃ&^9RŠAV2þ²ÔO–ÔÃp¬s³¼äEb±T"… ,Ρiˆ‰R×ÿ6ëý[–½”ÿ¡i«²¾'2v‘\Ì@c蔩íãÛ=æ‹<Þ“¶?Mˆ u‚,Oi¡ô=Gñ•7½ˆ>/¤æb£†›y9gll]F°cš‚Ûo¢%σBÈ„€h rÊÏÔ5éGéÏs±~Å妧¤€(ö…Õ–ºèdæZ¡E¦½FÀ&Jx8§Ÿ â?ÛP¦íVgØæý1¶v–ålM=C!‚ü7·à#/ÜS®4þ2JJ$)ØBÿÑwL!xÉÍXò}Dˆ˜@B tprÒwQü3`ëC'ëU£lØDB;ck:ƒ'¹–ô5ÍÕâë€'PÂãPIæÎ ºÙ%ÁѲ¾±N ‹5¤òîKPÁ¸wŠÖ<©A–YA.uTefáK_LK¥ "(ÖÚ²p¢+'ˈJôædªúl¥uI¤u±õÅö”Ÿö‹cѺØYdj‹óëpÐ@»³vËœ0ÀÖ퀣äºìtq¶ª>!äÎ1<ö¦âÆ«Lq–d0;…ð¥/¢…RÙp2"”NÀéS\vËÄ趰w+§Èª± 4–u>vú´^–÷™åggwæÒŠÞ‹¾¹©žmU5!Êí§"4/:)æf”Ó–XW×Gg~ ßx͵øxÙ›|4VÀô$—¼˜Î—«uI¼cpfºƒ¬M\rVñ/JõÉßÞÊT˜‹W•×µ¬•ÈèeÍõî\O@¡Œ‡2þËì(·çuÃ4ìG]SÁçìqý)YQØZ? â-‚88…;¿÷*ü…ë€Ã˜Cð²ÑéJ-D¬ïé‡3[ꨓ`ô·Ee§j>ݦf Ñ£TTö£%ß:3£0 žk£‡‡Q·ÀphõP4Ða¥rç9˜},oÝ9` À!'šRB ¼“øJŒ<ü,n{Ù ôd¥!—DðÎ@ÎtYQQâ^î‹"ãahÃoFJh‘×\ÕOH1 %z~/Κ­/¢§xUFñßᡯ(âÅ[☆´NŽ=^—¾§Ó-Áˆ@1ÐJ¸'S€ÐÅΫvÑ‚wxwî߉ç\shò,’ðçgàÌ”qÙË«úY‘â´ßS#gÄ6×´sµ§ÂŸûnè5¤Jõþž@„ üU±Ù‰†Àa>¯“P,.mÐ D¬úSb˜'péé'H誄€fò™á …EWà$šJÀ'¥ùyÈ#Nf†¦'ëGñσlhËmã0RØÔ ›š« 2jEaïïi±ùTñ ²ý˜1Cár›Z^LöºV?ÿVsµ(î‚J`§ÝtàH@ 2‚ÇÚ[“ €ƒ‘/3; ‹ª(Ö»Tˆ$‰p˜à2?š„¡ ¦w#ø$fðÙ˜›õš“‹ê°í‘ÊYȹ:‰ÍNFBî8+(0Æöþfv¿§gfl¿ I€Qö^Jiq1° 2SV€â—¡‚ËÜqjU»AŒ…ºYbËØ_Izíó‘Õm¡a6õ wØàTÚƒ½÷71ƒ,ï‰ëé b=L±ÞBíB *Å¢PYfÉVËãÝo­¥Õ}†ù› À.¼£xª‡ÈÜVÅ@ë7@ÞÍÂìw©}š´2¶ç70µçÓŸã> QœæÃH«^«ì„ú %aDJƒ*Ršsäu2¦ö“'n¼Î2¨`ˆÇ¦Š/a¿_àÎè4OÛFy  «çEÎÛbŠ¨Nü&fþw¨F † ±î_§8.­®t¼ þDñqNË|¶édÏ-rÛ‰[O·¡¹A F[àöàpb7Qç+·´ç(´N. ûs‘%Ù­SEd2l‡Þoõ·±ö( Ê€ðu³˜R±g',Úyý™ÿ˜»)ê·Ü²¡6à2Öj#¢[/–À¼ãx´È. 74кqž"¯°S/J×AIúeŒàýë”ä°@äkÐÁXZâRõïÂØÊÌؤ'1—4k‡ "ˉk”ÿ­¢À$>„ø³8h^Dd@Æ@Ø md:ÔäлQÅû“_€5iQPu@I> \€ã-@H–!À½A¶élŒ¸}8ÌÚb  ª¨G¶ÀÏÖ´cö«Ø_ŽûvÑòÍzQ¿VgÞûO¹ãýtÌp2IïBÈ$µ)üˆõ®uK4:1è<@91·“‹T3~¯dÜçP炸»&*ÀJs-jßW co¸ìQvð]À›á¡Q 2/jÈ)OÃL|ìÝ!CÐ/b¿ÓdÈ-ê%³TEs0ÂZ|Nh°±-r%tUó8ÿžEA3sª%[ 0†ˆñ¯q[¬AÌ­,Ðn‡Xì<Ž°„ýø ŒàÉ Û8À¬aD¸á»dh åõ±¢¼•¢Î%arz'Fðö•"¶"am”ÓËXƒ@éwÍOf¬Ìn)6–•Ëöç|â{\ `åG˜QÇ~¼S¸{h €yhÏÊ2ðÕG{¿ Üù(£Óc”lú»ï~~PŽÖÉ8°37Û3k*ádE«<³Åb q ¸(\En<þ…V¥Å¥ú"«[Û)}F€}x vàos \TJhp `}øâ=À'ïîz”qòÂp›¾ÑYäɳT—côs¨â÷ ¬|Ú¢pRÂÍ,7†Y§ð’ÿ,´2/QÐldÔ-ìÃ[±Ÿ.Y‹ÎópÿIàÏ¿ÁxüÌÖ5#@ËûÏl€$ô¡—ž8ôK¨  “…yq‰þ@f·(¿¹“¯&ö᧱ Š°0“¹3±ÈÀƒ§W/>|òkŒg·§ ›áhI`üY"]x¢W91<8xC²<8´€!ûð®™Ý—eìDZŸCXXฌXÐX¾xðG_>w£ß'?“†TÏëf¦ ‚Ðä·é?ÂÇ÷dÀacëdyo¿â؈†ré“ ñ$æñLᎮ«˜Œ,‰gteøìߟ¹xà)Æ·ž¹¸]!þåÙð@ß/èªé®ý”[c.ý6<ü«$‰¢_°~KźÙóÿ€ƒx3Fñ¢xŒÍòDȬ9€Ó€GÏŸ9¡u®a+ô݈{]Ã\©^ÄgÀa ¿ ‚ƒw€!hqÖ¢,*Œ—÷öwâdÏ'ŠTð ÆÛQÆF ê:Kpòàs÷3cÀßø.ãÛg€ k»ñÅ4,љ敵Oÿ7uëнé·Ñâ¹ ÈTÁÖ–[†.Öåó€´<¨cÿvãáéÜÈÇÏw=‡»?úÞqÆýg–±ðµÇ5§ 3 üå×iâ‘m“‡Ôia÷ÕèT€Ö¦®˜) JI‘Äe§ôÝ"0,㸀ÿö¶_ÞÄP¹sùë/WÒÏ®}ì!þÝ÷܉÷\Iž:׋6’9³eÔKGë 4 ÜõðhΙ73\1\=§»ûÐI`­ìŸÖ¥Ú…ÔÇP'¶ "‰ÛÉ« Õ¹†yÿ9ü¦×Ä3v«qGvÒÇ.‰áÝ pÿ³ôå÷ÞíþÆŸ?Š»å»’™“^›ýx"ícÉ{£³å£µy ùÀË“qÇ#í§<¸n¿~õ=Ojö>ZöM˜M‚J.0Y탘¨)Aø.IÏ$0ŒÎ+ú©[ÇÔ¯—}Ì'å¤.Ù¤—MPì<]X¡Óïÿ†ø¼O~¢ÑBèy(S¢@Dy5„(Ö”W*TE˜É»È"û|(#ÚÐ:³ßØÚ¹í×_{¼çoå#عŽDD £eˆªO²ìA–]’¾ÃŽƒBF}w™çt^½ùG©×MŽ`~XØpæ÷¢SìôY\Åâyˆ>ÿáÄ_=±@'I¢êˆ$n’×L“-\‘™Åç¢øº(`²ÏÌ4èÌ9VJ) „›Ö|7´ðÇ_~ö8§Œf‚ˆ !„$"D’˜fvAJW)à,Ápˆà„ ܈Ð<2Î{ñõ†·\ï)c4±L/GŠ3˜Î,aéSâÄïÝK÷E< $´*‘áV³Ag@” +!µ•Œes_ô±€ˆ‡3‡J©È€0Š¢N¶}WÚ8ÐHW(~ÑÿÊxðTñw)¥t]×!"—™=föxÌìÇï´Êë2à‚Ùe†K‡.ƒ7~gÑÒµ†Â£3ØûÖkù¶×]NaV/¸¤û‰bý xüÎÿñøÿ#ßÄ}§×pÚòv rNò“[dkÛÜÍŽ¯Ø\ÍZˆ(-§´âÏ-"jÅïMs,Š¢ ‚ÈpÂ~º¼q •€¯>¼ô½…7 Â÷}OJYbæªRªÊÌf.(Ç@ó ÐâwÇlÌl¢‚â › 3ˆu™ÑpÄCõûçqèÝ/­/Þ…}‹‹]õ= Û@&ÂK@­ŽÖß<‰ï|ä!|óïžâ“ëêHÿL™ù)š³‚sm $¢<‹œC:u4å`¡0]ˆhQ@ˆjBˆu!Ä:3ךÍfK)eÀÜ•6àxæãu!9"ÏóÇqÊQM2ó”RjB)5  Í™d $fcWêjÜ–jkŸÖZPùm|篾“×íÀÌKöОŸ9Žã7ìÀ.ò!2ÿíížpc`½†æWŸÁ©O?†oå$Ÿz| 0 ×@¹Ï»æý‘/,¶8;qÅ|1—2¢4€ævhk–,!.ø¾¿Öh4̼i7Jg Ià¿Ý[2 )¥dæ231ó 3Ï‹%Ü+*d†¢éëÐHø³8÷ÀY>óáûñÍvbö–Ý´ûûöcÿM;±sncÂKê«e‡y£dZœ{bBÐ@øí X¸ó<óÏâÙ;NñÓ/a&žF"ýµ^cÑÏù̬å~Ãa`RK1ÐJÌÌJ©†”²!„±Þ¶)ê ´øÁëG~ï Œõf×)Ð@`––HL86²ü5'bð‰38sâ ?óŸîÅ=“%TŒaì‡Ò«¦0}hóc›ðá–QJ„VQ&W¾è–#ç×±~¾ŽúÉU¬<±„¥ÏáÙ¯ŸæçžXÂR3JžgåN\’d÷N1³ I,˜Y‘™CAD€ MCùñÎå&[À+®^q0Z"üÚ§²¥Tä8N“ˆÖ˜y1nT‹ˆ*ÌœèfDÔUlZïçßœ¿Æè|¼Ø@s±çî;ËÏÆçå¨Ò‡wlš¦§Ë(ÏUQÝYEeÒ‡¿£ŠJAzð[B) ¨×„ß]ÁêJ­35¬?·Îë,`q©‰f+Ê8\LŸü-E7âNjĨmÑÚ¹3!DÔP°FDKVˆ¨®” c¿Ü¦‰øc=+ôºÝÿñMà7>É8¹¬ÖA¡"§T*yDTQJ*¥F™yÄÐ,ØX .Ú 4A2Çùb ¿Å±—)ÊùèÄ]íÉ1Ç‹þÃ&îq¬È0ÈyÇnÞ °ÝAÌZÐAƒˆêD´ND«Bˆ5"ZmµZÍ0 ûòföcuöPÒe¼Öðš0¾ú Ïó!„maf6踦 6íæÈ//n%bÎGD†浤çp;xbÀÚ½°ß»õv3Ô/Ç4@ìóÝ\y­3ïîÈ$ZÅ–¦áZF³Ý-h‹Ó¸6š1gk2s3‚ Š¢(צÎJ>¨¾øe`ÿ4`ÅÌÜl6…±â(³–™oÍp1®ä²`3"6IžŒÁ–Ñ÷,ÑÛ €&Jª#œ¬PéÈ"’fÏÁ‹¿kï³õ½n¢Ì€¬˜’ýœØ+ò¥UHRwF¶—øð Cf#MJ)eÿöPh0å5î–5I<- CÓQ²H˜ˆ)„HÄež‹åÄ©Ì]—³fŸP >ê²O 2à‹AC*.!jµÀ˜ˆÌg¶× PEéTyPå³v¨I×Xb6b1 A¡»ETì‹´Q©TžâX[š€5¸•ÄÀ÷^ üׯå¦ïÌœLPEöD3ÆÞ7Ö0ŸÍ±˜’sùãÖ}D^¿‹Ïçfƒ,ájÖqÄýèÊÕôÿFƒÎp3‹«u3#¯SÅç•õ½äX„É1f¶?s &;ènï#vg´Í×°AUDƒ­ ¼õûPÞùñB·G¾áÉ~ÜÙNŠ|FŒ!¡šÃd&ëXæ¼”29o€cÑþ}Š’Ü“™¡”‚J©® 3 B$›ÍÕâï'àKžÙ&ÛÀ̃Ó>f‰cšÌõöùóÐíØ–ÓÿfÄ£0~|#%tEXtdate:create2016-10-21T19:31:55+02:00ËÐ0¶%tEXtdate:modify2016-10-21T19:31:55+02:00ºˆ IEND®B`‚Slic3r-version_1.31.6/var/Slic3r_128px.png000066400000000000000000000313301301441720000200750ustar00rootroot00000000000000‰PNG  IHDR€€Ã>aËgAMA± üa cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFbKGDÿÿÿ ½§“ pHYs  šœ1ÚIDATxÚå½y°%Ù]ßùù“Ë]ßVïÕÒµ¾ª^Ô­Þ»º¬Å0hI-d ²A…¡ÃŒÇ3ÂÈ–a{<˜í@ÔÑ2aÐ’Ú‹ZR7’¡Þª»º»TÛÛßÝ2óœù#óäÍ»½wßVUíùEä»÷åÝNžïoÿýÎI±®ò-oûµ}|ê[õ²Ðl6Y__'Š"Êå2¥R ­5Zk¢(Âó<J)<Ï#Žc’$!´ÖˆJ)D„(Šð}c qcŒÁó© ×ì€ ^ àû~µV«},‚÷Çqì×j5æççñ}Ÿv»M»Ý&Š¢kVõoDq–º>urž}Ó:¡@9°hÍô¿ýÔäþùOýûvŒ‡g….ì|¸ÆÀC·ìß¿ÿóžç½-Iêõ:'Nœ@Dèt:>|˜W¾ò•ÜtÓM(¥^RL ž-†r¨¹áúyf÷M¡0Ê>ÌÖ ¿ÿXõŸþ³÷ýÖ⺞Á·]Àmv¶™e¼f£k-¥Ré{•R¿2ÆP.—9~ü8ZkÞùÎwò†7¼ÙÙYVWWyðÁy衇œÉ¸Ú—0”DRô”%Åàµâä‰ã¼øüšë+¾B+¨— _y¶ôÆw?´ïÀûÞ¸ø®c3ñ$9è ;H1_Ëà~­õˆÈ!c Zk<ˆïû4›MÞüæ7óÎw¾“¹¹9D„‰‰ ÞúÖ·277wMúB ´VÙ‘=W ´Oƒ§ %_qòÄ1¦êeBm¨P `ÿ„á¯/÷}ólð=hÛ:@ÌH×–Ð餈È[Eøm ´Ö¢”bzzšjµJÇÌÎÎrÿý÷|¼V«Q«Õ®©hÀI¼’I½H²Ç”ÀÓ†Àó8uò8^xl„VB;QüÌ«Våõw4~“H„®úß];  aqÖåMZËoƒ Ó L¥»^¯£µ¦Õj1??Ï¡C‡¾baaË—/ç&âj‘ž]ÀÝ£RØNúø:=< ¾6•2UÿÏ!N„ûïXýõÅò{H$Áî^UñÚ`ËϨþš¿x&øZ)ßZK­V£\.AþöQ*þ³Ÿý,/^¤T*]ÕKqPßïL€ÝË€<ð=rsPŸ™ÂÄyå'~åm÷­¾—DÌ /:Š#éÚðJ–OüyùÖO|sâ¡J(UHÁ÷É7¿ùÍž¯øÔ§>Ń>˜wý\ ê¿xz !ô ôSO¿@%„jfïÝÿž'¼î–Ö‡þî=«ïÅH»3‡o蘯zKXhùêÁÜ[~cß›‘zY »×7==M†ø¾ÏÔÔTâÅqÌxÝë^G­Vãßø?üpÎ4WƒŠj_ѵ÷EÇÏS©”;‰½ìÑO   ¬øÜ2ù쇿ïð·~Z ÅÙýqÈ ¶åfÃÏ\]Ð%ðÚ_žû½¯=¼¥¦Î›µ–J¥Âää$ÆjµÕjµ'Æã˜(ŠÒ‹! ëú¹_éEð½‚Ï÷¡ä§ÏK„:=x€ø¼lâ̇^yàñŸlÛsa›1Ðe³\=@eyïƒS¿øÈsþ[êa×sWJQ«Õòÿ‡9užç]5iï¿ ¿(õž³ñ:•ôRzÉ1Av.ðÄã†Úsûž¹Çè\  ¶ðÞ«È¡åÃZyío<\ý×¥îX­µT«U´Ö¹Ä›3¯%êÀækðU*Ùa&ù%?¿\x }=A”Ï|õìÇïþæO ¶Õþ8ä Dc‡ˆWƒ{é²®ü»OOþÇrN^~JQ.—¯Â°¶zÙc_x§¤+õ¹ÊwRïC9è_Ük‚hƒÁ¹ÿ÷ôô7Þ%bøî°lªSý[ñ®8¤óæ[~éÓõŸ?»¨oš(uU¿µ–r¹œ7mÏ_K4~ÁáËcú,¤ ýð~êÝ—ósBàhŸƒþ pïÔcïPb–±¢Ì÷o6 :;ì>sE åæКÏ|­tßo~¹úsµ°7c'"C¥ÿšÊìåcÍ’;øZ2gOw2©¯]ɯ8õï ¡JûÌé?yºþWïðb³L,š ÿ©­xýš^m1])HÁWØfCé÷}bòWcCÙ/øvÖZ|ßÇ÷ý‰ãø só‹€!ŸtU~ÚÏ$ß1@9“zçø)í3£Îîîòc?îu’eŒxx€AÐØ13~BWú·\¼²& ´ö߯½ý[çüûŠªßQ¥RÉ\éZ¨õ²ùEð¯+õ¹ÊÏ’:%ʾPÒ÷ˆç3gÏýñÝòèÛýv²Š•ŸT–c ‹°IPtq,–†¯ '°ëÅjì¥Kºúk_¨¾¯ìŽM)E†ƒ_ ’¯ùë÷ ®Ýï¢Úï/âô8{è•‚³Wò%õøƒüÙ仟¹Ë<úc~œ¬ãI‰´õËa²G(eš`p8œm ÛÐW"¾JXûá/—ßòÌ%ï&_÷ŽÑeðŠ¡_ÿëNç uƒ‹(tt!ÎïWùÎÎW‹ª?H%? @ySñå?»³õØOøQÒ©`ÑX„H¾‚B1Üò¹ º]AÐ þØL°— Ð]_Vúw©þ“aÒô{†Q»}e×Xû¬zl¾êÆù¾ôô+a÷Hí¿äæ@ù>“ÑÅ/ßÝxäǃ$j`¤ŠA‘ tH+ü‚BgMŸqÆÒ«ˆèÚ}/{n¸Æ4@1†ßÚ©¼ö‰óþ½7záåÈ/ËÚ¿ÚíöI÷ö«}ü@AÇï-èT¨…éQ {Á×ÏTçâWî^ÿú%µ@&0hT~X‡Æ#!íõé YËGqXÎî;ð¶hû‹_´·s¨°U¥>øpõÝ£Àwëû7£F£±GÃq=-[Yœ¯ q~fïËAWúÝó’_ðö=ZgáÛw®~ý=%µA&±x€Áà°( pUÿˆsà’=Ř߿­Xy/ WDk¿øðÞoŸ÷^zÃí»[‹¿‘ƒç´@³ÙÜS-Ðç«ÌæT¾“þ’“|'ýa·¤ëB½’Êó™Š/ÿÍ=+üBÙtš SXB,ð2@§9R„CRР½E`ÇÎã/‚¿ey·£€Áe ¿÷hùï;:Ÿ­µ«£WDX[[Ë—cïvD°Qa§ê9É®ø]o¿’©||àƒ(Ÿ¹|îöÎ×>&Ȇ&*/•ónúÆÒ!Æ’Ú}‹`QĘ,7þŸÒŽT¿£½4fyI—¾üTð†ò¬¶•b1†ÕÕÕ= ¯ŸiWÐ)÷9}ÎÖ»  ˆÇ¤¿Ò¼-üú—Bé2¥Œ%Äb²þ~›iИÌÞ›|§ø%‹Ü0ûÁß6í¦”~ÏògO÷½°¤OU‚ÑãÜJŸÛïgee…ÉÉI`終ô®ôÆùÅŠž³ù•ÂQ$¯îDyÌ–š·M~ýÉ Ó*á³`sˆ,1’i1 :«èI!ÜSÙc¶ ƒ ŸmOÀ^&‚à/ýpb6.gnµÜ+"´Z-D„z½>4{¸¥A2<ÉãzöœÚw¡^5,0A˜%x²r/Ɐ´Ø¹}ß×ÎûÒÖXµŸ©™IÚ—Û$6ÆH Äøikw ™#hQä&ËtgÏfºa€w´[ 0(ý 5D}åLðš`“_ÙŽS'’î"f­ebbb[LÐ~±ª§ ›®¯Çã/H~˜1€ˆÇD¸–Ü6ûè%_·!&dj~™ßOüí*É Ò²-€4êï: 0¨ ~Ç636‡[†‚¾¥p/L;§ákÓ´µO_ôŽ?· o ôÞ¤o&X^^Ƴ%FÊÁÒ«ï*zż¾‹ó«…¿tÛºD¦^¶Ÿ0wènf¾ Ÿ ÝÅ~æý»°ÎÙ~ NÙÛÌ×/JþŽÃ¡½ËxðÕ³Á]ËMUÝË܈Ðn·Y\\¤ÝneN\÷®d œ=-\CŠ:å¾0¯˜àqßTi%¾ýÀ×C¿a°(ê7L1ñò)°©œ— Ì8Íôu?‚¶.‹§ ‡*©PIÏ#™S(]ÖVi§ 0úGxø‰ào_‰>MW0Z^^fmm-?·Ñ€]Û¶R»=]<o¿ßásRïÀ¯ÍäÖ.~Ó`ªÇjÔn¬a³^$…»d`꺠2ý*Ä&€ÎT½süTt ôœÁ–g{·L@ïÿ Ûnˆÿõçƒï÷½ÍÕÿn„tðµµ5–––ò´q‘6røzì½×›ÝË‚ä‡~ê•W㻎üååJi5ß+Ç«Ôo­cûj3®tS¶0uâVoå KAâé9#°m GÑÞ˜e͹e}àüŠ:áÉ•a€|f²ŒáÒÒËËËÄqŒAå<÷ö‹U½²¿¹ÚW¢©‡øŽc\*—×",–Ê|•ÚmulÁLýu| e]¢~ìgðT±¶|`‰aÚ`÷ ÚÉ\<¯à…%}ÝZKÕljðv»åËI~«Õbqq‘•ÕUâ8B)AkÉ9”*´qy½›•>o¿¨öšrÐ6·ÎýR©ÜHÁW(ß\ÏÕ>ÝŒcSgNÏ@©v’Òþ7#47‘ ðÚð¹ß¶Øm@Ü·>»àè$¨qF³W˹•J££f³ÁÒÒ"++K´[-‹¯…À“|™V±–_)¼ý°Wí+4õJ#¾ëe_9_ŸXJkÔáá*åÛ§Ò_íß’1ÝÔ"e‚ò¡ǯ܌²­>O ØãÛÕ ½Nà®èƒ=KŸ¹¤çoŒ{²³WO«¹ Q§Íúê2+Ë 4ÖW0Q _[JP„J(}¹ýno˜I~µÜJn¿õ«—ª“+iõÞ;Zÿs:¯Ìƒ4z“—w‚P´®οåM 6éqUá:¨ž«»ª #ιp…‹kjNÆÈM¸mÒ¶Ç;À|GO ž'( IÔ¤ÝX¦½¾HÒ^A™&Š)û–j(TE9P„~ª)M)ŒìËo}l±2¹šnÓ¢TQ·NçÁzñr´Ûe€Øö2PÕëñfïGÑì )øƒ&`ÛbŠdGÿ˜…‹kzÿ¸Þ$IH’dwÖõKa&ú×èâüÐsv=Ƴ1*n"A<Òíùh«ñQHâS­·Ìmw=¶XŸ\ìÐAa–1É/\{7#$E]àcºeI@í'rùãHt!õXIÄÞ¶šâ"‘q°K¥î 0Њdj+ìèzî„œ´»©ê_[\šíÒºÕ’P+ µ’P+AÙKUϬ£¢âæ Ìm§¿²TŸ[L%?>R£s÷Lúí†ì|±RßiClºÿ"Ò7KxÙÿ÷д{@WLãIùžön¬þl$¬´¤2–˜Ñn0@q ÅuzÅ8òþ=ߥt»)Þ4½+Ù¢ A‰& ¬½ã•Ï¬Ö÷¯Ç„h®Lóåi²¿ §¼“öN{ü¢pßcæþÊ?„¶qÏö£2£±Øèüí¶c‘ÄH8ö‡²ï¶ÃA)¬/ì“|¿ öKA·e»–yúõRö¼$y]?õöÕJlïù¾§V÷[î#´÷—X½këÖ`0¼8ëŽ:Ðé@,äu?÷Z1*°Œ?K2û­B€f€!ŒøCÚˆ-¹õn½ÿ–AéuøtŸÍ÷ûb|×ÅS-0A5*™V=Ð(ʥĞþ¾§VöÍÀo*±tÏ$Ö¤ü"%¼µ‘íÞíëeèe1Íýxû›ôµƒlgÞÇúÔnE=ÿ‹°-¾Ùlnk B_3‡’Þ-¤v«=Y¾B3‡J¾g¹ãoŸY8°Ú!Zû|–n«a _1ÎïßÙþNéeŠ‘ ÜLx˜dæ ¨!É¡Þy¾j©àQ?ܳzEyÖÔKfÝlA¸ª^Çci¢öõ0É/dôœÔçGØUû%<Jabï~ÕÓKsÇ›DXZ3 wO`üTòû%¾|›‘…æú ÚPýô2:ÓoEðòº¿ëÚØÞ_µLàðX°–-/å1ÆliHQò‹Ë³½! 6òZ~©þb=ß­ß³Üý=O_ž;º¸F„¡¹/`áôd ~2(õÃÔ~¢ µh´ôêçIõ4Iù”F@¹kI Ø:l¶AAúfªæòv’{®Ëg£_É7_ìõ yýbQ§'½[êv\§ÁSÂíw?{qæÀòm,­)Ÿå»z%ß]ßPðm x» ­ÆpðG5qÏY]!šúA$ 7ûŠ7„Œóƒ‚‚ÃSÉ…dÌTpþÁ,pý~Ã~}d’§ãûƒj¿žyüi–¯Ûãç)!ð¬¹ãŽgÎ<|y‘ í)Ÿ•ÓÓ˜P!…:ÅH©ÏÀïDÐXN3~Ã<þ~dž0„…¸þw@¼Þ+ß]Éw´[y€ÞK˜©š·›Þo4CµÀ(‡¯§m»ož+êTKia§Gí‹ •pç­Ï<ðºË—icèL‡4NÏaCƒ?*ÑS?J`}"Ó+ýÙü¡Ý}âÊß" O vÏ7FØŒ‚µËŽL'Ï{jëàêù=Z ÏáëéßËbý<Î/n¼ööð¹ÂŽSûZ„ÛnzîìÜþÅ…tUîD@çîƒØP§è±±·Ÿƒo ±’2‘ÑÀ55AG߀lèG]ÃÕ@‹œÜ—œ <’í(auu•$IÒÚ¾l!Îï߈ɩôJJ{Í©~—ä ºIO ¾¶ö¶›ž}öðuÎaI&BâÓG±%oüâÆìEo?èÄ°¾í,äëOõ³ýzR&†õà{³^à%z6£=ÉbÐ'“óS³l3¹—$ kkkŸ>'ùa¡–_Tùµ¬ž_ÉLBQòoÙ™3‡_чÈ’-á0öV1{W JðNÎÆg&Kfq\? çîÎÞk!ŽÚ4«øžô&yü!Þ~fó‹à‹UÜtËó ‡ç/,cðJ¹g>5ŸÜéÀúRæéÛ®³×_ØÙ®Í/RÔr³ïFû×dнÜD¼#³Éów¾Ô‰Çk7âØ–%ð…¨½NÜ^Ï7\ªóúýIž‚·/VxÙm/¬Ìßrn9]ƒW.aî9ž¦†âÞ‘çIš´Ïƒ¨ Í¥Tå÷{ùý’¿Uoàú’âv7æ’{€QmåË·Z”ÚøÕ×·ÿ´³™#8LòxR¨èùBÜZ…¤E%T=7YHWëö©}$QÜ|ç «ó·½¸’‚_ ‰î9Œ rðs©• x›Vòš‹ÐXLS»1›Wõv*ùíõ´7À}A«s([8ºYyÛ´•žÀa1éÆïOð^}}çájhÚÖŽ*òõgøŠ÷Ô)®Î­`ÛKhc¨•«T“™€A›QÜxç‹·['BaJšæéY’)I·Þêª~qq'•ú¼‡¯ ñ¥vw ~.ý­Lúl¨ŽÕ³>˜üÒí…zé*’ðžùÎc÷‹þGkˆÈ·ba0»çî®ö'xJ ãe<³šöñ¹¾ý ÝÄÁÙüï8×>…oס³ˆ§|­Àh®¿õ»Íëïzq=Ñ.\?Åšö‰/A¼I; ³\Û¶‘.øñˆcTagWà°Ð^-øöIœf­xØ@Œ« ö¤-|œØ³÷y$Á G£ïüØéƯ7¢ÞÎÆâÚüâŒ.¯_ÍÔ¾}".yÇ—6¶y™¸ÝâÔÍßmÞx÷ó«$ÖÒñ…ó§&hÖ½®Í/ýÝ»®w/bxgãç– <#HZ«©(V»Rõï¦j³ùh+ÙÊö¢ Ëng‹„òOÜ×øoµÐ6]›ØÀœý·S z›7ëa·Ëm½žÞiK0‘åäõÏ7n¼ëì2‰µD.Í×iNú¨!%ÝžÝ;£Ôþf<Û!‘4äë¬÷ª~kRõŸÎvÉcÕ]Ó9EÚ‰0þ€" n¼.zòõ7·>ÑŠu–™”ü`ˆÚwmÛµro_觟³FqÃ-ë[N¯,[Kä ¯Ÿ¤1 FÄù»þ¶aèÖJßéÌH¢L:z ÿWGýú–Fµ›&`ðu›]­D¼÷ü/ËÿÁ‹Wš­vÚ³ï©Þì^¡¢WTù%¨;ð3óà+°‰âúÖ×o»gyØX:.Ÿš¢5ŒìäéWûEO/C½" Ð\Nm}¿Rí¬¥Ñ€«íì·Æi(Ûòèö6 HϦlDxã1óäëoZûƒ /±´p‰Vc1†r Ò4nfßk¯¿Z?ôR­apr~½qÛK $Æ)X91E{2Hm~FýÙº~ÉOæí ø’J~ÔêUý"i .œ×,m †dË#Û«b:4Cø oÿ:Y¡Ñîth®-³¶|ÆÊE’ÖžmQñcê%¡^QÔ+B­¤ºàûixˆUœ<ÞhÜyûÒ‚$:Z±~jí}åÉ/:oýàZ®5Êáƒ]pú´×Ò˜XV¬µRÈç‘m••Æ¦½ÐE…Õ«¼:/;ÎSx“ü²¨nÏ~¨"T²†m_Æ6/¢:—ð“%JÒ¢ìÅYŸ"ðkó‡Í;nYZH½}Ú'÷Ï”zzø†“‚?JíoÚ·¿•:|íÕAðE¥Ž_Q+X äÙB¯õVtÐU[ØÓš±=ÏÚ”öùè[î”/$¶Û§?QNzÉPÖm|»†t.Cë¶u ÛY$j58¾­uÇMK‹b iŠ÷Ø f¦4˜Ûg8øÃR»ÅÅš{¾@ÔÈœ¾aØd¹€~òynäün¬®˜0´¯5ÿÛ}VdÁ¢ÿÕóëÇ÷±Vò¡ž?YqŒ ÔËB5BÏ¢m›¨¹ÆÑ} ­»n^ZTˆ•Fœý•±ÀOìh©ßSðt©Ó7êõöZ_.€tãا6qÇÅd$íF&pøkÝü`ÚÄÐ!˜?Ä“ïþ~ùPÀdül¾Ûž%ôÀZaþ¨jßw—ZR$(üùiÔl¹§³|'õIAíoîífœ) íUh-~=‰Í‚%už¡{ï°aÍjãb2’vÃŒúáþå½–¹Cð¦;øüYó¼,Þ/Æù^š2Ž¤sß,+e!AN gKØq~QÅJë%·š9rÊÀl­dª}“ÜZìv×ç;\Ü ¼,FÒnú]«?œ[»¥[¥[øg_Ã/ßy„çO¨g™?WÖÅÂñÃÒyå}²èù6½›VéÄÞÁJøyûýIž"ŒRûÛšJ7 Y)·±˜zû£Àí•´ü<,"¨óGèì6R»‡ ÐN3Å"PqùRw«cÛ3ÅÅ6ËÕ€‹?y¯üê±},ûY&0ÍðÁ±ë¤óŠ{XÔÚ¦déø$Þ\ ;ÂÛï¸/·?ª¦¿«à«4½ÛXèíìú¾fZõž:_ØÂh¶Í»µO`¾v£ïÕ~«Ücˆ5Uáɾ…ÔËÄÙÖ~ÚOûoÝÍ%íÙc-þu5¼½à÷³UqáÆVìýNÁw…öZ*ù&ÞüláGsiøYÀãeÇä•Àþ+ÞµºÀn.W}6a¥p3”ÔŠ'QVìh“ ‡ê|õu·ðÑЧ½Ÿ4_}Ÿœ a°Ç&ðWsµ¿ø.ÎãoTÏß.øIœŸçö7XÊo 4.O»qTø2°=·„݈¶ÍÛÝ&N†<:ðÝ€Ü6'“Û~w£$'› øÄ„û+üå÷ß‚*OÙ¾’ b[#<¶ïÐàÛ;Q’¿]à-ÝÌž5£¥¾HÍ…Á¯H˜à“¨l¦ö˜¶ÃÃl~ÿ‘¾.ùÍÏÒ=ô»ÀÝ6¥ƒà‘Þ<©I‡`¦Ä7ѲóTB¬'ù wøF©üí‚ï€K:)øΉÛü¬ï­¹4Xè'Mƒ:Ÿ2®Q¡ßŽ˜d« 0» †ÎnfsðU¦"¤ç~yé3Ò B*‡_ø@*Ylnó]Q§¿_3o+—.’vê´×ÓÔ­µcH}6øæÒè€#ÔùSÊ<•ÝS F¼+Úa« 0Êëw¯™ü‹‡à#hQÆ’3BÊ*Ó *{n‰mƒ¹#ogâð-ùÎÛÛQûý໵â¸S(*uÜðÆŒ!õnŠH[Ì;Íßoi~…Ítçf,»c&Ø­›F¹¸ivŽ`zkE‚)ô‘íesàSo×Øf<ÀÜ¡×æèߌ?¦7Ø¥î7ºLmÕ4—ŸÄ)3ŒcëER Ñ\|ŸsLð™‚÷¿ðWEŒ¨d ÊÝÞÈÝ¥­§ËýS&°ù]q Ö6ØèÝ8ò3)ðvcµ¿•æÍ­N¹º:“dºnÌ ITúùæbÚ„:ÃX`–_¢Ä%’žVð]IùŽ¢íj€â Feª eÁ`ŒÎàvÒŸfô%½]¢]föºpàÈX3~Ï Ý>Éè•øÀ9uÒ½Š¸VšÈqþÇVv=•~Gc!cœ1Á÷y‘9~3»Kàf¾kL° 0Ã䬛m—ÌÝKèî†oˆ1v•é¹ÎþÃÿdüaûðõK½a´Úß|é^‰I²A­Tb-cÚø!ß×YK‹?ㆅdcžâC„,‘à±±ô_u Pd‚QƒÉ§¶0h»ëˆ±¶ÉÌ¡÷ràȆª}ÇBýàS»?0]} ÇQt·O±Èæ1ÎÀÕªlWåÔlHÑ7c6=.²Ÿ_ÃhÓþwî:b€âè·ë·¼é>Ë ‘m1uè_°ÿè†J~ÿÚüÍ:xF­Í&éq;[‡_}«­Ýg:kip\•_$ìçW(ó"I^úÝhNw•ÆÑE®gpE&}çIó‚¶Cmö'™=ò¯7£Š^1Ô³€Û—0ܤΘ‰wt÷®‰³½æÖ}7cg˜ãƒ˜ µê®«~GÃ@Fœë—æaZ¢ÿ³fà}Æ&TþcfüGÄʆ6ß?ªk7‘ø6Û^%Î~f&[ ;=»<— j­¥¡¡Ù‚­ï'‹á0ÿ(óüõÈwíø0È;œ»Ç”ŒµT¼‹¹cÿ Ì&6ŸÁ Ší]‰I8J÷åO’TÒ­éÕ?ìôÂw˜$MÿvÖ¶ A 0Ío±ÏôTýúçpOëýÛ‘n2 #£éÍœÂÔñ«Ìþ]fý§<ÁƒôJ¿Û/¶ÙZ=“n™ts¦È@œd‡!¿_þË2hvByN N¥=Oí©RÇï<×ñ/GÌ­{×5W ålô2@ÿö~ú¼M§2û”EËߧÊGiWh+T%}4ªÐ"b ]<Ò5ã.ÚØI×TX“:vQ3=’¬ ¹cß¡@ 0Ë¿e?eà÷Ó6·ÖÜyl¨³¦ã„†ýŸ´(¹Ÿ*ÿ9Íý«ÌηÀ¶Àz`°!˜îÌ‘H7ôKìð͘`àcüì²M’mÏÒéF Öîž´ÉU>ËQþåˆ1_©/ÒF& ßÓ/>ïoUöi›ª}>„¢Ü+µNªãložuˆTÊ&€ÄO™Ãx™†P½a^îC !éÿÇù6UëÎYL:Ùc”žÏõÛ.J{ÿlú<Á þš(+ø_=—£¨Ø‚³M*¦G »66Ϧàÿ(5~…î±Ñ=q¾T¾M7gŠ£nÂǤ»~€"õ4ˆå×ÅdI¿Ü˜,*H²PÐt‹ëïòHag¹!¥?·Âq~” çúTÿÖì½&Ý5HÀ4`ymãÏlòuã8ü}Ç{vàõtíÏk©òÁð÷8|ä‹ð—O[.¬lã7w@Ûmég‚ˆô†çm"û~Œ,ðžBû'tìpÐ7ÛŽ ^:à'@È_pŠ·Qç, ”p dh.§.ÍãOÁ™Ëðß¿ Ÿö¥>vnE.hªV½ m"RL}õ<‘ÄZ›çEÝskmñ°Ùùœiž[ö8 0¨–JðÑ?Ÿø eÄý~ÒZ™ˆˆ(ˆÒJ{´I—4{Záù Ï×Ö÷4¾¾µ¨ÈÒžíÔ;n2÷ÿÓ»Í?Ü7Ál \‹”©úÕuý þ?—ßfIžG(i•§Ã‹ÞL""–ÞžåDD6¢‘<’=w1Q$"iÊÌÚØ“d‡c˜±äÖ@A£ ·½×òô…Á÷‹ˆö}_+¥ ¬µ¡µ6ÂìyÖ€ DðÁ¦¢àÅIbÚ§¦í‘»Å¾ê­7p÷í8‚*LÛÕ$!ÏÈ]béwÿšoü—¿â‘'9ø"ymØ‘{5MPÔŽºìèdŒÐÉžwD¤ ´D¤´¶1&Šã86Æ8ÆÛEáÏ¿¯xÿÀE)å…aX&Œ1uk턵¶f­-[kK@)ßÙzÖZ—öÐÒ]5¬1Æ&@h)ÿÀ N½ëvîzõaŽî› Ú3eW t/Y«Iô™gyæ£óøgÎØ3‹-Öè–dò¹íŸë!ç$ÓŽIŠ&Â1BÒÇ-i‰HSDÖDdU)µ""«ív»‘$IÌL° -¯µ†¾W‚ ðEd"I’ëŒ1û1S@ÍZ[r’ïÀ¶ÖºTq¾kHêú .1ï$Ö~ò)Î|ò)ž9>ÁÔ;o•[ßp’“7O3;Q£”E½-à;Û®YdÓj=zŽ ô Oÿ÷'ì™Wo³9*ø–­óüòç…óÎ9LË_]?!&5N¬)¥–€‹ZësAÄ­VËX;òÒ`"HàRŽÎÀÙ…îi¥”xž§“$©Xk§9`ÚSÉ€÷ú@wÇ°ž‚a“<»Âúû¿l¿ôþ/óÇ&¨ß19z×~æî=À¡g˜™-SŇÒÊF "ŶlÅâùuÖŸYfù+ç9÷¥xákçí…'YÂe5ÉÂØÝ£QÍ5ý䂃"3$ÖÚŽˆT¬µ¾µ61Æ,{žç)¥$I¶ÿð(Àj8·§ßg9·”¿U—Ë¥’ˆÌ&IrÄsÀ3m­­fêß'ËrÁÁT¬ öOÂ()¦Œ,àÏ•)ŸœbêÄ$'&dâø“seÊsÊõ€À´¯QÖ¦‰¶fD¼Ñ^jÑ~qµ³«¬>½ÌÒÓKvåÌ +—›43À‹ú`¯ É£òEÓ‘û™ÿà|ç¬+¥Eä‚Öúy¹Øjµ™/0üG· á/ž€ÿû“ðÇß°¬4‹öÃ0¬Zk§’$™²ÖNZkk@93Ž|k­«v'WeÌ1z[™áÅ *n÷àÞ£­Ñ‚¸vØ í$ì°[Š6o+@—ÂXlrÙ,)8…Qfÿ[€óV”RKJ©¥N§³DZ[½Ë 1,´à­ÿ—åóßFi­µïûˆ„@ÉS΢ÇAö1B@7E¬‹NaÆ9sô2ŒQ€b­Ý¸Ôí¸Í­#%UÒŽ¢þø|d4@o~ »ì¥7ˆ2ÇÏEíì±Eê¶3G°e­mÇq܉ãxÓ˜i'p4µÓéš™†cû°&I›$I¬”j+¥ÖDDg‡'"¾ˆ8Ïßi÷ÜyÑN3x¤~C®% ÌÐÏN{äŒ!) 9“dêÎç » ؈a2ÏémË“0}€÷´ºŒðêóç‹À÷6Âe_ÈD"[k# Îr±1&±ÖcÌ–rÛgwÙ&ÝÁ³p†l@®œ'†”RJDòPƒäÍ#"R”þü¹ˆ8ÿ!÷#DD ‹(èÓÀÚÂZ‹µVD3¤2#"î°ºõKw„‹HžÕ+Hºû¿XðŽÝë™÷î2ÎÙË3‚iÞg ñ³«IòñÊÁxïÀS„Ï=Þóû=ƒ²Ö’$É€úuR™M°þW…ç’%ÖZ¥”ÊMAáùØîsN³ô¤_Œ1n\#/O)…ˆ¸Ç|²1N3ØôgìH¦°éà{4Dö~“}Oþ–ê%{Náµ~€÷¼"òÿ&8AßY¼%tEXtdate:create2016-10-22T16:52:13+02:00!pñ%tEXtdate:modify2016-10-21T19:33:36+02:00IÿK-IEND®B`‚Slic3r-version_1.31.6/var/Slic3r_192px.png000066400000000000000000000527121301441720000201050ustar00rootroot00000000000000‰PNG  IHDRÀÀRÜlgAMA± üa cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFbKGDÿÿÿ ½§“ pHYs  šœTÌIDATxÚí½yØ%iYßÿ¹Ÿª:Ë»¿ýv¿½MoÓ³13ݳÀà°DE4#.(1æ£&Q Ä-j®€šˆ4bäBÀ\ þ\PÔõ'²ˆè Ì0‹Äa˜}ïîé~÷³UÕóüþ¨å>Ž1†ÉÉI|ßG)…çyh­1Æ "4›M‚ `bb‚v»~×÷}&&&p‡0 ñ<€ ¨Õjh­iµZT*D×uiµZcPJÑn·©V«{1‡ǹø*×uO8Žs“ã8”RcŽãŒ;Ž#Žã ”B$ºŽÆŒ1„aHh­ÑZ†a²-ÐZ·ð°ˆ|xÊs§ëº_2Æ<Á9¥Tèû~zÌÉ9A@¥RADÒ±p]—N§CÔëušÍ&É÷•R8ŽƒïûéxˆÆ|?D‰æÏl›¯Šj«ä{tÏ&w§1yYRОn‘§¦¦¾¦V«¬T*óÕjUÕëu*• 6ØÀ™×ö>­}§ŠÐétÜf³é¶Ûíqß÷_Øl6_èû>a"²ì8ÎÀGÇyÄóàn ØéqÚ ¹¬;$ƘYà6cÌKDä333·×ëõêØظ®›=qü½ÌßÊã88ŽC¥Rarr2Ý—ïû4 ÖÖÖhµZîÚÚÚž n‘Û]×Ð"ò9à”R÷)¥îÎîôøm–\V€mc̘1æÕŽã|£Rêk'&&NLMM1>>N½^G)•ø¨ ðÛ™çD\×ezzš™™Œ14›MËËˬ®®RJ½DD^+ÑÓƘcþ@D>iŒ Šf ‹E.+À‹1Çq^¤”ú¾ ^Q«Õ®ß¿?“““Œ¥ OxúNŸ­µZ±±1æææh6›,//³¸¸H³Ù@)uHD^'"¯«T*w…aø7Àû€{vz¬×#—`“Ų´Sžç}‡Öú»Œ1¯˜œœ¬ìÙ³‡©©)*•ÊŽ‚~Ðñ'Ç”(ÃÞ½{Y^^faa•••ÔYnuçVàŸä8Îï…aøl­+»©rY6YÇ™¯T*?lŒùg"rbjjŠùùù42´A_&‰2(¥Ø³g3334 Ξ=Ëòò²­ÓÀ÷¹®û}ŽãÜ'"~ͳ²Óç0H.+À&‰RêD½^ã8ÿ88>>Îüü<“““(¥.*àçÅžÆÇÇ9~ü8kkkœ={6?# "§€·ýk×uÖó`m§Ï¡L.+ÀEDöW«Õs]÷õZëéJ¥Âüü°oß>æçç©T*—ðó’œÛÌÌ “““œ;wŽsçÎ¥”ɧSÀ‡Œ1w8ŽóËqôh§?µÓp±I|Q¿¹V«}ºZ­¾=‚µZãÇsÅWàº.anjs7‹Ö¥ääÉ“LLLR=¹Ýó¼)¥ÞÌìôq'rYF9î8Îû”R‘j­™››ãäÉ“LOO?¯€oKâ#ŒqâÄ æççKóJ©7:Žó ùGCî^⇲ɶ ËeRDä J©Ï*¥þµÖáÈ‘#=z4­ûy¾K2\qÅœ8q"­Ÿ*[DäcJ©_WJCŽ =·6ðÅú܆á² ¥Ô ×ux7pHkM­VãÊ+¯dïÞ½iÜe‰$™ ¦§§¹òÊ+™˜˜(õ…DäûÜŠ÷D}›ÇPj€?œÜ#?Àá²ôù®J¥ò×J©ïÃÉÉɾ\÷²D†aj(fggcz½—˜ ¨:æªz­ö‡oû³=ï~æœ3NÕt­¾c=)Âå`3%±äJ©ÚÄÄÄQJý6p¢é}nnŽãÇ÷›Ú/‹% UûPõ ßý?ö}ì¯ï¯ž¢bZ.Ñ `Ó ~³Àºä²Xâ8ÕjuÿØØØzž÷ï‰ÇGk;}û8zôhšÔ²Kž¯Îï0bŒA€£GsüÈAª®¡â<Üøá(˜®žYvþÁþæÜŸ}èscß+CW Yþu]€Ëy€X´ÖÌÌÌÜä8ÎEäÚÐa²wï^>œYl099ÉÄľﳼ¼œY ò|‘èá(1ˆ„<0£ gÏ<ƒPJ¢çø³Ï 5ó?ÿ±Ùßnúꇿçe«¿C(U4Š,À%þÛšu‚.+J)&&&¾Åqœ÷3 øµÖÌÎÎfÀ{öìá«¿ú«¹í¶ÛØ»w/kkk|ñ‹_äãÿ8gÏže7%z¶SDbÓƒZ©ØLKd¶Ñ<¸ŸŠ'œ;ó J N¢*VÀT~å/¦ß{fÙ½êǾaéÇhBÑD‹rÀk6~¸¬c¨V«?P¯×ßmŒIÇCkÍØØHiO:tˆ7¼á ¼ô¥/ÍìçÔ©SLMMñþ÷¿ŸF£ñ¼™ l€K x”äµXV^ÐØ¿‡óçÎà9’‚ßQÝÏÕ<Ãïß5þÚÈøë¾fég¦k¦‰&¤ ø ƒ.ûˆÈ[EäØà•‚ùùyªÕjZÖ099ÉßøÆðC4‹¼ò•¯äĉÏ Ù¶òŽŠÀŸ‚Üz/yßQ1çP„>t€ƒö᪪K÷áEÏuöŒ>úwãoxð™Êu8¦E4„tÁY6(¿¼ÙÞ`ŒÁó±öžYõJü\õÀS†±šÃW\ÁXÕ¡æª^Ôåâû_²ôÓ¯ºiõ]øRÅl®Õ·åù3Ôà·ÿBøÕOÕþãd-K{ ÿÄÄÕjÇqððÀÊÊÊ@EÙÍRdõó|?CyÈÒGÀq²Ü?u€U÷='ó½ssøí&ÿàУ¿ðš­þ<¡ƒßŽül蔊äÒ§@´}áç><ý_>W}çD5 ~èòþ¤OÒµ-×uyüñǹãŽ; ¢Óéð¾÷½Ï|æ3=ß½˜$þ´ô2çìfœ\ǹÏ鎓¥;v„§æA-þ»æAÍD9¼úTó­ßqëê&ƒ¡CõÙ2ðÃ¥>àÞñÇ/yÛŸNþúžq]Ɉ֚©©©”ò$mülGVD‚€ßüÍßdrr’Ûo¿=]àþÐCñÁ~O|â8ŽsÑ&Á¤l[Žêd¬¾êÆîó–>)sð¬×®EƒÜôûB€Ãm3¾óGz Fƒfã–ß>ÒýÈ%Ý´nøàgÆŽ¾î·fî¨Wä ’ì8$ÔgÏž=éßÕj5m•— ãºë®czzš¥¥%|ðAÒ~™£ä9)‚ë++¼éZ³€›s‚ep2Š „ÆåôÌW~ée‡ø©¨VNðoÆie¹ÿ÷èç‘à}ÚõÞú'S¿îª^ðCdÙ'''3|?iÞZ$IÛÏþói“\×u/ Îÿ‘¡=*WÚ VH3æð ð= Ø ²öç"%B\n˜|è]/;ðÀOc0I¢=ö¡­g°Îôýþ¥© -ü‡Mÿ—‡Ÿs¾n¦nzFÁCÒtÖ¶öƒ"8J©‹ð¶‚ßæûä,¿ѱ¬¹ òJè*Bþë&~ÏKæïÿq@Çà7E‡¶ŽÓzÀ¥©ÃÏýÞÔ÷ÿñ—j?6]~ˆ€lgz´]úóAŠÀ_Vãò¡MÛê;]§7¾9¿Éöðë'|Ïm{ïÿaH-¿)8ÄÍ´þ…ûºÔ@¨óÇŸ¯^óîOO¾}¢Z<~ÆÆÆÆ2±þç“ä£=*ywvÅ Uæ\nÎÂWÜøN÷9Qב˜ ‡ëÆzß­{îÿIzÁoëåFÀ¯†ÝÇ¥¢‘¶»˜³Ï)ï§><ý`N•L‚J)ÆÆÆŠwt‘:²ÃŠý]üžÄ–Êòx;Ü™Xüô×þŒ¤ßÓ¸\Uô¾pÏßÿàcŠAºžB7»s„mýŸ7>€àóö?›þáÏUþñL]¬1™:Ÿ¢÷/Eé—Ýí©âÌ?Ö´,¼gÞV€ø6ÿñ8ì>öþ[f¿ô£@ƒ_Þz/@권²ŸKA¢i¯jôTŽÿú_ÿÌdM—ž}÷^I.ÌIøs”' afÀïæÀŸ¡=’¡Iêñß~Ñž/ýˆÓ±¢=™ú:Ö_ïcƒ¿Èú—îóbW€è„¦ÕõæO¿=4LWKXL÷¾qÿ|EgbùÉ'·$ÛÏYþÔ±_µèN5õ$û7â²OžøÝÛfÿîßx¢tĠиDkä³Ë×{zö"y“{ô•‹Yº¡®Š1ïùèäw~ö¡êwN×Ëë¦D¤”ûC·§M¿\ÀÅ&…å̱‹¨r¼ßÉ…9{*9cW¨xYÎ_q¥'ä©ÅcŽ'ï¶éû~ÀÓº/`0¸!›Uˆc+ÀÈr±*@×Æ{F?ò”;÷ÎOLþÒxµ\á1iÒªŸõ‚Kç^pE…mÊJne®”2xVˆ³â–<œü®~Z¹Ì™'ïÖñûþ•§u‹Ž(@ã €ÊXþ|$hØÙ ïøBïj±KÎ ÎòFoûØä,4äød­ÿ¸å«<‹Ä÷ýK‚Iîuí!ËùËŸ&´ìð¦Eyò|?u|ãýÔ½¨~ï¿ôBÝ¢%‚A!1d%v NüÜ=ÔQ?ßÈÿ%í'ÔGÿÍßW|ä¾úûYˆèO­Vø™äÞºù‚¸‹U°Û¯3‘§—öx¹X~Êù㥊žêÒžŠeùÎ?<ù¡[Ý{¿ßkë6HâÆ& ‰aiЂX*=‘›a!¾¥³É@¹˜ kùãšÁ·ýéÔ[Z¾ì¤Žã”†>mIš]9Ž³Ó绡A«~Š#=’[³ƒ;µø ×Ï9¼)øîw\´ò˜óŸúß/”{¾×阤‚ƒÁAY0€½BLÚú¶÷TLŸÓLÀŸ|³¨MÊ@E¸ØòþÝë[5æÃ_¨]ýÙ‡¼ïþ¤ÊsØ2‡v»½Óç¹±Á±¯¨ò0§]™éZ\¿Gu*¹Eê¶Ã›–>Äß7ÊeÖ?óg·„÷þk'0€T!µûѳA0ø‹±S,¥UÙyF—Þò_23€¾LЄ_ù‹Éÿ2&Cœï°l"B§ÓIûZ^,R¸’« š3SÉ©ŠKR‹ïY¼ß/~†ö(0ŽËtëÙÞâßóa‘*Nä41Ý1qcЦь©FämÍy0ÓŸ¡”`·ÏÅÕUcþä¾úUw?Yùöš7ø<•R#­Ó ‚€v»}Ñ(@>Ôi7©*­æ,ªç±Wn%«¶*óý´Ì!áü®Çxëì'oiÝóúª:©cP„:~@€‰×w  ך Ц ²eÖßöú#ævó PŽ> ¿ýùñ7ѤÏOrCêa¥ÙltšwZʲ >Ìiwk°f€Ôé“[y˯ÉÆ3¿¹}ïÕBŒŒ!&spIÿ™˜)AÆŸ'¦G^a)Cš¼¦Û$7‰úØÜd%Øí3@o]wùÙÿñû+ÿt¬2ÜyŽºZKDð}WÏ}²Ð§¦§üÝÉwhË[~WE¼ß8.Ó§?qKãÞŸ3~ #Øws‰ò½Ñ `b胊ÿEŸ ‰Ö~%+;±/P,E¼ßÿºBv»UÊQ§àŸÿÁ–/ÔØ\ïBõf³¹ûC¡6ø-‡7ßžÐ.e¶­}è½ø­î‰õ׎ËdóÌ·6îyS¿cßÃàÄq“*BDuTL~$΄9ÞQ!;Úg?ì˜?ôZÿ‘`ؽ @V\Ì“Ï8Οÿ}åÛƇĴˆ¬+¤™8ÃÍfs×Í)Bòà'WÞPPÔ–,Y,ŠñÛÊ/mHhŽÇdëì]·¬ÞóŸ*&4 “˜ÒÛ9±åïÎ+C·ºÕñ)é4¼]$ùZŸ<ð×ÅÿawúåhóŒùÄ—k¯|vÙ½¥_Í-J©‘ùz "¬­­Q©T†Ê!lëàØ%Í%kwÓ‡ÕÁnW’çúIä§âô&¸\%¹&;ç¾|óÚÝ¿\3~dð3i(±¢1IxNÇóñÖ€0îý`ÛtC—yú½ŸÊ[ÿuËn¤h‹îÀGï­}“ÝLm c6ܪDkÍÊÊÊ®?‡7ß‘-)eÎXüÊE|$éñ,ðO›sßÜùk5ã·Ñ2…¡?¼xp£eIqú+{;£h² 1ñ#àØGÔW€ U¢ÿ|ƒÜuQŸDvÛ Ðëô&âý¹û«Ç?ù@õŸ×‡t~!Zä>¨þ§ïÅThmm-í·S“¼È³‘£<…m™fUn6»[ÍÄú%³ =éá£ñØç<{æF¹û£^'d XM|ãO ¬­JŸÈÆ+«âG£Óù8 c‚”œf’5žõ½e”ç’¸CŒô}Ï{žô^ÞòÕ\žUäf”4$TÈu]jµÚ¶+”ü¿UÕi·#χ:3aÎL›d­~ ~ƒËÞʹ•ë÷Ü㵑iI¯~cÑM’öJì:qÕöŸ½ výqcE0>Pµj‡Ê^’ݤE×:٪Öðá{êßä¹£÷f9°"ÂÊÊ J©žV*Û6 ÒmUÒ³x½ÏÚÝŠë÷²¼¿üŽ þÚùÆ©©/>䆾‡/³¸¬á°Š"@§ð´A½îvwKJ!’œpDk :ÝN¼—H$u›»CÜü½PN{ñŒ¹÷1ïÈ]{ßTQ6³Í‰Öšååe‚ Ø–ÈP¾¶GIÌùÕðX}›îØœ¿RRÞ ÇÞÚsÍÓ{î|Òu;ŽšÀ3“xf†Š™Âe¡ THnjm¬ûúš‚›['$)9+cf¤&’ù× zÛé½dî3¨’àÀT¾¦ÑQÓ£ân3*"„aÈââ"¾ïo©ôãü§Wõ&º’ŠÎtÝnç·ŠÚì¾—}õçZ7ì¹û¬£|ª†è*o–}7|=ãÓ7ᚊ:¤J঎08ÑU‹ÁoÒ’‡nL_¥«$ó:‘ngP;ÚST6½¡‹°(Pÿ“0>|âËÕÛ]gDb,%˜žžNï!¶Ù’œ"à—,d±±TËBùŠNkM€ÁeOíBçÔÞ;Ÿs•Õ8‹qS·œ€½“„•„wÐK  ãjŸ$ˆir Ôü»ÇNjãU|²!½î¬Ä®°-Eë.z Ôï$…>{Á¾ç)ïUÕélî `ïSkÍÒÒÒ¦'Êò´'ú½˜ö¨àws–ߎíg_k—ÕÔÖà2W;ß9µ÷®ó®ãÊEŒB9.³7_ÁØþIÜê®ÇžßÂÄä-¸ÆE¥4ÈIÁo,ð‹•Ãš º1¤èŒ[ö8Îýxÿ†§ÀŽ‹cÌã êðbCßM] m%h4é½6:ö‹ž{oчó»%^I†×êëãZ–®~¡sjß]*nÛ`”Fq˜½yž±CcˆÝæ± Œ9æN¾–ññpŒ ý1i±šÐÍwãùÙ@fv³‰N+‹”ÕFe'!5è$¢tàÓTonúâ쮂RЯ¬¬°´´´¡5…å ø)¿Ê‚¿¨Î§âvËš½Üâu›öL×–‚Sû¾¸à¹ƒQ 1Ѽ3sÓê‡j?:@%ñšHu·ÆÌÉF­v%Ê7]üb'À~o?g9· BuÀ{ÝÐØE6µð´ŒîÀ§¿R}…»‹W(Š­V‹……:ÎH³A¶å·j{J£=¹WÆâç#= çË"‹öÌÔýÓûï¼à¹-1øE Ó§g¨®¡}ë`ãƒqŠ†±ê4Ó'ÿ%w/b¢¥.Bw˜XYà¢?û>iFX ‡(?týþJvJ†±þ ÐçÜñθ/¯ìbÒõ‹‹‹¬®®5HÉ™›Ñ©l¤Ç±œÝ•\JP±|ƒÌJ®Èòû§Þu¡ê5CŒ’˜öÀÔÓÔÔ0Añ;DtÈ ¡>v€‰c߃#²µ;ݨO×éí*A~NHömrðßDÊ“—žúi¶ Æ,6åP££NÝàbÙάmøµµ5hµZÃÍíQkxíÖ%ù~=ykŸ®çµ“\n¶®Ç‰ÕNÕ–ýÓ‡î<_õš!(A´AÄ0yã4µ#]Ú“fî*9€+ÁØž2~ðÛQ&¤àäÊ B]@·mJïïmÑ,°Ó Ð_øÊgÿj[*ëõ/w¢v'™ –––29[ CÊ2ŸEmvŸýžâ6¯÷a×ö¸ÊæüÓõeÿôwž¯VðƒRÂÄSÔŽ[þhD³)(EœÓ0vð5T§nAL§Ç¾ƒØ¦®‚ض?;,££s䋽 C¼—P î{Ú;å‡ë¯ìXñZ øv»ÍÂÂKKKiYÙŠ d’\va[¢ý:µåcüi‰C®ª3Mr—ÉÚjpÓ±/œ«Õ~ ~ ŒŸš¢v¬^hùÓ¨»£³yp x¢;úƒ¸Îbtú~–óKÁ<Ý&eiØGýÆv+€”¼.–îÖ{ÁF`›¤ù„c°'NrZJ¡¥¤ç®ë’X~ûyˆÎ )ø®åw-à» 0.õÕàô‰;ÏV«Í ŽöÄÀØÓTÔûÒƒ¥Ò«Ž†Jýõ+¾E¡—çw=ƒìüìɦLª'RTFƒ.º(PÙw£ÀfuU¹÷®cÆë«Áé«î<[_óA)”‰Šj7LS=>†É-Èí¿€6Å Óåê!Töþc¼é#¦Uûé „JN¬ßÌãf_—ÝæØ'¨›5Öê0¿‘üÒniv›œCB:í6ËË‹,,,Ðl4Ð:@‰ÄwT‰îªâäZ—dZæ-¿×ºŠË¢=ãõFpÓuwž›Xõ11øŪ/˜Á»r<âüÚzÀŸ\ÓUM÷5XÑq©ùw8î b‚œ3Ln& TºáÐAÌaÝa7)@öÄ”1gWÕþÕŽÚ¿ÞÝësÇNÊ.iˆÿ‹hNä ÐX[aiñ«+‹´Û ŒöqU7~Ÿ/m¨:ï_µãü‰Ó+1ç_ nºáÎsc“«A ~e Þ fq®œˆÊx,)Z䀬‚ œú1¼#?„Ð!YܳéuƒmqÖìae7)@VV[2Þò¥º‘À³c]Þ¤÷‚gÝDGp Msm…µåškK5оâã+…G{ôu³pr²ü¶ô,Aп þ¤¯OÒÝ!¯@‚‹sðu˜å¿BŒNc¼ÙTXöo{)|w؆™ †ý\F¶sü‚Îz³¾Þ¸åö}ÃûéD «]¿_v RWÙe ±Å÷O(Ó‚`°½Hؼ€i/a:Ëà¯!º…C€+GÚe¬Þ OßzçÂøÌJ€QÊÊ@xÝ úªÁ?Ât˜µúùGž ÉÄ‹PÓ_2ÍÀÓ³ Q„¼ 9ô£^«íšÖ…bƒ©oF¿ÓélÛñlðÛ³@jø,EHBœE}ùm·æF´§–&¸4 Qd2 q!.cãZßpëKã³Ë>Ëám\5MpÕ$b¿wÐ{×\%ÀöÛ…tÁ£=öh3`æ¿gésÑ¢¢ˆtÐâçî"yC¯u/³ö»zV$9•3Kê¸Ú wOÚn‡¿õœr~EáYÒìn~+›[ó Vé‚¿ÏUW¢nÍ®àºÑžÀP­4õ­/ÿ»Å©}‹>¡eù[WOÓ¹®üy°çA¯-†à·zÁß­á/qŠ50õr̾ïÀ¡‘?œ®ó[4ô¥äþî¹%¯Ke'aý4„§ÝÊz#@¶$7½ØÒ˃?ïð’¥<=u=5ü5/¯ %Ê/fq*ÆÆ}Ë×<¼<9ß•B (ch^3IëÚ‰RðÛç• µþ>a/Øí×e7( á7BåP%“K$±ú½¨Öɽhg€Â õÍع1†N§³u? Ú“¿ý¨Ý¬*¥=V˜³ƒ?}¸øÓιÂ6´¢>è[¿ö¡åÙC±ÃKíY;9Iãšþà/âû™À€ßÈR{èGÒìqåzæP4sô§W²ˆ(ÿðÆ´ì(< ”ÉÍÊýmU£Û¼å·ï¹[ÖžÜS½m5·—ú$ÏO2…oö1ø_øÊ—§¬Fœ_ ˆÕ«'X»n|(Î_dù`û~ôÐÒô†>³€`ïkAMÄý!z£Av´?Ð׳½Pv›dNÂsÌòf¤B’„Øf·3éqx¥·oOþÎë™U\¹²ÛêwoP!Q™ƒc‡;#ç­¨×sËW?¼2½?? øOŽ³zíXÄÁs–¿Œ÷ç»n&qþöZìüRL{Q ˆÞÔc·¢Ç¯C¬ˆPQØsc—h$Äì´ô=Õv S›5l6 *rxóaÎð;½à¯ðþ„öTmÚc—8(­¨Ösó?xxyöÐr‡v¼bZŒaõx•ëÆÖE{2àð;Ñ#q~z̪Îþe·¾Í’bêÓ¯®ß¶…rۡ냰ÀdÍ,l&kiµZ›sBo²h=y¿´geÍ+nžçÛ4( ~{%FQ©„æÖ¯~xqÏáå6m…EkV×Yºa¼ÐòÛ¯‡±üÚ@k5²þeNo>þ?h¦¿ƒ°~Êtï 0i‘›Þ J_mµ SÄ$…Ÿuàª}Á‚Þ„DtámhUí±cü‰Ã›†9mÎoE|²¡MËò'´'.wNÚº Ä(ª•ÀÜò²‡f,·i«xµfõXåë³à/+o~v3ÎüJoسø:÷;ùß@A0ó ¿ :ÁÃ@ËÝGò€ßÑ ¬—ËàƒÓpfE—D¨¿ó£qŽÍOOVõ’Þ"PJŸÕÕU$æ;v1Jšà²-¿“óÛ‰®|a[Í×ô–X~÷ ½ñšÇ?xèü9B‰o*mBd~ÎMÇ{Ào =’ý,¿‘ðÍ%h®tg‚2‹¿UàO$hE; Õ~´Œ±ÇQœÞ]A†‘þ©m-Îl]Ÿ«˜'µÙ G8yš5Ú­V¦EaQ“Z»Am¢v¤'ë/tx㇒¨ìÔ {âÐÏ'P^4&F£öÏáÞr"ÃùG*o0ÝþТôjÔÔ”^}ùÉöÇ:›Üá0Ó±!¶ú+ËË„a6­ÍÓž¤UaŶú¹ݳ«<%Sד©êŒÿ]Ý“Ï:rîªÎñ¾ì÷äÛnnþÙæÖuŸÓ×JÐ&dey‰´a­tAï:Ù:þ4ÎïõÖöô€?íQb„nxüÙ#'ÎœnEŠB´}³øG¤=ðÇ\¿Ó‚Æ´Öº1ÿaBœü?ŽˆßˆfDBuŒÞŠ¼ŒòëCç¶+ ´þƒqíÑgÆ*¦±~@¦’ÓÚ–´) ük«Ë]àçcý+¹jVÒ«Ðò[¾ƒB0F¸þÆ'Î]qâìblù¢5²oÕÇòÛ#TÞ„×AÌõ—¢²æ<×/«éï7¾›þ8úúVÌÙ€ï]ÇæÆý‡¦K»Å(-Îþéðé™1ýP¸Áphaßž\E§«„N»A»±uiοÈòW‡ =I´#\{ÃS G®>³ƒß‰,ÿÞiÌ-Ç"u+0†}³»±ÅØî,DÖ?‰úäûøñýí°üø͘þX2‹)mvµ¥²Ó 08—¢ö̆Kß~só÷ÚèpX¸’+—äêR¡ÙXÆo7©xª[×SPÓÓÍîæêùmðKÜ] /8ýäâ‰ëŸYD«ènŠJÌžIÂ[Žô€¿ht2щÚ0*bk\ˆ*9S ü"ËŸÎÿîfBÒ˜H2„W Ç1™;ƒ­+µ¶ž£Þ.`ƒ¦uû‰ÎëÝK~%—]å™Fyò‘Wh7–Ð~3­Õ/«çOºµÙ _Ò;³HD{Рn~réØõÏ®¤–_iƒÞ3NðÂÃQ*¡å—è9ð¡µÍóÐi·-ì·‚kP9Ãf‚_$î,dá Ö:W0S°>`#™†¡d·øý“ To¾Â¿gß„~pÔ²ˆž¾=XEmI”Gº=Q‚ˆÂÚE[qW¶‡×.lËÝ„Z$¦=7=µzì†gו±ågÇhÝzSÂò'Ö^G@j.@ótš]‹_Ô´j˜Ö%-l &r~ó¢Cè´Ç¤R yZ4ìîŠ`]ÃTxÎûƒs_{MûOšþè+¹’Í´%WÝV…I}—‹óGÙ[ƒß\Dé6µŠ*rkÒ<ø•&P\}ú™Æ‰›žY#TQEµÒ†`¦NóÖýPUZóg.]ÐkaÚËоí%«MyIí~?º3L’k³­ЊŸùéØ„êq& ê¥a ìíT€ ©à¾öÖÆï‰0”'P¸€Ý*mp,%°‹Úò}:k¡æ‚Ö¬Q¯H¦oOµ ÉåÄ´Ê„Â5·<Ý8yóSk„JbÎþtÕîE×,ðÇ`O®•ö!hB'ýBôwQƒª²–…ýÀ_Vඳ€1E+¸¨-ÐfŠÐSTε0nWDÖÃà»îKí¥';w];üu'¼’Ë~ÝSÍigxsíÉSŸ©âŒ@o:K¬Æ7§ˆWrY}:mð£WßüLóä-O5ÐÝ$H´!˜®°ò¢=˜1­æ’ ÚÝ‚`:‹à;Ë1èµé1Å vñúvq~ût½Ö"ëŸ8ÅNO"¬,À€Ï$»•‰!D&§uóÕ§[Üì3dhíì =={’½â¬äJêÉ£cž þ t–"ÎïÅ·#µVs)À„Wz¶yÕ-O­ˆ`$¢=™ n™Åwá+à/Bg!~,¿Ñ;Ê“Xð¢ÕZùY ð·²¼¡øjÄ­ü"QAœŽâ6³%‹ä“£“ÜßEÛG–î Tö¢Ï !µ¯¿¶õÉñªY.ª-*oH"=™u¼¹z~»a•ׯç¡VZE¡Â&º}W‚讎Ê¿¶ÀŠ`DÚc.gOÓj*‚ç"K6@·ÁñÇGœ€>>ƒiÏ ào;øãÓi¯öÆýñ[Ñìg€ñܑႶ%ÛÙ®ìà‡+j2@G*·_Ó¾û›®o}h­“ÝuQßž4Ö/ÙPgÚ¡YåÖîæ­~lù땤y•¤nŽé6/@ØÂïø¨C‡«O?ݸúÖ'VS5¿Ã³WOx I€6Ø%;…¦ü£Ðž­Lrõ\9‰î(ÓiôZ­£¨Pò–bµ/.»ôÝD†á|‚PyÍMÍßRBa§[»Î§gKÂ÷­zþîÝsÕœ)èãç|Ó*Wp$D· ÚËh_¸òº³“§Ÿ^%(ÖtjŠ³'§+1ç/9Ã2ðçiÏ(!΢ý÷ÝM½šÚ+%í­$¦yVN@3Mÿ(ÐzŽv =ÚM P~â&þ?šj¯º±õ·_u¼óé|H4¿˜ErVßîÐl;»vr+±ö)å±îÑÝŸËnQ.(A³Áñ“4®½å‰e˯éÔÎ\=_s‚?ä«œ™r*4Šåß.‰ÀÚOrâ7²Ç¤X¤÷߬#ÞñÀ>€õ;+ö^4âÕþÖSÍß÷cjiGz2‰.+Îo÷æOÛZu==|?}H |Ïò’Që@¸æÔÚÚ ^|~1¢)b0:¤Ss8{õ4~}0øóìÆ¢;²”Ýœ®l(ÏÍ–$ãÛ^+¦>‰c´ó•‰î2GÙ´møì¶;0è€MßwiËØw¿°ù±«öÿ××* z²–ßµikòÄòç2» ßO9lùówfÉÄù¯_]»þÖåE|% í©»œ»j† æD=úûœmžö$à/º ]Ñ}yûÅù‡áÍ‘Èê7—JÀOïNcl¨Ð± ®ìs#ÚÝBÊ£ÓÑHf«Æ™™×~êë—ÞÒi7;ŽRÑj.+ΟoX•¹%QÎÚ×+äú÷XàÏÅú•€'¯Y[»áEK Ý6#ZÓ®»œ?9ƒ?æd2¼ÉñVs’¿ýw@qbËПûìVÓ c¢æZ¦ŒÊKäüvòq¬¡8 8¹#]O±Æ®›W|ŽTæÓ¦ç[ûÎÛZŸ¸~Ïù¿|úÙs,//àwÚÝqUZÊœ6¬rééÙS³"=ö Pu%uˆÓªNü¡põ5««7Þ²x!rx´ñk Wí!s‡¶ü§×”‡7Ý›k'’\™+&ñBûNë/à¯fßèjwP´l½‡‰*ŽtÆ»µ+D÷’v/¬= DÛ•¸?÷jy§cüöÊò žcáÂs¬®,¢ƒ6ž#T]•©ÑO£*¥=ž“«ìСâÊ#ÆÍ7.žüaÅ¡yÕ^ô¸Wjù“×…`6Å€¿(À¯"«ßZî~$ÊvwV‹S]žÃÅÏÌ÷£‡B×5çíV }Çd@_¼§Õ[Oòå7½Jþ['ìÖö$Žn½YøŠ qh£ÛËøkg gÑ­ó¨pO|**Œ;·)ï÷ßä¾×¡rüýè+ä†\9sN êž]ØߊÔ%ªìtG aWÑ­[oì,*1ŠŠÀ﹨«ö"ë‘åTÑ9(ܹÝ%~k8Ë]¡_tHÑ¡ÊØ,–åFC¥¹Ÿß>)šÎ†Õf±ùÏ‘ÔÿÙWñáox|QÓ}&ÃkßNry–Ãj8~HÚ/:-‹"!*B®ëà܃ÚDð÷D„èoùw’öt߸޿Õçþ&ÿš1Ãd’`ýBŸýÎtä9p»g€A×[’ütß×¹¨F#µ íÿð ü곬¸ŽE{ ,Õë½5QÂñÃÒ¾ýV•4íÁs¨\=‡šª`6þ²PgQ¬¿ ü;çOÚ+f.Ó€+ÙZÎ5Á*‡ó(Ö® ¢ÌÝ_÷l·Èïe/³XkL ’aÄññ®ØËC?ø2ù­Z%ïKÚÃÇn\•Ô÷„;DçÅ7±ß”H0ÄUTOÎâLz¿fãàÏÿþV_®æR\Ú<$»H¨’ßj|‡ôôUÖ5;1hùBˆ ‰2dížéQ’F>µW^ÇG¿õ´ü…¨lUgR ‘¿iÀÑC´_òBYp½ühƒ¸ŠÚÉYœ Zþ~•ùï qöŽÒæKÒ±¡q!^Ð>,µŽ«=›‰“<àøÇùTŽÚŽšùÝÐ’Èí ƒŽ"6÷7ñô¨É¦ÊMüžŽ?‘<‡4Þknä7:¡Ì?pŽS ç/j_päí—¼HC˜4ªuj'§q¦×þ¢ò†2g7d°Õß.Ú“†9—#?Jgb1Q„H‡ƒ¿çrIîÈñÿ2,ô‹ %NÉÈ£²Ó™àÞPgQáC–òØûˆà#éë.Ì ¸ŠÆ?9Í{¯ÞÏS"Yð§´'„+Ò~É‹dÁqbË/Æ ŽP;93üe5:öÕó—Û#?ñð·×"›QÁ¯âš ÖàïEðT9[¢£žåEAl)êñÒ»­;=&”G#A!;Ia TÅaáÛoä=‡f9]ð«ØòÞOû¥·Éy×EG±uc@AåÊÔô`Îo(Y¯žQ°Sðz«À/ÅꛋVäfðÇ™áa}…ˆÿ6J¾”Zïa³Ãë¦A;¥RðœÞ‡:s‚É“Zú¼ã[Ö $|42áòä?~æ‚1øƒÎKë¥/’3®KØ¿@åÄ île]¡Îü2ÆQëz¶3©• }â´®\ÑY¸ ‰úþ4/ ÐÃ4ÔSø>¼lÊHíDHúlʨPödóŠT­)€ÐAÃd…G¾î~gjœåfæçdí¥/äqÏÓшªWÎàì©nˆó—ÅúûÕôhú_Ò­P†Äê·–×Gy’}è0¿Ö eŒ Páq¦ø[4nÉÙn‹úïT)D÷Ofe}ÆŽþda#1²éOôìß:Úøè©*¾â>td?½ü÷U]Ö£p‡2TNîAí©õµüeœTðÕö0Äß›u)l«ŸÖ鬣ZÅè(RŽ <ýù–­À†ýî¶ÉvEÊx~?ËŸxö:v‘L\ÿbÛÌDaÂø9Y¢â ø'>Ï*Ó~å hášCø2k\Œ•ãó8³µŒå/ŠÂ’¯!ÁŸÿ~òšÜþó¿¿©W"¶ØÉ–dÛº.iñ±¸+³üVŸwÂ0áÑ¡d»Ã ƒ¨Ž½ÍX¯u\ ‘”ÄeÉC,Õ‰ãK¤ Rð·…Æ!ÀA¨"Ô@»ˆr¨\y gÏø@ð­ÇÍ÷ê,KpQ]ò[ù×›2ò¹8íÕ¨U¡Öë~r™LD{Fõ  Xa‚Ï[×™>ÏE{Ø´Úje„óŸUñVGæm}'™B“Y ˆ¿ãÄ ‘d£GˆBpã â2vâ6œ=S˜°<WXÎÌà^Ã.d±Ÿ7ý Ä'´­^=lü­Åxqûˆû1À$¿K§bþ?ê·7U¶s(¢>e'—ILo”UÿÓ͇˜x倱”ÀŽ*I¼Œ2YN(=ǾêÜþ¾+¹ŠÀowoXåïWÞ°i—8n’ú‘ÕÚqk#‰S üýêûÉ^~36kyöì7m”¶ZòqZð¹äu4Q抇,%£‰?Zu£b)F÷ÙÏco`zß 2ýiò€,³üýª:Gÿ¦Kü ¢:~³ ü€?¡PÍ…ò~Ÿƒ$J~ý܉Î`.Y'x˜Q²Óض˜øÝü’R¢$ûÛu‹%“#î*@ü€é€ŒqèøO2·ï«¢t½uös_/ZÌR¶tqXðoÚ¥—îê+¿Ñ£7|°B ÃeyËÄs¼‹ BH•ƒÇ~œ}ó¯ˆÖ§]r4ÃXþah¶öiÿF¿×#r<œ¡ß]|¢7 ø•7hýÑûü Ìñ¿1=fg˜ood”Je+  ìýN¬ˆ Ù>ƒNg€(3œ-G‘¢H«ßE¸1Qtèà±·±wþõ€¿,½6Èò÷ëÔœ÷#ÊÎ<ÿzX‰¾´cà·6‡êd~CE·0j\®¸­Ÿ`–ß Êtjýí³4 [BvªÔ¦=ö¶¢Œ`5“Fz¢ˆ@ˆF¥J|[Å3D4$à?pìÌÍ3aÎó*ŠÃ—9¼£‚?ŸÝµŸó¯‡éfo;ÍèöIAgóqŸÕ¨6hÃÎ3>süFœµÙêØ×вNp>±Uþ¢ï%Ïùœkv‡¼IY´‰‰R\Ô†ƒ1m ûý7öîÿÎB‡7‘a£=ë-jËÿæ(—>¥9AdéƒV6œ¹™ÀOcü‹ÐYÉþþzES¼ŸIîMÓšÃË–† ¶cD…ŠN.Ÿ.*¢Úýh›ÊüšÆ˜MÀü±w³ïÀwghOQÍMžþ”qþ~Åmý8ÿ¨àO@gLwuUàÇŽ-› úä7UäD77Æ÷óbðÙÇ{bë_düú%½¶t–Øn ÔÏú›’ÏB/¬¢}¨ÔöKÅ ÆDZ羋½û¿·4ÔYÄùSp—„:‡ÿ0s[‘$õ8&ŒÀ´" êøb›níÓŽF´³Ýy~CYâœh`–÷2Í]„¥…oe#µåi·¬ë7 ”£+”P¡tU˜é  Ù{ì1·ÿ{£NÄÖ·Ê,þ0qþQÞ"‹_x–èàëÔê¤:;èVHâ\ê6®ÝT_‚öñî´¤=+ƒÊ¶\6¢åëx‹Oh˜ÐW>qVäBöú‘C¬M­„¹#¿ÊÜühàïgù×Ó§3¦ék Ì:¶ô¡oYzô[…zº‰­ÎZT½Ñ(O‘„Àïešû {¸ÿŽD}ò²^’më=èa)QòœUƒAL€!döÈ»Ø{àuðç÷RìZ3°oÏ ÚSXÞ Öè˜(¦×Ú¤ôl;@ŸüP²æ·½'¶Øüß²¾³Ÿ_ÎÔÜè ¹}Ëd³)ÐF”ÀÞG"ƒ*ñ šé#oeïþ7ö€¿,Î?üÃX~ÈÑðDýȺøÉMŽ·Ê™-YG{-*ŒÛœðf±hà¿Àg 2ÖWXþDÖ£ƒF¬Ÿ“Û¯nPPÑJ2F£Å0yôìÝÿc¥+¹ŠÀŸ¾ü…ÝÚ$çÖ›®uã» ‡~¼R*9êí°òù‘RQô¨½9ºÉâ•­Ï0ϯÇQŸad[œÞ¼Œª›=bÂ?yÿ\óŸ<òóÌÅà/J­m˜öHü&Î$Ž«;±ñßI#Ø-Ü !)Ï×í™u„óoñcî?ŒÕß‘¤Ø( 0jmÿ0¼>¿ßaªÕ&¼•¹o†Àßcù¥ø&^ä®c Ç`Ãä:~dŽÚJaìî3n{5ò;eÜj }¼•Yî-p|‹dÇÀÃ+ÀÖÌmº˜ôÿ©#?ÇžCoÑ‘ì'²ÛÐXà&x £Æ A=Œo"‡º—û—.mØIÀ­uüÎZüä8·ã05Pã¯8Ì/£Fýv¼ vG`´ 006ýf¦g~aºôÄ~$@×1˜Ã0~ŽAîu>Þoˆ)P‚Š²Û*Ò.…(Žï·"ß#‰*mïá¬r„7ÆÔ'¿Ø½LvT†U€üA;²£–½ÞO(õ&ª+oeõÿ‚ªƒñeŸ^JcWufÒåúEëÕølÆŽ2O®Id)á÷Ia'|Ž8È™áÞüýdGi-ëúEfÊ>·Þî.Œ7€#?Á$ob¾ f ¤ªR^K2œ^†ïØV–è‚m¶üvò,?Î!Ín„i'm Lónò‹úI¿œøŽH‘ŒbµËB›ö¾6r²öòFPò“LðKÝ£³8¸ŽAa¨€Ô¢g* ãû[h¾s[™Õ6™¿!‘.…1:Nžu"+´¬äÙ‚> TøÇøI’û)Ë®½-‰uXð–)A¾ôyT:Ô] fPò™ä-™¥/ÉÞÒ˜|® ; Û1¥qÀxуjô¬UW’™¡(Ã[þM·üØ“&V>ìÄywXú¼DWõ ŽñÏ©ÒèC}våO$?ltdóÊ %ï3‰åPòLÄà/ uf€+–µÃ—a3¢?ÆÚ¼èaÜø;ñw“LmâTÛ¿eÿöÐbGa,;`èÁ…ø:Œ_ïpòlÑ49Æ¿`š‡ÿ®—Á†‘a¨=ƒ” Yí"òcLðöÌ üùlnêà&ûq,?ùžãDJ6 pAÜ(ƒ*ÊŠåž =žœ–¢ ㌠Ȏžu@Oo·Þá ?È>>5ü›§ 'p‰ª€7aˆ¶" j[yU°=yÝÿ4£eŽ?Â$ïXø-®P¬©cìƒñ hÝ°:YŽhz¤Æ:@c¨‰*6ºïçÎv»âô›%!°‡Ÿæ0ÿoA¡[râöóÆ$™¬h4àÇáŽàÌÒh»ùOßÑ»MÌÄ6ke¸yS©rÛ°ÍÿF÷»Q—‡ÔüwÎæJËJy¿uˆ£Ø3)ýãâ–¨Äù9Æ›¬†c‰lðQ CÃcÏÂß<¿õW†/=ž+¶%ƒÄ|ɦ@°ñ¨MÐE>A7¬Ù{Êç^ϤüêæZ~Š£?e±þÌ![Û.!,,!0˯qœ7€cÀw‰@¬,À€ÿù øÃÏÖÚ[sJ[Ý%‘|Í€½ÚËŽö´Pò:&xOy´‡,ø3…lC‚?ß­yÇãüD–ÿW8Æ¿ » Û~^âˆuÒäà¡ÇàÏÿ¾ü4üÁç OœßúÓ²g€ÍºÌeS¢­E¯5Ž¼žqÞÕ7Úc+A êàñç’gÛê÷‹ó_VðÏ€ý£äU ŸºÛðéûáýŸ6,¬mï©Ù3@>n¿^)Š%µ½J»ï§Asˆ:?ÂhùˬþzîÉ•/p» þ¬D´ç¿pŒÿäÁ?üÅg€§Ÿ†?ù;øÝÏ>þ¥=½¼0ÚI•K>â“D„Š’m ðP,Ñ4¯ùU<æ{–æÕAàïÇù‹€—ÁoK4F†ƒ¼CüZ¼Í6ŽƒGÈ!²ôî{>ýÜõüŸ» çWwú#Ù ”HÞmL`g;ÂöoV0|š¦yFþW6«J(Í0à/£=EÑž¢#¾Jtþ‹\Áë9ÈãñêûªV£ç3ÏÀÇîƒ?½>üC;üÓÛ-ù`+.½M«’™À^·˜ÌÂ8ðyšæ_Ê;𸹧š3 .a¦ìyÚc(uæÏúù|HˆêW8Î?aŽ»ã«½´Ø!Ø`€Z-XjÂÞ ÷? ¿‡á™Å>¡þ’Ÿ¶rKÞ‚„Ÿ¨"‹kìz3ŒäK!¶C Y…(²ÕU„shó´ù{Œü(©§à·_ä Jp]vx³]‰~–ãü<ãñxxÑŠÊÿû´Bøø}°w:~ñ#†gwúÀ7.IŒ¦¶^g=’Ÿ tÁß ¼+qžñ]æ.Úü"mNZt=àù2øË¥A“‡/¸üPkš}ª.<½ïÿKøÂ#†¯<»Ó¹u²YÅp£HQ„(ï¢&®n”ôø4ã|>?Â߸=Mûþ2ø{%Š½ñ—ð?ßôióæ×8·Ö†µ8*Zý|1IºÑõäÑ/FÒC7©Q$ÉýÚ“ÁŒ -SNí#R†äÞ^’æ ÀÁàÆßÒ@‡e¾‰³ü nì!TvéDè/ƒ*ÐhñÀ;>ÏÏýÜ_›ßò£ë3¨}É ÑÚõ£YT $æ2E’£)€ _y~ûozßšƒ—]§Ž@mPÐY†{Ÿ€©:\sLR'±ùB~€´T"J)”Ž€ÒEÓ´ØS=Ïë«+ü&¾]†^++ë{¾ƒ?šïýß¿ßy÷/ü­ûK_|Ö<í:Œ)‰À!I:­5Æ#"Ék“<[{íC+åýAÅp£S JþŸý£òó¹ê¼øJ¡VÏ}%ªæ«¸pÓQ˜¨Â‰}¹#Su˜1&jÆLÖ„}“FW£ÏW=1Æu¨iX1Èžir÷­5~vÌ3§RµµïV:;1ü;(ñíÂïyZ>óÖÏ9ïøÐê“ƘZÕãŠx4´Dè7"b£”2Éß1êÅH?“(H ,mŒAk~.mëûP´e[¯NY1Üp¡ÀÐúèÁgáÁg³»ëÈçŽ^òﻫMê#õ Òh‹LÔ}SŽ¯ŠªUDUDU=TÅÅQbª¡–qßðñ ÇÜõªúµßy¥þ‘±*‡SÊõ|y‘ÄÀø9|ÛçÔû>x¿úÔj›–ëéëcR g>ŠäC Ý1ñ{Æ-":V h¥”q'ý| üô;ZkmŒ1ZëDA’߆,™Ý¶¹ZÌdš.²ƒŒýX #ð¿ ½{¨cìYV%"JDD)¥¢ÿ•c”‰.ò\GPžƒ£Ä8®ÂqcPJpƒ 4ã“æÐÿsþæï»^ïÔóßãù&qlï™EÎþòäàKò™ç, ¨»‚˜dñglÉKK@œ¯ÆJÞ+»alæ9ù\¼¯0Q"@[bŒ1ÚžuØ$…Æ°ë&ûÿPÞô~øÅ<ž4I®bqG‰HääÆcŒk ÉÚDp 8bŒ«ˆ«Ä8"¸’|ã$¯Û!Úé\7kÿø‹Ìk^{­ùÚé1¦3ù‚KY’¥‚¾üϾçnþòƒ÷óÅg×XªJ‰]‹e_ßÂ8Z¬E–Œ$`& þ0{²=‘Г¼—ÚôYDìíQ¿>­ÃX)B­õ –R¦“Ö¹(ì¶ÿ”áÞ'ú^å8ŽS©T\q# /~Tè.xóŒ1IÍ  ¸Æ·ûGĸ±Cl+ŠžÂ :!CxÕ¬™ÿÁÓ¼ô[¯â–kæ8ˆC”E¾Ô!¦9a›ð®³<ýî/ò·¼Ÿ/5Ú€'’‰îô{6%÷(ˆE‘2JaÍ=í†cpÛÀ¬m>à‹ˆO7×ß‘@)Õßø¾AÏ -e 0ž;èÁ;¯Ãï~¾ûÝ}_ªZ­º®ëVµÖU­u¨cjƘ*Qµ+‚­¶dÀn@‰1‚’n9µÿmõ k.µ¯?Ɖ7ÜÄm¯:ÁÕª—['ª~1JN;ÏŸ>Êÿù%ó¥Ï>ÅÓD×ÑNpæÅ ùwϳE™’í)”EÒÙ€î ‘(B|Ÿø -"i-¥TKDZƘN«ÕòãÙd$%(‹å&Ò7ìõ_K&€Äà¯i­'´ÖƘIc̸1¦nŒ©+Yà;ðUÁC ˆÑÆ®?ÄzYyÖ 0}ˆÇ>úOÜ~Cßzµ\ýòÃ~ùaŽQE.e°@¿¸BãÓOòÄÇá¡?xÀ¤ã©péI‚‡žmɨæµ›*v_ ä‡W"û3þWð©çãÊq§^¯WÃ0œ0ÆÌj­g­u²Ý< *z@±‚Œ¢4ýš¸Ú¹goñ™*Õ ïš=2sx‚ñ¹µ›æ™Ÿ®R¬PÙWg,ÐG¡ên3$ðªà7|üvHøð"‹«>þC‹,<ºÌòÓ«¦ñä*«Ëm:Ï®Ñ0NŽ-!A;-£€®ŸCÝó°¢Iù©Ÿ8ÂD>Àªˆ,ŠÈ‚RjQ)µÜétZ¾ï”í)‹mlx\øÀ_Á‡þ>òÅôP•JÅó<¯¦µà‰2'˜ÈN¬²cŒÉ(¹h1¦Ÿb”)É *U&v€À~­å*Ô„‡Œ¤êà´CBO¡Za;$ F›L 6ìÊ:Žô@†-ˆ+šÿzœ` ’jX ´˜ó'¹€4DÖ nˆÈŠˆ¬Æq³ÕjùŒè­mŒƒ^…wþ¬ðÉ{áÓ÷œJ¥âzžWÑZ§áÏüqø³( ZJfJD’¢0 š{ ÑŒåÊÑo¶£ì{ÛQr>JEç0Qä9¡)eŽlO´'.•ÐEI±øï4òC7 ê‹H;ž:"ÒŠmii­;­V+É'lJtã²Ê÷`&?õyt§ÓñÃ0 =ÏóãIa±ƒãžˆäg$F‰Œ1N’A¶2É e* ›¦Ê+M¥4ƒ”*H¼Ï¼D?EìAß´d— *3‰ßTÿ:j¬¨>¨È¢÷$°çâþ)øé*@;¾‰$TÈ’DXÁðÕÊCÈæu†ÓDþ¹†¯È ¦„ahÂ0Ô"â;‘¤õþŽã8ƘŒ¥‘¸4Â8"â&+¥”EÒ\¥ 𘥑Ì,‘ó3†ñ9zþ¶@žÉAHŒÒøýŒ_U¢4…b9Ùm?PÛ ’©ÆÌ)EßL/ÙRˆ Ó ú¢šŸn;bëocL>––B(¥ìÏ…ZëУƒ Ðù‚½Í‚í–´Ft³®[ªÆ‚ ÐA@ :¥”ÄŒõŽÿNã1x" ;1x“¿‹>«¬ÏØÊ Öçlàç•#¸ÄÇ.…®Š” ’Ï[ï§3A2ÄE…Sr"VT$u>RÒýYS)éáâv3½ ï±î¹¸BkoQœ¤™’ˆ¼‚ˆH&ÜŽŠD³q¹óȌǦau3w–^Õ-{'ó,DU€h­ -«RQ±(]©d[xcæéOþ3Êú¾XŠïXG²Ïø÷“ã€ÞÙÀp&ûM^'À•0-qi^)…U{Ÿ¼_”¸,NÆÒ+¥òN}ªÖla—=§ÏXüžHleÉ+”6‘¤¼H ÎaËß3Æ›âgö¾ÀOÿ.üÒàJÑÜ7ûnKgÑ ‰-£J¨FæD°¬¸½KYR°ÚÖž€lÏûb›ý~T|ƒ7^8Òw€x9\œï‰ÏÓŽ—kù˜9äÀ_âÀæó1ùéžÏZuü)xãHÇçi ZQFw¶É¯‹þÞTÙº(P^â×ïûsøáß0´6Þl” dÏvÛj[²­9DåÚ©R%4ÅÞ ô˜’€9·tÿ6øµÖ„ah~ð‰‹à8Žãd”ÀXK-à{æ=zJ -K—>&€Ö˜œƒmƒ=Ù”;Ô²T }>·­²} @|ú5øü—á_½w`¶x3u½Ÿ滶ö¤m§6i23¥`Äùþp¼¿ä‘ì+æËöGÓY"¿}ÀO˜·¯÷s;&Eãÿÿ÷¦e£ì0œ%tEXtdate:create2016-10-22T17:14:52+02:00cÄÿ%tEXtdate:modify2016-10-21T19:32:38+02:00ö[NIEND®B`‚Slic3r-version_1.31.6/var/Slic3r_192px_transparent.png000066400000000000000000000512051301441720000225220ustar00rootroot00000000000000‰PNG  IHDRÀÀRÜlgAMA± üa cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFbKGDÿÿÿ ½§“ pHYs  šœQ‡IDATxÚí½iŒ,KvöˆÈÌZzïÛ}—¾}·÷î»÷¾ufÈ!=$‡")’ÇÆ0C°!‹[ eÊ(þ¡?þaØ? H–MB‹ Ð&@K²I #ÒcrÀ!Gœ!gÞ›áÌ[æ-wßúöZU™qü#"²"³²ª«»«·÷Þª«:«*+—ïœøΉsNÿ©ºáκ€€ÀÚ¶À—ߎðhKâáºÄßTx°!°•*Ì45˜ Bôz=äy!¶··Ñjµ$ Œ1`f(¥Ì "BžçȲ QA­5ˆišZ­V±¨=¥”Èó¼Ø!`Œ)~?Žc03²,ƒD)%Œ1”¦©BH)¥ ˆHåyi­I)Œ1Ä̤”ÊŒ1dŒa)e™ ˲Œ£(ʤ”š™ÁÌRçæö)¥½´îÎáçüñi­ÑëõÐl6Ñív‹óSJ•öÇÌBòÜ Ís|úªÀ¯þÜÌKÌ„qñ÷¶Cu´¨ýXj„±{L1s+Š¢v£Ñh:RJ’RBQŠ™Zkäyc Œ1ÐZûm¬µæ8Ž@ÊÌ;z¶l¹×¬¢|$åc8z!€)-³Fcjvv6I’D4 $I¥TöpT _{ñŠà­;3ûQ†ºÝ.u»]dYÖìv»Í^¯­5Œ1 "#„èx «]÷œàã¾PG!+Àá ¹GÀ €¹f³9×jµ’f³‰v»F£Qº1v½ñŠEZ­V±]kN§ƒt:loo‹^¯×dæOû`•à1€ ô•bÒDåÄÈÇ p8âÍt›™ÏXh4S333bzzív»ð3¼ßáA? G„ÒA¡Ýncjj evvv°±±ÍÍMôz=h!. !$‰aæ5<Á‡pdøX&+žÞœ1Æ, !¦äÜܦ¦¦E<ý¨¥:šH)1;;‹ÙÙYdY†ÍÍM¬­­a{{yžCJ)ˆhÀbE=cÌ3ßð vT8õÊð±\¼µŸpŽ™ÏÄqœÌÎÎbaa­V«ˆŠèG 3Ç$¥Ä°µµ…µµ5<{ö¬ˆnH„K–¬x;*d8ÅŠð±ì_<·Ÿ'¢‹Bˆ¹(ŠhaagÎœ)ª“¤6‡)^ˆSSS˜žžÆòò2?~Œ§OŸ†ŠóRÊùf³™ !¸ ƒS¨+ÀÞ…cÌB’$¥”³RJ,--aqq±~žçÇ}œû’pTˆã+++8sæL¡~þˆ(fæ•f³y.MÓ÷1`C«§F>V€½‰0¯”ºLD3D„ÙÙYœ={ívyžŸ8šsñ£WǸxñ"æææðàÁlll”&¸È$I®c.c>p§„}¬ã‰0%„¸¢”Z0Æ ÕjáìÙ³˜`#*VñT®ÕjáÚµkX[[ÃJ3Àn¶;’R^cæ Ƙ;è+‰•`´3'RÊ‹J© Ì,˜KKK8{ö,¢(:µTg?â&Ï°¸¸ˆééiÜ»wOž<±ªwî.^¼ˆ8Ž@̈Ј€fÄ ˜m0¾u/ZøKÿÛ™WÿÏßo/nkrè*¡ÈGZˆHDQt¶Ùl¾,¥œìl4¸té‹Üz ²N03«$I.6›Í+>ILk$I°²²‚ÙÙY¤iZ€½ÝncqqQIc¾Šë£.Dö! ħXXœƒwï݆É2H!Üûö³q“ÑNÿÓïÌ^ëå"ú?¾qg¾ÁÚ•æ s|'î $€ˆ!ÄU":çîiÏ… 077‡4M‘ç9’$Ák¯½†û±Ã7EîܹƒßþíßÆïþîïbkk A.ýGFˆ\Nˆ³ÙR8SM–Vè<Ãâââˆpïîmè,C$ ‚!œ"( kü³¯L¯>ÚRÿæskß=3£S¡ °`÷€?´(ÐGíÎ37£(z.I’Å°ðDÅÅEÌÎÎBk,Ë$ ~ê§~ ?ó3?ƒéééb'çÏŸÇ•+We¾ð…/@k]ÔÓ~˜%8‰²ø×䬼 Àè ó ¤ñðî€5¤$WÃí?qNã‹o%Kæÿ^?ÿgÖÞ\×=˜ÐŠ|”Æo‚MY¾ ~"ÂÜÜæççADE¨ó³Ÿýìø½œ9s?øƒ?ˆ™™™}h´µ.à ßóï+( Ä`bùÌ".^¼€$ˆ#Q°¨ÿ|~†ñÕÛÉüwÆ-Öÿã`BB¦¼«úàŸššÂüü|Ñ¡!MS\»v ŸÿüçkÁïeqq333E:À‡I¼µ/ €iÝQ»úf£ÑÀôôtQ­åÓ}_|ñEܸqcäŽ}„È+Ò^kwOšP𢂩€?¤:þY#Dn7b(ÒX9õ°½ùRZ§˜hCú?ûõwò[ #îìo(v S$pˆÚ!>™I’`zzq#ŽcÖn6›¸téR¡ÃäÑ£GX[[;õN0 ýǼàø¢28‹/œÕ—! rJ  …`Ä’±ráÜéBg0Œ!óŸ~ßú{?ùêÖd$÷?2KrºïÜ.bm!p½cÚTÀ¯”ÂÔÔ”RE _ .¥D’$#÷½¹¹‰¯~õ«X__G»Ý>µÖ¿üÈQ¦;åp§}–²~)Ü6§á{Š"¸cåâ Ý}YžéÏ¿ºqûßmë4á¨Á|HÀÞ8nn§òÚf*gf› ?wå#>ív»°ú¡¥—R¢ÛíâÞ½{0ÆÔÆùó<Ç—¿üe|éK_‚oVu€^T@²£Kè\„ —àJÚ÷•t¯E_ TáähÌÎ"ë-êX~ëöŸûäæ{0ø\>tQ "@3'wž©+¶ÔÂL£~/F­V« ”R€¥”HÓ_ûÚ×ðÍo~sؽ^_þò—ñK¿ôKxüøq±ŸÓ&Uð¹5|ß?B`+"iqðH¢rt§ðu$@0æs·6oÿ¹Ol…à?rë|ÈF•P_y7Yý—_k½¸”—Àïßn·Ký+«l’$xë­·ðË¿üËø™Ÿù¬®®666ðÅ/~¿ök¿†`zzútƒ¿æú•"<«/C^ïhŽy* DákÙçÿªˆû "ý=soÝýSßzÌ“^“:µ=íëC¡T„Þ˜~ÿÝøü¿ü£æÅ‹KzüžúDQTt9ðÍ\C ! ”ÂW¾ò|ç;ßÁåË—!„ÀÝ»wqÿþ}!033súÁ_ sŠa\?˜¸RPÊ€HÙm~4ˆ•DHü6÷æÏœó»ÖÞOü{–S­þŒwR‚è÷¿/üÓ/·¯,ÍšZpÆqŒf³Y¼ç^'B4ÂÙ¬¯Ðl6Omȳü태¿mÊ`‚Kô­»’Vâø±,6 NÀ@˜W§ß¾ûýgß| Ó$CûN˜;Õ  „Mbû½7#üÞ;©ß{'¹F²¡ºõ‘R¢ÙlÑÀ‚Ü·ð&q¡Óz/µàù>ú#@Éò;Kï©Lhéc§á¶p°þ‚„!2/M½sïûÎ|û椀8å ØI$·ŸÉËßz Úç òšlå$IÐh4¨N]·åªœfàCBC&·ŠÐf¨¢ ìHZ'7ò#€ê+Dü–öÜœ~ëÞ÷.~û-`¨å߯B8UúT+€3ľŸýÍ×[gVòð{Ç×S—Z.m´§ÎÙ¥`R‹úÑž*ðci}€XI@¼(I}Ë2·ÚoßÿÄüwÞÁ ø¬ð}”œZ`v2З¿ÏþâïL¯.Í /WŒ¢¨Èóù( Õü_übR+´ú!åQËï@ŸÖß~Æß9¼×›ß½ÿÉ…?y€A{ö{SÂl}'ÍN  Û#üæ7Éÿø[Ó—ŠÊ”x?ÐçþFã#eýGÎîÒ`&g|Qk†NnÐ8P€ø±¤Ð,ÍÅøݯÎ}«ü“°ü«; €˜¾õ@ùý·’¹•3ùø½DQ4Àý?2R—Í9$Ì©*a˨Bo…@ý°§"0KsA½ûðSsß|G‘10Dî ª`=è ™H©ä©S¨gÀðÝdæýÖôêüt=õñqÿ$IŠ…í> RÍèô–¡õ‡íÿâÃœªbù£€Ó{À‡t')” ¿`fY¾÷èS³ß|+&“#uàöw.#N±nÙ—B®T±ÿá[qüÿÍôÊ“m‘L5ÃŒ»Rj¤õ÷ Ɖ©KgFüáÄ–”º#û–½HeP6…Áo³é „DQA‰”é2Kâö£OÍ|ó͘MŽrØX“k 7ñuªFÃà­TÐëw£ùßx£¹|~NC×Ðzø(Šü’£µûóùü»¥=Ÿ©F{lI=ßiOhù‹œ5œöÄŠ‚ˆsxIððèµæoƹΑ“ƒ!aן¬=ý™¨œž€@iFøÜhüÂÿÛ^i%Æv "ã¤4ûÎf§]¨òZ`0­!tvUå‘>ºã©MdITIlS@âÁ_(€HšEsûÑ'ã×ßl˜y5ãÍ(7ÆvøqGãí»AÈÀ…¬`bí>9þ©V#?¡HNò`OXÝ.áW¾ÒlþÊ´WڌݘŠ”Qíjýý‘¦)ÆqŸï/ Jïп¯Ò ¢>QÅÙM*´Ç&¹Qÿ3í1BòB÷ÎãWÒ×ߊ‘å$ÃK`0´? ô;;x‹O°#‚ƸȫÿDyêIŠ6¼ÞôtGÎ?Ü”f2žŒKi¼#|ZÚVCàCÁ_¤$Wª·T%Ü#‚çûø¥$°<×½ÿìåîëï4M¦RŽæ¾}ÎÑ_R[‚ @Îf)€ƒMËL¬_ÐIÒŒðo¿•4þÅ×›ç¦[fä){gÖçøëÔj­ÑëõŠá“(à Y°øEÕ—e‹ï!ŽìÌn8I@‚Šç:wÖ^é¾ñv›2ËùÃÞ=ÆyeU"œCL@ìÊab¤C<Ìñh³¬“fòJÃ3¸›ÝY“³ß¾§¦fÆ´þ{²çþ½^ïÄŽ# YÂ0'Ê|JÃ@| ¼éÿ/[þHØ”fŠ;·×^Ýyã»mNs0E¶ð–aG»†“Í?¾­ff[»[`ü"—ÒO¹Ïw»ÝÒÒŸ'AJÉlR¶ˆ²Õ—Á×øe¥/gþ¸~‚‘ Ýû[¯l¿þAÃ8ðóˆ¨ #‚?xr>Bß9àFÿÝNýP¨—“¤%1 ~÷‘’_øVcÑ’v?o"*`¯ܧKïìì”VC?NUÌæDÒDz Ú#Ê–¿÷ÁNp©Íʦ4³PXÈïm¿²óú–Ns€”¸ƒ` êCRø¸¿ýßSŸdPVŸ'Dõ§#hŽ{üwyð¤Mø?‰“ßy+žŸmíÞ5)ìës ževvv ‡úØ/ȇ·ÎÙõ#@-ÝQ#R‚ð¨U|Eº×{Eýa= ¦ß–^T <2„ ô}„Êz娹¥•çêë‰ÈIP€ýO3âžJÚ艙ïܦ¦Æp~kÅ2£ëßét°³³sl Pgù}§eoõýWÑ–\Öp~7Á9®ß(q(h'A0PXŽîg¯ÄßXkÈ”AdY:—/Ší±ì¿ü¿wúÜ °ý•?Q3xêÁ·ê^OLNžLÀf‡ðëÔß¼¯f¥ÿ̪~ÌŒííí]ó‰éôKZ¨R cµ¿èsøR¨³n¢+px}b f‰sÍ{úVó8K ‚"Hy \ãÜ[Kf8€¼?t.\áp*Ì¿oÿ7 ·_+9&1:¶÷PçHaqÚ๥<ù7šó³Í£/côK¢nmm!˲# ªáÎð¢?Ù%0X¾:°ø£JÈ3¿ýà?Ûz o;Þã.,øYB²€,Öó­Rë±ÊQúŽ.P{¨B=’Åñ¼§PÝ–á_¿Ñ”_y/š‘ÒwÏÛÃN'¨^ 666ŠI²ÃP„ºô†"¶Ï}Þ/e¹+s$l”'ìÏGå8)Ú#û­ ¥£=†#œoß37^Ï#Ù˜`qSaé¥Ì]žG3I Yð%7çë“Ÿûyú\¬HÀMˆ•?í% ‹Ê¡ŽÇ¥õ(b`~Úà3Ïõ¢/¾™ÌL%ÇÛÅ¡ª‡‘5ZÚc M¡}ð« Î_êÌ\ïûÌÎðGa´‡%–[Íù׳FÔ±¿ÎLˆš /71½¢0w¡‰¹ hÅ û™]3ªÑoùeËFömD(¤Ic]¢IËq)À*’qC6>X“SÍx|úô;I§Õï3Ë2¬¯¯e“P„jxSø¨¢> u‘U±ü¡Å—Cª¸„¿ÂÙöCskñëyuãÀ¯„¹´ÎIȈ2`v¹‰¹•4¢’ËÔ‡ ðöGƒòÕN|y0¶Shñ™Á[÷¡êg èfį¿Ñ[e3Í ò„x(~‚-Ïslll Óéu¹¥a?‚LÏ çFDz’رË`†7l^+lb›f…¥öCssñy#êØŽmÌ€læ^ŠÐº Hb’˜[ncîÂbArÿ>–ù¨ ƒaOq!úaÔ¡—ê0ää„A Øé~óë ùµÛÑÔ ˜ˆßXw}}Y–¡Ýna×½Œ:azCõy(øçZÿ$rŽ®s‚#ÙóËÀò3Kœi=曋¯çIÔñ–ß‚æ¦Bó‚k€= %€ˆ3禑åúÞCc*à…{_¼„®pßÝžPq´÷ôx>f ~üV/úÒÛÉìTr“ÑЧD;;;X__G¯×€±Fƒ’© n|©€]‚_t§Ôº$äûç'ÄQ†7rŠ#Á°Âbû±yqùëY#Þ¶Gà ¨˜¹¥Ð¸Ø?) ˆ k`fe­3sd¿’žðï° €Ê' Æ© ;459Q#$ðxK&¶dkº±7þ¤‡¤Pk­Ñh4Ðl6GÖ!PÍ?Ë÷þìn©oOçÔzË_(A0ëËòìnäBJ†#œi?6·–_Ï›ñ6#'‚a@%„©›Ò‚ß8Ë_9V?ùK‰¦.."ëuÑYß@±é{\³}ðQ{‘ŽFŽzzŠyž $€õŽà_ýƒ}÷‰ˆsMEDd¯rÔyüÞAöQ¢ª“LTFq¥YWÔR¥eI¥'¿ö„½{âH$•¬¾6·Gs„3SOÌ‹¾‘·š[ ®kphßT}ð×…œÙâ;ÌÝQ°‘¡dªÖÙ3RØøm…•}*½*5 `@ F¤H~ë^Ô>Hôç¸ Y<Ø»Ýn¡½^Œ>Æ_P Àò‹üÕ8þËïzt“\¾€FGX˜~Ê7W¾ž·Ú›ìÒxDBhÝPh^¶Ñžü¥¨ Û÷Âk*àJÏ2 ¹ê¢µ>f¼Fv—„5Fgèî¤ÈS‰Z9ÞÞíì” ˜K£øPŽ©3åñ+áõ"¤9„íGÍC t"Ÿnf×Ï‘YîOnÅu†ÉSd&a„QV¤‚"X $±S߶¤ð¸èñ)ˆ`òósÏø…¯gSsël§`9ðãZüu}ª,µÖÉ[ÿª© jù,øƒ÷@FPŸ2ý¡Ò q}MÀÐËŒ ŽG¡»žZ®{‚lJO8À)c`Œ9òf·E:ƒûSÜóüåJ.%‘ D ™&K¡ È!aXÚ~ƒRA)EÊ~Y"% ’t&1?÷Œo¾ü|zî£GÖ2SDàë |u|ðwÆØô ~þ£: Ø»ˆ3‹à'@›Q ØârǼóS‚1ä†ðÁš¢'ÛBî5ÿ¿*ÆdY†(ŠŽlY¤jFLAá2;Ñ_ŽHqúÈ5œÝŠ+vv—+ a¤°-—Y‚°k·ÆYž`na“o¼òz>½ø, = HŸSÐW¥=@çífùý6F÷£@uÎp©Ï Ðâˆí-«Aî„ NþóÅ÷ö æ‰(Áñ+l˜9Õ ­YÑiËQ/zQâüT1t cü¾-yÝ’D‰"먈ùÇŠ¡(³u%àœ¡µ@–GXXzÂ7^yOÏ,´ ¤×²ç¤=’!:Úc`)OÖ³CsØÑ­: Œ9À‹‹ÀÚcˆõõÒäX](¤@ÁeÄxÀþŒ2~÷‘½œâHîðŽpžçE²âaú/ËOýÔŸÛ_Zq½®IUÔÖßæÛú3½D“JÌ.tøÅOWϯltn(ºÏ)ôø)]N~A{Ðn¬hgý«À¦dŽ$ÌùÈÎDš©léwŸø»Â>;T{`,4kCx¼-°Þ$ÅÁG¿èÅ¡žXM´'Ìñ Á_ZqÝQŸøq¥~·Èî$ þJb›¿Âüb‡_þÌûzáâ–AîÂ$kÝàÿ/…<ýƒ€<í[ÿaÀר‡e€™¦g RI\¾h@BƵ€®æ¸ÎˆLÄsÕZê¢ÃÀ_TpUsøƒ\~UªÓ-'·yë߈¨´(u8Ãk2…¹Å¿ô™÷ôâ¥u—ÕiR„ík;»€í) äý ­µ¹m¹¤±¼oÈ΀”°þúÜ°.⳿Û4‘›{"€íÌ£M›ÀicÐívåX«àU‰JV§çû‘[a¥Ú¹QÉçO¢>åñ)Îýí&—˜[èðË?ðž^¸´ÁHÉ]<l='°ý‚­& !>Юà'úL³²Å¯F~ªÏÕRFÒ€ž7ðåó"¸lÂ=ŠÀ£åD(€E¾Kf>àÀú“ngRux=·§àWüQÇXü¦{$ hø 0Wêè¿+!Ï$fç;üâ÷½¯.®ÛP§aغ"°Z~w ÕÈÎn–ß0ÐëZ׃?|h þF!`)Ï/`ßy½cɉ÷Æ; &2Lë_ûkRMnÀï·UòùK àÁ$µ–¾Ò«³Q©Î×WÁôfç:üâ÷¿¯Ï\~fÓ Ûëæ­ëƒ–¯´‡öœó‹á¡Ïû8ÐáÓ@¶xÜhÖ¦;”­ÿ~Iчcˆ$èêmÎN›,›P*1¦(W<¨Ôr~?×4Ìò;Hdßé-ó|kùí)8¿{("èTaz¶Ë/~ú}æ’Ko0Ìø7^`åÀX~/cY~²œ?ݱÖ߃X´§ÚÁ¡6óĺ#›™qÀ/§@œäîaŒ­Å‚íØ æ 8~ɲìÀ£@-ø¹ÏÿÃTfYÃùCð×YþÄÑž$¿rÔJg ³s;üÒ§ßË—VŸigùm¬`óªÀæ ¥öèªtd,ðþ»d9 ©>Þïÿ¯s~Q󛀴Èç%måÏomݯHSÆ>8Ä”ÐËah¥Ãįú²_©Òžp–wWίúœ`ýÝfÈû#*ßG{$&S˜™îð­O}/­>3ÈÈ]Vææ‰õ9ÿž€üHSÇýM=õ©.n1î¦ȧf‘7[¥íéϞoÑ¿h °§Â…H2Vç´97mR=¡DN? Öëõöå ‡¹=á ïnÑžpÙÑ"‹3®8»Qßò€_Z+ÌÌôøÅO¾Ÿ-]p–_3À‚Ëœ?µY¿®†+ë,¿Ö@oËÆýë8¿©ì§ú;Øm› ¤ó‹¶ {àÓy.äø™˜Ú ã‡oö°4­õ$(P(Y–íyÙ£a‰m»YþR £_tÚsýpâ+àüE›rþ<ÂT+å›/-­<ÓÈÐÌ`¶/KìÜTÖò;οøF€üºÛ6ôn«F€Â}Žú:Èfçí:ó:ö¾‡¥{:±fƒñý7R^š2Z ݛԸQ@k=žTf+‹¾à»€¿nE–FþRœ_¢¦]!`r…©Vo¾øAvöÂÓ)¹ç²D熲oÀù«RµØÃ8¿ÐÛÒN?¢úÝa^{ºÃ0Q&Šj&ÁŽÄÊ’ã€“Ó ç±4˜T=Kè w»Ý]áêBtE—æüE[òÐò‡=:ër{Š”rmÊûÖßïËä íVo½ø~zþâ“ yþîe‰îÍ2øk®á@x²Îòk² ÐëZêãó}r NxÕY÷}•.Jt~ÞÍ ûö±(ÃIQ"€¥Äî‹íCŒ1èt:{Zü.Ì× cüBŠ†Xþ0ÌWÛ(¨å-/l—k…v3å›/Üî;÷4CF@æÀŸ^VèyÚS™äê_¿Á•G?íÝüuÖ>¤>À þÎ8Ò[‚ò°ž’œ €µ²Ë3:o™4›`Ec8 t:ZT¬¼è_‡íÉ믆О0Å¡á›Ô†à¯›är£‰Ñ íFÊ7¯ßî?WX~—’|I!»©€ˆ€´þë,ÿ0ÚÃüÍr¼¿.Å!T¨ƒÞb C¦È>ž¤µ?оN†ØTZž1éÅy½ÝÍÇë‘1®øˆP§ÓX ~ ·ç­¾ôˆ2݉à—’Úª“\²Æòç ­FÊ·ž¿Ý»pþqMäÀÏЗôÈ‚¿2ÉUGuüëRüÞWr9 {ðç•É®º /`pT¸gãÞÒL¢§bØ8÷$‡íë0à{>(b>7£{Y&…fY†­­-xÎU›Ø&Úò~ÏýU?܆<« S”&»d=íi%ß¼v»wþÜãÔ.'Ê®WþÅ|3üýkTzm*¯KÔ‡Ë) ÝÐÙ¨Ÿé­Ž»Ü§=CŽ]yåvs~OÐ#“1SM£_]É;úzÄô—@í¢ÛíÙŽ~þ=ô-=PH{J+²FÜŸðJÂ…¨«ÛBð;ÚsáÂãÔ/ÚZ€[±íBОqÀ_L\“\šm¨³»e ]vKs¨þ^ݶ=‰° €èÅsÐ$'|wO$Úû ¢vÄüÚŬ)žh(´t`¬±½½<Ë!•">@™ó—Ò|+’øøK׫³Hm}¿!ךIÆ7Ÿ»Ý»¸ò(ƒ\f%ƒ.F·PÒ·üu£À_ôð¶ãpwÓ9¼CfyC?ì…Õ©-6"¶UÑ“½¥ùòq%í–¦t f} !ÍRloo[Ë/iüuIm>¿' ݨoù‘SéÚ—DèשsiiÏówÒ••ÇY1ñb%†¸•ð{©›„*¥+p¹„1íÝ ëãüÕD¶aÜ~à÷·8ïÙrÉ\FHe|’"AÇ­e!ÂÒ¼é]˜5;Ýl²Žpñ®%M·³ƒn§)¨ïìÖYþ!Ñž¤’ÙÙˆ}·¾Ó«T_‰L®Ðˆ5¿pývzñÒà ÀA¾”€š»ƒ¿âdî[}ÖÁín[¾Ÿ¥ø4œï›!¿ƒš×û­-ÿ',zqsÂ7öDR }9ÁãüþÄÍî“íÞäáÂá-šfƒíí-d©õ Î/û”% R™‹H§=ÁÃOrŪŸâàG)“I$qÎ/ܸ“]¼üÈ¢ÁÀõF_‰ o%Öá­äö +h)ßÑ ëZÊÓÛê;»ºbù‡¥7WãþÕ×û!ly¥Ñ}Hä2q¯'5 œj T9¢)eÌ÷]Ív˜È 1¥¥ˆÂ—FçØÞÞH‰~“ZQïìVÞp’+üŒïØfs{$’Xó 7îd«×f$0 è¼åüh ‚耺òC†?yfßÙz½r^Ϩ~>×Èë}ßOXúÞH­švŽ“!'Ç c‹@ÎNë4’ m6„Im¥fÅÝÉÓv¶7!È Š¨Ïû«é Áìn2ü¾óCaùs‰82üü‹wóÕçæDLÐdÁó x©üÕÔ/EL_Xj£µ-bélØ|þ\»íc‚å™øI:³â&²x¢¸;‘h\áÊ0.ŸË;/]È6w@ƒêútåõw•°-³´ƒîö$Ùm¥HOÌîzî_¢=C²:3‰82¸þò½úÂÃœ$Œ?ŸS0/Ž¶üÕ(qjÌd£;½mëäv7mC€ãUqU÷]7(d;(-»D#&ìŸH t ­<¿¨Ó½Þ[Ûìío7‹wú“•nmÂ6œR‚Ñëm#ën!RTÌÞ6üDWduVÒ|{X~Iıáë/ßÉ/ß|Ki¼ågðY }+ÞÕòáNçܲ£:ÙÐ[·ÀO}ý®nñG•2Nšò„7Àä–þ„"ô²še Bö{ÂÚqw†«<ÃM)æO\Ì7IìݨZ~Oy< ’R||^$1òî&òaj¶e;2K\”.¤=à{‡7Ž4^xùž¹ôâ-Àd{ô³AoY!})O¶ü¾Òžaãçyj‹Õ³ÔFT´q4G ŸÔ–Î<,ü9Q@¾í¢?á 1@§#…B<,¹)ÀÂÈa)c¿ši@2bóê•tûêBÞy²-šSc.™Z*dAP–æãû5‰m…Ó«‘0н p4mÄ1!¦\Ïë*¹ü"üJ:˯×_½§/½ô@ 0ø½e…ÞK fŠŠî Å9QùÙ¸üð<µÏYfi­ ëG}v{ŒþIÃŒàÜÖ”¶Ã*³Îy-ó•*=JN$÷ÀxÈVº´œõ~òV÷ÉzW`¬:– í!¸ÎÌ¢Ò9ÈçD¹9m#ˆ•I7ÀùŠÑJD©OgXîX(€¤ϽrO_zùʹãüÙ’DçE=Ý)õ¥ß² Ý°t'ݱ–ÔÇù]VÁÈfµ£W&øá.zÖqÎoxS„Ufm9â1Žæ#RY'†h&îåbïÒ泎ó)ÍèwYdÁñ~¿ä/Wl&‰2àlÈ6‘(ƒf,úþ@M´‡s‰H<÷Ú]}åµûF*c-¿b ;#±õ²‚™#Ý?Xf€3Àt-ÐCÐg;.‚ÂŽß+9önù½:øÉwºSÿ~Ö[…^ÒìYÓØ¿@Æ+—³O]Ê6¿ú~4wfÊÔæ tn@¥„1°üaR[˜Øæ37›E>@C1D¾N ¢dI!’‘àÒd™Î”2xþµ{æÊ«Œ”H‰ ™ÑYظ%‘· ´m'„XϦÿlk '¶ŠŒN”¹þ8ïQÒžð–§î<«Ã6k@÷¼ŸCB†Ë‘(ÈqS áŸ3 ¥Y“ÿØ ÝgÝ´>-¢4ÉÖï Ôæó‡‹HûÂuŸÒÐ ’Ùš1ÐJl~¡wÀé:$zÖOPT€ßdRϽüÀ\~õvà·3¼Y'—%:DÐO€|È7| Èw€¼ ˜ÔZDOoÂ|ü»Sž:ð×]á•6ê“uêßÓ™S|RìsÄC8ìã>€¡¢‰ZÒðŸ}¹»¶º÷6{Tkír÷IPò|ßgu–r÷+=:CEhĘ ¹ “®ƒôŽKqй„R×_¹§¯¼vO+©Ì{†ðø’DWxÃÒ“[+ÈÎÒ“°¿)Tp ÿ8ÀU¿{Xà'Øóêm¡vÅy†›(Þ›`ÍßÁää*[˜¼´šíüäÞãg1Ðfµ:ÃëyQ¼"ËY‘¨/^)Uqùüžˆ\ÞÍñQœÂô6aÒMèÔ®ó{íŇúÊ«÷Œ’n].Fgšðä’D¯M> èÚ!°{x©rvŸÇ_ÿ8Ÿ*Ø«\‡I(HÚ¬Ó¼®%YËŸ—”톻#óN¢pqÃ4ÑtlÌOªód®it§Úõ;¨ß-¢=¢Òª0X”"ª´' ­‘ÜÙ.Í çÛ‘îìÀ¤ÏpíÆ}å•{Z c;5 ft¦_’HøÃûXååav¦†KgF=øG)A]”ç(í«§>év?æ\zŸÝ3á{G21Öáâ¾÷ï”@ðÉ«éög®ôÖ×vdÝ(*A¥oO± ¤2;¾_?šÎòûˆ &»ŒP‚ñü‹ôÕWîi%s +,øw¦_‘èMÙhÏ0ð»ó*?\‚´nAŠqBžÃ¬ü¡Z~²´¦·icÿÃÚµä_`¹©®ùÔ~äÀgwØNðÞ°ú M´Ø6ú?úD÷‘a gQšÙÚ#*+³ÈJ>ÿ.¼¿Y¬Ç„:Ý(ÂÚ¦L\i[?ÿ‰­<ŠØ-Gj€Îáé%‰Þô ø«çRþº¥ˆöúa<ÿPÁïþø\¤:ð“t×½ˆrGvðúàÏœ TN(çã'^î¬îÆÎÓ§ÛŒHIDJBJ*Op…Št…ôUÚÓt»&W¿£s~“ ®ßÚÖ×?±‘G’\«‰)ÂÓËÊ‚?ÀåéH©‚ £-]¾>×<øËûÓËý‡È&íqÅà«°Òÿ@ý&Nô°—ƒ¤Ï‡ßÒ$Î/èì¯výnºýT?z²‰,ë‚Àˆ"‰8’vvçüzÚ•fy+?î?'ŠŠÆµ–ß1®¿°¥¯¿²‘GŠ.0£;%ðìŠB:M5œ?|=d´ôUÎï·U¿“\¡as“z[#îhhý«~ÁÚLä,OÞÀÁàßa@0á3Ïëí?ÿJçñÖæ:ž­­ac} ;MäY‘‘D#’ˆÝ"su}ù›Ž÷ûç°c[8ë„?ðüõ-ýÂ+ëy¤˜Ýr¤Œ^›°uI!k׃¿Žó¼Ÿ+0Æ‹ú £#þqÃœÃÒŽüÒF|º6¥aägá&Å‚Z`Œ 9Tmò^dbg{’F†¡.N•ä ©æ?ÿQ<úâ›4û‡Ü\™·9þ¶o„å9L0È¡ ¡RR!‰Íõ‰_){fK{ã¹Õ}ã…<Ž £GÖò›–€¾¬ÀÓdÕîþ’p=àw[Šh·0'p4–߃?ÛÁÈõOHÚ¸]J„!…üx&¸N¨¸®öfŽ Bzõ2:ÿó¸;Û„éå­‰VhÅö‘D‘H!Ío€Óupï ¸û¦·η ‘B †R³±½vaG¿p}=•zÎòë¦@~Yg„MÉü!…Ù øw+`?Òh»!Ýuþ‘wÐöímº´‡%‘ȇ(ó±LŠ¤`Pê.’†PðÓ߃gr‡ýƒßâ³KÓ}g7Œî´âÀá€Dj(hcWñD* „Ì%zBáúèÏwt¢\bšâŠfDyÁ,Œaù1îÜÿ*_<Ê9Toù{øG„ÞIÚ°g6„"1€;nœ?rRF þ–·y ©P‘Ä0é³xüCÏQg«´’ Ì÷GV¡Tp[ÏKÂ@"CÞëBg;¸v~Óܺ¾©“(ï/DÍM: ø÷:«;l¢ë(m¤¯Gínùý4úó&¬ÿi`ƒeñÇ–q” 0îÌp_hèž9Ä•%ôþæàá±a§qå•'¹Â~‘$0˜Ï_楗' )È.DÝ ¨Ë b‚à5ñ5¬Š 8bÚ#¬[¢=£&]ÝÍêmÙè I‰0h¡ƒ$'eœüª‹v‡è üø‹XÿËߧ™±oV¿áÀïéQõ£=‘ j0Ï_&óÊKÈ 1R·˜€h:ðÏ ÍØø«¥‹»…<‡%·õ ¯Ém¨sËØ„·l'Hˆ"²œÃÄóZOŠØ“£â$¼êÿ_½¸9¨Cÿô÷àñgŸ£N7ÚIH}È¥6—Ãø pí"Ì«/!o6¤l^Ñ Ä—äÜÁÀ_µöûù ¢m“‘÷¬å/Øv¿íõã¨þyc˜8֌Г¤ÖƇ¶~°i Üö>TrÐ…9tÿ⿇‡×–H§Æ[*’ßâÊDWþU˜×^¥¼Ù²dC ¹¬ `ùC‡‹Ï q«äª;÷Ãr UYè¬÷óúwíFàR»–úŒR  …u¨¢ r?g5ñBù“¥Àèáž‚1!è›Iôò9lþ…OâÑB‹˜AhÆ.Töû÷Hi“7Ù×.Á|â5Ê[-¸5¹ !¹,÷mùu øëݺ¨Ï¨(Ïaƒl×è¬Æ/Ç4Ö„Ò-K}v;H0…uØ…÷ ä‰_‰£ƒÒ®ï 7!fÿçàbyسëpÎð™C ï*Ö  ~ëmœ¬ìk¤[—Äàê*Ìk¯‘£=n×2&$WFƒ¿úØÍòŠïé94ð»j"“Yç5ëX#0nßÚ‚.mº“Ùå{ -„ ÇJ}ú‡ut2Þ• ‡G®„G9Pj`ßJÀ|zOsBô‡`¨€_—/:ËßtÑ@Ą貄˜6„7ÂòÐÇ-b)ºÂ¿uhwÂQ—¼g¹»—òøï {1»ë ø  Áv1 ¶?9”+rÜaƒ1í=}'œ7&04(’È¿ÿ"+ ñÆ=Lû/渼B擯!kµô`ý¢KjÁ?@á8àëx}vç¸y=GÝñ—ÐWq¥›6Êc|Fç¸àf†óîxßÓ¦ð$H‚ÛëÙÚÕ9Nûîç‚”ÁÏîÙ@$ Ù÷\Äc!A¯ßÁ”Ê++¤?õ*²vp–Ÿ!"‚º¤ Çÿ0ÎZù*ç¶ühø[¼Õש¥€o/¬¿› 3CZŸ K¶Ñ†Ÿ(ØËA U:îæ¸Õ‹bÇlÆ.Ùápn ôú4È#:j 4R6J ±ÚB´ÆN„ãJÅ÷Ïa‡q,¿²_ ~˜Ä¥&asñ³Û›?O‹Ë1ð°ŒPHKó¿'HNÂPgìÿžÌ”?þGÔSRœ5”L0iÓg¶7g íþq²:ÇÿÄÅÜïΦ}Ãݽ:¹ánÉ&ÅeÛû¿=<Æ,Ö8û{¨r Pø0êïG]ä)Ê`e·ª20¬!UŒ³«g1¦ öí—1øÃÆUãVpÕísâÖ?¾î9‹ß+Gw~¸‡î>h `ÐDg;8²HÑqÃNFnñÙ¢\¸ÁÕ=K¦0l eŒs«°¸< (Ô¨mùwsx«ûÏtà§À*螥;Y¯lñ²¯o´Úsà•Ý9J|äë  ‚Þ£ó{¤aÒ“@FŸx9Î;Èåùò˜b Ù@ˆçW/aai0d›³¿4*Ö?ÌòJwèÿúè[¸ŸÛ:·yÇ?Ï&| ?¢tÖ]77³ÿ}2€66ckàîœ09náP¶çá;öÞ”ÁßO“_š5„ˆpvõ—çÁÜÿ^hO]”g«_N­žÏ¸Bn]WºcÙzÂÀR6§§³îŠ`à?vRðô¤r/‡©û {•ãýþµOÚÎQ¶ûTQÍ9„ˆ°´z‹gÏüãTq… `09šãëquæZŒôçÉ® ïös{ö’T'@ÛˆðÔÕþž¸Ðg(Ç=„RMvó¯­ØõBþ_VÃH(œ½t Ëü¼ðãü£&¸êܺ[¸Ûmõ3¶D6Ë2stfœ¹ËŸðá(«ãímî?ÒS• À9Üà ÆÌ”û*Š¶Œ²<â³õCÈË80r!"œY} ËK‹]Á¦)Œ uîÖ«Óè+P'Žâ°¶q{ÝsϹ=¸o‘'F$ü“ÆÈçG €6¶á1䞬ÿ±å¤(Ðî‹Üëâ³I…3—žÇÂÒ¸þ:7ο›ÃË»¼®ž%€tÞŽéSÝ´FQ‹PÌÜN˜>{Ÿ"Ûq}ý÷X°›h‹¸‹YôöpðÇšw p´">YN3Û›RX\±–ŸÍøàeùG¶T÷=¬ˆÅ¿ÌÚ&¦éÔ=rô—*4á;à©“Î]õ×ÎþrzF‰ÐÄð1Âü­-'É–ëS3”²mè™, ÈøÏ-¿º×jNÏ83¼Ã8?*û«­çò›na´[ô:uy9n‡¯¾3q &ÌzÛ®o[ÄcÒ¿Ç–ñôöðc—“¤Àð‹RØS€¡ g *¾Šù¥sàÅõ EÓòïçÇçsëTæ¡•wRý!^IïäjWö˜uQò)&)€Y<Ä<ž§Çú'OF‰¿d$g¢Æs˜›?b±ë$×@fçàK‹ý`gWZhr rÿìÏܧ7èôŠõ‡uê:6tÐ_¤â~œaW|9‹Û®éÕ¸I'BN‘0@Š‘,¢ä*f΃°;øDZüVŸP¬ÚNÔ³1}ëÎîu ð\®c;Z3D|›Î€l£_ï{¤¸q$pï¡­1a}bÀœ`@(FcY@&W1»pbðW¹{ üÔ.žÝgØÒ—ÜñwcÊÐq­r÷òȤ~ ¤¶½‰Ÿ4;4ßÂI …5,áÔXŸ' üÀiQ’@4%5¯`fñIŸ¨\óº’;€¶dƆs÷ÐÚ5¶2Áƒû–Ý‹Að›Tÿ›‡~=üy“~VüÃÖB7÷Ž¼‹&z»äûŸ8à{9 @A5/aznIJˆd0€r`åMÿÙ¹°ì(€Ûž³ŸP+‡;«@þÞVƒLGz[©O«˜mR\ÚuiÐG|/€óxÓØ<¹ðÞ]N€sÑ“Ut¶%¨ûö]c-|‰î@S¿m¡FùOÂg`0ÕÁÉ’Ûöuö~¶ØX §ø&Œ.!ð þy<Ä2îQìr¢Õã  PWØ2 qù>D \F«àL"MÚX¢PPì²É) x>÷ù¾¦ŠÓK¨ yú³ðÂ[þ0ÒÄýpjÞq)ÐaXêˆwý؆Â{Õ÷DßˤG€I0âü—ÐÂEHw³™­%Ì·ÞvÊ€`ÕQ2Ê–XAK]b[uîÐ,¿§6.åÕÀ¤ìy7˜< 2A‹ËtÄb¯‹Á¼ƒiì{õŸ<rè J‚ÿ ¦pTYS)ˆíûÈL˜-~pdˆ-ûÖÞ;µšË௳þÕ×Àn«Ÿp•WÔ&·€×©µø&³£YU 2¬Z')€¼ƒ¹R—·ªœðW€a£³:ëÅ)Ž³ümoù+¿VJf£rdÇø”rÔGˆã”ÊþÏ2a’í¦àhÈ¿z´Ì.È݇YS x?0pYOÀÄjÀ>ÀÒHÞ?ð3€Ù£9í“äÛ»NXE— ð×åßTãüžÓk¸¾qѬ¯LÁ(!á‹ ejŸ>PJdŠ;QëñT´¤ˆLi72éÊH•Û×uÅÇIoFI›êp·‘¸„ôúûw0a3šÀgÿ ÆÓ=´õòÆç÷öùI(À¨¼ïñGA`S¸ á²ÉÇÙ £<°Š`(÷'±t$³Qêt P¤-ˆJ¨š“ ʺ ߧС8a~˜dÚx†KCãý¾=h?ô·O¶?¹s4§w2FkQ.bŠv5¥¹ þa Ó…‘ŸïwiL(ª¯Šã¢1o/W0\òRÚ |(€l€ð$v*×bÿÀgÓ°ö¦üðÏ2lØÿ¿s÷hOqR 0jêGïðàLø« ÚˆO5æò¿£…ÆÜvŠ$\¤çMœÃb¼/ß®/øÓÀþ-ÆÝg8Ї2É`·q=|ß‚_\D›®€ F:¼þu)‘mLð‡+Us†Âß«{ýQ›Þ¼àÛ8‡ML8Ht/þŸþ9ÆkÀ›÷Žû$­Lšãx‘ œCW  ´jõÍàûýþ¹Ú¦,ÇN¢UQ|•þØ ›w±ÃŒ&]*” ÎòçØüuÎ.POêŽð£*üK¸…w±€.Z#>ÛFßÊÏÿÁße¼~Çnûà‘›À>ErØá€á˯èu;œ!¡+nò+,GÌáR˜QÚ ¹]Ì(ËÊnÖÄÅ—|îbš¼V-X+? ü‡ñÕ÷Ü{¸ýØÎ9žV9Êy€*Ü ú+Ø£¯ã¬m/þìî½´üþ/°l4ºb0Rç[ñÝž v¹k&ž"žâ<ž`€()WŠQ|?|®¾þ(ˆÐ_z‹ïýÝ/Fïÿñ#Ñíf×tÑ«ëÊ÷¡OÆ;idÿå1t…ìpîõæà·ÿ>áoü¯Œ_ø;lÈAyn3€A$\9ŒOÏ761Ýx‚Kè`¾8R<Ɖò|dn©;W  |ðPlý÷ÿN¾û½Ek÷6­y• ÆÌ0Æ€ˆØ¿ã¼,?hÒ§¾G 4¾8ëÿÂßc<ÞÜ}Çu"ÈŽ ?ðpn˜NˆØÓMÆtƒ°Øf4"P¤@±$€@RšadNÑJŠ•ç¸°@6x|ïʡ^ó“%@È:Èÿ—?–wÿáWåý÷Ö!Dé21UÒ»½xÑZŸaæÒû¡¢„_ª`˜~è²_`,úÓN°oðv’äÝÇ {Ïìþ¦F$^F˜Ÿ-ÍH´b¢f4#A±""°Ê 0>¸Ôä§?½ª/|ï /ƒa+•>oZà7dàöUzô¾*½ñ:=6Bš‚`° ° àµc¥ÂV90³¢xvß+³xÅw1~4¡PijäXïÜxQ a;žýYÆ“­½ÿ†Û?‘kè$‘„”f&ÃDR±) Š Û×Ò§órnIˆï?k¦ÿê‹fé³Wx€­Wý(*€îhà_}‡ÖÿÁ¿£'_¹‹mm;™ *.~õê %Up×¼Wçi•ÌbùçPAŒ1lŒ3ƒ­ ;®=Ë~)Ððo°±\ù;ŒµñKÔÈ],H)IrRü.³u?Ÿ b&)@ "ALDý†ƒ & ”iðTñ“—yêç?ÍËß³ÂmXE8¥!¼=‰+o6]ð¯}[ÿócý+÷ÐÙÊÀDb÷è[±­¢ÃÂ\- ÐW•ÂQ%¯‰èDÄÕïcXk]Œ#Ž{¤Š¬osmì“”’â8&²WÌ,,à‹ÚC *ÿ—Þw”³¤æLÆØÓ1įr믽†ÙYE«Ñ†€†U†“€Ø>ooÁüÊ·±ý _ÃÆ·Ÿ íjÀ ï1nÔÀ(QúaÛK lãºmîïm"b!cLžçœçù°ã*Ç©DDˆã˜”RÂ#Œ1Ø‚™}̆ÜëЗÂ93¹F µ7šI@C+Óˆþ ´ÿê+˜^=ëê r`Ài>-B(R¸ þÊ=¤ÿü[¼ýëo¢óhº[©âÜ£ ýf e ?_ë3ÔY{”•…‰¨4­éÁY;À! c §ijœ³=ÖY›à—ÆÉÌþQRT¬¿{í~­x.³à3•£”X‚?uÍÏ=Gº€äÜ¢søOƒ2 Šƒ xë²ýº¿ú'¼óÕ‡H{98ÝŒv²’JïC£FŒ¦~MDZ¡1¦×ëÙûQ€]>¤ü•‘;&¥5 ¡µ–̬˜9 •ý‘ dáÝv`ˆußeÛHQ¬°Ø€ü©kÔø‰ËhüÈE$ËóPnÅÉ~véqŠ¼‚5=àî¢÷ï¡ûoßãÞ=@º•Ád¶çïI-6ÞR…a×:À+€&¢œˆr!D.„ȳ,3išŽ뛬8øâÏ16»#>æ¬ERk­Œ1Q Ò›A«~h7×+ÃL ù™Ä?v‰’OŸEüò"¢éiHH”Ó«Ã[5 ÏLÀ¦û11n?Cþ;·ÑûýûHÿð§oOêLâò Ôõ¨VZH Z "7à†²Ç¥"lç0™nCß߆yÔ~ëò6YßÙ„~ÒyØÙLaŒËÈáàyÔö!TR ”Kž6Dzh=±¾@ZkdYf”RdŒÑÎâ"’°N¯WˆÚêS¥½PÅ (c}N³Í=€Tƒ7{ÖM¦ÇÀÞçb] ?±ÔR X‚4±´¿al¡?:8µërØþÔÜ_{ƒûϧ¡CÖ8\"ŒU¿3à3s­8Ä…ì`ÿÐZó¸ü?²«Äcª3sš¦ •R kíur€/a" _×E„Èå ŒTŽÊ¡xÿ¢zCÂh×HàwŽj\-Èó±oÆqGjÆÝÇ@$°â°û½Ò¼€Ïªl6fܶ0Zz03w»ÝC-Å ï`ùoŽ™½^µÖF)åOŽü$ØÀ‡!Q_rí¿ã?Ô;еJáo†(ÈÛ†cígä±ðãû¾3£÷¾¿—d³½L~UßÛ-]"´î~{ݘ+£A ÌÌœeçyÎCŽqb²«}ïåãì¦|‘òÝóÀu©^³aˆ*/5ÊQÚ‡ÏÁñç\ÇÒ¶ðs{¹ç'ANÆú}©7ƒ7ŸF}'@Iª¯= óÀáhû Á‚4¤(^¡Œ1ÐZåx „€RÊ+‡ÇZT/᱇‘¯ºó)G¸Ÿ…붸gã:á'NNšŒ+£MM©B¯Öñ{_Å—@U© ‘§,«¸g1Æ MÓؘÚ-J4Éëzß;vùÿË8JiÓ5Ç%tEXtdate:create2016-10-22T17:14:53+02:00ÅkÏK%tEXtdate:modify2016-10-21T19:35:47+02:00èS9ÇIEND®B`‚Slic3r-version_1.31.6/var/add.png000077500000000000000000000015511301441720000165310ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<°PLTEÿÿÿ‹»tˆ¹q„¶n€³j|±gw®cs«`n¨\‹»s‡¸qi¥Xe¡T‡¸p_žP[›LŠºs‡¸pV˜HQ”D‡¸pL‘@ƒµmGŽ<~²iB‹8z¯e=ˆ4u¬a9…0p©]4‚,k¦Yf£V4‚,0)aŸQ]œM4,0)X™IS–E4,N’AI=DŒ:@‰6<‡27„/3,0(¤Î”ËæÃÔëÏÎéɸݯ¹m»Ü¯àòܽ䶥ۛ Ù–¯ß¥ÅèÀŠÂy·ÚªÜñØØ’“͈ŽÌ„–Ô‹•ÔŠŽÒƒ·à¯}¹k—Ç…×îÒ Ù•”ÓŠ‰Èÿÿÿ…Íy|Ãk~Çoµß¬WžE¶Ý¬¯ß¦ŒË†É|y½nj¬[w¼`sº\™Ñ‹’Å€¾â¶—Õ‹†Ézp¸Y~ÁiªÔ³Ý©ŠÏ}Ìu}¾g«Ôœ˜ÌŠ–Ó‰zÆkpÁce«Ur¹[—Ì…¾{h«S´ÝªyÁdq¾_nµXt·\´Ú¦C8}¹j²Û¨oµYoµXt·[³Ù¥lªZx´dµÛ¨˜Ì‡}¼f|ºd˜Ë†´Ù¥kªXP™AÂ}¦Ð–¦Ï–‰¾xB6nAsK3tRNS#}ÛóóÛ}#SææSôôS"åå"~~ÛÛööööÛÛ~~"åå"SôôSSææ#}ÛóóÛ}#w¤öcbKGDˆHÇIDATÓc`À™˜YXÙØ9`|N.cS3s n(Ÿ×ÒÊÚÆÖÎÞÄttrvqus÷ðô ˆxûøúù‡„ŠÄÂÂ#"£¢cbãâÅ ‰I`œ’* JKÏ€ dfId²sróòÜä‚Â"Y €\qIiY P ¼¢²J(  X]›\[WßШ¤ rˆŠjSsKk[{G§š:Ä©š]Ý=½}ýZê0Ïhëèêéaõ9#Æ1]{hotEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/application_view_tile.png000077500000000000000000000007211301441720000223510ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<cIDAT8Ë¥“ÝKÂ`Æý%)‰èƒÂ‚¤•CaS )ˆBDZÚ‡QRÌ4ZaQvÑI’•÷A7]x§óôžóæfí"š<¼0öüÎÃÙ^8:±Ã9¥Ž/hÕZpç ämæô H›ÏØ(ƒý ĵø’E˜L<€°tÞø ÈÉ«æÉVõXþþk!z©'Û±gþ §_ÁŽ†gÏ8@ڪЃpÁ4JÐ<†QËEÓ¨ÁÈÉ7€-¬H•~Å(Íf“‚¹Š èsnû¯º®[ôMq~ªß‰-c¸ÝFƒÞé p€¸úh™ˆAP\†1øY5ŒrËû (÷ URŒÊΈtâT ~¬—?Ëñ[KªÙÖ ^¯[t‰ðÆ®mýNŸ ­» Ž-èÏ™;‡¡È) ÌäÙ–iQî =Òtr¬ö.›¬Ë Ut|;| .’ûc^IEND®B`‚Slic3r-version_1.31.6/var/arrow_down.png000066400000000000000000000005731301441720000201620ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe< IDAT8Ë¥“?KQÄçÄi‰œµ¢‚ ÁH*Ñ.â÷ˆEºøAÅï!XØXØ vc!v¦¿{;»û,®Ó»„\¶}ÙÝ7IŒóÌbÕÃà¥cŒ0u˜®Žï“2ÝBÀÝÑ^êàh¥ gw`4¨+Ü@jˆÉ¥ s‡ä5"H h†PÇðhõ"H.E„ºBFЛâ ôœÝœ¶›&è 5E˜°Ä€îõɃäòÔZn¦ +ÒÕ;ýÍl«·þ8r9¿~Æc¨§$ ý¦h÷¯>©*ÓÁåîkš®í›>†£·áíh¯L—LjãöÅƳRïwŸ‡UšdÞ:ÿ<$·ÇhݸIEND®B`‚Slic3r-version_1.31.6/var/arrow_left.png000066400000000000000000000005311301441720000201370ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<ëIDAT8Ëcüÿÿ?%€‰B0È (=‘ÉÄ»I1€õ2¤À‹ ÍÅÙ$ôþüùÃððýC†_?3üú¿~1˜þŽ`ƒä.ô_edj>)Æ*®§À­Äðçßn90ýûï_ þÍðûÿýÑ¿V¯\‹ðÐÙ¿ÿ0þaøõ÷XÑ ¢ß`Å¿4ÔÜŸÿ@±_P½¹3î¼0›ˆ3'Ã×^¿ƒÕÙ ¯4ÿùý‡áþÂGŒŒÈ)1vUÈM B9 Ç i;N@ͺ@͉Ռ⅜㡻¼zZÓÉIEND®B`‚Slic3r-version_1.31.6/var/arrow_out.png000077500000000000000000000013131301441720000200160ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<JPLTEÿÿÿd´[nÀcd³Zb±Yk¼`a±YoÁdm¿ci¹__®WY§Rl½aj»`h¹^[©S_®W]¬UPœJN™HL—GY§RO›JJ•EH“DW¤PM™HW¤PU¢NI”ET¡NtÇhsÆgrÅfqÃef¶\d´[b²Y`¯X^­V©Ø¡§Öžg´_”È•ÉŽ\ªT¥Ö›Ñ’‡Ê~~½v†À~ÅŠZ¨RrÄfuÅkŒÌƒ¤Ó›„Ç{}½u“ÇŒs¶mY§RW¥PpÃe‰É€‚Äyu¸nsµlU¢Nc³Zs¶lq´jd§_g¨bG‘Ca°X_®WŠÀ„tµna¥]y³uc¤_L”GEA_­VŠÀƒz·ss´l^ Zd¦^p­lD@\«T‰¿ƒƒ»}[¦TFBq­ms®nBŒ?Z¨SX¦QV£OT¡NRŸLEŽAC@B‹?AŠ>ÿÿÿJ¡{YtRNS®ñ®ìñ¸³®쳸®¸³ì³¸ñì®ñ®`XçôbKGDˆH£IDATÓc—WPTbeU5uy M(ŸQK[G—AAO߀ Ìgf1426a053·°d °YYÛØÚ1سs88r‚¸œœ¹\€ ^>ˆüÜ Ô‚ZHXHº2¸¹‹‚øbžâ^ Þ>n¾~’ )ÿ€À `†Ð°pi°وȨh†˜Ø¸x9¨a ‰IÉ )©iéP~fVvÅ•@;~DtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/arrow_right.png000066400000000000000000000005351301441720000203260ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<ïIDAT8Ëcüÿÿ?%€‰B0Ä ˜å±Ûk’ÙüúñËæç÷_W‘ÅA±Pz"ÿüeøóûÃï_~ýü Ô¿~1ˆ–’døõë7ÃÍÛ·.j¿ ÒÃ3ÉJØ–áï? ÿþÀñï¿ø7Ãï@ü&ö‡áË—¯zZYj'¯M»e㤮¨è7Xñoý!÷ë÷o+Ã]röþ‡{±:èg0›‹ƒ‹ARRŠáõ«× ·oܽp{Î=x µ-€ìÚü¨YäX¸ÐõPóA ku1ba„ççÀ7Ýl¬ÐIEND®B`‚Slic3r-version_1.31.6/var/arrow_rotate_anticlockwise.png000077500000000000000000000013141301441720000234250ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<PPLTEÿÿÿnÀcl¼`c±X_­UpÂdn¿bX£OTŸKm¿bP™Gm¾bG@jº_]ªSY¦PV¡MRœJC‰„8i¹^fµ[‡È|¡Ó–ªØ §Öž™ÎxºpŒÊ‚«Ø¡¢Ô™¦Õœ¤Ô››Ð’žÑ–y¸q…Ç{©×  Ñ—Àw~¼u—ÌŽ›Ï“˜Îi«aÑ” Ò–dž”ËŒ„À}f¶\¤Ôœ¢Ó™~¾vJ’BF?B‰;>„8c±X¡Ó˜{ºrI‘B’ɉ“Ë‹’Ê‹EŒ>A‡:rµi–̎ʈe§]D‹=^ XZT9}3q²iɇ„Ä}‰Æ‚‡Ä„Ã~‚Â{S–M1s,c¥[{»u…Ã~‚Â|€Áy~¿wO’J-n);57{1Q”LN‘I-n(/q+,m(,l'ÿÿÿSï1tRNSkØØkËËËËkkØý‚‚ýØ‚w‚Øý¦kËËkÓÔ"„|bKGDˆHžIDATÓc` 02É+0³À¹¬lŠJÊ*ªjìPNu M-m]=.Ÿ[ß@ÅÐÈØÄÔÌœ,Àka©ËÇ/ hem#°µ³wf`qtrv ¸ºéº‹20xÀ-óôò—`ðñ… Húù{‡„ÂD¤ÂÂ#"£¢cbã Ò2ñ ‰IÉ)©ipcdåÒ32³²Qý““‹æÁ<¢Oò“ttEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/arrow_rotate_clockwise.png000077500000000000000000000013021301441720000225460ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<GPLTEÿÿÿnÀcl¼`c±X_­UpÂdn¿bX£OTŸKm¿bP™Gm¾bG@jº_]ªSY¦PV¡MRœJC‰6y02t-1s,-n)3v.0r+i¹^fµ[‡È|¡Ó–ªØ §Öž™ÎxºpŒÊ‚«Ø¡¢Ô™¦Õœ¤Ô››Ð’žÑ–y¸q…Ç{©×  Ñ—Àw~¼u—ÌŽ›Ï“˜Îi«aÑ”¦ÕɉŒÈ…„À}f¶\c²Y`®V\©So¯gɈ>„8U Lj«cŠÇƒˆÅ‚:~4TŸKPšH„Á|~Áww·qSžKl®chª`H@a£Z‡Å…Ä~‚Â|T–NSJj­cɇ‹Ç…‰Æ‚‡Ä|¿u‚Â{[UN˜Ff©_‹Æƒ…Ã~tµmR•MF?^¡WZžU;57{1>ƒ76y0ÿÿÿù6¼tRNSkØØkËËËËkkØý‚‚ýØw‚‚¦ýØkËÓk’Æ/bKGDˆHžIDATÓc` 02ÉÉ3³À¹¬l ŠJÊ*ªìPN5u M-m].Ÿ[O_ÙÀÐÈØÄÔŒ,ÀknaÂÇ/ hie-°±µ³f`qp´r‚›ëÌÀ êâêæã{x2ˆ‰{yûH@ù¾~þAÁ!¡’~XxDdTtLlœTA|BbPRHrŠ”4̈ԴôŒLY$¿d¹3 l8 ]U+Ý:ÝtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/arrow_up.png000077500000000000000000000007671301441720000176470ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<ÃPLTEÿÿÿsÆgpÂerÅfh¸]tÇhrÄf^¬UY¦PqÃen¿bX¤OSžJRœIˆÊ~…È{‡Ê|§Öž¥Ôœ}ÀsƒÆy£Ôš¡Ó˜†Ã}e´[ŸÒ–œÐ”e¬]_­VšÏ“˜ÎPšHY¦P•ÌŽ“Ë‹J’BSžJ‘ÊŠŽÉ‡CŠÐz<Ît8Ìq7Ën4Û›v{Oå·ƒßUÎv:Ír7Ën5Êk3Éh2Ú˜uzN㲀ܔQÌp6Êm4Éi2Èg1Èe0Ú˜tyMà­~ä¯â«ߦ|Þ¢zÝ yÜžwÚ™uxMˆX†V…UƒT€S}PyNÿÿÿ)<™tRNS ¤ñóóóóóóóóç|îƒÛ¯ððððððððð·ÀÂ#7bKGDˆHÞIDATÓc` ™˜YXÙØ98¹¸yx|>~9yE%eU5u MA-m]=}C#cS3s!a K+k[;{G'gW7wO/o_?ÿ€À àPÑ°ðˆÈ¨è˜Ø¸ø„Ĥä±Ô´ôŒÌ¬ìœÜ¼ü‚¢bñ’Ò²òŠÊªêšÚºú†Æ&‰æˆêÖ¶öŽÎ®nÉž^ˆê¾þ 'MžÂ 5uDõô3gÍž3—AzÞüÉ -^Òµt,cY¾bå*·Õ)Åkº§¬»Lï[Im` ŽtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/brick.png000077500000000000000000000010151301441720000170660ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA± üa cHRMz&€„ú€èu0ê`:˜pœºQ<bKGDÿ‡Ì¿eIDAT(Ïm‘1H[Q†¿ûòbhÒPˆÔª[¡…ºfJÇN.ŽR©«d¯àâÞBQ,¡ÉÔ½ƒâT–RR%†T(ãC£é{¹÷w0Q¿³}œs8‡ßˆ>ÛËÁ|k ÒÇ©|ñF«W•L)TR¸9Ö÷Fl/s­I¼YrˆŸ€K7RŸóED©s=WWYUUõEõþ¦Žˆ½X‹ÍˆGˆ_t©ó—$–Ç8~ø;9SŽžûm 1j¼îÝU!KDËA×Sû ã¤!C ‡£Æ(´I£¶/`8gÄ Ø"Nèï}è Ž\àøÇ%#ø,áÛ„‡ˆ°D]bpØAO[» Ã!À!Ä’x ]Ͻj¾ùö{C°„ 1Lý£“wzi¬g´¨ÂÔçXšŽiœë£Vþ€é‡õ陊š›6§49¯èýÛï×Þܦ fµ¤­¾Þº; ÷qÓ¹%4£vÆtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/brick_add.png000077500000000000000000000015031301441720000177000ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<kPLTEÿÿÿ³³³¢¢¢­­­©©©¦¦¦³³³¢¢¢©©©®®®¬¬¬›››«««šššªªª™™™©©©˜˜˜¦¦¦•••¥¥¥[{H£££¢¢¢¡¡¡7kŸŸŸžžžœœœ›››ššš˜˜˜———–––Lt47k7k7kÿÿÿ¢¢¢±±±ÖÖÖýýýüüüÓÓÓààବ¬ÑÑÑ«««®®®ÕÕÕÇÇǵµµ£££ûûûÒÒÒØØØÍÍÍÎÎÎÌÌÌÁÁÁ¾¾¾óóóéééÝÝÝÞÞÞÂÂÂÚÚÚÃÃÃ×××»»»ÏÏÏñññîîîáááËËËÀÀÀðððìììêêêäääÄÄÄõõõòòòçççßßßÛÛÛš¬r–]fŽO^‡F‹¢~ãã㔨‰«a´Ô•Ð溻jW-èèèëëë`‰H±Ó±Ö’Œ¼e¼gÅÅÅL{1¶Ôœ²Ò•7k½½½~;{G'gCW7]w €€‡§—­“·¯Ÿ¿.HE@`PpˆKhXx„®¤ 0CTtLl\|‚ŽUbRrJªCZzFfVvNn^~AaQq‰(ƒXiYyEeUuMmqqQ]}ƒ¸DcSspKk[{GgW}wƒ¤”to_Cÿ„‰“&×Oén»TFVnê´é3fvO™%u¼‚âì9sçÍ_ ¤ 󰤊êÂEjê aE> ]ïîÒtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/building.png000077500000000000000000000013301301441720000175710ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<\PLTEÿÿÿtÇhrÅfL˜GqÄfH’DEAnÀck¼aDŽ@B‹?ç99šššÖÖÖÓÓÓÏÏÏÌÌÌÈÈÈÄÄį¯¯tttŽŽŽ±±±ÑÑÑóóóòòòñññððð©©©ÍÍͲÌõ¯Ëõ¬ÉõªÈó§Åóïï¢ÇÇÇäääãããâââáááàààßßß›››ÁÁÁ¬ÈõªÇó¦Åó£ÃóŸÀó¾òîîî“““»»»ÞÞÞÝÝÝÜÜÜíí파Œ´´´¢ÁóŸÀò›¾ò™»ò–ºò•¸ñììì„„„¥±¤ÛÛÛÚÚÚÙÙÙëëëxƒwzÁpƒƒƒ†††×××ÜäÛZœT|ÆsÅßÁ………µµµ···ŠŠŠÕÕÕËÛÊ`§ZrÂgˇ€Ãx‰‰‰¹¹¹‹‹‹ÌÑËTžN»yj¶`u°n’§‡Ž‡¼¼¼½½½ƒš‚X–Tm­ekkkjljZyY`s_gmgÿÿÿ±+p tRNS ARÞ-wþø±hD…7bKGDˆH²IDATÓc`€n4Àgñòñ  ‹ˆŠAÄ%$$%%¥¤¤e ²rrò ŠJÊ*PUI5u M-me¨€®”ž¾¡‘±‰)TÀL (mnaie °‘¶µ³wptrv ¸*¥ÝÜ=<½ |FoK_?ÿ€@ˆSP°[HhXxDd3ˆÏ럘”ÌÊ`çHIMKÏÈÌÊÎÉåä äÁA~Aa;â!†é tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/bullet_black.png000077500000000000000000000004371301441720000204260ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA± üa cHRMz&€„ú€èu0ê`:˜pœºQ<bKGDÿ‡Ì¿wIDAT(ÏcüÏ€01 ¼SIŠ!í_è_†ß«Íz÷ ‹†4Ïz†? wë—304`±âo¨Ã]†ë r ?C±ºá7Ã?†ß ?þ2üÅîÈŸ«o0(0h0Üd`X¤â?rK±50\e¸ÊÐÀ …e A ð÷*’|ˆÝtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/bullet_blue.png000077500000000000000000000004411301441720000202740ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<³IDAT8ËíÒ= AqÅñó:îd’R2 _ %Ãe±H2-¢ \ƒ§õORÊÓHêún:Þ€ÁM6ÃY?uê ’øføïTi JAÅQ(j…üIÛn‘Å“­ÃúæÁÈðB˜Kù(ßUsë0Ú¿ÑgifæšHÔç@á¢jëý–¦§sebb±¶ w”ðàLs¦Û uD°äâBve =${ ÒPäÞ¸ñ/ñGÀ ¼_퀢B…IEND®B`‚Slic3r-version_1.31.6/var/bullet_green.png000077500000000000000000000004471301441720000204530ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<¹IDAT8Ëcøÿÿ?%˜aÔì8ì²’âûí–Wí7[\µ]kÖ`³ÌDŠf_›þÿУƒÿwßßõê™Iÿ-æ6m€ý6Ë«ø?õÒÔÿg:þ/¹²è¿ù½«D`·ÁüêÖ;[þwŸéúßzªùÿÜ ³þ›tio€õr“†©§'þ_|eáÿÙfþŸp¨ç¿~™*ñ^°œg(e1]¿Á´OçªQ«æUÝ"å­D9©Ñ”H#"â«š¦üIEND®B`‚Slic3r-version_1.31.6/var/bullet_red.png000077500000000000000000000004371301441720000201240ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<±IDAT8ËíÒ- ÂP…áãÝGY°ïZD ‚ ›\ÃÆ¢¢Ñb,EaÍf°]ĬFe0/L‡0Û©xA¿ %ð°àÒ‚ÌM(m@]ä p¿ä«/™Ç>— &¾Ï*²0ð0¡òxÍ,ìQ·Ôã!w0Ta PÙ|FÝnò^¯1BÆ°‹yó<êÑ€iðÜér §ø…#„»‡[Xj[MàÈU·,ñOÀñ|Þ‹ëds)IEND®B`‚Slic3r-version_1.31.6/var/bullet_white.png000077500000000000000000000004241301441720000204660ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA± üa cHRMz&€„ú€èu0ê`:˜pœºQ<bKGDÿ‡Ì¿lIDAT(ÏÕ± €0DŸ¢!8VVpçÈ ™ÊBkµ AÌÙˆ±¶âýæxÜñ ñ®’ïU²sKr²Ý|cÝ7 ›¼¼VC¢Ï S³¨‘ÉnÑårhh.;2Úq¸h-þðêz>2µénpÇtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/cog.png000077500000000000000000000011171301441720000165470ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA± üa cHRMz&€„ú€èu0ê`:˜pœºQ<bKGDÿ‡Ì¿§IDAT(ÏM‘?hQÆïqi4i/˜ÜÕ€±ƒC&¡8(vPpvîd+8‰“І:ÚIzèÁ.. ‘ÚAK ¡ÿBB jî’»÷ÞCƒíoüø†ï'RŽù4§g ª1óì8G…fÕ˜¾nŸ/¦lvsžÎ«òí€húfWï)W™ˆˆ1£Üx/Þmø£ÂNÍž¯HÇÓûÚ2 qÕ~Å›‘gç×À‚X¶SD„kKP‘ñ÷éPŽ6l,/1üæ;¦°P„4WÖ@l~Ö%m{N@Á£,NýòÕ›õž tG|0å!ÉÐâëÍÚ;ðoÞz„äqy’HE„Æ’g…&ÁbýÜÞ.9ö%g@™Ãú* UŸ$FÒèõÕ)°¶<¹¨±üÀpÀ€õ•§5ðj)^˜ÀbŒ.`“åSdî-Qâ‰Óìð%¹ë"áE*Â+v‘‚h&£êþ¯;A§0}fë–§ñÛÃéd+,©çoîþ—õ ª&úÙöµbÀËnêÉüŸòëÖ ›GÜŸëÎFˆÆÚ Ýÿ”óºªià ¤tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/cog_go.png000077500000000000000000000020321301441720000172310ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<PLTEÿÿÿËËËÇÇÇÄÄÄ¿¿¿ÑÑÑÎÎÎËËËÇÇǬ¬¬¶¶¶²²²­­­ÑÑÑÎÎÎÊÊÊÆÆƲ²²±±±¬¬¬§§§£££ÐÐо¾¾°°°¬¬¬‹‹‹ÊÊÊÄÄÄyyyqqqÅÅʼn‰‰ÈÈÈÄÄÄÀÀÀ‚‚‚www~~~ŒŒŒ‡‡‡ƒƒƒÄÄÄ„„„ššškkk¿¿¿“““•••aaa£££   m£7g¡3b0XXXSSS¬¬¬5‡-ƒ«««¦¦¦%¤¤¤ƒƒƒ%yyooodddvvv$w yooojjjzzz[[[+ƒ!yymmmXXXQQQRRR!}yåååäääÞÞÞÝÝÝÜÜÜíííÛÛÛÖÖÖÔÔÔËËËççç···ÙÙÙÒÒÒÈÈÈÌÌÌÉÉɺººœœœ¡¡¡ÂÂÂÆÆÆÁÁÁØØØÍÍͼ¼¼ÃÃÃéééÎÎÎ¥¥¥p¤@eŸ1âââ±±±h :³ZW˜(ÀÀÀÏÏÏo¥=|¯UªË‘t«OEŽÅÅÅk£7°Î–­Í”¨Ë¼t¡ÇŠh¥FÕÕÕcŸ1Žºo‰¸k…¶f€³a‚µg˜Âƒ\ <¦¦¦[›)©Ê¥È¡ÆŠžÅˆ…¶j—‚f¥HQ—"J‘D;‹^Ÿ:–Á€b£F½½½²²²_¡C{ÿÿÿ“RsÆ[tRNSc¿¿c)êê)›ýççççý›{ôþþô{}þþ}……ÍãîÆDDÆîãÍýDDýýDDýÍãîüüþãÍ…û}þù{ôê ›ýçí)êêëÔc¿¿cë²×GbKGDˆHùIDATÓc`F&f8`ec爎áäâæðyùøcã„„EDÅ@|ñø„D ɤd)é”Ô4 €¬\|rzbRrzFJ¦¼H‰brVvNn^~Aaš«¬¢ZT\¢¦®¡Yš_¬¥­Ã [–”]^¡ÇÀ _Y•SgÀ`XQP\cÄÀ`\[WßaÂ`jfÞXÕdaiÕÜÒÚfm4Ŷ½°½£³«¥»§·ÏΞÁÁ±¿=eB×ÄI“§L6݉Á¹$v†ËÌY³çÌ7«P‹»‡§×ÂE‹—,]¶ÜÛì_?ÿ€+ƒV‡À=¹: È;wF'Šœ„ÄtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/control_pause.png000066400000000000000000000011261301441720000206510ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<èIDAT8Ë¥S=kAƒ(Š(r‚6‚…ÕXha©½mêt^¥þ Mig¡!¥…`k'¢Ý¨• j!‚wøýµ™Y½Í™&YöfoæÍ{] c þ³¬_F£QAÓIŒ ¸^¯*î-ÜÑh´g®·˜`³‚yN’$Ùét‚ÝnççûýÖë5Ìf³>‚”b±XY4Åp8Tƒ†ÅŒíº®3MÓØn·ãg›Í†u:­Ýn+Fgp§ý …dšºZ­°yˆÏçƒív Ýn—˜¼¤R©Þ`’&ÚFs¡P€J¥*š‹ÅW¨VßI ƒ2²I É0úAZ nƒÙý›ño ÁëõRm’Î š~8(„aœ€Ëå‚óùf­Ôtû~4Ù\s<át:™JæØl¶;>ó[3I].—  €ËåÒ"ƒ/’$߃rß`A5Óé”$´„‰¨½1ŸQ›ì÷ûAQ2âžÐÊdn¹Ûí†ù|ªªö1m‰D¢‡®–ð’èDÏãñ€Õjå¦ÒNAÍx¡ÙlêèA A{ß®r½^WP[.Ë@€¡˜/;'yóå¼ÏyÏw™€‰qsI“E“UÓÔHÖÑšéÏúqãMæ»/%[àã1ÙO3‰C!Î&…ݽób'GOûë6¬ÁÚß#óY_¨lf9¾&¬ô@=5Z](UêÞc¹…ͬkuˆ0£™M}•ÛðSº}¨Ë=45;}²&+]ØÆdÏúBÌ€sal쬛«R*?ºÀ‹C•Å”ê²¹æn¯ð8Ž –óÆغùâƒÜr' óäì\w%HüR¹ï@ù#4z` 9bpfŒŠ¦ ÷ ]‹B[l@­Ñ©¥Â‰¨Àâêk½˜Š$Ü,,@v¼¡Žkm¢Iû6\›gI:ü盛°â]ÐKûq–°»ê‘±¸PmÃù{A¸Jø/µz°¸ôÜX?|N2¢Ü†¢;’È,äOÈU ðžpcñdÒE(×Áâ fèB©ƒ•å"4_¦X2^¯?€­OI°»ß›hºã«Ú‚¡('Hmã$t¥Ë-ã8ќѺ;Ÿ,sWÜéá1ê‰z·¯½ É|½I’ˆM•¤Á1ðøÐœ.ÖÁáñÉ3Ôú¯‹4~•ç¼Qû²‹Ä2Pà%²'8s2/ÀF(sÔ7í|ó÷UL7Ÿåm³O7èG®%†šw ´ðÐáafúú÷cúŸçü? sq"õ–IEND®B`‚Slic3r-version_1.31.6/var/control_play.png000066400000000000000000000011201301441720000204730ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<âIDAT8Ë¥“˪â@†ÏCåò8«<ˆ‚"èÆ¢ ®‘ ¢*ÞÚËÂ…÷kÔxAQ±¦ÿæ$"s8Ã0 EBº¿¿ªþê|ÑÇÿÄúý¾Ôëõ´n·«w:ƒ1f´Z-½Ùljõz]úV€Ã2‡Ùz½¦óùLÇCÄét¢ÅbAµZU*ùKOؼ^¯„…çáp Ó4ér¹ˆo-—Ëf©T’ß>Ëf¼Ûíh»ÝR>Ÿ'Ã0h³Ùª²Dt]gÙlV²x¿šuÀ‚:?)—Ë x¹\ŠÀ ”J¥4[€›¥C¥´²:N<£€áü@‚D"¡ÛívÛ€Yûý^ÀȸZ­8ìárý¢jµJ³ÙLÝn7ŠF£†-ÀÇ$P¾ã `Uu‘¢ü{ÓéÔ®"‰¼†ÇцÕ+ªªúO&1™ápHápøÕŸ¯†Íçó)Àù|.ÊUEÀØÇ4è~¿S±X¤`0ø2‘ÏU* `!°"+àÃŒ‡ôv‘2™ŒœN§M¸ƒÇãÑ®— ™!ÂAÓçóÉ_^åd2)ÇãqÆ[-ÀôŒ¹c”dGþögŠÅbR(Ò€î÷û ¯×kpHw»Ý—þú7þküFF?ÔE·E IEND®B`‚Slic3r-version_1.31.6/var/control_play_blue.png000066400000000000000000000013151301441720000215100ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<_IDAT8Ë¥“MoQ†ûüüXºtîš.º3qcÂÆÄESW%5ÕEc a,QL›Ö*kª¶©‘ZéŠi,¥ èP˜Áa``ÊqÎ…©ºó&ïfæ<ïù¸çŽÀبn,‚A•I•YÕäPæá7ßñ£à5UÆo‹ïàŒ §éØÉ)'¸ý£$ýj/GMyy Æ`ìƒ!|Ý([£§Y†­ J]P.ûD– ¥ Á£8³´“µb¬f¢Ž'¿‹íŽx$¹¼ØNU³Ó#ßDI†ýpDtm¥ÐÄH °/,3kpU¡òS†·á °uÊõ”øŽn²³d؎ L>ú…eÂÞz€Ã Ïjm"<ÉÜ98¼! Y40¿¥hìKEPËzsvèuˆ%p¡Ú¡¥ÀE]‚åõw4²h0‰p8¬Z£K`ÌXäÚ*ü™hâQü1r‰ÉÊ%¬¹×9d‰Áq4N °| Æ@ÏÀøŒŸü˲ҰŠ.,¯¼Ô Ì_¾&èºØ†¤è½bàÄ}Îœ·Èͤ‹up¸Üz &·?CJ5è÷€ù ‰”;>ó‰À¦Ë-H•ZÐíõa÷0Vç}ˆ†ûžªÅ3œ0˜2fC!¬ÉR“$ȨÙíÏV™;ÎôàµErlD­›"ËëME¯— 3§‹<Ø\qÚ±õ{‘FWyÞ¶®z7™P$V 3Ážy¶Q˜w,1Sö÷¯òècºû"o™}¾M=Y\¡OÜ‚âÛ\ô´ÍGݦ’ÿ~LÿóœxWÌž%IEND®B`‚Slic3r-version_1.31.6/var/control_stop.png000066400000000000000000000006231301441720000205220ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<%IDAT(Ï}‘MKAÆýPóæ”}…Iï! ÅB]ºuèÐ)ˆ˜C(AHeãËÁÚ–µŽ:Ö’”ôô쬔lÏeØßïÿ²39äþÏ÷¡#Úª¥›Ö؆¾U×"#tdÛDˆ±`^1DÝ\ÉØÍÌ1ƒÃO1.]M.67 ž` ËŒyE›sá…–Š2ø‰º8Q^hê˜m¸ÎäQ$r“1Ž´îìSâˆ0ï…G>Y‘4xx>PE.YfÊ­`È‚ˆåEÉS7âÇßDZ:Dà*råªå¡©sDÌÙ]hTLIfë@ì¨m½e˶¤7UYüzÍ¿ò(Þyv-|úHIEND®B`‚Slic3r-version_1.31.6/var/control_stop_blue.png000066400000000000000000000012671301441720000215360ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<IIDAT8Ë¥“MoQ†ûüüXºtC¢û&FMܘ°1qÑ´º!n\4¦KÓ¦µJ‚&Ô¶©I¥#ˆi,SJ>,С03ÃÇPŽsî0#jãÆ›¼››ó¼çãž;S“º¶6]]N]Óc9Çw¶?ã'Á+ºìsodWøÓ)?Ì1GÇ'›J ûæõ‡"=]ƒ±¿Œá«ÁhÍÍž8¾)ƒ¢@»µ:}¨ÖEˆ¤¸¥‚cMÓÀŽp*óMéö4À£ö‡ *tµ{Cr§¨}ØO$ÿVMìÄû²1³ 7ä>Ôô— Õ¤TÅže²³ãî¯ñØŽ aæ;eÿ >mv‰ðdŠg@…â4²hàŒ}Í2Ø3–j‚7mz¸·½,Ë.È Î%–×7dÑ`:yt,à°š­1#‚¦Ð t®B±®£¾vkuYbpȦˆ–pEèZðõ¹Üò°PàU"£Š,¯¼² œ¿¤IéAKÕ¬^1+‚¨› †Aþ¬C^&W‘€ò¬Ý<]®6a4’Á,×ÌŠ`®Ölµƒáö>§ÁíÛ´†h{l¸v£ N)_fªm’ ¯g÷>_åîúrÆ3š‹D½eÝ‘÷Q…@©­YÕà2aæ\E?¨ÌR[¿ir•ç ÷j(ÂÅ“y(ó2™ öœ. °eažZâf¼ïþ^åÉÏtïeÉõøÅ6ýtq…¡žù„/-<ñø™YO˜¾Cg.ÿLÿóë8öÇu‚éIEND®B`‚Slic3r-version_1.31.6/var/cross.png000077500000000000000000000015161301441720000171330ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<•PLTEÿÿÿø`cÿtwÿtwø_b÷[]õVYýorø^aóQTòMOûil÷]`ðGJîBEÿsvþqtùac÷\_ðFIîADýnqüknïEHîACûgiùcfïDGî@Bø^aöZ]ïCFí?AöY\ë9<öX[è02õWZîACì<>å'*õVYî@Bì;>ë79é25ã "óQTí?Aì:=ç-0æ*,âðGJí>@ë9<å%'ä"$í=?ë8;ã!âÿwzþvyøadùhjÿ~þ~ýqtø_bûmoÿ|~þz}ÿ‡Šýy|ûilø^aúlnÿz}÷_aýtwÿ‚†üsvøbd÷]`újmÿy{ûmpÿ~€ÿ{~ÿy|ÿwy÷\^ÿy}ÿ[^ÿX[ÿtv÷[]ÿvyÿVYÿTWÿprðFHöZ\údgÿrtÿpsÿnpÿln÷UWî=?öY[úcfÿqtöXZôMPÿghõNPë46öX[úbeÿpqöVYòEGÿbcôHJé-/õVXúacöUXñ?AöJLê/1òLOÿÿÿÞ5¥>tRNS ++o>++¨)++oý++üüüüüýý+++++üý++üü+AüüAAýüAAh,1|bKGDˆH¼IDATÓc`@ŒPš‰B³°²Aøvöì šÃÁ‘“ Ìwrváf`àquswååc`àððôòòñõó)   —€&)#-³NV.6.>A^n¿bbRrJjšŒ¯œž‘™•“›§á«æ©©—”–i€øšå•UZÚ:ºÕ5µuz@ýú†FC#ã¦æÓV3sma á30XYCh[,%—$cŸÌøÑtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/delete.png000077500000000000000000000015141301441720000172420ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<›PLTEÿÿÿâmmájkÝjhÜdcÚdaÙc]Öc[ÔbXãlmßjjÑ^SÎ]PàijÌ[LÊXHállàijÇWEÅVAàijÂT>ÞjgÀS:Ûid¾O6Úc_¼P2×b\ºK.Ô`X¸J*Ò_TÏaS¸J*µK)ÍZMËYI·J+µK)ÈXFÆUB·J+ÃT?ÂP:¾S8½Q5¼K0¸N.·L+µH'í“ŽøþùÓÌùËÄô´ªâpfò­ªýÜØúº®ú£‘ú‹û©œüǺé{pó§£ýÛÔúš‡ð‘ñŽzø”ù’~øŒvø¶¨ãncêƒ}üÔÍ÷“~îŠuö„lóycø¯¤ÐO>õ¯¥ú«ðŒwì_TòwcôŽéxù¹¯ú“ð…pÿÿÿéYMîj^ñ–÷«¡ø†pö‚hêf\ñœ–îŒ÷‘~ós]é[Oðƒ{â{uÛVKö«¢ðdVîfRæXLæZRõ£ŸÄP4ãkaõ¬¡ê\PæYNæVLæVPô¢žÖ`Tàe\õ¦¡ï†~éc[ç]Yî„}ô ž×]QÌR<èzuî’äxqÁM3&¯‘3tRNS#}ÛóóÛ}#SææSôôS"åå"~~ÛÛööööÛÛ~~"åå"SôôSSææ#}ÛóóÛ}#w¤öcbKGDˆH¿IDATÓc`À™˜YXÙØ9`|N.cS3s n(Ÿ×ÒÊÚÆÖÎÞÄttrvqus÷ðô ˆxûØúúùA@`(P@,8$4 Â#"ÅQÑ1±`Ÿ JLJ† ¤¤JdÒÒ3âÀ 3+[( —“›—âËKJÃÊâÊ+*«ª•”AQQ­©­«ohljVS‡8UC³¥µ­­½CKæm]=}C#¬>ìÏ0°§—ÃtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/disk.png000077500000000000000000000017161301441720000167360ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<ûPLTEÿÿÿ6k¼6k¼6k¼6k¼6k¼6k»8k»>p»5i¶6k¼ßéø½Ðì^‰É5iµ6k¼>p»6k¼5i·7kº1`§5jº1`§6jº5i¹5i¸1`¦1a¨6k»6j»9l¼;n½:m»ÑàöÑà÷øûþ÷ûþöùýðõüêðúíòû÷úýëñûÑßö€ªéöúþöúýdŒÈîóûêñûòöüñöüâìùÛçøºÐî½ÐìÐßö~¨èéñúîôûèðúÝèøÛæ÷z£áÃÕïÌÝõ~¨çfÉéðúóøýøúþïôüßéùÛç÷Ùå÷x¢à©Âç5h¶ÉÜô}§çáìùãíùîôüó÷ýåíúØåöw Þ¤¾ä4g´ÇÙô}¦æeÉgŽÉl’Ëm’ËiÊeŒÈtœÚŸºá4f³ÅØò{¤ãz£ãz¤ã{¤â{£â{£áy¢áw ßvŸÞtžÝrœÛtÜšµÝ4e±ÂÕòx¡àužÞs›Ús›Ù•°Ú3d¯¾Òðz£âwŸÞvŸÝr›Ùq™Øp™ÖŽ«Õ3c­6jº»Ðïz¢âm–ÓŠ§Ò2b«8k»¸Îï÷úþˆÀbj“Ï„£Î2aª8l»¶Ìîz¢áÂÜ¿hÍžÌ2a¨³Êíz¢àeÊ|›É­Æë­Åê|šÈy˜Ç5h·5hµ4f²3e°3d®2c¬2bª2a©1`¨ÿÿÿ€\WtRNSqÌîúþïËT›þûìcØøðþþþÞíµîñÄéÑî3bKGDˆHøIDATÓc`dbfae“‘••“W`çàd`àRTRVQUS×PÕÔâæáåcà×ÖÑÕÓ704R66153`´°46Ö·²ÖTµ±µ³wb`ut²±qvqus÷ðôòöñe`óó Ò ñô `‰ŒÒŽ‰‹OÐ××OLJfMIMKÏÈÌÊÎÉÍË/(,b-NKËÌÌÈ. +-(+¯¨d­ª®¶ÏÌ*©©-¨«ohlbhniU†ƒ¶ö†Î®ìî(Pííëg˜0qR÷d(P2uƒðô3g‰0ˆÎžƒ0cî<1q Éù ".Z¼dé²å"RÒ[QÌ‹´ tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/error.png000077500000000000000000000014501301441720000171300ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<ŒPLTEÿÿÿì¿=ë¼<êº:è¸9ë¼<çµ7ë¼<éº:æ²5ä¯3é¹:ã¬1é¹:è·8á©/à¦-è·8Þ£+è¶8Ûœ&è¶8æ´6Ù™$Ø–"æ³6ÔŽæ³6å±4ЇÍ€å°4Éyå°4Ãmã­1Áhâª/¿dñÔ…ðÑ‚ýúñúïÕòØ”þüóþúçðÓÿýùùé”úëžþúìôß©ýùíÖ£>üõÔñ×¢íÈqÿþùôÜ^Õ¢>ôÙ\þûíå»h÷êÈýúæôÚ]Õ¡=ò×WüóÇôãÀðÒŒþûêøæ”ôÚ\ݱGò×VõÛ\ýøÞçÀ}þûóûòÃöÜ\ößdëËWòÖUõÙTøç”ûôãñ×ýùçøå‹öÛZôÚ[òÖTõØRôÖPüöØ忈è¿bþüôúïµõÚXóØWò×XòÖXôÙWõØQô×NöÚbÒ“Dõã¾þûïþûîþüïþûìþüòëΫà§-ߤ+Ý¡)Üž'Ú›%Ù˜#Ö“ ӌυÌ~Éw Æq ÃlÁhÿÿÿ àq'tRNSÔÕiòí´–0ýü0ÔÃZZ ìä ª‡$ûù$Ê´KKãØ¢¢ì½sabKGDˆH¶IDATÓc`À™˜YPXÕ5ØùìšZœ\HÜÚ:ºz<>/Ÿ¾¡¿\@ÐØÄÔÔÌ\ƶ°´²¶¶±µðEÅ윜]\Å%À’nîž^NÞ>¾~R ¾´Œ@ gPpHhX¸¬P@>"2*:ÆÉ)6.>!QA1)9%55-=#3+;Ç=W‰A9/9¿  °0¿ÀÖ¶¨¸D…Aµ´¬¼¢²ªº¦¶®¾¡±I Ãß7+&Nµ8M„tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/film.png000066400000000000000000000012151301441720000167220ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<IDAT8Ë¥“OhAÅßn»›Ì›ƒ‰ ÒRK‚%Jðè©zQAP4ƒ ÕKO¼yôdÿ€^Š§*DêQŠT4"RKmN‚ZIcgöo tד ?v˜ï½7ßðíaâžÁþ¢Z­¾‚`”|«Õj¹8q¹\þ ”Êyž·R¯× И÷}ÿ>9[©TbÛ¢Y3CG: 1AN0]e§f¼¤™€ôBÈ8—½†‘púü‹Aš'Éö¾Ïì/h|G®“¥WÖMÑa:ŠŒh¢(Òâ‹R.“{¤é€Æ!2I¼´õÏ{ Ø=p¦?ŽùÖq4ÚòŒÇÓO’t\€"M'Ü°gS m9ï?Šhub©›Õ÷ˆÖ¸‘nÊõ€‡ÜlÇ1ôÒ«À– …ÛRb=`g\À9æºniþâ瘘¼‚ܦ5Z°FæšÍ¦7~yn—à”Ht*sÃ)ûö¿^d—©+G¦Àt›Œ‘—?¯`Í_Aàë`àSw3†¼7úSkø¶#°`± ‹Æ¿¦ Ô#SkØ…逅™%–žÂQ~9NfÞÆ X ŸàY·­5ͳ¤×A‰‚SdëÌhhJ £—âÜ» ÐPj„æ½übKqôª[¶mßyzékd@ŽãlhµZpäwIÿΚb±¸X(d>Ÿ_èïýM2™ühYVhšærï©ñãЂ¬IEND®B`‚Slic3r-version_1.31.6/var/funnel.png000066400000000000000000000012011301441720000172550ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<ÞPLTEÿÿÿŸŸŸ›››ÝÝÝÌÌÌ———ÖÖÖ“““ÐÐÐŽŽŽŠŠŠîî†‚‚‚äää|||yyywwwªªªªªªªªªªªªªªªªªªªªª¢¢¢ŸŸŸ———“““ŠŠŠyyywwwwww¨¨¨¸¸¸ÇÇÇÔÔÔßßßçççìì쥥¥ÜÜÜÁÁÁ¤¤¤‰‰‰www¢¢¢êêê°°°ää䪪ª´´´ÂÂÂÌÌÌ›››ÝÝÝÀÀÀ———ÖÖÖÐÐПŸŸŽŽŽ¼¼¼ŠŠŠ†††îîî‚‚‚|||yyy···£££ÿÿÿ}¬ôµ"tRNS#W†¯Ðêú@€@€@€¿€*‰$bKGDˆHÂIDATÓ=È×ÁPEÑÁè½÷è-Hp!DtÿÿEÎõà¼ÌìET,•+ÕZ½^«VÊ¥"õÃÑx2Nƣ᠘™æ|±´¬åbnš3@Ã^ýg7æzƒ©íNT3†öâ8à°ç i]×[Dc±¶}:©í¹ÍęٻˆRž8 A”4|Q¾@P ¼ÞäŠf¥™ûFî”D®<4 (à§ÈS‚ò^ïOG‚ zV·÷»ú‹ð6ƒbž_tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/hourglass.png000077500000000000000000000016131301441720000200070ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<ÅPLTEÿÿÿןqןqןqןqןqןq¾†N³{?¨p/žf!•]W ןqW Ö£z]ÅÒᔥ·¾Ûú”¶ß¹Öö¹Öõ—¹â“µß°Ïñ±Ïð–¹á’µÞ¦Æꕸá¨Æé’´Þ¦Åé°Ëꈬ؂§Ô£Ãè¬Èé~¢ÑyŸÏ Âçq˜Ê§»Óq‰§Ñ™iÈ\žf!•]W W W Ñ™iÈ\à·‡æÆ•êÏìÓ¡ëÑ èÊ›å–âºÝ±‡Ô£yÄa®x>éÍ›éÍœçÇ™äÁ•à¸ŽÝ°‰×§Ï›sÂŒ]ÍÅÀÜ·šÕ¦}Ê•c¾‡O³{?¨p/Ÿg#˜cšk,§ƒSš”ˆÍãùìóû÷úþøûþíõüÕæ÷ÌáößìùÝëù´Îëàìùôøýæðû×çøÞëùÅÚòÉÝóâîú¶ÐíÎáôÌßóÐãôÍßóÒâóíôüçñûµÌéÞê÷ùüþò÷ýâíú·Ðë»ÓíåðúõùýúüþüýþôùýÏãöÓå÷Ñãöš¹Ý¥ÃæÀÖïêòûýþÿðöüÙèøÎâö­Èæ{ ÎÔ¹˜ÄÇÅÇØìãëöñõúÞçó¦¿ß€¤ÐtšËq—ÈŒ“£œbÿÿÿÛÖú¿4tRNSn³ÝôýýôݳnÄÄÑÑ**¸¸¯þþ®8ÝÛ8ÃÂÇÃ:áÜ8°þþ®¹¸**ÝôýôݳnK–RbKGDˆHÓIDATÓc``dbfae31eçàäâæa``à53·°´²¶±µ³wpä ð›™;9»¸º¹{xz9 ½}|ýüƒ‚CBÄ€ Âá‘QÑ1±qñ " ` *–˜”œ’š&.Á’Ré©™Ò2  ›•-Ç€ äsr¸ŠJyù…Ê*0¾ªZQdqIi™º„¯Y^QYU]S[Wß âk765WµT·¶Õ·wtê€üÒÕÝÓÛ×?aâ¤ÉS¦òA<‡ð Hè}]=ö€@}C#c‰z2œâ{ËtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/house.png000066400000000000000000000014461301441720000171240ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<¸IDAT8Ë“ëORaÇÏ«óGø®­Ëfá%Ë0ÍF¶…3`¬fe®QMBàaÌ€)ËËlŽ†#Š"Í ÓÀr^›Õ4Ñ6S»P¼2•3™ö"ýv8•­Òæ‹ï›g¿Ïç9Ï÷y€Ø*ÝEûI:q+ΣH$·›ÛÂEÂZŸ:iÍ[~0ìÕ"w$è)>@Ò`dØÄÅ„ó:^»Šá¿ ŸîHħg“ÿxä dŸ*)2bÉÁäC9&ÝJ;Ë1Ú"FŸ.-â©N#·x”‰dY25ÚÀCð‘þF¼µéxjÈÀp“ãî* XEp—±©ûŠTòA¿:™ô–§P~+ÁÇ*ø›„¨ã`zj’Io->‹{jtëù°IS¨æKÉŒ„  "é‚(ÿm‚eô§Šà5žÀËcX\\Äòò2æfgàTC‡–‡gwn ýæ)˜„,J:ž$|Õ©ÓÙŸçÌ£á,LŒ¿ÂÒÒÿÊìÛ´²qWv]æ h,Ì@9go€ ›åzõiëÃÍyèÑfn|x7·¹óßùôñ=jrXh¸xe™{ÖépXÆ}¢aXë-«««Ì°R©„J¥‚Z­Fii)³Fa1Ý‚š?ƒÿ¹F“É´BQ3[[[ÑÖÖ†ÊÊÊMAL*‘Hömù ÃJ$a†+**`³Ù`·ÛQSS³)Ëå …¿EÏ/'t;/¶óÄþ7ÇP;bF‡Ã§Ó Z̬=xcGA§bo:ÛÊѦkó þ,뽊ªÁõ Àšp8 N—Ë·Ûºº:„B!hT¨ÓC;¤D¾C„DY|” w¤m!Ú8.K§x×r¤Ré¼Ñhd@º˜Íf‚ùÜ’3 ÙµY_Ó5©c4üe÷•]ƒÄv¿éNó}¬‡îvýTIEND®B`‚Slic3r-version_1.31.6/var/infill.png000066400000000000000000000003621301441720000172520ustar00rootroot00000000000000‰PNG  IHDRóÿatEXtSoftwareAdobe ImageReadyqÉe<”IDATxÚbyþÄê?€DHÊcD¼˜¤æq"TÌÖZ?u²:åLØL…*L„jĪ˜(X @óØ%P1ì K"k9Ù;XÔ10‚â}®!¡Ã°‚“Ïý@0À°,U‘`€a XxBBv6P!Ô$±tïÁÔq„§DFJ³3@€*o‰êAØIEND®B`‚Slic3r-version_1.31.6/var/joystick.png000077500000000000000000000010571301441720000176410ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<ÁIDAT8Ë•S=hÂPþž4At±¸”¢âà ´d)tµ n ¥àصÐEpº•Î®"B77±[D§`‡HÑ‚à¿ñ/}÷ Al=8Ž—ûî{w—ï1Ó4qhÅb1´ÝnÕÕj^¯×X,?Óé4™Ëå´CìÌ0Œ@ öx< ]׃Nç§î±.'‚ÉdrÑh4Ðl6ÛíÆh4 9a 8Ùl–õz=A°\.…M ˲ˆŒ1A`‘MÀw€t:mú|>ðE §oNæ¸D¾q(ŠI’Ðjµà÷ûO뀃MºQÓ4(ó~ûPoo®ñúòÅýÙ±ƒr¹æAÛív2w10ĹÁÅ㘱d+½›ü.&ßR©ËR©”· ¨˜ J‹F£rµZÅ`0@¡PsŸ+WPj50¯R¯"‘H.CUÕ<#%r6#‹ÉœãñXrõÙ>ŸÏíèõzár¹ÉdÐn·™è€'e.]T*‘X˜UD>›ÍÄ™¾Ó9‘Hˆh@ ºu8Ú «p¿ Gº _kP’|6‘°ûq³Ùüs› Ûí¢^¯Û¢9tKTD£î¿`æôœO±?Òc¶ ™¶IEND®B`‚Slic3r-version_1.31.6/var/layers.png000077500000000000000000000021441301441720000172770ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<(PLTEÿÿÿtÇhsÆhqÃen¿bj»_f¶\b°X]ªSX¤OSžJN—FI‘AsÆgpÂem¾bi¹^e´[a¯W\©RW¢NRœIL•EG@Bˆ;oÁdl½atÇhsÆhqÂen¾bjº_eµ\a¯X\©SW£OM—FN—FI‘Ak¼`g·]sÆgm¿cjº`fµ\c±Y_«UZ¦PU LPšGB‰=G@Bˆ;f¶\b°XnÀci¹^sÆgrÅgpÁdl½ah¹]d´Z`®VY¦PV¢MPšGN—FI‘Aa¯W\©Rj»_d³Zfµ\d²Y`®W]«TZ§QV¢MP™GN—FGŽ@G@[§QV¡Meµ[_¬Ve´Za¯W^«TZ¦QV¡LQ›IJ“CG@A‡;A‡:TŸLO™G`®VX¥Pb°X^«TY¦QU LPšHK”CE‹=A‡:;5:4N—FI‘AX£NM•E[¨RW£NRJM—EHACŠ<>ƒ7;55x/4w/TŸLO™GY¥OTžKN˜FH‘BCŠ=>„89}34w//p).o)N—FI‘AQ›IK”DFŽ?<67z12u-.o))i%)i%O™GJ’BEŒ=?…9:45x00r+,m'(h$$c sÆgBˆ;oÁd;€5k¼`5x0f¶\/q*a¯W*j%[§Q%d!TŸL!_N—FI‘ACŠ<>ƒ89}34w/+k&'f##b ^[ÿÿÿâá‡ëžtRNS777777777777EEE ‚‚‚‚‚‚‚‚‚ ~~E ¢5:?BFJLPzJžE £=ØÙÚÛÜÝÝåÜëËËE £DzŠ–¦²¼ÑÆß±E£Jœ©¶ÀÇÌÛÐâ³E¤R¸ÂÊÐÓÖàÕâ±EE¸}ÖÚÝààáá×ᯞRÏÓÕÖØØÖÕà«žžãäâáààßÞ¦³²±¯®«¨¥¢¡¹çãßbKGDˆHßIDATÓc`@ŒLÌ,¬lìœ\Ü<`^>~A!aQ1q °€¤”´Œ¬œ¼‚¢’²ŠªP@]CSK[GWOßÀÐÈØ(`jfnaiemckgïàèäìÂàêæî1ÏÓËÛÇ×Ï? 0h>CpHhØ‚ðˆÈ¨è˜Ø¸ø„… ‰IÉ)‹RÓÒ32³²sró3ä-).)-+¯¨¬ª®Y 4¶¶nY}CcSsKk[{Çr @g׊îžÞø¾þ 'M^ vܪ)S§MŸ1sÖì9sWƒÖ¬]·~ÃÆ¥›6oÙº ’eBüÄÜGtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/lorry_add.png000077500000000000000000000012611301441720000177560ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<CIDAT8Ë¥“KHÔQÆÔR‡4J|…„fEeEb»ÊBªmЦˆˆ ÜD7AHÑ¢2z¬ŠB%m&PÙpÑ[\ØC!z‰(Þ{ν-æŸ  žÍw¿Åù8çûî ¼÷,¤²X`E†ïžSÕrçUAÕ"b1³h­AÄÄö_èÝû—€ª–¯ØÑ„÷ŠW‡w‚sŠWÁ«Å©àUxÕu{Ï?'±8'ÌL¤ð*8±8µƒCn´”›…mÜ8ßãUU±r2~i_GDÄPR{à¿»jo7çÕ¡Î3öu*ûjçË‹@Fàì“ §&Q㣨QdFgyMY>b#žu•El^]Ä•ûýÅkg8±<ÎϬÑpd‹†£ÿæK–Ur|lÑÅ£ŸÇ©®(Âˬ€³5é°ÑÎ6:1#ÅbÅŠ#96EÚèc¦Q1ä–d—Ðy'aŠKÙÒA:{1•§ï…!Z°8Bpp÷&ï½Ã9‡÷¢ó>ý'Z[BõÞ¶¬ÝJEñz†Ò?Øǧ‘o—³<} ¦ìÇ¢ªzÊÖïdøk®¬k"ºj;#?rº»ïƒìªüéM5Ñ,eci#Xê74œŠ„)N$m@¸‹ÅšÃ÷I€ñ©ïy‹‚šÖàÌ®ºÚÇy€d2æÄ~oîø>ñez(õ<ïm*NKãZcGÉËΘž×19ï.÷¿{NºÚÉ "Äß<¸Ì÷œë›ËZÕ I ½ÿZªå<0€y=XöIEND®B`‚Slic3r-version_1.31.6/var/lorry_go.png000077500000000000000000000012731301441720000176360ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<MIDAT8Ë¥“KHÕaŵËèš©i))QjP‰QQ-ÒDE‹ U»‚hSë1° …‹P´‹­¢K“k¡µ 3{ˆ¦·H ­ìþï÷ÍÌ×⪛Š†Ã™ÅáÌ& !0—ÊbŽ•Óëôˆª–š)ª‚ªGÄ#âfÑ{‡ˆk;ÐÔ¹÷7U--ܶ” F0ÁL *õ˜ A…÷nîù£™žLT0ñ˜ú ŠÃı`ñr®åµpåü“ ¢¨¨Š—“]—ö_ÏqUüç®ÚÙAãÑZÔ#c?²[ïö^2çî ?ùu†8E"iåkK"^p¨)O°qU‚Ë·ŸçäxŸæIJ.~f M[öè´õž»´œÖüvîôLqlÞjÊŠñÎgÎè}óu)dºÕ¥P£.Æ|Œ‰'ÇŠ‚*Z;wÒóntV ǹÇü¼¢Lâ’Iþê·6B¶Ç™à&ú)Í_MUñf¾ÇS\ìØ„êY¢#»6„ 3##Lcéñ»kŽ¡ÁPSŒÀçÉ yöá1½CO‰5½$ëΣ—Ñ«¤LTn¡d]=ýcQª¼v±84CãoàýX©q†¾¾gÃʬ)©#–0…¨®®Þ´)àpªö [­?˜"¦h0>M“¿¨˜—»yôúáW§4D{¦ÃW+,vgŽX•5Ñ–Š=ô wÓ>ÐöÙ ÉæÐýï7®kÊšª+«ÏíhuFC²9¼øoŠÆhJ-;7eZñ¥9 ÎÌn¡½þÈèIEND®B`‚Slic3r-version_1.31.6/var/note.png000077500000000000000000000013441301441720000167460ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<tPLTEÿÿÿþ߶úÒ¢ùÑœøÍ—÷Ê’öÆŒõÂ…ô¿~ôºvñ¶nð²eð­]ýܲÿþúþýúÿýúî¨SöÌ—ÿýùþûðþüðýûîýûïýûðþý÷í£JõÈ“ý÷áùêªùè£øçøå–÷ã÷áˆö߀õÝwûñÈëž@ôÅŒý÷Ýøè¢øå•÷ã÷á‡ößôÛmûðÄê˜7ð¹yüöÛøçœ÷á†õß~õÝvôÙdûðÀé”,î¶qôÑžðÊxðÇrðÆní¾`ôÛlóÖ[ûï¾è#ë­^ðÃüóÓüóÑúí²í¼[ôÚlôÙbóÖZóÔQûîºåŠì¬]ë­Uë¯Gùé¬úê­ë»VóÔPóÒIùí·ä…ë«]øã´æŸ2é«;øé¨ëºNòÒHòÑBùí´ãë§Uùæ¶ñÑ•è§Kë¯ZîÂ}ûî»ùîºùí³ùí²â}ê£MèžFçš>æ•5âŒ⌠ä!ã‰ãƒá à}ßyÿÿÿ’í¡›tRNS@æØfbKGDˆH°IDATÓc` 021³°²±sprqó€xù@€_€O@, $,""*&..!!)–‘•“WPTRVQU ¨khÊkiëèªèé€ Œµ´MLÍôÌ-,ÁVÖ6¶vöfæŽNÎ`W7wO/o_?°@@`PpH¨·OXxD$X *:&6.Þ',!1),’š–ž‘™•‘“›È/(,*.)-+¯¨¬"Æ«ì »ÕnMátEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/package.png000077500000000000000000000021321301441720000173700ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<gPLTEÿÿÿØ´MزK×°JÖ®HÙ¶NØ´MײKÕ¬EÔªDÓ§BÚ·OÙ¶NØ´LѤ?Т=Ï ;Ù·OÙµNÎ9Íš6Ù·OÙµMË•2Ø´MÉ’/ײKÈ-Ö°IÇ+Õ­GÆŠ(ÔªDŇ&Ó¨BÄ…$Ò¥@Ã"Т=Ï ;Î9Ä#‚"€ Íš6̘4Ë•2Ć%Ä#‚!Ê“0É.ÈŽ,Ä…$Ã#Æ‹*ʼn(Ň&Ä…$êÕœç̈åÏ’üøæþöãòݯ÷ä²áÀràÆ~÷îÑÿÿöÿþðûíËÚ­P÷׋ùáªòÖ•Û²bíÙ¥õëÒíÞ¾ÞÉ•ÛÉָpݹiõ×õÏøÛúãªìÊ„Õ¦QþøáùëÍíÒ’ëÌ„å¿oÛ±VÈ”;úìÎÿõÙÿê¹þß•ÿÕwÿä¥ûÜ„ýøâÿóÔúä°ñφõÐõÐxä±Lÿé¶ÿá›þÖxõ½@éµ=ñÕýöâÿôÚÿóÕÿë½÷Õ‰õÉié´LûÚÿÜŒùÄHì¶8è¿Hè»OðÐŒüöâÿô×ÿòÎÿïÈÿëºûÛ’ñÁVùÂHð½;ìÅGé½EæµBæ±GîʈÿðÉÿí¾ÿê³ÿç­þÙ|ïÇHêÄCè¾Cæµ?ã«:á§@ìŃþûçÿöÝÿïÁÿë·ÿè«ÿä¤þá–ëÆHé½@æ´=â©8ÞŸ2æ¶kîăܽwöå¿ÿöÛÿîÁÿå¥ÿãŸþá”êÁFæµ:âª7å¯VíƇä³tÊJàÀ}üîÇÿòÌÿè¨þà”çºAä±EïÊŠëÁ‚ЗSåÄ‚ÿôÌÿïÄñÒ‹ðΊפ_ëÍâ·oÈŽ@ÿÿÿŸ™pÜ;tRNS+¯¼1„ïóŒeÛàl FÂÈMŸþ¦ûûððððððððùø»ÁeÛàm …ïó+¥þ¬1F¾ÄMñ*NbKGDˆHùIDATÓc`F&f`ec·¶áàä‚r¹yxmíìøø@|A!gW7wO/oaQ1_?ÿ€À àаðˆHq‰¨è˜Ø¸ø„Ĥä”Ô´tI©ŒÌ¬ìœÜ¼¬ü‚¢âi™Ò²òŠÊªêšÚºú†Æ&Y¹æ–Ö¶öŽÎ®îžÞ¾þ ò Í™'Mž2uÚô3gÍž£È 4wÞü -^²tÙò+W)3¨¬^³vÝú 7mÞ²uÛöª jê;wíÞ³wßþijiª£«wøÈÑcÇOèB}cdlròÔiS3$ÿš[XZAXç2R95uºÒtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/package_green.png000077500000000000000000000021351301441720000205530ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<jPLTEÿÿÿØ´MزK×°JÖ®HÙ¶NØ´MײKÕ¬EÔªDÓ§BÚ·OÙ¶NØ´LѤ?Т=Ï ;Ù·OÙµNÎ9Íš6Ù·OÙµMË•2Ø´MÉ’/ײKÈ-Ö°IÇ+Õ­GÔªDŇ&Ó¨BÄ…$Ò¥@Ã"Т=Ï ;Î9Ä#‚"€ Íš6̘4Ë•2Ć%Ä#‚!Ê“0É.ÈŽ,Ä…$Ã#Æ‹*ʼn(Ň&Ä…$êÕœç̈åÏ’üøæþöãòݯ÷ä²áÀràÆ~÷îÑÿÿöÿþðûíËÚ­P÷׋ùáªòÖ•Û²bíÙ¥õëÒíÞ¾ÞÉ•ÛÉָpÞºjõ×õÏøÛúãªìÊ„Õ¦QþøáùëÍíÒ’ëÌ„å¿oÛ±VÈ”;úìÎÿõÙÿê¹þß•ÿÕwÿä¥ûÜ„ýøâÿóÔúä°ñφõÐõÐxä±Lÿé¶ÿá›þÖxõ½@éµ=ñÕøöÛÿóÙÿóÕÿë½÷Õ‰õÉié´LûÚÿÜŒùÄHì¶8è¿Hç¸HñÓÔç’Øå€ýñÈÿïÈÿëºûÛ’ñÁVùÂHð½;ìÅGé½EæµCÔ­9Ì҈Ɗ(âí¨³ÖAºØIääŒÿê³ÿç­þÙ|ïÇHêÄCè¾Cܳ=©®-ˆ±)»Ó…þûçùóи×F®Ô9ÃÙPòâŽþá–ëÆHã¼?±¯0„¬$­$¿gìăܽwöå¿ÿöÛë螬Ó7¬Ò7ÑØU¼¸7…ª$|ª"©·MëƆä³tÊJàÀ}üîÇþòËÐÝe¨Ñ3‘°5èˉëÁ‚ЗSåÄ‚ÿôÌúî¼äшðΊפ_ëÍâ·oÈŽ@ÿÿÿPñÜŒ:tRNS+¯¼1„ïóŒeÛàl FÂÈMŸþ¦ûûððøúû÷þùø»ÁeÛàm …ïó+¥þ¬1F¾ÄM?€7bKGDˆHúIDATÓc`F&f`ec·²æàä‚r¹yxmlíìùø@|A!'gW7wO/oaQ1_?ÿ€À àаðq‰È¨è˜Ø¸ø„Ĥä”Ô4I©ôŒÌ¬ìœÜ̼ü‚¢bi™’Ò²òŠÊªêšÚºú†FY¹¦æ–Ö¶öŽÎ®îžÞ¾þ ò'Mž2uÚô3gÍž3wžƒâü -^²tÙò+W­^£Ä ¼vÝú 7mÞ²uÛö;w©0¨ª©ïÞ³wßþm:¬¡©tª¶Žî‘£ÇŽŸ8©§oõ¡‘ñ©ÓgLL‘ükfna aRÎÂ/ VtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/page_white_go.png000077500000000000000000000012761301441720000206060ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<)PLTEÿÿÿøøøûûû”””•••™™™ 5‡*{% {wüüü :ùùùüüüÕäÑ!| 2üüüøøøôôôõõõñññïïïéééççç÷÷÷ùùùóóóðððêêêöööòòòëëëûûûìììæææíííp¦>eŸ1íïëúúúi£9³ZW˜(öøôo¥=n¤9h¢5bž1|¯UªË‘t«OFk£7°Î–­Í”¨Ë¼t¡ÇŠh¥FcŸ1Žºo‰¸k…¶f€³a‚µg˜Âƒ\ <[›)©Ê¥È¡ÆŠžÅˆ…¶j—‚f¥HR—"J‘D<‹^Ÿ:–Á€b£F4‰3ˆ _¡C6‰{ÿÿÿÆ"÷–tRNS36 ðý‘‘‘?ýüî1þW4õýõ÷PZ¤€bKGDˆH»IDATÓMÏÕÂ@EÑÒâî6Ð-ÐâîîîîüÿO0a?®äæ愈¤pb "¥2ðÎ%ÿ%sÓ4Íx¼À§@¢¤Ë±¬?¼[%~Çq,/„Ð¥D 좙H0ŠEðÄþJ<‘üJg²¹ä ÅR¹R­©¿Po4+­v§«Ñbè5ûƒáh<™ê0Ìæ‹åj½Ùê ŒvûÃñt¾\Mp‹Ùbý¼¹Ý6‚ÝŒ×;žNÒN¼ ‹Û@;=Œ9:Š6€Íu‚Íx§Ùœ¢Ø˜¢Ø——ÒƒÐyÎv~Ët{Éq¡×—Õ“€Îv¦Ù›¤Ø™¢×˜¡×–žÕ•œÔ“˜Ñ•ÐŒ”ÏŠ^­W}Ës£Ø™‡ËywÃisÂeqÁdsÂgqÀf”Ï‹Z©SzÇpwÄm…É|rÁeoÀbl¾_i½]f»ZψmµfR¡LNHJ™Eo½f™Òm¿`j½^h¼[d»YaºVo¿e‹Ìƒ‰Ê‚ˆÊ€F–Ak¹c–Ñi¼]cºX`¹U]·Rk½bˆÊ…È~„È~B’>n¼ej¸bzÀr“Ï‹d»X_¸S[¶QYµO‡Ê€b¬\B‘=?Ž:•Ï‹’ÏŠrÁiŽÍ†ŒÌ„ŠËƒf»]E”@e´^‘ψa¹VÍ…lµeOžIc­]ƒÇ|Æ{A)0oBDQn¿Å—2½QϾ+Qn.‡š,T‚ Á…B˜§©¡ŠÂ2é=ˆÊÒˆ(ꊨRùù-f n‚Š°±¾…¶ {ùQÌsoðZ¶íÀɾã.¢Ô­ªC͈-áPúØoÃÉξggÓ>æ’C“èèŠkË/§ÛPœ‰ïã´×wðòÃ(êÆ»é×ÄAßç°{ó~æÂOMôO—åYn˜ »ÿ4AQŠˆ 5[3§f'©_³á÷ ¼éÿ’‡KAÍH¯ë@ÔÈ~Â¥è7/“X%akCšLóaž¼ë§oìî§DèÌvû«áÉØSDAD‹·NŒW¼z@+P†?<Œ£¸Šûc}£3Ûí£¿sð/Õ|!Ê«•­.˜6çº}bqþ ÒF•äóKQøIEND®B`‚Slic3r-version_1.31.6/var/printer_empty.png000077500000000000000000000006501301441720000207010ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA± üa cHRMz&€„ú€èu0ê`:˜pœºQ<bKGDÿ‡Ì¿IDAT(ϥѽ+…qÆñÏÓŽ’”Éf9 %2˜°Éÿ`,þve‘ '³:«ÅnĤœ¤“³Îñòœ—ŸÁKOƒ{ºëú^÷}Õ¿OÛºøsÉ‚ %XRÀf§ÉA3ÊpÖ‰•Ùätÿ™(Ø\¶ÝßÕžrܹ¬&ë…|´17p<®÷‡ï%GÎçc[Súìü¬Yr³Ë`Qî›|!+«07;š¸–ýŠøóÊ*QÜPDÙ«j èr¯ˆ¢¸®„' I h¨)á^\— ã/jUT£ÔÅIë¡­[Y=ž,¸Õ-ï%Óõ±á”ûQÍ "áÌAôï6ßT(]¥rý:tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/reslice.png000066400000000000000000000012311301441720000174170ustar00rootroot00000000000000‰PNG  IHDR‘h6tRNSn¦‘ pHYsÄÄ•+9IDAT(‘eRÍjâ`½ILQÁŸRT´*¥$)Ôࢠ}q%n\)î|Šy‰élfúI»ÀA˜é¢Ã„QŠQ§à Vq š˜ïÎ"E2ÌYî=÷œÃe\ „ŒF£ù|ñx\„««+÷  ûý^–e7#˲an†ADBˆ®ë³Ù C¡(Š777ˆøúúªëúf³a&‘H\__¿¼¼€#s „(Š¢ªªªª²,BÜב+•JÛí/..q0GBÈr¹ ƒ¶mÇãqJi¿ß_¯×ËåÒ33™Ìn·SU•ã¸étZ.—O ý~¿eY»Ý.ëºÎrwyy™L&C¡P ˆF£ÃáRJ)‡±XììììííÍ4ÍóósŽãŸ¯×ëŽÝÛOßùÛ/¿±^¯çóy˲¢(¦R©~¿_.—%I*‹“É$N;Ù†ó‹Eð8^¯7—˵Z­R©ä0étº’2ŸÜ~üZÉ Ðn·5Mûçù8®E91ãñØñóþ|ð …‚$InFÓ´n· ʧâ­ýætIEND®B`‚Slic3r-version_1.31.6/var/shape_flip_horizontal.png000077500000000000000000000006231301441720000223630ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<%IDAT8ËÝÓ=JQà3ù1>4-ÙM .ÀÖÎz nÀf@D› ‚.ÂBA±ÁÂ4)Li)™Iî9׉Š‘`ãYÀ÷Þ;÷¾ÈÝ1OJ˜3œÝÃémÞ€½‹a÷ü9ü =1!ÉcÊ“™ÞMÞ2y×ø^®$ê&½Ak&ÀèéúJ)L“cc­ŒJN®³v#DF- …PV—Ê£§ö·ÀñUŒžÖkrLÓ ¯±XÌ”n<†/£'Íz)®–£ƒ*ž`Âh,˜ÍF56*ù^ŽZFï./D˜§SÓ‰Ù˜åä ÕÝÚ¿ÿ(´R•Rà 耨Xq£0xÉ ”CîAòÀ&Dÿô/ü&o~ß°ŒÖÙ ÜIEND®B`‚Slic3r-version_1.31.6/var/shape_handles.png000077500000000000000000000010321301441720000205710ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<¬IDAT8Ë¥’1‹Q…¿‘QÐB\AØvI M~Â"ÿ"Xæ„ü„€d‹”I¿e‚v6ÊÚhé$M$³èÂÖ&˜÷îÙ"o& F ½ðàñÞ=‡sν‘$þ§b€Á`JªHJz½^ýo€n·û!Ïó—ιd2™Ôãð^i·ÛÌf³Ú›w72 Þ™ao°Ýnét:ŒF£Z©À{ÿu:6ãGOy~v è€äöÉ9ÃáçÜ'€¨È`ðö§ÎÏì’À¤’ÈL˜‰åMÆ ó"*äz$Ì°¸Û1Iîí8DyÛ5 Ì `%° tî30/,4íš‹»í•Ìéws†7•>uàYÁR¡Ä"p¼·Òÿ1É^‘ÎNYðïãz*Œò @IxRÁk`Áûá8²**’D«ÕJó<¯<|üŒW‹£Ä¥Kâòâ5ß“Ïxï“,Ëê÷²,«ôû}n,Y\¯Y\o˜§k«_ÌÓ5óÕ†dµ&I7,¿]1qÎÕvó—h6›_†U«Õ+…úÓ‰ãø}E>JÚ¯ò¿Öù5¼oqIRriYyE%D ªº¦¶.§¨¾¡± "À/ ¦…š…1=Ç|&‰P V¾tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/spool.png000066400000000000000000000010411301441720000171240ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA± üa cHRMz&€„ú€èu0ê`:˜pœºQ<ÏPLTE‘““€­­­ÂÂÂbccåääs}z=J'þþþ~‹‡¦Vv§Hnc7U.;ˆŽŒ¨ ¢Ú©Þc“®Swh*@G$…‹¢šœóËÙø¥Éù•»õ“´«Mr[,ššš¨y…ô´Èÿ²Õÿ§ÒÿÉßõ°Æ×\n3G«‹ävž÷y°ÿºÕÿÜêñ®Éð„¯A #r'Fé…§ÿÀÝŠ•‘µ´µqqq¦„Š¨Ÿ¢‘™ÛÛÛ^_^¥ž Ÿ¤¢|||¬Š˜ ž£££nnnÿÿÿ±»‰tRNS@æØfbKGDDù´˜Á pHYs  šœ¢IDATÓUP‰‚P {9ñVåðoT¼þÿŸŒï¡Â’-i³¦Ý¡\ãs ‚˜% Hr±„ VÊj¥ZÃ×ÍV»£!ÕKÝžÞæí`$-{2ufæ\£î€ëùÁb¹2Ì5ÏÌFA0ÙXêv·¡K‡È·õã)># Ðs.W%a:ÜÛ]y¤¾Ÿ~‚‹“4“A|ý²³Ó¿xg N7ûêrIEND®B`‚Slic3r-version_1.31.6/var/tag_blue.png000077500000000000000000000013451301441720000175640ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<;PLTEÿÿÿËËËÈÈÈÄÄÄÊÊÊÀÀÀÊÊÊÈÈȽ½½¹¹¹ËË˵µµÉÉÉÇÇDZ±±ÅÅÅÃÃî®®ÁÁÁÀÀÀ¬¬¬½½½¼¼¼¬¬¬ººº¸¸¸«««¶¶¶´´´²²²±±±¯¯¯­­­ªªª«««ªªªÕÕÕÔÔÔÒÒÒÑÑÑÐÐÐÎÎÎÍÍÍÓÓÓýýýäääâââàààËËËóóóûûûÇÇÇ÷÷÷èóû½ãýÞÞÞÃÃÃüüüêõýŠÏþƒÌÿ¼âýÜÜÜÀÀÀëëëúúúçóû‰Îþ–ÔÿšÕÿ‹ÏÿÚÚÚ½½½éééÓëû˜Ôÿž×ÿ›ÖÿÙÙÙ¹¹¹èèèÖìûˆÍý˜Õÿ‰Îÿºáý×××µµµçççœÖÿŽÐÿÌ÷ûüý···ååå†ÍýŒÏÿ—Ñúó÷ùÕìû—Òý÷ûý¶¶¶ØØØÿÿÿ]´$tRNSÍùâö=ö;ö;ö;ö!;ö!;ö8ö8ö!8µ4Í‹bKGDˆHÇIDATÓcPQUS×ÐÔbd€mÐÕb‚ ¨éèiêëèè0C4t´X tôY!š:úlì&¦f:æ`-K+k[;{N—ƒŽ£“³‹«›­Ž»7P€‡×SÇËÆÛÇ(âçÏáÐ öñ Õ Š G€D"£¢cübE@ƈŠÅéÆ'$&ùÅŠC¬–ÔÕINIõ‹•‚9WZFOGÇ/ Îg`•ÓOGæ30È+¤)2 %e 'ˆ!oA¿TXtEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/textfield.png000077500000000000000000000002311301441720000177630ustar00rootroot00000000000000‰PNG  IHDRµú7êgAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<+IDAT(ÏcøÏ€2ÐAÁÉÿø!PÁ<ðDÁÉA ¯#_üÇA\+Šv*³Îæ“IEND®B`‚Slic3r-version_1.31.6/var/time.png000077500000000000000000000016771301441720000167500ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<ûPLTEÿÿÿ¿¨ŠÆ«~ͳxи{Í´zÄ©q¹q°™zª†Òºx¸œg©lÀ¨…Ÿ…d¹£ˆÌ³t¤ƒX›†j¼¡w˜|Y¾¢m›{S½¡lž{T¸šgyS­Ž^•uP …^tT‡k¢‚W”qM‘{bšawZ•|]šxP”rMvY•}a‘uS“rN—tMtR‘z^ãÙÈêçÝññîððìäàÒÒĨÜÌ—îëáÙáߖ­Õ’ªÔ£·ÜÎÚèßÙƶ›hìéßÂÏ殿ßÜãñìñóëñôÙâñ£ºÜ¯ÁÞØÏ·ÛÏ·×àíª½ÞÿÿÿîððÚåç÷ÿÿóþÿ˜´ÜÄÑỤsæáÓ¤¹ÛÖãñõûþóõõ•žŸéððòøø­¹¾ÂÚð‹§ÑÓÊ©îì䊥Ñéöúîøýùÿÿy€¤®±wºÆÉÓðúr•ÉâßÉìêÝŸÏâóúéöýãðò„ŒÂÏÒëûÿÌìúmÇáÝÁÝÓ·ªÑÁÛðæ÷ÿãòú¶ÀÅÞíñèüÿßõÿ¯Ôï{›ÉÐÂ’À©xÆÑÚˆªÙëþÿîúÿòýÿòþÿïüÿëýÿz£Ù¹Æ˱”XØÌ¢¥·Í‰ªØÏßïóöúóõúÑßט¬Ã킦ˆUÖÈ–¿Ê̆ŸÈv’ÅsÄ€šÄ¹ÄÃͽ}˜wG±—Zν…ÞÖ¤Þՠ˹{«ŒOŽê/tRNSB½íúúè°9–ùô}‘u<úõ1¶£çß÷ö÷öÞ⟪0ö÷5x€}óô‚6§áö©7ôß6FbKGDˆHÖIDATÓc`À™˜YXÙØ9`|N.}C#cnŸ×ÔÌÜÂÒÊÚÆÖŽÄç°wptrvqus÷ {zyûøúùû‹DCBÃÂ#"£¢cbãâŀ⠉IÉ)©ié™YÙ@ɜܼü‚Âô¢â’Ò2) €tyEeUuMm]}Cc“ P@¶¹¥µ­½£³«»§·O( ¯Ð?aâ¤ÉS¦N›>CQ ä噳fÏ™;oþ‚…‹T NUU[¼dé²å+Ô5`žÑÔÒÖÑÑÖÕÃês«ù8‚¼Ç˜tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/wrench.png000077500000000000000000000013461301441720000172710ustar00rootroot00000000000000‰PNG  IHDR(-SgAMA¯È7Šé cHRMz&€„ú€èu0ê`:˜pœºQ<YPLTEÿÿÿžžžœœœ›››™™™››››››˜˜˜’’’ŠŠŠ–––‡‡‡•••“““………‹­ãˆ§Ú’’’„„„‚‚‚‰©á‰‰‰………ƒƒƒ‡©áˆˆˆ†††…§á]‰Òƒ¥ßQƒÕ¥ßOÓMÓI}Ñe‘ÙG{ÑW‡ÕEyÑäääîîî–––âââççç¹¹¹“““ÏÏÏŽŽŽŒŒŒÝÝÝÅÅŬ¬¬×××ÔÔÔÈÈȼ¼¼ºººÂÂÂÄÄÄÇÇÇÌÌÌÆÆÆÃÃÃÀÀÀœ¹ç˜¶æŒ©ØÒÒÒµµµœ·æ¼ÏïºÎâ{›Ò™·æ»Îî§À飽è³Èì¤ß˜´æºÍ閴å¹ç®ÆëyŸÞ”³æ¸Ì锳囷æ­ÄêxžÞyŸÝ·Ì풱䚶æ¬ÃêtœÞo—Û³È훸ç«ÃêsœÞ«Âê¨Àêq™ÜQƒÕK}Ñÿÿÿ ”(+tRNSpÖûûpõÖûÂûüÁÃûHþÖ’Ïûõp’þûÖp’÷#’É’ª’¬¬¯Ì¯Õ¯ÅXtYbKGDˆH£IDATÓc`€F&f$Àʦ­£‹,À®§o`ˆ,À¡mÄÉ`lÂà65ãá5·àƒñù,­¬mlí!\!a{{G'gQ10_ÜÅÕÍÝC‚ORJÌ—ñôòöñ••ƒi—÷ó V€ñCBÃÂ#"£” |åè˜Ø¸ø„D˜‚¤äÀ”Ô´tU¸ƒ22³B²sÔNVÎÍË×@ö„fA¡ETšoÇ”“tEXtSoftwareAdobe ImageReadyqÉe<IEND®B`‚Slic3r-version_1.31.6/var/zoom.png000077500000000000000000000012641301441720000167660ustar00rootroot00000000000000‰PNG  IHDRóÿagAMA¯È7ŠétEXtSoftwareAdobe ImageReadyqÉe<FIDAT8ËÒKHÔAÀñï̪-–ŠK¾C=Ø ¡CmÒfuîP–‰)D—êB§"ÂK»$A„ e¤¦t¶¨¤ð ô‚JŒÍZÿyuÙmüÁ0ø}f~3#œsLÞ²|!!|g-V©9­¼Që鎺³ýc¬`²ïT«™C8*¬—èô£5Þb¬F'âÎR!DÆЋ› ­kbâ^sPÈÌ!«½»²¾«¨ÊLocÂgÀע≣‡.=^uéíÖ˜ˆ¬ïê[ €¨ê65ôÞ¶FG´§• !§Ô P ä%wN5•\«Òq=(¡t@ȀѶ(t2)Õ§ "«L?Bþ2¬uXcY‘äV$¦ÆÚƒÔ&ý´çÍa]còÂt²¥€Ô<â *¡æÒã©QçÄ1àð}E )h˜’Y—­§§Ò„ê°Ž’…æ6` øDXr<:=UR½Íï÷ÌžáóûO®úÎ9žÝ8Ò*}òªV&b==h”é·ÖqÙÜ+;¶ËœâJT<ÆÔÓçüúò­øø­—³ËÀÈõÃA !CÎ:”§£¾Ì¼Êú}änAHÉ~0bM”ž¸36» ü+†/ç——ö”ƒøsóIĢ̾™àÉÀ«ÏEkÿ ž …óJ {ÊvíÄ!ùùé=_ßMÏyKªb]Àö½aµ¤{6W°03ñnew; my $mswin = $^O eq 'MSWin32'; # _GLIBCXX_USE_C99 : to get the long long type for g++ # HAS_BOOL : stops Perl/lib/CORE/handy.h from doing "# define bool char" for MSVC # NOGDI : prevents inclusion of wingdi.h which defines functions Polygon() and Polyline() in global namespace # BOOST_ASIO_DISABLE_KQUEUE : prevents a Boost ASIO bug on OS X: https://svn.boost.org/trac/boost/ticket/5339 my @cflags = qw(-D_GLIBCXX_USE_C99 -DHAS_BOOL -DNOGDI -DSLIC3RXS -DBOOST_ASIO_DISABLE_KQUEUE -DGLEW_STATIC); my @ldflags = (); if ($^O eq 'darwin') { push @ldflags, qw(-framework IOKit -framework CoreFoundation); } if ($mswin) { # In case windows.h is included, we don't want the min / max macros to be active. # If is included, we want the #defines to be active (M_PI etc.) push @cflags, qw(-D_WIN32 -DNOMINMAX -D_USE_MATH_DEFINES); } if (! $cpp_guess->is_msvc) { # Don't use the version flag on MS Visual Studio, as it starts to recognize them up to 2015 and it uses different syntax. push @cflags, qw(-std=c++11); } my @early_includes = (); my @INC = qw(-Isrc/libslic3r -Isrc/glew/include); my @LIBS = $cpp_guess->is_msvc ? qw(-LIBPATH:src/libslic3r) : qw(-Lsrc/libslic3r); if ($ENV{SLIC3R_GUI}) { print "Slic3r will be built with GUI support\n"; require Alien::wxWidgets; Alien::wxWidgets->load; push @INC, Alien::wxWidgets->include_path; push @cflags, qw(-DSLIC3R_GUI -DUNICODE), Alien::wxWidgets->defines, Alien::wxWidgets->c_flags; my $alienwx_libraries = Alien::wxWidgets->libraries(qw(gl html)); $alienwx_libraries =~ s/-L/-LIBPATH:/g if ($cpp_guess->is_msvc); push @ldflags, Alien::wxWidgets->link_flags, $alienwx_libraries; # push @early_includes, qw(slic3r/GUI/wxinit.h); } if ($ENV{SLIC3R_PROFILE}) { print "Slic3r will be built with a Shiny invasive profiler\n"; push @cflags, qw(-DSLIC3R_PROFILE); } if ($ENV{SLIC3R_HAS_BROKEN_CROAK}) { # Some Strawberry Perl builds (mainly the latest 64bit builds) have a broken mechanism # for emiting Perl exception after handling a C++ exception. Perl interpreter # simply hangs. Better to show a message box in that case and stop the application. push @cflags, qw(-DSLIC3R_HAS_BROKEN_CROAK) } # search for Boost in a number of places my @boost_include = (); if (defined $ENV{BOOST_INCLUDEDIR}) { push @boost_include, $ENV{BOOST_INCLUDEDIR} } elsif (defined $ENV{BOOST_DIR}) { my $subdir = $ENV{BOOST_DIR} . (($mswin == 1) ? '\include' : '/include'); if (-d $subdir) { push @boost_include, $subdir; } else { push @boost_include, $ENV{BOOST_DIR}; } } else { # Boost library was not defined by the environment. # Try to guess at some default paths. if ($mswin) { for my $path (glob('C:\dev\boost*\include'), glob ('C:\boost*\include')) { push @boost_include, $path; } if (! @boost_include) { # No boost\include. Try to include the boost root. for my $path (glob('C:\dev\boost*'), glob ('C:\boost*')) { push @boost_include, $path; } } } else { push @boost_include, grep { -d $_ } qw(/opt/local/include /usr/local/include /opt/include /usr/include); } } my @boost_libs = (); if (defined $ENV{BOOST_LIBRARYDIR}) { push @boost_libs, $ENV{BOOST_LIBRARYDIR} } elsif (defined $ENV{BOOST_DIR}) { my $subdir = $ENV{BOOST_DIR} . ($mswin ? '\stage\lib' : '/stage/lib'); if (-d $subdir) { push @boost_libs, $subdir; } else { push @boost_libs, $ENV{BOOST_DIR}; } } else { # Boost library was not defined by the environment. # Try to guess at some default paths. if ($mswin) { for my $path ( glob('C:\dev\boost*\lib'), glob ('C:\boost*\lib'), glob('C:\dev\boost*\stage\lib'), glob ('C:\boost*\stage\lib')) { push @boost_libs, $path; } } else { push @boost_libs, grep { -d $_ } qw(/opt/local/lib /usr/local/lib /opt/lib /usr/lib /lib); } } # In order to generate the -l switches we need to know how Boost libraries are named my $have_boost = 0; my @boost_libraries = qw(system thread); # we need these # check without explicit lib path (works on Linux) if (! $mswin) { $have_boost = 1 if check_lib( lib => [ map "boost_${_}", @boost_libraries ], ); } if (!$ENV{SLIC3R_STATIC} && $have_boost) { # The boost library was detected by check_lib on Linux. push @LIBS, map "-lboost_${_}", @boost_libraries; } else { # Either static linking, or check_lib could not be used to find the boost libraries. my $lib_prefix = 'libboost_'; my $lib_ext = ${$cpp_guess}{config}{lib_ext}; PATH: foreach my $path (@boost_libs) { # Try to find the boost system library. my @files = glob "$path/${lib_prefix}system*$lib_ext"; next if !@files; if ($files[0] =~ /${lib_prefix}system([^.]+)$lib_ext$/) { # Suffix contains the version number, the build type etc. my $suffix = $1; # Verify existence of all required boost libraries at $path. for my $lib (map "${lib_prefix}${_}${suffix}${lib_ext}", @boost_libraries) { # If the library file does not exist, try next library path. -f "$path/$lib" or next PATH; } if (! $cpp_guess->is_msvc) { # Test the correctness of boost libraries by linking them to a minimal C program. check_lib( lib => [ map "boost_${_}${suffix}", @boost_libraries ], INC => join(' ', map "-I$_", @INC, @boost_include), LIBS => "-L$path", ) or next; } push @INC, (map " -I$_", @boost_include); # TODO: only use the one related to the chosen lib path if ($ENV{SLIC3R_STATIC} || $cpp_guess->is_msvc) { push @LIBS, map "${path}/${lib_prefix}$_${suffix}${lib_ext}", @boost_libraries; } else { push @LIBS, " -L$path", (map " -lboost_$_$suffix", @boost_libraries); } $have_boost = 1; last; } } } push @cflags, '-DBOOST_LIBS' if $have_boost; die <<'EOF' if !$have_boost; Slic3r requires the Boost libraries. Please make sure they are installed. If they are installed, this script should be able to locate them in several standard locations. If this is not the case, you might want to supply their path through the BOOST_DIR environment variable: BOOST_DIR=/path/to/boost perl Build.PL Or you may specify BOOST_INCLUDEPATH and BOOST_LIBRARYPATH separatly, which is handy, if you have built Boost libraries with mutliple settings. EOF # Add the OpenGL and GLU libraries. if ($ENV{SLIC3R_GUI}) { if ($mswin) { if ($cpp_guess->is_msvc) { push @LIBS, qw(OpenGL32.Lib GlU32.Lib); } else { push @LIBS, qw(-lopengl32); } } else { push @LIBS, qw(-lGL -lGLU); } } if ($ENV{SLIC3R_DEBUG}) { # only on newer GCCs: -ftemplate-backtrace-limit=0 push @cflags, '-DSLIC3R_DEBUG'; push @cflags, $cpp_guess->is_msvc ? '-Gd' : '-g'; } else { # Disable asserts in the release builds. push @cflags, '-DNDEBUG'; } if ($cpp_guess->is_gcc) { # check whether we're dealing with a buggy GCC version # see https://github.com/alexrj/Slic3r/issues/1965 if (`cc --version` =~ m/ 4\.7\.[012]/) { # Workaround suggested by Boost devs: # https://svn.boost.org/trac/boost/ticket/8695 push @cflags, qw(-fno-inline-small-functions); } } my $build = Module::Build::WithXSpp->new( module_name => 'Slic3r::XS', dist_abstract => 'XS code for Slic3r', build_requires => {qw( ExtUtils::ParseXS 3.18 ExtUtils::Typemaps 1.00 ExtUtils::Typemaps::Default 1.05 ExtUtils::XSpp 0.17 Module::Build 0.3601 Test::More 0 )}, configure_requires => {qw( ExtUtils::CppGuess 0.07 Module::Build 0.38 Module::Build::WithXSpp 0.13 )}, extra_compiler_flags => [ @INC, @cflags ], extra_linker_flags => [ @LIBS, @ldflags ], # Provides extra C typemaps that are auto-merged extra_typemap_modules => { 'ExtUtils::Typemaps::Basic' => '1.05', }, # for MSVC builds early_includes => [qw( cstring cstdlib ostream sstream libslic3r/GCodeSender.hpp ), @early_includes] ); $build->create_build_script; __END__ Slic3r-version_1.31.6/xs/MANIFEST000066400000000000000000000122261301441720000162640ustar00rootroot00000000000000Build.PL lib/Slic3r/XS.pm MANIFEST This list of files src/admesh/connect.c src/admesh/normals.c src/admesh/shared.c src/admesh/stl.h src/admesh/stl_io.c src/admesh/stlinit.c src/admesh/util.c src/clipper.cpp src/clipper.hpp src/libslic3r/BoundingBox.cpp src/libslic3r/BoundingBox.hpp src/libslic3r/BridgeDetector.cpp src/libslic3r/BridgeDetector.hpp src/libslic3r/ClipperUtils.cpp src/libslic3r/ClipperUtils.hpp src/libslic3r/Config.cpp src/libslic3r/Config.hpp src/libslic3r/EdgeGrid.cpp src/libslic3r/EdgeGrid.hpp src/libslic3r/ExPolygon.cpp src/libslic3r/ExPolygon.hpp src/libslic3r/ExPolygonCollection.cpp src/libslic3r/ExPolygonCollection.hpp src/libslic3r/Extruder.cpp src/libslic3r/Extruder.hpp src/libslic3r/ExtrusionEntity.cpp src/libslic3r/ExtrusionEntity.hpp src/libslic3r/ExtrusionEntityCollection.cpp src/libslic3r/ExtrusionEntityCollection.hpp src/libslic3r/ExtrusionSimulator.cpp src/libslic3r/ExtrusionSimulator.hpp src/libslic3r/Fill/FillBase.cpp src/libslic3r/Fill/FillBase.hpp src/libslic3r/Fill/FillConcentric.cpp src/libslic3r/Fill/FillConcentric.hpp src/libslic3r/Fill/FillHoneycomb.cpp src/libslic3r/Fill/FillHoneycomb.hpp src/libslic3r/Fill/Fill3DHoneycomb.cpp src/libslic3r/Fill/Fill3DHoneycomb.hpp src/libslic3r/Fill/FillPlanePath.cpp src/libslic3r/Fill/FillPlanePath.hpp src/libslic3r/Fill/FillRectilinear.cpp src/libslic3r/Fill/FillRectilinear.hpp src/libslic3r/Fill/FillRectilinear2.cpp src/libslic3r/Fill/FillRectilinear2.hpp src/libslic3r/Flow.cpp src/libslic3r/Flow.hpp src/libslic3r/GCode.cpp src/libslic3r/GCode.hpp src/libslic3r/GCodeSender.cpp src/libslic3r/GCodeSender.hpp src/libslic3r/GCodeWriter.cpp src/libslic3r/GCodeWriter.hpp src/libslic3r/GCode/PressureEqualizer.cpp src/libslic3r/GCode/PressureEqualizer.hpp src/libslic3r/Geometry.cpp src/libslic3r/Geometry.hpp src/libslic3r/Layer.cpp src/libslic3r/Layer.hpp src/libslic3r/LayerRegion.cpp src/libslic3r/libslic3r.h src/libslic3r/Line.cpp src/libslic3r/Line.hpp src/libslic3r/Model.cpp src/libslic3r/Model.hpp src/libslic3r/MotionPlanner.cpp src/libslic3r/MotionPlanner.hpp src/libslic3r/MultiPoint.cpp src/libslic3r/MultiPoint.hpp src/libslic3r/PerimeterGenerator.cpp src/libslic3r/PerimeterGenerator.hpp src/libslic3r/PlaceholderParser.cpp src/libslic3r/PlaceholderParser.hpp src/libslic3r/Point.cpp src/libslic3r/Point.hpp src/libslic3r/Polygon.cpp src/libslic3r/Polygon.hpp src/libslic3r/Polyline.cpp src/libslic3r/Polyline.hpp src/libslic3r/PolylineCollection.cpp src/libslic3r/PolylineCollection.hpp src/libslic3r/Print.cpp src/libslic3r/Print.hpp src/libslic3r/PrintConfig.cpp src/libslic3r/PrintConfig.hpp src/libslic3r/PrintObject.cpp src/libslic3r/PrintRegion.cpp src/libslic3r/SupportMaterial.cpp src/libslic3r/SupportMaterial.hpp src/libslic3r/Surface.cpp src/libslic3r/Surface.hpp src/libslic3r/SurfaceCollection.cpp src/libslic3r/SurfaceCollection.hpp src/libslic3r/SVG.cpp src/libslic3r/SVG.hpp src/libslic3r/TriangleMesh.cpp src/libslic3r/TriangleMesh.hpp src/libslic3r/utils.cpp src/perlglue.cpp src/poly2tri/common/shapes.cc src/poly2tri/common/shapes.h src/poly2tri/common/utils.h src/poly2tri/poly2tri.h src/poly2tri/sweep/advancing_front.cc src/poly2tri/sweep/advancing_front.h src/poly2tri/sweep/cdt.cc src/poly2tri/sweep/cdt.h src/poly2tri/sweep/sweep.cc src/poly2tri/sweep/sweep.h src/poly2tri/sweep/sweep_context.cc src/poly2tri/sweep/sweep_context.h src/polypartition.cpp src/polypartition.h src/ppport.h src/slic3r/GUI/3DScene.cpp src/slic3r/GUI/3DScene.hpp src/slic3r/GUI/GUI.cpp src/slic3r/GUI/GUI.hpp src/Shiny/Shiny.h src/Shiny/ShinyData.h src/Shiny/ShinyManager.h src/Shiny/ShinyNodePool.h src/Shiny/ShinyOutput.h src/Shiny/ShinyTools.h src/Shiny/ShinyZone.h src/Shiny/ShinyConfig.h src/Shiny/ShinyMacros.h src/Shiny/ShinyNode.h src/Shiny/ShinyNodeState.h src/Shiny/ShinyPrereqs.h src/Shiny/ShinyVersion.h src/Shiny/ShinyManager.c src/Shiny/ShinyNode.c src/Shiny/ShinyNodePool.c src/Shiny/ShinyNodeState.c src/Shiny/ShinyOutput.c src/Shiny/ShinyTools.c src/Shiny/ShinyZone.c src/glew/LICENSE.txt src/glew/README.md src/glew/src/glew.c src/glew/include/GL/glew.h src/glew/include/GL/glxew.h src/glew/include/GL/wglew.h src/xsinit.h t/01_trianglemesh.t t/03_point.t t/04_expolygon.t t/05_surface.t t/06_polygon.t t/07_extrusionpath.t t/08_extrusionloop.t t/09_polyline.t t/10_line.t t/11_clipper.t t/12_extrusionpathcollection.t t/13_polylinecollection.t t/14_geometry.t t/15_config.t t/16_flow.t t/17_boundingbox.t t/18_motionplanner.t t/19_model.t t/20_print.t t/21_gcode.t t/22_exception.t xsp/BoundingBox.xsp xsp/BridgeDetector.xsp xsp/Clipper.xsp xsp/Config.xsp xsp/ExPolygon.xsp xsp/ExPolygonCollection.xsp xsp/Extruder.xsp xsp/ExtrusionEntityCollection.xsp xsp/ExtrusionLoop.xsp xsp/ExtrusionPath.xsp xsp/ExtrusionSimulator.xsp xsp/Filler.xsp xsp/Flow.xsp xsp/GCode.xsp xsp/GCodeSender.xsp xsp/GCodeWriter.xsp xsp/GCodePressureEqualizer.xsp xsp/Geometry.xsp xsp/GUI.xsp xsp/GUI_3DScene.xsp xsp/Layer.xsp xsp/Line.xsp xsp/Model.xsp xsp/MotionPlanner.xsp xsp/my.map xsp/mytype.map xsp/PerimeterGenerator.xsp xsp/PlaceholderParser.xsp xsp/Point.xsp xsp/Polygon.xsp xsp/Polyline.xsp xsp/PolylineCollection.xsp xsp/Print.xsp xsp/SupportMaterial.xsp xsp/Surface.xsp xsp/SurfaceCollection.xsp xsp/TriangleMesh.xsp xsp/typemap.xspt xsp/XS.xsp Slic3r-version_1.31.6/xs/MANIFEST.SKIP000066400000000000000000000023031301441720000170240ustar00rootroot00000000000000 #!start included /Library/Perl/Updates/5.12.4/ExtUtils/MANIFEST.SKIP # Avoid version control files. \bRCS\b \bCVS\b \bSCCS\b ,v$ \B\.svn\b \B\.git\b \B\.gitignore\b \b_darcs\b \B\.cvsignore$ # Avoid VMS specific MakeMaker generated files \bDescrip.MMS$ \bDESCRIP.MMS$ \bdescrip.mms$ # Avoid Makemaker generated and utility files. \bMANIFEST\.bak \bMakefile$ \bblib/ \bMakeMaker-\d \bpm_to_blib\.ts$ \bpm_to_blib$ \bblibdirs\.ts$ # 6.18 through 6.25 generated this # Avoid Module::Build generated and utility files. \bBuild$ \b_build/ \bBuild.bat$ \bBuild.COM$ \bBUILD.COM$ \bbuild.com$ # Avoid temp and backup files. ~$ \.old$ \#$ \b\.# \.bak$ \.tmp$ \.# \.rej$ # Avoid OS-specific files/dirs # Mac OSX metadata \B\.DS_Store # Mac OSX SMB mount metadata files \B\._ # Avoid Devel::Cover and Devel::CoverX::Covered files. \bcover_db\b \bcovered\b # Avoid MYMETA files ^MYMETA\. #!end included /Library/Perl/Updates/5.12.4/ExtUtils/MANIFEST.SKIP # Avoid configuration metadata file ^MYMETA\. # Avoid Module::Build generated and utility files. \bBuild$ \bBuild.bat$ \b_build \bBuild.COM$ \bBUILD.COM$ \bbuild.com$ ^MANIFEST\.SKIP # Avoid archives of this distribution \bSlic3r-XS-[\d\.\_]+ ^assertlib Slic3r-version_1.31.6/xs/lib/000077500000000000000000000000001301441720000156765ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/lib/Slic3r/000077500000000000000000000000001301441720000170355ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/lib/Slic3r/XS.pm000066400000000000000000000170411301441720000177300ustar00rootroot00000000000000package Slic3r::XS; use warnings; use strict; our $VERSION = '0.01'; # We have to load these modules in order to have Wx.pm find the correct paths # for wxWidgets dlls on MSW. # We avoid loading these on OS X because Wx::Load() initializes a Wx App # automatically and it steals focus even when we're not running Slic3r in GUI mode. # TODO: only load these when compiling with GUI support BEGIN { if ($^O eq 'MSWin32') { eval "use Wx"; # eval "use Wx::Html"; eval "use Wx::Print"; # because of some Wx bug, thread creation fails if we don't have this (looks like Wx::Printout is hard-coded in some thread cleanup code) } } use Carp qw(); use XSLoader; XSLoader::load(__PACKAGE__, $VERSION); package Slic3r::Line; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::Point; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::Point3; use overload '@{}' => sub { [ $_[0]->x, $_[0]->y, $_[0]->z ] }, #, 'fallback' => 1; sub pp { my ($self) = @_; return [ @$self ]; } package Slic3r::Pointf; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::Pointf3; use overload '@{}' => sub { [ $_[0]->x, $_[0]->y, $_[0]->z ] }, #, 'fallback' => 1; sub pp { my ($self) = @_; return [ @$self ]; } package Slic3r::ExPolygon; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::Polyline; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::Polyline::Collection; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::Polygon; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::ExPolygon::Collection; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; package Slic3r::ExtrusionPath::Collection; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; sub new { my ($class, @paths) = @_; my $self = $class->_new; $self->append(@paths); return $self; } package Slic3r::ExtrusionLoop; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; sub new_from_paths { my ($class, @paths) = @_; my $loop = $class->new; $loop->append($_) for @paths; return $loop; } package Slic3r::ExtrusionPath; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; sub new { my ($class, %args) = @_; return $class->_new( $args{polyline}, # required $args{role}, # required $args{mm3_per_mm} // die("Missing required mm3_per_mm in ExtrusionPath constructor"), $args{width} // -1, $args{height} // -1, ); } sub clone { my ($self, %args) = @_; return __PACKAGE__->_new( $args{polyline} // $self->polyline, $args{role} // $self->role, $args{mm3_per_mm} // $self->mm3_per_mm, $args{width} // $self->width, $args{height} // $self->height, ); } package Slic3r::ExtrusionSimulator; sub new { my ($class, %args) = @_; return $class->_new(); } package Slic3r::Filler; sub fill_surface { my ($self, $surface, %args) = @_; $self->set_density($args{density}) if defined($args{density}); $self->set_dont_connect($args{dont_connect}) if defined($args{dont_connect}); $self->set_dont_adjust($args{dont_adjust}) if defined($args{dont_adjust}); $self->set_complete($args{complete}) if defined($args{complete}); return $self->_fill_surface($surface); } package Slic3r::Flow; sub new { my ($class, %args) = @_; my $self = $class->_new( @args{qw(width height nozzle_diameter)}, ); $self->set_bridge($args{bridge} // 0); return $self; } sub new_from_width { my ($class, %args) = @_; return $class->_new_from_width( @args{qw(role width nozzle_diameter layer_height bridge_flow_ratio)}, ); } sub new_from_spacing { my ($class, %args) = @_; return $class->_new_from_spacing( @args{qw(spacing nozzle_diameter layer_height bridge)}, ); } package Slic3r::Surface; sub new { my ($class, %args) = @_; # defensive programming: make sure no negative bridge_angle is supplied die "Error: invalid negative bridge_angle\n" if defined $args{bridge_angle} && $args{bridge_angle} < 0; return $class->_new( $args{expolygon} // (die "Missing required expolygon\n"), $args{surface_type} // (die "Missing required surface_type\n"), $args{thickness} // -1, $args{thickness_layers} // 1, $args{bridge_angle} // -1, $args{extra_perimeters} // 0, ); } sub clone { my ($self, %args) = @_; return (ref $self)->_new( delete $args{expolygon} // $self->expolygon, delete $args{surface_type} // $self->surface_type, delete $args{thickness} // $self->thickness, delete $args{thickness_layers} // $self->thickness_layers, delete $args{bridge_angle} // $self->bridge_angle, delete $args{extra_perimeters} // $self->extra_perimeters, ); } package Slic3r::Surface::Collection; use overload '@{}' => sub { $_[0]->arrayref }, 'fallback' => 1; sub new { my ($class, @surfaces) = @_; my $self = $class->_new; $self->append($_) for @surfaces; return $self; } package Slic3r::Print::SupportMaterial2; sub new { my ($class, %args) = @_; return $class->_new( $args{print_config}, # required $args{object_config}, # required $args{first_layer_flow}, # required $args{flow}, # required $args{interface_flow}, # required $args{soluble_interface} // 0 ); } package Slic3r::GUI::_3DScene::GLVertexArray; sub CLONE_SKIP { 1 } package main; for my $class (qw( Slic3r::BridgeDetector Slic3r::Config Slic3r::Config::Full Slic3r::Config::GCode Slic3r::Config::Print Slic3r::Config::PrintObject Slic3r::Config::PrintRegion Slic3r::Config::Static Slic3r::ExPolygon Slic3r::ExPolygon::Collection Slic3r::Extruder Slic3r::ExtrusionLoop Slic3r::ExtrusionPath Slic3r::ExtrusionPath::Collection Slic3r::ExtrusionSimulator Slic3r::Filler Slic3r::Flow Slic3r::GCode Slic3r::GCode::AvoidCrossingPerimeters Slic3r::GCode::OozePrevention Slic3r::GCode::PlaceholderParser Slic3r::GCode::Wipe Slic3r::GCode::Writer Slic3r::Geometry::BoundingBox Slic3r::Geometry::BoundingBoxf Slic3r::Geometry::BoundingBoxf3 Slic3r::Layer Slic3r::Layer::Region Slic3r::Layer::Support Slic3r::Line Slic3r::Linef3 Slic3r::Model Slic3r::Model::Instance Slic3r::Model::Material Slic3r::Model::Object Slic3r::Model::Volume Slic3r::Point Slic3r::Point3 Slic3r::Pointf Slic3r::Pointf3 Slic3r::Polygon Slic3r::Polyline Slic3r::Polyline::Collection Slic3r::Print Slic3r::Print::Object Slic3r::Print::Region Slic3r::Print::State Slic3r::Surface Slic3r::Surface::Collection Slic3r::Print::SupportMaterial2 Slic3r::TriangleMesh )) { no strict 'refs'; my $ref_class = $class . "::Ref"; eval "package $ref_class; our \@ISA = '$class'; sub DESTROY {};"; } 1; Slic3r-version_1.31.6/xs/src/000077500000000000000000000000001301441720000157175ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/Shiny/000077500000000000000000000000001301441720000170115ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/Shiny/Shiny.h000066400000000000000000000025221301441720000202550ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_H #define SHINY_H /*---------------------------------------------------------------------------*/ #include "ShinyMacros.h" #ifdef SLIC3R_PROFILE #include "ShinyManager.h" #endif /* SLIC3R_PROFILE */ #endif /* SHINY_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyConfig.h000066400000000000000000000036201301441720000214030ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_CONFIG_H #define SHINY_CONFIG_H /*---------------------------------------------------------------------------*/ /* if SHINY_LOOKUP_RATE is defined to TRUE then Shiny will record the success of its hash function. This is useful for debugging. Default is FALSE. */ #ifndef SHINY_LOOKUP_RATE // #define SHINY_LOOKUP_RATE FALSE #endif /* if SHINY_HAS_ENABLED is defined to TRUE then Shiny can be enabled and disabled at runtime. TODO: bla bla... */ #ifndef SHINY_HAS_ENABLED // #define SHINY_HAS_ENABLED FALSE #endif /* TODO: */ #define SHINY_OUTPUT_MODE_FLAT 0x1 /* TODO: */ #define SHINY_OUTPUT_MODE_TREE 0x2 /* TODO: */ #define SHINY_OUTPUT_MODE_BOTH 0x3 /* TODO: */ #ifndef SHINY_OUTPUT_MODE #define SHINY_OUTPUT_MODE SHINY_OUTPUT_MODE_BOTH #endif #endif /* SHINY_CONFIG_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyData.h000066400000000000000000000057301301441720000210530ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_DATA_H #define SHINY_DATA_H #include "ShinyPrereqs.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ typedef struct { uint32_t entryCount; shinytick_t selfTicks; } ShinyLastData; /*---------------------------------------------------------------------------*/ typedef struct { shinytick_t cur; float avg; } ShinyTickData; typedef struct { uint32_t cur; float avg; } ShinyCountData; typedef struct { ShinyCountData entryCount; ShinyTickData selfTicks; ShinyTickData childTicks; } ShinyData; SHINY_INLINE shinytick_t ShinyData_totalTicksCur(const ShinyData *self) { return self->selfTicks.cur + self->childTicks.cur; } SHINY_INLINE float ShinyData_totalTicksAvg(const ShinyData *self) { return self->selfTicks.avg + self->childTicks.avg; } SHINY_INLINE void ShinyData_computeAverage(ShinyData *self, float a_damping) { self->entryCount.avg = self->entryCount.cur + a_damping * (self->entryCount.avg - self->entryCount.cur); self->selfTicks.avg = self->selfTicks.cur + a_damping * (self->selfTicks.avg - self->selfTicks.cur); self->childTicks.avg = self->childTicks.cur + a_damping * (self->childTicks.avg - self->childTicks.cur); } SHINY_INLINE void ShinyData_copyAverage(ShinyData *self) { self->entryCount.avg = (float) self->entryCount.cur; self->selfTicks.avg = (float) self->selfTicks.cur; self->childTicks.avg = (float) self->childTicks.cur; } SHINY_INLINE void ShinyData_clearAll(ShinyData *self) { self->entryCount.cur = 0; self->entryCount.avg = 0; self->selfTicks.cur = 0; self->selfTicks.avg = 0; self->childTicks.cur = 0; self->childTicks.avg = 0; } SHINY_INLINE void ShinyData_clearCurrent(ShinyData *self) { self->entryCount.cur = 0; self->selfTicks.cur = 0; self->childTicks.cur = 0; } #if __cplusplus } /* end of extern "C" */ #endif #endif /* SHINY_DATA_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyMacros.h000066400000000000000000000214131301441720000214220ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_MACROS_H #define SHINY_MACROS_H #ifdef SLIC3R_PROFILE #include "ShinyManager.h" /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_UPDATE() \ ShinyManager_update(&Shiny_instance) #define PROFILE_SET_DAMPING(floatfrom0to1) \ Shiny_instance.damping = (floatfrom0to1); #define PROFILE_GET_DAMPING() \ (Shiny_instance.damping) #define PROFILE_OUTPUT(filename) \ ShinyManager_output(&Shiny_instance, (filename)) #define PROFILE_OUTPUT_STREAM(stream) \ ShinyManager_outputToStream(&Shiny_instance, (stream)) #ifdef __cplusplus #define PROFILE_GET_TREE_STRING() \ ShinyManager_outputTreeToString(&Shiny_instance) #define PROFILE_GET_FLAT_STRING() \ ShinyManager_outputFlatToString(&Shiny_instance) #endif /* __cplusplus */ #define PROFILE_DESTROY() \ ShinyManager_destroy(&Shiny_instance) #define PROFILE_CLEAR() \ ShinyManager_clear(&Shiny_instance) #define PROFILE_SORT_ZONES() \ ShinyManager_sortZones(&Shiny_instance) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_GET_TOTAL_TICKS_CUR() \ ShinyData_totalTicksCur(&Shiny_instance.rootZone.data) #define PROFILE_GET_TOTAL_TICKS() \ ShinyData_totalTicksAvg(&Shiny_instance.rootZone.data) #define PROFILE_GET_PROFILED_TICKS_CUR() \ (Shiny_instance.rootZone.data.selfTicks.cur) #define PROFILE_GET_PROFILED_TICKS() \ (Shiny_instance.rootZone.data.selfTicks.avg) #define PROFILE_GET_UNPROFILED_TICKS_CUR() \ (Shiny_instance.rootZone.data.childTicks.cur) #define PROFILE_GET_UNPROFILED_TICKS() \ (Shiny_instance.rootZone.data.childTicks.avg) #define PROFILE_GET_SHARED_TOTAL_TICKS_CUR(name) \ ShinyData_totalTicksCur(&(_PROFILE_ID_ZONE_SHARED(name).data)) #define PROFILE_GET_SHARED_TOTAL_TICKS(name) \ ShinyData_totalTicksAvg(&(_PROFILE_ID_ZONE_SHARED(name).data)) #define PROFILE_GET_SHARED_SELF_TICKS_CUR(name) \ (_PROFILE_ID_ZONE_SHARED(name).data.selfTicks.cur) #define PROFILE_GET_SHARED_SELF_TICKS(name) \ (_PROFILE_ID_ZONE_SHARED(name).data.selfTicks.avg) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_IS_SHARED_SELF_BELOW(name, floatfrom0to1) \ ShinyManager_isZoneSelfTimeBelow( \ &Shiny_instance, _PROFILE_ID_ZONE_SHARED(name), floatfrom0to1) #define PROFILE_IS_SHARED_TOTAL_BELOW(name, floatfrom0to1) \ ShinyManager_isZoneTotalTimeBelow( \ &Shiny_instance, _PROFILE_ID_ZONE_SHARED(name), floatfrom0to1) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_END() \ ShinyManager_endCurNode(&Shiny_instance) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_BEGIN( name ) \ \ static _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE(name), #name); \ _PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE(name)) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #ifdef __cplusplus #define PROFILE_BLOCK( name ) \ \ _PROFILE_BLOCK_DEFINE(_PROFILE_ID_BLOCK()); \ PROFILE_BEGIN(name) #endif /* __cplusplus */ /*---------------------------------------------------------------------------*/ /* public preprocessors */ #ifdef __cplusplus #define PROFILE_FUNC() \ \ _PROFILE_BLOCK_DEFINE(_PROFILE_ID_BLOCK()); \ static _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE_FUNC(), __FUNCTION__); \ _PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_FUNC()) #endif /* __cplusplus */ /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_CODE( code ) \ \ do { \ static _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE_CODE(), #code); \ _PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_CODE()); \ { code; } \ PROFILE_END(); \ } while(0) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_SHARED_EXTERN( name ) \ \ _PROFILE_ZONE_DECLARE(extern, _PROFILE_ID_ZONE_SHARED(name)) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_SHARED_DEFINE( name ) \ \ _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE_SHARED(name), #name) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #define PROFILE_SHARED_BEGIN( name ) \ \ _PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_SHARED(name)) /*---------------------------------------------------------------------------*/ /* public preprocessors */ #ifdef __cplusplus #define PROFILE_SHARED_BLOCK( name ) \ \ _PROFILE_BLOCK_DEFINE(_PROFILE_ID_BLOCK()); \ _PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_SHARED(name)) #endif /* __cplusplus */ /*---------------------------------------------------------------------------*/ /* public preprocessors */ #ifdef SHINY_HAS_ENABLED #define PROFILE_SET_ENABLED( boolean ) \ Shiny_instance.enabled = boolean #endif /*---------------------------------------------------------------------------*/ /* internal preprocessors */ #define _PROFILE_ID_ZONE( name ) __ShinyZone_##name #define _PROFILE_ID_ZONE_FUNC() __ShinyZoneFunc #define _PROFILE_ID_ZONE_CODE() __ShinyZoneCode #define _PROFILE_ID_ZONE_SHARED( name ) name##__ShinyZoneShared #define _PROFILE_ID_BLOCK() __ShinyBlock /*---------------------------------------------------------------------------*/ /* internal preprocessor */ #define _PROFILE_ZONE_DEFINE( id, string ) \ \ ShinyZone id = { \ NULL, SHINY_ZONE_STATE_HIDDEN, string, \ { { 0, 0 }, { 0, 0 }, { 0, 0 } } \ } /*---------------------------------------------------------------------------*/ /* internal preprocessor */ #define _PROFILE_ZONE_DECLARE( prefix, id ) \ \ prefix ShinyZone id /*---------------------------------------------------------------------------*/ /* internal preprocessor */ #define _PROFILE_BLOCK_DEFINE( id ) \ \ ShinyEndNodeOnDestruction SHINY_UNUSED id /*---------------------------------------------------------------------------*/ /* internal preprocessor */ #define _PROFILE_ZONE_BEGIN( id ) \ \ do { \ static ShinyNodeCache cache = &_ShinyNode_dummy; \ ShinyManager_lookupAndBeginNode(&Shiny_instance, &cache, &id); \ } while(0) /*---------------------------------------------------------------------------*/ #else /* SLIC3R_PROFILE */ #define PROFILE_UPDATE() #define PROFILE_SET_DAMPING(x) #define PROFILE_GET_DAMPING() 0.0f #define PROFILE_OUTPUT(x) #define PROFILE_OUTPUT_STREAM(x) #define PROFILE_CLEAR() #define PROFILE_GET_TREE_STRING() std::string() #define PROFILE_GET_FLAT_STRING() std::string() #define PROFILE_DESTROY() #define PROFILE_BEGIN(name) #define PROFILE_BLOCK(name) #define PROFILE_FUNC() #define PROFILE_CODE(code) do { code; } while (0) #define PROFILE_SHARED_GLOBAL(name) #define PROFILE_SHARED_MEMBER(name) #define PROFILE_SHARED_DEFINE(name) #define PROFILE_SHARED_BEGIN(name) #define PROFILE_SHARED_BLOCK(name) #define PROFILE_SET_ENABLED(boolean) #endif /* SLIC3R_PROFILE */ #endif /* SHINY_MACROS_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyManager.c000066400000000000000000000275701301441720000215550ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyManager.h" #include #include #include #include /*---------------------------------------------------------------------------*/ #define TABLE_SIZE_INIT 256 /*---------------------------------------------------------------------------*/ ShinyManager Shiny_instance = { #if SHINY_HAS_ENABLED == TRUE /* enabled = */ false, #endif /* _lastTick = */ 0, /* _curNode = */ &Shiny_instance.rootNode, /* _tableMask = */ 0, /* _nodeTable = */ _ShinyManager_dummyNodeTable, #if SHINY_LOOKUP_RATE == TRUE /* _lookupCount = */ 0, /* _lookupSuccessCount = */ 0, #endif /* _tableSize = */ 1, /* nodeCount = */ 1, /* zoneCount = */ 1, /* _lastZone = */ &Shiny_instance.rootZone, /* _lastNodePool = */ NULL, /* _firstNodePool = */ NULL, /* rootNode = */ { /* _last = */ { 0, 0 }, /* zone = */ &Shiny_instance.rootZone, /* parent = */ &Shiny_instance.rootNode, /* nextSibling = */ NULL, /* firstChild = */ NULL, /* lastChild = */ NULL, /* childCount = */ 0, /* entryLevel = */ 0, /* _cache = */ NULL, /* data = */ { { 0, 0 }, { 0, 0 }, { 0, 0 } } }, /* rootZone = */ { /* next = */ NULL, /* _state = */ SHINY_ZONE_STATE_HIDDEN, /* name = */ "", /* data = */ { { 0, 0 }, { 0, 0 }, { 0, 0 } } }, /* damping = */ 0.9f, /* _initialized = */ FALSE, /* _firstUpdate = */ TRUE }; ShinyNode* _ShinyManager_dummyNodeTable[] = { NULL }; /*---------------------------------------------------------------------------*/ #if SHINY_COMPILER == SHINY_COMPILER_MSVC # pragma warning (push) # pragma warning (disable: 4311) #endif /* primary hash function */ SHINY_INLINE uint32_t hash_value(void* a_pParent, void* a_pZone) { // uint32_t a = (uint32_t) a_pParent + (uint32_t) a_pZone; uint32_t a = *reinterpret_cast(&a_pParent) + *reinterpret_cast(&a_pZone); a = (a+0x7ed55d16) + (a<<12); a = (a^0xc761c23c) ^ (a>>19); return a; } /* * secondary hash used as index offset: force it to be odd * so it's relatively prime to the power-of-two table size */ SHINY_INLINE uint32_t hash_offset(uint32_t a) { return ((a << 8) + (a >> 4)) | 1; } #if SHINY_COMPILER == SHINY_COMPILER_MSVC # pragma warning (pop) #endif /*---------------------------------------------------------------------------*/ void ShinyManager_preLoad(ShinyManager *self) { if (!self->_initialized) { _ShinyManager_init(self); _ShinyManager_createNodeTable(self, TABLE_SIZE_INIT); _ShinyManager_createNodePool(self, TABLE_SIZE_INIT / 2); } } /*---------------------------------------------------------------------------*/ void ShinyManager_update(ShinyManager *self) { #if SHINY_HAS_ENABLED == TRUE if (!enabled) return; #endif _ShinyManager_appendTicksToCurNode(self); ShinyZone_preUpdateChain(&self->rootZone); if (self->_firstUpdate || self->damping == 0) { self->_firstUpdate = FALSE; ShinyNode_updateTreeClean(&self->rootNode); ShinyZone_updateChainClean(&self->rootZone); } else { ShinyNode_updateTree(&self->rootNode, self->damping); ShinyZone_updateChain(&self->rootZone, self->damping); } } /*---------------------------------------------------------------------------*/ void ShinyManager_updateClean(ShinyManager *self) { #if SHINY_HAS_ENABLED == TRUE if (!enabled) return; #endif _ShinyManager_appendTicksToCurNode(self); ShinyZone_preUpdateChain(&self->rootZone); self->_firstUpdate = FALSE; ShinyNode_updateTreeClean(&self->rootNode); ShinyZone_updateChainClean(&self->rootZone); } /*---------------------------------------------------------------------------*/ void ShinyManager_clear(ShinyManager *self) { ShinyManager_destroy(self); ShinyManager_preLoad(self); } /*---------------------------------------------------------------------------*/ void ShinyManager_destroy(ShinyManager *self) { ShinyManager_destroyNodes(self); ShinyManager_resetZones(self); _ShinyManager_uninit(self); } /*---------------------------------------------------------------------------*/ ShinyNode* _ShinyManager_lookupNode(ShinyManager *self, ShinyNodeCache *a_cache, ShinyZone *a_zone) { uint32_t nHash = hash_value(self->_curNode, a_zone); uint32_t nIndex = nHash & self->_tableMask; ShinyNode* pNode = self->_nodeTable[nIndex]; _ShinyManager_incLookup(self); _ShinyManager_incLookupSuccess(self); if (pNode) { uint32_t nStep; if (ShinyNode_isEqual(pNode, self->_curNode, a_zone)) return pNode; /* found it! */ /* hash collision: */ /* compute a secondary hash function for stepping */ nStep = hash_offset(nHash); for (;;) { _ShinyManager_incLookup(self); nIndex = (nIndex + nStep) & self->_tableMask; pNode = self->_nodeTable[nIndex]; if (!pNode) break; /* found empty slot */ else if (ShinyNode_isEqual(pNode, self->_curNode, a_zone)) return pNode; /* found it! */ } /* loop is guaranteed to end because the hash table is never full */ } if (a_zone->_state == SHINY_ZONE_STATE_HIDDEN) { /* zone is not initialized */ ShinyZone_init(a_zone, self->_lastZone); self->_lastZone = a_zone; self->zoneCount++; if (self->_initialized == FALSE) { /* first time init */ _ShinyManager_init(self); _ShinyManager_createNodeTable(self, TABLE_SIZE_INIT); _ShinyManager_createNodePool(self, TABLE_SIZE_INIT / 2); /* initialization has invalidated nIndex * we must compute nIndex again */ return _ShinyManager_createNode(self, a_cache, a_zone); } } /* Althouth nodeCount is not updated * it includes rootNode so it adds up. * * check if we need to grow the table * we keep it at most 1/2 full to be very fast */ if (self->_tableSize < 2 * self->nodeCount) { _ShinyManager_resizeNodeTable(self, 2 * self->_tableSize); _ShinyManager_resizeNodePool(self, self->nodeCount - 1); /* resize has invalidated nIndex * we must compute nIndex again */ return _ShinyManager_createNode(self, a_cache, a_zone); } self->nodeCount++; { ShinyNode* pNewNode = ShinyNodePool_newItem(self->_lastNodePool); ShinyNode_init(pNewNode, self->_curNode, a_zone, a_cache); self->_nodeTable[nIndex] = pNewNode; return pNewNode; } } /*---------------------------------------------------------------------------*/ void _ShinyManager_insertNode(ShinyManager *self, ShinyNode* a_pNode) { uint32_t nHash = hash_value(a_pNode->parent, a_pNode->zone); uint32_t nIndex = nHash & self->_tableMask; if (self->_nodeTable[nIndex]) { uint32_t nStep = hash_offset(nHash); while (self->_nodeTable[nIndex]) nIndex = (nIndex + nStep) & self->_tableMask; } self->_nodeTable[nIndex] = a_pNode; } /*---------------------------------------------------------------------------*/ ShinyNode* _ShinyManager_createNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_pZone) { ShinyNode* pNewNode = ShinyNodePool_newItem(self->_lastNodePool); ShinyNode_init(pNewNode, self->_curNode, a_pZone, a_cache); self->nodeCount++; _ShinyManager_insertNode(self, pNewNode); return pNewNode; } /*---------------------------------------------------------------------------*/ void _ShinyManager_createNodePool(ShinyManager *self, uint32_t a_nCount) { self->_firstNodePool = ShinyNodePool_create(a_nCount); self->_lastNodePool = self->_firstNodePool; } /*---------------------------------------------------------------------------*/ void _ShinyManager_resizeNodePool(ShinyManager *self, uint32_t a_nCount) { ShinyNodePool* pPool = ShinyNodePool_create(a_nCount); self->_lastNodePool->nextPool = pPool; self->_lastNodePool = pPool; } /*---------------------------------------------------------------------------*/ void _ShinyManager_createNodeTable(ShinyManager *self, uint32_t a_nCount) { self->_tableSize = a_nCount; self->_tableMask = a_nCount - 1; self->_nodeTable = (ShinyNodeTable*) malloc(sizeof(ShinyNode) * a_nCount); memset(self->_nodeTable, 0, a_nCount * sizeof(ShinyNode*)); } /*---------------------------------------------------------------------------*/ void _ShinyManager_resizeNodeTable(ShinyManager *self, uint32_t a_nCount) { ShinyNodePool* pPool; free(self->_nodeTable); _ShinyManager_createNodeTable(self, a_nCount); pPool = self->_firstNodePool; while (pPool) { ShinyNode *pIter = ShinyNodePool_firstItem(pPool); while (pIter != pPool->_nextItem) _ShinyManager_insertNode(self, pIter++); pPool = pPool->nextPool; } } /*---------------------------------------------------------------------------*/ void ShinyManager_resetZones(ShinyManager *self) { ShinyZone_resetChain(&self->rootZone); self->_lastZone = &self->rootZone; self->zoneCount = 1; } /*---------------------------------------------------------------------------*/ void ShinyManager_destroyNodes(ShinyManager *self) { if (self->_firstNodePool) { ShinyNodePool_destroy(self->_firstNodePool); self->_firstNodePool = NULL; } if (self->_nodeTable != _ShinyManager_dummyNodeTable) { free(self->_nodeTable); self->_nodeTable = _ShinyManager_dummyNodeTable; self->_tableSize = 1; self->_tableMask = 0; } self->_curNode = &self->rootNode; self->nodeCount = 1; _ShinyManager_init(self); } /*---------------------------------------------------------------------------*/ const char* ShinyManager_getOutputErrorString(ShinyManager *self) { if (self->_firstUpdate) return "!!! Profile data must first be updated !!!"; else if (!self->_initialized) return "!!! No profiles where executed !!!"; else return NULL; } /*---------------------------------------------------------------------------*/ #if SHINY_COMPILER == SHINY_COMPILER_MSVC # pragma warning (push) # pragma warning (disable: 4996) #endif int ShinyManager_output(ShinyManager *self, const char *a_filename) { if (!a_filename) { ShinyManager_outputToStream(self, stdout); } else { FILE *file = fopen(a_filename, "w"); if (!file) return FALSE; ShinyManager_outputToStream(self, file); fclose(file); } return TRUE; } #if SHINY_COMPILER == SHINY_COMPILER_MSVC # pragma warning (pop) #endif /*---------------------------------------------------------------------------*/ void ShinyManager_outputToStream(ShinyManager *self, FILE *a_stream) { const char *error = ShinyManager_getOutputErrorString(self); if (error) { fwrite(error, 1, strlen(error), a_stream); fwrite("\n\n", 1, 2, a_stream); return; } #if SHINY_OUTPUT_MODE & SHINY_OUTPUT_MODE_FLAT ShinyManager_sortZones(self); { int size = ShinyPrintZonesSize(self->zoneCount); char *buffer = (char*) malloc(size); ShinyPrintZones(buffer, &self->rootZone); fwrite(buffer, 1, size - 1, a_stream); fwrite("\n\n", 1, 2, a_stream); free(buffer); } #endif #if SHINY_OUTPUT_MODE & SHINY_OUTPUT_MODE_TREE { int size = ShinyPrintNodesSize(self->nodeCount); char *buffer = (char*) malloc(size); ShinyPrintNodes(buffer, &self->rootNode); fwrite(buffer, 1, size - 1, a_stream); fwrite("\n\n", 1, 2, a_stream); free(buffer); } #endif } #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyManager.h000066400000000000000000000177341301441720000215630ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_MANAGER_H #define SHINY_MANAGER_H #include "ShinyZone.h" #include "ShinyNode.h" #include "ShinyNodePool.h" #include "ShinyTools.h" #include "ShinyOutput.h" #include #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ typedef struct { #ifdef SHINY_HAS_ENABLED bool enabled; #endif shinytick_t _lastTick; ShinyNode* _curNode; uint32_t _tableMask; /* = _tableSize - 1 */ ShinyNodeTable* _nodeTable; #ifdef SHINY_LOOKUP_RATE uint64_t _lookupCount; uint64_t _lookupSuccessCount; #endif uint32_t _tableSize; uint32_t nodeCount; uint32_t zoneCount; ShinyZone* _lastZone; ShinyNodePool* _lastNodePool; ShinyNodePool* _firstNodePool; ShinyNode rootNode; ShinyZone rootZone; float damping; int _initialized; int _firstUpdate; } ShinyManager; /*---------------------------------------------------------------------------*/ extern ShinyNode* _ShinyManager_dummyNodeTable[]; extern ShinyManager Shiny_instance; /*---------------------------------------------------------------------------*/ SHINY_INLINE void _ShinyManager_appendTicksToCurNode(ShinyManager *self) { shinytick_t curTick; ShinyGetTicks(&curTick); ShinyNode_appendTicks(self->_curNode, curTick - self->_lastTick); self->_lastTick = curTick; } SHINY_API ShinyNode* _ShinyManager_lookupNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_zone); SHINY_API void _ShinyManager_createNodeTable(ShinyManager *self, uint32_t a_count); SHINY_API void _ShinyManager_resizeNodeTable(ShinyManager *self, uint32_t a_count); SHINY_API void _ShinyManager_createNodePool(ShinyManager *self, uint32_t a_count); SHINY_API void _ShinyManager_resizeNodePool(ShinyManager *self, uint32_t a_count); SHINY_API ShinyNode* _ShinyManager_createNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_pZone); SHINY_API void _ShinyManager_insertNode(ShinyManager *self, ShinyNode* a_pNode); SHINY_INLINE void _ShinyManager_init(ShinyManager *self) { self->_initialized = TRUE; self->rootNode._last.entryCount = 1; self->rootNode._last.selfTicks = 0; ShinyGetTicks(&self->_lastTick); } SHINY_INLINE void _ShinyManager_uninit(ShinyManager *self) { self->_initialized = FALSE; ShinyNode_clear(&self->rootNode); self->rootNode.parent = &self->rootNode; self->rootNode.zone = &self->rootZone; } #ifdef SHINY_LOOKUP_RATE SHINY_INLINE void _ShinyManager_incLookup(ShinyManager *self) { self->_lookupCount++; } SHINY_INLINE void _ShinyManager_incLookupSuccess(ShinyManager *self) { self->_lookupSuccessCount++; } SHINY_INLINE float ShinyManager_lookupRate(const ShinyManager *self) { return ((float) self->_lookupSuccessCount) / ((float) self->_lookupCount); } #else SHINY_INLINE void _ShinyManager_incLookup(ShinyManager * self) { self = self; } SHINY_INLINE void _ShinyManager_incLookupSuccess(ShinyManager * self) { self = self; } SHINY_INLINE float ShinyManager_lookupRate(const ShinyManager * self) { self = self; return -1; } #endif SHINY_API void ShinyManager_resetZones(ShinyManager *self); SHINY_API void ShinyManager_destroyNodes(ShinyManager *self); SHINY_INLINE float ShinyManager_tableUsage(const ShinyManager *self) { return ((float) self->nodeCount) / ((float) self->_tableSize); } SHINY_INLINE uint32_t ShinyManager_allocMemInBytes(const ShinyManager *self) { return self->_tableSize * sizeof(ShinyNode*) + (self->_firstNodePool)? ShinyNodePool_memoryUsageChain(self->_firstNodePool) : 0; } SHINY_INLINE void ShinyManager_beginNode(ShinyManager *self, ShinyNode* a_node) { ShinyNode_beginEntry(a_node); _ShinyManager_appendTicksToCurNode(self); self->_curNode = a_node; } SHINY_INLINE void ShinyManager_lookupAndBeginNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_zone) { #ifdef SHINY_HAS_ENABLED if (!self->enabled) return; #endif if (self->_curNode != (*a_cache)->parent) *a_cache = _ShinyManager_lookupNode(self, a_cache, a_zone); ShinyManager_beginNode(self, *a_cache); } SHINY_INLINE void ShinyManager_endCurNode(ShinyManager *self) { #ifdef SHINY_HAS_ENABLED if (!self->enabled) return; #endif _ShinyManager_appendTicksToCurNode(self); self->_curNode = self->_curNode->parent; } /**/ SHINY_API void ShinyManager_preLoad(ShinyManager *self); SHINY_API void ShinyManager_updateClean(ShinyManager *self); SHINY_API void ShinyManager_update(ShinyManager *self); SHINY_API void ShinyManager_clear(ShinyManager *self); SHINY_API void ShinyManager_destroy(ShinyManager *self); SHINY_INLINE void ShinyManager_sortZones(ShinyManager *self) { if (self->rootZone.next) self->_lastZone = ShinyZone_sortChain(&self->rootZone.next); } SHINY_API const char* ShinyManager_getOutputErrorString(ShinyManager *self); SHINY_API int ShinyManager_output(ShinyManager *self, const char *a_filename); SHINY_API void ShinyManager_outputToStream(ShinyManager *self, FILE *stream); #if __cplusplus } /* end of extern "C" */ SHINY_INLINE std::string ShinyManager_outputTreeToString(ShinyManager *self) { const char* error = ShinyManager_getOutputErrorString(self); if (error) return error; else return ShinyNodesToString(&self->rootNode, self->nodeCount); } SHINY_INLINE std::string ShinyManager_outputFlatToString(ShinyManager *self) { const char* error = ShinyManager_getOutputErrorString(self); if (error) return error; ShinyManager_sortZones(self); return ShinyZonesToString(&self->rootZone, self->zoneCount); } extern "C" { /* end of c++ */ #endif SHINY_INLINE int ShinyManager_isZoneSelfTimeBelow(ShinyManager *self, ShinyZone* a_zone, float a_percentage) { return a_percentage * (float) self->rootZone.data.childTicks.cur <= (float) a_zone->data.selfTicks.cur; } SHINY_INLINE int ShinyManager_isZoneTotalTimeBelow(ShinyManager *self, ShinyZone* a_zone, float a_percentage) { return a_percentage * (float) self->rootZone.data.childTicks.cur <= (float) ShinyData_totalTicksCur(&a_zone->data); } /**/ SHINY_INLINE void ShinyManager_enumerateNodes(ShinyManager *self, void (*a_func)(const ShinyNode*)) { ShinyNode_enumerateNodes(&self->rootNode, a_func); } SHINY_INLINE void ShinyManager_enumerateZones(ShinyManager *self, void (*a_func)(const ShinyZone*)) { ShinyZone_enumerateZones(&self->rootZone, a_func); } #if __cplusplus } /* end of extern "C" */ template void ShinyManager_enumerateNodes(ShinyManager *self, T* a_this, void (T::*a_func)(const ShinyNode*)) { ShinyNode_enumerateNodes(&self->rootNode, a_this, a_func); } template void ShinyManager_enumerateZones(ShinyManager *self, T* a_this, void (T::*a_func)(const ShinyZone*)) { ShinyZone_enumerateZones(&self->rootZone, a_this, a_func); } extern "C" { /* end of c++ */ #endif /*---------------------------------------------------------------------------*/ #if __cplusplus } /* end of extern "C" */ class ShinyEndNodeOnDestruction { public: SHINY_INLINE ~ShinyEndNodeOnDestruction() { ShinyManager_endCurNode(&Shiny_instance); } }; #endif #endif /* SHINY_MANAGER_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyNode.c000066400000000000000000000065611301441720000210650ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyNode.h" #include "ShinyZone.h" #include "ShinyNodeState.h" #include /*---------------------------------------------------------------------------*/ ShinyNode _ShinyNode_dummy = { /* _last = */ { 0, 0 }, /* zone = */ NULL, /* parent = */ NULL, /* nextSibling = */ NULL, /* firstChild = */ NULL, /* lastChild = */ NULL }; /*---------------------------------------------------------------------------*/ void ShinyNode_updateTree(ShinyNode* first, float a_damping) { ShinyNodeState *top = NULL; ShinyNode *node = first; for (;;) { do { top = ShinyNodeState_push(top, node); node = node->firstChild; } while (node); for (;;) { node = ShinyNodeState_finishAndGetNext(top, a_damping); top = ShinyNodeState_pop(top); if (node) break; else if (!top) return; } } } /*---------------------------------------------------------------------------*/ void ShinyNode_updateTreeClean(ShinyNode* first) { ShinyNodeState *top = NULL; ShinyNode *node = first; for (;;) { do { top = ShinyNodeState_push(top, node); node = node->firstChild; } while (node); for (;;) { node = ShinyNodeState_finishAndGetNextClean(top); top = ShinyNodeState_pop(top); if (node) break; else if (!top) return; } } } /*---------------------------------------------------------------------------*/ const ShinyNode* ShinyNode_findNextInTree(const ShinyNode* self) { if (self->firstChild) { return self->firstChild; } else if (self->nextSibling) { return self->nextSibling; } else { ShinyNode* pParent = self->parent; while (!ShinyNode_isRoot(pParent)) { if (pParent->nextSibling) return pParent->nextSibling; else pParent = pParent->parent; } return NULL; } } /*---------------------------------------------------------------------------*/ void ShinyNode_clear(ShinyNode* self) { memset(self, 0, sizeof(ShinyNode)); } /*---------------------------------------------------------------------------*/ void ShinyNode_enumerateNodes(const ShinyNode* a_node, void (*a_func)(const ShinyNode*)) { a_func(a_node); if (a_node->firstChild) ShinyNode_enumerateNodes(a_node->firstChild, a_func); if (a_node->nextSibling) ShinyNode_enumerateNodes(a_node->nextSibling, a_func); } #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyNode.h000066400000000000000000000075121301441720000210670ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_NODE_H #define SHINY_NODE_H #include "ShinyData.h" #include "ShinyTools.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ typedef struct _ShinyNode { ShinyLastData _last; struct _ShinyZone* zone; struct _ShinyNode* parent; struct _ShinyNode* nextSibling; struct _ShinyNode* firstChild; struct _ShinyNode* lastChild; uint32_t childCount; uint32_t entryLevel; ShinyNodeCache* _cache; ShinyData data; } ShinyNode; /*---------------------------------------------------------------------------*/ extern ShinyNode _ShinyNode_dummy; /*---------------------------------------------------------------------------*/ SHINY_INLINE void ShinyNode_addChild(ShinyNode* self, ShinyNode* a_child) { if (self->childCount++) { self->lastChild->nextSibling = a_child; self->lastChild = a_child; } else { self->lastChild = a_child; self->firstChild = a_child; } } SHINY_INLINE void ShinyNode_init(ShinyNode* self, ShinyNode* a_parent, struct _ShinyZone* a_zone, ShinyNodeCache* a_cache) { /* NOTE: all member variables are assumed to be zero when allocated */ self->zone = a_zone; self->parent = a_parent; self->entryLevel = a_parent->entryLevel + 1; ShinyNode_addChild(a_parent, self); self->_cache = a_cache; } SHINY_API void ShinyNode_updateTree(ShinyNode* self, float a_damping); SHINY_API void ShinyNode_updateTreeClean(ShinyNode* self); SHINY_INLINE void ShinyNode_destroy(ShinyNode* self) { *(self->_cache) = &_ShinyNode_dummy; } SHINY_INLINE void ShinyNode_appendTicks(ShinyNode* self, shinytick_t a_elapsedTicks) { self->_last.selfTicks += a_elapsedTicks; } SHINY_INLINE void ShinyNode_beginEntry(ShinyNode* self) { self->_last.entryCount++; } SHINY_INLINE int ShinyNode_isRoot(ShinyNode* self) { return (self->entryLevel == 0); } SHINY_INLINE int ShinyNode_isDummy(ShinyNode* self) { return (self == &_ShinyNode_dummy); } SHINY_INLINE int ShinyNode_isEqual(ShinyNode* self, const ShinyNode* a_parent, const struct _ShinyZone* a_zone) { return (self->parent == a_parent && self->zone == a_zone); } SHINY_API const ShinyNode* ShinyNode_findNextInTree(const ShinyNode* self); SHINY_API void ShinyNode_clear(ShinyNode* self); SHINY_API void ShinyNode_enumerateNodes(const ShinyNode* a_node, void (*a_func)(const ShinyNode*)); #if __cplusplus } /* end of extern "C" */ template void ShinyNode_enumerateNodes(const ShinyNode* a_node, T* a_this, void (T::*a_func)(const ShinyNode*)) { (a_this->*a_func)(a_node); if (a_node->firstChild) ShinyNode_enumerateNodes(a_node->firstChild, a_this, a_func); if (a_node->nextSibling) ShinyNode_enumerateNodes(a_node->nextSibling, a_this, a_func); } #endif /* __cplusplus */ #endif /* SHINY_NODE_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyNodePool.c000066400000000000000000000047271301441720000217210ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyNodePool.h" #include "ShinyTools.h" #include #include /*---------------------------------------------------------------------------*/ ShinyNodePool* ShinyNodePool_create(uint32_t a_items) { ShinyNodePool* pPool = (ShinyNodePool*) malloc(sizeof(ShinyNodePool) + sizeof(ShinyNode) * (a_items - 1)); pPool->nextPool = NULL; pPool->_nextItem = &pPool->_items[0]; pPool->endOfItems = &pPool->_items[a_items]; memset(&pPool->_items[0], 0, a_items * sizeof(ShinyNode)); return pPool; } /*---------------------------------------------------------------------------*/ uint32_t ShinyNodePool_memoryUsageChain(ShinyNodePool *first) { uint32_t bytes = (uint32_t) ((char*) first->endOfItems - (char*) first); ShinyNodePool *pool = first->nextPool; while (pool) { bytes += (uint32_t) ((char*) pool->endOfItems - (char*) pool); pool = pool->nextPool; } return bytes; } /*---------------------------------------------------------------------------*/ void ShinyNodePool_destroy(ShinyNodePool *self) { ShinyNode* firstNode = ShinyNodePool_firstItem(self); ShinyNode* lastNode = self->_nextItem; while (firstNode != lastNode) ShinyNode_destroy(firstNode++); /* TODO: make this into a loop or a tail recursion */ if (self->nextPool) ShinyNodePool_destroy(self->nextPool); free(self); } #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyNodePool.h000066400000000000000000000037341301441720000217230ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_NODE_POOL_H #define SHINY_NODE_POOL_H #include "ShinyNode.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ typedef struct _ShinyNodePool { struct _ShinyNodePool* nextPool; ShinyNode *_nextItem; ShinyNode *endOfItems; ShinyNode _items[1]; } ShinyNodePool; /*---------------------------------------------------------------------------*/ SHINY_INLINE ShinyNode* ShinyNodePool_firstItem(ShinyNodePool *self) { return &(self->_items[0]); } SHINY_INLINE ShinyNode* ShinyNodePool_newItem(ShinyNodePool *self) { return self->_nextItem++; } ShinyNodePool* ShinyNodePool_create(uint32_t a_items); void ShinyNodePool_destroy(ShinyNodePool *self); uint32_t ShinyNodePool_memoryUsageChain(ShinyNodePool *first); #if __cplusplus } /* end of extern "C" */ #endif #endif /* SHINY_NODE_POOL_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyNodeState.c000066400000000000000000000066121301441720000220630ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyNodeState.h" #include "ShinyNode.h" #include "ShinyZone.h" #include /*---------------------------------------------------------------------------*/ ShinyNodeState* ShinyNodeState_push(ShinyNodeState *a_top, ShinyNode *a_node) { ShinyZone *zone = a_node->zone; ShinyNodeState *self = (ShinyNodeState*) malloc(sizeof(ShinyNodeState)); self->node = a_node; self->_prev = a_top; a_node->data.selfTicks.cur = a_node->_last.selfTicks; a_node->data.entryCount.cur = a_node->_last.entryCount; zone->data.selfTicks.cur += a_node->_last.selfTicks; zone->data.entryCount.cur += a_node->_last.entryCount; a_node->data.childTicks.cur = 0; a_node->_last.selfTicks = 0; a_node->_last.entryCount = 0; self->zoneUpdating = zone->_state != SHINY_ZONE_STATE_UPDATING; if (self->zoneUpdating) { zone->_state = SHINY_ZONE_STATE_UPDATING; } else { zone->data.childTicks.cur -= a_node->data.selfTicks.cur; } return self; } /*---------------------------------------------------------------------------*/ ShinyNodeState* ShinyNodeState_pop(ShinyNodeState *a_top) { ShinyNodeState *prev = a_top->_prev; free(a_top); return prev; } /*---------------------------------------------------------------------------*/ ShinyNode* ShinyNodeState_finishAndGetNext(ShinyNodeState *self, float a_damping) { ShinyNode *node = self->node; ShinyZone *zone = node->zone; if (self->zoneUpdating) { zone->data.childTicks.cur += node->data.childTicks.cur; zone->_state = SHINY_ZONE_STATE_INITIALIZED; } ShinyData_computeAverage(&node->data, a_damping); if (!ShinyNode_isRoot(node)) node->parent->data.childTicks.cur += node->data.selfTicks.cur + node->data.childTicks.cur; return node->nextSibling; } /*---------------------------------------------------------------------------*/ ShinyNode* ShinyNodeState_finishAndGetNextClean(ShinyNodeState *self) { ShinyNode *node = self->node; ShinyZone *zone = node->zone; if (self->zoneUpdating) { zone->data.childTicks.cur += node->data.childTicks.cur; zone->_state = SHINY_ZONE_STATE_INITIALIZED; } ShinyData_copyAverage(&node->data); if (!ShinyNode_isRoot(node)) node->parent->data.childTicks.cur += node->data.selfTicks.cur + node->data.childTicks.cur; return node->nextSibling; } #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyNodeState.h000066400000000000000000000035601301441720000220670ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_NODE_STATE_H #define SHINY_NODE_STATE_H #include "ShinyNode.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ typedef struct _ShinyNodeState { ShinyNode *node; int zoneUpdating; struct _ShinyNodeState *_prev; } ShinyNodeState; /*---------------------------------------------------------------------------*/ ShinyNodeState* ShinyNodeState_push(ShinyNodeState *a_top, ShinyNode *a_node); ShinyNodeState* ShinyNodeState_pop(ShinyNodeState *a_top); ShinyNode* ShinyNodeState_finishAndGetNext(ShinyNodeState *self, float a_damping); ShinyNode* ShinyNodeState_finishAndGetNextClean(ShinyNodeState *self); #if __cplusplus } /* end of extern "C" */ #endif #endif /* SHINY_NODE_STATE_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyOutput.c000066400000000000000000000131571301441720000214770ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyOutput.h" #include #if SHINY_COMPILER == SHINY_COMPILER_MSVC # pragma warning(disable: 4996) # define snprintf _snprintf # define TRAILING 0 #else # define TRAILING 1 #endif /*---------------------------------------------------------------------------*/ #define OUTPUT_WIDTH_CALL 6 #define OUTPUT_WIDTH_TIME 6 #define OUTPUT_WIDTH_PERC 4 #define OUTPUT_WIDTH_SUM 120 #define OUTPUT_WIDTH_DATA (1+OUTPUT_WIDTH_CALL + 1 + 2*(OUTPUT_WIDTH_TIME+4+OUTPUT_WIDTH_PERC+1) + 1) #define OUTPUT_WIDTH_NAME (OUTPUT_WIDTH_SUM - OUTPUT_WIDTH_DATA) /*---------------------------------------------------------------------------*/ SHINY_INLINE char* printHeader(char *output, const char *a_title) { snprintf(output, OUTPUT_WIDTH_SUM + TRAILING, "%-*s %*s %*s %*s", OUTPUT_WIDTH_NAME, a_title, OUTPUT_WIDTH_CALL, "calls", OUTPUT_WIDTH_TIME+4+OUTPUT_WIDTH_PERC+1, "self time", OUTPUT_WIDTH_TIME+4+OUTPUT_WIDTH_PERC+1, "total time"); return output + OUTPUT_WIDTH_SUM; } /*---------------------------------------------------------------------------*/ SHINY_INLINE char* printData(char *output, const ShinyData *a_data, float a_topercent) { float totalTicksAvg = ShinyData_totalTicksAvg(a_data); const ShinyTimeUnit *selfUnit = ShinyGetTimeUnit(a_data->selfTicks.avg); const ShinyTimeUnit *totalUnit = ShinyGetTimeUnit(totalTicksAvg); snprintf(output, OUTPUT_WIDTH_DATA + TRAILING, " %*.1f %*.0f %-2s %*.0f%% %*.0f %-2s %*.0f%%", OUTPUT_WIDTH_CALL, a_data->entryCount.avg, OUTPUT_WIDTH_TIME, a_data->selfTicks.avg * selfUnit->invTickFreq, selfUnit->suffix, OUTPUT_WIDTH_PERC, a_data->selfTicks.avg * a_topercent, OUTPUT_WIDTH_TIME, totalTicksAvg * totalUnit->invTickFreq, totalUnit->suffix, OUTPUT_WIDTH_PERC, totalTicksAvg * a_topercent); return output + OUTPUT_WIDTH_DATA; } /*---------------------------------------------------------------------------*/ SHINY_INLINE char* printNode(char* output, const ShinyNode *a_node, float a_topercent) { int offset = a_node->entryLevel * 2; snprintf(output, OUTPUT_WIDTH_NAME + TRAILING, "%*s%-*s", offset, "", OUTPUT_WIDTH_NAME - offset, a_node->zone->name); output += OUTPUT_WIDTH_NAME; output = printData(output, &a_node->data, a_topercent); return output; } /*---------------------------------------------------------------------------*/ SHINY_INLINE char* printZone(char* output, const ShinyZone *a_zone, float a_topercent) { snprintf(output, OUTPUT_WIDTH_NAME + TRAILING, "%-*s", OUTPUT_WIDTH_NAME, a_zone->name); output += OUTPUT_WIDTH_NAME; output = printData(output, &a_zone->data, a_topercent); return output; } /*---------------------------------------------------------------------------*/ int ShinyPrintNodesSize(uint32_t a_count) { return (1 + a_count) * (OUTPUT_WIDTH_SUM + 1); } /*---------------------------------------------------------------------------*/ int ShinyPrintZonesSize(uint32_t a_count) { return (1 + a_count) * (OUTPUT_WIDTH_SUM + 1); } /*---------------------------------------------------------------------------*/ void ShinyPrintANode(char* output, const ShinyNode *a_node, const ShinyNode *a_root) { float fTicksToPc = 100.0f / a_root->data.childTicks.avg; output = printNode(output, a_node, fTicksToPc); (*output++) = '\0'; } /*---------------------------------------------------------------------------*/ void ShinyPrintAZone(char* output, const ShinyZone *a_zone, const ShinyZone *a_root) { float fTicksToPc = 100.0f / a_root->data.childTicks.avg; output = printZone(output, a_zone, fTicksToPc); (*output++) = '\0'; } /*---------------------------------------------------------------------------*/ void ShinyPrintNodes(char* output, const ShinyNode *a_root) { float fTicksToPc = 100.0f / a_root->data.childTicks.avg; const ShinyNode *node = a_root; output = printHeader(output, "call tree"); (*output++) = '\n'; for (;;) { output = printNode(output, node, fTicksToPc); node = ShinyNode_findNextInTree(node); if (node) { (*output++) = '\n'; } else { (*output++) = '\0'; return; } } } /*---------------------------------------------------------------------------*/ void ShinyPrintZones(char* output, const ShinyZone *a_root) { float fTicksToPc = 100.0f / a_root->data.childTicks.avg; const ShinyZone *zone = a_root; output = printHeader(output, "sorted list"); (*output++) = '\n'; for (;;) { output = printZone(output, zone, fTicksToPc); zone = zone->next; if (zone) { (*output++) = '\n'; } else { (*output++) = '\0'; return; } } } #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyOutput.h000066400000000000000000000045241301441720000215020ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_OUTPUT_H #define SHINY_OUTPUT_H #include "ShinyNode.h" #include "ShinyZone.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ SHINY_API int ShinyPrintNodesSize(uint32_t a_count); SHINY_API int ShinyPrintZonesSize(uint32_t a_count); SHINY_API void ShinyPrintANode(char* output, const ShinyNode *a_node, const ShinyNode *a_root); SHINY_API void ShinyPrintAZone(char* output, const ShinyZone *a_zone, const ShinyZone *a_root); SHINY_API void ShinyPrintNodes(char* output, const ShinyNode *a_root); SHINY_API void ShinyPrintZones(char* output, const ShinyZone *a_root); /*---------------------------------------------------------------------------*/ #if __cplusplus } /* end of extern "C" */ #include SHINY_INLINE std::string ShinyNodesToString(const ShinyNode *a_root, uint32_t a_count) { std::string str; str.resize(ShinyPrintNodesSize(a_count) - 1); ShinyPrintNodes(&str[0], a_root); return str; } SHINY_INLINE std::string ShinyZonesToString(const ShinyZone *a_root, uint32_t a_count) { std::string str; str.resize(ShinyPrintZonesSize(a_count) - 1); ShinyPrintZones(&str[0], a_root); return str; } #endif /* __cplusplus */ #endif /* SHINY_OUTPUT_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyPrereqs.h000066400000000000000000000066631301441720000216310ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_PREREQS_H #define SHINY_PREREQS_H /*---------------------------------------------------------------------------*/ #ifndef FALSE #define FALSE 0x0 #endif #ifndef TRUE #define TRUE 0x1 #endif #ifndef NULL #define NULL 0 #endif #include "ShinyConfig.h" #include "ShinyVersion.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ #define SHINY_PLATFORM_WIN32 0x1 #define SHINY_PLATFORM_POSIX 0x2 #if defined (_WIN32) # define SHINY_PLATFORM SHINY_PLATFORM_WIN32 #else /* ASSUME: POSIX-compliant OS */ # define SHINY_PLATFORM SHINY_PLATFORM_POSIX #endif /*---------------------------------------------------------------------------*/ #define SHINY_COMPILER_MSVC 0x1 #define SHINY_COMPILER_GNUC 0x2 #define SHINY_COMPILER_OTHER 0x3 #if defined (_MSC_VER) # define SHINY_COMPILER SHINY_COMPILER_MSVC #elif defined (__GNUG__) # define SHINY_COMPILER SHINY_COMPILER_GNUC #else # define SHINY_COMPILER SHINY_COMPILER_OTHER #endif /*---------------------------------------------------------------------------*/ #if SHINY_COMPILER == SHINY_COMPILER_GNUC #include #include #endif /*---------------------------------------------------------------------------*/ struct _ShinyNode; struct _ShinyZone; typedef struct _ShinyNode* ShinyNodeCache; typedef struct _ShinyNode* ShinyNodeTable; /*---------------------------------------------------------------------------*/ #define SHINY_API /*---------------------------------------------------------------------------*/ #if SHINY_COMPILER == SHINY_COMPILER_MSVC # define SHINY_INLINE __inline # define SHINY_UNUSED #elif SHINY_COMPILER == SHINY_COMPILER_GNUC # define SHINY_INLINE inline # define SHINY_UNUSED __attribute__((unused)) #elif SHINY_COMPILER == SHINY_COMPILER_OTHER # define SHINY_INLINE inline # define SHINY_UNUSED #endif /*---------------------------------------------------------------------------*/ #if SHINY_COMPILER == SHINY_COMPILER_MSVC typedef int int32_t; typedef unsigned int uint32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; /* #elif defined(__CYGWIN__) typedef u_int32_t uint32_t; typedef u_int64_t uint64_t; */ #endif typedef uint64_t shinytick_t; #if __cplusplus } /* end of extern "C" */ #endif #endif /* SHINY_PREREQS_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyTools.c000066400000000000000000000063451301441720000213000ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyTools.h" #if SHINY_PLATFORM == SHINY_PLATFORM_WIN32 #define WIN32_LEAN_AND_MEAN #ifndef NOMINMAX #define NOMINMAX #endif /* NOMINMAX */ #include #elif SHINY_PLATFORM == SHINY_PLATFORM_POSIX #include #endif /*---------------------------------------------------------------------------*/ const ShinyTimeUnit* ShinyGetTimeUnit(float ticks) { static ShinyTimeUnit units[4] = { 0 }; if (units[0].tickFreq == 0) { /* auto initialize first time */ units[0].tickFreq = ShinyGetTickFreq() / 1.0f; units[0].invTickFreq = ShinyGetTickInvFreq() * 1.0f; units[0].suffix = "s"; units[1].tickFreq = ShinyGetTickFreq() / 1000.0f; units[1].invTickFreq = ShinyGetTickInvFreq() * 1000.0f; units[1].suffix = "ms"; units[2].tickFreq = ShinyGetTickFreq() / 1000000.0f; units[2].invTickFreq = ShinyGetTickInvFreq() * 1000000.0f; units[2].suffix = "us"; units[3].tickFreq = ShinyGetTickFreq() / 1000000000.0f; units[3].invTickFreq = ShinyGetTickInvFreq() * 1000000000.0f; units[3].suffix = "ns"; } if (units[0].tickFreq < ticks) return &units[0]; else if (units[1].tickFreq < ticks) return &units[1]; else if (units[2].tickFreq < ticks) return &units[2]; else return &units[3]; } /*---------------------------------------------------------------------------*/ #if SHINY_PLATFORM == SHINY_PLATFORM_WIN32 void ShinyGetTicks(shinytick_t *p) { QueryPerformanceCounter((LARGE_INTEGER*)(p)); } shinytick_t ShinyGetTickFreq(void) { static shinytick_t freq = 0; if (freq == 0) QueryPerformanceFrequency((LARGE_INTEGER*)(&freq)); return freq; } float ShinyGetTickInvFreq(void) { static float invfreq = 0; if (invfreq == 0) invfreq = 1.0f / ShinyGetTickFreq(); return invfreq; } /*---------------------------------------------------------------------------*/ #elif SHINY_PLATFORM == SHINY_PLATFORM_POSIX void ShinyGetTicks(shinytick_t *p) { timeval time; gettimeofday(&time, NULL); *p = time.tv_sec * 1000000 + time.tv_usec; } shinytick_t ShinyGetTickFreq(void) { return 1000000; } float ShinyGetTickInvFreq(void) { return 1.0f / 1000000.0f; } #endif #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyTools.h000066400000000000000000000033521301441720000213000ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_TOOLS_H #define SHINY_TOOLS_H #include "ShinyPrereqs.h" #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ typedef struct { float tickFreq; float invTickFreq; const char* suffix; } ShinyTimeUnit; /*---------------------------------------------------------------------------*/ SHINY_API const ShinyTimeUnit* ShinyGetTimeUnit(float ticks); SHINY_API void ShinyGetTicks(shinytick_t *p); SHINY_API shinytick_t ShinyGetTickFreq(void); SHINY_API float ShinyGetTickInvFreq(void); #if __cplusplus } /* end of extern "C" */ #endif #endif /* SHINY_TOOLS_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyVersion.h000066400000000000000000000030531301441720000216230ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_VERSION_H #define SHINY_VERSION_H /*---------------------------------------------------------------------------*/ #define SHINY_VERSION "2.6 RC1" #define SHINY_SHORTNAME "Shiny" #define SHINY_FULLNAME "Shiny Profiler" #define SHINY_COPYRIGHT "Copyright (C) 2007-2010 Aidin Abedi" #define SHINY_DESCRIPTION "Shiny is a state of the art profiler designed to help finding bottlenecks in your project." #endif /* SHINY_VERSION_H */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyZone.c000066400000000000000000000114731301441720000211110ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef SLIC3R_PROFILE #include "ShinyZone.h" #include /*---------------------------------------------------------------------------*/ void ShinyZone_preUpdateChain(ShinyZone *first) { ShinyZone* zone = first; while (zone) { ShinyData_clearCurrent(&(zone->data)); zone = zone->next; } } /*---------------------------------------------------------------------------*/ void ShinyZone_updateChain(ShinyZone *first, float a_damping) { ShinyZone* zone = first; do { ShinyData_computeAverage(&(zone->data), a_damping); zone = zone->next; } while (zone); } /*---------------------------------------------------------------------------*/ void ShinyZone_updateChainClean(ShinyZone *first) { ShinyZone* zone = first; do { ShinyData_copyAverage(&(zone->data)); zone = zone->next; } while (zone); } /*---------------------------------------------------------------------------*/ void ShinyZone_resetChain(ShinyZone *first) { ShinyZone* zone = first, *temp; do { zone->_state = SHINY_ZONE_STATE_HIDDEN; temp = zone->next; zone->next = NULL; zone = temp; } while (zone); } /*---------------------------------------------------------------------------*/ /* A Linked-List Memory Sort by Philip J. Erdelsky pje@efgh.com http://www.alumni.caltech.edu/~pje/ Modified by Aidin Abedi */ ShinyZone* ShinyZone_sortChain(ShinyZone **first) /* return ptr to last zone */ { ShinyZone *p = *first; unsigned base; unsigned long block_size; struct tape { ShinyZone *first, *last; unsigned long count; } tape[4]; /* Distribute the records alternately to tape[0] and tape[1]. */ tape[0].count = tape[1].count = 0L; tape[0].first = NULL; base = 0; while (p != NULL) { ShinyZone *next = p->next; p->next = tape[base].first; tape[base].first = p; tape[base].count++; p = next; base ^= 1; } /* If the list is empty or contains only a single record, then */ /* tape[1].count == 0L and this part is vacuous. */ for (base = 0, block_size = 1L; tape[base+1].count != 0L; base ^= 2, block_size <<= 1) { int dest; struct tape *tape0, *tape1; tape0 = tape + base; tape1 = tape + base + 1; dest = base ^ 2; tape[dest].count = tape[dest+1].count = 0; for (; tape0->count != 0; dest ^= 1) { unsigned long n0, n1; struct tape *output_tape = tape + dest; n0 = n1 = block_size; while (1) { ShinyZone *chosen_record; struct tape *chosen_tape; if (n0 == 0 || tape0->count == 0) { if (n1 == 0 || tape1->count == 0) break; chosen_tape = tape1; n1--; } else if (n1 == 0 || tape1->count == 0) { chosen_tape = tape0; n0--; } else if (ShinyZone_compare(tape1->first, tape0->first) > 0) { chosen_tape = tape1; n1--; } else { chosen_tape = tape0; n0--; } chosen_tape->count--; chosen_record = chosen_tape->first; chosen_tape->first = chosen_record->next; if (output_tape->count == 0) output_tape->first = chosen_record; else output_tape->last->next = chosen_record; output_tape->last = chosen_record; output_tape->count++; } } } if (tape[base].count > 1L) { ShinyZone* last = tape[base].last; *first = tape[base].first; last->next = NULL; return last; } else { return NULL; } } /*---------------------------------------------------------------------------*/ void ShinyZone_clear(ShinyZone* self) { memset(self, 0, sizeof(ShinyZone)); } /*---------------------------------------------------------------------------*/ void ShinyZone_enumerateZones(const ShinyZone* a_zone, void (*a_func)(const ShinyZone*)) { a_func(a_zone); if (a_zone->next) ShinyZone_enumerateZones(a_zone->next, a_func); } #endif /* SLIC3R_PROFILE */ Slic3r-version_1.31.6/xs/src/Shiny/ShinyZone.h000066400000000000000000000055231301441720000211150ustar00rootroot00000000000000/* The MIT License Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef SHINY_ZONE_H #define SHINY_ZONE_H #include "ShinyData.h" #include #ifdef __cplusplus extern "C" { #endif /*---------------------------------------------------------------------------*/ #define SHINY_ZONE_STATE_HIDDEN 0 #define SHINY_ZONE_STATE_INITIALIZED 1 #define SHINY_ZONE_STATE_UPDATING 2 /*---------------------------------------------------------------------------*/ typedef struct _ShinyZone { struct _ShinyZone* next; int _state; const char* name; ShinyData data; } ShinyZone; /*---------------------------------------------------------------------------*/ SHINY_INLINE void ShinyZone_init(ShinyZone *self, ShinyZone* a_prev) { self->_state = SHINY_ZONE_STATE_INITIALIZED; a_prev->next = self; } SHINY_INLINE void ShinyZone_uninit(ShinyZone *self) { self->_state = SHINY_ZONE_STATE_HIDDEN; self->next = NULL; } SHINY_API void ShinyZone_preUpdateChain(ShinyZone *first); SHINY_API void ShinyZone_updateChain(ShinyZone *first, float a_damping); SHINY_API void ShinyZone_updateChainClean(ShinyZone *first); SHINY_API void ShinyZone_resetChain(ShinyZone *first); SHINY_API ShinyZone* ShinyZone_sortChain(ShinyZone **first); SHINY_INLINE float ShinyZone_compare(ShinyZone *a, ShinyZone *b) { return a->data.selfTicks.avg - b->data.selfTicks.avg; } SHINY_API void ShinyZone_clear(ShinyZone* self); SHINY_API void ShinyZone_enumerateZones(const ShinyZone* a_zone, void (*a_func)(const ShinyZone*)); #if __cplusplus } /* end of extern "C" */ template void ShinyZone_enumerateZones(const ShinyZone* a_zone, T* a_this, void (T::*a_func)(const ShinyZone*)) { (a_this->*a_func)(a_zone); if (a_zone->next) ShinyZone_enumerateZones(a_zone->next, a_this, a_func); } #endif /* __cplusplus */ #endif /* SHINY_ZONE_H */ Slic3r-version_1.31.6/xs/src/admesh/000077500000000000000000000000001301441720000171605ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/admesh/connect.c000066400000000000000000000767201301441720000207710ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #include #include #include #include #include "stl.h" static void stl_match_neighbors_exact(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b); static void stl_match_neighbors_nearby(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b); static void stl_record_neighbors(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b); static void stl_initialize_facet_check_exact(stl_file *stl); static void stl_initialize_facet_check_nearby(stl_file *stl); static void stl_load_edge_exact(stl_file *stl, stl_hash_edge *edge, stl_vertex *a, stl_vertex *b); static int stl_load_edge_nearby(stl_file *stl, stl_hash_edge *edge, stl_vertex *a, stl_vertex *b, float tolerance); static void insert_hash_edge(stl_file *stl, stl_hash_edge edge, void (*match_neighbors)(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b)); static int stl_get_hash_for_edge(int M, stl_hash_edge *edge); static int stl_compare_function(stl_hash_edge *edge_a, stl_hash_edge *edge_b); static void stl_free_edges(stl_file *stl); static void stl_remove_facet(stl_file *stl, int facet_number); static void stl_change_vertices(stl_file *stl, int facet_num, int vnot, stl_vertex new_vertex); static void stl_which_vertices_to_change(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b, int *facet1, int *vertex1, int *facet2, int *vertex2, stl_vertex *new_vertex1, stl_vertex *new_vertex2); static void stl_remove_degenerate(stl_file *stl, int facet); extern int stl_check_normal_vector(stl_file *stl, int facet_num, int normal_fix_flag); static void stl_update_connects_remove_1(stl_file *stl, int facet_num); void stl_check_facets_exact(stl_file *stl) { /* This function builds the neighbors list. No modifications are made * to any of the facets. The edges are said to match only if all six * floats of the first edge matches all six floats of the second edge. */ stl_hash_edge edge; stl_facet facet; int i; int j; if (stl->error) return; stl->stats.connected_edges = 0; stl->stats.connected_facets_1_edge = 0; stl->stats.connected_facets_2_edge = 0; stl->stats.connected_facets_3_edge = 0; stl_initialize_facet_check_exact(stl); for(i = 0; i < stl->stats.number_of_facets; i++) { facet = stl->facet_start[i]; /* If any two of the three vertices are found to be exactally the same, call them degenerate and remove the facet. */ if( !memcmp(&facet.vertex[0], &facet.vertex[1], sizeof(stl_vertex)) || !memcmp(&facet.vertex[1], &facet.vertex[2], sizeof(stl_vertex)) || !memcmp(&facet.vertex[0], &facet.vertex[2], sizeof(stl_vertex))) { stl->stats.degenerate_facets += 1; stl_remove_facet(stl, i); i--; continue; } for(j = 0; j < 3; j++) { edge.facet_number = i; edge.which_edge = j; stl_load_edge_exact(stl, &edge, &facet.vertex[j], &facet.vertex[(j + 1) % 3]); insert_hash_edge(stl, edge, stl_match_neighbors_exact); } } stl_free_edges(stl); #if 0 printf("Number of faces: %d, number of manifold edges: %d, number of connected edges: %d, number of unconnected edges: %d\r\n", stl->stats.number_of_facets, stl->stats.number_of_facets * 3, stl->stats.connected_edges, stl->stats.number_of_facets * 3 - stl->stats.connected_edges); #endif } static void stl_load_edge_exact(stl_file *stl, stl_hash_edge *edge, stl_vertex *a, stl_vertex *b) { if (stl->error) return; { float diff_x = ABS(a->x - b->x); float diff_y = ABS(a->y - b->y); float diff_z = ABS(a->z - b->z); float max_diff = STL_MAX(diff_x, diff_y); max_diff = STL_MAX(diff_z, max_diff); stl->stats.shortest_edge = STL_MIN(max_diff, stl->stats.shortest_edge); } // Ensure identical vertex ordering of equal edges. // This method is numerically robust. if ((a->x != b->x) ? (a->x < b->x) : ((a->y != b->y) ? (a->y < b->y) : (a->z < b->z))) { memcpy(&edge->key[0], a, sizeof(stl_vertex)); memcpy(&edge->key[3], b, sizeof(stl_vertex)); } else { memcpy(&edge->key[0], b, sizeof(stl_vertex)); memcpy(&edge->key[3], a, sizeof(stl_vertex)); edge->which_edge += 3; /* this edge is loaded backwards */ } } static void stl_initialize_facet_check_exact(stl_file *stl) { int i; if (stl->error) return; stl->stats.malloced = 0; stl->stats.freed = 0; stl->stats.collisions = 0; stl->M = 81397; for(i = 0; i < stl->stats.number_of_facets ; i++) { /* initialize neighbors list to -1 to mark unconnected edges */ stl->neighbors_start[i].neighbor[0] = -1; stl->neighbors_start[i].neighbor[1] = -1; stl->neighbors_start[i].neighbor[2] = -1; } stl->heads = (stl_hash_edge**)calloc(stl->M, sizeof(*stl->heads)); if(stl->heads == NULL) perror("stl_initialize_facet_check_exact"); stl->tail = (stl_hash_edge*)malloc(sizeof(stl_hash_edge)); if(stl->tail == NULL) perror("stl_initialize_facet_check_exact"); stl->tail->next = stl->tail; for(i = 0; i < stl->M; i++) { stl->heads[i] = stl->tail; } } static void insert_hash_edge(stl_file *stl, stl_hash_edge edge, void (*match_neighbors)(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b)) { stl_hash_edge *link; stl_hash_edge *new_edge; stl_hash_edge *temp; int chain_number; if (stl->error) return; chain_number = stl_get_hash_for_edge(stl->M, &edge); link = stl->heads[chain_number]; if(link == stl->tail) { /* This list doesn't have any edges currently in it. Add this one. */ new_edge = (stl_hash_edge*)malloc(sizeof(stl_hash_edge)); if(new_edge == NULL) perror("insert_hash_edge"); stl->stats.malloced++; *new_edge = edge; new_edge->next = stl->tail; stl->heads[chain_number] = new_edge; return; } else if(!stl_compare_function(&edge, link)) { /* This is a match. Record result in neighbors list. */ match_neighbors(stl, &edge, link); /* Delete the matched edge from the list. */ stl->heads[chain_number] = link->next; free(link); stl->stats.freed++; return; } else { /* Continue through the rest of the list */ for(;;) { if(link->next == stl->tail) { /* This is the last item in the list. Insert a new edge. */ new_edge = (stl_hash_edge*)malloc(sizeof(stl_hash_edge)); if(new_edge == NULL) perror("insert_hash_edge"); stl->stats.malloced++; *new_edge = edge; new_edge->next = stl->tail; link->next = new_edge; stl->stats.collisions++; return; } else if(!stl_compare_function(&edge, link->next)) { /* This is a match. Record result in neighbors list. */ match_neighbors(stl, &edge, link->next); /* Delete the matched edge from the list. */ temp = link->next; link->next = link->next->next; free(temp); stl->stats.freed++; return; } else { /* This is not a match. Go to the next link */ link = link->next; stl->stats.collisions++; } } } } static int stl_get_hash_for_edge(int M, stl_hash_edge *edge) { return ((edge->key[0] / 23 + edge->key[1] / 19 + edge->key[2] / 17 + edge->key[3] /13 + edge->key[4] / 11 + edge->key[5] / 7 ) % M); } static int stl_compare_function(stl_hash_edge *edge_a, stl_hash_edge *edge_b) { if(edge_a->facet_number == edge_b->facet_number) { return 1; /* Don't match edges of the same facet */ } else { return memcmp(edge_a, edge_b, SIZEOF_EDGE_SORT); } } void stl_check_facets_nearby(stl_file *stl, float tolerance) { stl_hash_edge edge[3]; stl_facet facet; int i; int j; if (stl->error) return; if( (stl->stats.connected_facets_1_edge == stl->stats.number_of_facets) && (stl->stats.connected_facets_2_edge == stl->stats.number_of_facets) && (stl->stats.connected_facets_3_edge == stl->stats.number_of_facets)) { /* No need to check any further. All facets are connected */ return; } stl_initialize_facet_check_nearby(stl); for(i = 0; i < stl->stats.number_of_facets; i++) { facet = stl->facet_start[i]; for(j = 0; j < 3; j++) { if(stl->neighbors_start[i].neighbor[j] == -1) { edge[j].facet_number = i; edge[j].which_edge = j; if(stl_load_edge_nearby(stl, &edge[j], &facet.vertex[j], &facet.vertex[(j + 1) % 3], tolerance)) { /* only insert edges that have different keys */ insert_hash_edge(stl, edge[j], stl_match_neighbors_nearby); } } } } stl_free_edges(stl); } static int stl_load_edge_nearby(stl_file *stl, stl_hash_edge *edge, stl_vertex *a, stl_vertex *b, float tolerance) { // Index of a grid cell spaced by tolerance. uint32_t vertex1[3] = { (uint32_t)((a->x - stl->stats.min.x) / tolerance), (uint32_t)((a->y - stl->stats.min.y) / tolerance), (uint32_t)((a->z - stl->stats.min.z) / tolerance) }; uint32_t vertex2[3] = { (uint32_t)((b->x - stl->stats.min.x) / tolerance), (uint32_t)((b->y - stl->stats.min.y) / tolerance), (uint32_t)((b->z - stl->stats.min.z) / tolerance) }; if( (vertex1[0] == vertex2[0]) && (vertex1[1] == vertex2[1]) && (vertex1[2] == vertex2[2])) { /* Both vertices hash to the same value */ return 0; } // Ensure identical vertex ordering of edges, which vertices land into equal grid cells. // This method is numerically robust. if ((vertex1[0] != vertex2[0]) ? (vertex1[0] < vertex2[0]) : ((vertex1[1] != vertex2[1]) ? (vertex1[1] < vertex2[1]) : (vertex1[2] < vertex2[2]))) { memcpy(&edge->key[0], vertex1, sizeof(stl_vertex)); memcpy(&edge->key[3], vertex2, sizeof(stl_vertex)); } else { memcpy(&edge->key[0], vertex2, sizeof(stl_vertex)); memcpy(&edge->key[3], vertex1, sizeof(stl_vertex)); edge->which_edge += 3; /* this edge is loaded backwards */ } return 1; } static void stl_free_edges(stl_file *stl) { int i; stl_hash_edge *temp; if (stl->error) return; if(stl->stats.malloced != stl->stats.freed) { for(i = 0; i < stl->M; i++) { for(temp = stl->heads[i]; stl->heads[i] != stl->tail; temp = stl->heads[i]) { stl->heads[i] = stl->heads[i]->next; free(temp); stl->stats.freed++; } } } free(stl->heads); free(stl->tail); } static void stl_initialize_facet_check_nearby(stl_file *stl) { int i; if (stl->error) return; stl->stats.malloced = 0; stl->stats.freed = 0; stl->stats.collisions = 0; /* tolerance = STL_MAX(stl->stats.shortest_edge, tolerance);*/ /* tolerance = STL_MAX((stl->stats.bounding_diameter / 500000.0), tolerance);*/ /* tolerance *= 0.5;*/ stl->M = 81397; stl->heads = (stl_hash_edge**)calloc(stl->M, sizeof(*stl->heads)); if(stl->heads == NULL) perror("stl_initialize_facet_check_nearby"); stl->tail = (stl_hash_edge*)malloc(sizeof(stl_hash_edge)); if(stl->tail == NULL) perror("stl_initialize_facet_check_nearby"); stl->tail->next = stl->tail; for(i = 0; i < stl->M; i++) { stl->heads[i] = stl->tail; } } static void stl_record_neighbors(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b) { int i; int j; if (stl->error) return; /* Facet a's neighbor is facet b */ stl->neighbors_start[edge_a->facet_number].neighbor[edge_a->which_edge % 3] = edge_b->facet_number; /* sets the .neighbor part */ stl->neighbors_start[edge_a->facet_number]. which_vertex_not[edge_a->which_edge % 3] = (edge_b->which_edge + 2) % 3; /* sets the .which_vertex_not part */ /* Facet b's neighbor is facet a */ stl->neighbors_start[edge_b->facet_number].neighbor[edge_b->which_edge % 3] = edge_a->facet_number; /* sets the .neighbor part */ stl->neighbors_start[edge_b->facet_number]. which_vertex_not[edge_b->which_edge % 3] = (edge_a->which_edge + 2) % 3; /* sets the .which_vertex_not part */ if( ((edge_a->which_edge < 3) && (edge_b->which_edge < 3)) || ((edge_a->which_edge > 2) && (edge_b->which_edge > 2))) { /* these facets are oriented in opposite directions. */ /* their normals are probably messed up. */ stl->neighbors_start[edge_a->facet_number]. which_vertex_not[edge_a->which_edge % 3] += 3; stl->neighbors_start[edge_b->facet_number]. which_vertex_not[edge_b->which_edge % 3] += 3; } /* Count successful connects */ /* Total connects */ stl->stats.connected_edges += 2; /* Count individual connects */ i = ((stl->neighbors_start[edge_a->facet_number].neighbor[0] == -1) + (stl->neighbors_start[edge_a->facet_number].neighbor[1] == -1) + (stl->neighbors_start[edge_a->facet_number].neighbor[2] == -1)); j = ((stl->neighbors_start[edge_b->facet_number].neighbor[0] == -1) + (stl->neighbors_start[edge_b->facet_number].neighbor[1] == -1) + (stl->neighbors_start[edge_b->facet_number].neighbor[2] == -1)); if(i == 2) { stl->stats.connected_facets_1_edge +=1; } else if(i == 1) { stl->stats.connected_facets_2_edge +=1; } else { stl->stats.connected_facets_3_edge +=1; } if(j == 2) { stl->stats.connected_facets_1_edge +=1; } else if(j == 1) { stl->stats.connected_facets_2_edge +=1; } else { stl->stats.connected_facets_3_edge +=1; } } static void stl_match_neighbors_exact(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b) { if (stl->error) return; stl_record_neighbors(stl, edge_a, edge_b); } static void stl_match_neighbors_nearby(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b) { int facet1; int facet2; int vertex1; int vertex2; int vnot1; int vnot2; stl_vertex new_vertex1; stl_vertex new_vertex2; if (stl->error) return; stl_record_neighbors(stl, edge_a, edge_b); stl_which_vertices_to_change(stl, edge_a, edge_b, &facet1, &vertex1, &facet2, &vertex2, &new_vertex1, &new_vertex2); if(facet1 != -1) { if(facet1 == edge_a->facet_number) { vnot1 = (edge_a->which_edge + 2) % 3; } else { vnot1 = (edge_b->which_edge + 2) % 3; } if(((vnot1 + 2) % 3) == vertex1) { vnot1 += 3; } stl_change_vertices(stl, facet1, vnot1, new_vertex1); } if(facet2 != -1) { if(facet2 == edge_a->facet_number) { vnot2 = (edge_a->which_edge + 2) % 3; } else { vnot2 = (edge_b->which_edge + 2) % 3; } if(((vnot2 + 2) % 3) == vertex2) { vnot2 += 3; } stl_change_vertices(stl, facet2, vnot2, new_vertex2); } stl->stats.edges_fixed += 2; } static void stl_change_vertices(stl_file *stl, int facet_num, int vnot, stl_vertex new_vertex) { int first_facet; int direction; int next_edge; int pivot_vertex; if (stl->error) return; first_facet = facet_num; direction = 0; for(;;) { if(vnot > 2) { if(direction == 0) { pivot_vertex = (vnot + 2) % 3; next_edge = pivot_vertex; direction = 1; } else { pivot_vertex = (vnot + 1) % 3; next_edge = vnot % 3; direction = 0; } } else { if(direction == 0) { pivot_vertex = (vnot + 1) % 3; next_edge = vnot; } else { pivot_vertex = (vnot + 2) % 3; next_edge = pivot_vertex; } } #if 0 if (stl->facet_start[facet_num].vertex[pivot_vertex].x == new_vertex.x && stl->facet_start[facet_num].vertex[pivot_vertex].y == new_vertex.y && stl->facet_start[facet_num].vertex[pivot_vertex].z == new_vertex.z) printf("Changing vertex %f,%f,%f: Same !!!\r\n", new_vertex.x, new_vertex.y, new_vertex.z); else { if (stl->facet_start[facet_num].vertex[pivot_vertex].x != new_vertex.x) printf("Changing coordinate x, vertex %e (0x%08x) to %e(0x%08x)\r\n", stl->facet_start[facet_num].vertex[pivot_vertex].x, *reinterpret_cast(&stl->facet_start[facet_num].vertex[pivot_vertex].x), new_vertex.x, *reinterpret_cast(&new_vertex.x)); if (stl->facet_start[facet_num].vertex[pivot_vertex].y != new_vertex.y) printf("Changing coordinate x, vertex %e (0x%08x) to %e(0x%08x)\r\n", stl->facet_start[facet_num].vertex[pivot_vertex].y, *reinterpret_cast(&stl->facet_start[facet_num].vertex[pivot_vertex].y), new_vertex.y, *reinterpret_cast(&new_vertex.y)); if (stl->facet_start[facet_num].vertex[pivot_vertex].z != new_vertex.z) printf("Changing coordinate x, vertex %e (0x%08x) to %e(0x%08x)\r\n", stl->facet_start[facet_num].vertex[pivot_vertex].z, *reinterpret_cast(&stl->facet_start[facet_num].vertex[pivot_vertex].z), new_vertex.z, *reinterpret_cast(&new_vertex.z)); } #endif stl->facet_start[facet_num].vertex[pivot_vertex] = new_vertex; vnot = stl->neighbors_start[facet_num].which_vertex_not[next_edge]; facet_num = stl->neighbors_start[facet_num].neighbor[next_edge]; if(facet_num == -1) { break; } if(facet_num == first_facet) { /* back to the beginning */ printf("\ Back to the first facet changing vertices: probably a mobius part.\n\ Try using a smaller tolerance or don't do a nearby check\n"); return; } } } static void stl_which_vertices_to_change(stl_file *stl, stl_hash_edge *edge_a, stl_hash_edge *edge_b, int *facet1, int *vertex1, int *facet2, int *vertex2, stl_vertex *new_vertex1, stl_vertex *new_vertex2) { int v1a; /* pair 1, facet a */ int v1b; /* pair 1, facet b */ int v2a; /* pair 2, facet a */ int v2b; /* pair 2, facet b */ /* Find first pair */ if(edge_a->which_edge < 3) { v1a = edge_a->which_edge; v2a = (edge_a->which_edge + 1) % 3; } else { v2a = edge_a->which_edge % 3; v1a = (edge_a->which_edge + 1) % 3; } if(edge_b->which_edge < 3) { v1b = edge_b->which_edge; v2b = (edge_b->which_edge + 1) % 3; } else { v2b = edge_b->which_edge % 3; v1b = (edge_b->which_edge + 1) % 3; } /* Of the first pair, which vertex, if any, should be changed */ if(!memcmp(&stl->facet_start[edge_a->facet_number].vertex[v1a], &stl->facet_start[edge_b->facet_number].vertex[v1b], sizeof(stl_vertex))) { /* These facets are already equal. No need to change. */ *facet1 = -1; } else { if( (stl->neighbors_start[edge_a->facet_number].neighbor[v1a] == -1) && (stl->neighbors_start[edge_a->facet_number]. neighbor[(v1a + 2) % 3] == -1)) { /* This vertex has no neighbors. This is a good one to change */ *facet1 = edge_a->facet_number; *vertex1 = v1a; *new_vertex1 = stl->facet_start[edge_b->facet_number].vertex[v1b]; } else { *facet1 = edge_b->facet_number; *vertex1 = v1b; *new_vertex1 = stl->facet_start[edge_a->facet_number].vertex[v1a]; } } /* Of the second pair, which vertex, if any, should be changed */ if(!memcmp(&stl->facet_start[edge_a->facet_number].vertex[v2a], &stl->facet_start[edge_b->facet_number].vertex[v2b], sizeof(stl_vertex))) { /* These facets are already equal. No need to change. */ *facet2 = -1; } else { if( (stl->neighbors_start[edge_a->facet_number].neighbor[v2a] == -1) && (stl->neighbors_start[edge_a->facet_number]. neighbor[(v2a + 2) % 3] == -1)) { /* This vertex has no neighbors. This is a good one to change */ *facet2 = edge_a->facet_number; *vertex2 = v2a; *new_vertex2 = stl->facet_start[edge_b->facet_number].vertex[v2b]; } else { *facet2 = edge_b->facet_number; *vertex2 = v2b; *new_vertex2 = stl->facet_start[edge_a->facet_number].vertex[v2a]; } } } static void stl_remove_facet(stl_file *stl, int facet_number) { int neighbor[3]; int vnot[3]; int i; int j; if (stl->error) return; stl->stats.facets_removed += 1; /* Update list of connected edges */ j = ((stl->neighbors_start[facet_number].neighbor[0] == -1) + (stl->neighbors_start[facet_number].neighbor[1] == -1) + (stl->neighbors_start[facet_number].neighbor[2] == -1)); if(j == 2) { stl->stats.connected_facets_1_edge -= 1; } else if(j == 1) { stl->stats.connected_facets_2_edge -= 1; stl->stats.connected_facets_1_edge -= 1; } else if(j == 0) { stl->stats.connected_facets_3_edge -= 1; stl->stats.connected_facets_2_edge -= 1; stl->stats.connected_facets_1_edge -= 1; } stl->facet_start[facet_number] = stl->facet_start[stl->stats.number_of_facets - 1]; /* I could reallocate at this point, but it is not really necessary. */ stl->neighbors_start[facet_number] = stl->neighbors_start[stl->stats.number_of_facets - 1]; stl->stats.number_of_facets -= 1; for(i = 0; i < 3; i++) { neighbor[i] = stl->neighbors_start[facet_number].neighbor[i]; vnot[i] = stl->neighbors_start[facet_number].which_vertex_not[i]; } for(i = 0; i < 3; i++) { if(neighbor[i] != -1) { if(stl->neighbors_start[neighbor[i]].neighbor[(vnot[i] + 1)% 3] != stl->stats.number_of_facets) { printf("\ in stl_remove_facet: neighbor = %d numfacets = %d this is wrong\n", stl->neighbors_start[neighbor[i]].neighbor[(vnot[i] + 1)% 3], stl->stats.number_of_facets); return; } stl->neighbors_start[neighbor[i]].neighbor[(vnot[i] + 1)% 3] = facet_number; } } } void stl_remove_unconnected_facets(stl_file *stl) { /* A couple of things need to be done here. One is to remove any */ /* completely unconnected facets (0 edges connected) since these are */ /* useless and could be completely wrong. The second thing that needs to */ /* be done is to remove any degenerate facets that were created during */ /* stl_check_facets_nearby(). */ int i; if (stl->error) return; /* remove degenerate facets */ for(i = 0; i < stl->stats.number_of_facets; i++) { if( !memcmp(&stl->facet_start[i].vertex[0], &stl->facet_start[i].vertex[1], sizeof(stl_vertex)) || !memcmp(&stl->facet_start[i].vertex[1], &stl->facet_start[i].vertex[2], sizeof(stl_vertex)) || !memcmp(&stl->facet_start[i].vertex[0], &stl->facet_start[i].vertex[2], sizeof(stl_vertex))) { stl_remove_degenerate(stl, i); i--; } } if(stl->stats.connected_facets_1_edge < stl->stats.number_of_facets) { /* remove completely unconnected facets */ for(i = 0; i < stl->stats.number_of_facets; i++) { if( (stl->neighbors_start[i].neighbor[0] == -1) && (stl->neighbors_start[i].neighbor[1] == -1) && (stl->neighbors_start[i].neighbor[2] == -1)) { /* This facet is completely unconnected. Remove it. */ stl_remove_facet(stl, i); i--; } } } } static void stl_remove_degenerate(stl_file *stl, int facet) { int edge1; int edge2; int edge3; int neighbor1; int neighbor2; int neighbor3; int vnot1; int vnot2; int vnot3; if (stl->error) return; if( !memcmp(&stl->facet_start[facet].vertex[0], &stl->facet_start[facet].vertex[1], sizeof(stl_vertex)) && !memcmp(&stl->facet_start[facet].vertex[1], &stl->facet_start[facet].vertex[2], sizeof(stl_vertex))) { /* all 3 vertices are equal. Just remove the facet. I don't think*/ /* this is really possible, but just in case... */ printf("removing a facet in stl_remove_degenerate\n"); stl_remove_facet(stl, facet); return; } if(!memcmp(&stl->facet_start[facet].vertex[0], &stl->facet_start[facet].vertex[1], sizeof(stl_vertex))) { edge1 = 1; edge2 = 2; edge3 = 0; } else if(!memcmp(&stl->facet_start[facet].vertex[1], &stl->facet_start[facet].vertex[2], sizeof(stl_vertex))) { edge1 = 0; edge2 = 2; edge3 = 1; } else if(!memcmp(&stl->facet_start[facet].vertex[2], &stl->facet_start[facet].vertex[0], sizeof(stl_vertex))) { edge1 = 0; edge2 = 1; edge3 = 2; } else { /* No degenerate. Function shouldn't have been called. */ return; } neighbor1 = stl->neighbors_start[facet].neighbor[edge1]; neighbor2 = stl->neighbors_start[facet].neighbor[edge2]; if(neighbor1 == -1) { stl_update_connects_remove_1(stl, neighbor2); } if(neighbor2 == -1) { stl_update_connects_remove_1(stl, neighbor1); } neighbor3 = stl->neighbors_start[facet].neighbor[edge3]; vnot1 = stl->neighbors_start[facet].which_vertex_not[edge1]; vnot2 = stl->neighbors_start[facet].which_vertex_not[edge2]; vnot3 = stl->neighbors_start[facet].which_vertex_not[edge3]; if(neighbor1 >= 0){ stl->neighbors_start[neighbor1].neighbor[(vnot1 + 1) % 3] = neighbor2; stl->neighbors_start[neighbor1].which_vertex_not[(vnot1 + 1) % 3] = vnot2; } if(neighbor2 >= 0){ stl->neighbors_start[neighbor2].neighbor[(vnot2 + 1) % 3] = neighbor1; stl->neighbors_start[neighbor2].which_vertex_not[(vnot2 + 1) % 3] = vnot1; } stl_remove_facet(stl, facet); if(neighbor3 >= 0) { stl_update_connects_remove_1(stl, neighbor3); stl->neighbors_start[neighbor3].neighbor[(vnot3 + 1) % 3] = -1; } } void stl_update_connects_remove_1(stl_file *stl, int facet_num) { int j; if (stl->error) return; /* Update list of connected edges */ j = ((stl->neighbors_start[facet_num].neighbor[0] == -1) + (stl->neighbors_start[facet_num].neighbor[1] == -1) + (stl->neighbors_start[facet_num].neighbor[2] == -1)); if(j == 0) { /* Facet has 3 neighbors */ stl->stats.connected_facets_3_edge -= 1; } else if(j == 1) { /* Facet has 2 neighbors */ stl->stats.connected_facets_2_edge -= 1; } else if(j == 2) { /* Facet has 1 neighbor */ stl->stats.connected_facets_1_edge -= 1; } } void stl_fill_holes(stl_file *stl) { stl_facet facet; stl_facet new_facet; int neighbors_initial[3]; stl_hash_edge edge; int first_facet; int direction; int facet_num; int vnot; int next_edge; int pivot_vertex; int next_facet; int i; int j; int k; if (stl->error) return; /* Insert all unconnected edges into hash list */ stl_initialize_facet_check_nearby(stl); for(i = 0; i < stl->stats.number_of_facets; i++) { facet = stl->facet_start[i]; for(j = 0; j < 3; j++) { if(stl->neighbors_start[i].neighbor[j] != -1) continue; edge.facet_number = i; edge.which_edge = j; stl_load_edge_exact(stl, &edge, &facet.vertex[j], &facet.vertex[(j + 1) % 3]); insert_hash_edge(stl, edge, stl_match_neighbors_exact); } } for(i = 0; i < stl->stats.number_of_facets; i++) { facet = stl->facet_start[i]; neighbors_initial[0] = stl->neighbors_start[i].neighbor[0]; neighbors_initial[1] = stl->neighbors_start[i].neighbor[1]; neighbors_initial[2] = stl->neighbors_start[i].neighbor[2]; first_facet = i; for(j = 0; j < 3; j++) { if(stl->neighbors_start[i].neighbor[j] != -1) continue; new_facet.vertex[0] = facet.vertex[j]; new_facet.vertex[1] = facet.vertex[(j + 1) % 3]; if(neighbors_initial[(j + 2) % 3] == -1) { direction = 1; } else { direction = 0; } facet_num = i; vnot = (j + 2) % 3; for(;;) { if(vnot > 2) { if(direction == 0) { pivot_vertex = (vnot + 2) % 3; next_edge = pivot_vertex; direction = 1; } else { pivot_vertex = (vnot + 1) % 3; next_edge = vnot % 3; direction = 0; } } else { if(direction == 0) { pivot_vertex = (vnot + 1) % 3; next_edge = vnot; } else { pivot_vertex = (vnot + 2) % 3; next_edge = pivot_vertex; } } next_facet = stl->neighbors_start[facet_num].neighbor[next_edge]; if(next_facet == -1) { new_facet.vertex[2] = stl->facet_start[facet_num]. vertex[vnot % 3]; stl_add_facet(stl, &new_facet); for(k = 0; k < 3; k++) { edge.facet_number = stl->stats.number_of_facets - 1; edge.which_edge = k; stl_load_edge_exact(stl, &edge, &new_facet.vertex[k], &new_facet.vertex[(k + 1) % 3]); insert_hash_edge(stl, edge, stl_match_neighbors_exact); } break; } else { vnot = stl->neighbors_start[facet_num]. which_vertex_not[next_edge]; facet_num = next_facet; } if(facet_num == first_facet) { /* back to the beginning */ printf("\ Back to the first facet filling holes: probably a mobius part.\n\ Try using a smaller tolerance or don't do a nearby check\n"); return; } } } } } void stl_add_facet(stl_file *stl, stl_facet *new_facet) { if (stl->error) return; stl->stats.facets_added += 1; if(stl->stats.facets_malloced < stl->stats.number_of_facets + 1) { stl->facet_start = (stl_facet*)realloc(stl->facet_start, (sizeof(stl_facet) * (stl->stats.facets_malloced + 256))); if(stl->facet_start == NULL) perror("stl_add_facet"); stl->neighbors_start = (stl_neighbors*)realloc(stl->neighbors_start, (sizeof(stl_neighbors) * (stl->stats.facets_malloced + 256))); if(stl->neighbors_start == NULL) perror("stl_add_facet"); stl->stats.facets_malloced += 256; } stl->facet_start[stl->stats.number_of_facets] = *new_facet; /* note that the normal vector is not set here, just initialized to 0 */ stl->facet_start[stl->stats.number_of_facets].normal.x = 0.0; stl->facet_start[stl->stats.number_of_facets].normal.y = 0.0; stl->facet_start[stl->stats.number_of_facets].normal.z = 0.0; stl->neighbors_start[stl->stats.number_of_facets].neighbor[0] = -1; stl->neighbors_start[stl->stats.number_of_facets].neighbor[1] = -1; stl->neighbors_start[stl->stats.number_of_facets].neighbor[2] = -1; stl->stats.number_of_facets += 1; } Slic3r-version_1.31.6/xs/src/admesh/normals.c000066400000000000000000000253241301441720000210050ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #include #include #include #include #include "stl.h" static void stl_reverse_facet(stl_file *stl, int facet_num); static void stl_reverse_vector(float v[]); int stl_check_normal_vector(stl_file *stl, int facet_num, int normal_fix_flag); static void stl_reverse_facet(stl_file *stl, int facet_num) { stl_vertex tmp_vertex; /* int tmp_neighbor;*/ int neighbor[3]; int vnot[3]; stl->stats.facets_reversed += 1; neighbor[0] = stl->neighbors_start[facet_num].neighbor[0]; neighbor[1] = stl->neighbors_start[facet_num].neighbor[1]; neighbor[2] = stl->neighbors_start[facet_num].neighbor[2]; vnot[0] = stl->neighbors_start[facet_num].which_vertex_not[0]; vnot[1] = stl->neighbors_start[facet_num].which_vertex_not[1]; vnot[2] = stl->neighbors_start[facet_num].which_vertex_not[2]; /* reverse the facet */ tmp_vertex = stl->facet_start[facet_num].vertex[0]; stl->facet_start[facet_num].vertex[0] = stl->facet_start[facet_num].vertex[1]; stl->facet_start[facet_num].vertex[1] = tmp_vertex; /* fix the vnots of the neighboring facets */ if(neighbor[0] != -1) stl->neighbors_start[neighbor[0]].which_vertex_not[(vnot[0] + 1) % 3] = (stl->neighbors_start[neighbor[0]]. which_vertex_not[(vnot[0] + 1) % 3] + 3) % 6; if(neighbor[1] != -1) stl->neighbors_start[neighbor[1]].which_vertex_not[(vnot[1] + 1) % 3] = (stl->neighbors_start[neighbor[1]]. which_vertex_not[(vnot[1] + 1) % 3] + 4) % 6; if(neighbor[2] != -1) stl->neighbors_start[neighbor[2]].which_vertex_not[(vnot[2] + 1) % 3] = (stl->neighbors_start[neighbor[2]]. which_vertex_not[(vnot[2] + 1) % 3] + 2) % 6; /* swap the neighbors of the facet that is being reversed */ stl->neighbors_start[facet_num].neighbor[1] = neighbor[2]; stl->neighbors_start[facet_num].neighbor[2] = neighbor[1]; /* swap the vnots of the facet that is being reversed */ stl->neighbors_start[facet_num].which_vertex_not[1] = vnot[2]; stl->neighbors_start[facet_num].which_vertex_not[2] = vnot[1]; /* reverse the values of the vnots of the facet that is being reversed */ stl->neighbors_start[facet_num].which_vertex_not[0] = (stl->neighbors_start[facet_num].which_vertex_not[0] + 3) % 6; stl->neighbors_start[facet_num].which_vertex_not[1] = (stl->neighbors_start[facet_num].which_vertex_not[1] + 3) % 6; stl->neighbors_start[facet_num].which_vertex_not[2] = (stl->neighbors_start[facet_num].which_vertex_not[2] + 3) % 6; } void stl_fix_normal_directions(stl_file *stl) { char *norm_sw; /* int edge_num;*/ /* int vnot;*/ int checked = 0; int facet_num; /* int next_facet;*/ int i; int j; struct stl_normal { int facet_num; struct stl_normal *next; }; struct stl_normal *head; struct stl_normal *tail; struct stl_normal *newn; struct stl_normal *temp; if (stl->error) return; /* Initialize linked list. */ head = (struct stl_normal*)malloc(sizeof(struct stl_normal)); if(head == NULL) perror("stl_fix_normal_directions"); tail = (struct stl_normal*)malloc(sizeof(struct stl_normal)); if(tail == NULL) perror("stl_fix_normal_directions"); head->next = tail; tail->next = tail; /* Initialize list that keeps track of already fixed facets. */ norm_sw = (char*)calloc(stl->stats.number_of_facets, sizeof(char)); if(norm_sw == NULL) perror("stl_fix_normal_directions"); facet_num = 0; /* If normal vector is not within tolerance and backwards: Arbitrarily starts at face 0. If this one is wrong, we're screwed. Thankfully, the chances of it being wrong randomly are low if most of the triangles are right: */ if(stl_check_normal_vector(stl, 0, 0) == 2) stl_reverse_facet(stl, 0); /* Say that we've fixed this facet: */ norm_sw[facet_num] = 1; checked++; for(;;) { /* Add neighbors_to_list. Add unconnected neighbors to the list:a */ for(j = 0; j < 3; j++) { /* Reverse the neighboring facets if necessary. */ if(stl->neighbors_start[facet_num].which_vertex_not[j] > 2) { /* If the facet has a neighbor that is -1, it means that edge isn't shared by another facet */ if(stl->neighbors_start[facet_num].neighbor[j] != -1) { stl_reverse_facet (stl, stl->neighbors_start[facet_num].neighbor[j]); } } /* If this edge of the facet is connected: */ if(stl->neighbors_start[facet_num].neighbor[j] != -1) { /* If we haven't fixed this facet yet, add it to the list: */ if(norm_sw[stl->neighbors_start[facet_num].neighbor[j]] != 1) { /* Add node to beginning of list. */ newn = (struct stl_normal*)malloc(sizeof(struct stl_normal)); if(newn == NULL) perror("stl_fix_normal_directions"); newn->facet_num = stl->neighbors_start[facet_num].neighbor[j]; newn->next = head->next; head->next = newn; } } } /* Get next facet to fix from top of list. */ if(head->next != tail) { facet_num = head->next->facet_num; if(norm_sw[facet_num] != 1) { /* If facet is in list mutiple times */ norm_sw[facet_num] = 1; /* Record this one as being fixed. */ checked++; } temp = head->next; /* Delete this facet from the list. */ head->next = head->next->next; free(temp); } else { /* if we ran out of facets to fix: */ /* All of the facets in this part have been fixed. */ stl->stats.number_of_parts += 1; if(checked >= stl->stats.number_of_facets) { /* All of the facets have been checked. Bail out. */ break; } else { /* There is another part here. Find it and continue. */ for(i = 0; i < stl->stats.number_of_facets; i++) { if(norm_sw[i] == 0) { /* This is the first facet of the next part. */ facet_num = i; if(stl_check_normal_vector(stl, i, 0) == 2) { stl_reverse_facet(stl, i); } norm_sw[facet_num] = 1; checked++; break; } } } } } free(head); free(tail); free(norm_sw); } int stl_check_normal_vector(stl_file *stl, int facet_num, int normal_fix_flag) { /* Returns 0 if the normal is within tolerance */ /* Returns 1 if the normal is not within tolerance, but direction is OK */ /* Returns 2 if the normal is not within tolerance and backwards */ /* Returns 4 if the status is unknown. */ float normal[3]; float test_norm[3]; stl_facet *facet; facet = &stl->facet_start[facet_num]; stl_calculate_normal(normal, facet); stl_normalize_vector(normal); if( (ABS(normal[0] - facet->normal.x) < 0.001) && (ABS(normal[1] - facet->normal.y) < 0.001) && (ABS(normal[2] - facet->normal.z) < 0.001)) { /* It is not really necessary to change the values here */ /* but just for consistency, I will. */ facet->normal.x = normal[0]; facet->normal.y = normal[1]; facet->normal.z = normal[2]; return 0; } test_norm[0] = facet->normal.x; test_norm[1] = facet->normal.y; test_norm[2] = facet->normal.z; stl_normalize_vector(test_norm); if( (ABS(normal[0] - test_norm[0]) < 0.001) && (ABS(normal[1] - test_norm[1]) < 0.001) && (ABS(normal[2] - test_norm[2]) < 0.001)) { if(normal_fix_flag) { facet->normal.x = normal[0]; facet->normal.y = normal[1]; facet->normal.z = normal[2]; stl->stats.normals_fixed += 1; } return 1; } stl_reverse_vector(test_norm); if( (ABS(normal[0] - test_norm[0]) < 0.001) && (ABS(normal[1] - test_norm[1]) < 0.001) && (ABS(normal[2] - test_norm[2]) < 0.001)) { /* Facet is backwards. */ if(normal_fix_flag) { facet->normal.x = normal[0]; facet->normal.y = normal[1]; facet->normal.z = normal[2]; stl->stats.normals_fixed += 1; } return 2; } if(normal_fix_flag) { facet->normal.x = normal[0]; facet->normal.y = normal[1]; facet->normal.z = normal[2]; stl->stats.normals_fixed += 1; } return 4; } static void stl_reverse_vector(float v[]) { v[0] *= -1; v[1] *= -1; v[2] *= -1; } void stl_calculate_normal(float normal[], stl_facet *facet) { float v1[3]; float v2[3]; v1[0] = facet->vertex[1].x - facet->vertex[0].x; v1[1] = facet->vertex[1].y - facet->vertex[0].y; v1[2] = facet->vertex[1].z - facet->vertex[0].z; v2[0] = facet->vertex[2].x - facet->vertex[0].x; v2[1] = facet->vertex[2].y - facet->vertex[0].y; v2[2] = facet->vertex[2].z - facet->vertex[0].z; normal[0] = (float)((double)v1[1] * (double)v2[2]) - ((double)v1[2] * (double)v2[1]); normal[1] = (float)((double)v1[2] * (double)v2[0]) - ((double)v1[0] * (double)v2[2]); normal[2] = (float)((double)v1[0] * (double)v2[1]) - ((double)v1[1] * (double)v2[0]); } void stl_normalize_vector(float v[]) { double length; double factor; float min_normal_length; length = sqrt((double)v[0] * (double)v[0] + (double)v[1] * (double)v[1] + (double)v[2] * (double)v[2]); min_normal_length = 0.000000000001; if(length < min_normal_length) { v[0] = 0.0; v[1] = 0.0; v[2] = 0.0; return; } factor = 1.0 / length; v[0] *= factor; v[1] *= factor; v[2] *= factor; } void stl_fix_normal_values(stl_file *stl) { int i; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { stl_check_normal_vector(stl, i, 1); } } void stl_reverse_all_facets(stl_file *stl) { int i; float normal[3]; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { stl_reverse_facet(stl, i); stl_calculate_normal(normal, &stl->facet_start[i]); stl_normalize_vector(normal); stl->facet_start[i].normal.x = normal[0]; stl->facet_start[i].normal.y = normal[1]; stl->facet_start[i].normal.z = normal[2]; } } Slic3r-version_1.31.6/xs/src/admesh/shared.c000066400000000000000000000173531301441720000206030ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #include #include #include "stl.h" void stl_invalidate_shared_vertices(stl_file *stl) { if (stl->error) return; if (stl->v_indices != NULL) { free(stl->v_indices); stl->v_indices = NULL; } if (stl->v_shared != NULL) { free(stl->v_shared); stl->v_shared = NULL; } } void stl_generate_shared_vertices(stl_file *stl) { int i; int j; int first_facet; int direction; int facet_num; int vnot; int next_edge; int pivot_vertex; int next_facet; int reversed; if (stl->error) return; /* make sure this function is idempotent and does not leak memory */ stl_invalidate_shared_vertices(stl); stl->v_indices = (v_indices_struct*) calloc(stl->stats.number_of_facets, sizeof(v_indices_struct)); if(stl->v_indices == NULL) perror("stl_generate_shared_vertices"); stl->v_shared = (stl_vertex*) calloc((stl->stats.number_of_facets / 2), sizeof(stl_vertex)); if(stl->v_shared == NULL) perror("stl_generate_shared_vertices"); stl->stats.shared_malloced = stl->stats.number_of_facets / 2; stl->stats.shared_vertices = 0; for(i = 0; i < stl->stats.number_of_facets; i++) { stl->v_indices[i].vertex[0] = -1; stl->v_indices[i].vertex[1] = -1; stl->v_indices[i].vertex[2] = -1; } for(i = 0; i < stl->stats.number_of_facets; i++) { first_facet = i; for(j = 0; j < 3; j++) { if(stl->v_indices[i].vertex[j] != -1) { continue; } if(stl->stats.shared_vertices == stl->stats.shared_malloced) { stl->stats.shared_malloced += 1024; stl->v_shared = (stl_vertex*)realloc(stl->v_shared, stl->stats.shared_malloced * sizeof(stl_vertex)); if(stl->v_shared == NULL) perror("stl_generate_shared_vertices"); } stl->v_shared[stl->stats.shared_vertices] = stl->facet_start[i].vertex[j]; direction = 0; reversed = 0; facet_num = i; vnot = (j + 2) % 3; for(;;) { if(vnot > 2) { if(direction == 0) { pivot_vertex = (vnot + 2) % 3; next_edge = pivot_vertex; direction = 1; } else { pivot_vertex = (vnot + 1) % 3; next_edge = vnot % 3; direction = 0; } } else { if(direction == 0) { pivot_vertex = (vnot + 1) % 3; next_edge = vnot; } else { pivot_vertex = (vnot + 2) % 3; next_edge = pivot_vertex; } } stl->v_indices[facet_num].vertex[pivot_vertex] = stl->stats.shared_vertices; next_facet = stl->neighbors_start[facet_num].neighbor[next_edge]; if(next_facet == -1) { if(reversed) { break; } else { direction = 1; vnot = (j + 1) % 3; reversed = 1; facet_num = first_facet; } } else if(next_facet != first_facet) { vnot = stl->neighbors_start[facet_num]. which_vertex_not[next_edge]; facet_num = next_facet; } else { break; } } stl->stats.shared_vertices += 1; } } } void stl_write_off(stl_file *stl, char *file) { int i; FILE *fp; char *error_msg; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } fprintf(fp, "OFF\n"); fprintf(fp, "%d %d 0\n", stl->stats.shared_vertices, stl->stats.number_of_facets); for(i = 0; i < stl->stats.shared_vertices; i++) { fprintf(fp, "\t%f %f %f\n", stl->v_shared[i].x, stl->v_shared[i].y, stl->v_shared[i].z); } for(i = 0; i < stl->stats.number_of_facets; i++) { fprintf(fp, "\t3 %d %d %d\n", stl->v_indices[i].vertex[0], stl->v_indices[i].vertex[1], stl->v_indices[i].vertex[2]); } fclose(fp); } void stl_write_vrml(stl_file *stl, char *file) { int i; FILE *fp; char *error_msg; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } fprintf(fp, "#VRML V1.0 ascii\n\n"); fprintf(fp, "Separator {\n"); fprintf(fp, "\tDEF STLShape ShapeHints {\n"); fprintf(fp, "\t\tvertexOrdering COUNTERCLOCKWISE\n"); fprintf(fp, "\t\tfaceType CONVEX\n"); fprintf(fp, "\t\tshapeType SOLID\n"); fprintf(fp, "\t\tcreaseAngle 0.0\n"); fprintf(fp, "\t}\n"); fprintf(fp, "\tDEF STLModel Separator {\n"); fprintf(fp, "\t\tDEF STLColor Material {\n"); fprintf(fp, "\t\t\temissiveColor 0.700000 0.700000 0.000000\n"); fprintf(fp, "\t\t}\n"); fprintf(fp, "\t\tDEF STLVertices Coordinate3 {\n"); fprintf(fp, "\t\t\tpoint [\n"); for(i = 0; i < (stl->stats.shared_vertices - 1); i++) { fprintf(fp, "\t\t\t\t%f %f %f,\n", stl->v_shared[i].x, stl->v_shared[i].y, stl->v_shared[i].z); } fprintf(fp, "\t\t\t\t%f %f %f]\n", stl->v_shared[i].x, stl->v_shared[i].y, stl->v_shared[i].z); fprintf(fp, "\t\t}\n"); fprintf(fp, "\t\tDEF STLTriangles IndexedFaceSet {\n"); fprintf(fp, "\t\t\tcoordIndex [\n"); for(i = 0; i < (stl->stats.number_of_facets - 1); i++) { fprintf(fp, "\t\t\t\t%d, %d, %d, -1,\n", stl->v_indices[i].vertex[0], stl->v_indices[i].vertex[1], stl->v_indices[i].vertex[2]); } fprintf(fp, "\t\t\t\t%d, %d, %d, -1]\n", stl->v_indices[i].vertex[0], stl->v_indices[i].vertex[1], stl->v_indices[i].vertex[2]); fprintf(fp, "\t\t}\n"); fprintf(fp, "\t}\n"); fprintf(fp, "}\n"); fclose(fp); } void stl_write_obj (stl_file *stl, char *file) { int i; FILE* fp; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if (fp == NULL) { char* error_msg = (char*)malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } for (i = 0; i < stl->stats.shared_vertices; i++) { fprintf(fp, "v %f %f %f\n", stl->v_shared[i].x, stl->v_shared[i].y, stl->v_shared[i].z); } for (i = 0; i < stl->stats.number_of_facets; i++) { fprintf(fp, "f %d %d %d\n", stl->v_indices[i].vertex[0]+1, stl->v_indices[i].vertex[1]+1, stl->v_indices[i].vertex[2]+1); } fclose(fp); } Slic3r-version_1.31.6/xs/src/admesh/stl.h000066400000000000000000000201241301441720000201320ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #ifndef __admesh_stl__ #define __admesh_stl__ #include #include #include #include #ifndef BOOST_LITTLE_ENDIAN #error "admesh works correctly on little endian machines only!" #endif #ifdef __cplusplus extern "C" { #endif #define STL_MAX(A,B) ((A)>(B)? (A):(B)) #define STL_MIN(A,B) ((A)<(B)? (A):(B)) #define ABS(X) ((X) < 0 ? -(X) : (X)) // Size of the binary STL header, free form. #define LABEL_SIZE 80 // Binary STL, length of the "number of faces" counter. #define NUM_FACET_SIZE 4 // Binary STL, sizeof header + number of faces. #define HEADER_SIZE 84 #define STL_MIN_FILE_SIZE 284 #define ASCII_LINES_PER_FACET 7 // Comparing an edge by memcmp, 2x3x4 bytes = 24 #define SIZEOF_EDGE_SORT 24 typedef struct { float x; float y; float z; } stl_vertex; static_assert(sizeof(stl_vertex) == 12, "size of stl_vertex incorrect"); typedef struct { float x; float y; float z; } stl_normal; static_assert(sizeof(stl_normal) == 12, "size of stl_normal incorrect"); typedef char stl_extra[2]; typedef struct { stl_normal normal; stl_vertex vertex[3]; stl_extra extra; } stl_facet; #define SIZEOF_STL_FACET 50 static_assert(offsetof(stl_facet, normal) == 0, "stl_facet.normal has correct offset"); static_assert(offsetof(stl_facet, vertex) == 12, "stl_facet.vertex has correct offset"); static_assert(offsetof(stl_facet, extra ) == 48, "stl_facet.extra has correct offset"); static_assert(sizeof(stl_facet) >= SIZEOF_STL_FACET, "size of stl_facet incorrect"); typedef enum {binary, ascii, inmemory} stl_type; typedef struct { stl_vertex p1; stl_vertex p2; int facet_number; } stl_edge; typedef struct stl_hash_edge { // Key of a hash edge: 2x binary copy of a floating point vertex. uint32_t key[6]; // Index of a facet owning this edge. int facet_number; // Index of this edge inside the facet with an index of facet_number. // If this edge is stored backwards, which_edge is increased by 3. int which_edge; struct stl_hash_edge *next; } stl_hash_edge; static_assert(offsetof(stl_hash_edge, facet_number) == SIZEOF_EDGE_SORT, "size of stl_hash_edge.key incorrect"); typedef struct { // Index of a neighbor facet. int neighbor[3]; // Index of an opposite vertex at the neighbor face. char which_vertex_not[3]; } stl_neighbors; typedef struct { int vertex[3]; } v_indices_struct; typedef struct { char header[81]; stl_type type; int number_of_facets; stl_vertex max; stl_vertex min; stl_vertex size; float bounding_diameter; float shortest_edge; float volume; unsigned number_of_blocks; int connected_edges; int connected_facets_1_edge; int connected_facets_2_edge; int connected_facets_3_edge; int facets_w_1_bad_edge; int facets_w_2_bad_edge; int facets_w_3_bad_edge; int original_num_facets; int edges_fixed; int degenerate_facets; int facets_removed; int facets_added; int facets_reversed; int backwards_edges; int normals_fixed; int number_of_parts; int malloced; int freed; int facets_malloced; int collisions; int shared_vertices; int shared_malloced; } stl_stats; typedef struct { FILE *fp; stl_facet *facet_start; stl_edge *edge_start; stl_hash_edge **heads; stl_hash_edge *tail; int M; stl_neighbors *neighbors_start; v_indices_struct *v_indices; stl_vertex *v_shared; stl_stats stats; char error; } stl_file; extern void stl_open(stl_file *stl, char *file); extern void stl_close(stl_file *stl); extern void stl_stats_out(stl_file *stl, FILE *file, char *input_file); extern void stl_print_edges(stl_file *stl, FILE *file); extern void stl_print_neighbors(stl_file *stl, char *file); extern void stl_put_little_int(FILE *fp, int value_in); extern void stl_put_little_float(FILE *fp, float value_in); extern void stl_write_ascii(stl_file *stl, const char *file, const char *label); extern void stl_write_binary(stl_file *stl, const char *file, const char *label); extern void stl_write_binary_block(stl_file *stl, FILE *fp); extern void stl_check_facets_exact(stl_file *stl); extern void stl_check_facets_nearby(stl_file *stl, float tolerance); extern void stl_remove_unconnected_facets(stl_file *stl); extern void stl_write_vertex(stl_file *stl, int facet, int vertex); extern void stl_write_facet(stl_file *stl, char *label, int facet); extern void stl_write_edge(stl_file *stl, char *label, stl_hash_edge edge); extern void stl_write_neighbor(stl_file *stl, int facet); extern void stl_write_quad_object(stl_file *stl, char *file); extern void stl_verify_neighbors(stl_file *stl); extern void stl_fill_holes(stl_file *stl); extern void stl_fix_normal_directions(stl_file *stl); extern void stl_fix_normal_values(stl_file *stl); extern void stl_reverse_all_facets(stl_file *stl); extern void stl_translate(stl_file *stl, float x, float y, float z); extern void stl_translate_relative(stl_file *stl, float x, float y, float z); extern void stl_scale_versor(stl_file *stl, float versor[3]); extern void stl_scale(stl_file *stl, float factor); extern void stl_rotate_x(stl_file *stl, float angle); extern void stl_rotate_y(stl_file *stl, float angle); extern void stl_rotate_z(stl_file *stl, float angle); extern void stl_mirror_xy(stl_file *stl); extern void stl_mirror_yz(stl_file *stl); extern void stl_mirror_xz(stl_file *stl); extern void stl_open_merge(stl_file *stl, char *file); extern void stl_invalidate_shared_vertices(stl_file *stl); extern void stl_generate_shared_vertices(stl_file *stl); extern void stl_write_obj(stl_file *stl, char *file); extern void stl_write_off(stl_file *stl, char *file); extern void stl_write_dxf(stl_file *stl, char *file, char *label); extern void stl_write_vrml(stl_file *stl, char *file); extern void stl_calculate_normal(float normal[], stl_facet *facet); extern void stl_normalize_vector(float v[]); extern void stl_calculate_volume(stl_file *stl); extern void stl_repair(stl_file *stl, int fixall_flag, int exact_flag, int tolerance_flag, float tolerance, int increment_flag, float increment, int nearby_flag, int iterations, int remove_unconnected_flag, int fill_holes_flag, int normal_directions_flag, int normal_values_flag, int reverse_all_flag, int verbose_flag); extern void stl_initialize(stl_file *stl); extern void stl_count_facets(stl_file *stl, char *file); extern void stl_allocate(stl_file *stl); extern void stl_read(stl_file *stl, int first_facet, int first); extern void stl_facet_stats(stl_file *stl, stl_facet facet, int first); extern void stl_reallocate(stl_file *stl); extern void stl_add_facet(stl_file *stl, stl_facet *new_facet); extern void stl_get_size(stl_file *stl); extern void stl_clear_error(stl_file *stl); extern int stl_get_error(stl_file *stl); extern void stl_exit_on_error(stl_file *stl); #ifdef __cplusplus } #endif #endif Slic3r-version_1.31.6/xs/src/admesh/stl_io.c000066400000000000000000000322121301441720000206150ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #include #include #include "stl.h" #include "config.h" #if !defined(SEEK_SET) #define SEEK_SET 0 #define SEEK_CUR 1 #define SEEK_END 2 #endif void stl_print_edges(stl_file *stl, FILE *file) { int i; int edges_allocated; if (stl->error) return; edges_allocated = stl->stats.number_of_facets * 3; for(i = 0; i < edges_allocated; i++) { fprintf(file, "%d, %f, %f, %f, %f, %f, %f\n", stl->edge_start[i].facet_number, stl->edge_start[i].p1.x, stl->edge_start[i].p1.y, stl->edge_start[i].p1.z, stl->edge_start[i].p2.x, stl->edge_start[i].p2.y, stl->edge_start[i].p2.z); } } void stl_stats_out(stl_file *stl, FILE *file, char *input_file) { if (stl->error) return; /* this is here for Slic3r, without our config.h it won't use this part of the code anyway */ #ifndef VERSION #define VERSION "unknown" #endif fprintf(file, "\n\ ================= Results produced by ADMesh version " VERSION " ================\n"); fprintf(file, "\ Input file : %s\n", input_file); if(stl->stats.type == binary) { fprintf(file, "\ File type : Binary STL file\n"); } else { fprintf(file, "\ File type : ASCII STL file\n"); } fprintf(file, "\ Header : %s\n", stl->stats.header); fprintf(file, "============== Size ==============\n"); fprintf(file, "Min X = % f, Max X = % f\n", stl->stats.min.x, stl->stats.max.x); fprintf(file, "Min Y = % f, Max Y = % f\n", stl->stats.min.y, stl->stats.max.y); fprintf(file, "Min Z = % f, Max Z = % f\n", stl->stats.min.z, stl->stats.max.z); fprintf(file, "\ ========= Facet Status ========== Original ============ Final ====\n"); fprintf(file, "\ Number of facets : %5d %5d\n", stl->stats.original_num_facets, stl->stats.number_of_facets); fprintf(file, "\ Facets with 1 disconnected edge : %5d %5d\n", stl->stats.facets_w_1_bad_edge, stl->stats.connected_facets_2_edge - stl->stats.connected_facets_3_edge); fprintf(file, "\ Facets with 2 disconnected edges : %5d %5d\n", stl->stats.facets_w_2_bad_edge, stl->stats.connected_facets_1_edge - stl->stats.connected_facets_2_edge); fprintf(file, "\ Facets with 3 disconnected edges : %5d %5d\n", stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - stl->stats.connected_facets_1_edge); fprintf(file, "\ Total disconnected facets : %5d %5d\n", stl->stats.facets_w_1_bad_edge + stl->stats.facets_w_2_bad_edge + stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - stl->stats.connected_facets_3_edge); fprintf(file, "=== Processing Statistics === ===== Other Statistics =====\n"); fprintf(file, "\ Number of parts : %5d Volume : % f\n", stl->stats.number_of_parts, stl->stats.volume); fprintf(file, "\ Degenerate facets : %5d\n", stl->stats.degenerate_facets); fprintf(file, "\ Edges fixed : %5d\n", stl->stats.edges_fixed); fprintf(file, "\ Facets removed : %5d\n", stl->stats.facets_removed); fprintf(file, "\ Facets added : %5d\n", stl->stats.facets_added); fprintf(file, "\ Facets reversed : %5d\n", stl->stats.facets_reversed); fprintf(file, "\ Backwards edges : %5d\n", stl->stats.backwards_edges); fprintf(file, "\ Normals fixed : %5d\n", stl->stats.normals_fixed); } void stl_write_ascii(stl_file *stl, const char *file, const char *label) { int i; FILE *fp; char *error_msg; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } fprintf(fp, "solid %s\n", label); for(i = 0; i < stl->stats.number_of_facets; i++) { fprintf(fp, " facet normal % .8E % .8E % .8E\n", stl->facet_start[i].normal.x, stl->facet_start[i].normal.y, stl->facet_start[i].normal.z); fprintf(fp, " outer loop\n"); fprintf(fp, " vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[0].x, stl->facet_start[i].vertex[0].y, stl->facet_start[i].vertex[0].z); fprintf(fp, " vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[1].x, stl->facet_start[i].vertex[1].y, stl->facet_start[i].vertex[1].z); fprintf(fp, " vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y, stl->facet_start[i].vertex[2].z); fprintf(fp, " endloop\n"); fprintf(fp, " endfacet\n"); } fprintf(fp, "endsolid %s\n", label); fclose(fp); } void stl_print_neighbors(stl_file *stl, char *file) { int i; FILE *fp; char *error_msg; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_print_neighbors: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } for(i = 0; i < stl->stats.number_of_facets; i++) { fprintf(fp, "%d, %d,%d, %d,%d, %d,%d\n", i, stl->neighbors_start[i].neighbor[0], (int)stl->neighbors_start[i].which_vertex_not[0], stl->neighbors_start[i].neighbor[1], (int)stl->neighbors_start[i].which_vertex_not[1], stl->neighbors_start[i].neighbor[2], (int)stl->neighbors_start[i].which_vertex_not[2]); } fclose(fp); } void stl_write_binary(stl_file *stl, const char *file, const char *label) { FILE *fp; int i; char *error_msg; if (stl->error) return; /* Open the file */ fp = fopen(file, "wb"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_binary: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } fprintf(fp, "%s", label); for(i = strlen(label); i < LABEL_SIZE; i++) putc(0, fp); fseek(fp, LABEL_SIZE, SEEK_SET); fwrite(&stl->stats.number_of_facets, 4, 1, fp); for(i = 0; i < stl->stats.number_of_facets; i++) fwrite(stl->facet_start + i, SIZEOF_STL_FACET, 1, fp); fclose(fp); } void stl_write_vertex(stl_file *stl, int facet, int vertex) { if (stl->error) return; printf(" vertex %d/%d % .8E % .8E % .8E\n", vertex, facet, stl->facet_start[facet].vertex[vertex].x, stl->facet_start[facet].vertex[vertex].y, stl->facet_start[facet].vertex[vertex].z); } void stl_write_facet(stl_file *stl, char *label, int facet) { if (stl->error) return; printf("facet (%d)/ %s\n", facet, label); stl_write_vertex(stl, facet, 0); stl_write_vertex(stl, facet, 1); stl_write_vertex(stl, facet, 2); } void stl_write_edge(stl_file *stl, char *label, stl_hash_edge edge) { if (stl->error) return; printf("edge (%d)/(%d) %s\n", edge.facet_number, edge.which_edge, label); if(edge.which_edge < 3) { stl_write_vertex(stl, edge.facet_number, edge.which_edge % 3); stl_write_vertex(stl, edge.facet_number, (edge.which_edge + 1) % 3); } else { stl_write_vertex(stl, edge.facet_number, (edge.which_edge + 1) % 3); stl_write_vertex(stl, edge.facet_number, edge.which_edge % 3); } } void stl_write_neighbor(stl_file *stl, int facet) { if (stl->error) return; printf("Neighbors %d: %d, %d, %d ; %d, %d, %d\n", facet, stl->neighbors_start[facet].neighbor[0], stl->neighbors_start[facet].neighbor[1], stl->neighbors_start[facet].neighbor[2], stl->neighbors_start[facet].which_vertex_not[0], stl->neighbors_start[facet].which_vertex_not[1], stl->neighbors_start[facet].which_vertex_not[2]); } void stl_write_quad_object(stl_file *stl, char *file) { FILE *fp; int i; int j; char *error_msg; stl_vertex connect_color; stl_vertex uncon_1_color; stl_vertex uncon_2_color; stl_vertex uncon_3_color; stl_vertex color; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_quad_object: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } connect_color.x = 0.0; connect_color.y = 0.0; connect_color.z = 1.0; uncon_1_color.x = 0.0; uncon_1_color.y = 1.0; uncon_1_color.z = 0.0; uncon_2_color.x = 1.0; uncon_2_color.y = 1.0; uncon_2_color.z = 1.0; uncon_3_color.x = 1.0; uncon_3_color.y = 0.0; uncon_3_color.z = 0.0; fprintf(fp, "CQUAD\n"); for(i = 0; i < stl->stats.number_of_facets; i++) { j = ((stl->neighbors_start[i].neighbor[0] == -1) + (stl->neighbors_start[i].neighbor[1] == -1) + (stl->neighbors_start[i].neighbor[2] == -1)); if(j == 0) { color = connect_color; } else if(j == 1) { color = uncon_1_color; } else if(j == 2) { color = uncon_2_color; } else { color = uncon_3_color; } fprintf(fp, "%f %f %f %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[0].x, stl->facet_start[i].vertex[0].y, stl->facet_start[i].vertex[0].z, color.x, color.y, color.z); fprintf(fp, "%f %f %f %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[1].x, stl->facet_start[i].vertex[1].y, stl->facet_start[i].vertex[1].z, color.x, color.y, color.z); fprintf(fp, "%f %f %f %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y, stl->facet_start[i].vertex[2].z, color.x, color.y, color.z); fprintf(fp, "%f %f %f %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y, stl->facet_start[i].vertex[2].z, color.x, color.y, color.z); } fclose(fp); } void stl_write_dxf(stl_file *stl, char *file, char *label) { int i; FILE *fp; char *error_msg; if (stl->error) return; /* Open the file */ fp = fopen(file, "w"); if(fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing", file); perror(error_msg); free(error_msg); stl->error = 1; return; } fprintf(fp, "999\n%s\n", label); fprintf(fp, "0\nSECTION\n2\nHEADER\n0\nENDSEC\n"); fprintf(fp, "0\nSECTION\n2\nTABLES\n0\nTABLE\n2\nLAYER\n70\n1\n\ 0\nLAYER\n2\n0\n70\n0\n62\n7\n6\nCONTINUOUS\n0\nENDTAB\n0\nENDSEC\n"); fprintf(fp, "0\nSECTION\n2\nBLOCKS\n0\nENDSEC\n"); fprintf(fp, "0\nSECTION\n2\nENTITIES\n"); for(i = 0; i < stl->stats.number_of_facets; i++) { fprintf(fp, "0\n3DFACE\n8\n0\n"); fprintf(fp, "10\n%f\n20\n%f\n30\n%f\n", stl->facet_start[i].vertex[0].x, stl->facet_start[i].vertex[0].y, stl->facet_start[i].vertex[0].z); fprintf(fp, "11\n%f\n21\n%f\n31\n%f\n", stl->facet_start[i].vertex[1].x, stl->facet_start[i].vertex[1].y, stl->facet_start[i].vertex[1].z); fprintf(fp, "12\n%f\n22\n%f\n32\n%f\n", stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y, stl->facet_start[i].vertex[2].z); fprintf(fp, "13\n%f\n23\n%f\n33\n%f\n", stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y, stl->facet_start[i].vertex[2].z); } fprintf(fp, "0\nENDSEC\n0\nEOF\n"); fclose(fp); } void stl_clear_error(stl_file *stl) { stl->error = 0; } void stl_exit_on_error(stl_file *stl) { if (!stl->error) return; stl->error = 0; stl_close(stl); exit(1); } int stl_get_error(stl_file *stl) { return stl->error; } Slic3r-version_1.31.6/xs/src/admesh/stlinit.c000066400000000000000000000356431301441720000210250ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #include #include #include #include #include "stl.h" #ifndef SEEK_SET #error "SEEK_SET not defined" #endif void stl_open(stl_file *stl, char *file) { stl_initialize(stl); stl_count_facets(stl, file); stl_allocate(stl); stl_read(stl, 0, 1); if (!stl->error) fclose(stl->fp); } void stl_initialize(stl_file *stl) { stl->error = 0; stl->stats.degenerate_facets = 0; stl->stats.edges_fixed = 0; stl->stats.facets_added = 0; stl->stats.facets_removed = 0; stl->stats.facets_reversed = 0; stl->stats.normals_fixed = 0; stl->stats.number_of_parts = 0; stl->stats.original_num_facets = 0; stl->stats.number_of_facets = 0; stl->stats.facets_malloced = 0; stl->stats.volume = -1.0; stl->neighbors_start = NULL; stl->facet_start = NULL; stl->v_indices = NULL; stl->v_shared = NULL; } void stl_count_facets(stl_file *stl, char *file) { long file_size; int header_num_facets; int num_facets; int i; size_t s; unsigned char chtest[128]; int num_lines = 1; char *error_msg; if (stl->error) return; /* Open the file in binary mode first */ stl->fp = fopen(file, "rb"); if(stl->fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_initialize: Couldn't open %s for reading", file); perror(error_msg); free(error_msg); stl->error = 1; return; } /* Find size of file */ fseek(stl->fp, 0, SEEK_END); file_size = ftell(stl->fp); /* Check for binary or ASCII file */ fseek(stl->fp, HEADER_SIZE, SEEK_SET); if (!fread(chtest, sizeof(chtest), 1, stl->fp)) { perror("The input is an empty file"); stl->error = 1; return; } stl->stats.type = ascii; for(s = 0; s < sizeof(chtest); s++) { if(chtest[s] > 127) { stl->stats.type = binary; break; } } rewind(stl->fp); /* Get the header and the number of facets in the .STL file */ /* If the .STL file is binary, then do the following */ if(stl->stats.type == binary) { /* Test if the STL file has the right size */ if(((file_size - HEADER_SIZE) % SIZEOF_STL_FACET != 0) || (file_size < STL_MIN_FILE_SIZE)) { fprintf(stderr, "The file %s has the wrong size.\n", file); stl->error = 1; return; } num_facets = (file_size - HEADER_SIZE) / SIZEOF_STL_FACET; /* Read the header */ if (fread(stl->stats.header, LABEL_SIZE, 1, stl->fp) > 79) { stl->stats.header[80] = '\0'; } /* Read the int following the header. This should contain # of facets */ if((!fread(&header_num_facets, sizeof(int), 1, stl->fp)) || (num_facets != header_num_facets)) { fprintf(stderr, "Warning: File size doesn't match number of facets in the header\n"); } } /* Otherwise, if the .STL file is ASCII, then do the following */ else { /* Reopen the file in text mode (for getting correct newlines on Windows) */ // fix to silence a warning about unused return value. // obviously if it fails we have problems.... stl->fp = freopen(file, "r", stl->fp); // do another null check to be safe if(stl->fp == NULL) { error_msg = (char*) malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */ sprintf(error_msg, "stl_initialize: Couldn't open %s for reading", file); perror(error_msg); free(error_msg); stl->error = 1; return; } /* Find the number of facets */ char linebuf[100]; while (fgets(linebuf, 100, stl->fp) != NULL) { /* don't count short lines */ if (strlen(linebuf) <= 4) continue; /* skip solid/endsolid lines as broken STL file generators may put several of them */ if (strncmp(linebuf, "solid", 5) == 0 || strncmp(linebuf, "endsolid", 8) == 0) continue; ++num_lines; } rewind(stl->fp); /* Get the header */ for(i = 0; (i < 80) && (stl->stats.header[i] = getc(stl->fp)) != '\n'; i++); stl->stats.header[i] = '\0'; /* Lose the '\n' */ stl->stats.header[80] = '\0'; num_facets = num_lines / ASCII_LINES_PER_FACET; } stl->stats.number_of_facets += num_facets; stl->stats.original_num_facets = stl->stats.number_of_facets; } void stl_allocate(stl_file *stl) { if (stl->error) return; /* Allocate memory for the entire .STL file */ stl->facet_start = (stl_facet*)calloc(stl->stats.number_of_facets, sizeof(stl_facet)); if(stl->facet_start == NULL) perror("stl_initialize"); stl->stats.facets_malloced = stl->stats.number_of_facets; /* Allocate memory for the neighbors list */ stl->neighbors_start = (stl_neighbors*) calloc(stl->stats.number_of_facets, sizeof(stl_neighbors)); if(stl->facet_start == NULL) perror("stl_initialize"); } void stl_open_merge(stl_file *stl, char *file_to_merge) { int num_facets_so_far; stl_type origStlType; FILE *origFp; stl_file stl_to_merge; if (stl->error) return; /* Record how many facets we have so far from the first file. We will start putting facets in the next position. Since we're 0-indexed, it'l be the same position. */ num_facets_so_far = stl->stats.number_of_facets; /* Record the file type we started with: */ origStlType=stl->stats.type; /* Record the file pointer too: */ origFp=stl->fp; /* Initialize the sturucture with zero stats, header info and sizes: */ stl_initialize(&stl_to_merge); stl_count_facets(&stl_to_merge, file_to_merge); /* Copy what we need to into stl so that we can read the file_to_merge directly into it using stl_read: Save the rest of the valuable info: */ stl->stats.type=stl_to_merge.stats.type; stl->fp=stl_to_merge.fp; /* Add the number of facets we already have in stl with what we we found in stl_to_merge but haven't read yet. */ stl->stats.number_of_facets=num_facets_so_far+stl_to_merge.stats.number_of_facets; /* Allocate enough room for stl->stats.number_of_facets facets and neighbors: */ stl_reallocate(stl); /* Read the file to merge directly into stl, adding it to what we have already. Start at num_facets_so_far, the index to the first unused facet. Also say that this isn't our first time so we should augment stats like min and max instead of erasing them. */ stl_read(stl, num_facets_so_far, 0); /* Restore the stl information we overwrote (for stl_read) so that it still accurately reflects the subject part: */ stl->stats.type=origStlType; stl->fp=origFp; } extern void stl_reallocate(stl_file *stl) { if (stl->error) return; /* Reallocate more memory for the .STL file(s) */ stl->facet_start = (stl_facet*)realloc(stl->facet_start, stl->stats.number_of_facets * sizeof(stl_facet)); if(stl->facet_start == NULL) perror("stl_initialize"); stl->stats.facets_malloced = stl->stats.number_of_facets; /* Reallocate more memory for the neighbors list */ stl->neighbors_start = (stl_neighbors*) realloc(stl->neighbors_start, stl->stats.number_of_facets * sizeof(stl_neighbors)); if(stl->facet_start == NULL) perror("stl_initialize"); } /* Reads the contents of the file pointed to by stl->fp into the stl structure, starting at facet first_facet. The second argument says if it's our first time running this for the stl and therefore we should reset our max and min stats. */ void stl_read(stl_file *stl, int first_facet, int first) { stl_facet facet; int i; if (stl->error) return; if(stl->stats.type == binary) { fseek(stl->fp, HEADER_SIZE, SEEK_SET); } else { rewind(stl->fp); } for(i = first_facet; i < stl->stats.number_of_facets; i++) { if(stl->stats.type == binary) /* Read a single facet from a binary .STL file */ { /* we assume little-endian architecture! */ if (fread(&facet, 1, SIZEOF_STL_FACET, stl->fp) != SIZEOF_STL_FACET) { stl->error = 1; return; } } else /* Read a single facet from an ASCII .STL file */ { // skip solid/endsolid // (in this order, otherwise it won't work when they are paired in the middle of a file) fscanf(stl->fp, "endsolid\n"); fscanf(stl->fp, "solid%*[^\n]\n"); // name might contain spaces so %*s doesn't work and it also can be empty (just "solid") if((fscanf(stl->fp, " facet normal %f %f %f\n", &facet.normal.x, &facet.normal.y, &facet.normal.z) + \ fscanf(stl->fp, " outer loop\n") + \ fscanf(stl->fp, " vertex %f %f %f\n", &facet.vertex[0].x, &facet.vertex[0].y, &facet.vertex[0].z) + \ fscanf(stl->fp, " vertex %f %f %f\n", &facet.vertex[1].x, &facet.vertex[1].y, &facet.vertex[1].z) + \ fscanf(stl->fp, " vertex %f %f %f\n", &facet.vertex[2].x, &facet.vertex[2].y, &facet.vertex[2].z) + \ fscanf(stl->fp, " endloop\n") + \ fscanf(stl->fp, " endfacet\n")) != 12) { perror("Something is syntactically very wrong with this ASCII STL!"); stl->error = 1; return; } } #if 0 // Report close to zero vertex coordinates. Due to the nature of the floating point numbers, // close to zero values may be represented with singificantly higher precision than the rest of the vertices. // It may be worth to round these numbers to zero during loading to reduce the number of errors reported // during the STL import. for (size_t j = 0; j < 3; ++ j) { if (facet.vertex[j].x > -1e-12f && facet.vertex[j].x < 1e-12f) printf("stl_read: facet %d.x = %e\r\n", j, facet.vertex[j].x); if (facet.vertex[j].y > -1e-12f && facet.vertex[j].y < 1e-12f) printf("stl_read: facet %d.y = %e\r\n", j, facet.vertex[j].y); if (facet.vertex[j].z > -1e-12f && facet.vertex[j].z < 1e-12f) printf("stl_read: facet %d.z = %e\r\n", j, facet.vertex[j].z); } #endif #if 1 { // Positive and negative zeros are possible in the floats, which are considered equal by the FP unit. // When using a memcmp on raw floats, those numbers report to be different. // Unify all +0 and -0 to +0 to make the floats equal under memcmp. uint32_t *f = (uint32_t*)&facet; for (int j = 0; j < 12; ++ j, ++ f) // 3x vertex + normal: 4x3 = 12 floats if (*f == 0x80000000) // Negative zero, switch to positive zero. *f = 0; } #else { // Due to the nature of the floating point numbers, close to zero values may be represented with singificantly higher precision // than the rest of the vertices. Round them to zero. float *f = (float*)&facet; for (int j = 0; j < 12; ++ j, ++ f) // 3x vertex + normal: 4x3 = 12 floats if (*f > -1e-12f && *f < 1e-12f) // Negative zero, switch to positive zero. *f = 0; } #endif /* Write the facet into memory. */ memcpy(stl->facet_start+i, &facet, SIZEOF_STL_FACET); stl_facet_stats(stl, facet, first); first = 0; } stl->stats.size.x = stl->stats.max.x - stl->stats.min.x; stl->stats.size.y = stl->stats.max.y - stl->stats.min.y; stl->stats.size.z = stl->stats.max.z - stl->stats.min.z; stl->stats.bounding_diameter = sqrt( stl->stats.size.x * stl->stats.size.x + stl->stats.size.y * stl->stats.size.y + stl->stats.size.z * stl->stats.size.z ); } void stl_facet_stats(stl_file *stl, stl_facet facet, int first) { float diff_x; float diff_y; float diff_z; float max_diff; if (stl->error) return; /* while we are going through all of the facets, let's find the */ /* maximum and minimum values for x, y, and z */ /* Initialize the max and min values the first time through*/ if (first) { stl->stats.max.x = facet.vertex[0].x; stl->stats.min.x = facet.vertex[0].x; stl->stats.max.y = facet.vertex[0].y; stl->stats.min.y = facet.vertex[0].y; stl->stats.max.z = facet.vertex[0].z; stl->stats.min.z = facet.vertex[0].z; diff_x = ABS(facet.vertex[0].x - facet.vertex[1].x); diff_y = ABS(facet.vertex[0].y - facet.vertex[1].y); diff_z = ABS(facet.vertex[0].z - facet.vertex[1].z); max_diff = STL_MAX(diff_x, diff_y); max_diff = STL_MAX(diff_z, max_diff); stl->stats.shortest_edge = max_diff; first = 0; } /* now find the max and min values */ stl->stats.max.x = STL_MAX(stl->stats.max.x, facet.vertex[0].x); stl->stats.min.x = STL_MIN(stl->stats.min.x, facet.vertex[0].x); stl->stats.max.y = STL_MAX(stl->stats.max.y, facet.vertex[0].y); stl->stats.min.y = STL_MIN(stl->stats.min.y, facet.vertex[0].y); stl->stats.max.z = STL_MAX(stl->stats.max.z, facet.vertex[0].z); stl->stats.min.z = STL_MIN(stl->stats.min.z, facet.vertex[0].z); stl->stats.max.x = STL_MAX(stl->stats.max.x, facet.vertex[1].x); stl->stats.min.x = STL_MIN(stl->stats.min.x, facet.vertex[1].x); stl->stats.max.y = STL_MAX(stl->stats.max.y, facet.vertex[1].y); stl->stats.min.y = STL_MIN(stl->stats.min.y, facet.vertex[1].y); stl->stats.max.z = STL_MAX(stl->stats.max.z, facet.vertex[1].z); stl->stats.min.z = STL_MIN(stl->stats.min.z, facet.vertex[1].z); stl->stats.max.x = STL_MAX(stl->stats.max.x, facet.vertex[2].x); stl->stats.min.x = STL_MIN(stl->stats.min.x, facet.vertex[2].x); stl->stats.max.y = STL_MAX(stl->stats.max.y, facet.vertex[2].y); stl->stats.min.y = STL_MIN(stl->stats.min.y, facet.vertex[2].y); stl->stats.max.z = STL_MAX(stl->stats.max.z, facet.vertex[2].z); stl->stats.min.z = STL_MIN(stl->stats.min.z, facet.vertex[2].z); } void stl_close(stl_file *stl) { if (stl->error) return; if(stl->neighbors_start != NULL) free(stl->neighbors_start); if(stl->facet_start != NULL) free(stl->facet_start); if(stl->v_indices != NULL) free(stl->v_indices); if(stl->v_shared != NULL) free(stl->v_shared); } Slic3r-version_1.31.6/xs/src/admesh/util.c000066400000000000000000000374331301441720000203130ustar00rootroot00000000000000/* ADMesh -- process triangulated solid meshes * Copyright (C) 1995, 1996 Anthony D. Martin * Copyright (C) 2013, 2014 several contributors, see AUTHORS * * 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., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Questions, comments, suggestions, etc to * https://github.com/admesh/admesh/issues */ #include #include #include #include #include "stl.h" static void stl_rotate(float *x, float *y, const double c, const double s); static float get_area(stl_facet *facet); static float get_volume(stl_file *stl); void stl_verify_neighbors(stl_file *stl) { int i; int j; stl_edge edge_a; stl_edge edge_b; int neighbor; int vnot; if (stl->error) return; stl->stats.backwards_edges = 0; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { edge_a.p1 = stl->facet_start[i].vertex[j]; edge_a.p2 = stl->facet_start[i].vertex[(j + 1) % 3]; neighbor = stl->neighbors_start[i].neighbor[j]; vnot = stl->neighbors_start[i].which_vertex_not[j]; if(neighbor == -1) continue; /* this edge has no neighbor... Continue. */ if(vnot < 3) { edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3]; edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3]; } else { stl->stats.backwards_edges += 1; edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3]; edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3]; } if(memcmp(&edge_a, &edge_b, SIZEOF_EDGE_SORT) != 0) { /* These edges should match but they don't. Print results. */ printf("edge %d of facet %d doesn't match edge %d of facet %d\n", j, i, vnot + 1, neighbor); stl_write_facet(stl, (char*)"first facet", i); stl_write_facet(stl, (char*)"second facet", neighbor); } } } } void stl_translate(stl_file *stl, float x, float y, float z) { int i; int j; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->facet_start[i].vertex[j].x -= (stl->stats.min.x - x); stl->facet_start[i].vertex[j].y -= (stl->stats.min.y - y); stl->facet_start[i].vertex[j].z -= (stl->stats.min.z - z); } } stl->stats.max.x -= (stl->stats.min.x - x); stl->stats.max.y -= (stl->stats.min.y - y); stl->stats.max.z -= (stl->stats.min.z - z); stl->stats.min.x = x; stl->stats.min.y = y; stl->stats.min.z = z; stl_invalidate_shared_vertices(stl); } /* Translates the stl by x,y,z, relatively from wherever it is currently */ void stl_translate_relative(stl_file *stl, float x, float y, float z) { int i; int j; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->facet_start[i].vertex[j].x += x; stl->facet_start[i].vertex[j].y += y; stl->facet_start[i].vertex[j].z += z; } } stl->stats.min.x += x; stl->stats.min.y += y; stl->stats.min.z += z; stl->stats.max.x += x; stl->stats.max.y += y; stl->stats.max.z += z; stl_invalidate_shared_vertices(stl); } void stl_scale_versor(stl_file *stl, float versor[3]) { int i; int j; if (stl->error) return; /* scale extents */ stl->stats.min.x *= versor[0]; stl->stats.min.y *= versor[1]; stl->stats.min.z *= versor[2]; stl->stats.max.x *= versor[0]; stl->stats.max.y *= versor[1]; stl->stats.max.z *= versor[2]; /* scale size */ stl->stats.size.x *= versor[0]; stl->stats.size.y *= versor[1]; stl->stats.size.z *= versor[2]; /* scale volume */ if (stl->stats.volume > 0.0) { stl->stats.volume *= (versor[0] * versor[1] * versor[2]); } for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->facet_start[i].vertex[j].x *= versor[0]; stl->facet_start[i].vertex[j].y *= versor[1]; stl->facet_start[i].vertex[j].z *= versor[2]; } } stl_invalidate_shared_vertices(stl); } void stl_scale(stl_file *stl, float factor) { float versor[3]; if (stl->error) return; versor[0] = factor; versor[1] = factor; versor[2] = factor; stl_scale_versor(stl, versor); } static void calculate_normals(stl_file *stl) { long i; float normal[3]; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { stl_calculate_normal(normal, &stl->facet_start[i]); stl_normalize_vector(normal); stl->facet_start[i].normal.x = normal[0]; stl->facet_start[i].normal.y = normal[1]; stl->facet_start[i].normal.z = normal[2]; } } void stl_rotate_x(stl_file *stl, float angle) { int i; int j; double radian_angle = (angle / 180.0) * M_PI; double c = cos(radian_angle); double s = sin(radian_angle); if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl_rotate(&stl->facet_start[i].vertex[j].y, &stl->facet_start[i].vertex[j].z, c, s); } } stl_get_size(stl); calculate_normals(stl); } void stl_rotate_y(stl_file *stl, float angle) { int i; int j; double radian_angle = (angle / 180.0) * M_PI; double c = cos(radian_angle); double s = sin(radian_angle); if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl_rotate(&stl->facet_start[i].vertex[j].z, &stl->facet_start[i].vertex[j].x, c, s); } } stl_get_size(stl); calculate_normals(stl); } void stl_rotate_z(stl_file *stl, float angle) { int i; int j; double radian_angle = (angle / 180.0) * M_PI; double c = cos(radian_angle); double s = sin(radian_angle); if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl_rotate(&stl->facet_start[i].vertex[j].x, &stl->facet_start[i].vertex[j].y, c, s); } } stl_get_size(stl); calculate_normals(stl); } static void stl_rotate(float *x, float *y, const double c, const double s) { double xold = *x; double yold = *y; *x = float(c * xold - s * yold); *y = float(s * xold + c * yold); } extern void stl_get_size(stl_file *stl) { int i; int j; if (stl->error) return; if (stl->stats.number_of_facets == 0) return; stl->stats.min.x = stl->facet_start[0].vertex[0].x; stl->stats.min.y = stl->facet_start[0].vertex[0].y; stl->stats.min.z = stl->facet_start[0].vertex[0].z; stl->stats.max.x = stl->facet_start[0].vertex[0].x; stl->stats.max.y = stl->facet_start[0].vertex[0].y; stl->stats.max.z = stl->facet_start[0].vertex[0].z; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->stats.min.x = STL_MIN(stl->stats.min.x, stl->facet_start[i].vertex[j].x); stl->stats.min.y = STL_MIN(stl->stats.min.y, stl->facet_start[i].vertex[j].y); stl->stats.min.z = STL_MIN(stl->stats.min.z, stl->facet_start[i].vertex[j].z); stl->stats.max.x = STL_MAX(stl->stats.max.x, stl->facet_start[i].vertex[j].x); stl->stats.max.y = STL_MAX(stl->stats.max.y, stl->facet_start[i].vertex[j].y); stl->stats.max.z = STL_MAX(stl->stats.max.z, stl->facet_start[i].vertex[j].z); } } stl->stats.size.x = stl->stats.max.x - stl->stats.min.x; stl->stats.size.y = stl->stats.max.y - stl->stats.min.y; stl->stats.size.z = stl->stats.max.z - stl->stats.min.z; stl->stats.bounding_diameter = sqrt( stl->stats.size.x * stl->stats.size.x + stl->stats.size.y * stl->stats.size.y + stl->stats.size.z * stl->stats.size.z ); } void stl_mirror_xy(stl_file *stl) { int i; int j; float temp_size; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->facet_start[i].vertex[j].z *= -1.0; } } temp_size = stl->stats.min.z; stl->stats.min.z = stl->stats.max.z; stl->stats.max.z = temp_size; stl->stats.min.z *= -1.0; stl->stats.max.z *= -1.0; stl_reverse_all_facets(stl); stl->stats.facets_reversed -= stl->stats.number_of_facets; /* for not altering stats */ } void stl_mirror_yz(stl_file *stl) { int i; int j; float temp_size; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->facet_start[i].vertex[j].x *= -1.0; } } temp_size = stl->stats.min.x; stl->stats.min.x = stl->stats.max.x; stl->stats.max.x = temp_size; stl->stats.min.x *= -1.0; stl->stats.max.x *= -1.0; stl_reverse_all_facets(stl); stl->stats.facets_reversed -= stl->stats.number_of_facets; /* for not altering stats */ } void stl_mirror_xz(stl_file *stl) { int i; int j; float temp_size; if (stl->error) return; for(i = 0; i < stl->stats.number_of_facets; i++) { for(j = 0; j < 3; j++) { stl->facet_start[i].vertex[j].y *= -1.0; } } temp_size = stl->stats.min.y; stl->stats.min.y = stl->stats.max.y; stl->stats.max.y = temp_size; stl->stats.min.y *= -1.0; stl->stats.max.y *= -1.0; stl_reverse_all_facets(stl); stl->stats.facets_reversed -= stl->stats.number_of_facets; /* for not altering stats */ } static float get_volume(stl_file *stl) { long i; stl_vertex p0; stl_vertex p; stl_normal n; float height; float area; float volume = 0.0; if (stl->error) return 0; /* Choose a point, any point as the reference */ p0.x = stl->facet_start[0].vertex[0].x; p0.y = stl->facet_start[0].vertex[0].y; p0.z = stl->facet_start[0].vertex[0].z; for(i = 0; i < stl->stats.number_of_facets; i++) { p.x = stl->facet_start[i].vertex[0].x - p0.x; p.y = stl->facet_start[i].vertex[0].y - p0.y; p.z = stl->facet_start[i].vertex[0].z - p0.z; /* Do dot product to get distance from point to plane */ n = stl->facet_start[i].normal; height = (n.x * p.x) + (n.y * p.y) + (n.z * p.z); area = get_area(&stl->facet_start[i]); volume += (area * height) / 3.0; } return volume; } void stl_calculate_volume(stl_file *stl) { if (stl->error) return; stl->stats.volume = get_volume(stl); if(stl->stats.volume < 0.0) { stl_reverse_all_facets(stl); stl->stats.volume = -stl->stats.volume; } } static float get_area(stl_facet *facet) { double cross[3][3]; float sum[3]; float n[3]; float area; int i; /* cast to double before calculating cross product because large coordinates can result in overflowing product (bad area is responsible for bad volume and bad facets reversal) */ for(i = 0; i < 3; i++) { cross[i][0]=(((double)facet->vertex[i].y * (double)facet->vertex[(i + 1) % 3].z) - ((double)facet->vertex[i].z * (double)facet->vertex[(i + 1) % 3].y)); cross[i][1]=(((double)facet->vertex[i].z * (double)facet->vertex[(i + 1) % 3].x) - ((double)facet->vertex[i].x * (double)facet->vertex[(i + 1) % 3].z)); cross[i][2]=(((double)facet->vertex[i].x * (double)facet->vertex[(i + 1) % 3].y) - ((double)facet->vertex[i].y * (double)facet->vertex[(i + 1) % 3].x)); } sum[0] = cross[0][0] + cross[1][0] + cross[2][0]; sum[1] = cross[0][1] + cross[1][1] + cross[2][1]; sum[2] = cross[0][2] + cross[1][2] + cross[2][2]; /* This should already be done. But just in case, let's do it again */ stl_calculate_normal(n, facet); stl_normalize_vector(n); area = 0.5 * (n[0] * sum[0] + n[1] * sum[1] + n[2] * sum[2]); return area; } void stl_repair(stl_file *stl, int fixall_flag, int exact_flag, int tolerance_flag, float tolerance, int increment_flag, float increment, int nearby_flag, int iterations, int remove_unconnected_flag, int fill_holes_flag, int normal_directions_flag, int normal_values_flag, int reverse_all_flag, int verbose_flag) { int i; int last_edges_fixed = 0; if (stl->error) return; if(exact_flag || fixall_flag || nearby_flag || remove_unconnected_flag || fill_holes_flag || normal_directions_flag) { if (verbose_flag) printf("Checking exact...\n"); exact_flag = 1; stl_check_facets_exact(stl); stl->stats.facets_w_1_bad_edge = (stl->stats.connected_facets_2_edge - stl->stats.connected_facets_3_edge); stl->stats.facets_w_2_bad_edge = (stl->stats.connected_facets_1_edge - stl->stats.connected_facets_2_edge); stl->stats.facets_w_3_bad_edge = (stl->stats.number_of_facets - stl->stats.connected_facets_1_edge); } if(nearby_flag || fixall_flag) { if(!tolerance_flag) { tolerance = stl->stats.shortest_edge; } if(!increment_flag) { increment = stl->stats.bounding_diameter / 10000.0; } if(stl->stats.connected_facets_3_edge < stl->stats.number_of_facets) { for(i = 0; i < iterations; i++) { if(stl->stats.connected_facets_3_edge < stl->stats.number_of_facets) { if (verbose_flag) printf("\ Checking nearby. Tolerance= %f Iteration=%d of %d...", tolerance, i + 1, iterations); stl_check_facets_nearby(stl, tolerance); if (verbose_flag) printf(" Fixed %d edges.\n", stl->stats.edges_fixed - last_edges_fixed); last_edges_fixed = stl->stats.edges_fixed; tolerance += increment; } else { if (verbose_flag) printf("\ All facets connected. No further nearby check necessary.\n"); break; } } } else { if (verbose_flag) printf("All facets connected. No nearby check necessary.\n"); } } if(remove_unconnected_flag || fixall_flag || fill_holes_flag) { if(stl->stats.connected_facets_3_edge < stl->stats.number_of_facets) { if (verbose_flag) printf("Removing unconnected facets...\n"); stl_remove_unconnected_facets(stl); } else if (verbose_flag) printf("No unconnected need to be removed.\n"); } if(fill_holes_flag || fixall_flag) { if(stl->stats.connected_facets_3_edge < stl->stats.number_of_facets) { if (verbose_flag) printf("Filling holes...\n"); stl_fill_holes(stl); } else if (verbose_flag) printf("No holes need to be filled.\n"); } if(reverse_all_flag) { if (verbose_flag) printf("Reversing all facets...\n"); stl_reverse_all_facets(stl); } if(normal_directions_flag || fixall_flag) { if (verbose_flag) printf("Checking normal directions...\n"); stl_fix_normal_directions(stl); } if(normal_values_flag || fixall_flag) { if (verbose_flag) printf("Checking normal values...\n"); stl_fix_normal_values(stl); } /* Always calculate the volume. It shouldn't take too long */ if (verbose_flag) printf("Calculating volume...\n"); stl_calculate_volume(stl); if(exact_flag) { if (verbose_flag) printf("Verifying neighbors...\n"); stl_verify_neighbors(stl); } } Slic3r-version_1.31.6/xs/src/clipper.cpp000066400000000000000000004215561301441720000200760ustar00rootroot00000000000000/******************************************************************************* * * * Author : Angus Johnson * * Version : 6.2.9 * * Date : 16 February 2015 * * Website : http://www.angusj.com * * Copyright : Angus Johnson 2010-2015 * * * * License: * * Use, modification & distribution is subject to Boost Software License Ver 1. * * http://www.boost.org/LICENSE_1_0.txt * * * * Attributions: * * The code in this library is an extension of Bala Vatti's clipping algorithm: * * "A generic solution to polygon clipping" * * Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63. * * http://portal.acm.org/citation.cfm?id=129906 * * * * Computer graphics and geometric modeling: implementation and algorithms * * By Max K. Agoston * * Springer; 1 edition (January 4, 2005) * * http://books.google.com/books?q=vatti+clipping+agoston * * * * See also: * * "Polygon Offsetting by Computing Winding Numbers" * * Paper no. DETC2005-85513 pp. 565-575 * * ASME 2005 International Design Engineering Technical Conferences * * and Computers and Information in Engineering Conference (IDETC/CIE2005) * * September 24-28, 2005 , Long Beach, California, USA * * http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf * * * *******************************************************************************/ /******************************************************************************* * * * This is a translation of the Delphi Clipper library and the naming style * * used has retained a Delphi flavour. * * * *******************************************************************************/ #include "clipper.hpp" #include #include #include #include #include #include #include #include namespace ClipperLib { static double const pi = 3.141592653589793238; static double const two_pi = pi *2; static double const def_arc_tolerance = 0.25; enum Direction { dRightToLeft, dLeftToRight }; static int const Unassigned = -1; //edge not currently 'owning' a solution static int const Skip = -2; //edge that would otherwise close a path #define HORIZONTAL (-1.0E+40) #define TOLERANCE (1.0e-20) #define NEAR_ZERO(val) (((val) > -TOLERANCE) && ((val) < TOLERANCE)) struct TEdge { IntPoint Bot; IntPoint Curr; IntPoint Top; IntPoint Delta; double Dx; PolyType PolyTyp; EdgeSide Side; int WindDelta; //1 or -1 depending on winding direction int WindCnt; int WindCnt2; //winding count of the opposite polytype int OutIdx; TEdge *Next; TEdge *Prev; TEdge *NextInLML; TEdge *NextInAEL; TEdge *PrevInAEL; TEdge *NextInSEL; TEdge *PrevInSEL; }; struct IntersectNode { TEdge *Edge1; TEdge *Edge2; IntPoint Pt; }; struct LocalMinimum { cInt Y; TEdge *LeftBound; TEdge *RightBound; }; struct OutPt; struct OutRec { int Idx; bool IsHole; bool IsOpen; OutRec *FirstLeft; //see comments in clipper.pas PolyNode *PolyNd; OutPt *Pts; OutPt *BottomPt; }; struct OutPt { int Idx; IntPoint Pt; OutPt *Next; OutPt *Prev; }; struct Join { OutPt *OutPt1; OutPt *OutPt2; IntPoint OffPt; }; struct LocMinSorter { inline bool operator()(const LocalMinimum& locMin1, const LocalMinimum& locMin2) { return locMin2.Y < locMin1.Y; } }; //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ inline cInt Round(double val) { if ((val < 0)) return static_cast(val - 0.5); else return static_cast(val + 0.5); } //------------------------------------------------------------------------------ inline cInt Abs(cInt val) { return val < 0 ? -val : val; } //------------------------------------------------------------------------------ // PolyTree methods ... //------------------------------------------------------------------------------ void PolyTree::Clear() { for (PolyNodes::size_type i = 0; i < AllNodes.size(); ++i) delete AllNodes[i]; AllNodes.resize(0); Childs.resize(0); } //------------------------------------------------------------------------------ PolyNode* PolyTree::GetFirst() const { if (!Childs.empty()) return Childs[0]; else return 0; } //------------------------------------------------------------------------------ int PolyTree::Total() const { int result = (int)AllNodes.size(); //with negative offsets, ignore the hidden outer polygon ... if (result > 0 && Childs[0] != AllNodes[0]) result--; return result; } //------------------------------------------------------------------------------ // PolyNode methods ... //------------------------------------------------------------------------------ PolyNode::PolyNode(): Childs(), Parent(0), Index(0), m_IsOpen(false) { } //------------------------------------------------------------------------------ int PolyNode::ChildCount() const { return (int)Childs.size(); } //------------------------------------------------------------------------------ void PolyNode::AddChild(PolyNode& child) { unsigned cnt = (unsigned)Childs.size(); Childs.push_back(&child); child.Parent = this; child.Index = cnt; } //------------------------------------------------------------------------------ PolyNode* PolyNode::GetNext() const { if (!Childs.empty()) return Childs[0]; else return GetNextSiblingUp(); } //------------------------------------------------------------------------------ PolyNode* PolyNode::GetNextSiblingUp() const { if (!Parent) //protects against PolyTree.GetNextSiblingUp() return 0; else if (Index == Parent->Childs.size() - 1) return Parent->GetNextSiblingUp(); else return Parent->Childs[Index + 1]; } //------------------------------------------------------------------------------ bool PolyNode::IsHole() const { bool result = true; PolyNode* node = Parent; while (node) { result = !result; node = node->Parent; } return result; } //------------------------------------------------------------------------------ bool PolyNode::IsOpen() const { return m_IsOpen; } //------------------------------------------------------------------------------ #ifndef use_int32 //------------------------------------------------------------------------------ // Int128 class (enables safe math on signed 64bit integers) // eg Int128 val1((long64)9223372036854775807); //ie 2^63 -1 // Int128 val2((long64)9223372036854775807); // Int128 val3 = val1 * val2; // val3.AsString => "85070591730234615847396907784232501249" (8.5e+37) //------------------------------------------------------------------------------ class Int128 { public: ulong64 lo; long64 hi; Int128(long64 _lo = 0) { lo = (ulong64)_lo; if (_lo < 0) hi = -1; else hi = 0; } Int128(const Int128 &val): lo(val.lo), hi(val.hi){} Int128(const long64& _hi, const ulong64& _lo): lo(_lo), hi(_hi){} Int128& operator = (const long64 &val) { lo = (ulong64)val; if (val < 0) hi = -1; else hi = 0; return *this; } bool operator == (const Int128 &val) const {return (hi == val.hi && lo == val.lo);} bool operator != (const Int128 &val) const { return !(*this == val);} bool operator > (const Int128 &val) const { if (hi != val.hi) return hi > val.hi; else return lo > val.lo; } bool operator < (const Int128 &val) const { if (hi != val.hi) return hi < val.hi; else return lo < val.lo; } bool operator >= (const Int128 &val) const { return !(*this < val);} bool operator <= (const Int128 &val) const { return !(*this > val);} Int128& operator += (const Int128 &rhs) { hi += rhs.hi; lo += rhs.lo; if (lo < rhs.lo) hi++; return *this; } Int128 operator + (const Int128 &rhs) const { Int128 result(*this); result+= rhs; return result; } Int128& operator -= (const Int128 &rhs) { *this += -rhs; return *this; } Int128 operator - (const Int128 &rhs) const { Int128 result(*this); result -= rhs; return result; } Int128 operator-() const //unary negation { if (lo == 0) return Int128(-hi, 0); else return Int128(~hi, ~lo + 1); } operator double() const { const double shift64 = 18446744073709551616.0; //2^64 if (hi < 0) { if (lo == 0) return (double)hi * shift64; else return -(double)(~lo + ~hi * shift64); } else return (double)(lo + hi * shift64); } }; //------------------------------------------------------------------------------ Int128 Int128Mul (long64 lhs, long64 rhs) { bool negate = (lhs < 0) != (rhs < 0); if (lhs < 0) lhs = -lhs; ulong64 int1Hi = ulong64(lhs) >> 32; ulong64 int1Lo = ulong64(lhs & 0xFFFFFFFF); if (rhs < 0) rhs = -rhs; ulong64 int2Hi = ulong64(rhs) >> 32; ulong64 int2Lo = ulong64(rhs & 0xFFFFFFFF); //nb: see comments in clipper.pas ulong64 a = int1Hi * int2Hi; ulong64 b = int1Lo * int2Lo; ulong64 c = int1Hi * int2Lo + int1Lo * int2Hi; Int128 tmp; tmp.hi = long64(a + (c >> 32)); tmp.lo = long64(c << 32); tmp.lo += long64(b); if (tmp.lo < b) tmp.hi++; if (negate) tmp = -tmp; return tmp; }; #endif //------------------------------------------------------------------------------ // Miscellaneous global functions //------------------------------------------------------------------------------ bool Orientation(const Path &poly) { return Area(poly) >= 0; } //------------------------------------------------------------------------------ double Area(const Path &poly) { int size = (int)poly.size(); if (size < 3) return 0; double a = 0; for (int i = 0, j = size -1; i < size; ++i) { a += ((double)poly[j].X + poly[i].X) * ((double)poly[j].Y - poly[i].Y); j = i; } return -a * 0.5; } //------------------------------------------------------------------------------ double Area(const OutRec &outRec) { OutPt *op = outRec.Pts; if (!op) return 0; double a = 0; do { a += (double)(op->Prev->Pt.X + op->Pt.X) * (double)(op->Prev->Pt.Y - op->Pt.Y); op = op->Next; } while (op != outRec.Pts); return a * 0.5; } //------------------------------------------------------------------------------ bool PointIsVertex(const IntPoint &Pt, OutPt *pp) { OutPt *pp2 = pp; do { if (pp2->Pt == Pt) return true; pp2 = pp2->Next; } while (pp2 != pp); return false; } //------------------------------------------------------------------------------ //See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann & Agathos //http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf int PointInPolygon(const IntPoint &pt, const Path &path) { //returns 0 if false, +1 if true, -1 if pt ON polygon boundary int result = 0; size_t cnt = path.size(); if (cnt < 3) return 0; IntPoint ip = path[0]; for(size_t i = 1; i <= cnt; ++i) { IntPoint ipNext = (i == cnt ? path[0] : path[i]); if (ipNext.Y == pt.Y) { if ((ipNext.X == pt.X) || (ip.Y == pt.Y && ((ipNext.X > pt.X) == (ip.X < pt.X)))) return -1; } if ((ip.Y < pt.Y) != (ipNext.Y < pt.Y)) { if (ip.X >= pt.X) { if (ipNext.X > pt.X) result = 1 - result; else { double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) - (double)(ipNext.X - pt.X) * (ip.Y - pt.Y); if (!d) return -1; if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result; } } else { if (ipNext.X > pt.X) { double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) - (double)(ipNext.X - pt.X) * (ip.Y - pt.Y); if (!d) return -1; if ((d > 0) == (ipNext.Y > ip.Y)) result = 1 - result; } } } ip = ipNext; } return result; } //------------------------------------------------------------------------------ int PointInPolygon (const IntPoint &pt, OutPt *op) { //returns 0 if false, +1 if true, -1 if pt ON polygon boundary int result = 0; OutPt* startOp = op; for(;;) { if (op->Next->Pt.Y == pt.Y) { if ((op->Next->Pt.X == pt.X) || (op->Pt.Y == pt.Y && ((op->Next->Pt.X > pt.X) == (op->Pt.X < pt.X)))) return -1; } if ((op->Pt.Y < pt.Y) != (op->Next->Pt.Y < pt.Y)) { if (op->Pt.X >= pt.X) { if (op->Next->Pt.X > pt.X) result = 1 - result; else { double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) - (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y); if (!d) return -1; if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result; } } else { if (op->Next->Pt.X > pt.X) { double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) - (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y); if (!d) return -1; if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y)) result = 1 - result; } } } op = op->Next; if (startOp == op) break; } return result; } //------------------------------------------------------------------------------ bool Poly2ContainsPoly1(OutPt *OutPt1, OutPt *OutPt2) { OutPt* op = OutPt1; do { //nb: PointInPolygon returns 0 if false, +1 if true, -1 if pt on polygon int res = PointInPolygon(op->Pt, OutPt2); if (res >= 0) return res > 0; op = op->Next; } while (op != OutPt1); return true; } //---------------------------------------------------------------------- bool SlopesEqual(const TEdge &e1, const TEdge &e2, bool UseFullInt64Range) { #ifndef use_int32 if (UseFullInt64Range) return Int128Mul(e1.Delta.Y, e2.Delta.X) == Int128Mul(e1.Delta.X, e2.Delta.Y); else #endif return e1.Delta.Y * e2.Delta.X == e1.Delta.X * e2.Delta.Y; } //------------------------------------------------------------------------------ bool SlopesEqual(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3, bool UseFullInt64Range) { #ifndef use_int32 if (UseFullInt64Range) return Int128Mul(pt1.Y-pt2.Y, pt2.X-pt3.X) == Int128Mul(pt1.X-pt2.X, pt2.Y-pt3.Y); else #endif return (pt1.Y-pt2.Y)*(pt2.X-pt3.X) == (pt1.X-pt2.X)*(pt2.Y-pt3.Y); } //------------------------------------------------------------------------------ bool SlopesEqual(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3, const IntPoint &pt4, bool UseFullInt64Range) { #ifndef use_int32 if (UseFullInt64Range) return Int128Mul(pt1.Y-pt2.Y, pt3.X-pt4.X) == Int128Mul(pt1.X-pt2.X, pt3.Y-pt4.Y); else #endif return (pt1.Y-pt2.Y)*(pt3.X-pt4.X) == (pt1.X-pt2.X)*(pt3.Y-pt4.Y); } //------------------------------------------------------------------------------ inline bool IsHorizontal(TEdge &e) { return e.Delta.Y == 0; } //------------------------------------------------------------------------------ inline double GetDx(const IntPoint &pt1, const IntPoint &pt2) { return (pt1.Y == pt2.Y) ? HORIZONTAL : (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y); } //--------------------------------------------------------------------------- inline void SetDx(TEdge &e) { e.Delta.X = (e.Top.X - e.Bot.X); e.Delta.Y = (e.Top.Y - e.Bot.Y); if (e.Delta.Y == 0) e.Dx = HORIZONTAL; else e.Dx = (double)(e.Delta.X) / e.Delta.Y; } //--------------------------------------------------------------------------- inline void SwapSides(TEdge &Edge1, TEdge &Edge2) { EdgeSide Side = Edge1.Side; Edge1.Side = Edge2.Side; Edge2.Side = Side; } //------------------------------------------------------------------------------ inline void SwapPolyIndexes(TEdge &Edge1, TEdge &Edge2) { int OutIdx = Edge1.OutIdx; Edge1.OutIdx = Edge2.OutIdx; Edge2.OutIdx = OutIdx; } //------------------------------------------------------------------------------ inline cInt TopX(TEdge &edge, const cInt currentY) { return ( currentY == edge.Top.Y ) ? edge.Top.X : edge.Bot.X + Round(edge.Dx *(currentY - edge.Bot.Y)); } //------------------------------------------------------------------------------ void IntersectPoint(TEdge &Edge1, TEdge &Edge2, IntPoint &ip) { #ifdef use_xyz ip.Z = 0; #endif double b1, b2; if (Edge1.Dx == Edge2.Dx) { ip.Y = Edge1.Curr.Y; ip.X = TopX(Edge1, ip.Y); return; } else if (Edge1.Delta.X == 0) { ip.X = Edge1.Bot.X; if (IsHorizontal(Edge2)) ip.Y = Edge2.Bot.Y; else { b2 = Edge2.Bot.Y - (Edge2.Bot.X / Edge2.Dx); ip.Y = Round(ip.X / Edge2.Dx + b2); } } else if (Edge2.Delta.X == 0) { ip.X = Edge2.Bot.X; if (IsHorizontal(Edge1)) ip.Y = Edge1.Bot.Y; else { b1 = Edge1.Bot.Y - (Edge1.Bot.X / Edge1.Dx); ip.Y = Round(ip.X / Edge1.Dx + b1); } } else { b1 = Edge1.Bot.X - Edge1.Bot.Y * Edge1.Dx; b2 = Edge2.Bot.X - Edge2.Bot.Y * Edge2.Dx; double q = (b2-b1) / (Edge1.Dx - Edge2.Dx); ip.Y = Round(q); if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx)) ip.X = Round(Edge1.Dx * q + b1); else ip.X = Round(Edge2.Dx * q + b2); } if (ip.Y < Edge1.Top.Y || ip.Y < Edge2.Top.Y) { if (Edge1.Top.Y > Edge2.Top.Y) ip.Y = Edge1.Top.Y; else ip.Y = Edge2.Top.Y; if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx)) ip.X = TopX(Edge1, ip.Y); else ip.X = TopX(Edge2, ip.Y); } //finally, don't allow 'ip' to be BELOW curr.Y (ie bottom of scanbeam) ... if (ip.Y > Edge1.Curr.Y) { ip.Y = Edge1.Curr.Y; //use the more vertical edge to derive X ... if (std::fabs(Edge1.Dx) > std::fabs(Edge2.Dx)) ip.X = TopX(Edge2, ip.Y); else ip.X = TopX(Edge1, ip.Y); } } //------------------------------------------------------------------------------ void ReversePolyPtLinks(OutPt *pp) { if (!pp) return; OutPt *pp1, *pp2; pp1 = pp; do { pp2 = pp1->Next; pp1->Next = pp1->Prev; pp1->Prev = pp2; pp1 = pp2; } while( pp1 != pp ); } //------------------------------------------------------------------------------ void DisposeOutPts(OutPt*& pp) { if (pp == 0) return; pp->Prev->Next = 0; while( pp ) { OutPt *tmpPp = pp; pp = pp->Next; delete tmpPp; } } //------------------------------------------------------------------------------ inline void InitEdge(TEdge* e, TEdge* eNext, TEdge* ePrev, const IntPoint& Pt) { std::memset(e, 0, sizeof(TEdge)); e->Next = eNext; e->Prev = ePrev; e->Curr = Pt; e->OutIdx = Unassigned; } //------------------------------------------------------------------------------ void InitEdge2(TEdge& e, PolyType Pt) { if (e.Curr.Y >= e.Next->Curr.Y) { e.Bot = e.Curr; e.Top = e.Next->Curr; } else { e.Top = e.Curr; e.Bot = e.Next->Curr; } SetDx(e); e.PolyTyp = Pt; } //------------------------------------------------------------------------------ TEdge* RemoveEdge(TEdge* e) { //removes e from double_linked_list (but without removing from memory) e->Prev->Next = e->Next; e->Next->Prev = e->Prev; TEdge* result = e->Next; e->Prev = 0; //flag as removed (see ClipperBase.Clear) return result; } //------------------------------------------------------------------------------ inline void ReverseHorizontal(TEdge &e) { //swap horizontal edges' Top and Bottom x's so they follow the natural //progression of the bounds - ie so their xbots will align with the //adjoining lower edge. [Helpful in the ProcessHorizontal() method.] std::swap(e.Top.X, e.Bot.X); #ifdef use_xyz std::swap(e.Top.Z, e.Bot.Z); #endif } //------------------------------------------------------------------------------ void SwapPoints(IntPoint &pt1, IntPoint &pt2) { IntPoint tmp = pt1; pt1 = pt2; pt2 = tmp; } //------------------------------------------------------------------------------ bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a, IntPoint pt2b, IntPoint &pt1, IntPoint &pt2) { //precondition: segments are Collinear. if (Abs(pt1a.X - pt1b.X) > Abs(pt1a.Y - pt1b.Y)) { if (pt1a.X > pt1b.X) SwapPoints(pt1a, pt1b); if (pt2a.X > pt2b.X) SwapPoints(pt2a, pt2b); if (pt1a.X > pt2a.X) pt1 = pt1a; else pt1 = pt2a; if (pt1b.X < pt2b.X) pt2 = pt1b; else pt2 = pt2b; return pt1.X < pt2.X; } else { if (pt1a.Y < pt1b.Y) SwapPoints(pt1a, pt1b); if (pt2a.Y < pt2b.Y) SwapPoints(pt2a, pt2b); if (pt1a.Y < pt2a.Y) pt1 = pt1a; else pt1 = pt2a; if (pt1b.Y > pt2b.Y) pt2 = pt1b; else pt2 = pt2b; return pt1.Y > pt2.Y; } } //------------------------------------------------------------------------------ bool FirstIsBottomPt(const OutPt* btmPt1, const OutPt* btmPt2) { OutPt *p = btmPt1->Prev; while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Prev; double dx1p = std::fabs(GetDx(btmPt1->Pt, p->Pt)); p = btmPt1->Next; while ((p->Pt == btmPt1->Pt) && (p != btmPt1)) p = p->Next; double dx1n = std::fabs(GetDx(btmPt1->Pt, p->Pt)); p = btmPt2->Prev; while ((p->Pt == btmPt2->Pt) && (p != btmPt2)) p = p->Prev; double dx2p = std::fabs(GetDx(btmPt2->Pt, p->Pt)); p = btmPt2->Next; while ((p->Pt == btmPt2->Pt) && (p != btmPt2)) p = p->Next; double dx2n = std::fabs(GetDx(btmPt2->Pt, p->Pt)); return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n); } //------------------------------------------------------------------------------ OutPt* GetBottomPt(OutPt *pp) { OutPt* dups = 0; OutPt* p = pp->Next; while (p != pp) { if (p->Pt.Y > pp->Pt.Y) { pp = p; dups = 0; } else if (p->Pt.Y == pp->Pt.Y && p->Pt.X <= pp->Pt.X) { if (p->Pt.X < pp->Pt.X) { dups = 0; pp = p; } else { if (p->Next != pp && p->Prev != pp) dups = p; } } p = p->Next; } if (dups) { //there appears to be at least 2 vertices at BottomPt so ... while (dups != p) { if (!FirstIsBottomPt(p, dups)) pp = dups; dups = dups->Next; while (dups->Pt != pp->Pt) dups = dups->Next; } } return pp; } //------------------------------------------------------------------------------ bool Pt2IsBetweenPt1AndPt3(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3) { if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2)) return false; else if (pt1.X != pt3.X) return (pt2.X > pt1.X) == (pt2.X < pt3.X); else return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y); } //------------------------------------------------------------------------------ bool HorzSegmentsOverlap(cInt seg1a, cInt seg1b, cInt seg2a, cInt seg2b) { if (seg1a > seg1b) std::swap(seg1a, seg1b); if (seg2a > seg2b) std::swap(seg2a, seg2b); return (seg1a < seg2b) && (seg2a < seg1b); } //------------------------------------------------------------------------------ // ClipperBase class methods ... //------------------------------------------------------------------------------ ClipperBase::ClipperBase() //constructor { m_CurrentLM = m_MinimaList.begin(); //begin() == end() here m_UseFullRange = false; } //------------------------------------------------------------------------------ ClipperBase::~ClipperBase() //destructor { Clear(); } //------------------------------------------------------------------------------ void RangeTest(const IntPoint& Pt, bool& useFullRange) { if (useFullRange) { if (Pt.X > hiRange || Pt.Y > hiRange || -Pt.X > hiRange || -Pt.Y > hiRange) throw "Coordinate outside allowed range"; } else if (Pt.X > loRange|| Pt.Y > loRange || -Pt.X > loRange || -Pt.Y > loRange) { useFullRange = true; RangeTest(Pt, useFullRange); } } //------------------------------------------------------------------------------ TEdge* FindNextLocMin(TEdge* E) { for (;;) { while (E->Bot != E->Prev->Bot || E->Curr == E->Top) E = E->Next; if (!IsHorizontal(*E) && !IsHorizontal(*E->Prev)) break; while (IsHorizontal(*E->Prev)) E = E->Prev; TEdge* E2 = E; while (IsHorizontal(*E)) E = E->Next; if (E->Top.Y == E->Prev->Bot.Y) continue; //ie just an intermediate horz. if (E2->Prev->Bot.X < E->Bot.X) E = E2; break; } return E; } //------------------------------------------------------------------------------ TEdge* ClipperBase::ProcessBound(TEdge* E, bool NextIsForward) { TEdge *Result = E; TEdge *Horz = 0; if (E->OutIdx == Skip) { //if edges still remain in the current bound beyond the skip edge then //create another LocMin and call ProcessBound once more if (NextIsForward) { while (E->Top.Y == E->Next->Bot.Y) E = E->Next; //don't include top horizontals when parsing a bound a second time, //they will be contained in the opposite bound ... while (E != Result && IsHorizontal(*E)) E = E->Prev; } else { while (E->Top.Y == E->Prev->Bot.Y) E = E->Prev; while (E != Result && IsHorizontal(*E)) E = E->Next; } if (E == Result) { if (NextIsForward) Result = E->Next; else Result = E->Prev; } else { //there are more edges in the bound beyond result starting with E if (NextIsForward) E = Result->Next; else E = Result->Prev; MinimaList::value_type locMin; locMin.Y = E->Bot.Y; locMin.LeftBound = 0; locMin.RightBound = E; E->WindDelta = 0; Result = ProcessBound(E, NextIsForward); m_MinimaList.push_back(locMin); } return Result; } TEdge *EStart; if (IsHorizontal(*E)) { //We need to be careful with open paths because this may not be a //true local minima (ie E may be following a skip edge). //Also, consecutive horz. edges may start heading left before going right. if (NextIsForward) EStart = E->Prev; else EStart = E->Next; if (IsHorizontal(*EStart)) //ie an adjoining horizontal skip edge { if (EStart->Bot.X != E->Bot.X && EStart->Top.X != E->Bot.X) ReverseHorizontal(*E); } else if (EStart->Bot.X != E->Bot.X) ReverseHorizontal(*E); } EStart = E; if (NextIsForward) { while (Result->Top.Y == Result->Next->Bot.Y && Result->Next->OutIdx != Skip) Result = Result->Next; if (IsHorizontal(*Result) && Result->Next->OutIdx != Skip) { //nb: at the top of a bound, horizontals are added to the bound //only when the preceding edge attaches to the horizontal's left vertex //unless a Skip edge is encountered when that becomes the top divide Horz = Result; while (IsHorizontal(*Horz->Prev)) Horz = Horz->Prev; if (Horz->Prev->Top.X > Result->Next->Top.X) Result = Horz->Prev; } while (E != Result) { E->NextInLML = E->Next; if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E); E = E->Next; } if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E); Result = Result->Next; //move to the edge just beyond current bound } else { while (Result->Top.Y == Result->Prev->Bot.Y && Result->Prev->OutIdx != Skip) Result = Result->Prev; if (IsHorizontal(*Result) && Result->Prev->OutIdx != Skip) { Horz = Result; while (IsHorizontal(*Horz->Next)) Horz = Horz->Next; if (Horz->Next->Top.X == Result->Prev->Top.X || Horz->Next->Top.X > Result->Prev->Top.X) Result = Horz->Next; } while (E != Result) { E->NextInLML = E->Prev; if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X) ReverseHorizontal(*E); E = E->Prev; } if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X) ReverseHorizontal(*E); Result = Result->Prev; //move to the edge just beyond current bound } return Result; } //------------------------------------------------------------------------------ bool ClipperBase::AddPath(const Path &pg, PolyType PolyTyp, bool Closed) { #ifdef use_lines if (!Closed && PolyTyp == ptClip) throw clipperException("AddPath: Open paths must be subject."); #else if (!Closed) throw clipperException("AddPath: Open paths have been disabled."); #endif int highI = (int)pg.size() -1; if (Closed) while (highI > 0 && (pg[highI] == pg[0])) --highI; while (highI > 0 && (pg[highI] == pg[highI -1])) --highI; if ((Closed && highI < 2) || (!Closed && highI < 1)) return false; //create a new edge array ... TEdge *edges = new TEdge [highI +1]; bool IsFlat = true; //1. Basic (first) edge initialization ... try { edges[1].Curr = pg[1]; RangeTest(pg[0], m_UseFullRange); RangeTest(pg[highI], m_UseFullRange); InitEdge(&edges[0], &edges[1], &edges[highI], pg[0]); InitEdge(&edges[highI], &edges[0], &edges[highI-1], pg[highI]); for (int i = highI - 1; i >= 1; --i) { RangeTest(pg[i], m_UseFullRange); InitEdge(&edges[i], &edges[i+1], &edges[i-1], pg[i]); } } catch(...) { delete [] edges; throw; //range test fails } TEdge *eStart = &edges[0]; //2. Remove duplicate vertices, and (when closed) collinear edges ... TEdge *E = eStart, *eLoopStop = eStart; for (;;) { //nb: allows matching start and end points when not Closed ... if (E->Curr == E->Next->Curr && (Closed || E->Next != eStart)) { if (E == E->Next) break; if (E == eStart) eStart = E->Next; E = RemoveEdge(E); eLoopStop = E; continue; } if (E->Prev == E->Next) break; //only two vertices else if (Closed && SlopesEqual(E->Prev->Curr, E->Curr, E->Next->Curr, m_UseFullRange) && (!m_PreserveCollinear || !Pt2IsBetweenPt1AndPt3(E->Prev->Curr, E->Curr, E->Next->Curr))) { //Collinear edges are allowed for open paths but in closed paths //the default is to merge adjacent collinear edges into a single edge. //However, if the PreserveCollinear property is enabled, only overlapping //collinear edges (ie spikes) will be removed from closed paths. if (E == eStart) eStart = E->Next; E = RemoveEdge(E); E = E->Prev; eLoopStop = E; continue; } E = E->Next; if ((E == eLoopStop) || (!Closed && E->Next == eStart)) break; } if ((!Closed && (E == E->Next)) || (Closed && (E->Prev == E->Next))) { delete [] edges; return false; } if (!Closed) { m_HasOpenPaths = true; eStart->Prev->OutIdx = Skip; } //3. Do second stage of edge initialization ... E = eStart; do { InitEdge2(*E, PolyTyp); E = E->Next; if (IsFlat && E->Curr.Y != eStart->Curr.Y) IsFlat = false; } while (E != eStart); //4. Finally, add edge bounds to LocalMinima list ... //Totally flat paths must be handled differently when adding them //to LocalMinima list to avoid endless loops etc ... if (IsFlat) { if (Closed) { delete [] edges; return false; } E->Prev->OutIdx = Skip; MinimaList::value_type locMin; locMin.Y = E->Bot.Y; locMin.LeftBound = 0; locMin.RightBound = E; locMin.RightBound->Side = esRight; locMin.RightBound->WindDelta = 0; for (;;) { if (E->Bot.X != E->Prev->Top.X) ReverseHorizontal(*E); if (E->Next->OutIdx == Skip) break; E->NextInLML = E->Next; E = E->Next; } m_MinimaList.push_back(locMin); m_edges.push_back(edges); return true; } m_edges.push_back(edges); bool leftBoundIsForward; TEdge* EMin = 0; //workaround to avoid an endless loop in the while loop below when //open paths have matching start and end points ... if (E->Prev->Bot == E->Prev->Top) E = E->Next; for (;;) { E = FindNextLocMin(E); if (E == EMin) break; else if (!EMin) EMin = E; //E and E.Prev now share a local minima (left aligned if horizontal). //Compare their slopes to find which starts which bound ... MinimaList::value_type locMin; locMin.Y = E->Bot.Y; if (E->Dx < E->Prev->Dx) { locMin.LeftBound = E->Prev; locMin.RightBound = E; leftBoundIsForward = false; //Q.nextInLML = Q.prev } else { locMin.LeftBound = E; locMin.RightBound = E->Prev; leftBoundIsForward = true; //Q.nextInLML = Q.next } locMin.LeftBound->Side = esLeft; locMin.RightBound->Side = esRight; if (!Closed) locMin.LeftBound->WindDelta = 0; else if (locMin.LeftBound->Next == locMin.RightBound) locMin.LeftBound->WindDelta = -1; else locMin.LeftBound->WindDelta = 1; locMin.RightBound->WindDelta = -locMin.LeftBound->WindDelta; E = ProcessBound(locMin.LeftBound, leftBoundIsForward); if (E->OutIdx == Skip) E = ProcessBound(E, leftBoundIsForward); TEdge* E2 = ProcessBound(locMin.RightBound, !leftBoundIsForward); if (E2->OutIdx == Skip) E2 = ProcessBound(E2, !leftBoundIsForward); if (locMin.LeftBound->OutIdx == Skip) locMin.LeftBound = 0; else if (locMin.RightBound->OutIdx == Skip) locMin.RightBound = 0; m_MinimaList.push_back(locMin); if (!leftBoundIsForward) E = E2; } return true; } //------------------------------------------------------------------------------ bool ClipperBase::AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed) { bool result = false; for (Paths::size_type i = 0; i < ppg.size(); ++i) if (AddPath(ppg[i], PolyTyp, Closed)) result = true; return result; } //------------------------------------------------------------------------------ void ClipperBase::Clear() { DisposeLocalMinimaList(); for (EdgeList::size_type i = 0; i < m_edges.size(); ++i) { //for each edge array in turn, find the first used edge and //check for and remove any hiddenPts in each edge in the array. TEdge* edges = m_edges[i]; delete [] edges; } m_edges.clear(); m_UseFullRange = false; m_HasOpenPaths = false; } //------------------------------------------------------------------------------ void ClipperBase::Reset() { m_CurrentLM = m_MinimaList.begin(); if (m_CurrentLM == m_MinimaList.end()) return; //ie nothing to process std::sort(m_MinimaList.begin(), m_MinimaList.end(), LocMinSorter()); //reset all edges ... for (MinimaList::iterator lm = m_MinimaList.begin(); lm != m_MinimaList.end(); ++lm) { TEdge* e = lm->LeftBound; if (e) { e->Curr = e->Bot; e->Side = esLeft; e->OutIdx = Unassigned; } e = lm->RightBound; if (e) { e->Curr = e->Bot; e->Side = esRight; e->OutIdx = Unassigned; } } } //------------------------------------------------------------------------------ void ClipperBase::DisposeLocalMinimaList() { m_MinimaList.clear(); m_CurrentLM = m_MinimaList.begin(); } //------------------------------------------------------------------------------ void ClipperBase::PopLocalMinima() { if (m_CurrentLM == m_MinimaList.end()) return; ++m_CurrentLM; } //------------------------------------------------------------------------------ IntRect ClipperBase::GetBounds() { IntRect result; MinimaList::iterator lm = m_MinimaList.begin(); if (lm == m_MinimaList.end()) { result.left = result.top = result.right = result.bottom = 0; return result; } result.left = lm->LeftBound->Bot.X; result.top = lm->LeftBound->Bot.Y; result.right = lm->LeftBound->Bot.X; result.bottom = lm->LeftBound->Bot.Y; while (lm != m_MinimaList.end()) { result.bottom = std::max(result.bottom, lm->LeftBound->Bot.Y); TEdge* e = lm->LeftBound; for (;;) { TEdge* bottomE = e; while (e->NextInLML) { if (e->Bot.X < result.left) result.left = e->Bot.X; if (e->Bot.X > result.right) result.right = e->Bot.X; e = e->NextInLML; } result.left = std::min(result.left, e->Bot.X); result.right = std::max(result.right, e->Bot.X); result.left = std::min(result.left, e->Top.X); result.right = std::max(result.right, e->Top.X); result.top = std::min(result.top, e->Top.Y); if (bottomE == lm->LeftBound) e = lm->RightBound; else break; } ++lm; } return result; } //------------------------------------------------------------------------------ // TClipper methods ... //------------------------------------------------------------------------------ Clipper::Clipper(int initOptions) : ClipperBase() //constructor { m_ActiveEdges = 0; m_SortedEdges = 0; m_ExecuteLocked = false; m_UseFullRange = false; m_ReverseOutput = ((initOptions & ioReverseSolution) != 0); m_StrictSimple = ((initOptions & ioStrictlySimple) != 0); m_PreserveCollinear = ((initOptions & ioPreserveCollinear) != 0); m_HasOpenPaths = false; #ifdef use_xyz m_ZFill = 0; #endif } //------------------------------------------------------------------------------ Clipper::~Clipper() //destructor { Clear(); } //------------------------------------------------------------------------------ #ifdef use_xyz void Clipper::ZFillFunction(ZFillCallback zFillFunc) { m_ZFill = zFillFunc; } //------------------------------------------------------------------------------ #endif void Clipper::Reset() { ClipperBase::Reset(); m_Scanbeam = ScanbeamList(); m_Maxima = MaximaList(); m_ActiveEdges = 0; m_SortedEdges = 0; for (MinimaList::iterator lm = m_MinimaList.begin(); lm != m_MinimaList.end(); ++lm) InsertScanbeam(lm->Y); } //------------------------------------------------------------------------------ bool Clipper::Execute(ClipType clipType, Paths &solution, PolyFillType fillType) { return Execute(clipType, solution, fillType, fillType); } //------------------------------------------------------------------------------ bool Clipper::Execute(ClipType clipType, PolyTree &polytree, PolyFillType fillType) { return Execute(clipType, polytree, fillType, fillType); } //------------------------------------------------------------------------------ bool Clipper::Execute(ClipType clipType, Paths &solution, PolyFillType subjFillType, PolyFillType clipFillType) { if( m_ExecuteLocked ) return false; if (m_HasOpenPaths) throw clipperException("Error: PolyTree struct is needed for open path clipping."); m_ExecuteLocked = true; solution.resize(0); m_SubjFillType = subjFillType; m_ClipFillType = clipFillType; m_ClipType = clipType; m_UsingPolyTree = false; bool succeeded = ExecuteInternal(); if (succeeded) BuildResult(solution); DisposeAllOutRecs(); m_ExecuteLocked = false; return succeeded; } //------------------------------------------------------------------------------ bool Clipper::Execute(ClipType clipType, PolyTree& polytree, PolyFillType subjFillType, PolyFillType clipFillType) { if( m_ExecuteLocked ) return false; m_ExecuteLocked = true; m_SubjFillType = subjFillType; m_ClipFillType = clipFillType; m_ClipType = clipType; m_UsingPolyTree = true; bool succeeded = ExecuteInternal(); if (succeeded) BuildResult2(polytree); DisposeAllOutRecs(); m_ExecuteLocked = false; return succeeded; } //------------------------------------------------------------------------------ void Clipper::FixHoleLinkage(OutRec &outrec) { //skip OutRecs that (a) contain outermost polygons or //(b) already have the correct owner/child linkage ... if (!outrec.FirstLeft || (outrec.IsHole != outrec.FirstLeft->IsHole && outrec.FirstLeft->Pts)) return; OutRec* orfl = outrec.FirstLeft; while (orfl && ((orfl->IsHole == outrec.IsHole) || !orfl->Pts)) orfl = orfl->FirstLeft; outrec.FirstLeft = orfl; } //------------------------------------------------------------------------------ bool Clipper::ExecuteInternal() { bool succeeded = true; try { Reset(); if (m_CurrentLM == m_MinimaList.end()) return true; cInt botY = PopScanbeam(); do { InsertLocalMinimaIntoAEL(botY); ProcessHorizontals(); ClearGhostJoins(); if (m_Scanbeam.empty()) break; cInt topY = PopScanbeam(); succeeded = ProcessIntersections(topY); if (!succeeded) break; ProcessEdgesAtTopOfScanbeam(topY); botY = topY; } while (!m_Scanbeam.empty() || m_CurrentLM != m_MinimaList.end()); } catch(...) { succeeded = false; } if (succeeded) { //fix orientations ... for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) { OutRec *outRec = m_PolyOuts[i]; if (!outRec->Pts || outRec->IsOpen) continue; if ((outRec->IsHole ^ m_ReverseOutput) == (Area(*outRec) > 0)) ReversePolyPtLinks(outRec->Pts); } if (!m_Joins.empty()) JoinCommonEdges(); //unfortunately FixupOutPolygon() must be done after JoinCommonEdges() for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) { OutRec *outRec = m_PolyOuts[i]; if (!outRec->Pts) continue; if (outRec->IsOpen) FixupOutPolyline(*outRec); else FixupOutPolygon(*outRec); } if (m_StrictSimple) DoSimplePolygons(); } ClearJoins(); ClearGhostJoins(); return succeeded; } //------------------------------------------------------------------------------ void Clipper::InsertScanbeam(const cInt Y) { m_Scanbeam.push(Y); } //------------------------------------------------------------------------------ cInt Clipper::PopScanbeam() { const cInt Y = m_Scanbeam.top(); m_Scanbeam.pop(); while (!m_Scanbeam.empty() && Y == m_Scanbeam.top()) { m_Scanbeam.pop(); } // Pop duplicates. return Y; } //------------------------------------------------------------------------------ void Clipper::DisposeAllOutRecs(){ for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) DisposeOutRec(i); m_PolyOuts.clear(); } //------------------------------------------------------------------------------ void Clipper::DisposeOutRec(PolyOutList::size_type index) { OutRec *outRec = m_PolyOuts[index]; if (outRec->Pts) DisposeOutPts(outRec->Pts); delete outRec; m_PolyOuts[index] = 0; } //------------------------------------------------------------------------------ void Clipper::SetWindingCount(TEdge &edge) const { TEdge *e = edge.PrevInAEL; //find the edge of the same polytype that immediately preceeds 'edge' in AEL while (e && ((e->PolyTyp != edge.PolyTyp) || (e->WindDelta == 0))) e = e->PrevInAEL; if (!e) { edge.WindCnt = (edge.WindDelta == 0 ? 1 : edge.WindDelta); edge.WindCnt2 = 0; e = m_ActiveEdges; //ie get ready to calc WindCnt2 } else if (edge.WindDelta == 0 && m_ClipType != ctUnion) { edge.WindCnt = 1; edge.WindCnt2 = e->WindCnt2; e = e->NextInAEL; //ie get ready to calc WindCnt2 } else if (IsEvenOddFillType(edge)) { //EvenOdd filling ... if (edge.WindDelta == 0) { //are we inside a subj polygon ... bool Inside = true; TEdge *e2 = e->PrevInAEL; while (e2) { if (e2->PolyTyp == e->PolyTyp && e2->WindDelta != 0) Inside = !Inside; e2 = e2->PrevInAEL; } edge.WindCnt = (Inside ? 0 : 1); } else { edge.WindCnt = edge.WindDelta; } edge.WindCnt2 = e->WindCnt2; e = e->NextInAEL; //ie get ready to calc WindCnt2 } else { //nonZero, Positive or Negative filling ... if (e->WindCnt * e->WindDelta < 0) { //prev edge is 'decreasing' WindCount (WC) toward zero //so we're outside the previous polygon ... if (Abs(e->WindCnt) > 1) { //outside prev poly but still inside another. //when reversing direction of prev poly use the same WC if (e->WindDelta * edge.WindDelta < 0) edge.WindCnt = e->WindCnt; //otherwise continue to 'decrease' WC ... else edge.WindCnt = e->WindCnt + edge.WindDelta; } else //now outside all polys of same polytype so set own WC ... edge.WindCnt = (edge.WindDelta == 0 ? 1 : edge.WindDelta); } else { //prev edge is 'increasing' WindCount (WC) away from zero //so we're inside the previous polygon ... if (edge.WindDelta == 0) edge.WindCnt = (e->WindCnt < 0 ? e->WindCnt - 1 : e->WindCnt + 1); //if wind direction is reversing prev then use same WC else if (e->WindDelta * edge.WindDelta < 0) edge.WindCnt = e->WindCnt; //otherwise add to WC ... else edge.WindCnt = e->WindCnt + edge.WindDelta; } edge.WindCnt2 = e->WindCnt2; e = e->NextInAEL; //ie get ready to calc WindCnt2 } //update WindCnt2 ... if (IsEvenOddAltFillType(edge)) { //EvenOdd filling ... while (e != &edge) { if (e->WindDelta != 0) edge.WindCnt2 = (edge.WindCnt2 == 0 ? 1 : 0); e = e->NextInAEL; } } else { //nonZero, Positive or Negative filling ... while ( e != &edge ) { edge.WindCnt2 += e->WindDelta; e = e->NextInAEL; } } } //------------------------------------------------------------------------------ bool Clipper::IsEvenOddFillType(const TEdge& edge) const { if (edge.PolyTyp == ptSubject) return m_SubjFillType == pftEvenOdd; else return m_ClipFillType == pftEvenOdd; } //------------------------------------------------------------------------------ bool Clipper::IsEvenOddAltFillType(const TEdge& edge) const { if (edge.PolyTyp == ptSubject) return m_ClipFillType == pftEvenOdd; else return m_SubjFillType == pftEvenOdd; } //------------------------------------------------------------------------------ bool Clipper::IsContributing(const TEdge& edge) const { PolyFillType pft, pft2; if (edge.PolyTyp == ptSubject) { pft = m_SubjFillType; pft2 = m_ClipFillType; } else { pft = m_ClipFillType; pft2 = m_SubjFillType; } switch(pft) { case pftEvenOdd: //return false if a subj line has been flagged as inside a subj polygon if (edge.WindDelta == 0 && edge.WindCnt != 1) return false; break; case pftNonZero: if (Abs(edge.WindCnt) != 1) return false; break; case pftPositive: if (edge.WindCnt != 1) return false; break; default: //pftNegative if (edge.WindCnt != -1) return false; } switch(m_ClipType) { case ctIntersection: switch(pft2) { case pftEvenOdd: case pftNonZero: return (edge.WindCnt2 != 0); case pftPositive: return (edge.WindCnt2 > 0); default: return (edge.WindCnt2 < 0); } break; case ctUnion: switch(pft2) { case pftEvenOdd: case pftNonZero: return (edge.WindCnt2 == 0); case pftPositive: return (edge.WindCnt2 <= 0); default: return (edge.WindCnt2 >= 0); } break; case ctDifference: if (edge.PolyTyp == ptSubject) switch(pft2) { case pftEvenOdd: case pftNonZero: return (edge.WindCnt2 == 0); case pftPositive: return (edge.WindCnt2 <= 0); default: return (edge.WindCnt2 >= 0); } else switch(pft2) { case pftEvenOdd: case pftNonZero: return (edge.WindCnt2 != 0); case pftPositive: return (edge.WindCnt2 > 0); default: return (edge.WindCnt2 < 0); } break; case ctXor: if (edge.WindDelta == 0) //XOr always contributing unless open switch(pft2) { case pftEvenOdd: case pftNonZero: return (edge.WindCnt2 == 0); case pftPositive: return (edge.WindCnt2 <= 0); default: return (edge.WindCnt2 >= 0); } else return true; break; default: return true; } } //------------------------------------------------------------------------------ OutPt* Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt) { OutPt* result; TEdge *e, *prevE; if (IsHorizontal(*e2) || ( e1->Dx > e2->Dx )) { result = AddOutPt(e1, Pt); e2->OutIdx = e1->OutIdx; e1->Side = esLeft; e2->Side = esRight; e = e1; if (e->PrevInAEL == e2) prevE = e2->PrevInAEL; else prevE = e->PrevInAEL; } else { result = AddOutPt(e2, Pt); e1->OutIdx = e2->OutIdx; e1->Side = esRight; e2->Side = esLeft; e = e2; if (e->PrevInAEL == e1) prevE = e1->PrevInAEL; else prevE = e->PrevInAEL; } if (prevE && prevE->OutIdx >= 0 && (TopX(*prevE, Pt.Y) == TopX(*e, Pt.Y)) && SlopesEqual(*e, *prevE, m_UseFullRange) && (e->WindDelta != 0) && (prevE->WindDelta != 0)) { OutPt* outPt = AddOutPt(prevE, Pt); AddJoin(result, outPt, e->Top); } return result; } //------------------------------------------------------------------------------ void Clipper::AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &Pt) { AddOutPt( e1, Pt ); if (e2->WindDelta == 0) AddOutPt(e2, Pt); if( e1->OutIdx == e2->OutIdx ) { e1->OutIdx = Unassigned; e2->OutIdx = Unassigned; } else if (e1->OutIdx < e2->OutIdx) AppendPolygon(e1, e2); else AppendPolygon(e2, e1); } //------------------------------------------------------------------------------ void Clipper::AddEdgeToSEL(TEdge *edge) { //SEL pointers in PEdge are reused to build a list of horizontal edges. //However, we don't need to worry about order with horizontal edge processing. if( !m_SortedEdges ) { m_SortedEdges = edge; edge->PrevInSEL = 0; edge->NextInSEL = 0; } else { edge->NextInSEL = m_SortedEdges; edge->PrevInSEL = 0; m_SortedEdges->PrevInSEL = edge; m_SortedEdges = edge; } } //------------------------------------------------------------------------------ void Clipper::CopyAELToSEL() { TEdge* e = m_ActiveEdges; m_SortedEdges = e; while ( e ) { e->PrevInSEL = e->PrevInAEL; e->NextInSEL = e->NextInAEL; e = e->NextInAEL; } } //------------------------------------------------------------------------------ void Clipper::AddJoin(OutPt *op1, OutPt *op2, const IntPoint &OffPt) { Join* j = new Join; j->OutPt1 = op1; j->OutPt2 = op2; j->OffPt = OffPt; m_Joins.push_back(j); } //------------------------------------------------------------------------------ void Clipper::ClearJoins() { for (JoinList::size_type i = 0; i < m_Joins.size(); i++) delete m_Joins[i]; m_Joins.resize(0); } //------------------------------------------------------------------------------ void Clipper::ClearGhostJoins() { for (JoinList::size_type i = 0; i < m_GhostJoins.size(); i++) delete m_GhostJoins[i]; m_GhostJoins.resize(0); } //------------------------------------------------------------------------------ void Clipper::AddGhostJoin(OutPt *op, const IntPoint &OffPt) { Join* j = new Join; j->OutPt1 = op; j->OutPt2 = 0; j->OffPt = OffPt; m_GhostJoins.push_back(j); } //------------------------------------------------------------------------------ void Clipper::InsertLocalMinimaIntoAEL(const cInt botY) { while (m_CurrentLM != m_MinimaList.end() && (m_CurrentLM->Y == botY)) { TEdge* lb = m_CurrentLM->LeftBound; TEdge* rb = m_CurrentLM->RightBound; PopLocalMinima(); OutPt *Op1 = 0; if (!lb) { //nb: don't insert LB into either AEL or SEL InsertEdgeIntoAEL(rb, 0); SetWindingCount(*rb); if (IsContributing(*rb)) Op1 = AddOutPt(rb, rb->Bot); } else if (!rb) { InsertEdgeIntoAEL(lb, 0); SetWindingCount(*lb); if (IsContributing(*lb)) Op1 = AddOutPt(lb, lb->Bot); InsertScanbeam(lb->Top.Y); } else { InsertEdgeIntoAEL(lb, 0); InsertEdgeIntoAEL(rb, lb); SetWindingCount( *lb ); rb->WindCnt = lb->WindCnt; rb->WindCnt2 = lb->WindCnt2; if (IsContributing(*lb)) Op1 = AddLocalMinPoly(lb, rb, lb->Bot); InsertScanbeam(lb->Top.Y); } if (rb) { if(IsHorizontal(*rb)) AddEdgeToSEL(rb); else InsertScanbeam( rb->Top.Y ); } if (!lb || !rb) continue; //if any output polygons share an edge, they'll need joining later ... if (Op1 && IsHorizontal(*rb) && m_GhostJoins.size() > 0 && (rb->WindDelta != 0)) { for (JoinList::size_type i = 0; i < m_GhostJoins.size(); ++i) { Join* jr = m_GhostJoins[i]; //if the horizontal Rb and a 'ghost' horizontal overlap, then convert //the 'ghost' join to a real join ready for later ... if (HorzSegmentsOverlap(jr->OutPt1->Pt.X, jr->OffPt.X, rb->Bot.X, rb->Top.X)) AddJoin(jr->OutPt1, Op1, jr->OffPt); } } if (lb->OutIdx >= 0 && lb->PrevInAEL && lb->PrevInAEL->Curr.X == lb->Bot.X && lb->PrevInAEL->OutIdx >= 0 && SlopesEqual(*lb->PrevInAEL, *lb, m_UseFullRange) && (lb->WindDelta != 0) && (lb->PrevInAEL->WindDelta != 0)) { OutPt *Op2 = AddOutPt(lb->PrevInAEL, lb->Bot); AddJoin(Op1, Op2, lb->Top); } if(lb->NextInAEL != rb) { if (rb->OutIdx >= 0 && rb->PrevInAEL->OutIdx >= 0 && SlopesEqual(*rb->PrevInAEL, *rb, m_UseFullRange) && (rb->WindDelta != 0) && (rb->PrevInAEL->WindDelta != 0)) { OutPt *Op2 = AddOutPt(rb->PrevInAEL, rb->Bot); AddJoin(Op1, Op2, rb->Top); } TEdge* e = lb->NextInAEL; if (e) { while( e != rb ) { //nb: For calculating winding counts etc, IntersectEdges() assumes //that param1 will be to the Right of param2 ABOVE the intersection ... IntersectEdges(rb , e , lb->Curr); //order important here e = e->NextInAEL; } } } } } //------------------------------------------------------------------------------ void Clipper::DeleteFromAEL(TEdge *e) { TEdge* AelPrev = e->PrevInAEL; TEdge* AelNext = e->NextInAEL; if( !AelPrev && !AelNext && (e != m_ActiveEdges) ) return; //already deleted if( AelPrev ) AelPrev->NextInAEL = AelNext; else m_ActiveEdges = AelNext; if( AelNext ) AelNext->PrevInAEL = AelPrev; e->NextInAEL = 0; e->PrevInAEL = 0; } //------------------------------------------------------------------------------ void Clipper::DeleteFromSEL(TEdge *e) { TEdge* SelPrev = e->PrevInSEL; TEdge* SelNext = e->NextInSEL; if( !SelPrev && !SelNext && (e != m_SortedEdges) ) return; //already deleted if( SelPrev ) SelPrev->NextInSEL = SelNext; else m_SortedEdges = SelNext; if( SelNext ) SelNext->PrevInSEL = SelPrev; e->NextInSEL = 0; e->PrevInSEL = 0; } //------------------------------------------------------------------------------ #ifdef use_xyz void Clipper::SetZ(IntPoint& pt, TEdge& e1, TEdge& e2) { if (pt.Z != 0 || !m_ZFill) return; else if (pt == e1.Bot) pt.Z = e1.Bot.Z; else if (pt == e1.Top) pt.Z = e1.Top.Z; else if (pt == e2.Bot) pt.Z = e2.Bot.Z; else if (pt == e2.Top) pt.Z = e2.Top.Z; else (*m_ZFill)(e1.Bot, e1.Top, e2.Bot, e2.Top, pt); } //------------------------------------------------------------------------------ #endif void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt) { bool e1Contributing = ( e1->OutIdx >= 0 ); bool e2Contributing = ( e2->OutIdx >= 0 ); #ifdef use_xyz SetZ(Pt, *e1, *e2); #endif #ifdef use_lines //if either edge is on an OPEN path ... if (e1->WindDelta == 0 || e2->WindDelta == 0) { //ignore subject-subject open path intersections UNLESS they //are both open paths, AND they are both 'contributing maximas' ... if (e1->WindDelta == 0 && e2->WindDelta == 0) return; //if intersecting a subj line with a subj poly ... else if (e1->PolyTyp == e2->PolyTyp && e1->WindDelta != e2->WindDelta && m_ClipType == ctUnion) { if (e1->WindDelta == 0) { if (e2Contributing) { AddOutPt(e1, Pt); if (e1Contributing) e1->OutIdx = Unassigned; } } else { if (e1Contributing) { AddOutPt(e2, Pt); if (e2Contributing) e2->OutIdx = Unassigned; } } } else if (e1->PolyTyp != e2->PolyTyp) { //toggle subj open path OutIdx on/off when Abs(clip.WndCnt) == 1 ... if ((e1->WindDelta == 0) && abs(e2->WindCnt) == 1 && (m_ClipType != ctUnion || e2->WindCnt2 == 0)) { AddOutPt(e1, Pt); if (e1Contributing) e1->OutIdx = Unassigned; } else if ((e2->WindDelta == 0) && (abs(e1->WindCnt) == 1) && (m_ClipType != ctUnion || e1->WindCnt2 == 0)) { AddOutPt(e2, Pt); if (e2Contributing) e2->OutIdx = Unassigned; } } return; } #endif //update winding counts... //assumes that e1 will be to the Right of e2 ABOVE the intersection if ( e1->PolyTyp == e2->PolyTyp ) { if ( IsEvenOddFillType( *e1) ) { int oldE1WindCnt = e1->WindCnt; e1->WindCnt = e2->WindCnt; e2->WindCnt = oldE1WindCnt; } else { if (e1->WindCnt + e2->WindDelta == 0 ) e1->WindCnt = -e1->WindCnt; else e1->WindCnt += e2->WindDelta; if ( e2->WindCnt - e1->WindDelta == 0 ) e2->WindCnt = -e2->WindCnt; else e2->WindCnt -= e1->WindDelta; } } else { if (!IsEvenOddFillType(*e2)) e1->WindCnt2 += e2->WindDelta; else e1->WindCnt2 = ( e1->WindCnt2 == 0 ) ? 1 : 0; if (!IsEvenOddFillType(*e1)) e2->WindCnt2 -= e1->WindDelta; else e2->WindCnt2 = ( e2->WindCnt2 == 0 ) ? 1 : 0; } PolyFillType e1FillType, e2FillType, e1FillType2, e2FillType2; if (e1->PolyTyp == ptSubject) { e1FillType = m_SubjFillType; e1FillType2 = m_ClipFillType; } else { e1FillType = m_ClipFillType; e1FillType2 = m_SubjFillType; } if (e2->PolyTyp == ptSubject) { e2FillType = m_SubjFillType; e2FillType2 = m_ClipFillType; } else { e2FillType = m_ClipFillType; e2FillType2 = m_SubjFillType; } cInt e1Wc, e2Wc; switch (e1FillType) { case pftPositive: e1Wc = e1->WindCnt; break; case pftNegative: e1Wc = -e1->WindCnt; break; default: e1Wc = Abs(e1->WindCnt); } switch(e2FillType) { case pftPositive: e2Wc = e2->WindCnt; break; case pftNegative: e2Wc = -e2->WindCnt; break; default: e2Wc = Abs(e2->WindCnt); } if ( e1Contributing && e2Contributing ) { if ((e1Wc != 0 && e1Wc != 1) || (e2Wc != 0 && e2Wc != 1) || (e1->PolyTyp != e2->PolyTyp && m_ClipType != ctXor) ) { AddLocalMaxPoly(e1, e2, Pt); } else { AddOutPt(e1, Pt); AddOutPt(e2, Pt); SwapSides( *e1 , *e2 ); SwapPolyIndexes( *e1 , *e2 ); } } else if ( e1Contributing ) { if (e2Wc == 0 || e2Wc == 1) { AddOutPt(e1, Pt); SwapSides(*e1, *e2); SwapPolyIndexes(*e1, *e2); } } else if ( e2Contributing ) { if (e1Wc == 0 || e1Wc == 1) { AddOutPt(e2, Pt); SwapSides(*e1, *e2); SwapPolyIndexes(*e1, *e2); } } else if ( (e1Wc == 0 || e1Wc == 1) && (e2Wc == 0 || e2Wc == 1)) { //neither edge is currently contributing ... cInt e1Wc2, e2Wc2; switch (e1FillType2) { case pftPositive: e1Wc2 = e1->WindCnt2; break; case pftNegative : e1Wc2 = -e1->WindCnt2; break; default: e1Wc2 = Abs(e1->WindCnt2); } switch (e2FillType2) { case pftPositive: e2Wc2 = e2->WindCnt2; break; case pftNegative: e2Wc2 = -e2->WindCnt2; break; default: e2Wc2 = Abs(e2->WindCnt2); } if (e1->PolyTyp != e2->PolyTyp) { AddLocalMinPoly(e1, e2, Pt); } else if (e1Wc == 1 && e2Wc == 1) switch( m_ClipType ) { case ctIntersection: if (e1Wc2 > 0 && e2Wc2 > 0) AddLocalMinPoly(e1, e2, Pt); break; case ctUnion: if ( e1Wc2 <= 0 && e2Wc2 <= 0 ) AddLocalMinPoly(e1, e2, Pt); break; case ctDifference: if (((e1->PolyTyp == ptClip) && (e1Wc2 > 0) && (e2Wc2 > 0)) || ((e1->PolyTyp == ptSubject) && (e1Wc2 <= 0) && (e2Wc2 <= 0))) AddLocalMinPoly(e1, e2, Pt); break; case ctXor: AddLocalMinPoly(e1, e2, Pt); } else SwapSides( *e1, *e2 ); } } //------------------------------------------------------------------------------ void Clipper::SetHoleState(TEdge *e, OutRec *outrec) const { bool IsHole = false; TEdge *e2 = e->PrevInAEL; while (e2) { if (e2->OutIdx >= 0 && e2->WindDelta != 0) { IsHole = !IsHole; if (! outrec->FirstLeft) outrec->FirstLeft = m_PolyOuts[e2->OutIdx]; } e2 = e2->PrevInAEL; } if (IsHole) outrec->IsHole = true; } //------------------------------------------------------------------------------ OutRec* GetLowermostRec(OutRec *outRec1, OutRec *outRec2) { //work out which polygon fragment has the correct hole state ... if (!outRec1->BottomPt) outRec1->BottomPt = GetBottomPt(outRec1->Pts); if (!outRec2->BottomPt) outRec2->BottomPt = GetBottomPt(outRec2->Pts); OutPt *OutPt1 = outRec1->BottomPt; OutPt *OutPt2 = outRec2->BottomPt; if (OutPt1->Pt.Y > OutPt2->Pt.Y) return outRec1; else if (OutPt1->Pt.Y < OutPt2->Pt.Y) return outRec2; else if (OutPt1->Pt.X < OutPt2->Pt.X) return outRec1; else if (OutPt1->Pt.X > OutPt2->Pt.X) return outRec2; else if (OutPt1->Next == OutPt1) return outRec2; else if (OutPt2->Next == OutPt2) return outRec1; else if (FirstIsBottomPt(OutPt1, OutPt2)) return outRec1; else return outRec2; } //------------------------------------------------------------------------------ bool Param1RightOfParam2(OutRec* outRec1, OutRec* outRec2) { do { outRec1 = outRec1->FirstLeft; if (outRec1 == outRec2) return true; } while (outRec1); return false; } //------------------------------------------------------------------------------ OutRec* Clipper::GetOutRec(int Idx) { OutRec* outrec = m_PolyOuts[Idx]; while (outrec != m_PolyOuts[outrec->Idx]) outrec = m_PolyOuts[outrec->Idx]; return outrec; } //------------------------------------------------------------------------------ void Clipper::AppendPolygon(TEdge *e1, TEdge *e2) const { //get the start and ends of both output polygons ... OutRec *outRec1 = m_PolyOuts[e1->OutIdx]; OutRec *outRec2 = m_PolyOuts[e2->OutIdx]; OutRec *holeStateRec; if (Param1RightOfParam2(outRec1, outRec2)) holeStateRec = outRec2; else if (Param1RightOfParam2(outRec2, outRec1)) holeStateRec = outRec1; else holeStateRec = GetLowermostRec(outRec1, outRec2); //get the start and ends of both output polygons and //join e2 poly onto e1 poly and delete pointers to e2 ... OutPt* p1_lft = outRec1->Pts; OutPt* p1_rt = p1_lft->Prev; OutPt* p2_lft = outRec2->Pts; OutPt* p2_rt = p2_lft->Prev; EdgeSide Side; //join e2 poly onto e1 poly and delete pointers to e2 ... if( e1->Side == esLeft ) { if( e2->Side == esLeft ) { //z y x a b c ReversePolyPtLinks(p2_lft); p2_lft->Next = p1_lft; p1_lft->Prev = p2_lft; p1_rt->Next = p2_rt; p2_rt->Prev = p1_rt; outRec1->Pts = p2_rt; } else { //x y z a b c p2_rt->Next = p1_lft; p1_lft->Prev = p2_rt; p2_lft->Prev = p1_rt; p1_rt->Next = p2_lft; outRec1->Pts = p2_lft; } Side = esLeft; } else { if( e2->Side == esRight ) { //a b c z y x ReversePolyPtLinks(p2_lft); p1_rt->Next = p2_rt; p2_rt->Prev = p1_rt; p2_lft->Next = p1_lft; p1_lft->Prev = p2_lft; } else { //a b c x y z p1_rt->Next = p2_lft; p2_lft->Prev = p1_rt; p1_lft->Prev = p2_rt; p2_rt->Next = p1_lft; } Side = esRight; } outRec1->BottomPt = 0; if (holeStateRec == outRec2) { if (outRec2->FirstLeft != outRec1) outRec1->FirstLeft = outRec2->FirstLeft; outRec1->IsHole = outRec2->IsHole; } outRec2->Pts = 0; outRec2->BottomPt = 0; outRec2->FirstLeft = outRec1; int OKIdx = e1->OutIdx; int ObsoleteIdx = e2->OutIdx; e1->OutIdx = Unassigned; //nb: safe because we only get here via AddLocalMaxPoly e2->OutIdx = Unassigned; TEdge* e = m_ActiveEdges; while( e ) { if( e->OutIdx == ObsoleteIdx ) { e->OutIdx = OKIdx; e->Side = Side; break; } e = e->NextInAEL; } outRec2->Idx = outRec1->Idx; } //------------------------------------------------------------------------------ OutRec* Clipper::CreateOutRec() { OutRec* result = new OutRec; result->IsHole = false; result->IsOpen = false; result->FirstLeft = 0; result->Pts = 0; result->BottomPt = 0; result->PolyNd = 0; m_PolyOuts.push_back(result); result->Idx = (int)m_PolyOuts.size()-1; return result; } //------------------------------------------------------------------------------ OutPt* Clipper::AddOutPt(TEdge *e, const IntPoint &pt) { if( e->OutIdx < 0 ) { OutRec *outRec = CreateOutRec(); outRec->IsOpen = (e->WindDelta == 0); OutPt* newOp = new OutPt; outRec->Pts = newOp; newOp->Idx = outRec->Idx; newOp->Pt = pt; newOp->Next = newOp; newOp->Prev = newOp; if (!outRec->IsOpen) SetHoleState(e, outRec); e->OutIdx = outRec->Idx; return newOp; } else { OutRec *outRec = m_PolyOuts[e->OutIdx]; //OutRec.Pts is the 'Left-most' point & OutRec.Pts.Prev is the 'Right-most' OutPt* op = outRec->Pts; bool ToFront = (e->Side == esLeft); if (ToFront && (pt == op->Pt)) return op; else if (!ToFront && (pt == op->Prev->Pt)) return op->Prev; OutPt* newOp = new OutPt; newOp->Idx = outRec->Idx; newOp->Pt = pt; newOp->Next = op; newOp->Prev = op->Prev; newOp->Prev->Next = newOp; op->Prev = newOp; if (ToFront) outRec->Pts = newOp; return newOp; } } //------------------------------------------------------------------------------ OutPt* Clipper::GetLastOutPt(TEdge *e) { OutRec *outRec = m_PolyOuts[e->OutIdx]; if (e->Side == esLeft) return outRec->Pts; else return outRec->Pts->Prev; } //------------------------------------------------------------------------------ void Clipper::ProcessHorizontals() { TEdge* horzEdge = m_SortedEdges; while(horzEdge) { DeleteFromSEL(horzEdge); ProcessHorizontal(horzEdge); horzEdge = m_SortedEdges; } } //------------------------------------------------------------------------------ inline bool IsMinima(TEdge *e) { return e && (e->Prev->NextInLML != e) && (e->Next->NextInLML != e); } //------------------------------------------------------------------------------ inline bool IsMaxima(TEdge *e, const cInt Y) { return e && e->Top.Y == Y && !e->NextInLML; } //------------------------------------------------------------------------------ inline bool IsIntermediate(TEdge *e, const cInt Y) { return e->Top.Y == Y && e->NextInLML; } //------------------------------------------------------------------------------ TEdge *GetMaximaPair(TEdge *e) { TEdge* result = 0; if ((e->Next->Top == e->Top) && !e->Next->NextInLML) result = e->Next; else if ((e->Prev->Top == e->Top) && !e->Prev->NextInLML) result = e->Prev; if (result && (result->OutIdx == Skip || //result is false if both NextInAEL & PrevInAEL are nil & not horizontal ... (result->NextInAEL == result->PrevInAEL && !IsHorizontal(*result)))) return 0; return result; } //------------------------------------------------------------------------------ void Clipper::SwapPositionsInAEL(TEdge *Edge1, TEdge *Edge2) { //check that one or other edge hasn't already been removed from AEL ... if (Edge1->NextInAEL == Edge1->PrevInAEL || Edge2->NextInAEL == Edge2->PrevInAEL) return; if( Edge1->NextInAEL == Edge2 ) { TEdge* Next = Edge2->NextInAEL; if( Next ) Next->PrevInAEL = Edge1; TEdge* Prev = Edge1->PrevInAEL; if( Prev ) Prev->NextInAEL = Edge2; Edge2->PrevInAEL = Prev; Edge2->NextInAEL = Edge1; Edge1->PrevInAEL = Edge2; Edge1->NextInAEL = Next; } else if( Edge2->NextInAEL == Edge1 ) { TEdge* Next = Edge1->NextInAEL; if( Next ) Next->PrevInAEL = Edge2; TEdge* Prev = Edge2->PrevInAEL; if( Prev ) Prev->NextInAEL = Edge1; Edge1->PrevInAEL = Prev; Edge1->NextInAEL = Edge2; Edge2->PrevInAEL = Edge1; Edge2->NextInAEL = Next; } else { TEdge* Next = Edge1->NextInAEL; TEdge* Prev = Edge1->PrevInAEL; Edge1->NextInAEL = Edge2->NextInAEL; if( Edge1->NextInAEL ) Edge1->NextInAEL->PrevInAEL = Edge1; Edge1->PrevInAEL = Edge2->PrevInAEL; if( Edge1->PrevInAEL ) Edge1->PrevInAEL->NextInAEL = Edge1; Edge2->NextInAEL = Next; if( Edge2->NextInAEL ) Edge2->NextInAEL->PrevInAEL = Edge2; Edge2->PrevInAEL = Prev; if( Edge2->PrevInAEL ) Edge2->PrevInAEL->NextInAEL = Edge2; } if( !Edge1->PrevInAEL ) m_ActiveEdges = Edge1; else if( !Edge2->PrevInAEL ) m_ActiveEdges = Edge2; } //------------------------------------------------------------------------------ void Clipper::SwapPositionsInSEL(TEdge *Edge1, TEdge *Edge2) { if( !( Edge1->NextInSEL ) && !( Edge1->PrevInSEL ) ) return; if( !( Edge2->NextInSEL ) && !( Edge2->PrevInSEL ) ) return; if( Edge1->NextInSEL == Edge2 ) { TEdge* Next = Edge2->NextInSEL; if( Next ) Next->PrevInSEL = Edge1; TEdge* Prev = Edge1->PrevInSEL; if( Prev ) Prev->NextInSEL = Edge2; Edge2->PrevInSEL = Prev; Edge2->NextInSEL = Edge1; Edge1->PrevInSEL = Edge2; Edge1->NextInSEL = Next; } else if( Edge2->NextInSEL == Edge1 ) { TEdge* Next = Edge1->NextInSEL; if( Next ) Next->PrevInSEL = Edge2; TEdge* Prev = Edge2->PrevInSEL; if( Prev ) Prev->NextInSEL = Edge1; Edge1->PrevInSEL = Prev; Edge1->NextInSEL = Edge2; Edge2->PrevInSEL = Edge1; Edge2->NextInSEL = Next; } else { TEdge* Next = Edge1->NextInSEL; TEdge* Prev = Edge1->PrevInSEL; Edge1->NextInSEL = Edge2->NextInSEL; if( Edge1->NextInSEL ) Edge1->NextInSEL->PrevInSEL = Edge1; Edge1->PrevInSEL = Edge2->PrevInSEL; if( Edge1->PrevInSEL ) Edge1->PrevInSEL->NextInSEL = Edge1; Edge2->NextInSEL = Next; if( Edge2->NextInSEL ) Edge2->NextInSEL->PrevInSEL = Edge2; Edge2->PrevInSEL = Prev; if( Edge2->PrevInSEL ) Edge2->PrevInSEL->NextInSEL = Edge2; } if( !Edge1->PrevInSEL ) m_SortedEdges = Edge1; else if( !Edge2->PrevInSEL ) m_SortedEdges = Edge2; } //------------------------------------------------------------------------------ TEdge* GetNextInAEL(TEdge *e, Direction dir) { return dir == dLeftToRight ? e->NextInAEL : e->PrevInAEL; } //------------------------------------------------------------------------------ void GetHorzDirection(TEdge& HorzEdge, Direction& Dir, cInt& Left, cInt& Right) { if (HorzEdge.Bot.X < HorzEdge.Top.X) { Left = HorzEdge.Bot.X; Right = HorzEdge.Top.X; Dir = dLeftToRight; } else { Left = HorzEdge.Top.X; Right = HorzEdge.Bot.X; Dir = dRightToLeft; } } //------------------------------------------------------------------------ /******************************************************************************* * Notes: Horizontal edges (HEs) at scanline intersections (ie at the Top or * * Bottom of a scanbeam) are processed as if layered. The order in which HEs * * are processed doesn't matter. HEs intersect with other HE Bot.Xs only [#] * * (or they could intersect with Top.Xs only, ie EITHER Bot.Xs OR Top.Xs), * * and with other non-horizontal edges [*]. Once these intersections are * * processed, intermediate HEs then 'promote' the Edge above (NextInLML) into * * the AEL. These 'promoted' edges may in turn intersect [%] with other HEs. * *******************************************************************************/ void Clipper::ProcessHorizontal(TEdge *horzEdge) { Direction dir; cInt horzLeft, horzRight; bool IsOpen = (horzEdge->OutIdx >= 0 && m_PolyOuts[horzEdge->OutIdx]->IsOpen); GetHorzDirection(*horzEdge, dir, horzLeft, horzRight); TEdge* eLastHorz = horzEdge, *eMaxPair = 0; while (eLastHorz->NextInLML && IsHorizontal(*eLastHorz->NextInLML)) eLastHorz = eLastHorz->NextInLML; if (!eLastHorz->NextInLML) eMaxPair = GetMaximaPair(eLastHorz); MaximaList::const_iterator maxIt; MaximaList::const_reverse_iterator maxRit; if (!m_Maxima.empty()) { //get the first maxima in range (X) ... if (dir == dLeftToRight) { maxIt = m_Maxima.begin(); while (maxIt != m_Maxima.end() && *maxIt <= horzEdge->Bot.X) ++maxIt; if (maxIt != m_Maxima.end() && *maxIt >= eLastHorz->Top.X) maxIt = m_Maxima.end(); } else { maxRit = m_Maxima.rbegin(); while (maxRit != m_Maxima.rend() && *maxRit > horzEdge->Bot.X) ++maxRit; if (maxRit != m_Maxima.rend() && *maxRit <= eLastHorz->Top.X) maxRit = m_Maxima.rend(); } } OutPt* op1 = 0; for (;;) //loop through consec. horizontal edges { bool IsLastHorz = (horzEdge == eLastHorz); TEdge* e = GetNextInAEL(horzEdge, dir); while(e) { //this code block inserts extra coords into horizontal edges (in output //polygons) whereever maxima touch these horizontal edges. This helps //'simplifying' polygons (ie if the Simplify property is set). if (!m_Maxima.empty()) { if (dir == dLeftToRight) { while (maxIt != m_Maxima.end() && *maxIt < e->Curr.X) { if (horzEdge->OutIdx >= 0 && !IsOpen) AddOutPt(horzEdge, IntPoint(*maxIt, horzEdge->Bot.Y)); ++maxIt; } } else { while (maxRit != m_Maxima.rend() && *maxRit > e->Curr.X) { if (horzEdge->OutIdx >= 0 && !IsOpen) AddOutPt(horzEdge, IntPoint(*maxRit, horzEdge->Bot.Y)); ++maxRit; } } }; if ((dir == dLeftToRight && e->Curr.X > horzRight) || (dir == dRightToLeft && e->Curr.X < horzLeft)) break; //Also break if we've got to the end of an intermediate horizontal edge ... //nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal. if (e->Curr.X == horzEdge->Top.X && horzEdge->NextInLML && e->Dx < horzEdge->NextInLML->Dx) break; if (horzEdge->OutIdx >= 0 && !IsOpen) //note: may be done multiple times { op1 = AddOutPt(horzEdge, e->Curr); TEdge* eNextHorz = m_SortedEdges; while (eNextHorz) { if (eNextHorz->OutIdx >= 0 && HorzSegmentsOverlap(horzEdge->Bot.X, horzEdge->Top.X, eNextHorz->Bot.X, eNextHorz->Top.X)) { OutPt* op2 = GetLastOutPt(eNextHorz); AddJoin(op2, op1, eNextHorz->Top); } eNextHorz = eNextHorz->NextInSEL; } AddGhostJoin(op1, horzEdge->Bot); } //OK, so far we're still in range of the horizontal Edge but make sure //we're at the last of consec. horizontals when matching with eMaxPair if(e == eMaxPair && IsLastHorz) { if (horzEdge->OutIdx >= 0) AddLocalMaxPoly(horzEdge, eMaxPair, horzEdge->Top); DeleteFromAEL(horzEdge); DeleteFromAEL(eMaxPair); return; } if(dir == dLeftToRight) { IntPoint Pt = IntPoint(e->Curr.X, horzEdge->Curr.Y); IntersectEdges(horzEdge, e, Pt); } else { IntPoint Pt = IntPoint(e->Curr.X, horzEdge->Curr.Y); IntersectEdges( e, horzEdge, Pt); } TEdge* eNext = GetNextInAEL(e, dir); SwapPositionsInAEL( horzEdge, e ); e = eNext; } //end while(e) //Break out of loop if HorzEdge.NextInLML is not also horizontal ... if (!horzEdge->NextInLML || !IsHorizontal(*horzEdge->NextInLML)) break; UpdateEdgeIntoAEL(horzEdge); if (horzEdge->OutIdx >= 0) AddOutPt(horzEdge, horzEdge->Bot); GetHorzDirection(*horzEdge, dir, horzLeft, horzRight); } //end for (;;) if (horzEdge->OutIdx >= 0 && !op1) { op1 = GetLastOutPt(horzEdge); TEdge* eNextHorz = m_SortedEdges; while (eNextHorz) { if (eNextHorz->OutIdx >= 0 && HorzSegmentsOverlap(horzEdge->Bot.X, horzEdge->Top.X, eNextHorz->Bot.X, eNextHorz->Top.X)) { OutPt* op2 = GetLastOutPt(eNextHorz); AddJoin(op2, op1, eNextHorz->Top); } eNextHorz = eNextHorz->NextInSEL; } AddGhostJoin(op1, horzEdge->Top); } if (horzEdge->NextInLML) { if(horzEdge->OutIdx >= 0) { op1 = AddOutPt( horzEdge, horzEdge->Top); UpdateEdgeIntoAEL(horzEdge); if (horzEdge->WindDelta == 0) return; //nb: HorzEdge is no longer horizontal here TEdge* ePrev = horzEdge->PrevInAEL; TEdge* eNext = horzEdge->NextInAEL; if (ePrev && ePrev->Curr.X == horzEdge->Bot.X && ePrev->Curr.Y == horzEdge->Bot.Y && ePrev->WindDelta != 0 && (ePrev->OutIdx >= 0 && ePrev->Curr.Y > ePrev->Top.Y && SlopesEqual(*horzEdge, *ePrev, m_UseFullRange))) { OutPt* op2 = AddOutPt(ePrev, horzEdge->Bot); AddJoin(op1, op2, horzEdge->Top); } else if (eNext && eNext->Curr.X == horzEdge->Bot.X && eNext->Curr.Y == horzEdge->Bot.Y && eNext->WindDelta != 0 && eNext->OutIdx >= 0 && eNext->Curr.Y > eNext->Top.Y && SlopesEqual(*horzEdge, *eNext, m_UseFullRange)) { OutPt* op2 = AddOutPt(eNext, horzEdge->Bot); AddJoin(op1, op2, horzEdge->Top); } } else UpdateEdgeIntoAEL(horzEdge); } else { if (horzEdge->OutIdx >= 0) AddOutPt(horzEdge, horzEdge->Top); DeleteFromAEL(horzEdge); } } //------------------------------------------------------------------------------ void Clipper::UpdateEdgeIntoAEL(TEdge *&e) { if( !e->NextInLML ) throw clipperException("UpdateEdgeIntoAEL: invalid call"); e->NextInLML->OutIdx = e->OutIdx; TEdge* AelPrev = e->PrevInAEL; TEdge* AelNext = e->NextInAEL; if (AelPrev) AelPrev->NextInAEL = e->NextInLML; else m_ActiveEdges = e->NextInLML; if (AelNext) AelNext->PrevInAEL = e->NextInLML; e->NextInLML->Side = e->Side; e->NextInLML->WindDelta = e->WindDelta; e->NextInLML->WindCnt = e->WindCnt; e->NextInLML->WindCnt2 = e->WindCnt2; e = e->NextInLML; e->Curr = e->Bot; e->PrevInAEL = AelPrev; e->NextInAEL = AelNext; if (!IsHorizontal(*e)) InsertScanbeam(e->Top.Y); } //------------------------------------------------------------------------------ bool Clipper::ProcessIntersections(const cInt topY) { if( !m_ActiveEdges ) return true; try { BuildIntersectList(topY); size_t IlSize = m_IntersectList.size(); if (IlSize == 0) return true; if (IlSize == 1 || FixupIntersectionOrder()) ProcessIntersectList(); else return false; } catch(...) { m_SortedEdges = 0; DisposeIntersectNodes(); throw clipperException("ProcessIntersections error"); } m_SortedEdges = 0; return true; } //------------------------------------------------------------------------------ void Clipper::DisposeIntersectNodes() { for (size_t i = 0; i < m_IntersectList.size(); ++i ) delete m_IntersectList[i]; m_IntersectList.clear(); } //------------------------------------------------------------------------------ void Clipper::BuildIntersectList(const cInt topY) { if ( !m_ActiveEdges ) return; //prepare for sorting ... TEdge* e = m_ActiveEdges; m_SortedEdges = e; while( e ) { e->PrevInSEL = e->PrevInAEL; e->NextInSEL = e->NextInAEL; e->Curr.X = TopX( *e, topY ); e = e->NextInAEL; } //bubblesort ... bool isModified; do { isModified = false; e = m_SortedEdges; while( e->NextInSEL ) { TEdge *eNext = e->NextInSEL; IntPoint Pt; if(e->Curr.X > eNext->Curr.X) { IntersectPoint(*e, *eNext, Pt); IntersectNode * newNode = new IntersectNode; newNode->Edge1 = e; newNode->Edge2 = eNext; newNode->Pt = Pt; m_IntersectList.push_back(newNode); SwapPositionsInSEL(e, eNext); isModified = true; } else e = eNext; } if( e->PrevInSEL ) e->PrevInSEL->NextInSEL = 0; else break; } while ( isModified ); m_SortedEdges = 0; //important } //------------------------------------------------------------------------------ void Clipper::ProcessIntersectList() { for (size_t i = 0; i < m_IntersectList.size(); ++i) { IntersectNode* iNode = m_IntersectList[i]; { IntersectEdges( iNode->Edge1, iNode->Edge2, iNode->Pt); SwapPositionsInAEL( iNode->Edge1 , iNode->Edge2 ); } delete iNode; } m_IntersectList.clear(); } //------------------------------------------------------------------------------ bool IntersectListSort(IntersectNode* node1, IntersectNode* node2) { return node2->Pt.Y < node1->Pt.Y; } //------------------------------------------------------------------------------ inline bool EdgesAdjacent(const IntersectNode &inode) { return (inode.Edge1->NextInSEL == inode.Edge2) || (inode.Edge1->PrevInSEL == inode.Edge2); } //------------------------------------------------------------------------------ bool Clipper::FixupIntersectionOrder() { //pre-condition: intersections are sorted Bottom-most first. //Now it's crucial that intersections are made only between adjacent edges, //so to ensure this the order of intersections may need adjusting ... CopyAELToSEL(); std::sort(m_IntersectList.begin(), m_IntersectList.end(), IntersectListSort); size_t cnt = m_IntersectList.size(); for (size_t i = 0; i < cnt; ++i) { if (!EdgesAdjacent(*m_IntersectList[i])) { size_t j = i + 1; while (j < cnt && !EdgesAdjacent(*m_IntersectList[j])) j++; if (j == cnt) return false; std::swap(m_IntersectList[i], m_IntersectList[j]); } SwapPositionsInSEL(m_IntersectList[i]->Edge1, m_IntersectList[i]->Edge2); } return true; } //------------------------------------------------------------------------------ void Clipper::DoMaxima(TEdge *e) { TEdge* eMaxPair = GetMaximaPair(e); if (!eMaxPair) { if (e->OutIdx >= 0) AddOutPt(e, e->Top); DeleteFromAEL(e); return; } TEdge* eNext = e->NextInAEL; while(eNext && eNext != eMaxPair) { IntersectEdges(e, eNext, e->Top); SwapPositionsInAEL(e, eNext); eNext = e->NextInAEL; } if(e->OutIdx == Unassigned && eMaxPair->OutIdx == Unassigned) { DeleteFromAEL(e); DeleteFromAEL(eMaxPair); } else if( e->OutIdx >= 0 && eMaxPair->OutIdx >= 0 ) { if (e->OutIdx >= 0) AddLocalMaxPoly(e, eMaxPair, e->Top); DeleteFromAEL(e); DeleteFromAEL(eMaxPair); } #ifdef use_lines else if (e->WindDelta == 0) { if (e->OutIdx >= 0) { AddOutPt(e, e->Top); e->OutIdx = Unassigned; } DeleteFromAEL(e); if (eMaxPair->OutIdx >= 0) { AddOutPt(eMaxPair, e->Top); eMaxPair->OutIdx = Unassigned; } DeleteFromAEL(eMaxPair); } #endif else throw clipperException("DoMaxima error"); } //------------------------------------------------------------------------------ void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) { TEdge* e = m_ActiveEdges; while( e ) { //1. process maxima, treating them as if they're 'bent' horizontal edges, // but exclude maxima with horizontal edges. nb: e can't be a horizontal. bool IsMaximaEdge = IsMaxima(e, topY); if(IsMaximaEdge) { TEdge* eMaxPair = GetMaximaPair(e); IsMaximaEdge = (!eMaxPair || !IsHorizontal(*eMaxPair)); } if(IsMaximaEdge) { if (m_StrictSimple) m_Maxima.push_back(e->Top.X); TEdge* ePrev = e->PrevInAEL; DoMaxima(e); if( !ePrev ) e = m_ActiveEdges; else e = ePrev->NextInAEL; } else { //2. promote horizontal edges, otherwise update Curr.X and Curr.Y ... if (IsIntermediate(e, topY) && IsHorizontal(*e->NextInLML)) { UpdateEdgeIntoAEL(e); if (e->OutIdx >= 0) AddOutPt(e, e->Bot); AddEdgeToSEL(e); } else { e->Curr.X = TopX( *e, topY ); e->Curr.Y = topY; } //When StrictlySimple and 'e' is being touched by another edge, then //make sure both edges have a vertex here ... if (m_StrictSimple) { TEdge* ePrev = e->PrevInAEL; if ((e->OutIdx >= 0) && (e->WindDelta != 0) && ePrev && (ePrev->OutIdx >= 0) && (ePrev->Curr.X == e->Curr.X) && (ePrev->WindDelta != 0)) { IntPoint pt = e->Curr; #ifdef use_xyz SetZ(pt, *ePrev, *e); #endif OutPt* op = AddOutPt(ePrev, pt); OutPt* op2 = AddOutPt(e, pt); AddJoin(op, op2, pt); //StrictlySimple (type-3) join } } e = e->NextInAEL; } } //3. Process horizontals at the Top of the scanbeam ... m_Maxima.sort(); ProcessHorizontals(); m_Maxima.clear(); //4. Promote intermediate vertices ... e = m_ActiveEdges; while(e) { if(IsIntermediate(e, topY)) { OutPt* op = 0; if( e->OutIdx >= 0 ) op = AddOutPt(e, e->Top); UpdateEdgeIntoAEL(e); //if output polygons share an edge, they'll need joining later ... TEdge* ePrev = e->PrevInAEL; TEdge* eNext = e->NextInAEL; if (ePrev && ePrev->Curr.X == e->Bot.X && ePrev->Curr.Y == e->Bot.Y && op && ePrev->OutIdx >= 0 && ePrev->Curr.Y > ePrev->Top.Y && SlopesEqual(*e, *ePrev, m_UseFullRange) && (e->WindDelta != 0) && (ePrev->WindDelta != 0)) { OutPt* op2 = AddOutPt(ePrev, e->Bot); AddJoin(op, op2, e->Top); } else if (eNext && eNext->Curr.X == e->Bot.X && eNext->Curr.Y == e->Bot.Y && op && eNext->OutIdx >= 0 && eNext->Curr.Y > eNext->Top.Y && SlopesEqual(*e, *eNext, m_UseFullRange) && (e->WindDelta != 0) && (eNext->WindDelta != 0)) { OutPt* op2 = AddOutPt(eNext, e->Bot); AddJoin(op, op2, e->Top); } } e = e->NextInAEL; } } //------------------------------------------------------------------------------ void Clipper::FixupOutPolyline(OutRec &outrec) { OutPt *pp = outrec.Pts; OutPt *lastPP = pp->Prev; while (pp != lastPP) { pp = pp->Next; if (pp->Pt == pp->Prev->Pt) { if (pp == lastPP) lastPP = pp->Prev; OutPt *tmpPP = pp->Prev; tmpPP->Next = pp->Next; pp->Next->Prev = tmpPP; delete pp; pp = tmpPP; } } if (pp == pp->Prev) { DisposeOutPts(pp); outrec.Pts = 0; return; } } //------------------------------------------------------------------------------ void Clipper::FixupOutPolygon(OutRec &outrec) { //FixupOutPolygon() - removes duplicate points and simplifies consecutive //parallel edges by removing the middle vertex. OutPt *lastOK = 0; outrec.BottomPt = 0; OutPt *pp = outrec.Pts; bool preserveCol = m_PreserveCollinear || m_StrictSimple; for (;;) { if (pp->Prev == pp || pp->Prev == pp->Next) { DisposeOutPts(pp); outrec.Pts = 0; return; } //test for duplicate points and collinear edges ... if ((pp->Pt == pp->Next->Pt) || (pp->Pt == pp->Prev->Pt) || (SlopesEqual(pp->Prev->Pt, pp->Pt, pp->Next->Pt, m_UseFullRange) && (!preserveCol || !Pt2IsBetweenPt1AndPt3(pp->Prev->Pt, pp->Pt, pp->Next->Pt)))) { lastOK = 0; OutPt *tmp = pp; pp->Prev->Next = pp->Next; pp->Next->Prev = pp->Prev; pp = pp->Prev; delete tmp; } else if (pp == lastOK) break; else { if (!lastOK) lastOK = pp; pp = pp->Next; } } outrec.Pts = pp; } //------------------------------------------------------------------------------ int PointCount(OutPt *Pts) { if (!Pts) return 0; int result = 0; OutPt* p = Pts; do { result++; p = p->Next; } while (p != Pts); return result; } //------------------------------------------------------------------------------ void Clipper::BuildResult(Paths &polys) { polys.reserve(m_PolyOuts.size()); for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) { if (!m_PolyOuts[i]->Pts) continue; Path pg; OutPt* p = m_PolyOuts[i]->Pts->Prev; int cnt = PointCount(p); if (cnt < 2) continue; pg.reserve(cnt); for (int i = 0; i < cnt; ++i) { pg.push_back(p->Pt); p = p->Prev; } polys.push_back(pg); } } //------------------------------------------------------------------------------ void Clipper::BuildResult2(PolyTree& polytree) { polytree.Clear(); polytree.AllNodes.reserve(m_PolyOuts.size()); //add each output polygon/contour to polytree ... for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); i++) { OutRec* outRec = m_PolyOuts[i]; int cnt = PointCount(outRec->Pts); if ((outRec->IsOpen && cnt < 2) || (!outRec->IsOpen && cnt < 3)) continue; FixHoleLinkage(*outRec); PolyNode* pn = new PolyNode(); //nb: polytree takes ownership of all the PolyNodes polytree.AllNodes.push_back(pn); outRec->PolyNd = pn; pn->Parent = 0; pn->Index = 0; pn->Contour.reserve(cnt); OutPt *op = outRec->Pts->Prev; for (int j = 0; j < cnt; j++) { pn->Contour.push_back(op->Pt); op = op->Prev; } } //fixup PolyNode links etc ... polytree.Childs.reserve(m_PolyOuts.size()); for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); i++) { OutRec* outRec = m_PolyOuts[i]; if (!outRec->PolyNd) continue; if (outRec->IsOpen) { outRec->PolyNd->m_IsOpen = true; polytree.AddChild(*outRec->PolyNd); } else if (outRec->FirstLeft && outRec->FirstLeft->PolyNd) outRec->FirstLeft->PolyNd->AddChild(*outRec->PolyNd); else polytree.AddChild(*outRec->PolyNd); } } //------------------------------------------------------------------------------ void SwapIntersectNodes(IntersectNode &int1, IntersectNode &int2) { //just swap the contents (because fIntersectNodes is a single-linked-list) IntersectNode inode = int1; //gets a copy of Int1 int1.Edge1 = int2.Edge1; int1.Edge2 = int2.Edge2; int1.Pt = int2.Pt; int2.Edge1 = inode.Edge1; int2.Edge2 = inode.Edge2; int2.Pt = inode.Pt; } //------------------------------------------------------------------------------ inline bool E2InsertsBeforeE1(TEdge &e1, TEdge &e2) { if (e2.Curr.X == e1.Curr.X) { if (e2.Top.Y > e1.Top.Y) return e2.Top.X < TopX(e1, e2.Top.Y); else return e1.Top.X > TopX(e2, e1.Top.Y); } else return e2.Curr.X < e1.Curr.X; } //------------------------------------------------------------------------------ bool GetOverlap(const cInt a1, const cInt a2, const cInt b1, const cInt b2, cInt& Left, cInt& Right) { if (a1 < a2) { if (b1 < b2) {Left = std::max(a1,b1); Right = std::min(a2,b2);} else {Left = std::max(a1,b2); Right = std::min(a2,b1);} } else { if (b1 < b2) {Left = std::max(a2,b1); Right = std::min(a1,b2);} else {Left = std::max(a2,b2); Right = std::min(a1,b1);} } return Left < Right; } //------------------------------------------------------------------------------ inline void UpdateOutPtIdxs(OutRec& outrec) { OutPt* op = outrec.Pts; do { op->Idx = outrec.Idx; op = op->Prev; } while(op != outrec.Pts); } //------------------------------------------------------------------------------ void Clipper::InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge) { if(!m_ActiveEdges) { edge->PrevInAEL = 0; edge->NextInAEL = 0; m_ActiveEdges = edge; } else if(!startEdge && E2InsertsBeforeE1(*m_ActiveEdges, *edge)) { edge->PrevInAEL = 0; edge->NextInAEL = m_ActiveEdges; m_ActiveEdges->PrevInAEL = edge; m_ActiveEdges = edge; } else { if(!startEdge) startEdge = m_ActiveEdges; while(startEdge->NextInAEL && !E2InsertsBeforeE1(*startEdge->NextInAEL , *edge)) startEdge = startEdge->NextInAEL; edge->NextInAEL = startEdge->NextInAEL; if(startEdge->NextInAEL) startEdge->NextInAEL->PrevInAEL = edge; edge->PrevInAEL = startEdge; startEdge->NextInAEL = edge; } } //---------------------------------------------------------------------- OutPt* DupOutPt(OutPt* outPt, bool InsertAfter) { OutPt* result = new OutPt; result->Pt = outPt->Pt; result->Idx = outPt->Idx; if (InsertAfter) { result->Next = outPt->Next; result->Prev = outPt; outPt->Next->Prev = result; outPt->Next = result; } else { result->Prev = outPt->Prev; result->Next = outPt; outPt->Prev->Next = result; outPt->Prev = result; } return result; } //------------------------------------------------------------------------------ bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, const IntPoint &Pt, bool DiscardLeft) { Direction Dir1 = (op1->Pt.X > op1b->Pt.X ? dRightToLeft : dLeftToRight); Direction Dir2 = (op2->Pt.X > op2b->Pt.X ? dRightToLeft : dLeftToRight); if (Dir1 == Dir2) return false; //When DiscardLeft, we want Op1b to be on the Left of Op1, otherwise we //want Op1b to be on the Right. (And likewise with Op2 and Op2b.) //So, to facilitate this while inserting Op1b and Op2b ... //when DiscardLeft, make sure we're AT or RIGHT of Pt before adding Op1b, //otherwise make sure we're AT or LEFT of Pt. (Likewise with Op2b.) if (Dir1 == dLeftToRight) { while (op1->Next->Pt.X <= Pt.X && op1->Next->Pt.X >= op1->Pt.X && op1->Next->Pt.Y == Pt.Y) op1 = op1->Next; if (DiscardLeft && (op1->Pt.X != Pt.X)) op1 = op1->Next; op1b = DupOutPt(op1, !DiscardLeft); if (op1b->Pt != Pt) { op1 = op1b; op1->Pt = Pt; op1b = DupOutPt(op1, !DiscardLeft); } } else { while (op1->Next->Pt.X >= Pt.X && op1->Next->Pt.X <= op1->Pt.X && op1->Next->Pt.Y == Pt.Y) op1 = op1->Next; if (!DiscardLeft && (op1->Pt.X != Pt.X)) op1 = op1->Next; op1b = DupOutPt(op1, DiscardLeft); if (op1b->Pt != Pt) { op1 = op1b; op1->Pt = Pt; op1b = DupOutPt(op1, DiscardLeft); } } if (Dir2 == dLeftToRight) { while (op2->Next->Pt.X <= Pt.X && op2->Next->Pt.X >= op2->Pt.X && op2->Next->Pt.Y == Pt.Y) op2 = op2->Next; if (DiscardLeft && (op2->Pt.X != Pt.X)) op2 = op2->Next; op2b = DupOutPt(op2, !DiscardLeft); if (op2b->Pt != Pt) { op2 = op2b; op2->Pt = Pt; op2b = DupOutPt(op2, !DiscardLeft); }; } else { while (op2->Next->Pt.X >= Pt.X && op2->Next->Pt.X <= op2->Pt.X && op2->Next->Pt.Y == Pt.Y) op2 = op2->Next; if (!DiscardLeft && (op2->Pt.X != Pt.X)) op2 = op2->Next; op2b = DupOutPt(op2, DiscardLeft); if (op2b->Pt != Pt) { op2 = op2b; op2->Pt = Pt; op2b = DupOutPt(op2, DiscardLeft); }; }; if ((Dir1 == dLeftToRight) == DiscardLeft) { op1->Prev = op2; op2->Next = op1; op1b->Next = op2b; op2b->Prev = op1b; } else { op1->Next = op2; op2->Prev = op1; op1b->Prev = op2b; op2b->Next = op1b; } return true; } //------------------------------------------------------------------------------ bool Clipper::JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2) { OutPt *op1 = j->OutPt1, *op1b; OutPt *op2 = j->OutPt2, *op2b; //There are 3 kinds of joins for output polygons ... //1. Horizontal joins where Join.OutPt1 & Join.OutPt2 are vertices anywhere //along (horizontal) collinear edges (& Join.OffPt is on the same horizontal). //2. Non-horizontal joins where Join.OutPt1 & Join.OutPt2 are at the same //location at the Bottom of the overlapping segment (& Join.OffPt is above). //3. StrictSimple joins where edges touch but are not collinear and where //Join.OutPt1, Join.OutPt2 & Join.OffPt all share the same point. bool isHorizontal = (j->OutPt1->Pt.Y == j->OffPt.Y); if (isHorizontal && (j->OffPt == j->OutPt1->Pt) && (j->OffPt == j->OutPt2->Pt)) { //Strictly Simple join ... if (outRec1 != outRec2) return false; op1b = j->OutPt1->Next; while (op1b != op1 && (op1b->Pt == j->OffPt)) op1b = op1b->Next; bool reverse1 = (op1b->Pt.Y > j->OffPt.Y); op2b = j->OutPt2->Next; while (op2b != op2 && (op2b->Pt == j->OffPt)) op2b = op2b->Next; bool reverse2 = (op2b->Pt.Y > j->OffPt.Y); if (reverse1 == reverse2) return false; if (reverse1) { op1b = DupOutPt(op1, false); op2b = DupOutPt(op2, true); op1->Prev = op2; op2->Next = op1; op1b->Next = op2b; op2b->Prev = op1b; j->OutPt1 = op1; j->OutPt2 = op1b; return true; } else { op1b = DupOutPt(op1, true); op2b = DupOutPt(op2, false); op1->Next = op2; op2->Prev = op1; op1b->Prev = op2b; op2b->Next = op1b; j->OutPt1 = op1; j->OutPt2 = op1b; return true; } } else if (isHorizontal) { //treat horizontal joins differently to non-horizontal joins since with //them we're not yet sure where the overlapping is. OutPt1.Pt & OutPt2.Pt //may be anywhere along the horizontal edge. op1b = op1; while (op1->Prev->Pt.Y == op1->Pt.Y && op1->Prev != op1b && op1->Prev != op2) op1 = op1->Prev; while (op1b->Next->Pt.Y == op1b->Pt.Y && op1b->Next != op1 && op1b->Next != op2) op1b = op1b->Next; if (op1b->Next == op1 || op1b->Next == op2) return false; //a flat 'polygon' op2b = op2; while (op2->Prev->Pt.Y == op2->Pt.Y && op2->Prev != op2b && op2->Prev != op1b) op2 = op2->Prev; while (op2b->Next->Pt.Y == op2b->Pt.Y && op2b->Next != op2 && op2b->Next != op1) op2b = op2b->Next; if (op2b->Next == op2 || op2b->Next == op1) return false; //a flat 'polygon' cInt Left, Right; //Op1 --> Op1b & Op2 --> Op2b are the extremites of the horizontal edges if (!GetOverlap(op1->Pt.X, op1b->Pt.X, op2->Pt.X, op2b->Pt.X, Left, Right)) return false; //DiscardLeftSide: when overlapping edges are joined, a spike will created //which needs to be cleaned up. However, we don't want Op1 or Op2 caught up //on the discard Side as either may still be needed for other joins ... IntPoint Pt; bool DiscardLeftSide; if (op1->Pt.X >= Left && op1->Pt.X <= Right) { Pt = op1->Pt; DiscardLeftSide = (op1->Pt.X > op1b->Pt.X); } else if (op2->Pt.X >= Left&& op2->Pt.X <= Right) { Pt = op2->Pt; DiscardLeftSide = (op2->Pt.X > op2b->Pt.X); } else if (op1b->Pt.X >= Left && op1b->Pt.X <= Right) { Pt = op1b->Pt; DiscardLeftSide = op1b->Pt.X > op1->Pt.X; } else { Pt = op2b->Pt; DiscardLeftSide = (op2b->Pt.X > op2->Pt.X); } j->OutPt1 = op1; j->OutPt2 = op2; return JoinHorz(op1, op1b, op2, op2b, Pt, DiscardLeftSide); } else { //nb: For non-horizontal joins ... // 1. Jr.OutPt1.Pt.Y == Jr.OutPt2.Pt.Y // 2. Jr.OutPt1.Pt > Jr.OffPt.Y //make sure the polygons are correctly oriented ... op1b = op1->Next; while ((op1b->Pt == op1->Pt) && (op1b != op1)) op1b = op1b->Next; bool Reverse1 = ((op1b->Pt.Y > op1->Pt.Y) || !SlopesEqual(op1->Pt, op1b->Pt, j->OffPt, m_UseFullRange)); if (Reverse1) { op1b = op1->Prev; while ((op1b->Pt == op1->Pt) && (op1b != op1)) op1b = op1b->Prev; if ((op1b->Pt.Y > op1->Pt.Y) || !SlopesEqual(op1->Pt, op1b->Pt, j->OffPt, m_UseFullRange)) return false; }; op2b = op2->Next; while ((op2b->Pt == op2->Pt) && (op2b != op2))op2b = op2b->Next; bool Reverse2 = ((op2b->Pt.Y > op2->Pt.Y) || !SlopesEqual(op2->Pt, op2b->Pt, j->OffPt, m_UseFullRange)); if (Reverse2) { op2b = op2->Prev; while ((op2b->Pt == op2->Pt) && (op2b != op2)) op2b = op2b->Prev; if ((op2b->Pt.Y > op2->Pt.Y) || !SlopesEqual(op2->Pt, op2b->Pt, j->OffPt, m_UseFullRange)) return false; } if ((op1b == op1) || (op2b == op2) || (op1b == op2b) || ((outRec1 == outRec2) && (Reverse1 == Reverse2))) return false; if (Reverse1) { op1b = DupOutPt(op1, false); op2b = DupOutPt(op2, true); op1->Prev = op2; op2->Next = op1; op1b->Next = op2b; op2b->Prev = op1b; j->OutPt1 = op1; j->OutPt2 = op1b; return true; } else { op1b = DupOutPt(op1, true); op2b = DupOutPt(op2, false); op1->Next = op2; op2->Prev = op1; op1b->Prev = op2b; op2b->Next = op1b; j->OutPt1 = op1; j->OutPt2 = op1b; return true; } } } //---------------------------------------------------------------------- static OutRec* ParseFirstLeft(OutRec* FirstLeft) { while (FirstLeft && !FirstLeft->Pts) FirstLeft = FirstLeft->FirstLeft; return FirstLeft; } //------------------------------------------------------------------------------ void Clipper::FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec) const { //tests if NewOutRec contains the polygon before reassigning FirstLeft for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) { OutRec* outRec = m_PolyOuts[i]; if (!outRec->Pts || !outRec->FirstLeft) continue; OutRec* firstLeft = ParseFirstLeft(outRec->FirstLeft); if (firstLeft == OldOutRec) { if (Poly2ContainsPoly1(outRec->Pts, NewOutRec->Pts)) outRec->FirstLeft = NewOutRec; } } } //---------------------------------------------------------------------- void Clipper::FixupFirstLefts2(OutRec* OldOutRec, OutRec* NewOutRec) const { //reassigns FirstLeft WITHOUT testing if NewOutRec contains the polygon for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) { OutRec* outRec = m_PolyOuts[i]; if (outRec->FirstLeft == OldOutRec) outRec->FirstLeft = NewOutRec; } } //---------------------------------------------------------------------- void Clipper::JoinCommonEdges() { for (JoinList::size_type i = 0; i < m_Joins.size(); i++) { Join* join = m_Joins[i]; OutRec *outRec1 = GetOutRec(join->OutPt1->Idx); OutRec *outRec2 = GetOutRec(join->OutPt2->Idx); if (!outRec1->Pts || !outRec2->Pts) continue; if (outRec1->IsOpen || outRec2->IsOpen) continue; //get the polygon fragment with the correct hole state (FirstLeft) //before calling JoinPoints() ... OutRec *holeStateRec; if (outRec1 == outRec2) holeStateRec = outRec1; else if (Param1RightOfParam2(outRec1, outRec2)) holeStateRec = outRec2; else if (Param1RightOfParam2(outRec2, outRec1)) holeStateRec = outRec1; else holeStateRec = GetLowermostRec(outRec1, outRec2); if (!JoinPoints(join, outRec1, outRec2)) continue; if (outRec1 == outRec2) { //instead of joining two polygons, we've just created a new one by //splitting one polygon into two. outRec1->Pts = join->OutPt1; outRec1->BottomPt = 0; outRec2 = CreateOutRec(); outRec2->Pts = join->OutPt2; //update all OutRec2.Pts Idx's ... UpdateOutPtIdxs(*outRec2); //We now need to check every OutRec.FirstLeft pointer. If it points //to OutRec1 it may need to point to OutRec2 instead ... if (m_UsingPolyTree) for (PolyOutList::size_type j = 0; j < m_PolyOuts.size() - 1; j++) { OutRec* oRec = m_PolyOuts[j]; if (!oRec->Pts || ParseFirstLeft(oRec->FirstLeft) != outRec1 || oRec->IsHole == outRec1->IsHole) continue; if (Poly2ContainsPoly1(oRec->Pts, join->OutPt2)) oRec->FirstLeft = outRec2; } if (Poly2ContainsPoly1(outRec2->Pts, outRec1->Pts)) { //outRec2 is contained by outRec1 ... outRec2->IsHole = !outRec1->IsHole; outRec2->FirstLeft = outRec1; //fixup FirstLeft pointers that may need reassigning to OutRec1 if (m_UsingPolyTree) FixupFirstLefts2(outRec2, outRec1); if ((outRec2->IsHole ^ m_ReverseOutput) == (Area(*outRec2) > 0)) ReversePolyPtLinks(outRec2->Pts); } else if (Poly2ContainsPoly1(outRec1->Pts, outRec2->Pts)) { //outRec1 is contained by outRec2 ... outRec2->IsHole = outRec1->IsHole; outRec1->IsHole = !outRec2->IsHole; outRec2->FirstLeft = outRec1->FirstLeft; outRec1->FirstLeft = outRec2; //fixup FirstLeft pointers that may need reassigning to OutRec1 if (m_UsingPolyTree) FixupFirstLefts2(outRec1, outRec2); if ((outRec1->IsHole ^ m_ReverseOutput) == (Area(*outRec1) > 0)) ReversePolyPtLinks(outRec1->Pts); } else { //the 2 polygons are completely separate ... outRec2->IsHole = outRec1->IsHole; outRec2->FirstLeft = outRec1->FirstLeft; //fixup FirstLeft pointers that may need reassigning to OutRec2 if (m_UsingPolyTree) FixupFirstLefts1(outRec1, outRec2); } } else { //joined 2 polygons together ... outRec2->Pts = 0; outRec2->BottomPt = 0; outRec2->Idx = outRec1->Idx; outRec1->IsHole = holeStateRec->IsHole; if (holeStateRec == outRec2) outRec1->FirstLeft = outRec2->FirstLeft; outRec2->FirstLeft = outRec1; //fixup FirstLeft pointers that may need reassigning to OutRec1 if (m_UsingPolyTree) FixupFirstLefts2(outRec2, outRec1); } } } //------------------------------------------------------------------------------ // ClipperOffset support functions ... //------------------------------------------------------------------------------ DoublePoint GetUnitNormal(const IntPoint &pt1, const IntPoint &pt2) { if(pt2.X == pt1.X && pt2.Y == pt1.Y) return DoublePoint(0, 0); double Dx = (double)(pt2.X - pt1.X); double dy = (double)(pt2.Y - pt1.Y); double f = 1 *1.0/ std::sqrt( Dx*Dx + dy*dy ); Dx *= f; dy *= f; return DoublePoint(dy, -Dx); } //------------------------------------------------------------------------------ // ClipperOffset class //------------------------------------------------------------------------------ ClipperOffset::ClipperOffset(double miterLimit, double arcTolerance) { this->MiterLimit = miterLimit; this->ArcTolerance = arcTolerance; m_lowest.X = -1; } //------------------------------------------------------------------------------ ClipperOffset::~ClipperOffset() { Clear(); } //------------------------------------------------------------------------------ void ClipperOffset::Clear() { for (int i = 0; i < m_polyNodes.ChildCount(); ++i) delete m_polyNodes.Childs[i]; m_polyNodes.Childs.clear(); m_lowest.X = -1; } //------------------------------------------------------------------------------ void ClipperOffset::AddPath(const Path& path, JoinType joinType, EndType endType) { int highI = (int)path.size() - 1; if (highI < 0) return; PolyNode* newNode = new PolyNode(); newNode->m_jointype = joinType; newNode->m_endtype = endType; //strip duplicate points from path and also get index to the lowest point ... if (endType == etClosedLine || endType == etClosedPolygon) while (highI > 0 && path[0] == path[highI]) highI--; newNode->Contour.reserve(highI + 1); newNode->Contour.push_back(path[0]); int j = 0, k = 0; for (int i = 1; i <= highI; i++) if (newNode->Contour[j] != path[i]) { j++; newNode->Contour.push_back(path[i]); if (path[i].Y > newNode->Contour[k].Y || (path[i].Y == newNode->Contour[k].Y && path[i].X < newNode->Contour[k].X)) k = j; } if (endType == etClosedPolygon && j < 2) { delete newNode; return; } m_polyNodes.AddChild(*newNode); //if this path's lowest pt is lower than all the others then update m_lowest if (endType != etClosedPolygon) return; if (m_lowest.X < 0) m_lowest = IntPoint(m_polyNodes.ChildCount() - 1, k); else { IntPoint ip = m_polyNodes.Childs[(int)m_lowest.X]->Contour[(int)m_lowest.Y]; if (newNode->Contour[k].Y > ip.Y || (newNode->Contour[k].Y == ip.Y && newNode->Contour[k].X < ip.X)) m_lowest = IntPoint(m_polyNodes.ChildCount() - 1, k); } } //------------------------------------------------------------------------------ void ClipperOffset::AddPaths(const Paths& paths, JoinType joinType, EndType endType) { for (Paths::size_type i = 0; i < paths.size(); ++i) AddPath(paths[i], joinType, endType); } //------------------------------------------------------------------------------ void ClipperOffset::FixOrientations() { //fixup orientations of all closed paths if the orientation of the //closed path with the lowermost vertex is wrong ... if (m_lowest.X >= 0 && !Orientation(m_polyNodes.Childs[(int)m_lowest.X]->Contour)) { for (int i = 0; i < m_polyNodes.ChildCount(); ++i) { PolyNode& node = *m_polyNodes.Childs[i]; if (node.m_endtype == etClosedPolygon || (node.m_endtype == etClosedLine && Orientation(node.Contour))) ReversePath(node.Contour); } } else { for (int i = 0; i < m_polyNodes.ChildCount(); ++i) { PolyNode& node = *m_polyNodes.Childs[i]; if (node.m_endtype == etClosedLine && !Orientation(node.Contour)) ReversePath(node.Contour); } } } //------------------------------------------------------------------------------ void ClipperOffset::Execute(Paths& solution, double delta) { solution.clear(); FixOrientations(); DoOffset(delta); //now clean up 'corners' ... Clipper clpr; clpr.AddPaths(m_destPolys, ptSubject, true); if (delta > 0) { clpr.Execute(ctUnion, solution, pftPositive, pftPositive); } else { IntRect r = clpr.GetBounds(); Path outer(4); outer[0] = IntPoint(r.left - 10, r.bottom + 10); outer[1] = IntPoint(r.right + 10, r.bottom + 10); outer[2] = IntPoint(r.right + 10, r.top - 10); outer[3] = IntPoint(r.left - 10, r.top - 10); clpr.AddPath(outer, ptSubject, true); clpr.ReverseSolution(true); clpr.Execute(ctUnion, solution, pftNegative, pftNegative); if (solution.size() > 0) solution.erase(solution.begin()); } } //------------------------------------------------------------------------------ void ClipperOffset::Execute(PolyTree& solution, double delta) { solution.Clear(); FixOrientations(); DoOffset(delta); //now clean up 'corners' ... Clipper clpr; clpr.AddPaths(m_destPolys, ptSubject, true); if (delta > 0) { clpr.Execute(ctUnion, solution, pftPositive, pftPositive); } else { IntRect r = clpr.GetBounds(); Path outer(4); outer[0] = IntPoint(r.left - 10, r.bottom + 10); outer[1] = IntPoint(r.right + 10, r.bottom + 10); outer[2] = IntPoint(r.right + 10, r.top - 10); outer[3] = IntPoint(r.left - 10, r.top - 10); clpr.AddPath(outer, ptSubject, true); clpr.ReverseSolution(true); clpr.Execute(ctUnion, solution, pftNegative, pftNegative); //remove the outer PolyNode rectangle ... if (solution.ChildCount() == 1 && solution.Childs[0]->ChildCount() > 0) { PolyNode* outerNode = solution.Childs[0]; solution.Childs.reserve(outerNode->ChildCount()); solution.Childs[0] = outerNode->Childs[0]; solution.Childs[0]->Parent = outerNode->Parent; for (int i = 1; i < outerNode->ChildCount(); ++i) solution.AddChild(*outerNode->Childs[i]); } else solution.Clear(); } } //------------------------------------------------------------------------------ void ClipperOffset::DoOffset(double delta) { m_destPolys.clear(); m_delta = delta; //if Zero offset, just copy any CLOSED polygons to m_p and return ... if (NEAR_ZERO(delta)) { m_destPolys.reserve(m_polyNodes.ChildCount()); for (int i = 0; i < m_polyNodes.ChildCount(); i++) { PolyNode& node = *m_polyNodes.Childs[i]; if (node.m_endtype == etClosedPolygon) m_destPolys.push_back(node.Contour); } return; } //see offset_triginometry3.svg in the documentation folder ... if (MiterLimit > 2) m_miterLim = 2/(MiterLimit * MiterLimit); else m_miterLim = 0.5; double y; if (ArcTolerance <= 0.0) y = def_arc_tolerance; else if (ArcTolerance > std::fabs(delta) * def_arc_tolerance) y = std::fabs(delta) * def_arc_tolerance; else y = ArcTolerance; //see offset_triginometry2.svg in the documentation folder ... double steps = pi / std::acos(1 - y / std::fabs(delta)); if (steps > std::fabs(delta) * pi) steps = std::fabs(delta) * pi; //ie excessive precision check m_sin = std::sin(two_pi / steps); m_cos = std::cos(two_pi / steps); m_StepsPerRad = steps / two_pi; if (delta < 0.0) m_sin = -m_sin; m_destPolys.reserve(m_polyNodes.ChildCount() * 2); for (int i = 0; i < m_polyNodes.ChildCount(); i++) { PolyNode& node = *m_polyNodes.Childs[i]; m_srcPoly = node.Contour; int len = (int)m_srcPoly.size(); if (len == 0 || (delta <= 0 && (len < 3 || node.m_endtype != etClosedPolygon))) continue; m_destPoly.clear(); if (len == 1) { if (node.m_jointype == jtRound) { double X = 1.0, Y = 0.0; for (cInt j = 1; j <= steps; j++) { m_destPoly.push_back(IntPoint( Round(m_srcPoly[0].X + X * delta), Round(m_srcPoly[0].Y + Y * delta))); double X2 = X; X = X * m_cos - m_sin * Y; Y = X2 * m_sin + Y * m_cos; } } else { double X = -1.0, Y = -1.0; for (int j = 0; j < 4; ++j) { m_destPoly.push_back(IntPoint( Round(m_srcPoly[0].X + X * delta), Round(m_srcPoly[0].Y + Y * delta))); if (X < 0) X = 1; else if (Y < 0) Y = 1; else X = -1; } } m_destPolys.push_back(m_destPoly); continue; } //build m_normals ... m_normals.clear(); m_normals.reserve(len); for (int j = 0; j < len - 1; ++j) m_normals.push_back(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1])); if (node.m_endtype == etClosedLine || node.m_endtype == etClosedPolygon) m_normals.push_back(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0])); else m_normals.push_back(DoublePoint(m_normals[len - 2])); if (node.m_endtype == etClosedPolygon) { int k = len - 1; for (int j = 0; j < len; ++j) OffsetPoint(j, k, node.m_jointype); m_destPolys.push_back(m_destPoly); } else if (node.m_endtype == etClosedLine) { int k = len - 1; for (int j = 0; j < len; ++j) OffsetPoint(j, k, node.m_jointype); m_destPolys.push_back(m_destPoly); m_destPoly.clear(); //re-build m_normals ... DoublePoint n = m_normals[len -1]; for (int j = len - 1; j > 0; j--) m_normals[j] = DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y); m_normals[0] = DoublePoint(-n.X, -n.Y); k = 0; for (int j = len - 1; j >= 0; j--) OffsetPoint(j, k, node.m_jointype); m_destPolys.push_back(m_destPoly); } else { int k = 0; for (int j = 1; j < len - 1; ++j) OffsetPoint(j, k, node.m_jointype); IntPoint pt1; if (node.m_endtype == etOpenButt) { int j = len - 1; pt1 = IntPoint((cInt)Round(m_srcPoly[j].X + m_normals[j].X * delta), (cInt)Round(m_srcPoly[j].Y + m_normals[j].Y * delta)); m_destPoly.push_back(pt1); pt1 = IntPoint((cInt)Round(m_srcPoly[j].X - m_normals[j].X * delta), (cInt)Round(m_srcPoly[j].Y - m_normals[j].Y * delta)); m_destPoly.push_back(pt1); } else { int j = len - 1; k = len - 2; m_sinA = 0; m_normals[j] = DoublePoint(-m_normals[j].X, -m_normals[j].Y); if (node.m_endtype == etOpenSquare) DoSquare(j, k); else DoRound(j, k); } //re-build m_normals ... for (int j = len - 1; j > 0; j--) m_normals[j] = DoublePoint(-m_normals[j - 1].X, -m_normals[j - 1].Y); m_normals[0] = DoublePoint(-m_normals[1].X, -m_normals[1].Y); k = len - 1; for (int j = k - 1; j > 0; --j) OffsetPoint(j, k, node.m_jointype); if (node.m_endtype == etOpenButt) { pt1 = IntPoint((cInt)Round(m_srcPoly[0].X - m_normals[0].X * delta), (cInt)Round(m_srcPoly[0].Y - m_normals[0].Y * delta)); m_destPoly.push_back(pt1); pt1 = IntPoint((cInt)Round(m_srcPoly[0].X + m_normals[0].X * delta), (cInt)Round(m_srcPoly[0].Y + m_normals[0].Y * delta)); m_destPoly.push_back(pt1); } else { k = 1; m_sinA = 0; if (node.m_endtype == etOpenSquare) DoSquare(0, 1); else DoRound(0, 1); } m_destPolys.push_back(m_destPoly); } } } //------------------------------------------------------------------------------ void ClipperOffset::OffsetPoint(int j, int& k, JoinType jointype) { //cross product ... m_sinA = (m_normals[k].X * m_normals[j].Y - m_normals[j].X * m_normals[k].Y); if (std::fabs(m_sinA * m_delta) < 1.0) { //dot product ... double cosA = (m_normals[k].X * m_normals[j].X + m_normals[j].Y * m_normals[k].Y ); if (cosA > 0) // angle => 0 degrees { m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta), Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta))); return; } //else angle => 180 degrees } else if (m_sinA > 1.0) m_sinA = 1.0; else if (m_sinA < -1.0) m_sinA = -1.0; if (m_sinA * m_delta < 0) { m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[k].X * m_delta), Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta))); m_destPoly.push_back(m_srcPoly[j]); m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + m_normals[j].X * m_delta), Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta))); } else switch (jointype) { case jtMiter: { double r = 1 + (m_normals[j].X * m_normals[k].X + m_normals[j].Y * m_normals[k].Y); if (r >= m_miterLim) DoMiter(j, k, r); else DoSquare(j, k); break; } case jtSquare: DoSquare(j, k); break; case jtRound: DoRound(j, k); break; } k = j; } //------------------------------------------------------------------------------ void ClipperOffset::DoSquare(int j, int k) { double dx = std::tan(std::atan2(m_sinA, m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y) / 4); m_destPoly.push_back(IntPoint( Round(m_srcPoly[j].X + m_delta * (m_normals[k].X - m_normals[k].Y * dx)), Round(m_srcPoly[j].Y + m_delta * (m_normals[k].Y + m_normals[k].X * dx)))); m_destPoly.push_back(IntPoint( Round(m_srcPoly[j].X + m_delta * (m_normals[j].X + m_normals[j].Y * dx)), Round(m_srcPoly[j].Y + m_delta * (m_normals[j].Y - m_normals[j].X * dx)))); } //------------------------------------------------------------------------------ void ClipperOffset::DoMiter(int j, int k, double r) { double q = m_delta / r; m_destPoly.push_back(IntPoint(Round(m_srcPoly[j].X + (m_normals[k].X + m_normals[j].X) * q), Round(m_srcPoly[j].Y + (m_normals[k].Y + m_normals[j].Y) * q))); } //------------------------------------------------------------------------------ void ClipperOffset::DoRound(int j, int k) { double a = std::atan2(m_sinA, m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y); int steps = std::max((int)Round(m_StepsPerRad * std::fabs(a)), 1); double X = m_normals[k].X, Y = m_normals[k].Y, X2; for (int i = 0; i < steps; ++i) { m_destPoly.push_back(IntPoint( Round(m_srcPoly[j].X + X * m_delta), Round(m_srcPoly[j].Y + Y * m_delta))); X2 = X; X = X * m_cos - m_sin * Y; Y = X2 * m_sin + Y * m_cos; } m_destPoly.push_back(IntPoint( Round(m_srcPoly[j].X + m_normals[j].X * m_delta), Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta))); } //------------------------------------------------------------------------------ // Miscellaneous public functions //------------------------------------------------------------------------------ void Clipper::DoSimplePolygons() { PolyOutList::size_type i = 0; while (i < m_PolyOuts.size()) { OutRec* outrec = m_PolyOuts[i++]; OutPt* op = outrec->Pts; if (!op || outrec->IsOpen) continue; do //for each Pt in Polygon until duplicate found do ... { OutPt* op2 = op->Next; while (op2 != outrec->Pts) { if ((op->Pt == op2->Pt) && op2->Next != op && op2->Prev != op) { //split the polygon into two ... OutPt* op3 = op->Prev; OutPt* op4 = op2->Prev; op->Prev = op4; op4->Next = op; op2->Prev = op3; op3->Next = op2; outrec->Pts = op; OutRec* outrec2 = CreateOutRec(); outrec2->Pts = op2; UpdateOutPtIdxs(*outrec2); if (Poly2ContainsPoly1(outrec2->Pts, outrec->Pts)) { //OutRec2 is contained by OutRec1 ... outrec2->IsHole = !outrec->IsHole; outrec2->FirstLeft = outrec; if (m_UsingPolyTree) FixupFirstLefts2(outrec2, outrec); } else if (Poly2ContainsPoly1(outrec->Pts, outrec2->Pts)) { //OutRec1 is contained by OutRec2 ... outrec2->IsHole = outrec->IsHole; outrec->IsHole = !outrec2->IsHole; outrec2->FirstLeft = outrec->FirstLeft; outrec->FirstLeft = outrec2; if (m_UsingPolyTree) FixupFirstLefts2(outrec, outrec2); } else { //the 2 polygons are separate ... outrec2->IsHole = outrec->IsHole; outrec2->FirstLeft = outrec->FirstLeft; if (m_UsingPolyTree) FixupFirstLefts1(outrec, outrec2); } op2 = op; //ie get ready for the Next iteration } op2 = op2->Next; } op = op->Next; } while (op != outrec->Pts); } } //------------------------------------------------------------------------------ void ReversePath(Path& p) { std::reverse(p.begin(), p.end()); } //------------------------------------------------------------------------------ void ReversePaths(Paths& p) { for (Paths::size_type i = 0; i < p.size(); ++i) ReversePath(p[i]); } //------------------------------------------------------------------------------ void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType) { Clipper c; c.StrictlySimple(true); c.AddPath(in_poly, ptSubject, true); c.Execute(ctUnion, out_polys, fillType, fillType); } //------------------------------------------------------------------------------ void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType) { Clipper c; c.StrictlySimple(true); c.AddPaths(in_polys, ptSubject, true); c.Execute(ctUnion, out_polys, fillType, fillType); } //------------------------------------------------------------------------------ void SimplifyPolygons(Paths &polys, PolyFillType fillType) { SimplifyPolygons(polys, polys, fillType); } //------------------------------------------------------------------------------ inline double DistanceSqrd(const IntPoint& pt1, const IntPoint& pt2) { double Dx = ((double)pt1.X - pt2.X); double dy = ((double)pt1.Y - pt2.Y); return (Dx*Dx + dy*dy); } //------------------------------------------------------------------------------ double DistanceFromLineSqrd( const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2) { //The equation of a line in general form (Ax + By + C = 0) //given 2 points (x¹,y¹) & (x²,y²) is ... //(y¹ - y²)x + (x² - x¹)y + (y² - y¹)x¹ - (x² - x¹)y¹ = 0 //A = (y¹ - y²); B = (x² - x¹); C = (y² - y¹)x¹ - (x² - x¹)y¹ //perpendicular distance of point (x³,y³) = (Ax³ + By³ + C)/Sqrt(A² + B²) //see http://en.wikipedia.org/wiki/Perpendicular_distance double A = double(ln1.Y - ln2.Y); double B = double(ln2.X - ln1.X); double C = A * ln1.X + B * ln1.Y; C = A * pt.X + B * pt.Y - C; return (C * C) / (A * A + B * B); } //--------------------------------------------------------------------------- bool SlopesNearCollinear(const IntPoint& pt1, const IntPoint& pt2, const IntPoint& pt3, double distSqrd) { //this function is more accurate when the point that's geometrically //between the other 2 points is the one that's tested for distance. //ie makes it more likely to pick up 'spikes' ... if (Abs(pt1.X - pt2.X) > Abs(pt1.Y - pt2.Y)) { if ((pt1.X > pt2.X) == (pt1.X < pt3.X)) return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd; else if ((pt2.X > pt1.X) == (pt2.X < pt3.X)) return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd; else return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd; } else { if ((pt1.Y > pt2.Y) == (pt1.Y < pt3.Y)) return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd; else if ((pt2.Y > pt1.Y) == (pt2.Y < pt3.Y)) return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd; else return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd; } } //------------------------------------------------------------------------------ bool PointsAreClose(IntPoint pt1, IntPoint pt2, double distSqrd) { double Dx = (double)pt1.X - pt2.X; double dy = (double)pt1.Y - pt2.Y; return ((Dx * Dx) + (dy * dy) <= distSqrd); } //------------------------------------------------------------------------------ OutPt* ExcludeOp(OutPt* op) { OutPt* result = op->Prev; result->Next = op->Next; op->Next->Prev = result; result->Idx = 0; return result; } //------------------------------------------------------------------------------ void CleanPolygon(const Path& in_poly, Path& out_poly, double distance) { //distance = proximity in units/pixels below which vertices //will be stripped. Default ~= sqrt(2). size_t size = in_poly.size(); if (size == 0) { out_poly.clear(); return; } OutPt* outPts = new OutPt[size]; for (size_t i = 0; i < size; ++i) { outPts[i].Pt = in_poly[i]; outPts[i].Next = &outPts[(i + 1) % size]; outPts[i].Next->Prev = &outPts[i]; outPts[i].Idx = 0; } double distSqrd = distance * distance; OutPt* op = &outPts[0]; while (op->Idx == 0 && op->Next != op->Prev) { if (PointsAreClose(op->Pt, op->Prev->Pt, distSqrd)) { op = ExcludeOp(op); size--; } else if (PointsAreClose(op->Prev->Pt, op->Next->Pt, distSqrd)) { ExcludeOp(op->Next); op = ExcludeOp(op); size -= 2; } else if (SlopesNearCollinear(op->Prev->Pt, op->Pt, op->Next->Pt, distSqrd)) { op = ExcludeOp(op); size--; } else { op->Idx = 1; op = op->Next; } } if (size < 3) size = 0; out_poly.resize(size); for (size_t i = 0; i < size; ++i) { out_poly[i] = op->Pt; op = op->Next; } delete [] outPts; } //------------------------------------------------------------------------------ void CleanPolygon(Path& poly, double distance) { CleanPolygon(poly, poly, distance); } //------------------------------------------------------------------------------ void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance) { for (Paths::size_type i = 0; i < in_polys.size(); ++i) CleanPolygon(in_polys[i], out_polys[i], distance); } //------------------------------------------------------------------------------ void CleanPolygons(Paths& polys, double distance) { CleanPolygons(polys, polys, distance); } //------------------------------------------------------------------------------ void Minkowski(const Path& poly, const Path& path, Paths& solution, bool isSum, bool isClosed) { int delta = (isClosed ? 1 : 0); size_t polyCnt = poly.size(); size_t pathCnt = path.size(); Paths pp; pp.reserve(pathCnt); if (isSum) for (size_t i = 0; i < pathCnt; ++i) { Path p; p.reserve(polyCnt); for (size_t j = 0; j < poly.size(); ++j) p.push_back(IntPoint(path[i].X + poly[j].X, path[i].Y + poly[j].Y)); pp.push_back(p); } else for (size_t i = 0; i < pathCnt; ++i) { Path p; p.reserve(polyCnt); for (size_t j = 0; j < poly.size(); ++j) p.push_back(IntPoint(path[i].X - poly[j].X, path[i].Y - poly[j].Y)); pp.push_back(p); } solution.clear(); solution.reserve((pathCnt + delta) * (polyCnt + 1)); for (size_t i = 0; i < pathCnt - 1 + delta; ++i) for (size_t j = 0; j < polyCnt; ++j) { Path quad; quad.reserve(4); quad.push_back(pp[i % pathCnt][j % polyCnt]); quad.push_back(pp[(i + 1) % pathCnt][j % polyCnt]); quad.push_back(pp[(i + 1) % pathCnt][(j + 1) % polyCnt]); quad.push_back(pp[i % pathCnt][(j + 1) % polyCnt]); if (!Orientation(quad)) ReversePath(quad); solution.push_back(quad); } } //------------------------------------------------------------------------------ void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed) { Minkowski(pattern, path, solution, true, pathIsClosed); Clipper c; c.AddPaths(solution, ptSubject, true); c.Execute(ctUnion, solution, pftNonZero, pftNonZero); } //------------------------------------------------------------------------------ void TranslatePath(const Path& input, Path& output, const IntPoint& delta) { //precondition: input != output output.resize(input.size()); for (size_t i = 0; i < input.size(); ++i) output[i] = IntPoint(input[i].X + delta.X, input[i].Y + delta.Y); } //------------------------------------------------------------------------------ void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed) { Clipper c; for (size_t i = 0; i < paths.size(); ++i) { Paths tmp; Minkowski(pattern, paths[i], tmp, true, pathIsClosed); c.AddPaths(tmp, ptSubject, true); if (pathIsClosed) { Path tmp2; TranslatePath(paths[i], tmp2, pattern[0]); c.AddPath(tmp2, ptClip, true); } } c.Execute(ctUnion, solution, pftNonZero, pftNonZero); } //------------------------------------------------------------------------------ void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution) { Minkowski(poly1, poly2, solution, false, true); Clipper c; c.AddPaths(solution, ptSubject, true); c.Execute(ctUnion, solution, pftNonZero, pftNonZero); } //------------------------------------------------------------------------------ enum NodeType {ntAny, ntOpen, ntClosed}; void AddPolyNodeToPaths(const PolyNode& polynode, NodeType nodetype, Paths& paths) { bool match = true; if (nodetype == ntClosed) match = !polynode.IsOpen(); else if (nodetype == ntOpen) return; if (!polynode.Contour.empty() && match) paths.push_back(polynode.Contour); for (int i = 0; i < polynode.ChildCount(); ++i) AddPolyNodeToPaths(*polynode.Childs[i], nodetype, paths); } //------------------------------------------------------------------------------ void PolyTreeToPaths(const PolyTree& polytree, Paths& paths) { paths.resize(0); paths.reserve(polytree.Total()); AddPolyNodeToPaths(polytree, ntAny, paths); } //------------------------------------------------------------------------------ void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths) { paths.resize(0); paths.reserve(polytree.Total()); AddPolyNodeToPaths(polytree, ntClosed, paths); } //------------------------------------------------------------------------------ void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths) { paths.resize(0); paths.reserve(polytree.Total()); //Open paths are top level only, so ... for (int i = 0; i < polytree.ChildCount(); ++i) if (polytree.Childs[i]->IsOpen()) paths.push_back(polytree.Childs[i]->Contour); } //------------------------------------------------------------------------------ std::ostream& operator <<(std::ostream &s, const IntPoint &p) { s << "(" << p.X << "," << p.Y << ")"; return s; } //------------------------------------------------------------------------------ std::ostream& operator <<(std::ostream &s, const Path &p) { if (p.empty()) return s; Path::size_type last = p.size() -1; for (Path::size_type i = 0; i < last; i++) s << "(" << p[i].X << "," << p[i].Y << "), "; s << "(" << p[last].X << "," << p[last].Y << ")\n"; return s; } //------------------------------------------------------------------------------ std::ostream& operator <<(std::ostream &s, const Paths &p) { for (Paths::size_type i = 0; i < p.size(); i++) s << p[i]; s << "\n"; return s; } //------------------------------------------------------------------------------ } //ClipperLib namespace Slic3r-version_1.31.6/xs/src/clipper.hpp000066400000000000000000000357311301441720000200770ustar00rootroot00000000000000/******************************************************************************* * * * Author : Angus Johnson * * Version : 6.2.9 * * Date : 16 February 2015 * * Website : http://www.angusj.com * * Copyright : Angus Johnson 2010-2015 * * * * License: * * Use, modification & distribution is subject to Boost Software License Ver 1. * * http://www.boost.org/LICENSE_1_0.txt * * * * Attributions: * * The code in this library is an extension of Bala Vatti's clipping algorithm: * * "A generic solution to polygon clipping" * * Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63. * * http://portal.acm.org/citation.cfm?id=129906 * * * * Computer graphics and geometric modeling: implementation and algorithms * * By Max K. Agoston * * Springer; 1 edition (January 4, 2005) * * http://books.google.com/books?q=vatti+clipping+agoston * * * * See also: * * "Polygon Offsetting by Computing Winding Numbers" * * Paper no. DETC2005-85513 pp. 565-575 * * ASME 2005 International Design Engineering Technical Conferences * * and Computers and Information in Engineering Conference (IDETC/CIE2005) * * September 24-28, 2005 , Long Beach, California, USA * * http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf * * * *******************************************************************************/ #ifndef clipper_hpp #define clipper_hpp #define CLIPPER_VERSION "6.2.6" //use_int32: When enabled 32bit ints are used instead of 64bit ints. This //improve performance but coordinate values are limited to the range +/- 46340 //#define use_int32 //use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance. //#define use_xyz //use_lines: Enables line clipping. Adds a very minor cost to performance. #define use_lines //use_deprecated: Enables temporary support for the obsolete functions //#define use_deprecated #include #include #include #include #include #include #include #include #include namespace ClipperLib { enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor }; enum PolyType { ptSubject, ptClip }; //By far the most widely used winding rules for polygon filling are //EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32) //Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL) //see http://glprogramming.com/red/chapter11.html enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative }; #ifdef use_int32 typedef int cInt; static cInt const loRange = 0x7FFF; static cInt const hiRange = 0x7FFF; #else typedef signed long long cInt; static cInt const loRange = 0x3FFFFFFF; static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL; typedef signed long long long64; //used by Int128 class typedef unsigned long long ulong64; #endif struct IntPoint { cInt X; cInt Y; #ifdef use_xyz cInt Z; IntPoint(cInt x = 0, cInt y = 0, cInt z = 0): X(x), Y(y), Z(z) {}; #else IntPoint(cInt x = 0, cInt y = 0): X(x), Y(y) {}; #endif friend inline bool operator== (const IntPoint& a, const IntPoint& b) { return a.X == b.X && a.Y == b.Y; } friend inline bool operator!= (const IntPoint& a, const IntPoint& b) { return a.X != b.X || a.Y != b.Y; } }; //------------------------------------------------------------------------------ typedef std::vector< IntPoint > Path; typedef std::vector< Path > Paths; inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;} inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;} std::ostream& operator <<(std::ostream &s, const IntPoint &p); std::ostream& operator <<(std::ostream &s, const Path &p); std::ostream& operator <<(std::ostream &s, const Paths &p); struct DoublePoint { double X; double Y; DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {} DoublePoint(IntPoint ip) : X((double)ip.X), Y((double)ip.Y) {} }; //------------------------------------------------------------------------------ #ifdef use_xyz typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, IntPoint& pt); #endif enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4}; enum JoinType {jtSquare, jtRound, jtMiter}; enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound}; class PolyNode; typedef std::vector< PolyNode* > PolyNodes; class PolyNode { public: PolyNode(); virtual ~PolyNode(){}; Path Contour; PolyNodes Childs; PolyNode* Parent; PolyNode* GetNext() const; bool IsHole() const; bool IsOpen() const; int ChildCount() const; private: unsigned Index; //node index in Parent.Childs bool m_IsOpen; JoinType m_jointype; EndType m_endtype; PolyNode* GetNextSiblingUp() const; void AddChild(PolyNode& child); friend class Clipper; //to access Index friend class ClipperOffset; }; class PolyTree: public PolyNode { public: ~PolyTree(){Clear();}; PolyNode* GetFirst() const; void Clear(); int Total() const; private: PolyNodes AllNodes; friend class Clipper; //to access AllNodes }; bool Orientation(const Path &poly); double Area(const Path &poly); int PointInPolygon(const IntPoint &pt, const Path &path); void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd); void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd); void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd); void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415); void CleanPolygon(Path& poly, double distance = 1.415); void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.415); void CleanPolygons(Paths& polys, double distance = 1.415); void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed); void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed); void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution); void PolyTreeToPaths(const PolyTree& polytree, Paths& paths); void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths); void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths); void ReversePath(Path& p); void ReversePaths(Paths& p); struct IntRect { cInt left; cInt top; cInt right; cInt bottom; }; //enums that are used internally ... enum EdgeSide { esLeft = 1, esRight = 2}; //forward declarations (for stuff used internally) ... struct TEdge; struct IntersectNode; struct LocalMinimum; struct OutPt; struct OutRec; struct Join; typedef std::vector < OutRec* > PolyOutList; typedef std::vector < TEdge* > EdgeList; typedef std::vector < Join* > JoinList; typedef std::vector < IntersectNode* > IntersectList; //------------------------------------------------------------------------------ //ClipperBase is the ancestor to the Clipper class. It should not be //instantiated directly. This class simply abstracts the conversion of sets of //polygon coordinates into edge objects that are stored in a LocalMinima list. class ClipperBase { public: ClipperBase(); virtual ~ClipperBase(); bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed); bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed); virtual void Clear(); IntRect GetBounds(); bool PreserveCollinear() const {return m_PreserveCollinear;}; void PreserveCollinear(bool value) {m_PreserveCollinear = value;}; protected: void DisposeLocalMinimaList(); TEdge* AddBoundsToLML(TEdge *e, bool IsClosed); void PopLocalMinima(); virtual void Reset(); TEdge* ProcessBound(TEdge* E, bool IsClockwise); TEdge* DescendToMin(TEdge *&E); void AscendToMax(TEdge *&E, bool Appending, bool IsClosed); typedef std::vector MinimaList; MinimaList::iterator m_CurrentLM; MinimaList m_MinimaList; bool m_UseFullRange; EdgeList m_edges; bool m_PreserveCollinear; bool m_HasOpenPaths; }; //------------------------------------------------------------------------------ class Clipper : public virtual ClipperBase { public: Clipper(int initOptions = 0); ~Clipper(); bool Execute(ClipType clipType, Paths &solution, PolyFillType fillType = pftEvenOdd); bool Execute(ClipType clipType, Paths &solution, PolyFillType subjFillType, PolyFillType clipFillType); bool Execute(ClipType clipType, PolyTree &polytree, PolyFillType fillType = pftEvenOdd); bool Execute(ClipType clipType, PolyTree &polytree, PolyFillType subjFillType, PolyFillType clipFillType); bool ReverseSolution() const { return m_ReverseOutput; }; void ReverseSolution(bool value) {m_ReverseOutput = value;}; bool StrictlySimple() const {return m_StrictSimple;}; void StrictlySimple(bool value) {m_StrictSimple = value;}; //set the callback function for z value filling on intersections (otherwise Z is 0) #ifdef use_xyz void ZFillFunction(ZFillCallback zFillFunc); #endif protected: void Reset(); virtual bool ExecuteInternal(); private: PolyOutList m_PolyOuts; JoinList m_Joins; JoinList m_GhostJoins; IntersectList m_IntersectList; ClipType m_ClipType; typedef std::priority_queue ScanbeamList; ScanbeamList m_Scanbeam; typedef std::list MaximaList; MaximaList m_Maxima; TEdge *m_ActiveEdges; TEdge *m_SortedEdges; bool m_ExecuteLocked; PolyFillType m_ClipFillType; PolyFillType m_SubjFillType; bool m_ReverseOutput; bool m_UsingPolyTree; bool m_StrictSimple; #ifdef use_xyz ZFillCallback m_ZFill; //custom callback #endif void SetWindingCount(TEdge& edge) const; bool IsEvenOddFillType(const TEdge& edge) const; bool IsEvenOddAltFillType(const TEdge& edge) const; void InsertScanbeam(const cInt Y); cInt PopScanbeam(); void InsertLocalMinimaIntoAEL(const cInt botY); void InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge); void AddEdgeToSEL(TEdge *edge); void CopyAELToSEL(); void DeleteFromSEL(TEdge *e); void DeleteFromAEL(TEdge *e); void UpdateEdgeIntoAEL(TEdge *&e); void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2); bool IsContributing(const TEdge& edge) const; bool IsTopHorz(const cInt XPos); void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2); void DoMaxima(TEdge *e); void ProcessHorizontals(); void ProcessHorizontal(TEdge *horzEdge); void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt); OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt); OutRec* GetOutRec(int idx); void AppendPolygon(TEdge *e1, TEdge *e2) const; void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt); OutRec* CreateOutRec(); OutPt* AddOutPt(TEdge *e, const IntPoint &pt); OutPt* GetLastOutPt(TEdge *e); void DisposeAllOutRecs(); void DisposeOutRec(PolyOutList::size_type index); bool ProcessIntersections(const cInt topY); void BuildIntersectList(const cInt topY); void ProcessIntersectList(); void ProcessEdgesAtTopOfScanbeam(const cInt topY); void BuildResult(Paths& polys); void BuildResult2(PolyTree& polytree); void SetHoleState(TEdge *e, OutRec *outrec) const; void DisposeIntersectNodes(); bool FixupIntersectionOrder(); void FixupOutPolygon(OutRec &outrec); void FixupOutPolyline(OutRec &outrec); bool IsHole(TEdge *e); bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl); void FixHoleLinkage(OutRec &outrec); void AddJoin(OutPt *op1, OutPt *op2, const IntPoint &offPt); void ClearJoins(); void ClearGhostJoins(); void AddGhostJoin(OutPt *op, const IntPoint &offPt); bool JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2); void JoinCommonEdges(); void DoSimplePolygons(); void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec) const; void FixupFirstLefts2(OutRec* OldOutRec, OutRec* NewOutRec) const; #ifdef use_xyz void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2); #endif }; //------------------------------------------------------------------------------ class ClipperOffset { public: ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25); ~ClipperOffset(); void AddPath(const Path& path, JoinType joinType, EndType endType); void AddPaths(const Paths& paths, JoinType joinType, EndType endType); void Execute(Paths& solution, double delta); void Execute(PolyTree& solution, double delta); void Clear(); double MiterLimit; double ArcTolerance; private: Paths m_destPolys; Path m_srcPoly; Path m_destPoly; std::vector m_normals; double m_delta, m_sinA, m_sin, m_cos; double m_miterLim, m_StepsPerRad; IntPoint m_lowest; PolyNode m_polyNodes; void FixOrientations(); void DoOffset(double delta); void OffsetPoint(int j, int& k, JoinType jointype); void DoSquare(int j, int k); void DoMiter(int j, int k, double r); void DoRound(int j, int k); }; //------------------------------------------------------------------------------ class clipperException : public std::exception { public: clipperException(const char* description): m_descr(description) {} virtual ~clipperException() throw() {} virtual const char* what() const throw() {return m_descr.c_str();} private: std::string m_descr; }; //------------------------------------------------------------------------------ } //ClipperLib namespace #endif //clipper_hpp Slic3r-version_1.31.6/xs/src/glew/000077500000000000000000000000001301441720000166555ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/glew/LICENSE.txt000066400000000000000000000073251301441720000205070ustar00rootroot00000000000000The OpenGL Extension Wrangler Library Copyright (C) 2002-2007, Milan Ikits Copyright (C) 2002-2007, Marcelo E. Magallon Copyright (C) 2002, Lev Povalahev All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Mesa 3-D graphics library Version: 7.0 Copyright (C) 1999-2007 Brian Paul All Rights Reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Copyright (c) 2007 The Khronos Group Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and/or associated documentation files (the "Materials"), to deal in the Materials without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Materials, and to permit persons to whom the Materials are furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Materials. THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. Slic3r-version_1.31.6/xs/src/glew/README.md000066400000000000000000000145661301441720000201500ustar00rootroot00000000000000THIS IS NOT THE COMPLETE GLEW DISTRIBUTION. ONLY FILES NEEDED FOR COMPILING GLEW INTO SLIC3R WERE PUT INTO THE SLIC3R SOURCE DISTRIBUTION. # GLEW - The OpenGL Extension Wrangler Library ![](http://glew.sourceforge.net/glew.png) http://glew.sourceforge.net/ https://github.com/nigels-com/glew [![Build Status](https://travis-ci.org/nigels-com/glew.svg?branch=master)](https://travis-ci.org/nigels-com/glew) [![Gitter](https://badges.gitter.im/nigels-com/glew.svg)](https://gitter.im/nigels-com/glew?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) [![Download](https://img.shields.io/sourceforge/dm/glew.svg)](https://sourceforge.net/projects/glew/files/latest/download) ## Downloads Current release is [2.0.0](https://sourceforge.net/projects/glew/files/glew/2.0.0/). [(Change Log)](http://glew.sourceforge.net/log.html) Sources available as [ZIP](https://sourceforge.net/projects/glew/files/glew/2.0.0/glew-2.0.0.zip/download) or [TGZ](https://sourceforge.net/projects/glew/files/glew/2.0.0/glew-2.0.0.tgz/download). Windows binaries for [32-bit and 64-bit](https://sourceforge.net/projects/glew/files/glew/2.0.0/glew-2.0.0-win32.zip/download). ### Recent snapshots Snapshots may contain new features, bug-fixes or new OpenGL extensions ahead of tested, official releases. [glew-20160708.tgz](http://sourceforge.net/projects/glew/files/glew/snapshots/glew-20160708.tgz/download) *GLEW 2.0.0 RC: Core context, EGL support, no MX* [glew-20160402.tgz](http://sourceforge.net/projects/glew/files/glew/snapshots/glew-20160402.tgz/download) *GLEW 2.0.0 RC: Core context, EGL support, no MX* ## Build From a downloaded tarball or zip archive: ### Linux and Mac #### Using GNU Make ##### Install build tools Debian/Ubuntu/Mint: `$ sudo apt-get install build-essential libxmu-dev libxi-dev libgl-dev libosmesa-dev git` RedHat/CentOS/Fedora: `$ sudo yum install libXmu-devel libXi-devel libGL-devel git` ##### Build $ make $ sudo make install $ make clean Targets: `all, glew.lib, glew.bin, clean, install, uninstall` Variables: `SYSTEM=linux-clang, GLEW_DEST=/usr/local, STRIP=` #### Using cmake *CMake 2.8.12 or higher is required.* ##### Install build tools Debian/Ubuntu/Mint: `$ sudo apt-get install build-essential libXmu-dev libXi-dev libgl-dev git cmake` RedHat/CentOS/Fedora: `$ sudo yum install libXmu-devel libXi-devel libGL-devel git cmake` ##### Build $ cd build $ cmake ./cmake $ make -j4 | Target | Description | | ---------- | ----------- | | glew | Build the glew shared library. | | glew_s | Build the glew static library. | | glewinfo | Build the `glewinfo` executable (requires `BUILD_UTILS` to be `ON`). | | visualinfo | Build the `visualinfo` executable (requires `BUILD_UTILS` to be `ON`). | | install | Install all enabled targets into `CMAKE_INSTALL_PREFIX`. | | clean | Clean up build artifacts. | | all | Build all enabled targets (default target). | | Variables | Description | | --------------- | ----------- | | BUILD_UTILS | Build the `glewinfo` and `visualinfo` executables. | | GLEW_REGAL | Build in Regal mode. | | GLEW_OSMESA | Build in off-screen Mesa mode. | | BUILD_FRAMEWORK | Build as MacOSX Framework. Setting `CMAKE_INSTALL_PREFIX` to `/Library/Frameworks` is recommended. | ### Windows #### Visual Studio Use the provided Visual Studio project file in build/vc12/ Projects for vc6 and vc10 are also provided #### MSYS/Mingw Available from [Mingw](http://www.mingw.org/) Requirements: bash, make, gcc $ mingw32-make $ mingw32-make install $ mingw32-make install.all Alternative toolchain: `SYSTEM=mingw-win32` #### MSYS2/Mingw-w64 Available from [Msys2](http://msys2.github.io/) and/or [Mingw-w64](http://mingw-w64.org/) Requirements: bash, make, gcc $ pacman -S gcc make mingw-w64-i686-gcc mingw-w64-x86_64-gcc $ make $ make install $ make install.all Alternative toolchain: `SYSTEM=msys, SYSTEM=msys-win32, SYSTEM=msys-win64` ## glewinfo `glewinfo` is a command-line tool useful for inspecting the capabilities of an OpenGL implementation and GLEW support for that. Please include the output of `glewinfo` with bug reports, as appropriate. --------------------------- GLEW Extension Info --------------------------- GLEW version 2.0.0 Reporting capabilities of pixelformat 3 Running on a Intel(R) HD Graphics 3000 from Intel OpenGL version 3.1.0 - Build 9.17.10.4229 is supported GL_VERSION_1_1: OK --------------- GL_VERSION_1_2: OK --------------- glCopyTexSubImage3D: OK glDrawRangeElements: OK glTexImage3D: OK glTexSubImage3D: OK ... ## Code Generation A Unix or Mac environment is neded for building GLEW from scratch to include new extensions, or customize the code generation. The extension data is regenerated from the top level source directory with: make extensions An alternative to generating the GLEW sources from scratch is to download a pre-generated (unsupported) snapshot: https://sourceforge.net/projects/glew/files/glew/snapshots/ Travis-built snapshots are also available: https://glew.s3.amazonaws.com/index.html ## Authors GLEW is currently maintained by [Nigel Stewart](https://github.com/nigels-com) with bug fixes, new OpenGL extension support and new releases. GLEW was developed by [Milan Ikits](http://www.cs.utah.edu/~ikits/) and [Marcelo Magallon](http://wwwvis.informatik.uni-stuttgart.de/~magallon/). Aaron Lefohn, Joe Kniss, and Chris Wyman were the first users and also assisted with the design and debugging process. The acronym GLEW originates from Aaron Lefohn. Pasi Kärkkäinen identified and fixed several problems with GLX and SDL. Nate Robins created the `wglinfo` utility, to which modifications were made by Michael Wimmer. ## Copyright and Licensing GLEW is originally derived from the EXTGL project by Lev Povalahev. The source code is licensed under the [Modified BSD License](http://glew.sourceforge.net/glew.txt), the [Mesa 3-D License](http://glew.sourceforge.net/mesa.txt) (MIT) and the [Khronos License](http://glew.sourceforge.net/khronos.txt) (MIT). The automatic code generation scripts are released under the [GNU GPL](http://glew.sourceforge.net/gpl.txt). Slic3r-version_1.31.6/xs/src/glew/include/000077500000000000000000000000001301441720000203005ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/glew/include/GL/000077500000000000000000000000001301441720000206025ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/glew/include/GL/glew.h000066400000000000000000037056711301441720000217340ustar00rootroot00000000000000/* ** The OpenGL Extension Wrangler Library ** Copyright (C) 2008-2015, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are met: ** ** * Redistributions of source code must retain the above copyright notice, ** this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright notice, ** this list of conditions and the following disclaimer in the documentation ** and/or other materials provided with the distribution. ** * The name of the author may be used to endorse or promote products ** derived from this software without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF ** THE POSSIBILITY OF SUCH DAMAGE. */ /* * Mesa 3-D graphics library * Version: 7.0 * * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* ** Copyright (c) 2007 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a ** copy of this software and/or associated documentation files (the ** "Materials"), to deal in the Materials without restriction, including ** without limitation the rights to use, copy, modify, merge, publish, ** distribute, sublicense, and/or sell copies of the Materials, and to ** permit persons to whom the Materials are furnished to do so, subject to ** the following conditions: ** ** The above copyright notice and this permission notice shall be included ** in all copies or substantial portions of the Materials. ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. */ #ifndef __glew_h__ #define __glew_h__ #define __GLEW_H__ #if defined(__gl_h_) || defined(__GL_H__) || defined(_GL_H) || defined(__X_GL_H) #error gl.h included before glew.h #endif #if defined(__gl2_h_) #error gl2.h included before glew.h #endif #if defined(__gltypes_h_) #error gltypes.h included before glew.h #endif #if defined(__REGAL_H__) #error Regal.h included before glew.h #endif #if defined(__glext_h_) || defined(__GLEXT_H_) #error glext.h included before glew.h #endif #if defined(__gl_ATI_h_) #error glATI.h included before glew.h #endif #define __gl_h_ #define __gl2_h_ #define __GL_H__ #define _GL_H #define __gltypes_h_ #define __REGAL_H__ #define __X_GL_H #define __glext_h_ #define __GLEXT_H_ #define __gl_ATI_h_ #if defined(_WIN32) /* * GLEW does not include to avoid name space pollution. * GL needs GLAPI and GLAPIENTRY, GLU needs APIENTRY, CALLBACK, and wchar_t * defined properly. */ /* and */ #ifdef APIENTRY # ifndef GLAPIENTRY # define GLAPIENTRY APIENTRY # endif # ifndef GLEWAPIENTRY # define GLEWAPIENTRY APIENTRY # endif #else #define GLEW_APIENTRY_DEFINED # if defined(__MINGW32__) || defined(__CYGWIN__) || (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) # define APIENTRY __stdcall # ifndef GLAPIENTRY # define GLAPIENTRY __stdcall # endif # ifndef GLEWAPIENTRY # define GLEWAPIENTRY __stdcall # endif # else # define APIENTRY # endif #endif #ifndef GLAPI # if defined(__MINGW32__) || defined(__CYGWIN__) # define GLAPI extern # endif #endif /* */ #ifndef CALLBACK #define GLEW_CALLBACK_DEFINED # if defined(__MINGW32__) || defined(__CYGWIN__) # define CALLBACK __attribute__ ((__stdcall__)) # elif (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) # define CALLBACK __stdcall # else # define CALLBACK # endif #endif /* and */ #ifndef WINGDIAPI #define GLEW_WINGDIAPI_DEFINED #define WINGDIAPI __declspec(dllimport) #endif /* */ #if (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(_WCHAR_T_DEFINED) typedef unsigned short wchar_t; # define _WCHAR_T_DEFINED #endif /* */ #if !defined(_W64) # if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && defined(_MSC_VER) && _MSC_VER >= 1300 # define _W64 __w64 # else # define _W64 # endif #endif #if !defined(_PTRDIFF_T_DEFINED) && !defined(_PTRDIFF_T_) && !defined(__MINGW64__) # ifdef _WIN64 typedef __int64 ptrdiff_t; # else typedef _W64 int ptrdiff_t; # endif # define _PTRDIFF_T_DEFINED # define _PTRDIFF_T_ #endif #ifndef GLAPI # if defined(__MINGW32__) || defined(__CYGWIN__) # define GLAPI extern # else # define GLAPI WINGDIAPI # endif #endif /* * GLEW_STATIC is defined for static library. * GLEW_BUILD is defined for building the DLL library. */ #ifdef GLEW_STATIC # define GLEWAPI extern #else # ifdef GLEW_BUILD # define GLEWAPI extern __declspec(dllexport) # else # define GLEWAPI extern __declspec(dllimport) # endif #endif #else /* _UNIX */ /* * Needed for ptrdiff_t in turn needed by VBO. This is defined by ISO * C. On my system, this amounts to _3 lines_ of included code, all of * them pretty much harmless. If you know of a way of detecting 32 vs * 64 _targets_ at compile time you are free to replace this with * something that's portable. For now, _this_ is the portable solution. * (mem, 2004-01-04) */ #include /* SGI MIPSPro doesn't like stdint.h in C++ mode */ /* ID: 3376260 Solaris 9 has inttypes.h, but not stdint.h */ #if (defined(__sgi) || defined(__sun)) && !defined(__GNUC__) #include #else #include #endif #define GLEW_APIENTRY_DEFINED #define APIENTRY /* * GLEW_STATIC is defined for static library. */ #ifdef GLEW_STATIC # define GLEWAPI extern #else # if defined(__GNUC__) && __GNUC__>=4 # define GLEWAPI extern __attribute__ ((visibility("default"))) # elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) # define GLEWAPI extern __global # else # define GLEWAPI extern # endif #endif /* */ #ifndef GLAPI #define GLAPI extern #endif #endif /* _WIN32 */ #ifndef GLAPIENTRY #define GLAPIENTRY #endif #ifndef GLEWAPIENTRY #define GLEWAPIENTRY #endif #ifdef __cplusplus extern "C" { #endif /* ----------------------------- GL_VERSION_1_1 ---------------------------- */ #ifndef GL_VERSION_1_1 #define GL_VERSION_1_1 1 typedef unsigned int GLenum; typedef unsigned int GLbitfield; typedef unsigned int GLuint; typedef int GLint; typedef int GLsizei; typedef unsigned char GLboolean; typedef signed char GLbyte; typedef short GLshort; typedef unsigned char GLubyte; typedef unsigned short GLushort; typedef unsigned long GLulong; typedef float GLfloat; typedef float GLclampf; typedef double GLdouble; typedef double GLclampd; typedef void GLvoid; #if defined(_MSC_VER) && _MSC_VER < 1400 typedef __int64 GLint64EXT; typedef unsigned __int64 GLuint64EXT; #elif defined(_MSC_VER) || defined(__BORLANDC__) typedef signed long long GLint64EXT; typedef unsigned long long GLuint64EXT; #else # if defined(__MINGW32__) || defined(__CYGWIN__) #include # endif typedef int64_t GLint64EXT; typedef uint64_t GLuint64EXT; #endif typedef GLint64EXT GLint64; typedef GLuint64EXT GLuint64; typedef struct __GLsync *GLsync; typedef char GLchar; #define GL_ZERO 0 #define GL_FALSE 0 #define GL_LOGIC_OP 0x0BF1 #define GL_NONE 0 #define GL_TEXTURE_COMPONENTS 0x1003 #define GL_NO_ERROR 0 #define GL_POINTS 0x0000 #define GL_CURRENT_BIT 0x00000001 #define GL_TRUE 1 #define GL_ONE 1 #define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 #define GL_LINES 0x0001 #define GL_LINE_LOOP 0x0002 #define GL_POINT_BIT 0x00000002 #define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 #define GL_LINE_STRIP 0x0003 #define GL_LINE_BIT 0x00000004 #define GL_TRIANGLES 0x0004 #define GL_TRIANGLE_STRIP 0x0005 #define GL_TRIANGLE_FAN 0x0006 #define GL_QUADS 0x0007 #define GL_QUAD_STRIP 0x0008 #define GL_POLYGON_BIT 0x00000008 #define GL_POLYGON 0x0009 #define GL_POLYGON_STIPPLE_BIT 0x00000010 #define GL_PIXEL_MODE_BIT 0x00000020 #define GL_LIGHTING_BIT 0x00000040 #define GL_FOG_BIT 0x00000080 #define GL_DEPTH_BUFFER_BIT 0x00000100 #define GL_ACCUM 0x0100 #define GL_LOAD 0x0101 #define GL_RETURN 0x0102 #define GL_MULT 0x0103 #define GL_ADD 0x0104 #define GL_NEVER 0x0200 #define GL_ACCUM_BUFFER_BIT 0x00000200 #define GL_LESS 0x0201 #define GL_EQUAL 0x0202 #define GL_LEQUAL 0x0203 #define GL_GREATER 0x0204 #define GL_NOTEQUAL 0x0205 #define GL_GEQUAL 0x0206 #define GL_ALWAYS 0x0207 #define GL_SRC_COLOR 0x0300 #define GL_ONE_MINUS_SRC_COLOR 0x0301 #define GL_SRC_ALPHA 0x0302 #define GL_ONE_MINUS_SRC_ALPHA 0x0303 #define GL_DST_ALPHA 0x0304 #define GL_ONE_MINUS_DST_ALPHA 0x0305 #define GL_DST_COLOR 0x0306 #define GL_ONE_MINUS_DST_COLOR 0x0307 #define GL_SRC_ALPHA_SATURATE 0x0308 #define GL_STENCIL_BUFFER_BIT 0x00000400 #define GL_FRONT_LEFT 0x0400 #define GL_FRONT_RIGHT 0x0401 #define GL_BACK_LEFT 0x0402 #define GL_BACK_RIGHT 0x0403 #define GL_FRONT 0x0404 #define GL_BACK 0x0405 #define GL_LEFT 0x0406 #define GL_RIGHT 0x0407 #define GL_FRONT_AND_BACK 0x0408 #define GL_AUX0 0x0409 #define GL_AUX1 0x040A #define GL_AUX2 0x040B #define GL_AUX3 0x040C #define GL_INVALID_ENUM 0x0500 #define GL_INVALID_VALUE 0x0501 #define GL_INVALID_OPERATION 0x0502 #define GL_STACK_OVERFLOW 0x0503 #define GL_STACK_UNDERFLOW 0x0504 #define GL_OUT_OF_MEMORY 0x0505 #define GL_2D 0x0600 #define GL_3D 0x0601 #define GL_3D_COLOR 0x0602 #define GL_3D_COLOR_TEXTURE 0x0603 #define GL_4D_COLOR_TEXTURE 0x0604 #define GL_PASS_THROUGH_TOKEN 0x0700 #define GL_POINT_TOKEN 0x0701 #define GL_LINE_TOKEN 0x0702 #define GL_POLYGON_TOKEN 0x0703 #define GL_BITMAP_TOKEN 0x0704 #define GL_DRAW_PIXEL_TOKEN 0x0705 #define GL_COPY_PIXEL_TOKEN 0x0706 #define GL_LINE_RESET_TOKEN 0x0707 #define GL_EXP 0x0800 #define GL_VIEWPORT_BIT 0x00000800 #define GL_EXP2 0x0801 #define GL_CW 0x0900 #define GL_CCW 0x0901 #define GL_COEFF 0x0A00 #define GL_ORDER 0x0A01 #define GL_DOMAIN 0x0A02 #define GL_CURRENT_COLOR 0x0B00 #define GL_CURRENT_INDEX 0x0B01 #define GL_CURRENT_NORMAL 0x0B02 #define GL_CURRENT_TEXTURE_COORDS 0x0B03 #define GL_CURRENT_RASTER_COLOR 0x0B04 #define GL_CURRENT_RASTER_INDEX 0x0B05 #define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 #define GL_CURRENT_RASTER_POSITION 0x0B07 #define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 #define GL_CURRENT_RASTER_DISTANCE 0x0B09 #define GL_POINT_SMOOTH 0x0B10 #define GL_POINT_SIZE 0x0B11 #define GL_POINT_SIZE_RANGE 0x0B12 #define GL_POINT_SIZE_GRANULARITY 0x0B13 #define GL_LINE_SMOOTH 0x0B20 #define GL_LINE_WIDTH 0x0B21 #define GL_LINE_WIDTH_RANGE 0x0B22 #define GL_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_LINE_STIPPLE 0x0B24 #define GL_LINE_STIPPLE_PATTERN 0x0B25 #define GL_LINE_STIPPLE_REPEAT 0x0B26 #define GL_LIST_MODE 0x0B30 #define GL_MAX_LIST_NESTING 0x0B31 #define GL_LIST_BASE 0x0B32 #define GL_LIST_INDEX 0x0B33 #define GL_POLYGON_MODE 0x0B40 #define GL_POLYGON_SMOOTH 0x0B41 #define GL_POLYGON_STIPPLE 0x0B42 #define GL_EDGE_FLAG 0x0B43 #define GL_CULL_FACE 0x0B44 #define GL_CULL_FACE_MODE 0x0B45 #define GL_FRONT_FACE 0x0B46 #define GL_LIGHTING 0x0B50 #define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 #define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 #define GL_LIGHT_MODEL_AMBIENT 0x0B53 #define GL_SHADE_MODEL 0x0B54 #define GL_COLOR_MATERIAL_FACE 0x0B55 #define GL_COLOR_MATERIAL_PARAMETER 0x0B56 #define GL_COLOR_MATERIAL 0x0B57 #define GL_FOG 0x0B60 #define GL_FOG_INDEX 0x0B61 #define GL_FOG_DENSITY 0x0B62 #define GL_FOG_START 0x0B63 #define GL_FOG_END 0x0B64 #define GL_FOG_MODE 0x0B65 #define GL_FOG_COLOR 0x0B66 #define GL_DEPTH_RANGE 0x0B70 #define GL_DEPTH_TEST 0x0B71 #define GL_DEPTH_WRITEMASK 0x0B72 #define GL_DEPTH_CLEAR_VALUE 0x0B73 #define GL_DEPTH_FUNC 0x0B74 #define GL_ACCUM_CLEAR_VALUE 0x0B80 #define GL_STENCIL_TEST 0x0B90 #define GL_STENCIL_CLEAR_VALUE 0x0B91 #define GL_STENCIL_FUNC 0x0B92 #define GL_STENCIL_VALUE_MASK 0x0B93 #define GL_STENCIL_FAIL 0x0B94 #define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 #define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 #define GL_STENCIL_REF 0x0B97 #define GL_STENCIL_WRITEMASK 0x0B98 #define GL_MATRIX_MODE 0x0BA0 #define GL_NORMALIZE 0x0BA1 #define GL_VIEWPORT 0x0BA2 #define GL_MODELVIEW_STACK_DEPTH 0x0BA3 #define GL_PROJECTION_STACK_DEPTH 0x0BA4 #define GL_TEXTURE_STACK_DEPTH 0x0BA5 #define GL_MODELVIEW_MATRIX 0x0BA6 #define GL_PROJECTION_MATRIX 0x0BA7 #define GL_TEXTURE_MATRIX 0x0BA8 #define GL_ATTRIB_STACK_DEPTH 0x0BB0 #define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 #define GL_ALPHA_TEST 0x0BC0 #define GL_ALPHA_TEST_FUNC 0x0BC1 #define GL_ALPHA_TEST_REF 0x0BC2 #define GL_DITHER 0x0BD0 #define GL_BLEND_DST 0x0BE0 #define GL_BLEND_SRC 0x0BE1 #define GL_BLEND 0x0BE2 #define GL_LOGIC_OP_MODE 0x0BF0 #define GL_INDEX_LOGIC_OP 0x0BF1 #define GL_COLOR_LOGIC_OP 0x0BF2 #define GL_AUX_BUFFERS 0x0C00 #define GL_DRAW_BUFFER 0x0C01 #define GL_READ_BUFFER 0x0C02 #define GL_SCISSOR_BOX 0x0C10 #define GL_SCISSOR_TEST 0x0C11 #define GL_INDEX_CLEAR_VALUE 0x0C20 #define GL_INDEX_WRITEMASK 0x0C21 #define GL_COLOR_CLEAR_VALUE 0x0C22 #define GL_COLOR_WRITEMASK 0x0C23 #define GL_INDEX_MODE 0x0C30 #define GL_RGBA_MODE 0x0C31 #define GL_DOUBLEBUFFER 0x0C32 #define GL_STEREO 0x0C33 #define GL_RENDER_MODE 0x0C40 #define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 #define GL_POINT_SMOOTH_HINT 0x0C51 #define GL_LINE_SMOOTH_HINT 0x0C52 #define GL_POLYGON_SMOOTH_HINT 0x0C53 #define GL_FOG_HINT 0x0C54 #define GL_TEXTURE_GEN_S 0x0C60 #define GL_TEXTURE_GEN_T 0x0C61 #define GL_TEXTURE_GEN_R 0x0C62 #define GL_TEXTURE_GEN_Q 0x0C63 #define GL_PIXEL_MAP_I_TO_I 0x0C70 #define GL_PIXEL_MAP_S_TO_S 0x0C71 #define GL_PIXEL_MAP_I_TO_R 0x0C72 #define GL_PIXEL_MAP_I_TO_G 0x0C73 #define GL_PIXEL_MAP_I_TO_B 0x0C74 #define GL_PIXEL_MAP_I_TO_A 0x0C75 #define GL_PIXEL_MAP_R_TO_R 0x0C76 #define GL_PIXEL_MAP_G_TO_G 0x0C77 #define GL_PIXEL_MAP_B_TO_B 0x0C78 #define GL_PIXEL_MAP_A_TO_A 0x0C79 #define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 #define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 #define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 #define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 #define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 #define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 #define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 #define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 #define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 #define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 #define GL_UNPACK_SWAP_BYTES 0x0CF0 #define GL_UNPACK_LSB_FIRST 0x0CF1 #define GL_UNPACK_ROW_LENGTH 0x0CF2 #define GL_UNPACK_SKIP_ROWS 0x0CF3 #define GL_UNPACK_SKIP_PIXELS 0x0CF4 #define GL_UNPACK_ALIGNMENT 0x0CF5 #define GL_PACK_SWAP_BYTES 0x0D00 #define GL_PACK_LSB_FIRST 0x0D01 #define GL_PACK_ROW_LENGTH 0x0D02 #define GL_PACK_SKIP_ROWS 0x0D03 #define GL_PACK_SKIP_PIXELS 0x0D04 #define GL_PACK_ALIGNMENT 0x0D05 #define GL_MAP_COLOR 0x0D10 #define GL_MAP_STENCIL 0x0D11 #define GL_INDEX_SHIFT 0x0D12 #define GL_INDEX_OFFSET 0x0D13 #define GL_RED_SCALE 0x0D14 #define GL_RED_BIAS 0x0D15 #define GL_ZOOM_X 0x0D16 #define GL_ZOOM_Y 0x0D17 #define GL_GREEN_SCALE 0x0D18 #define GL_GREEN_BIAS 0x0D19 #define GL_BLUE_SCALE 0x0D1A #define GL_BLUE_BIAS 0x0D1B #define GL_ALPHA_SCALE 0x0D1C #define GL_ALPHA_BIAS 0x0D1D #define GL_DEPTH_SCALE 0x0D1E #define GL_DEPTH_BIAS 0x0D1F #define GL_MAX_EVAL_ORDER 0x0D30 #define GL_MAX_LIGHTS 0x0D31 #define GL_MAX_CLIP_PLANES 0x0D32 #define GL_MAX_TEXTURE_SIZE 0x0D33 #define GL_MAX_PIXEL_MAP_TABLE 0x0D34 #define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 #define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 #define GL_MAX_NAME_STACK_DEPTH 0x0D37 #define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 #define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 #define GL_MAX_VIEWPORT_DIMS 0x0D3A #define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B #define GL_SUBPIXEL_BITS 0x0D50 #define GL_INDEX_BITS 0x0D51 #define GL_RED_BITS 0x0D52 #define GL_GREEN_BITS 0x0D53 #define GL_BLUE_BITS 0x0D54 #define GL_ALPHA_BITS 0x0D55 #define GL_DEPTH_BITS 0x0D56 #define GL_STENCIL_BITS 0x0D57 #define GL_ACCUM_RED_BITS 0x0D58 #define GL_ACCUM_GREEN_BITS 0x0D59 #define GL_ACCUM_BLUE_BITS 0x0D5A #define GL_ACCUM_ALPHA_BITS 0x0D5B #define GL_NAME_STACK_DEPTH 0x0D70 #define GL_AUTO_NORMAL 0x0D80 #define GL_MAP1_COLOR_4 0x0D90 #define GL_MAP1_INDEX 0x0D91 #define GL_MAP1_NORMAL 0x0D92 #define GL_MAP1_TEXTURE_COORD_1 0x0D93 #define GL_MAP1_TEXTURE_COORD_2 0x0D94 #define GL_MAP1_TEXTURE_COORD_3 0x0D95 #define GL_MAP1_TEXTURE_COORD_4 0x0D96 #define GL_MAP1_VERTEX_3 0x0D97 #define GL_MAP1_VERTEX_4 0x0D98 #define GL_MAP2_COLOR_4 0x0DB0 #define GL_MAP2_INDEX 0x0DB1 #define GL_MAP2_NORMAL 0x0DB2 #define GL_MAP2_TEXTURE_COORD_1 0x0DB3 #define GL_MAP2_TEXTURE_COORD_2 0x0DB4 #define GL_MAP2_TEXTURE_COORD_3 0x0DB5 #define GL_MAP2_TEXTURE_COORD_4 0x0DB6 #define GL_MAP2_VERTEX_3 0x0DB7 #define GL_MAP2_VERTEX_4 0x0DB8 #define GL_MAP1_GRID_DOMAIN 0x0DD0 #define GL_MAP1_GRID_SEGMENTS 0x0DD1 #define GL_MAP2_GRID_DOMAIN 0x0DD2 #define GL_MAP2_GRID_SEGMENTS 0x0DD3 #define GL_TEXTURE_1D 0x0DE0 #define GL_TEXTURE_2D 0x0DE1 #define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 #define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 #define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 #define GL_SELECTION_BUFFER_POINTER 0x0DF3 #define GL_SELECTION_BUFFER_SIZE 0x0DF4 #define GL_TEXTURE_WIDTH 0x1000 #define GL_TRANSFORM_BIT 0x00001000 #define GL_TEXTURE_HEIGHT 0x1001 #define GL_TEXTURE_INTERNAL_FORMAT 0x1003 #define GL_TEXTURE_BORDER_COLOR 0x1004 #define GL_TEXTURE_BORDER 0x1005 #define GL_DONT_CARE 0x1100 #define GL_FASTEST 0x1101 #define GL_NICEST 0x1102 #define GL_AMBIENT 0x1200 #define GL_DIFFUSE 0x1201 #define GL_SPECULAR 0x1202 #define GL_POSITION 0x1203 #define GL_SPOT_DIRECTION 0x1204 #define GL_SPOT_EXPONENT 0x1205 #define GL_SPOT_CUTOFF 0x1206 #define GL_CONSTANT_ATTENUATION 0x1207 #define GL_LINEAR_ATTENUATION 0x1208 #define GL_QUADRATIC_ATTENUATION 0x1209 #define GL_COMPILE 0x1300 #define GL_COMPILE_AND_EXECUTE 0x1301 #define GL_BYTE 0x1400 #define GL_UNSIGNED_BYTE 0x1401 #define GL_SHORT 0x1402 #define GL_UNSIGNED_SHORT 0x1403 #define GL_INT 0x1404 #define GL_UNSIGNED_INT 0x1405 #define GL_FLOAT 0x1406 #define GL_2_BYTES 0x1407 #define GL_3_BYTES 0x1408 #define GL_4_BYTES 0x1409 #define GL_DOUBLE 0x140A #define GL_CLEAR 0x1500 #define GL_AND 0x1501 #define GL_AND_REVERSE 0x1502 #define GL_COPY 0x1503 #define GL_AND_INVERTED 0x1504 #define GL_NOOP 0x1505 #define GL_XOR 0x1506 #define GL_OR 0x1507 #define GL_NOR 0x1508 #define GL_EQUIV 0x1509 #define GL_INVERT 0x150A #define GL_OR_REVERSE 0x150B #define GL_COPY_INVERTED 0x150C #define GL_OR_INVERTED 0x150D #define GL_NAND 0x150E #define GL_SET 0x150F #define GL_EMISSION 0x1600 #define GL_SHININESS 0x1601 #define GL_AMBIENT_AND_DIFFUSE 0x1602 #define GL_COLOR_INDEXES 0x1603 #define GL_MODELVIEW 0x1700 #define GL_PROJECTION 0x1701 #define GL_TEXTURE 0x1702 #define GL_COLOR 0x1800 #define GL_DEPTH 0x1801 #define GL_STENCIL 0x1802 #define GL_COLOR_INDEX 0x1900 #define GL_STENCIL_INDEX 0x1901 #define GL_DEPTH_COMPONENT 0x1902 #define GL_RED 0x1903 #define GL_GREEN 0x1904 #define GL_BLUE 0x1905 #define GL_ALPHA 0x1906 #define GL_RGB 0x1907 #define GL_RGBA 0x1908 #define GL_LUMINANCE 0x1909 #define GL_LUMINANCE_ALPHA 0x190A #define GL_BITMAP 0x1A00 #define GL_POINT 0x1B00 #define GL_LINE 0x1B01 #define GL_FILL 0x1B02 #define GL_RENDER 0x1C00 #define GL_FEEDBACK 0x1C01 #define GL_SELECT 0x1C02 #define GL_FLAT 0x1D00 #define GL_SMOOTH 0x1D01 #define GL_KEEP 0x1E00 #define GL_REPLACE 0x1E01 #define GL_INCR 0x1E02 #define GL_DECR 0x1E03 #define GL_VENDOR 0x1F00 #define GL_RENDERER 0x1F01 #define GL_VERSION 0x1F02 #define GL_EXTENSIONS 0x1F03 #define GL_S 0x2000 #define GL_ENABLE_BIT 0x00002000 #define GL_T 0x2001 #define GL_R 0x2002 #define GL_Q 0x2003 #define GL_MODULATE 0x2100 #define GL_DECAL 0x2101 #define GL_TEXTURE_ENV_MODE 0x2200 #define GL_TEXTURE_ENV_COLOR 0x2201 #define GL_TEXTURE_ENV 0x2300 #define GL_EYE_LINEAR 0x2400 #define GL_OBJECT_LINEAR 0x2401 #define GL_SPHERE_MAP 0x2402 #define GL_TEXTURE_GEN_MODE 0x2500 #define GL_OBJECT_PLANE 0x2501 #define GL_EYE_PLANE 0x2502 #define GL_NEAREST 0x2600 #define GL_LINEAR 0x2601 #define GL_NEAREST_MIPMAP_NEAREST 0x2700 #define GL_LINEAR_MIPMAP_NEAREST 0x2701 #define GL_NEAREST_MIPMAP_LINEAR 0x2702 #define GL_LINEAR_MIPMAP_LINEAR 0x2703 #define GL_TEXTURE_MAG_FILTER 0x2800 #define GL_TEXTURE_MIN_FILTER 0x2801 #define GL_TEXTURE_WRAP_S 0x2802 #define GL_TEXTURE_WRAP_T 0x2803 #define GL_CLAMP 0x2900 #define GL_REPEAT 0x2901 #define GL_POLYGON_OFFSET_UNITS 0x2A00 #define GL_POLYGON_OFFSET_POINT 0x2A01 #define GL_POLYGON_OFFSET_LINE 0x2A02 #define GL_R3_G3_B2 0x2A10 #define GL_V2F 0x2A20 #define GL_V3F 0x2A21 #define GL_C4UB_V2F 0x2A22 #define GL_C4UB_V3F 0x2A23 #define GL_C3F_V3F 0x2A24 #define GL_N3F_V3F 0x2A25 #define GL_C4F_N3F_V3F 0x2A26 #define GL_T2F_V3F 0x2A27 #define GL_T4F_V4F 0x2A28 #define GL_T2F_C4UB_V3F 0x2A29 #define GL_T2F_C3F_V3F 0x2A2A #define GL_T2F_N3F_V3F 0x2A2B #define GL_T2F_C4F_N3F_V3F 0x2A2C #define GL_T4F_C4F_N3F_V4F 0x2A2D #define GL_CLIP_PLANE0 0x3000 #define GL_CLIP_PLANE1 0x3001 #define GL_CLIP_PLANE2 0x3002 #define GL_CLIP_PLANE3 0x3003 #define GL_CLIP_PLANE4 0x3004 #define GL_CLIP_PLANE5 0x3005 #define GL_LIGHT0 0x4000 #define GL_COLOR_BUFFER_BIT 0x00004000 #define GL_LIGHT1 0x4001 #define GL_LIGHT2 0x4002 #define GL_LIGHT3 0x4003 #define GL_LIGHT4 0x4004 #define GL_LIGHT5 0x4005 #define GL_LIGHT6 0x4006 #define GL_LIGHT7 0x4007 #define GL_HINT_BIT 0x00008000 #define GL_POLYGON_OFFSET_FILL 0x8037 #define GL_POLYGON_OFFSET_FACTOR 0x8038 #define GL_ALPHA4 0x803B #define GL_ALPHA8 0x803C #define GL_ALPHA12 0x803D #define GL_ALPHA16 0x803E #define GL_LUMINANCE4 0x803F #define GL_LUMINANCE8 0x8040 #define GL_LUMINANCE12 0x8041 #define GL_LUMINANCE16 0x8042 #define GL_LUMINANCE4_ALPHA4 0x8043 #define GL_LUMINANCE6_ALPHA2 0x8044 #define GL_LUMINANCE8_ALPHA8 0x8045 #define GL_LUMINANCE12_ALPHA4 0x8046 #define GL_LUMINANCE12_ALPHA12 0x8047 #define GL_LUMINANCE16_ALPHA16 0x8048 #define GL_INTENSITY 0x8049 #define GL_INTENSITY4 0x804A #define GL_INTENSITY8 0x804B #define GL_INTENSITY12 0x804C #define GL_INTENSITY16 0x804D #define GL_RGB4 0x804F #define GL_RGB5 0x8050 #define GL_RGB8 0x8051 #define GL_RGB10 0x8052 #define GL_RGB12 0x8053 #define GL_RGB16 0x8054 #define GL_RGBA2 0x8055 #define GL_RGBA4 0x8056 #define GL_RGB5_A1 0x8057 #define GL_RGBA8 0x8058 #define GL_RGB10_A2 0x8059 #define GL_RGBA12 0x805A #define GL_RGBA16 0x805B #define GL_TEXTURE_RED_SIZE 0x805C #define GL_TEXTURE_GREEN_SIZE 0x805D #define GL_TEXTURE_BLUE_SIZE 0x805E #define GL_TEXTURE_ALPHA_SIZE 0x805F #define GL_TEXTURE_LUMINANCE_SIZE 0x8060 #define GL_TEXTURE_INTENSITY_SIZE 0x8061 #define GL_PROXY_TEXTURE_1D 0x8063 #define GL_PROXY_TEXTURE_2D 0x8064 #define GL_TEXTURE_PRIORITY 0x8066 #define GL_TEXTURE_RESIDENT 0x8067 #define GL_TEXTURE_BINDING_1D 0x8068 #define GL_TEXTURE_BINDING_2D 0x8069 #define GL_VERTEX_ARRAY 0x8074 #define GL_NORMAL_ARRAY 0x8075 #define GL_COLOR_ARRAY 0x8076 #define GL_INDEX_ARRAY 0x8077 #define GL_TEXTURE_COORD_ARRAY 0x8078 #define GL_EDGE_FLAG_ARRAY 0x8079 #define GL_VERTEX_ARRAY_SIZE 0x807A #define GL_VERTEX_ARRAY_TYPE 0x807B #define GL_VERTEX_ARRAY_STRIDE 0x807C #define GL_NORMAL_ARRAY_TYPE 0x807E #define GL_NORMAL_ARRAY_STRIDE 0x807F #define GL_COLOR_ARRAY_SIZE 0x8081 #define GL_COLOR_ARRAY_TYPE 0x8082 #define GL_COLOR_ARRAY_STRIDE 0x8083 #define GL_INDEX_ARRAY_TYPE 0x8085 #define GL_INDEX_ARRAY_STRIDE 0x8086 #define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 #define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 #define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A #define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C #define GL_VERTEX_ARRAY_POINTER 0x808E #define GL_NORMAL_ARRAY_POINTER 0x808F #define GL_COLOR_ARRAY_POINTER 0x8090 #define GL_INDEX_ARRAY_POINTER 0x8091 #define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 #define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_EVAL_BIT 0x00010000 #define GL_LIST_BIT 0x00020000 #define GL_TEXTURE_BIT 0x00040000 #define GL_SCISSOR_BIT 0x00080000 #define GL_ALL_ATTRIB_BITS 0x000fffff #define GL_CLIENT_ALL_ATTRIB_BITS 0xffffffff GLAPI void GLAPIENTRY glAccum (GLenum op, GLfloat value); GLAPI void GLAPIENTRY glAlphaFunc (GLenum func, GLclampf ref); GLAPI GLboolean GLAPIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences); GLAPI void GLAPIENTRY glArrayElement (GLint i); GLAPI void GLAPIENTRY glBegin (GLenum mode); GLAPI void GLAPIENTRY glBindTexture (GLenum target, GLuint texture); GLAPI void GLAPIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); GLAPI void GLAPIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor); GLAPI void GLAPIENTRY glCallList (GLuint list); GLAPI void GLAPIENTRY glCallLists (GLsizei n, GLenum type, const void *lists); GLAPI void GLAPIENTRY glClear (GLbitfield mask); GLAPI void GLAPIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); GLAPI void GLAPIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); GLAPI void GLAPIENTRY glClearDepth (GLclampd depth); GLAPI void GLAPIENTRY glClearIndex (GLfloat c); GLAPI void GLAPIENTRY glClearStencil (GLint s); GLAPI void GLAPIENTRY glClipPlane (GLenum plane, const GLdouble *equation); GLAPI void GLAPIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue); GLAPI void GLAPIENTRY glColor3bv (const GLbyte *v); GLAPI void GLAPIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue); GLAPI void GLAPIENTRY glColor3dv (const GLdouble *v); GLAPI void GLAPIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue); GLAPI void GLAPIENTRY glColor3fv (const GLfloat *v); GLAPI void GLAPIENTRY glColor3i (GLint red, GLint green, GLint blue); GLAPI void GLAPIENTRY glColor3iv (const GLint *v); GLAPI void GLAPIENTRY glColor3s (GLshort red, GLshort green, GLshort blue); GLAPI void GLAPIENTRY glColor3sv (const GLshort *v); GLAPI void GLAPIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue); GLAPI void GLAPIENTRY glColor3ubv (const GLubyte *v); GLAPI void GLAPIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue); GLAPI void GLAPIENTRY glColor3uiv (const GLuint *v); GLAPI void GLAPIENTRY glColor3us (GLushort red, GLushort green, GLushort blue); GLAPI void GLAPIENTRY glColor3usv (const GLushort *v); GLAPI void GLAPIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); GLAPI void GLAPIENTRY glColor4bv (const GLbyte *v); GLAPI void GLAPIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); GLAPI void GLAPIENTRY glColor4dv (const GLdouble *v); GLAPI void GLAPIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); GLAPI void GLAPIENTRY glColor4fv (const GLfloat *v); GLAPI void GLAPIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha); GLAPI void GLAPIENTRY glColor4iv (const GLint *v); GLAPI void GLAPIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha); GLAPI void GLAPIENTRY glColor4sv (const GLshort *v); GLAPI void GLAPIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); GLAPI void GLAPIENTRY glColor4ubv (const GLubyte *v); GLAPI void GLAPIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha); GLAPI void GLAPIENTRY glColor4uiv (const GLuint *v); GLAPI void GLAPIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha); GLAPI void GLAPIENTRY glColor4usv (const GLushort *v); GLAPI void GLAPIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); GLAPI void GLAPIENTRY glColorMaterial (GLenum face, GLenum mode); GLAPI void GLAPIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const void *pointer); GLAPI void GLAPIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); GLAPI void GLAPIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); GLAPI void GLAPIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); GLAPI void GLAPIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); GLAPI void GLAPIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); GLAPI void GLAPIENTRY glCullFace (GLenum mode); GLAPI void GLAPIENTRY glDeleteLists (GLuint list, GLsizei range); GLAPI void GLAPIENTRY glDeleteTextures (GLsizei n, const GLuint *textures); GLAPI void GLAPIENTRY glDepthFunc (GLenum func); GLAPI void GLAPIENTRY glDepthMask (GLboolean flag); GLAPI void GLAPIENTRY glDepthRange (GLclampd zNear, GLclampd zFar); GLAPI void GLAPIENTRY glDisable (GLenum cap); GLAPI void GLAPIENTRY glDisableClientState (GLenum array); GLAPI void GLAPIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count); GLAPI void GLAPIENTRY glDrawBuffer (GLenum mode); GLAPI void GLAPIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices); GLAPI void GLAPIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); GLAPI void GLAPIENTRY glEdgeFlag (GLboolean flag); GLAPI void GLAPIENTRY glEdgeFlagPointer (GLsizei stride, const void *pointer); GLAPI void GLAPIENTRY glEdgeFlagv (const GLboolean *flag); GLAPI void GLAPIENTRY glEnable (GLenum cap); GLAPI void GLAPIENTRY glEnableClientState (GLenum array); GLAPI void GLAPIENTRY glEnd (void); GLAPI void GLAPIENTRY glEndList (void); GLAPI void GLAPIENTRY glEvalCoord1d (GLdouble u); GLAPI void GLAPIENTRY glEvalCoord1dv (const GLdouble *u); GLAPI void GLAPIENTRY glEvalCoord1f (GLfloat u); GLAPI void GLAPIENTRY glEvalCoord1fv (const GLfloat *u); GLAPI void GLAPIENTRY glEvalCoord2d (GLdouble u, GLdouble v); GLAPI void GLAPIENTRY glEvalCoord2dv (const GLdouble *u); GLAPI void GLAPIENTRY glEvalCoord2f (GLfloat u, GLfloat v); GLAPI void GLAPIENTRY glEvalCoord2fv (const GLfloat *u); GLAPI void GLAPIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2); GLAPI void GLAPIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); GLAPI void GLAPIENTRY glEvalPoint1 (GLint i); GLAPI void GLAPIENTRY glEvalPoint2 (GLint i, GLint j); GLAPI void GLAPIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer); GLAPI void GLAPIENTRY glFinish (void); GLAPI void GLAPIENTRY glFlush (void); GLAPI void GLAPIENTRY glFogf (GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glFogfv (GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glFogi (GLenum pname, GLint param); GLAPI void GLAPIENTRY glFogiv (GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glFrontFace (GLenum mode); GLAPI void GLAPIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); GLAPI GLuint GLAPIENTRY glGenLists (GLsizei range); GLAPI void GLAPIENTRY glGenTextures (GLsizei n, GLuint *textures); GLAPI void GLAPIENTRY glGetBooleanv (GLenum pname, GLboolean *params); GLAPI void GLAPIENTRY glGetClipPlane (GLenum plane, GLdouble *equation); GLAPI void GLAPIENTRY glGetDoublev (GLenum pname, GLdouble *params); GLAPI GLenum GLAPIENTRY glGetError (void); GLAPI void GLAPIENTRY glGetFloatv (GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetIntegerv (GLenum pname, GLint *params); GLAPI void GLAPIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params); GLAPI void GLAPIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v); GLAPI void GLAPIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v); GLAPI void GLAPIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v); GLAPI void GLAPIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params); GLAPI void GLAPIENTRY glGetPixelMapfv (GLenum map, GLfloat *values); GLAPI void GLAPIENTRY glGetPixelMapuiv (GLenum map, GLuint *values); GLAPI void GLAPIENTRY glGetPixelMapusv (GLenum map, GLushort *values); GLAPI void GLAPIENTRY glGetPointerv (GLenum pname, void* *params); GLAPI void GLAPIENTRY glGetPolygonStipple (GLubyte *mask); GLAPI const GLubyte * GLAPIENTRY glGetString (GLenum name); GLAPI void GLAPIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params); GLAPI void GLAPIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params); GLAPI void GLAPIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params); GLAPI void GLAPIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels); GLAPI void GLAPIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params); GLAPI void GLAPIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params); GLAPI void GLAPIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params); GLAPI void GLAPIENTRY glHint (GLenum target, GLenum mode); GLAPI void GLAPIENTRY glIndexMask (GLuint mask); GLAPI void GLAPIENTRY glIndexPointer (GLenum type, GLsizei stride, const void *pointer); GLAPI void GLAPIENTRY glIndexd (GLdouble c); GLAPI void GLAPIENTRY glIndexdv (const GLdouble *c); GLAPI void GLAPIENTRY glIndexf (GLfloat c); GLAPI void GLAPIENTRY glIndexfv (const GLfloat *c); GLAPI void GLAPIENTRY glIndexi (GLint c); GLAPI void GLAPIENTRY glIndexiv (const GLint *c); GLAPI void GLAPIENTRY glIndexs (GLshort c); GLAPI void GLAPIENTRY glIndexsv (const GLshort *c); GLAPI void GLAPIENTRY glIndexub (GLubyte c); GLAPI void GLAPIENTRY glIndexubv (const GLubyte *c); GLAPI void GLAPIENTRY glInitNames (void); GLAPI void GLAPIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const void *pointer); GLAPI GLboolean GLAPIENTRY glIsEnabled (GLenum cap); GLAPI GLboolean GLAPIENTRY glIsList (GLuint list); GLAPI GLboolean GLAPIENTRY glIsTexture (GLuint texture); GLAPI void GLAPIENTRY glLightModelf (GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glLightModelfv (GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glLightModeli (GLenum pname, GLint param); GLAPI void GLAPIENTRY glLightModeliv (GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glLightf (GLenum light, GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glLighti (GLenum light, GLenum pname, GLint param); GLAPI void GLAPIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glLineStipple (GLint factor, GLushort pattern); GLAPI void GLAPIENTRY glLineWidth (GLfloat width); GLAPI void GLAPIENTRY glListBase (GLuint base); GLAPI void GLAPIENTRY glLoadIdentity (void); GLAPI void GLAPIENTRY glLoadMatrixd (const GLdouble *m); GLAPI void GLAPIENTRY glLoadMatrixf (const GLfloat *m); GLAPI void GLAPIENTRY glLoadName (GLuint name); GLAPI void GLAPIENTRY glLogicOp (GLenum opcode); GLAPI void GLAPIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); GLAPI void GLAPIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); GLAPI void GLAPIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); GLAPI void GLAPIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); GLAPI void GLAPIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2); GLAPI void GLAPIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2); GLAPI void GLAPIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); GLAPI void GLAPIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); GLAPI void GLAPIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glMateriali (GLenum face, GLenum pname, GLint param); GLAPI void GLAPIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glMatrixMode (GLenum mode); GLAPI void GLAPIENTRY glMultMatrixd (const GLdouble *m); GLAPI void GLAPIENTRY glMultMatrixf (const GLfloat *m); GLAPI void GLAPIENTRY glNewList (GLuint list, GLenum mode); GLAPI void GLAPIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz); GLAPI void GLAPIENTRY glNormal3bv (const GLbyte *v); GLAPI void GLAPIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz); GLAPI void GLAPIENTRY glNormal3dv (const GLdouble *v); GLAPI void GLAPIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz); GLAPI void GLAPIENTRY glNormal3fv (const GLfloat *v); GLAPI void GLAPIENTRY glNormal3i (GLint nx, GLint ny, GLint nz); GLAPI void GLAPIENTRY glNormal3iv (const GLint *v); GLAPI void GLAPIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz); GLAPI void GLAPIENTRY glNormal3sv (const GLshort *v); GLAPI void GLAPIENTRY glNormalPointer (GLenum type, GLsizei stride, const void *pointer); GLAPI void GLAPIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); GLAPI void GLAPIENTRY glPassThrough (GLfloat token); GLAPI void GLAPIENTRY glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values); GLAPI void GLAPIENTRY glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values); GLAPI void GLAPIENTRY glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values); GLAPI void GLAPIENTRY glPixelStoref (GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glPixelStorei (GLenum pname, GLint param); GLAPI void GLAPIENTRY glPixelTransferf (GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glPixelTransferi (GLenum pname, GLint param); GLAPI void GLAPIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor); GLAPI void GLAPIENTRY glPointSize (GLfloat size); GLAPI void GLAPIENTRY glPolygonMode (GLenum face, GLenum mode); GLAPI void GLAPIENTRY glPolygonOffset (GLfloat factor, GLfloat units); GLAPI void GLAPIENTRY glPolygonStipple (const GLubyte *mask); GLAPI void GLAPIENTRY glPopAttrib (void); GLAPI void GLAPIENTRY glPopClientAttrib (void); GLAPI void GLAPIENTRY glPopMatrix (void); GLAPI void GLAPIENTRY glPopName (void); GLAPI void GLAPIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities); GLAPI void GLAPIENTRY glPushAttrib (GLbitfield mask); GLAPI void GLAPIENTRY glPushClientAttrib (GLbitfield mask); GLAPI void GLAPIENTRY glPushMatrix (void); GLAPI void GLAPIENTRY glPushName (GLuint name); GLAPI void GLAPIENTRY glRasterPos2d (GLdouble x, GLdouble y); GLAPI void GLAPIENTRY glRasterPos2dv (const GLdouble *v); GLAPI void GLAPIENTRY glRasterPos2f (GLfloat x, GLfloat y); GLAPI void GLAPIENTRY glRasterPos2fv (const GLfloat *v); GLAPI void GLAPIENTRY glRasterPos2i (GLint x, GLint y); GLAPI void GLAPIENTRY glRasterPos2iv (const GLint *v); GLAPI void GLAPIENTRY glRasterPos2s (GLshort x, GLshort y); GLAPI void GLAPIENTRY glRasterPos2sv (const GLshort *v); GLAPI void GLAPIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z); GLAPI void GLAPIENTRY glRasterPos3dv (const GLdouble *v); GLAPI void GLAPIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z); GLAPI void GLAPIENTRY glRasterPos3fv (const GLfloat *v); GLAPI void GLAPIENTRY glRasterPos3i (GLint x, GLint y, GLint z); GLAPI void GLAPIENTRY glRasterPos3iv (const GLint *v); GLAPI void GLAPIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z); GLAPI void GLAPIENTRY glRasterPos3sv (const GLshort *v); GLAPI void GLAPIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); GLAPI void GLAPIENTRY glRasterPos4dv (const GLdouble *v); GLAPI void GLAPIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); GLAPI void GLAPIENTRY glRasterPos4fv (const GLfloat *v); GLAPI void GLAPIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w); GLAPI void GLAPIENTRY glRasterPos4iv (const GLint *v); GLAPI void GLAPIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w); GLAPI void GLAPIENTRY glRasterPos4sv (const GLshort *v); GLAPI void GLAPIENTRY glReadBuffer (GLenum mode); GLAPI void GLAPIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); GLAPI void GLAPIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); GLAPI void GLAPIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2); GLAPI void GLAPIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); GLAPI void GLAPIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2); GLAPI void GLAPIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2); GLAPI void GLAPIENTRY glRectiv (const GLint *v1, const GLint *v2); GLAPI void GLAPIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2); GLAPI void GLAPIENTRY glRectsv (const GLshort *v1, const GLshort *v2); GLAPI GLint GLAPIENTRY glRenderMode (GLenum mode); GLAPI void GLAPIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); GLAPI void GLAPIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); GLAPI void GLAPIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z); GLAPI void GLAPIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z); GLAPI void GLAPIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height); GLAPI void GLAPIENTRY glSelectBuffer (GLsizei size, GLuint *buffer); GLAPI void GLAPIENTRY glShadeModel (GLenum mode); GLAPI void GLAPIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask); GLAPI void GLAPIENTRY glStencilMask (GLuint mask); GLAPI void GLAPIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass); GLAPI void GLAPIENTRY glTexCoord1d (GLdouble s); GLAPI void GLAPIENTRY glTexCoord1dv (const GLdouble *v); GLAPI void GLAPIENTRY glTexCoord1f (GLfloat s); GLAPI void GLAPIENTRY glTexCoord1fv (const GLfloat *v); GLAPI void GLAPIENTRY glTexCoord1i (GLint s); GLAPI void GLAPIENTRY glTexCoord1iv (const GLint *v); GLAPI void GLAPIENTRY glTexCoord1s (GLshort s); GLAPI void GLAPIENTRY glTexCoord1sv (const GLshort *v); GLAPI void GLAPIENTRY glTexCoord2d (GLdouble s, GLdouble t); GLAPI void GLAPIENTRY glTexCoord2dv (const GLdouble *v); GLAPI void GLAPIENTRY glTexCoord2f (GLfloat s, GLfloat t); GLAPI void GLAPIENTRY glTexCoord2fv (const GLfloat *v); GLAPI void GLAPIENTRY glTexCoord2i (GLint s, GLint t); GLAPI void GLAPIENTRY glTexCoord2iv (const GLint *v); GLAPI void GLAPIENTRY glTexCoord2s (GLshort s, GLshort t); GLAPI void GLAPIENTRY glTexCoord2sv (const GLshort *v); GLAPI void GLAPIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r); GLAPI void GLAPIENTRY glTexCoord3dv (const GLdouble *v); GLAPI void GLAPIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r); GLAPI void GLAPIENTRY glTexCoord3fv (const GLfloat *v); GLAPI void GLAPIENTRY glTexCoord3i (GLint s, GLint t, GLint r); GLAPI void GLAPIENTRY glTexCoord3iv (const GLint *v); GLAPI void GLAPIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r); GLAPI void GLAPIENTRY glTexCoord3sv (const GLshort *v); GLAPI void GLAPIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q); GLAPI void GLAPIENTRY glTexCoord4dv (const GLdouble *v); GLAPI void GLAPIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q); GLAPI void GLAPIENTRY glTexCoord4fv (const GLfloat *v); GLAPI void GLAPIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q); GLAPI void GLAPIENTRY glTexCoord4iv (const GLint *v); GLAPI void GLAPIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q); GLAPI void GLAPIENTRY glTexCoord4sv (const GLshort *v); GLAPI void GLAPIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const void *pointer); GLAPI void GLAPIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param); GLAPI void GLAPIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param); GLAPI void GLAPIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params); GLAPI void GLAPIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param); GLAPI void GLAPIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); GLAPI void GLAPIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); GLAPI void GLAPIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param); GLAPI void GLAPIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params); GLAPI void GLAPIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param); GLAPI void GLAPIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params); GLAPI void GLAPIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); GLAPI void GLAPIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); GLAPI void GLAPIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z); GLAPI void GLAPIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z); GLAPI void GLAPIENTRY glVertex2d (GLdouble x, GLdouble y); GLAPI void GLAPIENTRY glVertex2dv (const GLdouble *v); GLAPI void GLAPIENTRY glVertex2f (GLfloat x, GLfloat y); GLAPI void GLAPIENTRY glVertex2fv (const GLfloat *v); GLAPI void GLAPIENTRY glVertex2i (GLint x, GLint y); GLAPI void GLAPIENTRY glVertex2iv (const GLint *v); GLAPI void GLAPIENTRY glVertex2s (GLshort x, GLshort y); GLAPI void GLAPIENTRY glVertex2sv (const GLshort *v); GLAPI void GLAPIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z); GLAPI void GLAPIENTRY glVertex3dv (const GLdouble *v); GLAPI void GLAPIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z); GLAPI void GLAPIENTRY glVertex3fv (const GLfloat *v); GLAPI void GLAPIENTRY glVertex3i (GLint x, GLint y, GLint z); GLAPI void GLAPIENTRY glVertex3iv (const GLint *v); GLAPI void GLAPIENTRY glVertex3s (GLshort x, GLshort y, GLshort z); GLAPI void GLAPIENTRY glVertex3sv (const GLshort *v); GLAPI void GLAPIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); GLAPI void GLAPIENTRY glVertex4dv (const GLdouble *v); GLAPI void GLAPIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); GLAPI void GLAPIENTRY glVertex4fv (const GLfloat *v); GLAPI void GLAPIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w); GLAPI void GLAPIENTRY glVertex4iv (const GLint *v); GLAPI void GLAPIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w); GLAPI void GLAPIENTRY glVertex4sv (const GLshort *v); GLAPI void GLAPIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const void *pointer); GLAPI void GLAPIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height); #define GLEW_VERSION_1_1 GLEW_GET_VAR(__GLEW_VERSION_1_1) #endif /* GL_VERSION_1_1 */ /* ---------------------------------- GLU ---------------------------------- */ #ifndef GLEW_NO_GLU # ifdef __APPLE__ # include # if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) # define GLEW_NO_GLU # endif # endif #endif #ifndef GLEW_NO_GLU /* this is where we can safely include GLU */ # if defined(__APPLE__) && defined(__MACH__) # include # else # include # endif #endif /* ----------------------------- GL_VERSION_1_2 ---------------------------- */ #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_RESCALE_NORMAL 0x803A #define GL_TEXTURE_BINDING_3D 0x806A #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_TEXTURE_3D 0x806F #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_CLAMP_TO_EDGE 0x812F #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_SINGLE_COLOR 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); #define glCopyTexSubImage3D GLEW_GET_FUN(__glewCopyTexSubImage3D) #define glDrawRangeElements GLEW_GET_FUN(__glewDrawRangeElements) #define glTexImage3D GLEW_GET_FUN(__glewTexImage3D) #define glTexSubImage3D GLEW_GET_FUN(__glewTexSubImage3D) #define GLEW_VERSION_1_2 GLEW_GET_VAR(__GLEW_VERSION_1_2) #endif /* GL_VERSION_1_2 */ /* ---------------------------- GL_VERSION_1_2_1 --------------------------- */ #ifndef GL_VERSION_1_2_1 #define GL_VERSION_1_2_1 1 #define GLEW_VERSION_1_2_1 GLEW_GET_VAR(__GLEW_VERSION_1_2_1) #endif /* GL_VERSION_1_2_1 */ /* ----------------------------- GL_VERSION_1_3 ---------------------------- */ #ifndef GL_VERSION_1_3 #define GL_VERSION_1_3 1 #define GL_MULTISAMPLE 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLES 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_CLAMP_TO_BORDER 0x812D #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_SUBTRACT 0x84E7 #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_NORMAL_MAP 0x8511 #define GL_REFLECTION_MAP 0x8512 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_COMBINE 0x8570 #define GL_COMBINE_RGB 0x8571 #define GL_COMBINE_ALPHA 0x8572 #define GL_RGB_SCALE 0x8573 #define GL_ADD_SIGNED 0x8574 #define GL_INTERPOLATE 0x8575 #define GL_CONSTANT 0x8576 #define GL_PRIMARY_COLOR 0x8577 #define GL_PREVIOUS 0x8578 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_RGB 0x8582 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE2_ALPHA 0x858A #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_RGB 0x8592 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND2_ALPHA 0x859A #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #define GL_MULTISAMPLE_BIT 0x20000000 typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREPROC) (GLenum texture); typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint lod, void *img); typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble m[16]); typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat m[16]); typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble m[16]); typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat m[16]); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); #define glActiveTexture GLEW_GET_FUN(__glewActiveTexture) #define glClientActiveTexture GLEW_GET_FUN(__glewClientActiveTexture) #define glCompressedTexImage1D GLEW_GET_FUN(__glewCompressedTexImage1D) #define glCompressedTexImage2D GLEW_GET_FUN(__glewCompressedTexImage2D) #define glCompressedTexImage3D GLEW_GET_FUN(__glewCompressedTexImage3D) #define glCompressedTexSubImage1D GLEW_GET_FUN(__glewCompressedTexSubImage1D) #define glCompressedTexSubImage2D GLEW_GET_FUN(__glewCompressedTexSubImage2D) #define glCompressedTexSubImage3D GLEW_GET_FUN(__glewCompressedTexSubImage3D) #define glGetCompressedTexImage GLEW_GET_FUN(__glewGetCompressedTexImage) #define glLoadTransposeMatrixd GLEW_GET_FUN(__glewLoadTransposeMatrixd) #define glLoadTransposeMatrixf GLEW_GET_FUN(__glewLoadTransposeMatrixf) #define glMultTransposeMatrixd GLEW_GET_FUN(__glewMultTransposeMatrixd) #define glMultTransposeMatrixf GLEW_GET_FUN(__glewMultTransposeMatrixf) #define glMultiTexCoord1d GLEW_GET_FUN(__glewMultiTexCoord1d) #define glMultiTexCoord1dv GLEW_GET_FUN(__glewMultiTexCoord1dv) #define glMultiTexCoord1f GLEW_GET_FUN(__glewMultiTexCoord1f) #define glMultiTexCoord1fv GLEW_GET_FUN(__glewMultiTexCoord1fv) #define glMultiTexCoord1i GLEW_GET_FUN(__glewMultiTexCoord1i) #define glMultiTexCoord1iv GLEW_GET_FUN(__glewMultiTexCoord1iv) #define glMultiTexCoord1s GLEW_GET_FUN(__glewMultiTexCoord1s) #define glMultiTexCoord1sv GLEW_GET_FUN(__glewMultiTexCoord1sv) #define glMultiTexCoord2d GLEW_GET_FUN(__glewMultiTexCoord2d) #define glMultiTexCoord2dv GLEW_GET_FUN(__glewMultiTexCoord2dv) #define glMultiTexCoord2f GLEW_GET_FUN(__glewMultiTexCoord2f) #define glMultiTexCoord2fv GLEW_GET_FUN(__glewMultiTexCoord2fv) #define glMultiTexCoord2i GLEW_GET_FUN(__glewMultiTexCoord2i) #define glMultiTexCoord2iv GLEW_GET_FUN(__glewMultiTexCoord2iv) #define glMultiTexCoord2s GLEW_GET_FUN(__glewMultiTexCoord2s) #define glMultiTexCoord2sv GLEW_GET_FUN(__glewMultiTexCoord2sv) #define glMultiTexCoord3d GLEW_GET_FUN(__glewMultiTexCoord3d) #define glMultiTexCoord3dv GLEW_GET_FUN(__glewMultiTexCoord3dv) #define glMultiTexCoord3f GLEW_GET_FUN(__glewMultiTexCoord3f) #define glMultiTexCoord3fv GLEW_GET_FUN(__glewMultiTexCoord3fv) #define glMultiTexCoord3i GLEW_GET_FUN(__glewMultiTexCoord3i) #define glMultiTexCoord3iv GLEW_GET_FUN(__glewMultiTexCoord3iv) #define glMultiTexCoord3s GLEW_GET_FUN(__glewMultiTexCoord3s) #define glMultiTexCoord3sv GLEW_GET_FUN(__glewMultiTexCoord3sv) #define glMultiTexCoord4d GLEW_GET_FUN(__glewMultiTexCoord4d) #define glMultiTexCoord4dv GLEW_GET_FUN(__glewMultiTexCoord4dv) #define glMultiTexCoord4f GLEW_GET_FUN(__glewMultiTexCoord4f) #define glMultiTexCoord4fv GLEW_GET_FUN(__glewMultiTexCoord4fv) #define glMultiTexCoord4i GLEW_GET_FUN(__glewMultiTexCoord4i) #define glMultiTexCoord4iv GLEW_GET_FUN(__glewMultiTexCoord4iv) #define glMultiTexCoord4s GLEW_GET_FUN(__glewMultiTexCoord4s) #define glMultiTexCoord4sv GLEW_GET_FUN(__glewMultiTexCoord4sv) #define glSampleCoverage GLEW_GET_FUN(__glewSampleCoverage) #define GLEW_VERSION_1_3 GLEW_GET_VAR(__GLEW_VERSION_1_3) #endif /* GL_VERSION_1_3 */ /* ----------------------------- GL_VERSION_1_4 ---------------------------- */ #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_MIRRORED_REPEAT 0x8370 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORDINATE 0x8451 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_COLOR_SUM 0x8458 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_INCR_WRAP 0x8507 #define GL_DECR_WRAP 0x8508 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_R_TO_TEXTURE 0x884E typedef void (GLAPIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode); typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLFOGCOORDDPROC) (GLdouble coord); typedef void (GLAPIENTRY * PFNGLFOGCOORDDVPROC) (const GLdouble *coord); typedef void (GLAPIENTRY * PFNGLFOGCOORDFPROC) (GLfloat coord); typedef void (GLAPIENTRY * PFNGLFOGCOORDFVPROC) (const GLfloat *coord); typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const void *const* indices, GLsizei drawcount); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVPROC) (const GLdouble *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVPROC) (const GLfloat *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IPROC) (GLint x, GLint y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVPROC) (const GLint *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVPROC) (const GLshort *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVPROC) (const GLdouble *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVPROC) (const GLfloat *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVPROC) (const GLint *p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVPROC) (const GLshort *p); #define glBlendColor GLEW_GET_FUN(__glewBlendColor) #define glBlendEquation GLEW_GET_FUN(__glewBlendEquation) #define glBlendFuncSeparate GLEW_GET_FUN(__glewBlendFuncSeparate) #define glFogCoordPointer GLEW_GET_FUN(__glewFogCoordPointer) #define glFogCoordd GLEW_GET_FUN(__glewFogCoordd) #define glFogCoorddv GLEW_GET_FUN(__glewFogCoorddv) #define glFogCoordf GLEW_GET_FUN(__glewFogCoordf) #define glFogCoordfv GLEW_GET_FUN(__glewFogCoordfv) #define glMultiDrawArrays GLEW_GET_FUN(__glewMultiDrawArrays) #define glMultiDrawElements GLEW_GET_FUN(__glewMultiDrawElements) #define glPointParameterf GLEW_GET_FUN(__glewPointParameterf) #define glPointParameterfv GLEW_GET_FUN(__glewPointParameterfv) #define glPointParameteri GLEW_GET_FUN(__glewPointParameteri) #define glPointParameteriv GLEW_GET_FUN(__glewPointParameteriv) #define glSecondaryColor3b GLEW_GET_FUN(__glewSecondaryColor3b) #define glSecondaryColor3bv GLEW_GET_FUN(__glewSecondaryColor3bv) #define glSecondaryColor3d GLEW_GET_FUN(__glewSecondaryColor3d) #define glSecondaryColor3dv GLEW_GET_FUN(__glewSecondaryColor3dv) #define glSecondaryColor3f GLEW_GET_FUN(__glewSecondaryColor3f) #define glSecondaryColor3fv GLEW_GET_FUN(__glewSecondaryColor3fv) #define glSecondaryColor3i GLEW_GET_FUN(__glewSecondaryColor3i) #define glSecondaryColor3iv GLEW_GET_FUN(__glewSecondaryColor3iv) #define glSecondaryColor3s GLEW_GET_FUN(__glewSecondaryColor3s) #define glSecondaryColor3sv GLEW_GET_FUN(__glewSecondaryColor3sv) #define glSecondaryColor3ub GLEW_GET_FUN(__glewSecondaryColor3ub) #define glSecondaryColor3ubv GLEW_GET_FUN(__glewSecondaryColor3ubv) #define glSecondaryColor3ui GLEW_GET_FUN(__glewSecondaryColor3ui) #define glSecondaryColor3uiv GLEW_GET_FUN(__glewSecondaryColor3uiv) #define glSecondaryColor3us GLEW_GET_FUN(__glewSecondaryColor3us) #define glSecondaryColor3usv GLEW_GET_FUN(__glewSecondaryColor3usv) #define glSecondaryColorPointer GLEW_GET_FUN(__glewSecondaryColorPointer) #define glWindowPos2d GLEW_GET_FUN(__glewWindowPos2d) #define glWindowPos2dv GLEW_GET_FUN(__glewWindowPos2dv) #define glWindowPos2f GLEW_GET_FUN(__glewWindowPos2f) #define glWindowPos2fv GLEW_GET_FUN(__glewWindowPos2fv) #define glWindowPos2i GLEW_GET_FUN(__glewWindowPos2i) #define glWindowPos2iv GLEW_GET_FUN(__glewWindowPos2iv) #define glWindowPos2s GLEW_GET_FUN(__glewWindowPos2s) #define glWindowPos2sv GLEW_GET_FUN(__glewWindowPos2sv) #define glWindowPos3d GLEW_GET_FUN(__glewWindowPos3d) #define glWindowPos3dv GLEW_GET_FUN(__glewWindowPos3dv) #define glWindowPos3f GLEW_GET_FUN(__glewWindowPos3f) #define glWindowPos3fv GLEW_GET_FUN(__glewWindowPos3fv) #define glWindowPos3i GLEW_GET_FUN(__glewWindowPos3i) #define glWindowPos3iv GLEW_GET_FUN(__glewWindowPos3iv) #define glWindowPos3s GLEW_GET_FUN(__glewWindowPos3s) #define glWindowPos3sv GLEW_GET_FUN(__glewWindowPos3sv) #define GLEW_VERSION_1_4 GLEW_GET_VAR(__GLEW_VERSION_1_4) #endif /* GL_VERSION_1_4 */ /* ----------------------------- GL_VERSION_1_5 ---------------------------- */ #ifndef GL_VERSION_1_5 #define GL_VERSION_1_5 1 #define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE #define GL_FOG_COORD GL_FOG_COORDINATE #define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY #define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING #define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER #define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE #define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE #define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE #define GL_SRC0_ALPHA GL_SOURCE0_ALPHA #define GL_SRC0_RGB GL_SOURCE0_RGB #define GL_SRC1_ALPHA GL_SOURCE1_ALPHA #define GL_SRC1_RGB GL_SOURCE1_RGB #define GL_SRC2_ALPHA GL_SOURCE2_ALPHA #define GL_SRC2_RGB GL_SOURCE2_RGB #define GL_BUFFER_SIZE 0x8764 #define GL_BUFFER_USAGE 0x8765 #define GL_QUERY_COUNTER_BITS 0x8864 #define GL_CURRENT_QUERY 0x8865 #define GL_QUERY_RESULT 0x8866 #define GL_QUERY_RESULT_AVAILABLE 0x8867 #define GL_ARRAY_BUFFER 0x8892 #define GL_ELEMENT_ARRAY_BUFFER 0x8893 #define GL_ARRAY_BUFFER_BINDING 0x8894 #define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 #define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 #define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 #define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 #define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D #define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F #define GL_READ_ONLY 0x88B8 #define GL_WRITE_ONLY 0x88B9 #define GL_READ_WRITE 0x88BA #define GL_BUFFER_ACCESS 0x88BB #define GL_BUFFER_MAPPED 0x88BC #define GL_BUFFER_MAP_POINTER 0x88BD #define GL_STREAM_DRAW 0x88E0 #define GL_STREAM_READ 0x88E1 #define GL_STREAM_COPY 0x88E2 #define GL_STATIC_DRAW 0x88E4 #define GL_STATIC_READ 0x88E5 #define GL_STATIC_COPY 0x88E6 #define GL_DYNAMIC_DRAW 0x88E8 #define GL_DYNAMIC_READ 0x88E9 #define GL_DYNAMIC_COPY 0x88EA #define GL_SAMPLES_PASSED 0x8914 typedef ptrdiff_t GLintptr; typedef ptrdiff_t GLsizeiptr; typedef void (GLAPIENTRY * PFNGLBEGINQUERYPROC) (GLenum target, GLuint id); typedef void (GLAPIENTRY * PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); typedef void (GLAPIENTRY * PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const void* data, GLenum usage); typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const void* data); typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint* buffers); typedef void (GLAPIENTRY * PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLENDQUERYPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLGENBUFFERSPROC) (GLsizei n, GLuint* buffers); typedef void (GLAPIENTRY * PFNGLGENQUERIESPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, void** params); typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, void* data); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERPROC) (GLuint buffer); typedef GLboolean (GLAPIENTRY * PFNGLISQUERYPROC) (GLuint id); typedef void* (GLAPIENTRY * PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERPROC) (GLenum target); #define glBeginQuery GLEW_GET_FUN(__glewBeginQuery) #define glBindBuffer GLEW_GET_FUN(__glewBindBuffer) #define glBufferData GLEW_GET_FUN(__glewBufferData) #define glBufferSubData GLEW_GET_FUN(__glewBufferSubData) #define glDeleteBuffers GLEW_GET_FUN(__glewDeleteBuffers) #define glDeleteQueries GLEW_GET_FUN(__glewDeleteQueries) #define glEndQuery GLEW_GET_FUN(__glewEndQuery) #define glGenBuffers GLEW_GET_FUN(__glewGenBuffers) #define glGenQueries GLEW_GET_FUN(__glewGenQueries) #define glGetBufferParameteriv GLEW_GET_FUN(__glewGetBufferParameteriv) #define glGetBufferPointerv GLEW_GET_FUN(__glewGetBufferPointerv) #define glGetBufferSubData GLEW_GET_FUN(__glewGetBufferSubData) #define glGetQueryObjectiv GLEW_GET_FUN(__glewGetQueryObjectiv) #define glGetQueryObjectuiv GLEW_GET_FUN(__glewGetQueryObjectuiv) #define glGetQueryiv GLEW_GET_FUN(__glewGetQueryiv) #define glIsBuffer GLEW_GET_FUN(__glewIsBuffer) #define glIsQuery GLEW_GET_FUN(__glewIsQuery) #define glMapBuffer GLEW_GET_FUN(__glewMapBuffer) #define glUnmapBuffer GLEW_GET_FUN(__glewUnmapBuffer) #define GLEW_VERSION_1_5 GLEW_GET_VAR(__GLEW_VERSION_1_5) #endif /* GL_VERSION_1_5 */ /* ----------------------------- GL_VERSION_2_0 ---------------------------- */ #ifndef GL_VERSION_2_0 #define GL_VERSION_2_0 1 #define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION #define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 #define GL_CURRENT_VERTEX_ATTRIB 0x8626 #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 #define GL_STENCIL_BACK_FUNC 0x8800 #define GL_STENCIL_BACK_FAIL 0x8801 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 #define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 #define GL_MAX_DRAW_BUFFERS 0x8824 #define GL_DRAW_BUFFER0 0x8825 #define GL_DRAW_BUFFER1 0x8826 #define GL_DRAW_BUFFER2 0x8827 #define GL_DRAW_BUFFER3 0x8828 #define GL_DRAW_BUFFER4 0x8829 #define GL_DRAW_BUFFER5 0x882A #define GL_DRAW_BUFFER6 0x882B #define GL_DRAW_BUFFER7 0x882C #define GL_DRAW_BUFFER8 0x882D #define GL_DRAW_BUFFER9 0x882E #define GL_DRAW_BUFFER10 0x882F #define GL_DRAW_BUFFER11 0x8830 #define GL_DRAW_BUFFER12 0x8831 #define GL_DRAW_BUFFER13 0x8832 #define GL_DRAW_BUFFER14 0x8833 #define GL_DRAW_BUFFER15 0x8834 #define GL_BLEND_EQUATION_ALPHA 0x883D #define GL_POINT_SPRITE 0x8861 #define GL_COORD_REPLACE 0x8862 #define GL_MAX_VERTEX_ATTRIBS 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A #define GL_MAX_TEXTURE_COORDS 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 #define GL_FRAGMENT_SHADER 0x8B30 #define GL_VERTEX_SHADER 0x8B31 #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 #define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A #define GL_MAX_VARYING_FLOATS 0x8B4B #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D #define GL_SHADER_TYPE 0x8B4F #define GL_FLOAT_VEC2 0x8B50 #define GL_FLOAT_VEC3 0x8B51 #define GL_FLOAT_VEC4 0x8B52 #define GL_INT_VEC2 0x8B53 #define GL_INT_VEC3 0x8B54 #define GL_INT_VEC4 0x8B55 #define GL_BOOL 0x8B56 #define GL_BOOL_VEC2 0x8B57 #define GL_BOOL_VEC3 0x8B58 #define GL_BOOL_VEC4 0x8B59 #define GL_FLOAT_MAT2 0x8B5A #define GL_FLOAT_MAT3 0x8B5B #define GL_FLOAT_MAT4 0x8B5C #define GL_SAMPLER_1D 0x8B5D #define GL_SAMPLER_2D 0x8B5E #define GL_SAMPLER_3D 0x8B5F #define GL_SAMPLER_CUBE 0x8B60 #define GL_SAMPLER_1D_SHADOW 0x8B61 #define GL_SAMPLER_2D_SHADOW 0x8B62 #define GL_DELETE_STATUS 0x8B80 #define GL_COMPILE_STATUS 0x8B81 #define GL_LINK_STATUS 0x8B82 #define GL_VALIDATE_STATUS 0x8B83 #define GL_INFO_LOG_LENGTH 0x8B84 #define GL_ATTACHED_SHADERS 0x8B85 #define GL_ACTIVE_UNIFORMS 0x8B86 #define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 #define GL_SHADER_SOURCE_LENGTH 0x8B88 #define GL_ACTIVE_ATTRIBUTES 0x8B89 #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B #define GL_SHADING_LANGUAGE_VERSION 0x8B8C #define GL_CURRENT_PROGRAM 0x8B8D #define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 #define GL_LOWER_LEFT 0x8CA1 #define GL_UPPER_LEFT 0x8CA2 #define GL_STENCIL_BACK_REF 0x8CA3 #define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 #define GL_STENCIL_BACK_WRITEMASK 0x8CA5 typedef void (GLAPIENTRY * PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar* name); typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha); typedef void (GLAPIENTRY * PFNGLCOMPILESHADERPROC) (GLuint shader); typedef GLuint (GLAPIENTRY * PFNGLCREATEPROGRAMPROC) (void); typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROC) (GLenum type); typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMPROC) (GLuint program); typedef void (GLAPIENTRY * PFNGLDELETESHADERPROC) (GLuint shader); typedef void (GLAPIENTRY * PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index); typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum* bufs); typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index); typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name); typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name); typedef void (GLAPIENTRY * PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders); typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar* name); typedef void (GLAPIENTRY * PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEPROC) (GLuint obj, GLsizei maxLength, GLsizei* length, GLchar* source); typedef void (GLAPIENTRY * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint* param); typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar* name); typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, void** pointer); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMPROC) (GLuint program); typedef GLboolean (GLAPIENTRY * PFNGLISSHADERPROC) (GLuint shader); typedef void (GLAPIENTRY * PFNGLLINKPROGRAMPROC) (GLuint program); typedef void (GLAPIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const* string, const GLint* length); typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); typedef void (GLAPIENTRY * PFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuint mask); typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); typedef void (GLAPIENTRY * PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); typedef void (GLAPIENTRY * PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM1IPROC) (GLint location, GLint v0); typedef void (GLAPIENTRY * PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); typedef void (GLAPIENTRY * PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); typedef void (GLAPIENTRY * PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (GLAPIENTRY * PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); typedef void (GLAPIENTRY * PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (GLAPIENTRY * PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (GLAPIENTRY * PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUSEPROGRAMPROC) (GLuint program); typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMPROC) (GLuint program); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer); #define glAttachShader GLEW_GET_FUN(__glewAttachShader) #define glBindAttribLocation GLEW_GET_FUN(__glewBindAttribLocation) #define glBlendEquationSeparate GLEW_GET_FUN(__glewBlendEquationSeparate) #define glCompileShader GLEW_GET_FUN(__glewCompileShader) #define glCreateProgram GLEW_GET_FUN(__glewCreateProgram) #define glCreateShader GLEW_GET_FUN(__glewCreateShader) #define glDeleteProgram GLEW_GET_FUN(__glewDeleteProgram) #define glDeleteShader GLEW_GET_FUN(__glewDeleteShader) #define glDetachShader GLEW_GET_FUN(__glewDetachShader) #define glDisableVertexAttribArray GLEW_GET_FUN(__glewDisableVertexAttribArray) #define glDrawBuffers GLEW_GET_FUN(__glewDrawBuffers) #define glEnableVertexAttribArray GLEW_GET_FUN(__glewEnableVertexAttribArray) #define glGetActiveAttrib GLEW_GET_FUN(__glewGetActiveAttrib) #define glGetActiveUniform GLEW_GET_FUN(__glewGetActiveUniform) #define glGetAttachedShaders GLEW_GET_FUN(__glewGetAttachedShaders) #define glGetAttribLocation GLEW_GET_FUN(__glewGetAttribLocation) #define glGetProgramInfoLog GLEW_GET_FUN(__glewGetProgramInfoLog) #define glGetProgramiv GLEW_GET_FUN(__glewGetProgramiv) #define glGetShaderInfoLog GLEW_GET_FUN(__glewGetShaderInfoLog) #define glGetShaderSource GLEW_GET_FUN(__glewGetShaderSource) #define glGetShaderiv GLEW_GET_FUN(__glewGetShaderiv) #define glGetUniformLocation GLEW_GET_FUN(__glewGetUniformLocation) #define glGetUniformfv GLEW_GET_FUN(__glewGetUniformfv) #define glGetUniformiv GLEW_GET_FUN(__glewGetUniformiv) #define glGetVertexAttribPointerv GLEW_GET_FUN(__glewGetVertexAttribPointerv) #define glGetVertexAttribdv GLEW_GET_FUN(__glewGetVertexAttribdv) #define glGetVertexAttribfv GLEW_GET_FUN(__glewGetVertexAttribfv) #define glGetVertexAttribiv GLEW_GET_FUN(__glewGetVertexAttribiv) #define glIsProgram GLEW_GET_FUN(__glewIsProgram) #define glIsShader GLEW_GET_FUN(__glewIsShader) #define glLinkProgram GLEW_GET_FUN(__glewLinkProgram) #define glShaderSource GLEW_GET_FUN(__glewShaderSource) #define glStencilFuncSeparate GLEW_GET_FUN(__glewStencilFuncSeparate) #define glStencilMaskSeparate GLEW_GET_FUN(__glewStencilMaskSeparate) #define glStencilOpSeparate GLEW_GET_FUN(__glewStencilOpSeparate) #define glUniform1f GLEW_GET_FUN(__glewUniform1f) #define glUniform1fv GLEW_GET_FUN(__glewUniform1fv) #define glUniform1i GLEW_GET_FUN(__glewUniform1i) #define glUniform1iv GLEW_GET_FUN(__glewUniform1iv) #define glUniform2f GLEW_GET_FUN(__glewUniform2f) #define glUniform2fv GLEW_GET_FUN(__glewUniform2fv) #define glUniform2i GLEW_GET_FUN(__glewUniform2i) #define glUniform2iv GLEW_GET_FUN(__glewUniform2iv) #define glUniform3f GLEW_GET_FUN(__glewUniform3f) #define glUniform3fv GLEW_GET_FUN(__glewUniform3fv) #define glUniform3i GLEW_GET_FUN(__glewUniform3i) #define glUniform3iv GLEW_GET_FUN(__glewUniform3iv) #define glUniform4f GLEW_GET_FUN(__glewUniform4f) #define glUniform4fv GLEW_GET_FUN(__glewUniform4fv) #define glUniform4i GLEW_GET_FUN(__glewUniform4i) #define glUniform4iv GLEW_GET_FUN(__glewUniform4iv) #define glUniformMatrix2fv GLEW_GET_FUN(__glewUniformMatrix2fv) #define glUniformMatrix3fv GLEW_GET_FUN(__glewUniformMatrix3fv) #define glUniformMatrix4fv GLEW_GET_FUN(__glewUniformMatrix4fv) #define glUseProgram GLEW_GET_FUN(__glewUseProgram) #define glValidateProgram GLEW_GET_FUN(__glewValidateProgram) #define glVertexAttrib1d GLEW_GET_FUN(__glewVertexAttrib1d) #define glVertexAttrib1dv GLEW_GET_FUN(__glewVertexAttrib1dv) #define glVertexAttrib1f GLEW_GET_FUN(__glewVertexAttrib1f) #define glVertexAttrib1fv GLEW_GET_FUN(__glewVertexAttrib1fv) #define glVertexAttrib1s GLEW_GET_FUN(__glewVertexAttrib1s) #define glVertexAttrib1sv GLEW_GET_FUN(__glewVertexAttrib1sv) #define glVertexAttrib2d GLEW_GET_FUN(__glewVertexAttrib2d) #define glVertexAttrib2dv GLEW_GET_FUN(__glewVertexAttrib2dv) #define glVertexAttrib2f GLEW_GET_FUN(__glewVertexAttrib2f) #define glVertexAttrib2fv GLEW_GET_FUN(__glewVertexAttrib2fv) #define glVertexAttrib2s GLEW_GET_FUN(__glewVertexAttrib2s) #define glVertexAttrib2sv GLEW_GET_FUN(__glewVertexAttrib2sv) #define glVertexAttrib3d GLEW_GET_FUN(__glewVertexAttrib3d) #define glVertexAttrib3dv GLEW_GET_FUN(__glewVertexAttrib3dv) #define glVertexAttrib3f GLEW_GET_FUN(__glewVertexAttrib3f) #define glVertexAttrib3fv GLEW_GET_FUN(__glewVertexAttrib3fv) #define glVertexAttrib3s GLEW_GET_FUN(__glewVertexAttrib3s) #define glVertexAttrib3sv GLEW_GET_FUN(__glewVertexAttrib3sv) #define glVertexAttrib4Nbv GLEW_GET_FUN(__glewVertexAttrib4Nbv) #define glVertexAttrib4Niv GLEW_GET_FUN(__glewVertexAttrib4Niv) #define glVertexAttrib4Nsv GLEW_GET_FUN(__glewVertexAttrib4Nsv) #define glVertexAttrib4Nub GLEW_GET_FUN(__glewVertexAttrib4Nub) #define glVertexAttrib4Nubv GLEW_GET_FUN(__glewVertexAttrib4Nubv) #define glVertexAttrib4Nuiv GLEW_GET_FUN(__glewVertexAttrib4Nuiv) #define glVertexAttrib4Nusv GLEW_GET_FUN(__glewVertexAttrib4Nusv) #define glVertexAttrib4bv GLEW_GET_FUN(__glewVertexAttrib4bv) #define glVertexAttrib4d GLEW_GET_FUN(__glewVertexAttrib4d) #define glVertexAttrib4dv GLEW_GET_FUN(__glewVertexAttrib4dv) #define glVertexAttrib4f GLEW_GET_FUN(__glewVertexAttrib4f) #define glVertexAttrib4fv GLEW_GET_FUN(__glewVertexAttrib4fv) #define glVertexAttrib4iv GLEW_GET_FUN(__glewVertexAttrib4iv) #define glVertexAttrib4s GLEW_GET_FUN(__glewVertexAttrib4s) #define glVertexAttrib4sv GLEW_GET_FUN(__glewVertexAttrib4sv) #define glVertexAttrib4ubv GLEW_GET_FUN(__glewVertexAttrib4ubv) #define glVertexAttrib4uiv GLEW_GET_FUN(__glewVertexAttrib4uiv) #define glVertexAttrib4usv GLEW_GET_FUN(__glewVertexAttrib4usv) #define glVertexAttribPointer GLEW_GET_FUN(__glewVertexAttribPointer) #define GLEW_VERSION_2_0 GLEW_GET_VAR(__GLEW_VERSION_2_0) #endif /* GL_VERSION_2_0 */ /* ----------------------------- GL_VERSION_2_1 ---------------------------- */ #ifndef GL_VERSION_2_1 #define GL_VERSION_2_1 1 #define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F #define GL_PIXEL_PACK_BUFFER 0x88EB #define GL_PIXEL_UNPACK_BUFFER 0x88EC #define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED #define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF #define GL_FLOAT_MAT2x3 0x8B65 #define GL_FLOAT_MAT2x4 0x8B66 #define GL_FLOAT_MAT3x2 0x8B67 #define GL_FLOAT_MAT3x4 0x8B68 #define GL_FLOAT_MAT4x2 0x8B69 #define GL_FLOAT_MAT4x3 0x8B6A #define GL_SRGB 0x8C40 #define GL_SRGB8 0x8C41 #define GL_SRGB_ALPHA 0x8C42 #define GL_SRGB8_ALPHA8 0x8C43 #define GL_SLUMINANCE_ALPHA 0x8C44 #define GL_SLUMINANCE8_ALPHA8 0x8C45 #define GL_SLUMINANCE 0x8C46 #define GL_SLUMINANCE8 0x8C47 #define GL_COMPRESSED_SRGB 0x8C48 #define GL_COMPRESSED_SRGB_ALPHA 0x8C49 #define GL_COMPRESSED_SLUMINANCE 0x8C4A #define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); #define glUniformMatrix2x3fv GLEW_GET_FUN(__glewUniformMatrix2x3fv) #define glUniformMatrix2x4fv GLEW_GET_FUN(__glewUniformMatrix2x4fv) #define glUniformMatrix3x2fv GLEW_GET_FUN(__glewUniformMatrix3x2fv) #define glUniformMatrix3x4fv GLEW_GET_FUN(__glewUniformMatrix3x4fv) #define glUniformMatrix4x2fv GLEW_GET_FUN(__glewUniformMatrix4x2fv) #define glUniformMatrix4x3fv GLEW_GET_FUN(__glewUniformMatrix4x3fv) #define GLEW_VERSION_2_1 GLEW_GET_VAR(__GLEW_VERSION_2_1) #endif /* GL_VERSION_2_1 */ /* ----------------------------- GL_VERSION_3_0 ---------------------------- */ #ifndef GL_VERSION_3_0 #define GL_VERSION_3_0 1 #define GL_CLIP_DISTANCE0 GL_CLIP_PLANE0 #define GL_CLIP_DISTANCE1 GL_CLIP_PLANE1 #define GL_CLIP_DISTANCE2 GL_CLIP_PLANE2 #define GL_CLIP_DISTANCE3 GL_CLIP_PLANE3 #define GL_CLIP_DISTANCE4 GL_CLIP_PLANE4 #define GL_CLIP_DISTANCE5 GL_CLIP_PLANE5 #define GL_COMPARE_REF_TO_TEXTURE GL_COMPARE_R_TO_TEXTURE_ARB #define GL_MAX_CLIP_DISTANCES GL_MAX_CLIP_PLANES #define GL_MAX_VARYING_COMPONENTS GL_MAX_VARYING_FLOATS #define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001 #define GL_MAJOR_VERSION 0x821B #define GL_MINOR_VERSION 0x821C #define GL_NUM_EXTENSIONS 0x821D #define GL_CONTEXT_FLAGS 0x821E #define GL_DEPTH_BUFFER 0x8223 #define GL_STENCIL_BUFFER 0x8224 #define GL_RGBA32F 0x8814 #define GL_RGB32F 0x8815 #define GL_RGBA16F 0x881A #define GL_RGB16F 0x881B #define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD #define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF #define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 #define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 #define GL_CLAMP_VERTEX_COLOR 0x891A #define GL_CLAMP_FRAGMENT_COLOR 0x891B #define GL_CLAMP_READ_COLOR 0x891C #define GL_FIXED_ONLY 0x891D #define GL_TEXTURE_RED_TYPE 0x8C10 #define GL_TEXTURE_GREEN_TYPE 0x8C11 #define GL_TEXTURE_BLUE_TYPE 0x8C12 #define GL_TEXTURE_ALPHA_TYPE 0x8C13 #define GL_TEXTURE_LUMINANCE_TYPE 0x8C14 #define GL_TEXTURE_INTENSITY_TYPE 0x8C15 #define GL_TEXTURE_DEPTH_TYPE 0x8C16 #define GL_TEXTURE_1D_ARRAY 0x8C18 #define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 #define GL_TEXTURE_2D_ARRAY 0x8C1A #define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B #define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C #define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D #define GL_R11F_G11F_B10F 0x8C3A #define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B #define GL_RGB9_E5 0x8C3D #define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E #define GL_TEXTURE_SHARED_SIZE 0x8C3F #define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 #define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 #define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 #define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 #define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 #define GL_PRIMITIVES_GENERATED 0x8C87 #define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 #define GL_RASTERIZER_DISCARD 0x8C89 #define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B #define GL_INTERLEAVED_ATTRIBS 0x8C8C #define GL_SEPARATE_ATTRIBS 0x8C8D #define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E #define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F #define GL_RGBA32UI 0x8D70 #define GL_RGB32UI 0x8D71 #define GL_RGBA16UI 0x8D76 #define GL_RGB16UI 0x8D77 #define GL_RGBA8UI 0x8D7C #define GL_RGB8UI 0x8D7D #define GL_RGBA32I 0x8D82 #define GL_RGB32I 0x8D83 #define GL_RGBA16I 0x8D88 #define GL_RGB16I 0x8D89 #define GL_RGBA8I 0x8D8E #define GL_RGB8I 0x8D8F #define GL_RED_INTEGER 0x8D94 #define GL_GREEN_INTEGER 0x8D95 #define GL_BLUE_INTEGER 0x8D96 #define GL_ALPHA_INTEGER 0x8D97 #define GL_RGB_INTEGER 0x8D98 #define GL_RGBA_INTEGER 0x8D99 #define GL_BGR_INTEGER 0x8D9A #define GL_BGRA_INTEGER 0x8D9B #define GL_SAMPLER_1D_ARRAY 0x8DC0 #define GL_SAMPLER_2D_ARRAY 0x8DC1 #define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 #define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 #define GL_SAMPLER_CUBE_SHADOW 0x8DC5 #define GL_UNSIGNED_INT_VEC2 0x8DC6 #define GL_UNSIGNED_INT_VEC3 0x8DC7 #define GL_UNSIGNED_INT_VEC4 0x8DC8 #define GL_INT_SAMPLER_1D 0x8DC9 #define GL_INT_SAMPLER_2D 0x8DCA #define GL_INT_SAMPLER_3D 0x8DCB #define GL_INT_SAMPLER_CUBE 0x8DCC #define GL_INT_SAMPLER_1D_ARRAY 0x8DCE #define GL_INT_SAMPLER_2D_ARRAY 0x8DCF #define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 #define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 #define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 #define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 #define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 #define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 #define GL_QUERY_WAIT 0x8E13 #define GL_QUERY_NO_WAIT 0x8E14 #define GL_QUERY_BY_REGION_WAIT 0x8E15 #define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERPROC) (GLuint id, GLenum mode); typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKPROC) (GLenum primitiveMode); typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONPROC) (GLuint program, GLuint colorNumber, const GLchar* name); typedef void (GLAPIENTRY * PFNGLCLAMPCOLORPROC) (GLenum target, GLenum clamp); typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFIPROC) (GLenum buffer, GLint drawBuffer, GLfloat depth, GLint stencil); typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFVPROC) (GLenum buffer, GLint drawBuffer, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLCLEARBUFFERIVPROC) (GLenum buffer, GLint drawBuffer, const GLint* value); typedef void (GLAPIENTRY * PFNGLCLEARBUFFERUIVPROC) (GLenum buffer, GLint drawBuffer, const GLuint* value); typedef void (GLAPIENTRY * PFNGLCOLORMASKIPROC) (GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); typedef void (GLAPIENTRY * PFNGLDISABLEIPROC) (GLenum cap, GLuint index); typedef void (GLAPIENTRY * PFNGLENABLEIPROC) (GLenum cap, GLuint index); typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERPROC) (void); typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKPROC) (void); typedef void (GLAPIENTRY * PFNGLGETBOOLEANI_VPROC) (GLenum pname, GLuint index, GLboolean* data); typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONPROC) (GLuint program, const GLchar* name); typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGIPROC) (GLenum name, GLuint index); typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVPROC) (GLenum target, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVPROC) (GLuint program, GLint location, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVPROC) (GLuint index, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVPROC) (GLuint index, GLenum pname, GLuint* params); typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIPROC) (GLenum cap, GLuint index); typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVPROC) (GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVPROC) (GLenum target, GLenum pname, const GLuint* params); typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode); typedef void (GLAPIENTRY * PFNGLUNIFORM1UIPROC) (GLint location, GLuint v0); typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVPROC) (GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2UIPROC) (GLint location, GLuint v0, GLuint v1); typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVPROC) (GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3UIPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVPROC) (GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4UIPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVPROC) (GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IPROC) (GLuint index, GLint v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVPROC) (GLuint index, const GLint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIPROC) (GLuint index, GLuint v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVPROC) (GLuint index, const GLuint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IPROC) (GLuint index, GLint v0, GLint v1); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVPROC) (GLuint index, const GLint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIPROC) (GLuint index, GLuint v0, GLuint v1); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVPROC) (GLuint index, const GLuint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IPROC) (GLuint index, GLint v0, GLint v1, GLint v2); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVPROC) (GLuint index, const GLint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIPROC) (GLuint index, GLuint v0, GLuint v1, GLuint v2); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVPROC) (GLuint index, const GLuint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVPROC) (GLuint index, const GLbyte* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IPROC) (GLuint index, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVPROC) (GLuint index, const GLint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVPROC) (GLuint index, const GLshort* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVPROC) (GLuint index, const GLubyte* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIPROC) (GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVPROC) (GLuint index, const GLuint* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVPROC) (GLuint index, const GLushort* v0); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void*pointer); #define glBeginConditionalRender GLEW_GET_FUN(__glewBeginConditionalRender) #define glBeginTransformFeedback GLEW_GET_FUN(__glewBeginTransformFeedback) #define glBindFragDataLocation GLEW_GET_FUN(__glewBindFragDataLocation) #define glClampColor GLEW_GET_FUN(__glewClampColor) #define glClearBufferfi GLEW_GET_FUN(__glewClearBufferfi) #define glClearBufferfv GLEW_GET_FUN(__glewClearBufferfv) #define glClearBufferiv GLEW_GET_FUN(__glewClearBufferiv) #define glClearBufferuiv GLEW_GET_FUN(__glewClearBufferuiv) #define glColorMaski GLEW_GET_FUN(__glewColorMaski) #define glDisablei GLEW_GET_FUN(__glewDisablei) #define glEnablei GLEW_GET_FUN(__glewEnablei) #define glEndConditionalRender GLEW_GET_FUN(__glewEndConditionalRender) #define glEndTransformFeedback GLEW_GET_FUN(__glewEndTransformFeedback) #define glGetBooleani_v GLEW_GET_FUN(__glewGetBooleani_v) #define glGetFragDataLocation GLEW_GET_FUN(__glewGetFragDataLocation) #define glGetStringi GLEW_GET_FUN(__glewGetStringi) #define glGetTexParameterIiv GLEW_GET_FUN(__glewGetTexParameterIiv) #define glGetTexParameterIuiv GLEW_GET_FUN(__glewGetTexParameterIuiv) #define glGetTransformFeedbackVarying GLEW_GET_FUN(__glewGetTransformFeedbackVarying) #define glGetUniformuiv GLEW_GET_FUN(__glewGetUniformuiv) #define glGetVertexAttribIiv GLEW_GET_FUN(__glewGetVertexAttribIiv) #define glGetVertexAttribIuiv GLEW_GET_FUN(__glewGetVertexAttribIuiv) #define glIsEnabledi GLEW_GET_FUN(__glewIsEnabledi) #define glTexParameterIiv GLEW_GET_FUN(__glewTexParameterIiv) #define glTexParameterIuiv GLEW_GET_FUN(__glewTexParameterIuiv) #define glTransformFeedbackVaryings GLEW_GET_FUN(__glewTransformFeedbackVaryings) #define glUniform1ui GLEW_GET_FUN(__glewUniform1ui) #define glUniform1uiv GLEW_GET_FUN(__glewUniform1uiv) #define glUniform2ui GLEW_GET_FUN(__glewUniform2ui) #define glUniform2uiv GLEW_GET_FUN(__glewUniform2uiv) #define glUniform3ui GLEW_GET_FUN(__glewUniform3ui) #define glUniform3uiv GLEW_GET_FUN(__glewUniform3uiv) #define glUniform4ui GLEW_GET_FUN(__glewUniform4ui) #define glUniform4uiv GLEW_GET_FUN(__glewUniform4uiv) #define glVertexAttribI1i GLEW_GET_FUN(__glewVertexAttribI1i) #define glVertexAttribI1iv GLEW_GET_FUN(__glewVertexAttribI1iv) #define glVertexAttribI1ui GLEW_GET_FUN(__glewVertexAttribI1ui) #define glVertexAttribI1uiv GLEW_GET_FUN(__glewVertexAttribI1uiv) #define glVertexAttribI2i GLEW_GET_FUN(__glewVertexAttribI2i) #define glVertexAttribI2iv GLEW_GET_FUN(__glewVertexAttribI2iv) #define glVertexAttribI2ui GLEW_GET_FUN(__glewVertexAttribI2ui) #define glVertexAttribI2uiv GLEW_GET_FUN(__glewVertexAttribI2uiv) #define glVertexAttribI3i GLEW_GET_FUN(__glewVertexAttribI3i) #define glVertexAttribI3iv GLEW_GET_FUN(__glewVertexAttribI3iv) #define glVertexAttribI3ui GLEW_GET_FUN(__glewVertexAttribI3ui) #define glVertexAttribI3uiv GLEW_GET_FUN(__glewVertexAttribI3uiv) #define glVertexAttribI4bv GLEW_GET_FUN(__glewVertexAttribI4bv) #define glVertexAttribI4i GLEW_GET_FUN(__glewVertexAttribI4i) #define glVertexAttribI4iv GLEW_GET_FUN(__glewVertexAttribI4iv) #define glVertexAttribI4sv GLEW_GET_FUN(__glewVertexAttribI4sv) #define glVertexAttribI4ubv GLEW_GET_FUN(__glewVertexAttribI4ubv) #define glVertexAttribI4ui GLEW_GET_FUN(__glewVertexAttribI4ui) #define glVertexAttribI4uiv GLEW_GET_FUN(__glewVertexAttribI4uiv) #define glVertexAttribI4usv GLEW_GET_FUN(__glewVertexAttribI4usv) #define glVertexAttribIPointer GLEW_GET_FUN(__glewVertexAttribIPointer) #define GLEW_VERSION_3_0 GLEW_GET_VAR(__GLEW_VERSION_3_0) #endif /* GL_VERSION_3_0 */ /* ----------------------------- GL_VERSION_3_1 ---------------------------- */ #ifndef GL_VERSION_3_1 #define GL_VERSION_3_1 1 #define GL_TEXTURE_RECTANGLE 0x84F5 #define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 #define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 #define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 #define GL_SAMPLER_2D_RECT 0x8B63 #define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 #define GL_TEXTURE_BUFFER 0x8C2A #define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B #define GL_TEXTURE_BINDING_BUFFER 0x8C2C #define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D #define GL_TEXTURE_BUFFER_FORMAT 0x8C2E #define GL_SAMPLER_BUFFER 0x8DC2 #define GL_INT_SAMPLER_2D_RECT 0x8DCD #define GL_INT_SAMPLER_BUFFER 0x8DD0 #define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 #define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 #define GL_RED_SNORM 0x8F90 #define GL_RG_SNORM 0x8F91 #define GL_RGB_SNORM 0x8F92 #define GL_RGBA_SNORM 0x8F93 #define GL_R8_SNORM 0x8F94 #define GL_RG8_SNORM 0x8F95 #define GL_RGB8_SNORM 0x8F96 #define GL_RGBA8_SNORM 0x8F97 #define GL_R16_SNORM 0x8F98 #define GL_RG16_SNORM 0x8F99 #define GL_RGB16_SNORM 0x8F9A #define GL_RGBA16_SNORM 0x8F9B #define GL_SIGNED_NORMALIZED 0x8F9C #define GL_PRIMITIVE_RESTART 0x8F9D #define GL_PRIMITIVE_RESTART_INDEX 0x8F9E #define GL_BUFFER_ACCESS_FLAGS 0x911F #define GL_BUFFER_MAP_LENGTH 0x9120 #define GL_BUFFER_MAP_OFFSET 0x9121 typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTINDEXPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLTEXBUFFERPROC) (GLenum target, GLenum internalFormat, GLuint buffer); #define glDrawArraysInstanced GLEW_GET_FUN(__glewDrawArraysInstanced) #define glDrawElementsInstanced GLEW_GET_FUN(__glewDrawElementsInstanced) #define glPrimitiveRestartIndex GLEW_GET_FUN(__glewPrimitiveRestartIndex) #define glTexBuffer GLEW_GET_FUN(__glewTexBuffer) #define GLEW_VERSION_3_1 GLEW_GET_VAR(__GLEW_VERSION_3_1) #endif /* GL_VERSION_3_1 */ /* ----------------------------- GL_VERSION_3_2 ---------------------------- */ #ifndef GL_VERSION_3_2 #define GL_VERSION_3_2 1 #define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 #define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 #define GL_LINES_ADJACENCY 0x000A #define GL_LINE_STRIP_ADJACENCY 0x000B #define GL_TRIANGLES_ADJACENCY 0x000C #define GL_TRIANGLE_STRIP_ADJACENCY 0x000D #define GL_PROGRAM_POINT_SIZE 0x8642 #define GL_GEOMETRY_VERTICES_OUT 0x8916 #define GL_GEOMETRY_INPUT_TYPE 0x8917 #define GL_GEOMETRY_OUTPUT_TYPE 0x8918 #define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 #define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 #define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 #define GL_GEOMETRY_SHADER 0x8DD9 #define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF #define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 #define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 #define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 #define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 #define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 #define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 #define GL_CONTEXT_PROFILE_MASK 0x9126 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERI64VPROC) (GLenum target, GLenum value, GLint64 * data); typedef void (GLAPIENTRY * PFNGLGETINTEGER64I_VPROC) (GLenum pname, GLuint index, GLint64 * data); #define glFramebufferTexture GLEW_GET_FUN(__glewFramebufferTexture) #define glGetBufferParameteri64v GLEW_GET_FUN(__glewGetBufferParameteri64v) #define glGetInteger64i_v GLEW_GET_FUN(__glewGetInteger64i_v) #define GLEW_VERSION_3_2 GLEW_GET_VAR(__GLEW_VERSION_3_2) #endif /* GL_VERSION_3_2 */ /* ----------------------------- GL_VERSION_3_3 ---------------------------- */ #ifndef GL_VERSION_3_3 #define GL_VERSION_3_3 1 #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE #define GL_RGB10_A2UI 0x906F typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORPROC) (GLuint index, GLuint divisor); #define glVertexAttribDivisor GLEW_GET_FUN(__glewVertexAttribDivisor) #define GLEW_VERSION_3_3 GLEW_GET_VAR(__GLEW_VERSION_3_3) #endif /* GL_VERSION_3_3 */ /* ----------------------------- GL_VERSION_4_0 ---------------------------- */ #ifndef GL_VERSION_4_0 #define GL_VERSION_4_0 1 #define GL_SAMPLE_SHADING 0x8C36 #define GL_MIN_SAMPLE_SHADING_VALUE 0x8C37 #define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E #define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F #define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS 0x8F9F #define GL_TEXTURE_CUBE_MAP_ARRAY 0x9009 #define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A #define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY 0x900B #define GL_SAMPLER_CUBE_MAP_ARRAY 0x900C #define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D #define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E #define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIPROC) (GLuint buf, GLenum mode); typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); typedef void (GLAPIENTRY * PFNGLBLENDFUNCIPROC) (GLuint buf, GLenum src, GLenum dst); typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGPROC) (GLclampf value); #define glBlendEquationSeparatei GLEW_GET_FUN(__glewBlendEquationSeparatei) #define glBlendEquationi GLEW_GET_FUN(__glewBlendEquationi) #define glBlendFuncSeparatei GLEW_GET_FUN(__glewBlendFuncSeparatei) #define glBlendFunci GLEW_GET_FUN(__glewBlendFunci) #define glMinSampleShading GLEW_GET_FUN(__glewMinSampleShading) #define GLEW_VERSION_4_0 GLEW_GET_VAR(__GLEW_VERSION_4_0) #endif /* GL_VERSION_4_0 */ /* ----------------------------- GL_VERSION_4_1 ---------------------------- */ #ifndef GL_VERSION_4_1 #define GL_VERSION_4_1 1 #define GLEW_VERSION_4_1 GLEW_GET_VAR(__GLEW_VERSION_4_1) #endif /* GL_VERSION_4_1 */ /* ----------------------------- GL_VERSION_4_2 ---------------------------- */ #ifndef GL_VERSION_4_2 #define GL_VERSION_4_2 1 #define GL_TRANSFORM_FEEDBACK_PAUSED 0x8E23 #define GL_TRANSFORM_FEEDBACK_ACTIVE 0x8E24 #define GL_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C #define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D #define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E #define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F #define GL_COPY_READ_BUFFER_BINDING 0x8F36 #define GL_COPY_WRITE_BUFFER_BINDING 0x8F37 #define GLEW_VERSION_4_2 GLEW_GET_VAR(__GLEW_VERSION_4_2) #endif /* GL_VERSION_4_2 */ /* ----------------------------- GL_VERSION_4_3 ---------------------------- */ #ifndef GL_VERSION_4_3 #define GL_VERSION_4_3 1 #define GL_NUM_SHADING_LANGUAGE_VERSIONS 0x82E9 #define GL_VERTEX_ATTRIB_ARRAY_LONG 0x874E #define GLEW_VERSION_4_3 GLEW_GET_VAR(__GLEW_VERSION_4_3) #endif /* GL_VERSION_4_3 */ /* ----------------------------- GL_VERSION_4_4 ---------------------------- */ #ifndef GL_VERSION_4_4 #define GL_VERSION_4_4 1 #define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED 0x8221 #define GL_MAX_VERTEX_ATTRIB_STRIDE 0x82E5 #define GL_TEXTURE_BUFFER_BINDING 0x8C2A #define GLEW_VERSION_4_4 GLEW_GET_VAR(__GLEW_VERSION_4_4) #endif /* GL_VERSION_4_4 */ /* ----------------------------- GL_VERSION_4_5 ---------------------------- */ #ifndef GL_VERSION_4_5 #define GL_VERSION_4_5 1 #define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT 0x00000004 typedef GLenum (GLAPIENTRY * PFNGLGETGRAPHICSRESETSTATUSPROC) (void); typedef void (GLAPIENTRY * PFNGLGETNCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint lod, GLsizei bufSize, GLvoid *pixels); typedef void (GLAPIENTRY * PFNGLGETNTEXIMAGEPROC) (GLenum tex, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid *pixels); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMDVPROC) (GLuint program, GLint location, GLsizei bufSize, GLdouble *params); #define glGetGraphicsResetStatus GLEW_GET_FUN(__glewGetGraphicsResetStatus) #define glGetnCompressedTexImage GLEW_GET_FUN(__glewGetnCompressedTexImage) #define glGetnTexImage GLEW_GET_FUN(__glewGetnTexImage) #define glGetnUniformdv GLEW_GET_FUN(__glewGetnUniformdv) #define GLEW_VERSION_4_5 GLEW_GET_VAR(__GLEW_VERSION_4_5) #endif /* GL_VERSION_4_5 */ /* -------------------------- GL_3DFX_multisample -------------------------- */ #ifndef GL_3DFX_multisample #define GL_3DFX_multisample 1 #define GL_MULTISAMPLE_3DFX 0x86B2 #define GL_SAMPLE_BUFFERS_3DFX 0x86B3 #define GL_SAMPLES_3DFX 0x86B4 #define GL_MULTISAMPLE_BIT_3DFX 0x20000000 #define GLEW_3DFX_multisample GLEW_GET_VAR(__GLEW_3DFX_multisample) #endif /* GL_3DFX_multisample */ /* ---------------------------- GL_3DFX_tbuffer ---------------------------- */ #ifndef GL_3DFX_tbuffer #define GL_3DFX_tbuffer 1 typedef void (GLAPIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask); #define glTbufferMask3DFX GLEW_GET_FUN(__glewTbufferMask3DFX) #define GLEW_3DFX_tbuffer GLEW_GET_VAR(__GLEW_3DFX_tbuffer) #endif /* GL_3DFX_tbuffer */ /* -------------------- GL_3DFX_texture_compression_FXT1 ------------------- */ #ifndef GL_3DFX_texture_compression_FXT1 #define GL_3DFX_texture_compression_FXT1 1 #define GL_COMPRESSED_RGB_FXT1_3DFX 0x86B0 #define GL_COMPRESSED_RGBA_FXT1_3DFX 0x86B1 #define GLEW_3DFX_texture_compression_FXT1 GLEW_GET_VAR(__GLEW_3DFX_texture_compression_FXT1) #endif /* GL_3DFX_texture_compression_FXT1 */ /* ----------------------- GL_AMD_blend_minmax_factor ---------------------- */ #ifndef GL_AMD_blend_minmax_factor #define GL_AMD_blend_minmax_factor 1 #define GL_FACTOR_MIN_AMD 0x901C #define GL_FACTOR_MAX_AMD 0x901D #define GLEW_AMD_blend_minmax_factor GLEW_GET_VAR(__GLEW_AMD_blend_minmax_factor) #endif /* GL_AMD_blend_minmax_factor */ /* ----------------------- GL_AMD_conservative_depth ----------------------- */ #ifndef GL_AMD_conservative_depth #define GL_AMD_conservative_depth 1 #define GLEW_AMD_conservative_depth GLEW_GET_VAR(__GLEW_AMD_conservative_depth) #endif /* GL_AMD_conservative_depth */ /* -------------------------- GL_AMD_debug_output -------------------------- */ #ifndef GL_AMD_debug_output #define GL_AMD_debug_output 1 #define GL_MAX_DEBUG_MESSAGE_LENGTH_AMD 0x9143 #define GL_MAX_DEBUG_LOGGED_MESSAGES_AMD 0x9144 #define GL_DEBUG_LOGGED_MESSAGES_AMD 0x9145 #define GL_DEBUG_SEVERITY_HIGH_AMD 0x9146 #define GL_DEBUG_SEVERITY_MEDIUM_AMD 0x9147 #define GL_DEBUG_SEVERITY_LOW_AMD 0x9148 #define GL_DEBUG_CATEGORY_API_ERROR_AMD 0x9149 #define GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD 0x914A #define GL_DEBUG_CATEGORY_DEPRECATION_AMD 0x914B #define GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD 0x914C #define GL_DEBUG_CATEGORY_PERFORMANCE_AMD 0x914D #define GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD 0x914E #define GL_DEBUG_CATEGORY_APPLICATION_AMD 0x914F #define GL_DEBUG_CATEGORY_OTHER_AMD 0x9150 typedef void (GLAPIENTRY *GLDEBUGPROCAMD)(GLuint id, GLenum category, GLenum severity, GLsizei length, const GLchar* message, void* userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, void *userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEENABLEAMDPROC) (GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTAMDPROC) (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar* buf); typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message); #define glDebugMessageCallbackAMD GLEW_GET_FUN(__glewDebugMessageCallbackAMD) #define glDebugMessageEnableAMD GLEW_GET_FUN(__glewDebugMessageEnableAMD) #define glDebugMessageInsertAMD GLEW_GET_FUN(__glewDebugMessageInsertAMD) #define glGetDebugMessageLogAMD GLEW_GET_FUN(__glewGetDebugMessageLogAMD) #define GLEW_AMD_debug_output GLEW_GET_VAR(__GLEW_AMD_debug_output) #endif /* GL_AMD_debug_output */ /* ---------------------- GL_AMD_depth_clamp_separate ---------------------- */ #ifndef GL_AMD_depth_clamp_separate #define GL_AMD_depth_clamp_separate 1 #define GL_DEPTH_CLAMP_NEAR_AMD 0x901E #define GL_DEPTH_CLAMP_FAR_AMD 0x901F #define GLEW_AMD_depth_clamp_separate GLEW_GET_VAR(__GLEW_AMD_depth_clamp_separate) #endif /* GL_AMD_depth_clamp_separate */ /* ----------------------- GL_AMD_draw_buffers_blend ----------------------- */ #ifndef GL_AMD_draw_buffers_blend #define GL_AMD_draw_buffers_blend 1 typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONINDEXEDAMDPROC) (GLuint buf, GLenum mode); typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); typedef void (GLAPIENTRY * PFNGLBLENDFUNCINDEXEDAMDPROC) (GLuint buf, GLenum src, GLenum dst); typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); #define glBlendEquationIndexedAMD GLEW_GET_FUN(__glewBlendEquationIndexedAMD) #define glBlendEquationSeparateIndexedAMD GLEW_GET_FUN(__glewBlendEquationSeparateIndexedAMD) #define glBlendFuncIndexedAMD GLEW_GET_FUN(__glewBlendFuncIndexedAMD) #define glBlendFuncSeparateIndexedAMD GLEW_GET_FUN(__glewBlendFuncSeparateIndexedAMD) #define GLEW_AMD_draw_buffers_blend GLEW_GET_VAR(__GLEW_AMD_draw_buffers_blend) #endif /* GL_AMD_draw_buffers_blend */ /* --------------------------- GL_AMD_gcn_shader --------------------------- */ #ifndef GL_AMD_gcn_shader #define GL_AMD_gcn_shader 1 #define GLEW_AMD_gcn_shader GLEW_GET_VAR(__GLEW_AMD_gcn_shader) #endif /* GL_AMD_gcn_shader */ /* ------------------------ GL_AMD_gpu_shader_int64 ------------------------ */ #ifndef GL_AMD_gpu_shader_int64 #define GL_AMD_gpu_shader_int64 1 #define GLEW_AMD_gpu_shader_int64 GLEW_GET_VAR(__GLEW_AMD_gpu_shader_int64) #endif /* GL_AMD_gpu_shader_int64 */ /* ---------------------- GL_AMD_interleaved_elements ---------------------- */ #ifndef GL_AMD_interleaved_elements #define GL_AMD_interleaved_elements 1 #define GL_RED 0x1903 #define GL_GREEN 0x1904 #define GL_BLUE 0x1905 #define GL_ALPHA 0x1906 #define GL_RG8UI 0x8238 #define GL_RG16UI 0x823A #define GL_RGBA8UI 0x8D7C #define GL_VERTEX_ELEMENT_SWIZZLE_AMD 0x91A4 #define GL_VERTEX_ID_SWIZZLE_AMD 0x91A5 typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPARAMETERIAMDPROC) (GLuint index, GLenum pname, GLint param); #define glVertexAttribParameteriAMD GLEW_GET_FUN(__glewVertexAttribParameteriAMD) #define GLEW_AMD_interleaved_elements GLEW_GET_VAR(__GLEW_AMD_interleaved_elements) #endif /* GL_AMD_interleaved_elements */ /* ----------------------- GL_AMD_multi_draw_indirect ---------------------- */ #ifndef GL_AMD_multi_draw_indirect #define GL_AMD_multi_draw_indirect 1 typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC) (GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC) (GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride); #define glMultiDrawArraysIndirectAMD GLEW_GET_FUN(__glewMultiDrawArraysIndirectAMD) #define glMultiDrawElementsIndirectAMD GLEW_GET_FUN(__glewMultiDrawElementsIndirectAMD) #define GLEW_AMD_multi_draw_indirect GLEW_GET_VAR(__GLEW_AMD_multi_draw_indirect) #endif /* GL_AMD_multi_draw_indirect */ /* ------------------------- GL_AMD_name_gen_delete ------------------------ */ #ifndef GL_AMD_name_gen_delete #define GL_AMD_name_gen_delete 1 #define GL_DATA_BUFFER_AMD 0x9151 #define GL_PERFORMANCE_MONITOR_AMD 0x9152 #define GL_QUERY_OBJECT_AMD 0x9153 #define GL_VERTEX_ARRAY_OBJECT_AMD 0x9154 #define GL_SAMPLER_OBJECT_AMD 0x9155 typedef void (GLAPIENTRY * PFNGLDELETENAMESAMDPROC) (GLenum identifier, GLuint num, const GLuint* names); typedef void (GLAPIENTRY * PFNGLGENNAMESAMDPROC) (GLenum identifier, GLuint num, GLuint* names); typedef GLboolean (GLAPIENTRY * PFNGLISNAMEAMDPROC) (GLenum identifier, GLuint name); #define glDeleteNamesAMD GLEW_GET_FUN(__glewDeleteNamesAMD) #define glGenNamesAMD GLEW_GET_FUN(__glewGenNamesAMD) #define glIsNameAMD GLEW_GET_FUN(__glewIsNameAMD) #define GLEW_AMD_name_gen_delete GLEW_GET_VAR(__GLEW_AMD_name_gen_delete) #endif /* GL_AMD_name_gen_delete */ /* ---------------------- GL_AMD_occlusion_query_event --------------------- */ #ifndef GL_AMD_occlusion_query_event #define GL_AMD_occlusion_query_event 1 #define GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD 0x00000001 #define GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD 0x00000002 #define GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD 0x00000004 #define GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD 0x00000008 #define GL_OCCLUSION_QUERY_EVENT_MASK_AMD 0x874F #define GL_QUERY_ALL_EVENT_BITS_AMD 0xFFFFFFFF typedef void (GLAPIENTRY * PFNGLQUERYOBJECTPARAMETERUIAMDPROC) (GLenum target, GLuint id, GLenum pname, GLuint param); #define glQueryObjectParameteruiAMD GLEW_GET_FUN(__glewQueryObjectParameteruiAMD) #define GLEW_AMD_occlusion_query_event GLEW_GET_VAR(__GLEW_AMD_occlusion_query_event) #endif /* GL_AMD_occlusion_query_event */ /* ----------------------- GL_AMD_performance_monitor ---------------------- */ #ifndef GL_AMD_performance_monitor #define GL_AMD_performance_monitor 1 #define GL_COUNTER_TYPE_AMD 0x8BC0 #define GL_COUNTER_RANGE_AMD 0x8BC1 #define GL_UNSIGNED_INT64_AMD 0x8BC2 #define GL_PERCENTAGE_AMD 0x8BC3 #define GL_PERFMON_RESULT_AVAILABLE_AMD 0x8BC4 #define GL_PERFMON_RESULT_SIZE_AMD 0x8BC5 #define GL_PERFMON_RESULT_AMD 0x8BC6 typedef void (GLAPIENTRY * PFNGLBEGINPERFMONITORAMDPROC) (GLuint monitor); typedef void (GLAPIENTRY * PFNGLDELETEPERFMONITORSAMDPROC) (GLsizei n, GLuint* monitors); typedef void (GLAPIENTRY * PFNGLENDPERFMONITORAMDPROC) (GLuint monitor); typedef void (GLAPIENTRY * PFNGLGENPERFMONITORSAMDPROC) (GLsizei n, GLuint* monitors); typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERDATAAMDPROC) (GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint *bytesWritten); typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERINFOAMDPROC) (GLuint group, GLuint counter, GLenum pname, void *data); typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC) (GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar *counterString); typedef void (GLAPIENTRY * PFNGLGETPERFMONITORCOUNTERSAMDPROC) (GLuint group, GLint* numCounters, GLint *maxActiveCounters, GLsizei countersSize, GLuint *counters); typedef void (GLAPIENTRY * PFNGLGETPERFMONITORGROUPSTRINGAMDPROC) (GLuint group, GLsizei bufSize, GLsizei* length, GLchar *groupString); typedef void (GLAPIENTRY * PFNGLGETPERFMONITORGROUPSAMDPROC) (GLint* numGroups, GLsizei groupsSize, GLuint *groups); typedef void (GLAPIENTRY * PFNGLSELECTPERFMONITORCOUNTERSAMDPROC) (GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList); #define glBeginPerfMonitorAMD GLEW_GET_FUN(__glewBeginPerfMonitorAMD) #define glDeletePerfMonitorsAMD GLEW_GET_FUN(__glewDeletePerfMonitorsAMD) #define glEndPerfMonitorAMD GLEW_GET_FUN(__glewEndPerfMonitorAMD) #define glGenPerfMonitorsAMD GLEW_GET_FUN(__glewGenPerfMonitorsAMD) #define glGetPerfMonitorCounterDataAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterDataAMD) #define glGetPerfMonitorCounterInfoAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterInfoAMD) #define glGetPerfMonitorCounterStringAMD GLEW_GET_FUN(__glewGetPerfMonitorCounterStringAMD) #define glGetPerfMonitorCountersAMD GLEW_GET_FUN(__glewGetPerfMonitorCountersAMD) #define glGetPerfMonitorGroupStringAMD GLEW_GET_FUN(__glewGetPerfMonitorGroupStringAMD) #define glGetPerfMonitorGroupsAMD GLEW_GET_FUN(__glewGetPerfMonitorGroupsAMD) #define glSelectPerfMonitorCountersAMD GLEW_GET_FUN(__glewSelectPerfMonitorCountersAMD) #define GLEW_AMD_performance_monitor GLEW_GET_VAR(__GLEW_AMD_performance_monitor) #endif /* GL_AMD_performance_monitor */ /* -------------------------- GL_AMD_pinned_memory ------------------------- */ #ifndef GL_AMD_pinned_memory #define GL_AMD_pinned_memory 1 #define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD 0x9160 #define GLEW_AMD_pinned_memory GLEW_GET_VAR(__GLEW_AMD_pinned_memory) #endif /* GL_AMD_pinned_memory */ /* ----------------------- GL_AMD_query_buffer_object ---------------------- */ #ifndef GL_AMD_query_buffer_object #define GL_AMD_query_buffer_object 1 #define GL_QUERY_BUFFER_AMD 0x9192 #define GL_QUERY_BUFFER_BINDING_AMD 0x9193 #define GL_QUERY_RESULT_NO_WAIT_AMD 0x9194 #define GLEW_AMD_query_buffer_object GLEW_GET_VAR(__GLEW_AMD_query_buffer_object) #endif /* GL_AMD_query_buffer_object */ /* ------------------------ GL_AMD_sample_positions ------------------------ */ #ifndef GL_AMD_sample_positions #define GL_AMD_sample_positions 1 #define GL_SUBSAMPLE_DISTANCE_AMD 0x883F typedef void (GLAPIENTRY * PFNGLSETMULTISAMPLEFVAMDPROC) (GLenum pname, GLuint index, const GLfloat* val); #define glSetMultisamplefvAMD GLEW_GET_FUN(__glewSetMultisamplefvAMD) #define GLEW_AMD_sample_positions GLEW_GET_VAR(__GLEW_AMD_sample_positions) #endif /* GL_AMD_sample_positions */ /* ------------------ GL_AMD_seamless_cubemap_per_texture ------------------ */ #ifndef GL_AMD_seamless_cubemap_per_texture #define GL_AMD_seamless_cubemap_per_texture 1 #define GL_TEXTURE_CUBE_MAP_SEAMLESS_ARB 0x884F #define GLEW_AMD_seamless_cubemap_per_texture GLEW_GET_VAR(__GLEW_AMD_seamless_cubemap_per_texture) #endif /* GL_AMD_seamless_cubemap_per_texture */ /* -------------------- GL_AMD_shader_atomic_counter_ops ------------------- */ #ifndef GL_AMD_shader_atomic_counter_ops #define GL_AMD_shader_atomic_counter_ops 1 #define GLEW_AMD_shader_atomic_counter_ops GLEW_GET_VAR(__GLEW_AMD_shader_atomic_counter_ops) #endif /* GL_AMD_shader_atomic_counter_ops */ /* ---------------------- GL_AMD_shader_stencil_export --------------------- */ #ifndef GL_AMD_shader_stencil_export #define GL_AMD_shader_stencil_export 1 #define GLEW_AMD_shader_stencil_export GLEW_GET_VAR(__GLEW_AMD_shader_stencil_export) #endif /* GL_AMD_shader_stencil_export */ /* ------------------- GL_AMD_shader_stencil_value_export ------------------ */ #ifndef GL_AMD_shader_stencil_value_export #define GL_AMD_shader_stencil_value_export 1 #define GLEW_AMD_shader_stencil_value_export GLEW_GET_VAR(__GLEW_AMD_shader_stencil_value_export) #endif /* GL_AMD_shader_stencil_value_export */ /* ---------------------- GL_AMD_shader_trinary_minmax --------------------- */ #ifndef GL_AMD_shader_trinary_minmax #define GL_AMD_shader_trinary_minmax 1 #define GLEW_AMD_shader_trinary_minmax GLEW_GET_VAR(__GLEW_AMD_shader_trinary_minmax) #endif /* GL_AMD_shader_trinary_minmax */ /* ------------------------- GL_AMD_sparse_texture ------------------------- */ #ifndef GL_AMD_sparse_texture #define GL_AMD_sparse_texture 1 #define GL_TEXTURE_STORAGE_SPARSE_BIT_AMD 0x00000001 #define GL_VIRTUAL_PAGE_SIZE_X_AMD 0x9195 #define GL_VIRTUAL_PAGE_SIZE_Y_AMD 0x9196 #define GL_VIRTUAL_PAGE_SIZE_Z_AMD 0x9197 #define GL_MAX_SPARSE_TEXTURE_SIZE_AMD 0x9198 #define GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD 0x9199 #define GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS 0x919A #define GL_MIN_SPARSE_LEVEL_AMD 0x919B #define GL_MIN_LOD_WARNING_AMD 0x919C typedef void (GLAPIENTRY * PFNGLTEXSTORAGESPARSEAMDPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGESPARSEAMDPROC) (GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags); #define glTexStorageSparseAMD GLEW_GET_FUN(__glewTexStorageSparseAMD) #define glTextureStorageSparseAMD GLEW_GET_FUN(__glewTextureStorageSparseAMD) #define GLEW_AMD_sparse_texture GLEW_GET_VAR(__GLEW_AMD_sparse_texture) #endif /* GL_AMD_sparse_texture */ /* ------------------- GL_AMD_stencil_operation_extended ------------------- */ #ifndef GL_AMD_stencil_operation_extended #define GL_AMD_stencil_operation_extended 1 #define GL_SET_AMD 0x874A #define GL_REPLACE_VALUE_AMD 0x874B #define GL_STENCIL_OP_VALUE_AMD 0x874C #define GL_STENCIL_BACK_OP_VALUE_AMD 0x874D typedef void (GLAPIENTRY * PFNGLSTENCILOPVALUEAMDPROC) (GLenum face, GLuint value); #define glStencilOpValueAMD GLEW_GET_FUN(__glewStencilOpValueAMD) #define GLEW_AMD_stencil_operation_extended GLEW_GET_VAR(__GLEW_AMD_stencil_operation_extended) #endif /* GL_AMD_stencil_operation_extended */ /* ------------------------ GL_AMD_texture_texture4 ------------------------ */ #ifndef GL_AMD_texture_texture4 #define GL_AMD_texture_texture4 1 #define GLEW_AMD_texture_texture4 GLEW_GET_VAR(__GLEW_AMD_texture_texture4) #endif /* GL_AMD_texture_texture4 */ /* --------------- GL_AMD_transform_feedback3_lines_triangles -------------- */ #ifndef GL_AMD_transform_feedback3_lines_triangles #define GL_AMD_transform_feedback3_lines_triangles 1 #define GLEW_AMD_transform_feedback3_lines_triangles GLEW_GET_VAR(__GLEW_AMD_transform_feedback3_lines_triangles) #endif /* GL_AMD_transform_feedback3_lines_triangles */ /* ----------------------- GL_AMD_transform_feedback4 ---------------------- */ #ifndef GL_AMD_transform_feedback4 #define GL_AMD_transform_feedback4 1 #define GL_STREAM_RASTERIZATION_AMD 0x91A0 #define GLEW_AMD_transform_feedback4 GLEW_GET_VAR(__GLEW_AMD_transform_feedback4) #endif /* GL_AMD_transform_feedback4 */ /* ----------------------- GL_AMD_vertex_shader_layer ---------------------- */ #ifndef GL_AMD_vertex_shader_layer #define GL_AMD_vertex_shader_layer 1 #define GLEW_AMD_vertex_shader_layer GLEW_GET_VAR(__GLEW_AMD_vertex_shader_layer) #endif /* GL_AMD_vertex_shader_layer */ /* -------------------- GL_AMD_vertex_shader_tessellator ------------------- */ #ifndef GL_AMD_vertex_shader_tessellator #define GL_AMD_vertex_shader_tessellator 1 #define GL_SAMPLER_BUFFER_AMD 0x9001 #define GL_INT_SAMPLER_BUFFER_AMD 0x9002 #define GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD 0x9003 #define GL_TESSELLATION_MODE_AMD 0x9004 #define GL_TESSELLATION_FACTOR_AMD 0x9005 #define GL_DISCRETE_AMD 0x9006 #define GL_CONTINUOUS_AMD 0x9007 typedef void (GLAPIENTRY * PFNGLTESSELLATIONFACTORAMDPROC) (GLfloat factor); typedef void (GLAPIENTRY * PFNGLTESSELLATIONMODEAMDPROC) (GLenum mode); #define glTessellationFactorAMD GLEW_GET_FUN(__glewTessellationFactorAMD) #define glTessellationModeAMD GLEW_GET_FUN(__glewTessellationModeAMD) #define GLEW_AMD_vertex_shader_tessellator GLEW_GET_VAR(__GLEW_AMD_vertex_shader_tessellator) #endif /* GL_AMD_vertex_shader_tessellator */ /* ------------------ GL_AMD_vertex_shader_viewport_index ------------------ */ #ifndef GL_AMD_vertex_shader_viewport_index #define GL_AMD_vertex_shader_viewport_index 1 #define GLEW_AMD_vertex_shader_viewport_index GLEW_GET_VAR(__GLEW_AMD_vertex_shader_viewport_index) #endif /* GL_AMD_vertex_shader_viewport_index */ /* ------------------------- GL_ANGLE_depth_texture ------------------------ */ #ifndef GL_ANGLE_depth_texture #define GL_ANGLE_depth_texture 1 #define GLEW_ANGLE_depth_texture GLEW_GET_VAR(__GLEW_ANGLE_depth_texture) #endif /* GL_ANGLE_depth_texture */ /* ----------------------- GL_ANGLE_framebuffer_blit ----------------------- */ #ifndef GL_ANGLE_framebuffer_blit #define GL_ANGLE_framebuffer_blit 1 #define GL_DRAW_FRAMEBUFFER_BINDING_ANGLE 0x8CA6 #define GL_READ_FRAMEBUFFER_ANGLE 0x8CA8 #define GL_DRAW_FRAMEBUFFER_ANGLE 0x8CA9 #define GL_READ_FRAMEBUFFER_BINDING_ANGLE 0x8CAA typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERANGLEPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); #define glBlitFramebufferANGLE GLEW_GET_FUN(__glewBlitFramebufferANGLE) #define GLEW_ANGLE_framebuffer_blit GLEW_GET_VAR(__GLEW_ANGLE_framebuffer_blit) #endif /* GL_ANGLE_framebuffer_blit */ /* -------------------- GL_ANGLE_framebuffer_multisample ------------------- */ #ifndef GL_ANGLE_framebuffer_multisample #define GL_ANGLE_framebuffer_multisample 1 #define GL_RENDERBUFFER_SAMPLES_ANGLE 0x8CAB #define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE 0x8D56 #define GL_MAX_SAMPLES_ANGLE 0x8D57 typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); #define glRenderbufferStorageMultisampleANGLE GLEW_GET_FUN(__glewRenderbufferStorageMultisampleANGLE) #define GLEW_ANGLE_framebuffer_multisample GLEW_GET_VAR(__GLEW_ANGLE_framebuffer_multisample) #endif /* GL_ANGLE_framebuffer_multisample */ /* ----------------------- GL_ANGLE_instanced_arrays ----------------------- */ #ifndef GL_ANGLE_instanced_arrays #define GL_ANGLE_instanced_arrays 1 #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE 0x88FE typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDANGLEPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDANGLEPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORANGLEPROC) (GLuint index, GLuint divisor); #define glDrawArraysInstancedANGLE GLEW_GET_FUN(__glewDrawArraysInstancedANGLE) #define glDrawElementsInstancedANGLE GLEW_GET_FUN(__glewDrawElementsInstancedANGLE) #define glVertexAttribDivisorANGLE GLEW_GET_FUN(__glewVertexAttribDivisorANGLE) #define GLEW_ANGLE_instanced_arrays GLEW_GET_VAR(__GLEW_ANGLE_instanced_arrays) #endif /* GL_ANGLE_instanced_arrays */ /* -------------------- GL_ANGLE_pack_reverse_row_order -------------------- */ #ifndef GL_ANGLE_pack_reverse_row_order #define GL_ANGLE_pack_reverse_row_order 1 #define GL_PACK_REVERSE_ROW_ORDER_ANGLE 0x93A4 #define GLEW_ANGLE_pack_reverse_row_order GLEW_GET_VAR(__GLEW_ANGLE_pack_reverse_row_order) #endif /* GL_ANGLE_pack_reverse_row_order */ /* ------------------------ GL_ANGLE_program_binary ------------------------ */ #ifndef GL_ANGLE_program_binary #define GL_ANGLE_program_binary 1 #define GL_PROGRAM_BINARY_ANGLE 0x93A6 #define GLEW_ANGLE_program_binary GLEW_GET_VAR(__GLEW_ANGLE_program_binary) #endif /* GL_ANGLE_program_binary */ /* ------------------- GL_ANGLE_texture_compression_dxt1 ------------------- */ #ifndef GL_ANGLE_texture_compression_dxt1 #define GL_ANGLE_texture_compression_dxt1 1 #define GL_COMPRESSED_RGB_S3TC_DXT1_ANGLE 0x83F0 #define GL_COMPRESSED_RGBA_S3TC_DXT1_ANGLE 0x83F1 #define GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE 0x83F2 #define GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE 0x83F3 #define GLEW_ANGLE_texture_compression_dxt1 GLEW_GET_VAR(__GLEW_ANGLE_texture_compression_dxt1) #endif /* GL_ANGLE_texture_compression_dxt1 */ /* ------------------- GL_ANGLE_texture_compression_dxt3 ------------------- */ #ifndef GL_ANGLE_texture_compression_dxt3 #define GL_ANGLE_texture_compression_dxt3 1 #define GL_COMPRESSED_RGB_S3TC_DXT1_ANGLE 0x83F0 #define GL_COMPRESSED_RGBA_S3TC_DXT1_ANGLE 0x83F1 #define GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE 0x83F2 #define GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE 0x83F3 #define GLEW_ANGLE_texture_compression_dxt3 GLEW_GET_VAR(__GLEW_ANGLE_texture_compression_dxt3) #endif /* GL_ANGLE_texture_compression_dxt3 */ /* ------------------- GL_ANGLE_texture_compression_dxt5 ------------------- */ #ifndef GL_ANGLE_texture_compression_dxt5 #define GL_ANGLE_texture_compression_dxt5 1 #define GL_COMPRESSED_RGB_S3TC_DXT1_ANGLE 0x83F0 #define GL_COMPRESSED_RGBA_S3TC_DXT1_ANGLE 0x83F1 #define GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE 0x83F2 #define GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE 0x83F3 #define GLEW_ANGLE_texture_compression_dxt5 GLEW_GET_VAR(__GLEW_ANGLE_texture_compression_dxt5) #endif /* GL_ANGLE_texture_compression_dxt5 */ /* ------------------------- GL_ANGLE_texture_usage ------------------------ */ #ifndef GL_ANGLE_texture_usage #define GL_ANGLE_texture_usage 1 #define GL_TEXTURE_USAGE_ANGLE 0x93A2 #define GL_FRAMEBUFFER_ATTACHMENT_ANGLE 0x93A3 #define GLEW_ANGLE_texture_usage GLEW_GET_VAR(__GLEW_ANGLE_texture_usage) #endif /* GL_ANGLE_texture_usage */ /* -------------------------- GL_ANGLE_timer_query ------------------------- */ #ifndef GL_ANGLE_timer_query #define GL_ANGLE_timer_query 1 #define GL_QUERY_COUNTER_BITS_ANGLE 0x8864 #define GL_CURRENT_QUERY_ANGLE 0x8865 #define GL_QUERY_RESULT_ANGLE 0x8866 #define GL_QUERY_RESULT_AVAILABLE_ANGLE 0x8867 #define GL_TIME_ELAPSED_ANGLE 0x88BF #define GL_TIMESTAMP_ANGLE 0x8E28 typedef void (GLAPIENTRY * PFNGLBEGINQUERYANGLEPROC) (GLenum target, GLuint id); typedef void (GLAPIENTRY * PFNGLDELETEQUERIESANGLEPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLENDQUERYANGLEPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLGENQUERIESANGLEPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VANGLEPROC) (GLuint id, GLenum pname, GLint64* params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVANGLEPROC) (GLuint id, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VANGLEPROC) (GLuint id, GLenum pname, GLuint64* params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVANGLEPROC) (GLuint id, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYIVANGLEPROC) (GLenum target, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISQUERYANGLEPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLQUERYCOUNTERANGLEPROC) (GLuint id, GLenum target); #define glBeginQueryANGLE GLEW_GET_FUN(__glewBeginQueryANGLE) #define glDeleteQueriesANGLE GLEW_GET_FUN(__glewDeleteQueriesANGLE) #define glEndQueryANGLE GLEW_GET_FUN(__glewEndQueryANGLE) #define glGenQueriesANGLE GLEW_GET_FUN(__glewGenQueriesANGLE) #define glGetQueryObjecti64vANGLE GLEW_GET_FUN(__glewGetQueryObjecti64vANGLE) #define glGetQueryObjectivANGLE GLEW_GET_FUN(__glewGetQueryObjectivANGLE) #define glGetQueryObjectui64vANGLE GLEW_GET_FUN(__glewGetQueryObjectui64vANGLE) #define glGetQueryObjectuivANGLE GLEW_GET_FUN(__glewGetQueryObjectuivANGLE) #define glGetQueryivANGLE GLEW_GET_FUN(__glewGetQueryivANGLE) #define glIsQueryANGLE GLEW_GET_FUN(__glewIsQueryANGLE) #define glQueryCounterANGLE GLEW_GET_FUN(__glewQueryCounterANGLE) #define GLEW_ANGLE_timer_query GLEW_GET_VAR(__GLEW_ANGLE_timer_query) #endif /* GL_ANGLE_timer_query */ /* ------------------- GL_ANGLE_translated_shader_source ------------------- */ #ifndef GL_ANGLE_translated_shader_source #define GL_ANGLE_translated_shader_source 1 #define GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE 0x93A0 typedef void (GLAPIENTRY * PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC) (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source); #define glGetTranslatedShaderSourceANGLE GLEW_GET_FUN(__glewGetTranslatedShaderSourceANGLE) #define GLEW_ANGLE_translated_shader_source GLEW_GET_VAR(__GLEW_ANGLE_translated_shader_source) #endif /* GL_ANGLE_translated_shader_source */ /* ----------------------- GL_APPLE_aux_depth_stencil ---------------------- */ #ifndef GL_APPLE_aux_depth_stencil #define GL_APPLE_aux_depth_stencil 1 #define GL_AUX_DEPTH_STENCIL_APPLE 0x8A14 #define GLEW_APPLE_aux_depth_stencil GLEW_GET_VAR(__GLEW_APPLE_aux_depth_stencil) #endif /* GL_APPLE_aux_depth_stencil */ /* ------------------------ GL_APPLE_client_storage ------------------------ */ #ifndef GL_APPLE_client_storage #define GL_APPLE_client_storage 1 #define GL_UNPACK_CLIENT_STORAGE_APPLE 0x85B2 #define GLEW_APPLE_client_storage GLEW_GET_VAR(__GLEW_APPLE_client_storage) #endif /* GL_APPLE_client_storage */ /* ------------------------- GL_APPLE_element_array ------------------------ */ #ifndef GL_APPLE_element_array #define GL_APPLE_element_array 1 #define GL_ELEMENT_ARRAY_APPLE 0x8A0C #define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8A0D #define GL_ELEMENT_ARRAY_POINTER_APPLE 0x8A0E typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count); typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count); typedef void (GLAPIENTRY * PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const void *pointer); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, const GLint* first, const GLsizei *count, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, const GLint* first, const GLsizei *count, GLsizei primcount); #define glDrawElementArrayAPPLE GLEW_GET_FUN(__glewDrawElementArrayAPPLE) #define glDrawRangeElementArrayAPPLE GLEW_GET_FUN(__glewDrawRangeElementArrayAPPLE) #define glElementPointerAPPLE GLEW_GET_FUN(__glewElementPointerAPPLE) #define glMultiDrawElementArrayAPPLE GLEW_GET_FUN(__glewMultiDrawElementArrayAPPLE) #define glMultiDrawRangeElementArrayAPPLE GLEW_GET_FUN(__glewMultiDrawRangeElementArrayAPPLE) #define GLEW_APPLE_element_array GLEW_GET_VAR(__GLEW_APPLE_element_array) #endif /* GL_APPLE_element_array */ /* ----------------------------- GL_APPLE_fence ---------------------------- */ #ifndef GL_APPLE_fence #define GL_APPLE_fence 1 #define GL_DRAW_PIXELS_APPLE 0x8A0A #define GL_FENCE_APPLE 0x8A0B typedef void (GLAPIENTRY * PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLuint* fences); typedef void (GLAPIENTRY * PFNGLFINISHFENCEAPPLEPROC) (GLuint fence); typedef void (GLAPIENTRY * PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint name); typedef void (GLAPIENTRY * PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint* fences); typedef GLboolean (GLAPIENTRY * PFNGLISFENCEAPPLEPROC) (GLuint fence); typedef void (GLAPIENTRY * PFNGLSETFENCEAPPLEPROC) (GLuint fence); typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCEAPPLEPROC) (GLuint fence); typedef GLboolean (GLAPIENTRY * PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GLuint name); #define glDeleteFencesAPPLE GLEW_GET_FUN(__glewDeleteFencesAPPLE) #define glFinishFenceAPPLE GLEW_GET_FUN(__glewFinishFenceAPPLE) #define glFinishObjectAPPLE GLEW_GET_FUN(__glewFinishObjectAPPLE) #define glGenFencesAPPLE GLEW_GET_FUN(__glewGenFencesAPPLE) #define glIsFenceAPPLE GLEW_GET_FUN(__glewIsFenceAPPLE) #define glSetFenceAPPLE GLEW_GET_FUN(__glewSetFenceAPPLE) #define glTestFenceAPPLE GLEW_GET_FUN(__glewTestFenceAPPLE) #define glTestObjectAPPLE GLEW_GET_FUN(__glewTestObjectAPPLE) #define GLEW_APPLE_fence GLEW_GET_VAR(__GLEW_APPLE_fence) #endif /* GL_APPLE_fence */ /* ------------------------- GL_APPLE_float_pixels ------------------------- */ #ifndef GL_APPLE_float_pixels #define GL_APPLE_float_pixels 1 #define GL_HALF_APPLE 0x140B #define GL_RGBA_FLOAT32_APPLE 0x8814 #define GL_RGB_FLOAT32_APPLE 0x8815 #define GL_ALPHA_FLOAT32_APPLE 0x8816 #define GL_INTENSITY_FLOAT32_APPLE 0x8817 #define GL_LUMINANCE_FLOAT32_APPLE 0x8818 #define GL_LUMINANCE_ALPHA_FLOAT32_APPLE 0x8819 #define GL_RGBA_FLOAT16_APPLE 0x881A #define GL_RGB_FLOAT16_APPLE 0x881B #define GL_ALPHA_FLOAT16_APPLE 0x881C #define GL_INTENSITY_FLOAT16_APPLE 0x881D #define GL_LUMINANCE_FLOAT16_APPLE 0x881E #define GL_LUMINANCE_ALPHA_FLOAT16_APPLE 0x881F #define GL_COLOR_FLOAT_APPLE 0x8A0F #define GLEW_APPLE_float_pixels GLEW_GET_VAR(__GLEW_APPLE_float_pixels) #endif /* GL_APPLE_float_pixels */ /* ---------------------- GL_APPLE_flush_buffer_range ---------------------- */ #ifndef GL_APPLE_flush_buffer_range #define GL_APPLE_flush_buffer_range 1 #define GL_BUFFER_SERIALIZED_MODIFY_APPLE 0x8A12 #define GL_BUFFER_FLUSHING_UNMAP_APPLE 0x8A13 typedef void (GLAPIENTRY * PFNGLBUFFERPARAMETERIAPPLEPROC) (GLenum target, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target, GLintptr offset, GLsizeiptr size); #define glBufferParameteriAPPLE GLEW_GET_FUN(__glewBufferParameteriAPPLE) #define glFlushMappedBufferRangeAPPLE GLEW_GET_FUN(__glewFlushMappedBufferRangeAPPLE) #define GLEW_APPLE_flush_buffer_range GLEW_GET_VAR(__GLEW_APPLE_flush_buffer_range) #endif /* GL_APPLE_flush_buffer_range */ /* ----------------------- GL_APPLE_object_purgeable ----------------------- */ #ifndef GL_APPLE_object_purgeable #define GL_APPLE_object_purgeable 1 #define GL_BUFFER_OBJECT_APPLE 0x85B3 #define GL_RELEASED_APPLE 0x8A19 #define GL_VOLATILE_APPLE 0x8A1A #define GL_RETAINED_APPLE 0x8A1B #define GL_UNDEFINED_APPLE 0x8A1C #define GL_PURGEABLE_APPLE 0x8A1D typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVAPPLEPROC) (GLenum objectType, GLuint name, GLenum pname, GLint* params); typedef GLenum (GLAPIENTRY * PFNGLOBJECTPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option); typedef GLenum (GLAPIENTRY * PFNGLOBJECTUNPURGEABLEAPPLEPROC) (GLenum objectType, GLuint name, GLenum option); #define glGetObjectParameterivAPPLE GLEW_GET_FUN(__glewGetObjectParameterivAPPLE) #define glObjectPurgeableAPPLE GLEW_GET_FUN(__glewObjectPurgeableAPPLE) #define glObjectUnpurgeableAPPLE GLEW_GET_FUN(__glewObjectUnpurgeableAPPLE) #define GLEW_APPLE_object_purgeable GLEW_GET_VAR(__GLEW_APPLE_object_purgeable) #endif /* GL_APPLE_object_purgeable */ /* ------------------------- GL_APPLE_pixel_buffer ------------------------- */ #ifndef GL_APPLE_pixel_buffer #define GL_APPLE_pixel_buffer 1 #define GL_MIN_PBUFFER_VIEWPORT_DIMS_APPLE 0x8A10 #define GLEW_APPLE_pixel_buffer GLEW_GET_VAR(__GLEW_APPLE_pixel_buffer) #endif /* GL_APPLE_pixel_buffer */ /* ---------------------------- GL_APPLE_rgb_422 --------------------------- */ #ifndef GL_APPLE_rgb_422 #define GL_APPLE_rgb_422 1 #define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA #define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB #define GL_RGB_422_APPLE 0x8A1F #define GL_RGB_RAW_422_APPLE 0x8A51 #define GLEW_APPLE_rgb_422 GLEW_GET_VAR(__GLEW_APPLE_rgb_422) #endif /* GL_APPLE_rgb_422 */ /* --------------------------- GL_APPLE_row_bytes -------------------------- */ #ifndef GL_APPLE_row_bytes #define GL_APPLE_row_bytes 1 #define GL_PACK_ROW_BYTES_APPLE 0x8A15 #define GL_UNPACK_ROW_BYTES_APPLE 0x8A16 #define GLEW_APPLE_row_bytes GLEW_GET_VAR(__GLEW_APPLE_row_bytes) #endif /* GL_APPLE_row_bytes */ /* ------------------------ GL_APPLE_specular_vector ----------------------- */ #ifndef GL_APPLE_specular_vector #define GL_APPLE_specular_vector 1 #define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0 #define GLEW_APPLE_specular_vector GLEW_GET_VAR(__GLEW_APPLE_specular_vector) #endif /* GL_APPLE_specular_vector */ /* ------------------------- GL_APPLE_texture_range ------------------------ */ #ifndef GL_APPLE_texture_range #define GL_APPLE_texture_range 1 #define GL_TEXTURE_RANGE_LENGTH_APPLE 0x85B7 #define GL_TEXTURE_RANGE_POINTER_APPLE 0x85B8 #define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC #define GL_STORAGE_PRIVATE_APPLE 0x85BD #define GL_STORAGE_CACHED_APPLE 0x85BE #define GL_STORAGE_SHARED_APPLE 0x85BF typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC) (GLenum target, GLenum pname, void **params); typedef void (GLAPIENTRY * PFNGLTEXTURERANGEAPPLEPROC) (GLenum target, GLsizei length, void *pointer); #define glGetTexParameterPointervAPPLE GLEW_GET_FUN(__glewGetTexParameterPointervAPPLE) #define glTextureRangeAPPLE GLEW_GET_FUN(__glewTextureRangeAPPLE) #define GLEW_APPLE_texture_range GLEW_GET_VAR(__GLEW_APPLE_texture_range) #endif /* GL_APPLE_texture_range */ /* ------------------------ GL_APPLE_transform_hint ------------------------ */ #ifndef GL_APPLE_transform_hint #define GL_APPLE_transform_hint 1 #define GL_TRANSFORM_HINT_APPLE 0x85B1 #define GLEW_APPLE_transform_hint GLEW_GET_VAR(__GLEW_APPLE_transform_hint) #endif /* GL_APPLE_transform_hint */ /* ---------------------- GL_APPLE_vertex_array_object --------------------- */ #ifndef GL_APPLE_vertex_array_object #define GL_APPLE_vertex_array_object 1 #define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5 typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array); typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint* arrays); typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint* arrays); typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array); #define glBindVertexArrayAPPLE GLEW_GET_FUN(__glewBindVertexArrayAPPLE) #define glDeleteVertexArraysAPPLE GLEW_GET_FUN(__glewDeleteVertexArraysAPPLE) #define glGenVertexArraysAPPLE GLEW_GET_FUN(__glewGenVertexArraysAPPLE) #define glIsVertexArrayAPPLE GLEW_GET_FUN(__glewIsVertexArrayAPPLE) #define GLEW_APPLE_vertex_array_object GLEW_GET_VAR(__GLEW_APPLE_vertex_array_object) #endif /* GL_APPLE_vertex_array_object */ /* ---------------------- GL_APPLE_vertex_array_range ---------------------- */ #ifndef GL_APPLE_vertex_array_range #define GL_APPLE_vertex_array_range 1 #define GL_VERTEX_ARRAY_RANGE_APPLE 0x851D #define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E #define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F #define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_APPLE 0x8520 #define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521 #define GL_STORAGE_CLIENT_APPLE 0x85B4 #define GL_STORAGE_CACHED_APPLE 0x85BE #define GL_STORAGE_SHARED_APPLE 0x85BF typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void *pointer); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void *pointer); #define glFlushVertexArrayRangeAPPLE GLEW_GET_FUN(__glewFlushVertexArrayRangeAPPLE) #define glVertexArrayParameteriAPPLE GLEW_GET_FUN(__glewVertexArrayParameteriAPPLE) #define glVertexArrayRangeAPPLE GLEW_GET_FUN(__glewVertexArrayRangeAPPLE) #define GLEW_APPLE_vertex_array_range GLEW_GET_VAR(__GLEW_APPLE_vertex_array_range) #endif /* GL_APPLE_vertex_array_range */ /* ------------------- GL_APPLE_vertex_program_evaluators ------------------ */ #ifndef GL_APPLE_vertex_program_evaluators #define GL_APPLE_vertex_program_evaluators 1 #define GL_VERTEX_ATTRIB_MAP1_APPLE 0x8A00 #define GL_VERTEX_ATTRIB_MAP2_APPLE 0x8A01 #define GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE 0x8A02 #define GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE 0x8A03 #define GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE 0x8A04 #define GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE 0x8A05 #define GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE 0x8A06 #define GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE 0x8A07 #define GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE 0x8A08 #define GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE 0x8A09 typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname); typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBAPPLEPROC) (GLuint index, GLenum pname); typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXATTRIBENABLEDAPPLEPROC) (GLuint index, GLenum pname); typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB1DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points); typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB1FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points); typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB2DAPPLEPROC) (GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points); typedef void (GLAPIENTRY * PFNGLMAPVERTEXATTRIB2FAPPLEPROC) (GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points); #define glDisableVertexAttribAPPLE GLEW_GET_FUN(__glewDisableVertexAttribAPPLE) #define glEnableVertexAttribAPPLE GLEW_GET_FUN(__glewEnableVertexAttribAPPLE) #define glIsVertexAttribEnabledAPPLE GLEW_GET_FUN(__glewIsVertexAttribEnabledAPPLE) #define glMapVertexAttrib1dAPPLE GLEW_GET_FUN(__glewMapVertexAttrib1dAPPLE) #define glMapVertexAttrib1fAPPLE GLEW_GET_FUN(__glewMapVertexAttrib1fAPPLE) #define glMapVertexAttrib2dAPPLE GLEW_GET_FUN(__glewMapVertexAttrib2dAPPLE) #define glMapVertexAttrib2fAPPLE GLEW_GET_FUN(__glewMapVertexAttrib2fAPPLE) #define GLEW_APPLE_vertex_program_evaluators GLEW_GET_VAR(__GLEW_APPLE_vertex_program_evaluators) #endif /* GL_APPLE_vertex_program_evaluators */ /* --------------------------- GL_APPLE_ycbcr_422 -------------------------- */ #ifndef GL_APPLE_ycbcr_422 #define GL_APPLE_ycbcr_422 1 #define GL_YCBCR_422_APPLE 0x85B9 #define GLEW_APPLE_ycbcr_422 GLEW_GET_VAR(__GLEW_APPLE_ycbcr_422) #endif /* GL_APPLE_ycbcr_422 */ /* ------------------------ GL_ARB_ES2_compatibility ----------------------- */ #ifndef GL_ARB_ES2_compatibility #define GL_ARB_ES2_compatibility 1 #define GL_FIXED 0x140C #define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A #define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B #define GL_RGB565 0x8D62 #define GL_LOW_FLOAT 0x8DF0 #define GL_MEDIUM_FLOAT 0x8DF1 #define GL_HIGH_FLOAT 0x8DF2 #define GL_LOW_INT 0x8DF3 #define GL_MEDIUM_INT 0x8DF4 #define GL_HIGH_INT 0x8DF5 #define GL_SHADER_BINARY_FORMATS 0x8DF8 #define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9 #define GL_SHADER_COMPILER 0x8DFA #define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB #define GL_MAX_VARYING_VECTORS 0x8DFC #define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD typedef int GLfixed; typedef void (GLAPIENTRY * PFNGLCLEARDEPTHFPROC) (GLclampf d); typedef void (GLAPIENTRY * PFNGLDEPTHRANGEFPROC) (GLclampf n, GLclampf f); typedef void (GLAPIENTRY * PFNGLGETSHADERPRECISIONFORMATPROC) (GLenum shadertype, GLenum precisiontype, GLint* range, GLint *precision); typedef void (GLAPIENTRY * PFNGLRELEASESHADERCOMPILERPROC) (void); typedef void (GLAPIENTRY * PFNGLSHADERBINARYPROC) (GLsizei count, const GLuint* shaders, GLenum binaryformat, const void*binary, GLsizei length); #define glClearDepthf GLEW_GET_FUN(__glewClearDepthf) #define glDepthRangef GLEW_GET_FUN(__glewDepthRangef) #define glGetShaderPrecisionFormat GLEW_GET_FUN(__glewGetShaderPrecisionFormat) #define glReleaseShaderCompiler GLEW_GET_FUN(__glewReleaseShaderCompiler) #define glShaderBinary GLEW_GET_FUN(__glewShaderBinary) #define GLEW_ARB_ES2_compatibility GLEW_GET_VAR(__GLEW_ARB_ES2_compatibility) #endif /* GL_ARB_ES2_compatibility */ /* ----------------------- GL_ARB_ES3_1_compatibility ---------------------- */ #ifndef GL_ARB_ES3_1_compatibility #define GL_ARB_ES3_1_compatibility 1 typedef void (GLAPIENTRY * PFNGLMEMORYBARRIERBYREGIONPROC) (GLbitfield barriers); #define glMemoryBarrierByRegion GLEW_GET_FUN(__glewMemoryBarrierByRegion) #define GLEW_ARB_ES3_1_compatibility GLEW_GET_VAR(__GLEW_ARB_ES3_1_compatibility) #endif /* GL_ARB_ES3_1_compatibility */ /* ----------------------- GL_ARB_ES3_2_compatibility ---------------------- */ #ifndef GL_ARB_ES3_2_compatibility #define GL_ARB_ES3_2_compatibility 1 #define GL_PRIMITIVE_BOUNDING_BOX_ARB 0x92BE #define GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB 0x9381 #define GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB 0x9382 typedef void (GLAPIENTRY * PFNGLPRIMITIVEBOUNDINGBOXARBPROC) (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW); #define glPrimitiveBoundingBoxARB GLEW_GET_FUN(__glewPrimitiveBoundingBoxARB) #define GLEW_ARB_ES3_2_compatibility GLEW_GET_VAR(__GLEW_ARB_ES3_2_compatibility) #endif /* GL_ARB_ES3_2_compatibility */ /* ------------------------ GL_ARB_ES3_compatibility ----------------------- */ #ifndef GL_ARB_ES3_compatibility #define GL_ARB_ES3_compatibility 1 #define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF #define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69 #define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A #define GL_MAX_ELEMENT_INDEX 0x8D6B #define GL_COMPRESSED_R11_EAC 0x9270 #define GL_COMPRESSED_SIGNED_R11_EAC 0x9271 #define GL_COMPRESSED_RG11_EAC 0x9272 #define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273 #define GL_COMPRESSED_RGB8_ETC2 0x9274 #define GL_COMPRESSED_SRGB8_ETC2 0x9275 #define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276 #define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277 #define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 #define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279 #define GLEW_ARB_ES3_compatibility GLEW_GET_VAR(__GLEW_ARB_ES3_compatibility) #endif /* GL_ARB_ES3_compatibility */ /* ------------------------ GL_ARB_arrays_of_arrays ------------------------ */ #ifndef GL_ARB_arrays_of_arrays #define GL_ARB_arrays_of_arrays 1 #define GLEW_ARB_arrays_of_arrays GLEW_GET_VAR(__GLEW_ARB_arrays_of_arrays) #endif /* GL_ARB_arrays_of_arrays */ /* -------------------------- GL_ARB_base_instance ------------------------- */ #ifndef GL_ARB_base_instance #define GL_ARB_base_instance 1 typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLuint baseinstance); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLint basevertex, GLuint baseinstance); #define glDrawArraysInstancedBaseInstance GLEW_GET_FUN(__glewDrawArraysInstancedBaseInstance) #define glDrawElementsInstancedBaseInstance GLEW_GET_FUN(__glewDrawElementsInstancedBaseInstance) #define glDrawElementsInstancedBaseVertexBaseInstance GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertexBaseInstance) #define GLEW_ARB_base_instance GLEW_GET_VAR(__GLEW_ARB_base_instance) #endif /* GL_ARB_base_instance */ /* ------------------------ GL_ARB_bindless_texture ------------------------ */ #ifndef GL_ARB_bindless_texture #define GL_ARB_bindless_texture 1 #define GL_UNSIGNED_INT64_ARB 0x140F typedef GLuint64 (GLAPIENTRY * PFNGLGETIMAGEHANDLEARBPROC) (GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format); typedef GLuint64 (GLAPIENTRY * PFNGLGETTEXTUREHANDLEARBPROC) (GLuint texture); typedef GLuint64 (GLAPIENTRY * PFNGLGETTEXTURESAMPLERHANDLEARBPROC) (GLuint texture, GLuint sampler); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLUI64VARBPROC) (GLuint index, GLenum pname, GLuint64EXT* params); typedef GLboolean (GLAPIENTRY * PFNGLISIMAGEHANDLERESIDENTARBPROC) (GLuint64 handle); typedef GLboolean (GLAPIENTRY * PFNGLISTEXTUREHANDLERESIDENTARBPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLMAKEIMAGEHANDLERESIDENTARBPROC) (GLuint64 handle, GLenum access); typedef void (GLAPIENTRY * PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLMAKETEXTUREHANDLERESIDENTARBPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC) (GLuint program, GLint location, GLuint64 value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* values); typedef void (GLAPIENTRY * PFNGLUNIFORMHANDLEUI64ARBPROC) (GLint location, GLuint64 value); typedef void (GLAPIENTRY * PFNGLUNIFORMHANDLEUI64VARBPROC) (GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64ARBPROC) (GLuint index, GLuint64EXT x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64VARBPROC) (GLuint index, const GLuint64EXT* v); #define glGetImageHandleARB GLEW_GET_FUN(__glewGetImageHandleARB) #define glGetTextureHandleARB GLEW_GET_FUN(__glewGetTextureHandleARB) #define glGetTextureSamplerHandleARB GLEW_GET_FUN(__glewGetTextureSamplerHandleARB) #define glGetVertexAttribLui64vARB GLEW_GET_FUN(__glewGetVertexAttribLui64vARB) #define glIsImageHandleResidentARB GLEW_GET_FUN(__glewIsImageHandleResidentARB) #define glIsTextureHandleResidentARB GLEW_GET_FUN(__glewIsTextureHandleResidentARB) #define glMakeImageHandleNonResidentARB GLEW_GET_FUN(__glewMakeImageHandleNonResidentARB) #define glMakeImageHandleResidentARB GLEW_GET_FUN(__glewMakeImageHandleResidentARB) #define glMakeTextureHandleNonResidentARB GLEW_GET_FUN(__glewMakeTextureHandleNonResidentARB) #define glMakeTextureHandleResidentARB GLEW_GET_FUN(__glewMakeTextureHandleResidentARB) #define glProgramUniformHandleui64ARB GLEW_GET_FUN(__glewProgramUniformHandleui64ARB) #define glProgramUniformHandleui64vARB GLEW_GET_FUN(__glewProgramUniformHandleui64vARB) #define glUniformHandleui64ARB GLEW_GET_FUN(__glewUniformHandleui64ARB) #define glUniformHandleui64vARB GLEW_GET_FUN(__glewUniformHandleui64vARB) #define glVertexAttribL1ui64ARB GLEW_GET_FUN(__glewVertexAttribL1ui64ARB) #define glVertexAttribL1ui64vARB GLEW_GET_FUN(__glewVertexAttribL1ui64vARB) #define GLEW_ARB_bindless_texture GLEW_GET_VAR(__GLEW_ARB_bindless_texture) #endif /* GL_ARB_bindless_texture */ /* ----------------------- GL_ARB_blend_func_extended ---------------------- */ #ifndef GL_ARB_blend_func_extended #define GL_ARB_blend_func_extended 1 #define GL_SRC1_COLOR 0x88F9 #define GL_ONE_MINUS_SRC1_COLOR 0x88FA #define GL_ONE_MINUS_SRC1_ALPHA 0x88FB #define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) (GLuint program, GLuint colorNumber, GLuint index, const GLchar * name); typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATAINDEXPROC) (GLuint program, const GLchar * name); #define glBindFragDataLocationIndexed GLEW_GET_FUN(__glewBindFragDataLocationIndexed) #define glGetFragDataIndex GLEW_GET_FUN(__glewGetFragDataIndex) #define GLEW_ARB_blend_func_extended GLEW_GET_VAR(__GLEW_ARB_blend_func_extended) #endif /* GL_ARB_blend_func_extended */ /* ------------------------- GL_ARB_buffer_storage ------------------------- */ #ifndef GL_ARB_buffer_storage #define GL_ARB_buffer_storage 1 #define GL_MAP_READ_BIT 0x0001 #define GL_MAP_WRITE_BIT 0x0002 #define GL_MAP_PERSISTENT_BIT 0x00000040 #define GL_MAP_COHERENT_BIT 0x00000080 #define GL_DYNAMIC_STORAGE_BIT 0x0100 #define GL_CLIENT_STORAGE_BIT 0x0200 #define GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT 0x00004000 #define GL_BUFFER_IMMUTABLE_STORAGE 0x821F #define GL_BUFFER_STORAGE_FLAGS 0x8220 typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEPROC) (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags); typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags); #define glBufferStorage GLEW_GET_FUN(__glewBufferStorage) #define glNamedBufferStorageEXT GLEW_GET_FUN(__glewNamedBufferStorageEXT) #define GLEW_ARB_buffer_storage GLEW_GET_VAR(__GLEW_ARB_buffer_storage) #endif /* GL_ARB_buffer_storage */ /* ---------------------------- GL_ARB_cl_event ---------------------------- */ #ifndef GL_ARB_cl_event #define GL_ARB_cl_event 1 #define GL_SYNC_CL_EVENT_ARB 0x8240 #define GL_SYNC_CL_EVENT_COMPLETE_ARB 0x8241 typedef struct _cl_context *cl_context; typedef struct _cl_event *cl_event; typedef GLsync (GLAPIENTRY * PFNGLCREATESYNCFROMCLEVENTARBPROC) (cl_context context, cl_event event, GLbitfield flags); #define glCreateSyncFromCLeventARB GLEW_GET_FUN(__glewCreateSyncFromCLeventARB) #define GLEW_ARB_cl_event GLEW_GET_VAR(__GLEW_ARB_cl_event) #endif /* GL_ARB_cl_event */ /* ----------------------- GL_ARB_clear_buffer_object ---------------------- */ #ifndef GL_ARB_clear_buffer_object #define GL_ARB_clear_buffer_object 1 typedef void (GLAPIENTRY * PFNGLCLEARBUFFERDATAPROC) (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCLEARBUFFERSUBDATAPROC) (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data); #define glClearBufferData GLEW_GET_FUN(__glewClearBufferData) #define glClearBufferSubData GLEW_GET_FUN(__glewClearBufferSubData) #define glClearNamedBufferDataEXT GLEW_GET_FUN(__glewClearNamedBufferDataEXT) #define glClearNamedBufferSubDataEXT GLEW_GET_FUN(__glewClearNamedBufferSubDataEXT) #define GLEW_ARB_clear_buffer_object GLEW_GET_VAR(__GLEW_ARB_clear_buffer_object) #endif /* GL_ARB_clear_buffer_object */ /* -------------------------- GL_ARB_clear_texture ------------------------- */ #ifndef GL_ARB_clear_texture #define GL_ARB_clear_texture 1 #define GL_CLEAR_TEXTURE 0x9365 typedef void (GLAPIENTRY * PFNGLCLEARTEXIMAGEPROC) (GLuint texture, GLint level, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCLEARTEXSUBIMAGEPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data); #define glClearTexImage GLEW_GET_FUN(__glewClearTexImage) #define glClearTexSubImage GLEW_GET_FUN(__glewClearTexSubImage) #define GLEW_ARB_clear_texture GLEW_GET_VAR(__GLEW_ARB_clear_texture) #endif /* GL_ARB_clear_texture */ /* -------------------------- GL_ARB_clip_control -------------------------- */ #ifndef GL_ARB_clip_control #define GL_ARB_clip_control 1 #define GL_LOWER_LEFT 0x8CA1 #define GL_UPPER_LEFT 0x8CA2 #define GL_CLIP_ORIGIN 0x935C #define GL_CLIP_DEPTH_MODE 0x935D #define GL_NEGATIVE_ONE_TO_ONE 0x935E #define GL_ZERO_TO_ONE 0x935F typedef void (GLAPIENTRY * PFNGLCLIPCONTROLPROC) (GLenum origin, GLenum depth); #define glClipControl GLEW_GET_FUN(__glewClipControl) #define GLEW_ARB_clip_control GLEW_GET_VAR(__GLEW_ARB_clip_control) #endif /* GL_ARB_clip_control */ /* ----------------------- GL_ARB_color_buffer_float ----------------------- */ #ifndef GL_ARB_color_buffer_float #define GL_ARB_color_buffer_float 1 #define GL_RGBA_FLOAT_MODE_ARB 0x8820 #define GL_CLAMP_VERTEX_COLOR_ARB 0x891A #define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B #define GL_CLAMP_READ_COLOR_ARB 0x891C #define GL_FIXED_ONLY_ARB 0x891D typedef void (GLAPIENTRY * PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp); #define glClampColorARB GLEW_GET_FUN(__glewClampColorARB) #define GLEW_ARB_color_buffer_float GLEW_GET_VAR(__GLEW_ARB_color_buffer_float) #endif /* GL_ARB_color_buffer_float */ /* -------------------------- GL_ARB_compatibility ------------------------- */ #ifndef GL_ARB_compatibility #define GL_ARB_compatibility 1 #define GLEW_ARB_compatibility GLEW_GET_VAR(__GLEW_ARB_compatibility) #endif /* GL_ARB_compatibility */ /* ---------------- GL_ARB_compressed_texture_pixel_storage ---------------- */ #ifndef GL_ARB_compressed_texture_pixel_storage #define GL_ARB_compressed_texture_pixel_storage 1 #define GL_UNPACK_COMPRESSED_BLOCK_WIDTH 0x9127 #define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT 0x9128 #define GL_UNPACK_COMPRESSED_BLOCK_DEPTH 0x9129 #define GL_UNPACK_COMPRESSED_BLOCK_SIZE 0x912A #define GL_PACK_COMPRESSED_BLOCK_WIDTH 0x912B #define GL_PACK_COMPRESSED_BLOCK_HEIGHT 0x912C #define GL_PACK_COMPRESSED_BLOCK_DEPTH 0x912D #define GL_PACK_COMPRESSED_BLOCK_SIZE 0x912E #define GLEW_ARB_compressed_texture_pixel_storage GLEW_GET_VAR(__GLEW_ARB_compressed_texture_pixel_storage) #endif /* GL_ARB_compressed_texture_pixel_storage */ /* ------------------------- GL_ARB_compute_shader ------------------------- */ #ifndef GL_ARB_compute_shader #define GL_ARB_compute_shader 1 #define GL_COMPUTE_SHADER_BIT 0x00000020 #define GL_MAX_COMPUTE_SHARED_MEMORY_SIZE 0x8262 #define GL_MAX_COMPUTE_UNIFORM_COMPONENTS 0x8263 #define GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS 0x8264 #define GL_MAX_COMPUTE_ATOMIC_COUNTERS 0x8265 #define GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS 0x8266 #define GL_COMPUTE_WORK_GROUP_SIZE 0x8267 #define GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS 0x90EB #define GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER 0x90EC #define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER 0x90ED #define GL_DISPATCH_INDIRECT_BUFFER 0x90EE #define GL_DISPATCH_INDIRECT_BUFFER_BINDING 0x90EF #define GL_COMPUTE_SHADER 0x91B9 #define GL_MAX_COMPUTE_UNIFORM_BLOCKS 0x91BB #define GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS 0x91BC #define GL_MAX_COMPUTE_IMAGE_UNIFORMS 0x91BD #define GL_MAX_COMPUTE_WORK_GROUP_COUNT 0x91BE #define GL_MAX_COMPUTE_WORK_GROUP_SIZE 0x91BF typedef void (GLAPIENTRY * PFNGLDISPATCHCOMPUTEPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); typedef void (GLAPIENTRY * PFNGLDISPATCHCOMPUTEINDIRECTPROC) (GLintptr indirect); #define glDispatchCompute GLEW_GET_FUN(__glewDispatchCompute) #define glDispatchComputeIndirect GLEW_GET_FUN(__glewDispatchComputeIndirect) #define GLEW_ARB_compute_shader GLEW_GET_VAR(__GLEW_ARB_compute_shader) #endif /* GL_ARB_compute_shader */ /* ------------------- GL_ARB_compute_variable_group_size ------------------ */ #ifndef GL_ARB_compute_variable_group_size #define GL_ARB_compute_variable_group_size 1 #define GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB 0x90EB #define GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB 0x91BF #define GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB 0x9344 #define GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB 0x9345 typedef void (GLAPIENTRY * PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z); #define glDispatchComputeGroupSizeARB GLEW_GET_FUN(__glewDispatchComputeGroupSizeARB) #define GLEW_ARB_compute_variable_group_size GLEW_GET_VAR(__GLEW_ARB_compute_variable_group_size) #endif /* GL_ARB_compute_variable_group_size */ /* ------------------- GL_ARB_conditional_render_inverted ------------------ */ #ifndef GL_ARB_conditional_render_inverted #define GL_ARB_conditional_render_inverted 1 #define GL_QUERY_WAIT_INVERTED 0x8E17 #define GL_QUERY_NO_WAIT_INVERTED 0x8E18 #define GL_QUERY_BY_REGION_WAIT_INVERTED 0x8E19 #define GL_QUERY_BY_REGION_NO_WAIT_INVERTED 0x8E1A #define GLEW_ARB_conditional_render_inverted GLEW_GET_VAR(__GLEW_ARB_conditional_render_inverted) #endif /* GL_ARB_conditional_render_inverted */ /* ----------------------- GL_ARB_conservative_depth ----------------------- */ #ifndef GL_ARB_conservative_depth #define GL_ARB_conservative_depth 1 #define GLEW_ARB_conservative_depth GLEW_GET_VAR(__GLEW_ARB_conservative_depth) #endif /* GL_ARB_conservative_depth */ /* --------------------------- GL_ARB_copy_buffer -------------------------- */ #ifndef GL_ARB_copy_buffer #define GL_ARB_copy_buffer 1 #define GL_COPY_READ_BUFFER 0x8F36 #define GL_COPY_WRITE_BUFFER 0x8F37 typedef void (GLAPIENTRY * PFNGLCOPYBUFFERSUBDATAPROC) (GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size); #define glCopyBufferSubData GLEW_GET_FUN(__glewCopyBufferSubData) #define GLEW_ARB_copy_buffer GLEW_GET_VAR(__GLEW_ARB_copy_buffer) #endif /* GL_ARB_copy_buffer */ /* --------------------------- GL_ARB_copy_image --------------------------- */ #ifndef GL_ARB_copy_image #define GL_ARB_copy_image 1 typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATAPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); #define glCopyImageSubData GLEW_GET_FUN(__glewCopyImageSubData) #define GLEW_ARB_copy_image GLEW_GET_VAR(__GLEW_ARB_copy_image) #endif /* GL_ARB_copy_image */ /* -------------------------- GL_ARB_cull_distance ------------------------- */ #ifndef GL_ARB_cull_distance #define GL_ARB_cull_distance 1 #define GL_MAX_CULL_DISTANCES 0x82F9 #define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES 0x82FA #define GLEW_ARB_cull_distance GLEW_GET_VAR(__GLEW_ARB_cull_distance) #endif /* GL_ARB_cull_distance */ /* -------------------------- GL_ARB_debug_output -------------------------- */ #ifndef GL_ARB_debug_output #define GL_ARB_debug_output 1 #define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB 0x8242 #define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB 0x8243 #define GL_DEBUG_CALLBACK_FUNCTION_ARB 0x8244 #define GL_DEBUG_CALLBACK_USER_PARAM_ARB 0x8245 #define GL_DEBUG_SOURCE_API_ARB 0x8246 #define GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB 0x8247 #define GL_DEBUG_SOURCE_SHADER_COMPILER_ARB 0x8248 #define GL_DEBUG_SOURCE_THIRD_PARTY_ARB 0x8249 #define GL_DEBUG_SOURCE_APPLICATION_ARB 0x824A #define GL_DEBUG_SOURCE_OTHER_ARB 0x824B #define GL_DEBUG_TYPE_ERROR_ARB 0x824C #define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB 0x824D #define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB 0x824E #define GL_DEBUG_TYPE_PORTABILITY_ARB 0x824F #define GL_DEBUG_TYPE_PERFORMANCE_ARB 0x8250 #define GL_DEBUG_TYPE_OTHER_ARB 0x8251 #define GL_MAX_DEBUG_MESSAGE_LENGTH_ARB 0x9143 #define GL_MAX_DEBUG_LOGGED_MESSAGES_ARB 0x9144 #define GL_DEBUG_LOGGED_MESSAGES_ARB 0x9145 #define GL_DEBUG_SEVERITY_HIGH_ARB 0x9146 #define GL_DEBUG_SEVERITY_MEDIUM_ARB 0x9147 #define GL_DEBUG_SEVERITY_LOW_ARB 0x9148 typedef void (GLAPIENTRY *GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKARBPROC) (GLDEBUGPROCARB callback, const void *userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECONTROLARBPROC) (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTARBPROC) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf); typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGARBPROC) (GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog); #define glDebugMessageCallbackARB GLEW_GET_FUN(__glewDebugMessageCallbackARB) #define glDebugMessageControlARB GLEW_GET_FUN(__glewDebugMessageControlARB) #define glDebugMessageInsertARB GLEW_GET_FUN(__glewDebugMessageInsertARB) #define glGetDebugMessageLogARB GLEW_GET_FUN(__glewGetDebugMessageLogARB) #define GLEW_ARB_debug_output GLEW_GET_VAR(__GLEW_ARB_debug_output) #endif /* GL_ARB_debug_output */ /* ----------------------- GL_ARB_depth_buffer_float ----------------------- */ #ifndef GL_ARB_depth_buffer_float #define GL_ARB_depth_buffer_float 1 #define GL_DEPTH_COMPONENT32F 0x8CAC #define GL_DEPTH32F_STENCIL8 0x8CAD #define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD #define GLEW_ARB_depth_buffer_float GLEW_GET_VAR(__GLEW_ARB_depth_buffer_float) #endif /* GL_ARB_depth_buffer_float */ /* --------------------------- GL_ARB_depth_clamp -------------------------- */ #ifndef GL_ARB_depth_clamp #define GL_ARB_depth_clamp 1 #define GL_DEPTH_CLAMP 0x864F #define GLEW_ARB_depth_clamp GLEW_GET_VAR(__GLEW_ARB_depth_clamp) #endif /* GL_ARB_depth_clamp */ /* -------------------------- GL_ARB_depth_texture ------------------------- */ #ifndef GL_ARB_depth_texture #define GL_ARB_depth_texture 1 #define GL_DEPTH_COMPONENT16_ARB 0x81A5 #define GL_DEPTH_COMPONENT24_ARB 0x81A6 #define GL_DEPTH_COMPONENT32_ARB 0x81A7 #define GL_TEXTURE_DEPTH_SIZE_ARB 0x884A #define GL_DEPTH_TEXTURE_MODE_ARB 0x884B #define GLEW_ARB_depth_texture GLEW_GET_VAR(__GLEW_ARB_depth_texture) #endif /* GL_ARB_depth_texture */ /* ----------------------- GL_ARB_derivative_control ----------------------- */ #ifndef GL_ARB_derivative_control #define GL_ARB_derivative_control 1 #define GLEW_ARB_derivative_control GLEW_GET_VAR(__GLEW_ARB_derivative_control) #endif /* GL_ARB_derivative_control */ /* ----------------------- GL_ARB_direct_state_access ---------------------- */ #ifndef GL_ARB_direct_state_access #define GL_ARB_direct_state_access 1 #define GL_TEXTURE_TARGET 0x1006 #define GL_QUERY_TARGET 0x82EA typedef void (GLAPIENTRY * PFNGLBINDTEXTUREUNITPROC) (GLuint unit, GLuint texture); typedef void (GLAPIENTRY * PFNGLBLITNAMEDFRAMEBUFFERPROC) (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); typedef GLenum (GLAPIENTRY * PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC) (GLuint framebuffer, GLenum target); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDBUFFERDATAPROC) (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDBUFFERSUBDATAPROC) (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDFRAMEBUFFERFIPROC) (GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDFRAMEBUFFERFVPROC) (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDFRAMEBUFFERIVPROC) (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value); typedef void (GLAPIENTRY * PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC) (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC) (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOPYNAMEDBUFFERSUBDATAPROC) (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE1DPROC) (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE2DPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE3DPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLCREATEBUFFERSPROC) (GLsizei n, GLuint* buffers); typedef void (GLAPIENTRY * PFNGLCREATEFRAMEBUFFERSPROC) (GLsizei n, GLuint* framebuffers); typedef void (GLAPIENTRY * PFNGLCREATEPROGRAMPIPELINESPROC) (GLsizei n, GLuint* pipelines); typedef void (GLAPIENTRY * PFNGLCREATEQUERIESPROC) (GLenum target, GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLCREATERENDERBUFFERSPROC) (GLsizei n, GLuint* renderbuffers); typedef void (GLAPIENTRY * PFNGLCREATESAMPLERSPROC) (GLsizei n, GLuint* samplers); typedef void (GLAPIENTRY * PFNGLCREATETEXTURESPROC) (GLenum target, GLsizei n, GLuint* textures); typedef void (GLAPIENTRY * PFNGLCREATETRANSFORMFEEDBACKSPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLCREATEVERTEXARRAYSPROC) (GLsizei n, GLuint* arrays); typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYATTRIBPROC) (GLuint vaobj, GLuint index); typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYATTRIBPROC) (GLuint vaobj, GLuint index); typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length); typedef void (GLAPIENTRY * PFNGLGENERATETEXTUREMIPMAPPROC) (GLuint texture); typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC) (GLuint texture, GLint level, GLsizei bufSize, void *pixels); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERI64VPROC) (GLuint buffer, GLenum pname, GLint64* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERIVPROC) (GLuint buffer, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPOINTERVPROC) (GLuint buffer, GLenum pname, void** params); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERSUBDATAPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data); typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC) (GLuint framebuffer, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC) (GLuint renderbuffer, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTI64VPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTIVPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTUI64VPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTUIVPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); typedef void (GLAPIENTRY * PFNGLGETTEXTUREIMAGEPROC) (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels); typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVPROC) (GLuint texture, GLint level, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVPROC) (GLuint texture, GLint level, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIIVPROC) (GLuint texture, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIUIVPROC) (GLuint texture, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERFVPROC) (GLuint texture, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIVPROC) (GLuint texture, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKI64_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint64* param); typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKI_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint* param); typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKIVPROC) (GLuint xfb, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINDEXED64IVPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint64* param); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINDEXEDIVPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYIVPROC) (GLuint vaobj, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC) (GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments); typedef void (GLAPIENTRY * PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC) (GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height); typedef void * (GLAPIENTRY * PFNGLMAPNAMEDBUFFERPROC) (GLuint buffer, GLenum access); typedef void * (GLAPIENTRY * PFNGLMAPNAMEDBUFFERRANGEPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access); typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERDATAPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage); typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags); typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSUBDATAPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC) (GLuint framebuffer, GLenum mode); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC) (GLuint framebuffer, GLsizei n, const GLenum* bufs); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC) (GLuint framebuffer, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC) (GLuint framebuffer, GLenum mode); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEPROC) (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFERPROC) (GLuint texture, GLenum internalformat, GLuint buffer); typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFERRANGEPROC) (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVPROC) (GLuint texture, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVPROC) (GLuint texture, GLenum pname, const GLuint* params); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFPROC) (GLuint texture, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFVPROC) (GLuint texture, GLenum pname, const GLfloat* param); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIPROC) (GLuint texture, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIVPROC) (GLuint texture, GLenum pname, const GLint* param); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE1DPROC) (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DPROC) (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC) (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DPROC) (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC) (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE1DPROC) (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE2DPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE3DPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC) (GLuint xfb, GLuint index, GLuint buffer); typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC) (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFERPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYATTRIBBINDINGPROC) (GLuint vaobj, GLuint attribindex, GLuint bindingindex); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYATTRIBFORMATPROC) (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYATTRIBIFORMATPROC) (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYATTRIBLFORMATPROC) (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYBINDINGDIVISORPROC) (GLuint vaobj, GLuint bindingindex, GLuint divisor); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYELEMENTBUFFERPROC) (GLuint vaobj, GLuint buffer); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXBUFFERPROC) (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXBUFFERSPROC) (GLuint vaobj, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr *offsets, const GLsizei *strides); #define glBindTextureUnit GLEW_GET_FUN(__glewBindTextureUnit) #define glBlitNamedFramebuffer GLEW_GET_FUN(__glewBlitNamedFramebuffer) #define glCheckNamedFramebufferStatus GLEW_GET_FUN(__glewCheckNamedFramebufferStatus) #define glClearNamedBufferData GLEW_GET_FUN(__glewClearNamedBufferData) #define glClearNamedBufferSubData GLEW_GET_FUN(__glewClearNamedBufferSubData) #define glClearNamedFramebufferfi GLEW_GET_FUN(__glewClearNamedFramebufferfi) #define glClearNamedFramebufferfv GLEW_GET_FUN(__glewClearNamedFramebufferfv) #define glClearNamedFramebufferiv GLEW_GET_FUN(__glewClearNamedFramebufferiv) #define glClearNamedFramebufferuiv GLEW_GET_FUN(__glewClearNamedFramebufferuiv) #define glCompressedTextureSubImage1D GLEW_GET_FUN(__glewCompressedTextureSubImage1D) #define glCompressedTextureSubImage2D GLEW_GET_FUN(__glewCompressedTextureSubImage2D) #define glCompressedTextureSubImage3D GLEW_GET_FUN(__glewCompressedTextureSubImage3D) #define glCopyNamedBufferSubData GLEW_GET_FUN(__glewCopyNamedBufferSubData) #define glCopyTextureSubImage1D GLEW_GET_FUN(__glewCopyTextureSubImage1D) #define glCopyTextureSubImage2D GLEW_GET_FUN(__glewCopyTextureSubImage2D) #define glCopyTextureSubImage3D GLEW_GET_FUN(__glewCopyTextureSubImage3D) #define glCreateBuffers GLEW_GET_FUN(__glewCreateBuffers) #define glCreateFramebuffers GLEW_GET_FUN(__glewCreateFramebuffers) #define glCreateProgramPipelines GLEW_GET_FUN(__glewCreateProgramPipelines) #define glCreateQueries GLEW_GET_FUN(__glewCreateQueries) #define glCreateRenderbuffers GLEW_GET_FUN(__glewCreateRenderbuffers) #define glCreateSamplers GLEW_GET_FUN(__glewCreateSamplers) #define glCreateTextures GLEW_GET_FUN(__glewCreateTextures) #define glCreateTransformFeedbacks GLEW_GET_FUN(__glewCreateTransformFeedbacks) #define glCreateVertexArrays GLEW_GET_FUN(__glewCreateVertexArrays) #define glDisableVertexArrayAttrib GLEW_GET_FUN(__glewDisableVertexArrayAttrib) #define glEnableVertexArrayAttrib GLEW_GET_FUN(__glewEnableVertexArrayAttrib) #define glFlushMappedNamedBufferRange GLEW_GET_FUN(__glewFlushMappedNamedBufferRange) #define glGenerateTextureMipmap GLEW_GET_FUN(__glewGenerateTextureMipmap) #define glGetCompressedTextureImage GLEW_GET_FUN(__glewGetCompressedTextureImage) #define glGetNamedBufferParameteri64v GLEW_GET_FUN(__glewGetNamedBufferParameteri64v) #define glGetNamedBufferParameteriv GLEW_GET_FUN(__glewGetNamedBufferParameteriv) #define glGetNamedBufferPointerv GLEW_GET_FUN(__glewGetNamedBufferPointerv) #define glGetNamedBufferSubData GLEW_GET_FUN(__glewGetNamedBufferSubData) #define glGetNamedFramebufferAttachmentParameteriv GLEW_GET_FUN(__glewGetNamedFramebufferAttachmentParameteriv) #define glGetNamedFramebufferParameteriv GLEW_GET_FUN(__glewGetNamedFramebufferParameteriv) #define glGetNamedRenderbufferParameteriv GLEW_GET_FUN(__glewGetNamedRenderbufferParameteriv) #define glGetQueryBufferObjecti64v GLEW_GET_FUN(__glewGetQueryBufferObjecti64v) #define glGetQueryBufferObjectiv GLEW_GET_FUN(__glewGetQueryBufferObjectiv) #define glGetQueryBufferObjectui64v GLEW_GET_FUN(__glewGetQueryBufferObjectui64v) #define glGetQueryBufferObjectuiv GLEW_GET_FUN(__glewGetQueryBufferObjectuiv) #define glGetTextureImage GLEW_GET_FUN(__glewGetTextureImage) #define glGetTextureLevelParameterfv GLEW_GET_FUN(__glewGetTextureLevelParameterfv) #define glGetTextureLevelParameteriv GLEW_GET_FUN(__glewGetTextureLevelParameteriv) #define glGetTextureParameterIiv GLEW_GET_FUN(__glewGetTextureParameterIiv) #define glGetTextureParameterIuiv GLEW_GET_FUN(__glewGetTextureParameterIuiv) #define glGetTextureParameterfv GLEW_GET_FUN(__glewGetTextureParameterfv) #define glGetTextureParameteriv GLEW_GET_FUN(__glewGetTextureParameteriv) #define glGetTransformFeedbacki64_v GLEW_GET_FUN(__glewGetTransformFeedbacki64_v) #define glGetTransformFeedbacki_v GLEW_GET_FUN(__glewGetTransformFeedbacki_v) #define glGetTransformFeedbackiv GLEW_GET_FUN(__glewGetTransformFeedbackiv) #define glGetVertexArrayIndexed64iv GLEW_GET_FUN(__glewGetVertexArrayIndexed64iv) #define glGetVertexArrayIndexediv GLEW_GET_FUN(__glewGetVertexArrayIndexediv) #define glGetVertexArrayiv GLEW_GET_FUN(__glewGetVertexArrayiv) #define glInvalidateNamedFramebufferData GLEW_GET_FUN(__glewInvalidateNamedFramebufferData) #define glInvalidateNamedFramebufferSubData GLEW_GET_FUN(__glewInvalidateNamedFramebufferSubData) #define glMapNamedBuffer GLEW_GET_FUN(__glewMapNamedBuffer) #define glMapNamedBufferRange GLEW_GET_FUN(__glewMapNamedBufferRange) #define glNamedBufferData GLEW_GET_FUN(__glewNamedBufferData) #define glNamedBufferStorage GLEW_GET_FUN(__glewNamedBufferStorage) #define glNamedBufferSubData GLEW_GET_FUN(__glewNamedBufferSubData) #define glNamedFramebufferDrawBuffer GLEW_GET_FUN(__glewNamedFramebufferDrawBuffer) #define glNamedFramebufferDrawBuffers GLEW_GET_FUN(__glewNamedFramebufferDrawBuffers) #define glNamedFramebufferParameteri GLEW_GET_FUN(__glewNamedFramebufferParameteri) #define glNamedFramebufferReadBuffer GLEW_GET_FUN(__glewNamedFramebufferReadBuffer) #define glNamedFramebufferRenderbuffer GLEW_GET_FUN(__glewNamedFramebufferRenderbuffer) #define glNamedFramebufferTexture GLEW_GET_FUN(__glewNamedFramebufferTexture) #define glNamedFramebufferTextureLayer GLEW_GET_FUN(__glewNamedFramebufferTextureLayer) #define glNamedRenderbufferStorage GLEW_GET_FUN(__glewNamedRenderbufferStorage) #define glNamedRenderbufferStorageMultisample GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisample) #define glTextureBuffer GLEW_GET_FUN(__glewTextureBuffer) #define glTextureBufferRange GLEW_GET_FUN(__glewTextureBufferRange) #define glTextureParameterIiv GLEW_GET_FUN(__glewTextureParameterIiv) #define glTextureParameterIuiv GLEW_GET_FUN(__glewTextureParameterIuiv) #define glTextureParameterf GLEW_GET_FUN(__glewTextureParameterf) #define glTextureParameterfv GLEW_GET_FUN(__glewTextureParameterfv) #define glTextureParameteri GLEW_GET_FUN(__glewTextureParameteri) #define glTextureParameteriv GLEW_GET_FUN(__glewTextureParameteriv) #define glTextureStorage1D GLEW_GET_FUN(__glewTextureStorage1D) #define glTextureStorage2D GLEW_GET_FUN(__glewTextureStorage2D) #define glTextureStorage2DMultisample GLEW_GET_FUN(__glewTextureStorage2DMultisample) #define glTextureStorage3D GLEW_GET_FUN(__glewTextureStorage3D) #define glTextureStorage3DMultisample GLEW_GET_FUN(__glewTextureStorage3DMultisample) #define glTextureSubImage1D GLEW_GET_FUN(__glewTextureSubImage1D) #define glTextureSubImage2D GLEW_GET_FUN(__glewTextureSubImage2D) #define glTextureSubImage3D GLEW_GET_FUN(__glewTextureSubImage3D) #define glTransformFeedbackBufferBase GLEW_GET_FUN(__glewTransformFeedbackBufferBase) #define glTransformFeedbackBufferRange GLEW_GET_FUN(__glewTransformFeedbackBufferRange) #define glUnmapNamedBuffer GLEW_GET_FUN(__glewUnmapNamedBuffer) #define glVertexArrayAttribBinding GLEW_GET_FUN(__glewVertexArrayAttribBinding) #define glVertexArrayAttribFormat GLEW_GET_FUN(__glewVertexArrayAttribFormat) #define glVertexArrayAttribIFormat GLEW_GET_FUN(__glewVertexArrayAttribIFormat) #define glVertexArrayAttribLFormat GLEW_GET_FUN(__glewVertexArrayAttribLFormat) #define glVertexArrayBindingDivisor GLEW_GET_FUN(__glewVertexArrayBindingDivisor) #define glVertexArrayElementBuffer GLEW_GET_FUN(__glewVertexArrayElementBuffer) #define glVertexArrayVertexBuffer GLEW_GET_FUN(__glewVertexArrayVertexBuffer) #define glVertexArrayVertexBuffers GLEW_GET_FUN(__glewVertexArrayVertexBuffers) #define GLEW_ARB_direct_state_access GLEW_GET_VAR(__GLEW_ARB_direct_state_access) #endif /* GL_ARB_direct_state_access */ /* -------------------------- GL_ARB_draw_buffers -------------------------- */ #ifndef GL_ARB_draw_buffers #define GL_ARB_draw_buffers 1 #define GL_MAX_DRAW_BUFFERS_ARB 0x8824 #define GL_DRAW_BUFFER0_ARB 0x8825 #define GL_DRAW_BUFFER1_ARB 0x8826 #define GL_DRAW_BUFFER2_ARB 0x8827 #define GL_DRAW_BUFFER3_ARB 0x8828 #define GL_DRAW_BUFFER4_ARB 0x8829 #define GL_DRAW_BUFFER5_ARB 0x882A #define GL_DRAW_BUFFER6_ARB 0x882B #define GL_DRAW_BUFFER7_ARB 0x882C #define GL_DRAW_BUFFER8_ARB 0x882D #define GL_DRAW_BUFFER9_ARB 0x882E #define GL_DRAW_BUFFER10_ARB 0x882F #define GL_DRAW_BUFFER11_ARB 0x8830 #define GL_DRAW_BUFFER12_ARB 0x8831 #define GL_DRAW_BUFFER13_ARB 0x8832 #define GL_DRAW_BUFFER14_ARB 0x8833 #define GL_DRAW_BUFFER15_ARB 0x8834 typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum* bufs); #define glDrawBuffersARB GLEW_GET_FUN(__glewDrawBuffersARB) #define GLEW_ARB_draw_buffers GLEW_GET_VAR(__GLEW_ARB_draw_buffers) #endif /* GL_ARB_draw_buffers */ /* ----------------------- GL_ARB_draw_buffers_blend ----------------------- */ #ifndef GL_ARB_draw_buffers_blend #define GL_ARB_draw_buffers_blend 1 typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIARBPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIARBPROC) (GLuint buf, GLenum mode); typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIARBPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); typedef void (GLAPIENTRY * PFNGLBLENDFUNCIARBPROC) (GLuint buf, GLenum src, GLenum dst); #define glBlendEquationSeparateiARB GLEW_GET_FUN(__glewBlendEquationSeparateiARB) #define glBlendEquationiARB GLEW_GET_FUN(__glewBlendEquationiARB) #define glBlendFuncSeparateiARB GLEW_GET_FUN(__glewBlendFuncSeparateiARB) #define glBlendFunciARB GLEW_GET_FUN(__glewBlendFunciARB) #define GLEW_ARB_draw_buffers_blend GLEW_GET_VAR(__GLEW_ARB_draw_buffers_blend) #endif /* GL_ARB_draw_buffers_blend */ /* -------------------- GL_ARB_draw_elements_base_vertex ------------------- */ #ifndef GL_ARB_draw_elements_base_vertex #define GL_ARB_draw_elements_base_vertex 1 typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLint basevertex); typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei primcount, const GLint *basevertex); #define glDrawElementsBaseVertex GLEW_GET_FUN(__glewDrawElementsBaseVertex) #define glDrawElementsInstancedBaseVertex GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertex) #define glDrawRangeElementsBaseVertex GLEW_GET_FUN(__glewDrawRangeElementsBaseVertex) #define glMultiDrawElementsBaseVertex GLEW_GET_FUN(__glewMultiDrawElementsBaseVertex) #define GLEW_ARB_draw_elements_base_vertex GLEW_GET_VAR(__GLEW_ARB_draw_elements_base_vertex) #endif /* GL_ARB_draw_elements_base_vertex */ /* -------------------------- GL_ARB_draw_indirect ------------------------- */ #ifndef GL_ARB_draw_indirect #define GL_ARB_draw_indirect 1 #define GL_DRAW_INDIRECT_BUFFER 0x8F3F #define GL_DRAW_INDIRECT_BUFFER_BINDING 0x8F43 typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINDIRECTPROC) (GLenum mode, const void *indirect); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINDIRECTPROC) (GLenum mode, GLenum type, const void *indirect); #define glDrawArraysIndirect GLEW_GET_FUN(__glewDrawArraysIndirect) #define glDrawElementsIndirect GLEW_GET_FUN(__glewDrawElementsIndirect) #define GLEW_ARB_draw_indirect GLEW_GET_VAR(__GLEW_ARB_draw_indirect) #endif /* GL_ARB_draw_indirect */ /* ------------------------- GL_ARB_draw_instanced ------------------------- */ #ifndef GL_ARB_draw_instanced #define GL_ARB_draw_instanced 1 #define GLEW_ARB_draw_instanced GLEW_GET_VAR(__GLEW_ARB_draw_instanced) #endif /* GL_ARB_draw_instanced */ /* ------------------------ GL_ARB_enhanced_layouts ------------------------ */ #ifndef GL_ARB_enhanced_layouts #define GL_ARB_enhanced_layouts 1 #define GL_LOCATION_COMPONENT 0x934A #define GL_TRANSFORM_FEEDBACK_BUFFER_INDEX 0x934B #define GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE 0x934C #define GLEW_ARB_enhanced_layouts GLEW_GET_VAR(__GLEW_ARB_enhanced_layouts) #endif /* GL_ARB_enhanced_layouts */ /* -------------------- GL_ARB_explicit_attrib_location -------------------- */ #ifndef GL_ARB_explicit_attrib_location #define GL_ARB_explicit_attrib_location 1 #define GLEW_ARB_explicit_attrib_location GLEW_GET_VAR(__GLEW_ARB_explicit_attrib_location) #endif /* GL_ARB_explicit_attrib_location */ /* -------------------- GL_ARB_explicit_uniform_location ------------------- */ #ifndef GL_ARB_explicit_uniform_location #define GL_ARB_explicit_uniform_location 1 #define GL_MAX_UNIFORM_LOCATIONS 0x826E #define GLEW_ARB_explicit_uniform_location GLEW_GET_VAR(__GLEW_ARB_explicit_uniform_location) #endif /* GL_ARB_explicit_uniform_location */ /* ------------------- GL_ARB_fragment_coord_conventions ------------------- */ #ifndef GL_ARB_fragment_coord_conventions #define GL_ARB_fragment_coord_conventions 1 #define GLEW_ARB_fragment_coord_conventions GLEW_GET_VAR(__GLEW_ARB_fragment_coord_conventions) #endif /* GL_ARB_fragment_coord_conventions */ /* --------------------- GL_ARB_fragment_layer_viewport -------------------- */ #ifndef GL_ARB_fragment_layer_viewport #define GL_ARB_fragment_layer_viewport 1 #define GLEW_ARB_fragment_layer_viewport GLEW_GET_VAR(__GLEW_ARB_fragment_layer_viewport) #endif /* GL_ARB_fragment_layer_viewport */ /* ------------------------ GL_ARB_fragment_program ------------------------ */ #ifndef GL_ARB_fragment_program #define GL_ARB_fragment_program 1 #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #define GLEW_ARB_fragment_program GLEW_GET_VAR(__GLEW_ARB_fragment_program) #endif /* GL_ARB_fragment_program */ /* --------------------- GL_ARB_fragment_program_shadow -------------------- */ #ifndef GL_ARB_fragment_program_shadow #define GL_ARB_fragment_program_shadow 1 #define GLEW_ARB_fragment_program_shadow GLEW_GET_VAR(__GLEW_ARB_fragment_program_shadow) #endif /* GL_ARB_fragment_program_shadow */ /* ------------------------- GL_ARB_fragment_shader ------------------------ */ #ifndef GL_ARB_fragment_shader #define GL_ARB_fragment_shader 1 #define GL_FRAGMENT_SHADER_ARB 0x8B30 #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49 #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B #define GLEW_ARB_fragment_shader GLEW_GET_VAR(__GLEW_ARB_fragment_shader) #endif /* GL_ARB_fragment_shader */ /* -------------------- GL_ARB_fragment_shader_interlock ------------------- */ #ifndef GL_ARB_fragment_shader_interlock #define GL_ARB_fragment_shader_interlock 1 #define GLEW_ARB_fragment_shader_interlock GLEW_GET_VAR(__GLEW_ARB_fragment_shader_interlock) #endif /* GL_ARB_fragment_shader_interlock */ /* ------------------- GL_ARB_framebuffer_no_attachments ------------------- */ #ifndef GL_ARB_framebuffer_no_attachments #define GL_ARB_framebuffer_no_attachments 1 #define GL_FRAMEBUFFER_DEFAULT_WIDTH 0x9310 #define GL_FRAMEBUFFER_DEFAULT_HEIGHT 0x9311 #define GL_FRAMEBUFFER_DEFAULT_LAYERS 0x9312 #define GL_FRAMEBUFFER_DEFAULT_SAMPLES 0x9313 #define GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS 0x9314 #define GL_MAX_FRAMEBUFFER_WIDTH 0x9315 #define GL_MAX_FRAMEBUFFER_HEIGHT 0x9316 #define GL_MAX_FRAMEBUFFER_LAYERS 0x9317 #define GL_MAX_FRAMEBUFFER_SAMPLES 0x9318 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERPARAMETERIPROC) (GLenum target, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC) (GLuint framebuffer, GLenum pname, GLint param); #define glFramebufferParameteri GLEW_GET_FUN(__glewFramebufferParameteri) #define glGetFramebufferParameteriv GLEW_GET_FUN(__glewGetFramebufferParameteriv) #define glGetNamedFramebufferParameterivEXT GLEW_GET_FUN(__glewGetNamedFramebufferParameterivEXT) #define glNamedFramebufferParameteriEXT GLEW_GET_FUN(__glewNamedFramebufferParameteriEXT) #define GLEW_ARB_framebuffer_no_attachments GLEW_GET_VAR(__GLEW_ARB_framebuffer_no_attachments) #endif /* GL_ARB_framebuffer_no_attachments */ /* ----------------------- GL_ARB_framebuffer_object ----------------------- */ #ifndef GL_ARB_framebuffer_object #define GL_ARB_framebuffer_object 1 #define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 #define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 #define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 #define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 #define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 #define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 #define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 #define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 #define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 #define GL_FRAMEBUFFER_DEFAULT 0x8218 #define GL_FRAMEBUFFER_UNDEFINED 0x8219 #define GL_DEPTH_STENCIL_ATTACHMENT 0x821A #define GL_INDEX 0x8222 #define GL_MAX_RENDERBUFFER_SIZE 0x84E8 #define GL_DEPTH_STENCIL 0x84F9 #define GL_UNSIGNED_INT_24_8 0x84FA #define GL_DEPTH24_STENCIL8 0x88F0 #define GL_TEXTURE_STENCIL_SIZE 0x88F1 #define GL_UNSIGNED_NORMALIZED 0x8C17 #define GL_SRGB 0x8C40 #define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 #define GL_FRAMEBUFFER_BINDING 0x8CA6 #define GL_RENDERBUFFER_BINDING 0x8CA7 #define GL_READ_FRAMEBUFFER 0x8CA8 #define GL_DRAW_FRAMEBUFFER 0x8CA9 #define GL_READ_FRAMEBUFFER_BINDING 0x8CAA #define GL_RENDERBUFFER_SAMPLES 0x8CAB #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 #define GL_FRAMEBUFFER_COMPLETE 0x8CD5 #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 #define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB #define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC #define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD #define GL_MAX_COLOR_ATTACHMENTS 0x8CDF #define GL_COLOR_ATTACHMENT0 0x8CE0 #define GL_COLOR_ATTACHMENT1 0x8CE1 #define GL_COLOR_ATTACHMENT2 0x8CE2 #define GL_COLOR_ATTACHMENT3 0x8CE3 #define GL_COLOR_ATTACHMENT4 0x8CE4 #define GL_COLOR_ATTACHMENT5 0x8CE5 #define GL_COLOR_ATTACHMENT6 0x8CE6 #define GL_COLOR_ATTACHMENT7 0x8CE7 #define GL_COLOR_ATTACHMENT8 0x8CE8 #define GL_COLOR_ATTACHMENT9 0x8CE9 #define GL_COLOR_ATTACHMENT10 0x8CEA #define GL_COLOR_ATTACHMENT11 0x8CEB #define GL_COLOR_ATTACHMENT12 0x8CEC #define GL_COLOR_ATTACHMENT13 0x8CED #define GL_COLOR_ATTACHMENT14 0x8CEE #define GL_COLOR_ATTACHMENT15 0x8CEF #define GL_DEPTH_ATTACHMENT 0x8D00 #define GL_STENCIL_ATTACHMENT 0x8D20 #define GL_FRAMEBUFFER 0x8D40 #define GL_RENDERBUFFER 0x8D41 #define GL_RENDERBUFFER_WIDTH 0x8D42 #define GL_RENDERBUFFER_HEIGHT 0x8D43 #define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 #define GL_STENCIL_INDEX1 0x8D46 #define GL_STENCIL_INDEX4 0x8D47 #define GL_STENCIL_INDEX8 0x8D48 #define GL_STENCIL_INDEX16 0x8D49 #define GL_RENDERBUFFER_RED_SIZE 0x8D50 #define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 #define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 #define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 #define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 #define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 #define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 #define GL_MAX_SAMPLES 0x8D57 typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer); typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint* framebuffers); typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint* renderbuffers); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer); typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint* framebuffers); typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint* renderbuffers); typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFERPROC) (GLuint framebuffer); typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFERPROC) (GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); #define glBindFramebuffer GLEW_GET_FUN(__glewBindFramebuffer) #define glBindRenderbuffer GLEW_GET_FUN(__glewBindRenderbuffer) #define glBlitFramebuffer GLEW_GET_FUN(__glewBlitFramebuffer) #define glCheckFramebufferStatus GLEW_GET_FUN(__glewCheckFramebufferStatus) #define glDeleteFramebuffers GLEW_GET_FUN(__glewDeleteFramebuffers) #define glDeleteRenderbuffers GLEW_GET_FUN(__glewDeleteRenderbuffers) #define glFramebufferRenderbuffer GLEW_GET_FUN(__glewFramebufferRenderbuffer) #define glFramebufferTexture1D GLEW_GET_FUN(__glewFramebufferTexture1D) #define glFramebufferTexture2D GLEW_GET_FUN(__glewFramebufferTexture2D) #define glFramebufferTexture3D GLEW_GET_FUN(__glewFramebufferTexture3D) #define glFramebufferTextureLayer GLEW_GET_FUN(__glewFramebufferTextureLayer) #define glGenFramebuffers GLEW_GET_FUN(__glewGenFramebuffers) #define glGenRenderbuffers GLEW_GET_FUN(__glewGenRenderbuffers) #define glGenerateMipmap GLEW_GET_FUN(__glewGenerateMipmap) #define glGetFramebufferAttachmentParameteriv GLEW_GET_FUN(__glewGetFramebufferAttachmentParameteriv) #define glGetRenderbufferParameteriv GLEW_GET_FUN(__glewGetRenderbufferParameteriv) #define glIsFramebuffer GLEW_GET_FUN(__glewIsFramebuffer) #define glIsRenderbuffer GLEW_GET_FUN(__glewIsRenderbuffer) #define glRenderbufferStorage GLEW_GET_FUN(__glewRenderbufferStorage) #define glRenderbufferStorageMultisample GLEW_GET_FUN(__glewRenderbufferStorageMultisample) #define GLEW_ARB_framebuffer_object GLEW_GET_VAR(__GLEW_ARB_framebuffer_object) #endif /* GL_ARB_framebuffer_object */ /* ------------------------ GL_ARB_framebuffer_sRGB ------------------------ */ #ifndef GL_ARB_framebuffer_sRGB #define GL_ARB_framebuffer_sRGB 1 #define GL_FRAMEBUFFER_SRGB 0x8DB9 #define GLEW_ARB_framebuffer_sRGB GLEW_GET_VAR(__GLEW_ARB_framebuffer_sRGB) #endif /* GL_ARB_framebuffer_sRGB */ /* ------------------------ GL_ARB_geometry_shader4 ------------------------ */ #ifndef GL_ARB_geometry_shader4 #define GL_ARB_geometry_shader4 1 #define GL_LINES_ADJACENCY_ARB 0xA #define GL_LINE_STRIP_ADJACENCY_ARB 0xB #define GL_TRIANGLES_ADJACENCY_ARB 0xC #define GL_TRIANGLE_STRIP_ADJACENCY_ARB 0xD #define GL_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB 0x8C29 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 #define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB 0x8DA7 #define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB 0x8DA8 #define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB 0x8DA9 #define GL_GEOMETRY_SHADER_ARB 0x8DD9 #define GL_GEOMETRY_VERTICES_OUT_ARB 0x8DDA #define GL_GEOMETRY_INPUT_TYPE_ARB 0x8DDB #define GL_GEOMETRY_OUTPUT_TYPE_ARB 0x8DDC #define GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB 0x8DDD #define GL_MAX_VERTEX_VARYING_COMPONENTS_ARB 0x8DDE #define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB 0x8DDF #define GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB 0x8DE0 #define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB 0x8DE1 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIARBPROC) (GLuint program, GLenum pname, GLint value); #define glFramebufferTextureARB GLEW_GET_FUN(__glewFramebufferTextureARB) #define glFramebufferTextureFaceARB GLEW_GET_FUN(__glewFramebufferTextureFaceARB) #define glFramebufferTextureLayerARB GLEW_GET_FUN(__glewFramebufferTextureLayerARB) #define glProgramParameteriARB GLEW_GET_FUN(__glewProgramParameteriARB) #define GLEW_ARB_geometry_shader4 GLEW_GET_VAR(__GLEW_ARB_geometry_shader4) #endif /* GL_ARB_geometry_shader4 */ /* ----------------------- GL_ARB_get_program_binary ----------------------- */ #ifndef GL_ARB_get_program_binary #define GL_ARB_get_program_binary 1 #define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257 #define GL_PROGRAM_BINARY_LENGTH 0x8741 #define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE #define GL_PROGRAM_BINARY_FORMATS 0x87FF typedef void (GLAPIENTRY * PFNGLGETPROGRAMBINARYPROC) (GLuint program, GLsizei bufSize, GLsizei* length, GLenum *binaryFormat, void*binary); typedef void (GLAPIENTRY * PFNGLPROGRAMBINARYPROC) (GLuint program, GLenum binaryFormat, const void *binary, GLsizei length); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIPROC) (GLuint program, GLenum pname, GLint value); #define glGetProgramBinary GLEW_GET_FUN(__glewGetProgramBinary) #define glProgramBinary GLEW_GET_FUN(__glewProgramBinary) #define glProgramParameteri GLEW_GET_FUN(__glewProgramParameteri) #define GLEW_ARB_get_program_binary GLEW_GET_VAR(__GLEW_ARB_get_program_binary) #endif /* GL_ARB_get_program_binary */ /* ---------------------- GL_ARB_get_texture_sub_image --------------------- */ #ifndef GL_ARB_get_texture_sub_image #define GL_ARB_get_texture_sub_image 1 typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels); typedef void (GLAPIENTRY * PFNGLGETTEXTURESUBIMAGEPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels); #define glGetCompressedTextureSubImage GLEW_GET_FUN(__glewGetCompressedTextureSubImage) #define glGetTextureSubImage GLEW_GET_FUN(__glewGetTextureSubImage) #define GLEW_ARB_get_texture_sub_image GLEW_GET_VAR(__GLEW_ARB_get_texture_sub_image) #endif /* GL_ARB_get_texture_sub_image */ /* --------------------------- GL_ARB_gpu_shader5 -------------------------- */ #ifndef GL_ARB_gpu_shader5 #define GL_ARB_gpu_shader5 1 #define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F #define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A #define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B #define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C #define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D #define GL_MAX_VERTEX_STREAMS 0x8E71 #define GLEW_ARB_gpu_shader5 GLEW_GET_VAR(__GLEW_ARB_gpu_shader5) #endif /* GL_ARB_gpu_shader5 */ /* ------------------------- GL_ARB_gpu_shader_fp64 ------------------------ */ #ifndef GL_ARB_gpu_shader_fp64 #define GL_ARB_gpu_shader_fp64 1 #define GL_DOUBLE_MAT2 0x8F46 #define GL_DOUBLE_MAT3 0x8F47 #define GL_DOUBLE_MAT4 0x8F48 #define GL_DOUBLE_MAT2x3 0x8F49 #define GL_DOUBLE_MAT2x4 0x8F4A #define GL_DOUBLE_MAT3x2 0x8F4B #define GL_DOUBLE_MAT3x4 0x8F4C #define GL_DOUBLE_MAT4x2 0x8F4D #define GL_DOUBLE_MAT4x3 0x8F4E #define GL_DOUBLE_VEC2 0x8FFC #define GL_DOUBLE_VEC3 0x8FFD #define GL_DOUBLE_VEC4 0x8FFE typedef void (GLAPIENTRY * PFNGLGETUNIFORMDVPROC) (GLuint program, GLint location, GLdouble* params); typedef void (GLAPIENTRY * PFNGLUNIFORM1DPROC) (GLint location, GLdouble x); typedef void (GLAPIENTRY * PFNGLUNIFORM1DVPROC) (GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2DPROC) (GLint location, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLUNIFORM2DVPROC) (GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3DPROC) (GLint location, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLUNIFORM3DVPROC) (GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4DPROC) (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLUNIFORM4DVPROC) (GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3DVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); #define glGetUniformdv GLEW_GET_FUN(__glewGetUniformdv) #define glUniform1d GLEW_GET_FUN(__glewUniform1d) #define glUniform1dv GLEW_GET_FUN(__glewUniform1dv) #define glUniform2d GLEW_GET_FUN(__glewUniform2d) #define glUniform2dv GLEW_GET_FUN(__glewUniform2dv) #define glUniform3d GLEW_GET_FUN(__glewUniform3d) #define glUniform3dv GLEW_GET_FUN(__glewUniform3dv) #define glUniform4d GLEW_GET_FUN(__glewUniform4d) #define glUniform4dv GLEW_GET_FUN(__glewUniform4dv) #define glUniformMatrix2dv GLEW_GET_FUN(__glewUniformMatrix2dv) #define glUniformMatrix2x3dv GLEW_GET_FUN(__glewUniformMatrix2x3dv) #define glUniformMatrix2x4dv GLEW_GET_FUN(__glewUniformMatrix2x4dv) #define glUniformMatrix3dv GLEW_GET_FUN(__glewUniformMatrix3dv) #define glUniformMatrix3x2dv GLEW_GET_FUN(__glewUniformMatrix3x2dv) #define glUniformMatrix3x4dv GLEW_GET_FUN(__glewUniformMatrix3x4dv) #define glUniformMatrix4dv GLEW_GET_FUN(__glewUniformMatrix4dv) #define glUniformMatrix4x2dv GLEW_GET_FUN(__glewUniformMatrix4x2dv) #define glUniformMatrix4x3dv GLEW_GET_FUN(__glewUniformMatrix4x3dv) #define GLEW_ARB_gpu_shader_fp64 GLEW_GET_VAR(__GLEW_ARB_gpu_shader_fp64) #endif /* GL_ARB_gpu_shader_fp64 */ /* ------------------------ GL_ARB_gpu_shader_int64 ------------------------ */ #ifndef GL_ARB_gpu_shader_int64 #define GL_ARB_gpu_shader_int64 1 #define GL_INT64_ARB 0x140E #define GL_UNSIGNED_INT64_ARB 0x140F #define GL_INT64_VEC2_ARB 0x8FE9 #define GL_INT64_VEC3_ARB 0x8FEA #define GL_INT64_VEC4_ARB 0x8FEB #define GL_UNSIGNED_INT64_VEC2_ARB 0x8FF5 #define GL_UNSIGNED_INT64_VEC3_ARB 0x8FF6 #define GL_UNSIGNED_INT64_VEC4_ARB 0x8FF7 typedef void (GLAPIENTRY * PFNGLGETUNIFORMI64VARBPROC) (GLuint program, GLint location, GLint64* params); typedef void (GLAPIENTRY * PFNGLGETUNIFORMUI64VARBPROC) (GLuint program, GLint location, GLuint64* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMI64VARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLint64* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMUI64VARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLuint64* params); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64ARBPROC) (GLuint program, GLint location, GLint64 x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64ARBPROC) (GLuint program, GLint location, GLuint64 x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64ARBPROC) (GLuint program, GLint location, GLint64 x, GLint64 y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64ARBPROC) (GLuint program, GLint location, GLuint64 x, GLuint64 y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64ARBPROC) (GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64ARBPROC) (GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64ARBPROC) (GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64ARBPROC) (GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64VARBPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM1I64ARBPROC) (GLint location, GLint64 x); typedef void (GLAPIENTRY * PFNGLUNIFORM1I64VARBPROC) (GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64ARBPROC) (GLint location, GLuint64 x); typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64VARBPROC) (GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2I64ARBPROC) (GLint location, GLint64 x, GLint64 y); typedef void (GLAPIENTRY * PFNGLUNIFORM2I64VARBPROC) (GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64ARBPROC) (GLint location, GLuint64 x, GLuint64 y); typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64VARBPROC) (GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3I64ARBPROC) (GLint location, GLint64 x, GLint64 y, GLint64 z); typedef void (GLAPIENTRY * PFNGLUNIFORM3I64VARBPROC) (GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64ARBPROC) (GLint location, GLuint64 x, GLuint64 y, GLuint64 z); typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64VARBPROC) (GLint location, GLsizei count, const GLuint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4I64ARBPROC) (GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w); typedef void (GLAPIENTRY * PFNGLUNIFORM4I64VARBPROC) (GLint location, GLsizei count, const GLint64* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64ARBPROC) (GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w); typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64VARBPROC) (GLint location, GLsizei count, const GLuint64* value); #define glGetUniformi64vARB GLEW_GET_FUN(__glewGetUniformi64vARB) #define glGetUniformui64vARB GLEW_GET_FUN(__glewGetUniformui64vARB) #define glGetnUniformi64vARB GLEW_GET_FUN(__glewGetnUniformi64vARB) #define glGetnUniformui64vARB GLEW_GET_FUN(__glewGetnUniformui64vARB) #define glProgramUniform1i64ARB GLEW_GET_FUN(__glewProgramUniform1i64ARB) #define glProgramUniform1i64vARB GLEW_GET_FUN(__glewProgramUniform1i64vARB) #define glProgramUniform1ui64ARB GLEW_GET_FUN(__glewProgramUniform1ui64ARB) #define glProgramUniform1ui64vARB GLEW_GET_FUN(__glewProgramUniform1ui64vARB) #define glProgramUniform2i64ARB GLEW_GET_FUN(__glewProgramUniform2i64ARB) #define glProgramUniform2i64vARB GLEW_GET_FUN(__glewProgramUniform2i64vARB) #define glProgramUniform2ui64ARB GLEW_GET_FUN(__glewProgramUniform2ui64ARB) #define glProgramUniform2ui64vARB GLEW_GET_FUN(__glewProgramUniform2ui64vARB) #define glProgramUniform3i64ARB GLEW_GET_FUN(__glewProgramUniform3i64ARB) #define glProgramUniform3i64vARB GLEW_GET_FUN(__glewProgramUniform3i64vARB) #define glProgramUniform3ui64ARB GLEW_GET_FUN(__glewProgramUniform3ui64ARB) #define glProgramUniform3ui64vARB GLEW_GET_FUN(__glewProgramUniform3ui64vARB) #define glProgramUniform4i64ARB GLEW_GET_FUN(__glewProgramUniform4i64ARB) #define glProgramUniform4i64vARB GLEW_GET_FUN(__glewProgramUniform4i64vARB) #define glProgramUniform4ui64ARB GLEW_GET_FUN(__glewProgramUniform4ui64ARB) #define glProgramUniform4ui64vARB GLEW_GET_FUN(__glewProgramUniform4ui64vARB) #define glUniform1i64ARB GLEW_GET_FUN(__glewUniform1i64ARB) #define glUniform1i64vARB GLEW_GET_FUN(__glewUniform1i64vARB) #define glUniform1ui64ARB GLEW_GET_FUN(__glewUniform1ui64ARB) #define glUniform1ui64vARB GLEW_GET_FUN(__glewUniform1ui64vARB) #define glUniform2i64ARB GLEW_GET_FUN(__glewUniform2i64ARB) #define glUniform2i64vARB GLEW_GET_FUN(__glewUniform2i64vARB) #define glUniform2ui64ARB GLEW_GET_FUN(__glewUniform2ui64ARB) #define glUniform2ui64vARB GLEW_GET_FUN(__glewUniform2ui64vARB) #define glUniform3i64ARB GLEW_GET_FUN(__glewUniform3i64ARB) #define glUniform3i64vARB GLEW_GET_FUN(__glewUniform3i64vARB) #define glUniform3ui64ARB GLEW_GET_FUN(__glewUniform3ui64ARB) #define glUniform3ui64vARB GLEW_GET_FUN(__glewUniform3ui64vARB) #define glUniform4i64ARB GLEW_GET_FUN(__glewUniform4i64ARB) #define glUniform4i64vARB GLEW_GET_FUN(__glewUniform4i64vARB) #define glUniform4ui64ARB GLEW_GET_FUN(__glewUniform4ui64ARB) #define glUniform4ui64vARB GLEW_GET_FUN(__glewUniform4ui64vARB) #define GLEW_ARB_gpu_shader_int64 GLEW_GET_VAR(__GLEW_ARB_gpu_shader_int64) #endif /* GL_ARB_gpu_shader_int64 */ /* ------------------------ GL_ARB_half_float_pixel ------------------------ */ #ifndef GL_ARB_half_float_pixel #define GL_ARB_half_float_pixel 1 #define GL_HALF_FLOAT_ARB 0x140B #define GLEW_ARB_half_float_pixel GLEW_GET_VAR(__GLEW_ARB_half_float_pixel) #endif /* GL_ARB_half_float_pixel */ /* ------------------------ GL_ARB_half_float_vertex ----------------------- */ #ifndef GL_ARB_half_float_vertex #define GL_ARB_half_float_vertex 1 #define GL_HALF_FLOAT 0x140B #define GLEW_ARB_half_float_vertex GLEW_GET_VAR(__GLEW_ARB_half_float_vertex) #endif /* GL_ARB_half_float_vertex */ /* ----------------------------- GL_ARB_imaging ---------------------------- */ #ifndef GL_ARB_imaging #define GL_ARB_imaging 1 #define GL_CONSTANT_COLOR 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_CONSTANT_ALPHA 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_BLEND_COLOR 0x8005 #define GL_FUNC_ADD 0x8006 #define GL_MIN 0x8007 #define GL_MAX 0x8008 #define GL_BLEND_EQUATION 0x8009 #define GL_FUNC_SUBTRACT 0x800A #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_CONVOLUTION_1D 0x8010 #define GL_CONVOLUTION_2D 0x8011 #define GL_SEPARABLE_2D 0x8012 #define GL_CONVOLUTION_BORDER_MODE 0x8013 #define GL_CONVOLUTION_FILTER_SCALE 0x8014 #define GL_CONVOLUTION_FILTER_BIAS 0x8015 #define GL_REDUCE 0x8016 #define GL_CONVOLUTION_FORMAT 0x8017 #define GL_CONVOLUTION_WIDTH 0x8018 #define GL_CONVOLUTION_HEIGHT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH 0x801A #define GL_MAX_CONVOLUTION_HEIGHT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F #define GL_POST_CONVOLUTION_RED_BIAS 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 #define GL_HISTOGRAM 0x8024 #define GL_PROXY_HISTOGRAM 0x8025 #define GL_HISTOGRAM_WIDTH 0x8026 #define GL_HISTOGRAM_FORMAT 0x8027 #define GL_HISTOGRAM_RED_SIZE 0x8028 #define GL_HISTOGRAM_GREEN_SIZE 0x8029 #define GL_HISTOGRAM_BLUE_SIZE 0x802A #define GL_HISTOGRAM_ALPHA_SIZE 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C #define GL_HISTOGRAM_SINK 0x802D #define GL_MINMAX 0x802E #define GL_MINMAX_FORMAT 0x802F #define GL_MINMAX_SINK 0x8030 #define GL_TABLE_TOO_LARGE 0x8031 #define GL_COLOR_MATRIX 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB #define GL_COLOR_TABLE 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 #define GL_PROXY_COLOR_TABLE 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 #define GL_COLOR_TABLE_SCALE 0x80D6 #define GL_COLOR_TABLE_BIAS 0x80D7 #define GL_COLOR_TABLE_FORMAT 0x80D8 #define GL_COLOR_TABLE_WIDTH 0x80D9 #define GL_COLOR_TABLE_RED_SIZE 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF #define GL_IGNORE_BORDER 0x8150 #define GL_CONSTANT_BORDER 0x8151 #define GL_WRAP_BORDER 0x8152 #define GL_REPLICATE_BORDER 0x8153 #define GL_CONVOLUTION_BORDER_COLOR 0x8154 typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table); typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, void *table); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, void *image); typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values); typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (GLAPIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, void *values); typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, void *row, void *column, void *span); typedef void (GLAPIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); typedef void (GLAPIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLRESETMINMAXPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column); #define glColorSubTable GLEW_GET_FUN(__glewColorSubTable) #define glColorTable GLEW_GET_FUN(__glewColorTable) #define glColorTableParameterfv GLEW_GET_FUN(__glewColorTableParameterfv) #define glColorTableParameteriv GLEW_GET_FUN(__glewColorTableParameteriv) #define glConvolutionFilter1D GLEW_GET_FUN(__glewConvolutionFilter1D) #define glConvolutionFilter2D GLEW_GET_FUN(__glewConvolutionFilter2D) #define glConvolutionParameterf GLEW_GET_FUN(__glewConvolutionParameterf) #define glConvolutionParameterfv GLEW_GET_FUN(__glewConvolutionParameterfv) #define glConvolutionParameteri GLEW_GET_FUN(__glewConvolutionParameteri) #define glConvolutionParameteriv GLEW_GET_FUN(__glewConvolutionParameteriv) #define glCopyColorSubTable GLEW_GET_FUN(__glewCopyColorSubTable) #define glCopyColorTable GLEW_GET_FUN(__glewCopyColorTable) #define glCopyConvolutionFilter1D GLEW_GET_FUN(__glewCopyConvolutionFilter1D) #define glCopyConvolutionFilter2D GLEW_GET_FUN(__glewCopyConvolutionFilter2D) #define glGetColorTable GLEW_GET_FUN(__glewGetColorTable) #define glGetColorTableParameterfv GLEW_GET_FUN(__glewGetColorTableParameterfv) #define glGetColorTableParameteriv GLEW_GET_FUN(__glewGetColorTableParameteriv) #define glGetConvolutionFilter GLEW_GET_FUN(__glewGetConvolutionFilter) #define glGetConvolutionParameterfv GLEW_GET_FUN(__glewGetConvolutionParameterfv) #define glGetConvolutionParameteriv GLEW_GET_FUN(__glewGetConvolutionParameteriv) #define glGetHistogram GLEW_GET_FUN(__glewGetHistogram) #define glGetHistogramParameterfv GLEW_GET_FUN(__glewGetHistogramParameterfv) #define glGetHistogramParameteriv GLEW_GET_FUN(__glewGetHistogramParameteriv) #define glGetMinmax GLEW_GET_FUN(__glewGetMinmax) #define glGetMinmaxParameterfv GLEW_GET_FUN(__glewGetMinmaxParameterfv) #define glGetMinmaxParameteriv GLEW_GET_FUN(__glewGetMinmaxParameteriv) #define glGetSeparableFilter GLEW_GET_FUN(__glewGetSeparableFilter) #define glHistogram GLEW_GET_FUN(__glewHistogram) #define glMinmax GLEW_GET_FUN(__glewMinmax) #define glResetHistogram GLEW_GET_FUN(__glewResetHistogram) #define glResetMinmax GLEW_GET_FUN(__glewResetMinmax) #define glSeparableFilter2D GLEW_GET_FUN(__glewSeparableFilter2D) #define GLEW_ARB_imaging GLEW_GET_VAR(__GLEW_ARB_imaging) #endif /* GL_ARB_imaging */ /* ----------------------- GL_ARB_indirect_parameters ---------------------- */ #ifndef GL_ARB_indirect_parameters #define GL_ARB_indirect_parameters 1 #define GL_PARAMETER_BUFFER_ARB 0x80EE #define GL_PARAMETER_BUFFER_BINDING_ARB 0x80EF typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC) (GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC) (GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); #define glMultiDrawArraysIndirectCountARB GLEW_GET_FUN(__glewMultiDrawArraysIndirectCountARB) #define glMultiDrawElementsIndirectCountARB GLEW_GET_FUN(__glewMultiDrawElementsIndirectCountARB) #define GLEW_ARB_indirect_parameters GLEW_GET_VAR(__GLEW_ARB_indirect_parameters) #endif /* GL_ARB_indirect_parameters */ /* ------------------------ GL_ARB_instanced_arrays ------------------------ */ #ifndef GL_ARB_instanced_arrays #define GL_ARB_instanced_arrays 1 #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB 0x88FE typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDARBPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDARBPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORARBPROC) (GLuint index, GLuint divisor); #define glDrawArraysInstancedARB GLEW_GET_FUN(__glewDrawArraysInstancedARB) #define glDrawElementsInstancedARB GLEW_GET_FUN(__glewDrawElementsInstancedARB) #define glVertexAttribDivisorARB GLEW_GET_FUN(__glewVertexAttribDivisorARB) #define GLEW_ARB_instanced_arrays GLEW_GET_VAR(__GLEW_ARB_instanced_arrays) #endif /* GL_ARB_instanced_arrays */ /* ---------------------- GL_ARB_internalformat_query ---------------------- */ #ifndef GL_ARB_internalformat_query #define GL_ARB_internalformat_query 1 #define GL_NUM_SAMPLE_COUNTS 0x9380 typedef void (GLAPIENTRY * PFNGLGETINTERNALFORMATIVPROC) (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params); #define glGetInternalformativ GLEW_GET_FUN(__glewGetInternalformativ) #define GLEW_ARB_internalformat_query GLEW_GET_VAR(__GLEW_ARB_internalformat_query) #endif /* GL_ARB_internalformat_query */ /* ---------------------- GL_ARB_internalformat_query2 --------------------- */ #ifndef GL_ARB_internalformat_query2 #define GL_ARB_internalformat_query2 1 #define GL_INTERNALFORMAT_SUPPORTED 0x826F #define GL_INTERNALFORMAT_PREFERRED 0x8270 #define GL_INTERNALFORMAT_RED_SIZE 0x8271 #define GL_INTERNALFORMAT_GREEN_SIZE 0x8272 #define GL_INTERNALFORMAT_BLUE_SIZE 0x8273 #define GL_INTERNALFORMAT_ALPHA_SIZE 0x8274 #define GL_INTERNALFORMAT_DEPTH_SIZE 0x8275 #define GL_INTERNALFORMAT_STENCIL_SIZE 0x8276 #define GL_INTERNALFORMAT_SHARED_SIZE 0x8277 #define GL_INTERNALFORMAT_RED_TYPE 0x8278 #define GL_INTERNALFORMAT_GREEN_TYPE 0x8279 #define GL_INTERNALFORMAT_BLUE_TYPE 0x827A #define GL_INTERNALFORMAT_ALPHA_TYPE 0x827B #define GL_INTERNALFORMAT_DEPTH_TYPE 0x827C #define GL_INTERNALFORMAT_STENCIL_TYPE 0x827D #define GL_MAX_WIDTH 0x827E #define GL_MAX_HEIGHT 0x827F #define GL_MAX_DEPTH 0x8280 #define GL_MAX_LAYERS 0x8281 #define GL_MAX_COMBINED_DIMENSIONS 0x8282 #define GL_COLOR_COMPONENTS 0x8283 #define GL_DEPTH_COMPONENTS 0x8284 #define GL_STENCIL_COMPONENTS 0x8285 #define GL_COLOR_RENDERABLE 0x8286 #define GL_DEPTH_RENDERABLE 0x8287 #define GL_STENCIL_RENDERABLE 0x8288 #define GL_FRAMEBUFFER_RENDERABLE 0x8289 #define GL_FRAMEBUFFER_RENDERABLE_LAYERED 0x828A #define GL_FRAMEBUFFER_BLEND 0x828B #define GL_READ_PIXELS 0x828C #define GL_READ_PIXELS_FORMAT 0x828D #define GL_READ_PIXELS_TYPE 0x828E #define GL_TEXTURE_IMAGE_FORMAT 0x828F #define GL_TEXTURE_IMAGE_TYPE 0x8290 #define GL_GET_TEXTURE_IMAGE_FORMAT 0x8291 #define GL_GET_TEXTURE_IMAGE_TYPE 0x8292 #define GL_MIPMAP 0x8293 #define GL_MANUAL_GENERATE_MIPMAP 0x8294 #define GL_AUTO_GENERATE_MIPMAP 0x8295 #define GL_COLOR_ENCODING 0x8296 #define GL_SRGB_READ 0x8297 #define GL_SRGB_WRITE 0x8298 #define GL_SRGB_DECODE_ARB 0x8299 #define GL_FILTER 0x829A #define GL_VERTEX_TEXTURE 0x829B #define GL_TESS_CONTROL_TEXTURE 0x829C #define GL_TESS_EVALUATION_TEXTURE 0x829D #define GL_GEOMETRY_TEXTURE 0x829E #define GL_FRAGMENT_TEXTURE 0x829F #define GL_COMPUTE_TEXTURE 0x82A0 #define GL_TEXTURE_SHADOW 0x82A1 #define GL_TEXTURE_GATHER 0x82A2 #define GL_TEXTURE_GATHER_SHADOW 0x82A3 #define GL_SHADER_IMAGE_LOAD 0x82A4 #define GL_SHADER_IMAGE_STORE 0x82A5 #define GL_SHADER_IMAGE_ATOMIC 0x82A6 #define GL_IMAGE_TEXEL_SIZE 0x82A7 #define GL_IMAGE_COMPATIBILITY_CLASS 0x82A8 #define GL_IMAGE_PIXEL_FORMAT 0x82A9 #define GL_IMAGE_PIXEL_TYPE 0x82AA #define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST 0x82AC #define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST 0x82AD #define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE 0x82AE #define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE 0x82AF #define GL_TEXTURE_COMPRESSED_BLOCK_WIDTH 0x82B1 #define GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT 0x82B2 #define GL_TEXTURE_COMPRESSED_BLOCK_SIZE 0x82B3 #define GL_CLEAR_BUFFER 0x82B4 #define GL_TEXTURE_VIEW 0x82B5 #define GL_VIEW_COMPATIBILITY_CLASS 0x82B6 #define GL_FULL_SUPPORT 0x82B7 #define GL_CAVEAT_SUPPORT 0x82B8 #define GL_IMAGE_CLASS_4_X_32 0x82B9 #define GL_IMAGE_CLASS_2_X_32 0x82BA #define GL_IMAGE_CLASS_1_X_32 0x82BB #define GL_IMAGE_CLASS_4_X_16 0x82BC #define GL_IMAGE_CLASS_2_X_16 0x82BD #define GL_IMAGE_CLASS_1_X_16 0x82BE #define GL_IMAGE_CLASS_4_X_8 0x82BF #define GL_IMAGE_CLASS_2_X_8 0x82C0 #define GL_IMAGE_CLASS_1_X_8 0x82C1 #define GL_IMAGE_CLASS_11_11_10 0x82C2 #define GL_IMAGE_CLASS_10_10_10_2 0x82C3 #define GL_VIEW_CLASS_128_BITS 0x82C4 #define GL_VIEW_CLASS_96_BITS 0x82C5 #define GL_VIEW_CLASS_64_BITS 0x82C6 #define GL_VIEW_CLASS_48_BITS 0x82C7 #define GL_VIEW_CLASS_32_BITS 0x82C8 #define GL_VIEW_CLASS_24_BITS 0x82C9 #define GL_VIEW_CLASS_16_BITS 0x82CA #define GL_VIEW_CLASS_8_BITS 0x82CB #define GL_VIEW_CLASS_S3TC_DXT1_RGB 0x82CC #define GL_VIEW_CLASS_S3TC_DXT1_RGBA 0x82CD #define GL_VIEW_CLASS_S3TC_DXT3_RGBA 0x82CE #define GL_VIEW_CLASS_S3TC_DXT5_RGBA 0x82CF #define GL_VIEW_CLASS_RGTC1_RED 0x82D0 #define GL_VIEW_CLASS_RGTC2_RG 0x82D1 #define GL_VIEW_CLASS_BPTC_UNORM 0x82D2 #define GL_VIEW_CLASS_BPTC_FLOAT 0x82D3 typedef void (GLAPIENTRY * PFNGLGETINTERNALFORMATI64VPROC) (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64* params); #define glGetInternalformati64v GLEW_GET_FUN(__glewGetInternalformati64v) #define GLEW_ARB_internalformat_query2 GLEW_GET_VAR(__GLEW_ARB_internalformat_query2) #endif /* GL_ARB_internalformat_query2 */ /* ----------------------- GL_ARB_invalidate_subdata ----------------------- */ #ifndef GL_ARB_invalidate_subdata #define GL_ARB_invalidate_subdata 1 typedef void (GLAPIENTRY * PFNGLINVALIDATEBUFFERDATAPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLINVALIDATEBUFFERSUBDATAPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length); typedef void (GLAPIENTRY * PFNGLINVALIDATEFRAMEBUFFERPROC) (GLenum target, GLsizei numAttachments, const GLenum* attachments); typedef void (GLAPIENTRY * PFNGLINVALIDATESUBFRAMEBUFFERPROC) (GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLINVALIDATETEXIMAGEPROC) (GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLINVALIDATETEXSUBIMAGEPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth); #define glInvalidateBufferData GLEW_GET_FUN(__glewInvalidateBufferData) #define glInvalidateBufferSubData GLEW_GET_FUN(__glewInvalidateBufferSubData) #define glInvalidateFramebuffer GLEW_GET_FUN(__glewInvalidateFramebuffer) #define glInvalidateSubFramebuffer GLEW_GET_FUN(__glewInvalidateSubFramebuffer) #define glInvalidateTexImage GLEW_GET_FUN(__glewInvalidateTexImage) #define glInvalidateTexSubImage GLEW_GET_FUN(__glewInvalidateTexSubImage) #define GLEW_ARB_invalidate_subdata GLEW_GET_VAR(__GLEW_ARB_invalidate_subdata) #endif /* GL_ARB_invalidate_subdata */ /* ---------------------- GL_ARB_map_buffer_alignment ---------------------- */ #ifndef GL_ARB_map_buffer_alignment #define GL_ARB_map_buffer_alignment 1 #define GL_MIN_MAP_BUFFER_ALIGNMENT 0x90BC #define GLEW_ARB_map_buffer_alignment GLEW_GET_VAR(__GLEW_ARB_map_buffer_alignment) #endif /* GL_ARB_map_buffer_alignment */ /* ------------------------ GL_ARB_map_buffer_range ------------------------ */ #ifndef GL_ARB_map_buffer_range #define GL_ARB_map_buffer_range 1 #define GL_MAP_READ_BIT 0x0001 #define GL_MAP_WRITE_BIT 0x0002 #define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 #define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 #define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 #define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length); typedef void * (GLAPIENTRY * PFNGLMAPBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); #define glFlushMappedBufferRange GLEW_GET_FUN(__glewFlushMappedBufferRange) #define glMapBufferRange GLEW_GET_FUN(__glewMapBufferRange) #define GLEW_ARB_map_buffer_range GLEW_GET_VAR(__GLEW_ARB_map_buffer_range) #endif /* GL_ARB_map_buffer_range */ /* ------------------------- GL_ARB_matrix_palette ------------------------- */ #ifndef GL_ARB_matrix_palette #define GL_ARB_matrix_palette 1 #define GL_MATRIX_PALETTE_ARB 0x8840 #define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841 #define GL_MAX_PALETTE_MATRICES_ARB 0x8842 #define GL_CURRENT_PALETTE_MATRIX_ARB 0x8843 #define GL_MATRIX_INDEX_ARRAY_ARB 0x8844 #define GL_CURRENT_MATRIX_INDEX_ARB 0x8845 #define GL_MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846 #define GL_MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847 #define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848 #define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849 typedef void (GLAPIENTRY * PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index); typedef void (GLAPIENTRY * PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUBVARBPROC) (GLint size, GLubyte *indices); typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUIVARBPROC) (GLint size, GLuint *indices); typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUSVARBPROC) (GLint size, GLushort *indices); #define glCurrentPaletteMatrixARB GLEW_GET_FUN(__glewCurrentPaletteMatrixARB) #define glMatrixIndexPointerARB GLEW_GET_FUN(__glewMatrixIndexPointerARB) #define glMatrixIndexubvARB GLEW_GET_FUN(__glewMatrixIndexubvARB) #define glMatrixIndexuivARB GLEW_GET_FUN(__glewMatrixIndexuivARB) #define glMatrixIndexusvARB GLEW_GET_FUN(__glewMatrixIndexusvARB) #define GLEW_ARB_matrix_palette GLEW_GET_VAR(__GLEW_ARB_matrix_palette) #endif /* GL_ARB_matrix_palette */ /* --------------------------- GL_ARB_multi_bind --------------------------- */ #ifndef GL_ARB_multi_bind #define GL_ARB_multi_bind 1 typedef void (GLAPIENTRY * PFNGLBINDBUFFERSBASEPROC) (GLenum target, GLuint first, GLsizei count, const GLuint* buffers); typedef void (GLAPIENTRY * PFNGLBINDBUFFERSRANGEPROC) (GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr *offsets, const GLsizeiptr *sizes); typedef void (GLAPIENTRY * PFNGLBINDIMAGETEXTURESPROC) (GLuint first, GLsizei count, const GLuint* textures); typedef void (GLAPIENTRY * PFNGLBINDSAMPLERSPROC) (GLuint first, GLsizei count, const GLuint* samplers); typedef void (GLAPIENTRY * PFNGLBINDTEXTURESPROC) (GLuint first, GLsizei count, const GLuint* textures); typedef void (GLAPIENTRY * PFNGLBINDVERTEXBUFFERSPROC) (GLuint first, GLsizei count, const GLuint* buffers, const GLintptr *offsets, const GLsizei *strides); #define glBindBuffersBase GLEW_GET_FUN(__glewBindBuffersBase) #define glBindBuffersRange GLEW_GET_FUN(__glewBindBuffersRange) #define glBindImageTextures GLEW_GET_FUN(__glewBindImageTextures) #define glBindSamplers GLEW_GET_FUN(__glewBindSamplers) #define glBindTextures GLEW_GET_FUN(__glewBindTextures) #define glBindVertexBuffers GLEW_GET_FUN(__glewBindVertexBuffers) #define GLEW_ARB_multi_bind GLEW_GET_VAR(__GLEW_ARB_multi_bind) #endif /* GL_ARB_multi_bind */ /* ----------------------- GL_ARB_multi_draw_indirect ---------------------- */ #ifndef GL_ARB_multi_draw_indirect #define GL_ARB_multi_draw_indirect 1 typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTPROC) (GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTPROC) (GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride); #define glMultiDrawArraysIndirect GLEW_GET_FUN(__glewMultiDrawArraysIndirect) #define glMultiDrawElementsIndirect GLEW_GET_FUN(__glewMultiDrawElementsIndirect) #define GLEW_ARB_multi_draw_indirect GLEW_GET_VAR(__GLEW_ARB_multi_draw_indirect) #endif /* GL_ARB_multi_draw_indirect */ /* --------------------------- GL_ARB_multisample -------------------------- */ #ifndef GL_ARB_multisample #define GL_ARB_multisample 1 #define GL_MULTISAMPLE_ARB 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E #define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F #define GL_SAMPLE_COVERAGE_ARB 0x80A0 #define GL_SAMPLE_BUFFERS_ARB 0x80A8 #define GL_SAMPLES_ARB 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA #define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB #define GL_MULTISAMPLE_BIT_ARB 0x20000000 typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert); #define glSampleCoverageARB GLEW_GET_FUN(__glewSampleCoverageARB) #define GLEW_ARB_multisample GLEW_GET_VAR(__GLEW_ARB_multisample) #endif /* GL_ARB_multisample */ /* -------------------------- GL_ARB_multitexture -------------------------- */ #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 #define GL_TEXTURE2_ARB 0x84C2 #define GL_TEXTURE3_ARB 0x84C3 #define GL_TEXTURE4_ARB 0x84C4 #define GL_TEXTURE5_ARB 0x84C5 #define GL_TEXTURE6_ARB 0x84C6 #define GL_TEXTURE7_ARB 0x84C7 #define GL_TEXTURE8_ARB 0x84C8 #define GL_TEXTURE9_ARB 0x84C9 #define GL_TEXTURE10_ARB 0x84CA #define GL_TEXTURE11_ARB 0x84CB #define GL_TEXTURE12_ARB 0x84CC #define GL_TEXTURE13_ARB 0x84CD #define GL_TEXTURE14_ARB 0x84CE #define GL_TEXTURE15_ARB 0x84CF #define GL_TEXTURE16_ARB 0x84D0 #define GL_TEXTURE17_ARB 0x84D1 #define GL_TEXTURE18_ARB 0x84D2 #define GL_TEXTURE19_ARB 0x84D3 #define GL_TEXTURE20_ARB 0x84D4 #define GL_TEXTURE21_ARB 0x84D5 #define GL_TEXTURE22_ARB 0x84D6 #define GL_TEXTURE23_ARB 0x84D7 #define GL_TEXTURE24_ARB 0x84D8 #define GL_TEXTURE25_ARB 0x84D9 #define GL_TEXTURE26_ARB 0x84DA #define GL_TEXTURE27_ARB 0x84DB #define GL_TEXTURE28_ARB 0x84DC #define GL_TEXTURE29_ARB 0x84DD #define GL_TEXTURE30_ARB 0x84DE #define GL_TEXTURE31_ARB 0x84DF #define GL_ACTIVE_TEXTURE_ARB 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture); typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); #define glActiveTextureARB GLEW_GET_FUN(__glewActiveTextureARB) #define glClientActiveTextureARB GLEW_GET_FUN(__glewClientActiveTextureARB) #define glMultiTexCoord1dARB GLEW_GET_FUN(__glewMultiTexCoord1dARB) #define glMultiTexCoord1dvARB GLEW_GET_FUN(__glewMultiTexCoord1dvARB) #define glMultiTexCoord1fARB GLEW_GET_FUN(__glewMultiTexCoord1fARB) #define glMultiTexCoord1fvARB GLEW_GET_FUN(__glewMultiTexCoord1fvARB) #define glMultiTexCoord1iARB GLEW_GET_FUN(__glewMultiTexCoord1iARB) #define glMultiTexCoord1ivARB GLEW_GET_FUN(__glewMultiTexCoord1ivARB) #define glMultiTexCoord1sARB GLEW_GET_FUN(__glewMultiTexCoord1sARB) #define glMultiTexCoord1svARB GLEW_GET_FUN(__glewMultiTexCoord1svARB) #define glMultiTexCoord2dARB GLEW_GET_FUN(__glewMultiTexCoord2dARB) #define glMultiTexCoord2dvARB GLEW_GET_FUN(__glewMultiTexCoord2dvARB) #define glMultiTexCoord2fARB GLEW_GET_FUN(__glewMultiTexCoord2fARB) #define glMultiTexCoord2fvARB GLEW_GET_FUN(__glewMultiTexCoord2fvARB) #define glMultiTexCoord2iARB GLEW_GET_FUN(__glewMultiTexCoord2iARB) #define glMultiTexCoord2ivARB GLEW_GET_FUN(__glewMultiTexCoord2ivARB) #define glMultiTexCoord2sARB GLEW_GET_FUN(__glewMultiTexCoord2sARB) #define glMultiTexCoord2svARB GLEW_GET_FUN(__glewMultiTexCoord2svARB) #define glMultiTexCoord3dARB GLEW_GET_FUN(__glewMultiTexCoord3dARB) #define glMultiTexCoord3dvARB GLEW_GET_FUN(__glewMultiTexCoord3dvARB) #define glMultiTexCoord3fARB GLEW_GET_FUN(__glewMultiTexCoord3fARB) #define glMultiTexCoord3fvARB GLEW_GET_FUN(__glewMultiTexCoord3fvARB) #define glMultiTexCoord3iARB GLEW_GET_FUN(__glewMultiTexCoord3iARB) #define glMultiTexCoord3ivARB GLEW_GET_FUN(__glewMultiTexCoord3ivARB) #define glMultiTexCoord3sARB GLEW_GET_FUN(__glewMultiTexCoord3sARB) #define glMultiTexCoord3svARB GLEW_GET_FUN(__glewMultiTexCoord3svARB) #define glMultiTexCoord4dARB GLEW_GET_FUN(__glewMultiTexCoord4dARB) #define glMultiTexCoord4dvARB GLEW_GET_FUN(__glewMultiTexCoord4dvARB) #define glMultiTexCoord4fARB GLEW_GET_FUN(__glewMultiTexCoord4fARB) #define glMultiTexCoord4fvARB GLEW_GET_FUN(__glewMultiTexCoord4fvARB) #define glMultiTexCoord4iARB GLEW_GET_FUN(__glewMultiTexCoord4iARB) #define glMultiTexCoord4ivARB GLEW_GET_FUN(__glewMultiTexCoord4ivARB) #define glMultiTexCoord4sARB GLEW_GET_FUN(__glewMultiTexCoord4sARB) #define glMultiTexCoord4svARB GLEW_GET_FUN(__glewMultiTexCoord4svARB) #define GLEW_ARB_multitexture GLEW_GET_VAR(__GLEW_ARB_multitexture) #endif /* GL_ARB_multitexture */ /* ------------------------- GL_ARB_occlusion_query ------------------------ */ #ifndef GL_ARB_occlusion_query #define GL_ARB_occlusion_query 1 #define GL_QUERY_COUNTER_BITS_ARB 0x8864 #define GL_CURRENT_QUERY_ARB 0x8865 #define GL_QUERY_RESULT_ARB 0x8866 #define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867 #define GL_SAMPLES_PASSED_ARB 0x8914 typedef void (GLAPIENTRY * PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id); typedef void (GLAPIENTRY * PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLENDQUERYARBPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISQUERYARBPROC) (GLuint id); #define glBeginQueryARB GLEW_GET_FUN(__glewBeginQueryARB) #define glDeleteQueriesARB GLEW_GET_FUN(__glewDeleteQueriesARB) #define glEndQueryARB GLEW_GET_FUN(__glewEndQueryARB) #define glGenQueriesARB GLEW_GET_FUN(__glewGenQueriesARB) #define glGetQueryObjectivARB GLEW_GET_FUN(__glewGetQueryObjectivARB) #define glGetQueryObjectuivARB GLEW_GET_FUN(__glewGetQueryObjectuivARB) #define glGetQueryivARB GLEW_GET_FUN(__glewGetQueryivARB) #define glIsQueryARB GLEW_GET_FUN(__glewIsQueryARB) #define GLEW_ARB_occlusion_query GLEW_GET_VAR(__GLEW_ARB_occlusion_query) #endif /* GL_ARB_occlusion_query */ /* ------------------------ GL_ARB_occlusion_query2 ------------------------ */ #ifndef GL_ARB_occlusion_query2 #define GL_ARB_occlusion_query2 1 #define GL_ANY_SAMPLES_PASSED 0x8C2F #define GLEW_ARB_occlusion_query2 GLEW_GET_VAR(__GLEW_ARB_occlusion_query2) #endif /* GL_ARB_occlusion_query2 */ /* --------------------- GL_ARB_parallel_shader_compile -------------------- */ #ifndef GL_ARB_parallel_shader_compile #define GL_ARB_parallel_shader_compile 1 #define GL_MAX_SHADER_COMPILER_THREADS_ARB 0x91B0 #define GL_COMPLETION_STATUS_ARB 0x91B1 typedef void (GLAPIENTRY * PFNGLMAXSHADERCOMPILERTHREADSARBPROC) (GLuint count); #define glMaxShaderCompilerThreadsARB GLEW_GET_FUN(__glewMaxShaderCompilerThreadsARB) #define GLEW_ARB_parallel_shader_compile GLEW_GET_VAR(__GLEW_ARB_parallel_shader_compile) #endif /* GL_ARB_parallel_shader_compile */ /* -------------------- GL_ARB_pipeline_statistics_query ------------------- */ #ifndef GL_ARB_pipeline_statistics_query #define GL_ARB_pipeline_statistics_query 1 #define GL_VERTICES_SUBMITTED_ARB 0x82EE #define GL_PRIMITIVES_SUBMITTED_ARB 0x82EF #define GL_VERTEX_SHADER_INVOCATIONS_ARB 0x82F0 #define GL_TESS_CONTROL_SHADER_PATCHES_ARB 0x82F1 #define GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB 0x82F2 #define GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB 0x82F3 #define GL_FRAGMENT_SHADER_INVOCATIONS_ARB 0x82F4 #define GL_COMPUTE_SHADER_INVOCATIONS_ARB 0x82F5 #define GL_CLIPPING_INPUT_PRIMITIVES_ARB 0x82F6 #define GL_CLIPPING_OUTPUT_PRIMITIVES_ARB 0x82F7 #define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F #define GLEW_ARB_pipeline_statistics_query GLEW_GET_VAR(__GLEW_ARB_pipeline_statistics_query) #endif /* GL_ARB_pipeline_statistics_query */ /* ----------------------- GL_ARB_pixel_buffer_object ---------------------- */ #ifndef GL_ARB_pixel_buffer_object #define GL_ARB_pixel_buffer_object 1 #define GL_PIXEL_PACK_BUFFER_ARB 0x88EB #define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC #define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED #define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF #define GLEW_ARB_pixel_buffer_object GLEW_GET_VAR(__GLEW_ARB_pixel_buffer_object) #endif /* GL_ARB_pixel_buffer_object */ /* ------------------------ GL_ARB_point_parameters ------------------------ */ #ifndef GL_ARB_point_parameters #define GL_ARB_point_parameters 1 #define GL_POINT_SIZE_MIN_ARB 0x8126 #define GL_POINT_SIZE_MAX_ARB 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128 #define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129 typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GLfloat* params); #define glPointParameterfARB GLEW_GET_FUN(__glewPointParameterfARB) #define glPointParameterfvARB GLEW_GET_FUN(__glewPointParameterfvARB) #define GLEW_ARB_point_parameters GLEW_GET_VAR(__GLEW_ARB_point_parameters) #endif /* GL_ARB_point_parameters */ /* -------------------------- GL_ARB_point_sprite -------------------------- */ #ifndef GL_ARB_point_sprite #define GL_ARB_point_sprite 1 #define GL_POINT_SPRITE_ARB 0x8861 #define GL_COORD_REPLACE_ARB 0x8862 #define GLEW_ARB_point_sprite GLEW_GET_VAR(__GLEW_ARB_point_sprite) #endif /* GL_ARB_point_sprite */ /* ----------------------- GL_ARB_post_depth_coverage ---------------------- */ #ifndef GL_ARB_post_depth_coverage #define GL_ARB_post_depth_coverage 1 #define GLEW_ARB_post_depth_coverage GLEW_GET_VAR(__GLEW_ARB_post_depth_coverage) #endif /* GL_ARB_post_depth_coverage */ /* --------------------- GL_ARB_program_interface_query -------------------- */ #ifndef GL_ARB_program_interface_query #define GL_ARB_program_interface_query 1 #define GL_UNIFORM 0x92E1 #define GL_UNIFORM_BLOCK 0x92E2 #define GL_PROGRAM_INPUT 0x92E3 #define GL_PROGRAM_OUTPUT 0x92E4 #define GL_BUFFER_VARIABLE 0x92E5 #define GL_SHADER_STORAGE_BLOCK 0x92E6 #define GL_IS_PER_PATCH 0x92E7 #define GL_VERTEX_SUBROUTINE 0x92E8 #define GL_TESS_CONTROL_SUBROUTINE 0x92E9 #define GL_TESS_EVALUATION_SUBROUTINE 0x92EA #define GL_GEOMETRY_SUBROUTINE 0x92EB #define GL_FRAGMENT_SUBROUTINE 0x92EC #define GL_COMPUTE_SUBROUTINE 0x92ED #define GL_VERTEX_SUBROUTINE_UNIFORM 0x92EE #define GL_TESS_CONTROL_SUBROUTINE_UNIFORM 0x92EF #define GL_TESS_EVALUATION_SUBROUTINE_UNIFORM 0x92F0 #define GL_GEOMETRY_SUBROUTINE_UNIFORM 0x92F1 #define GL_FRAGMENT_SUBROUTINE_UNIFORM 0x92F2 #define GL_COMPUTE_SUBROUTINE_UNIFORM 0x92F3 #define GL_TRANSFORM_FEEDBACK_VARYING 0x92F4 #define GL_ACTIVE_RESOURCES 0x92F5 #define GL_MAX_NAME_LENGTH 0x92F6 #define GL_MAX_NUM_ACTIVE_VARIABLES 0x92F7 #define GL_MAX_NUM_COMPATIBLE_SUBROUTINES 0x92F8 #define GL_NAME_LENGTH 0x92F9 #define GL_TYPE 0x92FA #define GL_ARRAY_SIZE 0x92FB #define GL_OFFSET 0x92FC #define GL_BLOCK_INDEX 0x92FD #define GL_ARRAY_STRIDE 0x92FE #define GL_MATRIX_STRIDE 0x92FF #define GL_IS_ROW_MAJOR 0x9300 #define GL_ATOMIC_COUNTER_BUFFER_INDEX 0x9301 #define GL_BUFFER_BINDING 0x9302 #define GL_BUFFER_DATA_SIZE 0x9303 #define GL_NUM_ACTIVE_VARIABLES 0x9304 #define GL_ACTIVE_VARIABLES 0x9305 #define GL_REFERENCED_BY_VERTEX_SHADER 0x9306 #define GL_REFERENCED_BY_TESS_CONTROL_SHADER 0x9307 #define GL_REFERENCED_BY_TESS_EVALUATION_SHADER 0x9308 #define GL_REFERENCED_BY_GEOMETRY_SHADER 0x9309 #define GL_REFERENCED_BY_FRAGMENT_SHADER 0x930A #define GL_REFERENCED_BY_COMPUTE_SHADER 0x930B #define GL_TOP_LEVEL_ARRAY_SIZE 0x930C #define GL_TOP_LEVEL_ARRAY_STRIDE 0x930D #define GL_LOCATION 0x930E #define GL_LOCATION_INDEX 0x930F typedef void (GLAPIENTRY * PFNGLGETPROGRAMINTERFACEIVPROC) (GLuint program, GLenum programInterface, GLenum pname, GLint* params); typedef GLuint (GLAPIENTRY * PFNGLGETPROGRAMRESOURCEINDEXPROC) (GLuint program, GLenum programInterface, const GLchar* name); typedef GLint (GLAPIENTRY * PFNGLGETPROGRAMRESOURCELOCATIONPROC) (GLuint program, GLenum programInterface, const GLchar* name); typedef GLint (GLAPIENTRY * PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC) (GLuint program, GLenum programInterface, const GLchar* name); typedef void (GLAPIENTRY * PFNGLGETPROGRAMRESOURCENAMEPROC) (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar *name); typedef void (GLAPIENTRY * PFNGLGETPROGRAMRESOURCEIVPROC) (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei *length, GLint *params); #define glGetProgramInterfaceiv GLEW_GET_FUN(__glewGetProgramInterfaceiv) #define glGetProgramResourceIndex GLEW_GET_FUN(__glewGetProgramResourceIndex) #define glGetProgramResourceLocation GLEW_GET_FUN(__glewGetProgramResourceLocation) #define glGetProgramResourceLocationIndex GLEW_GET_FUN(__glewGetProgramResourceLocationIndex) #define glGetProgramResourceName GLEW_GET_FUN(__glewGetProgramResourceName) #define glGetProgramResourceiv GLEW_GET_FUN(__glewGetProgramResourceiv) #define GLEW_ARB_program_interface_query GLEW_GET_VAR(__GLEW_ARB_program_interface_query) #endif /* GL_ARB_program_interface_query */ /* ------------------------ GL_ARB_provoking_vertex ------------------------ */ #ifndef GL_ARB_provoking_vertex #define GL_ARB_provoking_vertex 1 #define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C #define GL_FIRST_VERTEX_CONVENTION 0x8E4D #define GL_LAST_VERTEX_CONVENTION 0x8E4E #define GL_PROVOKING_VERTEX 0x8E4F typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXPROC) (GLenum mode); #define glProvokingVertex GLEW_GET_FUN(__glewProvokingVertex) #define GLEW_ARB_provoking_vertex GLEW_GET_VAR(__GLEW_ARB_provoking_vertex) #endif /* GL_ARB_provoking_vertex */ /* ----------------------- GL_ARB_query_buffer_object ---------------------- */ #ifndef GL_ARB_query_buffer_object #define GL_ARB_query_buffer_object 1 #define GL_QUERY_BUFFER_BARRIER_BIT 0x00008000 #define GL_QUERY_BUFFER 0x9192 #define GL_QUERY_BUFFER_BINDING 0x9193 #define GL_QUERY_RESULT_NO_WAIT 0x9194 #define GLEW_ARB_query_buffer_object GLEW_GET_VAR(__GLEW_ARB_query_buffer_object) #endif /* GL_ARB_query_buffer_object */ /* ------------------ GL_ARB_robust_buffer_access_behavior ----------------- */ #ifndef GL_ARB_robust_buffer_access_behavior #define GL_ARB_robust_buffer_access_behavior 1 #define GLEW_ARB_robust_buffer_access_behavior GLEW_GET_VAR(__GLEW_ARB_robust_buffer_access_behavior) #endif /* GL_ARB_robust_buffer_access_behavior */ /* --------------------------- GL_ARB_robustness --------------------------- */ #ifndef GL_ARB_robustness #define GL_ARB_robustness 1 #define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB 0x00000004 #define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252 #define GL_GUILTY_CONTEXT_RESET_ARB 0x8253 #define GL_INNOCENT_CONTEXT_RESET_ARB 0x8254 #define GL_UNKNOWN_CONTEXT_RESET_ARB 0x8255 #define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 #define GL_NO_RESET_NOTIFICATION_ARB 0x8261 typedef GLenum (GLAPIENTRY * PFNGLGETGRAPHICSRESETSTATUSARBPROC) (void); typedef void (GLAPIENTRY * PFNGLGETNCOLORTABLEARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* table); typedef void (GLAPIENTRY * PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint lod, GLsizei bufSize, void* img); typedef void (GLAPIENTRY * PFNGLGETNCONVOLUTIONFILTERARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* image); typedef void (GLAPIENTRY * PFNGLGETNHISTOGRAMARBPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values); typedef void (GLAPIENTRY * PFNGLGETNMAPDVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLdouble* v); typedef void (GLAPIENTRY * PFNGLGETNMAPFVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLfloat* v); typedef void (GLAPIENTRY * PFNGLGETNMAPIVARBPROC) (GLenum target, GLenum query, GLsizei bufSize, GLint* v); typedef void (GLAPIENTRY * PFNGLGETNMINMAXARBPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values); typedef void (GLAPIENTRY * PFNGLGETNPIXELMAPFVARBPROC) (GLenum map, GLsizei bufSize, GLfloat* values); typedef void (GLAPIENTRY * PFNGLGETNPIXELMAPUIVARBPROC) (GLenum map, GLsizei bufSize, GLuint* values); typedef void (GLAPIENTRY * PFNGLGETNPIXELMAPUSVARBPROC) (GLenum map, GLsizei bufSize, GLushort* values); typedef void (GLAPIENTRY * PFNGLGETNPOLYGONSTIPPLEARBPROC) (GLsizei bufSize, GLubyte* pattern); typedef void (GLAPIENTRY * PFNGLGETNSEPARABLEFILTERARBPROC) (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, void*column, void*span); typedef void (GLAPIENTRY * PFNGLGETNTEXIMAGEARBPROC) (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMDVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMFVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMIVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMUIVARBPROC) (GLuint program, GLint location, GLsizei bufSize, GLuint* params); typedef void (GLAPIENTRY * PFNGLREADNPIXELSARBPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data); #define glGetGraphicsResetStatusARB GLEW_GET_FUN(__glewGetGraphicsResetStatusARB) #define glGetnColorTableARB GLEW_GET_FUN(__glewGetnColorTableARB) #define glGetnCompressedTexImageARB GLEW_GET_FUN(__glewGetnCompressedTexImageARB) #define glGetnConvolutionFilterARB GLEW_GET_FUN(__glewGetnConvolutionFilterARB) #define glGetnHistogramARB GLEW_GET_FUN(__glewGetnHistogramARB) #define glGetnMapdvARB GLEW_GET_FUN(__glewGetnMapdvARB) #define glGetnMapfvARB GLEW_GET_FUN(__glewGetnMapfvARB) #define glGetnMapivARB GLEW_GET_FUN(__glewGetnMapivARB) #define glGetnMinmaxARB GLEW_GET_FUN(__glewGetnMinmaxARB) #define glGetnPixelMapfvARB GLEW_GET_FUN(__glewGetnPixelMapfvARB) #define glGetnPixelMapuivARB GLEW_GET_FUN(__glewGetnPixelMapuivARB) #define glGetnPixelMapusvARB GLEW_GET_FUN(__glewGetnPixelMapusvARB) #define glGetnPolygonStippleARB GLEW_GET_FUN(__glewGetnPolygonStippleARB) #define glGetnSeparableFilterARB GLEW_GET_FUN(__glewGetnSeparableFilterARB) #define glGetnTexImageARB GLEW_GET_FUN(__glewGetnTexImageARB) #define glGetnUniformdvARB GLEW_GET_FUN(__glewGetnUniformdvARB) #define glGetnUniformfvARB GLEW_GET_FUN(__glewGetnUniformfvARB) #define glGetnUniformivARB GLEW_GET_FUN(__glewGetnUniformivARB) #define glGetnUniformuivARB GLEW_GET_FUN(__glewGetnUniformuivARB) #define glReadnPixelsARB GLEW_GET_FUN(__glewReadnPixelsARB) #define GLEW_ARB_robustness GLEW_GET_VAR(__GLEW_ARB_robustness) #endif /* GL_ARB_robustness */ /* ---------------- GL_ARB_robustness_application_isolation ---------------- */ #ifndef GL_ARB_robustness_application_isolation #define GL_ARB_robustness_application_isolation 1 #define GLEW_ARB_robustness_application_isolation GLEW_GET_VAR(__GLEW_ARB_robustness_application_isolation) #endif /* GL_ARB_robustness_application_isolation */ /* ---------------- GL_ARB_robustness_share_group_isolation ---------------- */ #ifndef GL_ARB_robustness_share_group_isolation #define GL_ARB_robustness_share_group_isolation 1 #define GLEW_ARB_robustness_share_group_isolation GLEW_GET_VAR(__GLEW_ARB_robustness_share_group_isolation) #endif /* GL_ARB_robustness_share_group_isolation */ /* ------------------------ GL_ARB_sample_locations ------------------------ */ #ifndef GL_ARB_sample_locations #define GL_ARB_sample_locations 1 #define GL_SAMPLE_LOCATION_ARB 0x8E50 #define GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB 0x933D #define GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB 0x933E #define GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB 0x933F #define GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB 0x9340 #define GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB 0x9341 #define GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB 0x9342 #define GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB 0x9343 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC) (GLenum target, GLuint start, GLsizei count, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC) (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v); #define glFramebufferSampleLocationsfvARB GLEW_GET_FUN(__glewFramebufferSampleLocationsfvARB) #define glNamedFramebufferSampleLocationsfvARB GLEW_GET_FUN(__glewNamedFramebufferSampleLocationsfvARB) #define GLEW_ARB_sample_locations GLEW_GET_VAR(__GLEW_ARB_sample_locations) #endif /* GL_ARB_sample_locations */ /* ------------------------- GL_ARB_sample_shading ------------------------- */ #ifndef GL_ARB_sample_shading #define GL_ARB_sample_shading 1 #define GL_SAMPLE_SHADING_ARB 0x8C36 #define GL_MIN_SAMPLE_SHADING_VALUE_ARB 0x8C37 typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGARBPROC) (GLclampf value); #define glMinSampleShadingARB GLEW_GET_FUN(__glewMinSampleShadingARB) #define GLEW_ARB_sample_shading GLEW_GET_VAR(__GLEW_ARB_sample_shading) #endif /* GL_ARB_sample_shading */ /* ------------------------- GL_ARB_sampler_objects ------------------------ */ #ifndef GL_ARB_sampler_objects #define GL_ARB_sampler_objects 1 #define GL_SAMPLER_BINDING 0x8919 typedef void (GLAPIENTRY * PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler); typedef void (GLAPIENTRY * PFNGLDELETESAMPLERSPROC) (GLsizei count, const GLuint * samplers); typedef void (GLAPIENTRY * PFNGLGENSAMPLERSPROC) (GLsizei count, GLuint* samplers); typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISSAMPLERPROC) (GLuint sampler); typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIIVPROC) (GLuint sampler, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, const GLuint* params); typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFPROC) (GLuint sampler, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIPROC) (GLuint sampler, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, const GLint* params); #define glBindSampler GLEW_GET_FUN(__glewBindSampler) #define glDeleteSamplers GLEW_GET_FUN(__glewDeleteSamplers) #define glGenSamplers GLEW_GET_FUN(__glewGenSamplers) #define glGetSamplerParameterIiv GLEW_GET_FUN(__glewGetSamplerParameterIiv) #define glGetSamplerParameterIuiv GLEW_GET_FUN(__glewGetSamplerParameterIuiv) #define glGetSamplerParameterfv GLEW_GET_FUN(__glewGetSamplerParameterfv) #define glGetSamplerParameteriv GLEW_GET_FUN(__glewGetSamplerParameteriv) #define glIsSampler GLEW_GET_FUN(__glewIsSampler) #define glSamplerParameterIiv GLEW_GET_FUN(__glewSamplerParameterIiv) #define glSamplerParameterIuiv GLEW_GET_FUN(__glewSamplerParameterIuiv) #define glSamplerParameterf GLEW_GET_FUN(__glewSamplerParameterf) #define glSamplerParameterfv GLEW_GET_FUN(__glewSamplerParameterfv) #define glSamplerParameteri GLEW_GET_FUN(__glewSamplerParameteri) #define glSamplerParameteriv GLEW_GET_FUN(__glewSamplerParameteriv) #define GLEW_ARB_sampler_objects GLEW_GET_VAR(__GLEW_ARB_sampler_objects) #endif /* GL_ARB_sampler_objects */ /* ------------------------ GL_ARB_seamless_cube_map ----------------------- */ #ifndef GL_ARB_seamless_cube_map #define GL_ARB_seamless_cube_map 1 #define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F #define GLEW_ARB_seamless_cube_map GLEW_GET_VAR(__GLEW_ARB_seamless_cube_map) #endif /* GL_ARB_seamless_cube_map */ /* ------------------ GL_ARB_seamless_cubemap_per_texture ------------------ */ #ifndef GL_ARB_seamless_cubemap_per_texture #define GL_ARB_seamless_cubemap_per_texture 1 #define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F #define GLEW_ARB_seamless_cubemap_per_texture GLEW_GET_VAR(__GLEW_ARB_seamless_cubemap_per_texture) #endif /* GL_ARB_seamless_cubemap_per_texture */ /* --------------------- GL_ARB_separate_shader_objects -------------------- */ #ifndef GL_ARB_separate_shader_objects #define GL_ARB_separate_shader_objects 1 #define GL_VERTEX_SHADER_BIT 0x00000001 #define GL_FRAGMENT_SHADER_BIT 0x00000002 #define GL_GEOMETRY_SHADER_BIT 0x00000004 #define GL_TESS_CONTROL_SHADER_BIT 0x00000008 #define GL_TESS_EVALUATION_SHADER_BIT 0x00000010 #define GL_PROGRAM_SEPARABLE 0x8258 #define GL_ACTIVE_PROGRAM 0x8259 #define GL_PROGRAM_PIPELINE_BINDING 0x825A #define GL_ALL_SHADER_BITS 0xFFFFFFFF typedef void (GLAPIENTRY * PFNGLACTIVESHADERPROGRAMPROC) (GLuint pipeline, GLuint program); typedef void (GLAPIENTRY * PFNGLBINDPROGRAMPIPELINEPROC) (GLuint pipeline); typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROGRAMVPROC) (GLenum type, GLsizei count, const GLchar * const * strings); typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMPIPELINESPROC) (GLsizei n, const GLuint* pipelines); typedef void (GLAPIENTRY * PFNGLGENPROGRAMPIPELINESPROC) (GLsizei n, GLuint* pipelines); typedef void (GLAPIENTRY * PFNGLGETPROGRAMPIPELINEINFOLOGPROC) (GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar *infoLog); typedef void (GLAPIENTRY * PFNGLGETPROGRAMPIPELINEIVPROC) (GLuint pipeline, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMPIPELINEPROC) (GLuint pipeline); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1DPROC) (GLuint program, GLint location, GLdouble x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FPROC) (GLuint program, GLint location, GLfloat x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IPROC) (GLuint program, GLint location, GLint x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIPROC) (GLuint program, GLint location, GLuint x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2DPROC) (GLuint program, GLint location, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FPROC) (GLuint program, GLint location, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IPROC) (GLuint program, GLint location, GLint x, GLint y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIPROC) (GLuint program, GLint location, GLuint x, GLuint y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3DPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIPROC) (GLuint program, GLint location, GLuint x, GLuint y, GLuint z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4DPROC) (GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4DVPROC) (GLuint program, GLint location, GLsizei count, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FPROC) (GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FVPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IPROC) (GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IVPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIPROC) (GLuint program, GLint location, GLuint x, GLuint y, GLuint z, GLuint w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIVPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUSEPROGRAMSTAGESPROC) (GLuint pipeline, GLbitfield stages, GLuint program); typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMPIPELINEPROC) (GLuint pipeline); #define glActiveShaderProgram GLEW_GET_FUN(__glewActiveShaderProgram) #define glBindProgramPipeline GLEW_GET_FUN(__glewBindProgramPipeline) #define glCreateShaderProgramv GLEW_GET_FUN(__glewCreateShaderProgramv) #define glDeleteProgramPipelines GLEW_GET_FUN(__glewDeleteProgramPipelines) #define glGenProgramPipelines GLEW_GET_FUN(__glewGenProgramPipelines) #define glGetProgramPipelineInfoLog GLEW_GET_FUN(__glewGetProgramPipelineInfoLog) #define glGetProgramPipelineiv GLEW_GET_FUN(__glewGetProgramPipelineiv) #define glIsProgramPipeline GLEW_GET_FUN(__glewIsProgramPipeline) #define glProgramUniform1d GLEW_GET_FUN(__glewProgramUniform1d) #define glProgramUniform1dv GLEW_GET_FUN(__glewProgramUniform1dv) #define glProgramUniform1f GLEW_GET_FUN(__glewProgramUniform1f) #define glProgramUniform1fv GLEW_GET_FUN(__glewProgramUniform1fv) #define glProgramUniform1i GLEW_GET_FUN(__glewProgramUniform1i) #define glProgramUniform1iv GLEW_GET_FUN(__glewProgramUniform1iv) #define glProgramUniform1ui GLEW_GET_FUN(__glewProgramUniform1ui) #define glProgramUniform1uiv GLEW_GET_FUN(__glewProgramUniform1uiv) #define glProgramUniform2d GLEW_GET_FUN(__glewProgramUniform2d) #define glProgramUniform2dv GLEW_GET_FUN(__glewProgramUniform2dv) #define glProgramUniform2f GLEW_GET_FUN(__glewProgramUniform2f) #define glProgramUniform2fv GLEW_GET_FUN(__glewProgramUniform2fv) #define glProgramUniform2i GLEW_GET_FUN(__glewProgramUniform2i) #define glProgramUniform2iv GLEW_GET_FUN(__glewProgramUniform2iv) #define glProgramUniform2ui GLEW_GET_FUN(__glewProgramUniform2ui) #define glProgramUniform2uiv GLEW_GET_FUN(__glewProgramUniform2uiv) #define glProgramUniform3d GLEW_GET_FUN(__glewProgramUniform3d) #define glProgramUniform3dv GLEW_GET_FUN(__glewProgramUniform3dv) #define glProgramUniform3f GLEW_GET_FUN(__glewProgramUniform3f) #define glProgramUniform3fv GLEW_GET_FUN(__glewProgramUniform3fv) #define glProgramUniform3i GLEW_GET_FUN(__glewProgramUniform3i) #define glProgramUniform3iv GLEW_GET_FUN(__glewProgramUniform3iv) #define glProgramUniform3ui GLEW_GET_FUN(__glewProgramUniform3ui) #define glProgramUniform3uiv GLEW_GET_FUN(__glewProgramUniform3uiv) #define glProgramUniform4d GLEW_GET_FUN(__glewProgramUniform4d) #define glProgramUniform4dv GLEW_GET_FUN(__glewProgramUniform4dv) #define glProgramUniform4f GLEW_GET_FUN(__glewProgramUniform4f) #define glProgramUniform4fv GLEW_GET_FUN(__glewProgramUniform4fv) #define glProgramUniform4i GLEW_GET_FUN(__glewProgramUniform4i) #define glProgramUniform4iv GLEW_GET_FUN(__glewProgramUniform4iv) #define glProgramUniform4ui GLEW_GET_FUN(__glewProgramUniform4ui) #define glProgramUniform4uiv GLEW_GET_FUN(__glewProgramUniform4uiv) #define glProgramUniformMatrix2dv GLEW_GET_FUN(__glewProgramUniformMatrix2dv) #define glProgramUniformMatrix2fv GLEW_GET_FUN(__glewProgramUniformMatrix2fv) #define glProgramUniformMatrix2x3dv GLEW_GET_FUN(__glewProgramUniformMatrix2x3dv) #define glProgramUniformMatrix2x3fv GLEW_GET_FUN(__glewProgramUniformMatrix2x3fv) #define glProgramUniformMatrix2x4dv GLEW_GET_FUN(__glewProgramUniformMatrix2x4dv) #define glProgramUniformMatrix2x4fv GLEW_GET_FUN(__glewProgramUniformMatrix2x4fv) #define glProgramUniformMatrix3dv GLEW_GET_FUN(__glewProgramUniformMatrix3dv) #define glProgramUniformMatrix3fv GLEW_GET_FUN(__glewProgramUniformMatrix3fv) #define glProgramUniformMatrix3x2dv GLEW_GET_FUN(__glewProgramUniformMatrix3x2dv) #define glProgramUniformMatrix3x2fv GLEW_GET_FUN(__glewProgramUniformMatrix3x2fv) #define glProgramUniformMatrix3x4dv GLEW_GET_FUN(__glewProgramUniformMatrix3x4dv) #define glProgramUniformMatrix3x4fv GLEW_GET_FUN(__glewProgramUniformMatrix3x4fv) #define glProgramUniformMatrix4dv GLEW_GET_FUN(__glewProgramUniformMatrix4dv) #define glProgramUniformMatrix4fv GLEW_GET_FUN(__glewProgramUniformMatrix4fv) #define glProgramUniformMatrix4x2dv GLEW_GET_FUN(__glewProgramUniformMatrix4x2dv) #define glProgramUniformMatrix4x2fv GLEW_GET_FUN(__glewProgramUniformMatrix4x2fv) #define glProgramUniformMatrix4x3dv GLEW_GET_FUN(__glewProgramUniformMatrix4x3dv) #define glProgramUniformMatrix4x3fv GLEW_GET_FUN(__glewProgramUniformMatrix4x3fv) #define glUseProgramStages GLEW_GET_FUN(__glewUseProgramStages) #define glValidateProgramPipeline GLEW_GET_FUN(__glewValidateProgramPipeline) #define GLEW_ARB_separate_shader_objects GLEW_GET_VAR(__GLEW_ARB_separate_shader_objects) #endif /* GL_ARB_separate_shader_objects */ /* -------------------- GL_ARB_shader_atomic_counter_ops ------------------- */ #ifndef GL_ARB_shader_atomic_counter_ops #define GL_ARB_shader_atomic_counter_ops 1 #define GLEW_ARB_shader_atomic_counter_ops GLEW_GET_VAR(__GLEW_ARB_shader_atomic_counter_ops) #endif /* GL_ARB_shader_atomic_counter_ops */ /* --------------------- GL_ARB_shader_atomic_counters --------------------- */ #ifndef GL_ARB_shader_atomic_counters #define GL_ARB_shader_atomic_counters 1 #define GL_ATOMIC_COUNTER_BUFFER 0x92C0 #define GL_ATOMIC_COUNTER_BUFFER_BINDING 0x92C1 #define GL_ATOMIC_COUNTER_BUFFER_START 0x92C2 #define GL_ATOMIC_COUNTER_BUFFER_SIZE 0x92C3 #define GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE 0x92C4 #define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS 0x92C5 #define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES 0x92C6 #define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER 0x92C7 #define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER 0x92C8 #define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER 0x92C9 #define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER 0x92CA #define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER 0x92CB #define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS 0x92CC #define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS 0x92CD #define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS 0x92CE #define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS 0x92CF #define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS 0x92D0 #define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS 0x92D1 #define GL_MAX_VERTEX_ATOMIC_COUNTERS 0x92D2 #define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS 0x92D3 #define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS 0x92D4 #define GL_MAX_GEOMETRY_ATOMIC_COUNTERS 0x92D5 #define GL_MAX_FRAGMENT_ATOMIC_COUNTERS 0x92D6 #define GL_MAX_COMBINED_ATOMIC_COUNTERS 0x92D7 #define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE 0x92D8 #define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS 0x92D9 #define GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX 0x92DA #define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB #define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS 0x92DC typedef void (GLAPIENTRY * PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC) (GLuint program, GLuint bufferIndex, GLenum pname, GLint* params); #define glGetActiveAtomicCounterBufferiv GLEW_GET_FUN(__glewGetActiveAtomicCounterBufferiv) #define GLEW_ARB_shader_atomic_counters GLEW_GET_VAR(__GLEW_ARB_shader_atomic_counters) #endif /* GL_ARB_shader_atomic_counters */ /* -------------------------- GL_ARB_shader_ballot ------------------------- */ #ifndef GL_ARB_shader_ballot #define GL_ARB_shader_ballot 1 #define GLEW_ARB_shader_ballot GLEW_GET_VAR(__GLEW_ARB_shader_ballot) #endif /* GL_ARB_shader_ballot */ /* ----------------------- GL_ARB_shader_bit_encoding ---------------------- */ #ifndef GL_ARB_shader_bit_encoding #define GL_ARB_shader_bit_encoding 1 #define GLEW_ARB_shader_bit_encoding GLEW_GET_VAR(__GLEW_ARB_shader_bit_encoding) #endif /* GL_ARB_shader_bit_encoding */ /* -------------------------- GL_ARB_shader_clock -------------------------- */ #ifndef GL_ARB_shader_clock #define GL_ARB_shader_clock 1 #define GLEW_ARB_shader_clock GLEW_GET_VAR(__GLEW_ARB_shader_clock) #endif /* GL_ARB_shader_clock */ /* --------------------- GL_ARB_shader_draw_parameters --------------------- */ #ifndef GL_ARB_shader_draw_parameters #define GL_ARB_shader_draw_parameters 1 #define GLEW_ARB_shader_draw_parameters GLEW_GET_VAR(__GLEW_ARB_shader_draw_parameters) #endif /* GL_ARB_shader_draw_parameters */ /* ------------------------ GL_ARB_shader_group_vote ----------------------- */ #ifndef GL_ARB_shader_group_vote #define GL_ARB_shader_group_vote 1 #define GLEW_ARB_shader_group_vote GLEW_GET_VAR(__GLEW_ARB_shader_group_vote) #endif /* GL_ARB_shader_group_vote */ /* --------------------- GL_ARB_shader_image_load_store -------------------- */ #ifndef GL_ARB_shader_image_load_store #define GL_ARB_shader_image_load_store 1 #define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT 0x00000001 #define GL_ELEMENT_ARRAY_BARRIER_BIT 0x00000002 #define GL_UNIFORM_BARRIER_BIT 0x00000004 #define GL_TEXTURE_FETCH_BARRIER_BIT 0x00000008 #define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020 #define GL_COMMAND_BARRIER_BIT 0x00000040 #define GL_PIXEL_BUFFER_BARRIER_BIT 0x00000080 #define GL_TEXTURE_UPDATE_BARRIER_BIT 0x00000100 #define GL_BUFFER_UPDATE_BARRIER_BIT 0x00000200 #define GL_FRAMEBUFFER_BARRIER_BIT 0x00000400 #define GL_TRANSFORM_FEEDBACK_BARRIER_BIT 0x00000800 #define GL_ATOMIC_COUNTER_BARRIER_BIT 0x00001000 #define GL_MAX_IMAGE_UNITS 0x8F38 #define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS 0x8F39 #define GL_IMAGE_BINDING_NAME 0x8F3A #define GL_IMAGE_BINDING_LEVEL 0x8F3B #define GL_IMAGE_BINDING_LAYERED 0x8F3C #define GL_IMAGE_BINDING_LAYER 0x8F3D #define GL_IMAGE_BINDING_ACCESS 0x8F3E #define GL_IMAGE_1D 0x904C #define GL_IMAGE_2D 0x904D #define GL_IMAGE_3D 0x904E #define GL_IMAGE_2D_RECT 0x904F #define GL_IMAGE_CUBE 0x9050 #define GL_IMAGE_BUFFER 0x9051 #define GL_IMAGE_1D_ARRAY 0x9052 #define GL_IMAGE_2D_ARRAY 0x9053 #define GL_IMAGE_CUBE_MAP_ARRAY 0x9054 #define GL_IMAGE_2D_MULTISAMPLE 0x9055 #define GL_IMAGE_2D_MULTISAMPLE_ARRAY 0x9056 #define GL_INT_IMAGE_1D 0x9057 #define GL_INT_IMAGE_2D 0x9058 #define GL_INT_IMAGE_3D 0x9059 #define GL_INT_IMAGE_2D_RECT 0x905A #define GL_INT_IMAGE_CUBE 0x905B #define GL_INT_IMAGE_BUFFER 0x905C #define GL_INT_IMAGE_1D_ARRAY 0x905D #define GL_INT_IMAGE_2D_ARRAY 0x905E #define GL_INT_IMAGE_CUBE_MAP_ARRAY 0x905F #define GL_INT_IMAGE_2D_MULTISAMPLE 0x9060 #define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x9061 #define GL_UNSIGNED_INT_IMAGE_1D 0x9062 #define GL_UNSIGNED_INT_IMAGE_2D 0x9063 #define GL_UNSIGNED_INT_IMAGE_3D 0x9064 #define GL_UNSIGNED_INT_IMAGE_2D_RECT 0x9065 #define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066 #define GL_UNSIGNED_INT_IMAGE_BUFFER 0x9067 #define GL_UNSIGNED_INT_IMAGE_1D_ARRAY 0x9068 #define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069 #define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A #define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE 0x906B #define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x906C #define GL_MAX_IMAGE_SAMPLES 0x906D #define GL_IMAGE_BINDING_FORMAT 0x906E #define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7 #define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE 0x90C8 #define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS 0x90C9 #define GL_MAX_VERTEX_IMAGE_UNIFORMS 0x90CA #define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS 0x90CB #define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS 0x90CC #define GL_MAX_GEOMETRY_IMAGE_UNIFORMS 0x90CD #define GL_MAX_FRAGMENT_IMAGE_UNIFORMS 0x90CE #define GL_MAX_COMBINED_IMAGE_UNIFORMS 0x90CF #define GL_ALL_BARRIER_BITS 0xFFFFFFFF typedef void (GLAPIENTRY * PFNGLBINDIMAGETEXTUREPROC) (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); typedef void (GLAPIENTRY * PFNGLMEMORYBARRIERPROC) (GLbitfield barriers); #define glBindImageTexture GLEW_GET_FUN(__glewBindImageTexture) #define glMemoryBarrier GLEW_GET_FUN(__glewMemoryBarrier) #define GLEW_ARB_shader_image_load_store GLEW_GET_VAR(__GLEW_ARB_shader_image_load_store) #endif /* GL_ARB_shader_image_load_store */ /* ------------------------ GL_ARB_shader_image_size ----------------------- */ #ifndef GL_ARB_shader_image_size #define GL_ARB_shader_image_size 1 #define GLEW_ARB_shader_image_size GLEW_GET_VAR(__GLEW_ARB_shader_image_size) #endif /* GL_ARB_shader_image_size */ /* ------------------------- GL_ARB_shader_objects ------------------------- */ #ifndef GL_ARB_shader_objects #define GL_ARB_shader_objects 1 #define GL_PROGRAM_OBJECT_ARB 0x8B40 #define GL_SHADER_OBJECT_ARB 0x8B48 #define GL_OBJECT_TYPE_ARB 0x8B4E #define GL_OBJECT_SUBTYPE_ARB 0x8B4F #define GL_FLOAT_VEC2_ARB 0x8B50 #define GL_FLOAT_VEC3_ARB 0x8B51 #define GL_FLOAT_VEC4_ARB 0x8B52 #define GL_INT_VEC2_ARB 0x8B53 #define GL_INT_VEC3_ARB 0x8B54 #define GL_INT_VEC4_ARB 0x8B55 #define GL_BOOL_ARB 0x8B56 #define GL_BOOL_VEC2_ARB 0x8B57 #define GL_BOOL_VEC3_ARB 0x8B58 #define GL_BOOL_VEC4_ARB 0x8B59 #define GL_FLOAT_MAT2_ARB 0x8B5A #define GL_FLOAT_MAT3_ARB 0x8B5B #define GL_FLOAT_MAT4_ARB 0x8B5C #define GL_SAMPLER_1D_ARB 0x8B5D #define GL_SAMPLER_2D_ARB 0x8B5E #define GL_SAMPLER_3D_ARB 0x8B5F #define GL_SAMPLER_CUBE_ARB 0x8B60 #define GL_SAMPLER_1D_SHADOW_ARB 0x8B61 #define GL_SAMPLER_2D_SHADOW_ARB 0x8B62 #define GL_SAMPLER_2D_RECT_ARB 0x8B63 #define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 #define GL_OBJECT_DELETE_STATUS_ARB 0x8B80 #define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81 #define GL_OBJECT_LINK_STATUS_ARB 0x8B82 #define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83 #define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84 #define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85 #define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86 #define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87 #define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88 typedef char GLcharARB; typedef unsigned int GLhandleARB; typedef void (GLAPIENTRY * PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); typedef void (GLAPIENTRY * PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); typedef GLhandleARB (GLAPIENTRY * PFNGLCREATEPROGRAMOBJECTARBPROC) (void); typedef GLhandleARB (GLAPIENTRY * PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); typedef void (GLAPIENTRY * PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); typedef void (GLAPIENTRY * PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name); typedef void (GLAPIENTRY * PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB *obj); typedef GLhandleARB (GLAPIENTRY * PFNGLGETHANDLEARBPROC) (GLenum pname); typedef void (GLAPIENTRY * PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *infoLog); typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *source); typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB* name); typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint* params); typedef void (GLAPIENTRY * PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); typedef void (GLAPIENTRY * PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB ** string, const GLint *length); typedef void (GLAPIENTRY * PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); typedef void (GLAPIENTRY * PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); typedef void (GLAPIENTRY * PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); typedef void (GLAPIENTRY * PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); typedef void (GLAPIENTRY * PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (GLAPIENTRY * PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); typedef void (GLAPIENTRY * PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (GLAPIENTRY * PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (GLAPIENTRY * PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); #define glAttachObjectARB GLEW_GET_FUN(__glewAttachObjectARB) #define glCompileShaderARB GLEW_GET_FUN(__glewCompileShaderARB) #define glCreateProgramObjectARB GLEW_GET_FUN(__glewCreateProgramObjectARB) #define glCreateShaderObjectARB GLEW_GET_FUN(__glewCreateShaderObjectARB) #define glDeleteObjectARB GLEW_GET_FUN(__glewDeleteObjectARB) #define glDetachObjectARB GLEW_GET_FUN(__glewDetachObjectARB) #define glGetActiveUniformARB GLEW_GET_FUN(__glewGetActiveUniformARB) #define glGetAttachedObjectsARB GLEW_GET_FUN(__glewGetAttachedObjectsARB) #define glGetHandleARB GLEW_GET_FUN(__glewGetHandleARB) #define glGetInfoLogARB GLEW_GET_FUN(__glewGetInfoLogARB) #define glGetObjectParameterfvARB GLEW_GET_FUN(__glewGetObjectParameterfvARB) #define glGetObjectParameterivARB GLEW_GET_FUN(__glewGetObjectParameterivARB) #define glGetShaderSourceARB GLEW_GET_FUN(__glewGetShaderSourceARB) #define glGetUniformLocationARB GLEW_GET_FUN(__glewGetUniformLocationARB) #define glGetUniformfvARB GLEW_GET_FUN(__glewGetUniformfvARB) #define glGetUniformivARB GLEW_GET_FUN(__glewGetUniformivARB) #define glLinkProgramARB GLEW_GET_FUN(__glewLinkProgramARB) #define glShaderSourceARB GLEW_GET_FUN(__glewShaderSourceARB) #define glUniform1fARB GLEW_GET_FUN(__glewUniform1fARB) #define glUniform1fvARB GLEW_GET_FUN(__glewUniform1fvARB) #define glUniform1iARB GLEW_GET_FUN(__glewUniform1iARB) #define glUniform1ivARB GLEW_GET_FUN(__glewUniform1ivARB) #define glUniform2fARB GLEW_GET_FUN(__glewUniform2fARB) #define glUniform2fvARB GLEW_GET_FUN(__glewUniform2fvARB) #define glUniform2iARB GLEW_GET_FUN(__glewUniform2iARB) #define glUniform2ivARB GLEW_GET_FUN(__glewUniform2ivARB) #define glUniform3fARB GLEW_GET_FUN(__glewUniform3fARB) #define glUniform3fvARB GLEW_GET_FUN(__glewUniform3fvARB) #define glUniform3iARB GLEW_GET_FUN(__glewUniform3iARB) #define glUniform3ivARB GLEW_GET_FUN(__glewUniform3ivARB) #define glUniform4fARB GLEW_GET_FUN(__glewUniform4fARB) #define glUniform4fvARB GLEW_GET_FUN(__glewUniform4fvARB) #define glUniform4iARB GLEW_GET_FUN(__glewUniform4iARB) #define glUniform4ivARB GLEW_GET_FUN(__glewUniform4ivARB) #define glUniformMatrix2fvARB GLEW_GET_FUN(__glewUniformMatrix2fvARB) #define glUniformMatrix3fvARB GLEW_GET_FUN(__glewUniformMatrix3fvARB) #define glUniformMatrix4fvARB GLEW_GET_FUN(__glewUniformMatrix4fvARB) #define glUseProgramObjectARB GLEW_GET_FUN(__glewUseProgramObjectARB) #define glValidateProgramARB GLEW_GET_FUN(__glewValidateProgramARB) #define GLEW_ARB_shader_objects GLEW_GET_VAR(__GLEW_ARB_shader_objects) #endif /* GL_ARB_shader_objects */ /* ------------------------ GL_ARB_shader_precision ------------------------ */ #ifndef GL_ARB_shader_precision #define GL_ARB_shader_precision 1 #define GLEW_ARB_shader_precision GLEW_GET_VAR(__GLEW_ARB_shader_precision) #endif /* GL_ARB_shader_precision */ /* ---------------------- GL_ARB_shader_stencil_export --------------------- */ #ifndef GL_ARB_shader_stencil_export #define GL_ARB_shader_stencil_export 1 #define GLEW_ARB_shader_stencil_export GLEW_GET_VAR(__GLEW_ARB_shader_stencil_export) #endif /* GL_ARB_shader_stencil_export */ /* ------------------ GL_ARB_shader_storage_buffer_object ------------------ */ #ifndef GL_ARB_shader_storage_buffer_object #define GL_ARB_shader_storage_buffer_object 1 #define GL_SHADER_STORAGE_BARRIER_BIT 0x2000 #define GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES 0x8F39 #define GL_SHADER_STORAGE_BUFFER 0x90D2 #define GL_SHADER_STORAGE_BUFFER_BINDING 0x90D3 #define GL_SHADER_STORAGE_BUFFER_START 0x90D4 #define GL_SHADER_STORAGE_BUFFER_SIZE 0x90D5 #define GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS 0x90D6 #define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS 0x90D7 #define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS 0x90D8 #define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS 0x90D9 #define GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS 0x90DA #define GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS 0x90DB #define GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS 0x90DC #define GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS 0x90DD #define GL_MAX_SHADER_STORAGE_BLOCK_SIZE 0x90DE #define GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT 0x90DF typedef void (GLAPIENTRY * PFNGLSHADERSTORAGEBLOCKBINDINGPROC) (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding); #define glShaderStorageBlockBinding GLEW_GET_FUN(__glewShaderStorageBlockBinding) #define GLEW_ARB_shader_storage_buffer_object GLEW_GET_VAR(__GLEW_ARB_shader_storage_buffer_object) #endif /* GL_ARB_shader_storage_buffer_object */ /* ------------------------ GL_ARB_shader_subroutine ----------------------- */ #ifndef GL_ARB_shader_subroutine #define GL_ARB_shader_subroutine 1 #define GL_ACTIVE_SUBROUTINES 0x8DE5 #define GL_ACTIVE_SUBROUTINE_UNIFORMS 0x8DE6 #define GL_MAX_SUBROUTINES 0x8DE7 #define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS 0x8DE8 #define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS 0x8E47 #define GL_ACTIVE_SUBROUTINE_MAX_LENGTH 0x8E48 #define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH 0x8E49 #define GL_NUM_COMPATIBLE_SUBROUTINES 0x8E4A #define GL_COMPATIBLE_SUBROUTINES 0x8E4B typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINENAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar *name); typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC) (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar *name); typedef void (GLAPIENTRY * PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC) (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values); typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTAGEIVPROC) (GLuint program, GLenum shadertype, GLenum pname, GLint* values); typedef GLuint (GLAPIENTRY * PFNGLGETSUBROUTINEINDEXPROC) (GLuint program, GLenum shadertype, const GLchar* name); typedef GLint (GLAPIENTRY * PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC) (GLuint program, GLenum shadertype, const GLchar* name); typedef void (GLAPIENTRY * PFNGLGETUNIFORMSUBROUTINEUIVPROC) (GLenum shadertype, GLint location, GLuint* params); typedef void (GLAPIENTRY * PFNGLUNIFORMSUBROUTINESUIVPROC) (GLenum shadertype, GLsizei count, const GLuint* indices); #define glGetActiveSubroutineName GLEW_GET_FUN(__glewGetActiveSubroutineName) #define glGetActiveSubroutineUniformName GLEW_GET_FUN(__glewGetActiveSubroutineUniformName) #define glGetActiveSubroutineUniformiv GLEW_GET_FUN(__glewGetActiveSubroutineUniformiv) #define glGetProgramStageiv GLEW_GET_FUN(__glewGetProgramStageiv) #define glGetSubroutineIndex GLEW_GET_FUN(__glewGetSubroutineIndex) #define glGetSubroutineUniformLocation GLEW_GET_FUN(__glewGetSubroutineUniformLocation) #define glGetUniformSubroutineuiv GLEW_GET_FUN(__glewGetUniformSubroutineuiv) #define glUniformSubroutinesuiv GLEW_GET_FUN(__glewUniformSubroutinesuiv) #define GLEW_ARB_shader_subroutine GLEW_GET_VAR(__GLEW_ARB_shader_subroutine) #endif /* GL_ARB_shader_subroutine */ /* ------------------ GL_ARB_shader_texture_image_samples ------------------ */ #ifndef GL_ARB_shader_texture_image_samples #define GL_ARB_shader_texture_image_samples 1 #define GLEW_ARB_shader_texture_image_samples GLEW_GET_VAR(__GLEW_ARB_shader_texture_image_samples) #endif /* GL_ARB_shader_texture_image_samples */ /* ----------------------- GL_ARB_shader_texture_lod ----------------------- */ #ifndef GL_ARB_shader_texture_lod #define GL_ARB_shader_texture_lod 1 #define GLEW_ARB_shader_texture_lod GLEW_GET_VAR(__GLEW_ARB_shader_texture_lod) #endif /* GL_ARB_shader_texture_lod */ /* ------------------- GL_ARB_shader_viewport_layer_array ------------------ */ #ifndef GL_ARB_shader_viewport_layer_array #define GL_ARB_shader_viewport_layer_array 1 #define GLEW_ARB_shader_viewport_layer_array GLEW_GET_VAR(__GLEW_ARB_shader_viewport_layer_array) #endif /* GL_ARB_shader_viewport_layer_array */ /* ---------------------- GL_ARB_shading_language_100 ---------------------- */ #ifndef GL_ARB_shading_language_100 #define GL_ARB_shading_language_100 1 #define GL_SHADING_LANGUAGE_VERSION_ARB 0x8B8C #define GLEW_ARB_shading_language_100 GLEW_GET_VAR(__GLEW_ARB_shading_language_100) #endif /* GL_ARB_shading_language_100 */ /* -------------------- GL_ARB_shading_language_420pack -------------------- */ #ifndef GL_ARB_shading_language_420pack #define GL_ARB_shading_language_420pack 1 #define GLEW_ARB_shading_language_420pack GLEW_GET_VAR(__GLEW_ARB_shading_language_420pack) #endif /* GL_ARB_shading_language_420pack */ /* -------------------- GL_ARB_shading_language_include -------------------- */ #ifndef GL_ARB_shading_language_include #define GL_ARB_shading_language_include 1 #define GL_SHADER_INCLUDE_ARB 0x8DAE #define GL_NAMED_STRING_LENGTH_ARB 0x8DE9 #define GL_NAMED_STRING_TYPE_ARB 0x8DEA typedef void (GLAPIENTRY * PFNGLCOMPILESHADERINCLUDEARBPROC) (GLuint shader, GLsizei count, const GLchar* const *path, const GLint *length); typedef void (GLAPIENTRY * PFNGLDELETENAMEDSTRINGARBPROC) (GLint namelen, const GLchar* name); typedef void (GLAPIENTRY * PFNGLGETNAMEDSTRINGARBPROC) (GLint namelen, const GLchar* name, GLsizei bufSize, GLint *stringlen, GLchar *string); typedef void (GLAPIENTRY * PFNGLGETNAMEDSTRINGIVARBPROC) (GLint namelen, const GLchar* name, GLenum pname, GLint *params); typedef GLboolean (GLAPIENTRY * PFNGLISNAMEDSTRINGARBPROC) (GLint namelen, const GLchar* name); typedef void (GLAPIENTRY * PFNGLNAMEDSTRINGARBPROC) (GLenum type, GLint namelen, const GLchar* name, GLint stringlen, const GLchar *string); #define glCompileShaderIncludeARB GLEW_GET_FUN(__glewCompileShaderIncludeARB) #define glDeleteNamedStringARB GLEW_GET_FUN(__glewDeleteNamedStringARB) #define glGetNamedStringARB GLEW_GET_FUN(__glewGetNamedStringARB) #define glGetNamedStringivARB GLEW_GET_FUN(__glewGetNamedStringivARB) #define glIsNamedStringARB GLEW_GET_FUN(__glewIsNamedStringARB) #define glNamedStringARB GLEW_GET_FUN(__glewNamedStringARB) #define GLEW_ARB_shading_language_include GLEW_GET_VAR(__GLEW_ARB_shading_language_include) #endif /* GL_ARB_shading_language_include */ /* -------------------- GL_ARB_shading_language_packing -------------------- */ #ifndef GL_ARB_shading_language_packing #define GL_ARB_shading_language_packing 1 #define GLEW_ARB_shading_language_packing GLEW_GET_VAR(__GLEW_ARB_shading_language_packing) #endif /* GL_ARB_shading_language_packing */ /* ----------------------------- GL_ARB_shadow ----------------------------- */ #ifndef GL_ARB_shadow #define GL_ARB_shadow 1 #define GL_TEXTURE_COMPARE_MODE_ARB 0x884C #define GL_TEXTURE_COMPARE_FUNC_ARB 0x884D #define GL_COMPARE_R_TO_TEXTURE_ARB 0x884E #define GLEW_ARB_shadow GLEW_GET_VAR(__GLEW_ARB_shadow) #endif /* GL_ARB_shadow */ /* ------------------------- GL_ARB_shadow_ambient ------------------------- */ #ifndef GL_ARB_shadow_ambient #define GL_ARB_shadow_ambient 1 #define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF #define GLEW_ARB_shadow_ambient GLEW_GET_VAR(__GLEW_ARB_shadow_ambient) #endif /* GL_ARB_shadow_ambient */ /* -------------------------- GL_ARB_sparse_buffer ------------------------- */ #ifndef GL_ARB_sparse_buffer #define GL_ARB_sparse_buffer 1 #define GL_SPARSE_STORAGE_BIT_ARB 0x0400 #define GL_SPARSE_BUFFER_PAGE_SIZE_ARB 0x82F8 typedef void (GLAPIENTRY * PFNGLBUFFERPAGECOMMITMENTARBPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit); #define glBufferPageCommitmentARB GLEW_GET_FUN(__glewBufferPageCommitmentARB) #define GLEW_ARB_sparse_buffer GLEW_GET_VAR(__GLEW_ARB_sparse_buffer) #endif /* GL_ARB_sparse_buffer */ /* ------------------------- GL_ARB_sparse_texture ------------------------- */ #ifndef GL_ARB_sparse_texture #define GL_ARB_sparse_texture 1 #define GL_VIRTUAL_PAGE_SIZE_X_ARB 0x9195 #define GL_VIRTUAL_PAGE_SIZE_Y_ARB 0x9196 #define GL_VIRTUAL_PAGE_SIZE_Z_ARB 0x9197 #define GL_MAX_SPARSE_TEXTURE_SIZE_ARB 0x9198 #define GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB 0x9199 #define GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB 0x919A #define GL_TEXTURE_SPARSE_ARB 0x91A6 #define GL_VIRTUAL_PAGE_SIZE_INDEX_ARB 0x91A7 #define GL_NUM_VIRTUAL_PAGE_SIZES_ARB 0x91A8 #define GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB 0x91A9 #define GL_NUM_SPARSE_LEVELS_ARB 0x91AA typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); #define glTexPageCommitmentARB GLEW_GET_FUN(__glewTexPageCommitmentARB) #define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT) #define GLEW_ARB_sparse_texture GLEW_GET_VAR(__GLEW_ARB_sparse_texture) #endif /* GL_ARB_sparse_texture */ /* ------------------------- GL_ARB_sparse_texture2 ------------------------ */ #ifndef GL_ARB_sparse_texture2 #define GL_ARB_sparse_texture2 1 #define GLEW_ARB_sparse_texture2 GLEW_GET_VAR(__GLEW_ARB_sparse_texture2) #endif /* GL_ARB_sparse_texture2 */ /* ---------------------- GL_ARB_sparse_texture_clamp ---------------------- */ #ifndef GL_ARB_sparse_texture_clamp #define GL_ARB_sparse_texture_clamp 1 #define GLEW_ARB_sparse_texture_clamp GLEW_GET_VAR(__GLEW_ARB_sparse_texture_clamp) #endif /* GL_ARB_sparse_texture_clamp */ /* ------------------------ GL_ARB_stencil_texturing ----------------------- */ #ifndef GL_ARB_stencil_texturing #define GL_ARB_stencil_texturing 1 #define GL_DEPTH_STENCIL_TEXTURE_MODE 0x90EA #define GLEW_ARB_stencil_texturing GLEW_GET_VAR(__GLEW_ARB_stencil_texturing) #endif /* GL_ARB_stencil_texturing */ /* ------------------------------ GL_ARB_sync ------------------------------ */ #ifndef GL_ARB_sync #define GL_ARB_sync 1 #define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 #define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 #define GL_OBJECT_TYPE 0x9112 #define GL_SYNC_CONDITION 0x9113 #define GL_SYNC_STATUS 0x9114 #define GL_SYNC_FLAGS 0x9115 #define GL_SYNC_FENCE 0x9116 #define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 #define GL_UNSIGNALED 0x9118 #define GL_SIGNALED 0x9119 #define GL_ALREADY_SIGNALED 0x911A #define GL_TIMEOUT_EXPIRED 0x911B #define GL_CONDITION_SATISFIED 0x911C #define GL_WAIT_FAILED 0x911D #define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF typedef GLenum (GLAPIENTRY * PFNGLCLIENTWAITSYNCPROC) (GLsync GLsync,GLbitfield flags,GLuint64 timeout); typedef void (GLAPIENTRY * PFNGLDELETESYNCPROC) (GLsync GLsync); typedef GLsync (GLAPIENTRY * PFNGLFENCESYNCPROC) (GLenum condition,GLbitfield flags); typedef void (GLAPIENTRY * PFNGLGETINTEGER64VPROC) (GLenum pname, GLint64* params); typedef void (GLAPIENTRY * PFNGLGETSYNCIVPROC) (GLsync GLsync,GLenum pname,GLsizei bufSize,GLsizei* length, GLint *values); typedef GLboolean (GLAPIENTRY * PFNGLISSYNCPROC) (GLsync GLsync); typedef void (GLAPIENTRY * PFNGLWAITSYNCPROC) (GLsync GLsync,GLbitfield flags,GLuint64 timeout); #define glClientWaitSync GLEW_GET_FUN(__glewClientWaitSync) #define glDeleteSync GLEW_GET_FUN(__glewDeleteSync) #define glFenceSync GLEW_GET_FUN(__glewFenceSync) #define glGetInteger64v GLEW_GET_FUN(__glewGetInteger64v) #define glGetSynciv GLEW_GET_FUN(__glewGetSynciv) #define glIsSync GLEW_GET_FUN(__glewIsSync) #define glWaitSync GLEW_GET_FUN(__glewWaitSync) #define GLEW_ARB_sync GLEW_GET_VAR(__GLEW_ARB_sync) #endif /* GL_ARB_sync */ /* ----------------------- GL_ARB_tessellation_shader ---------------------- */ #ifndef GL_ARB_tessellation_shader #define GL_ARB_tessellation_shader 1 #define GL_PATCHES 0xE #define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER 0x84F0 #define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER 0x84F1 #define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C #define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D #define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E #define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F #define GL_PATCH_VERTICES 0x8E72 #define GL_PATCH_DEFAULT_INNER_LEVEL 0x8E73 #define GL_PATCH_DEFAULT_OUTER_LEVEL 0x8E74 #define GL_TESS_CONTROL_OUTPUT_VERTICES 0x8E75 #define GL_TESS_GEN_MODE 0x8E76 #define GL_TESS_GEN_SPACING 0x8E77 #define GL_TESS_GEN_VERTEX_ORDER 0x8E78 #define GL_TESS_GEN_POINT_MODE 0x8E79 #define GL_ISOLINES 0x8E7A #define GL_FRACTIONAL_ODD 0x8E7B #define GL_FRACTIONAL_EVEN 0x8E7C #define GL_MAX_PATCH_VERTICES 0x8E7D #define GL_MAX_TESS_GEN_LEVEL 0x8E7E #define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F #define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80 #define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81 #define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82 #define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83 #define GL_MAX_TESS_PATCH_COMPONENTS 0x8E84 #define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85 #define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86 #define GL_TESS_EVALUATION_SHADER 0x8E87 #define GL_TESS_CONTROL_SHADER 0x8E88 #define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89 #define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERFVPROC) (GLenum pname, const GLfloat* values); typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERIPROC) (GLenum pname, GLint value); #define glPatchParameterfv GLEW_GET_FUN(__glewPatchParameterfv) #define glPatchParameteri GLEW_GET_FUN(__glewPatchParameteri) #define GLEW_ARB_tessellation_shader GLEW_GET_VAR(__GLEW_ARB_tessellation_shader) #endif /* GL_ARB_tessellation_shader */ /* ------------------------- GL_ARB_texture_barrier ------------------------ */ #ifndef GL_ARB_texture_barrier #define GL_ARB_texture_barrier 1 typedef void (GLAPIENTRY * PFNGLTEXTUREBARRIERPROC) (void); #define glTextureBarrier GLEW_GET_FUN(__glewTextureBarrier) #define GLEW_ARB_texture_barrier GLEW_GET_VAR(__GLEW_ARB_texture_barrier) #endif /* GL_ARB_texture_barrier */ /* ---------------------- GL_ARB_texture_border_clamp ---------------------- */ #ifndef GL_ARB_texture_border_clamp #define GL_ARB_texture_border_clamp 1 #define GL_CLAMP_TO_BORDER_ARB 0x812D #define GLEW_ARB_texture_border_clamp GLEW_GET_VAR(__GLEW_ARB_texture_border_clamp) #endif /* GL_ARB_texture_border_clamp */ /* ---------------------- GL_ARB_texture_buffer_object --------------------- */ #ifndef GL_ARB_texture_buffer_object #define GL_ARB_texture_buffer_object 1 #define GL_TEXTURE_BUFFER_ARB 0x8C2A #define GL_MAX_TEXTURE_BUFFER_SIZE_ARB 0x8C2B #define GL_TEXTURE_BINDING_BUFFER_ARB 0x8C2C #define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB 0x8C2D #define GL_TEXTURE_BUFFER_FORMAT_ARB 0x8C2E typedef void (GLAPIENTRY * PFNGLTEXBUFFERARBPROC) (GLenum target, GLenum internalformat, GLuint buffer); #define glTexBufferARB GLEW_GET_FUN(__glewTexBufferARB) #define GLEW_ARB_texture_buffer_object GLEW_GET_VAR(__GLEW_ARB_texture_buffer_object) #endif /* GL_ARB_texture_buffer_object */ /* ------------------- GL_ARB_texture_buffer_object_rgb32 ------------------ */ #ifndef GL_ARB_texture_buffer_object_rgb32 #define GL_ARB_texture_buffer_object_rgb32 1 #define GLEW_ARB_texture_buffer_object_rgb32 GLEW_GET_VAR(__GLEW_ARB_texture_buffer_object_rgb32) #endif /* GL_ARB_texture_buffer_object_rgb32 */ /* ---------------------- GL_ARB_texture_buffer_range ---------------------- */ #ifndef GL_ARB_texture_buffer_range #define GL_ARB_texture_buffer_range 1 #define GL_TEXTURE_BUFFER_OFFSET 0x919D #define GL_TEXTURE_BUFFER_SIZE 0x919E #define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT 0x919F typedef void (GLAPIENTRY * PFNGLTEXBUFFERRANGEPROC) (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFERRANGEEXTPROC) (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); #define glTexBufferRange GLEW_GET_FUN(__glewTexBufferRange) #define glTextureBufferRangeEXT GLEW_GET_FUN(__glewTextureBufferRangeEXT) #define GLEW_ARB_texture_buffer_range GLEW_GET_VAR(__GLEW_ARB_texture_buffer_range) #endif /* GL_ARB_texture_buffer_range */ /* ----------------------- GL_ARB_texture_compression ---------------------- */ #ifndef GL_ARB_texture_compression #define GL_ARB_texture_compression 1 #define GL_COMPRESSED_ALPHA_ARB 0x84E9 #define GL_COMPRESSED_LUMINANCE_ARB 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB #define GL_COMPRESSED_INTENSITY_ARB 0x84EC #define GL_COMPRESSED_RGB_ARB 0x84ED #define GL_COMPRESSED_RGBA_ARB 0x84EE #define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0 #define GL_TEXTURE_COMPRESSED_ARB 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3 typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint lod, void *img); #define glCompressedTexImage1DARB GLEW_GET_FUN(__glewCompressedTexImage1DARB) #define glCompressedTexImage2DARB GLEW_GET_FUN(__glewCompressedTexImage2DARB) #define glCompressedTexImage3DARB GLEW_GET_FUN(__glewCompressedTexImage3DARB) #define glCompressedTexSubImage1DARB GLEW_GET_FUN(__glewCompressedTexSubImage1DARB) #define glCompressedTexSubImage2DARB GLEW_GET_FUN(__glewCompressedTexSubImage2DARB) #define glCompressedTexSubImage3DARB GLEW_GET_FUN(__glewCompressedTexSubImage3DARB) #define glGetCompressedTexImageARB GLEW_GET_FUN(__glewGetCompressedTexImageARB) #define GLEW_ARB_texture_compression GLEW_GET_VAR(__GLEW_ARB_texture_compression) #endif /* GL_ARB_texture_compression */ /* -------------------- GL_ARB_texture_compression_bptc -------------------- */ #ifndef GL_ARB_texture_compression_bptc #define GL_ARB_texture_compression_bptc 1 #define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB 0x8E8C #define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB 0x8E8D #define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB 0x8E8E #define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB 0x8E8F #define GLEW_ARB_texture_compression_bptc GLEW_GET_VAR(__GLEW_ARB_texture_compression_bptc) #endif /* GL_ARB_texture_compression_bptc */ /* -------------------- GL_ARB_texture_compression_rgtc -------------------- */ #ifndef GL_ARB_texture_compression_rgtc #define GL_ARB_texture_compression_rgtc 1 #define GL_COMPRESSED_RED_RGTC1 0x8DBB #define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC #define GL_COMPRESSED_RG_RGTC2 0x8DBD #define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE #define GLEW_ARB_texture_compression_rgtc GLEW_GET_VAR(__GLEW_ARB_texture_compression_rgtc) #endif /* GL_ARB_texture_compression_rgtc */ /* ------------------------ GL_ARB_texture_cube_map ------------------------ */ #ifndef GL_ARB_texture_cube_map #define GL_ARB_texture_cube_map 1 #define GL_NORMAL_MAP_ARB 0x8511 #define GL_REFLECTION_MAP_ARB 0x8512 #define GL_TEXTURE_CUBE_MAP_ARB 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C #define GLEW_ARB_texture_cube_map GLEW_GET_VAR(__GLEW_ARB_texture_cube_map) #endif /* GL_ARB_texture_cube_map */ /* --------------------- GL_ARB_texture_cube_map_array --------------------- */ #ifndef GL_ARB_texture_cube_map_array #define GL_ARB_texture_cube_map_array 1 #define GL_TEXTURE_CUBE_MAP_ARRAY_ARB 0x9009 #define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB 0x900A #define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB 0x900B #define GL_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900C #define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB 0x900D #define GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900E #define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB 0x900F #define GLEW_ARB_texture_cube_map_array GLEW_GET_VAR(__GLEW_ARB_texture_cube_map_array) #endif /* GL_ARB_texture_cube_map_array */ /* ------------------------- GL_ARB_texture_env_add ------------------------ */ #ifndef GL_ARB_texture_env_add #define GL_ARB_texture_env_add 1 #define GLEW_ARB_texture_env_add GLEW_GET_VAR(__GLEW_ARB_texture_env_add) #endif /* GL_ARB_texture_env_add */ /* ----------------------- GL_ARB_texture_env_combine ---------------------- */ #ifndef GL_ARB_texture_env_combine #define GL_ARB_texture_env_combine 1 #define GL_SUBTRACT_ARB 0x84E7 #define GL_COMBINE_ARB 0x8570 #define GL_COMBINE_RGB_ARB 0x8571 #define GL_COMBINE_ALPHA_ARB 0x8572 #define GL_RGB_SCALE_ARB 0x8573 #define GL_ADD_SIGNED_ARB 0x8574 #define GL_INTERPOLATE_ARB 0x8575 #define GL_CONSTANT_ARB 0x8576 #define GL_PRIMARY_COLOR_ARB 0x8577 #define GL_PREVIOUS_ARB 0x8578 #define GL_SOURCE0_RGB_ARB 0x8580 #define GL_SOURCE1_RGB_ARB 0x8581 #define GL_SOURCE2_RGB_ARB 0x8582 #define GL_SOURCE0_ALPHA_ARB 0x8588 #define GL_SOURCE1_ALPHA_ARB 0x8589 #define GL_SOURCE2_ALPHA_ARB 0x858A #define GL_OPERAND0_RGB_ARB 0x8590 #define GL_OPERAND1_RGB_ARB 0x8591 #define GL_OPERAND2_RGB_ARB 0x8592 #define GL_OPERAND0_ALPHA_ARB 0x8598 #define GL_OPERAND1_ALPHA_ARB 0x8599 #define GL_OPERAND2_ALPHA_ARB 0x859A #define GLEW_ARB_texture_env_combine GLEW_GET_VAR(__GLEW_ARB_texture_env_combine) #endif /* GL_ARB_texture_env_combine */ /* ---------------------- GL_ARB_texture_env_crossbar ---------------------- */ #ifndef GL_ARB_texture_env_crossbar #define GL_ARB_texture_env_crossbar 1 #define GLEW_ARB_texture_env_crossbar GLEW_GET_VAR(__GLEW_ARB_texture_env_crossbar) #endif /* GL_ARB_texture_env_crossbar */ /* ------------------------ GL_ARB_texture_env_dot3 ------------------------ */ #ifndef GL_ARB_texture_env_dot3 #define GL_ARB_texture_env_dot3 1 #define GL_DOT3_RGB_ARB 0x86AE #define GL_DOT3_RGBA_ARB 0x86AF #define GLEW_ARB_texture_env_dot3 GLEW_GET_VAR(__GLEW_ARB_texture_env_dot3) #endif /* GL_ARB_texture_env_dot3 */ /* ---------------------- GL_ARB_texture_filter_minmax --------------------- */ #ifndef GL_ARB_texture_filter_minmax #define GL_ARB_texture_filter_minmax 1 #define GL_TEXTURE_REDUCTION_MODE_ARB 0x9366 #define GL_WEIGHTED_AVERAGE_ARB 0x9367 #define GLEW_ARB_texture_filter_minmax GLEW_GET_VAR(__GLEW_ARB_texture_filter_minmax) #endif /* GL_ARB_texture_filter_minmax */ /* -------------------------- GL_ARB_texture_float ------------------------- */ #ifndef GL_ARB_texture_float #define GL_ARB_texture_float 1 #define GL_RGBA32F_ARB 0x8814 #define GL_RGB32F_ARB 0x8815 #define GL_ALPHA32F_ARB 0x8816 #define GL_INTENSITY32F_ARB 0x8817 #define GL_LUMINANCE32F_ARB 0x8818 #define GL_LUMINANCE_ALPHA32F_ARB 0x8819 #define GL_RGBA16F_ARB 0x881A #define GL_RGB16F_ARB 0x881B #define GL_ALPHA16F_ARB 0x881C #define GL_INTENSITY16F_ARB 0x881D #define GL_LUMINANCE16F_ARB 0x881E #define GL_LUMINANCE_ALPHA16F_ARB 0x881F #define GL_TEXTURE_RED_TYPE_ARB 0x8C10 #define GL_TEXTURE_GREEN_TYPE_ARB 0x8C11 #define GL_TEXTURE_BLUE_TYPE_ARB 0x8C12 #define GL_TEXTURE_ALPHA_TYPE_ARB 0x8C13 #define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x8C14 #define GL_TEXTURE_INTENSITY_TYPE_ARB 0x8C15 #define GL_TEXTURE_DEPTH_TYPE_ARB 0x8C16 #define GL_UNSIGNED_NORMALIZED_ARB 0x8C17 #define GLEW_ARB_texture_float GLEW_GET_VAR(__GLEW_ARB_texture_float) #endif /* GL_ARB_texture_float */ /* ------------------------- GL_ARB_texture_gather ------------------------- */ #ifndef GL_ARB_texture_gather #define GL_ARB_texture_gather 1 #define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5E #define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB 0x8E5F #define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB 0x8F9F #define GLEW_ARB_texture_gather GLEW_GET_VAR(__GLEW_ARB_texture_gather) #endif /* GL_ARB_texture_gather */ /* ------------------ GL_ARB_texture_mirror_clamp_to_edge ------------------ */ #ifndef GL_ARB_texture_mirror_clamp_to_edge #define GL_ARB_texture_mirror_clamp_to_edge 1 #define GL_MIRROR_CLAMP_TO_EDGE 0x8743 #define GLEW_ARB_texture_mirror_clamp_to_edge GLEW_GET_VAR(__GLEW_ARB_texture_mirror_clamp_to_edge) #endif /* GL_ARB_texture_mirror_clamp_to_edge */ /* --------------------- GL_ARB_texture_mirrored_repeat -------------------- */ #ifndef GL_ARB_texture_mirrored_repeat #define GL_ARB_texture_mirrored_repeat 1 #define GL_MIRRORED_REPEAT_ARB 0x8370 #define GLEW_ARB_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_ARB_texture_mirrored_repeat) #endif /* GL_ARB_texture_mirrored_repeat */ /* ----------------------- GL_ARB_texture_multisample ---------------------- */ #ifndef GL_ARB_texture_multisample #define GL_ARB_texture_multisample 1 #define GL_SAMPLE_POSITION 0x8E50 #define GL_SAMPLE_MASK 0x8E51 #define GL_SAMPLE_MASK_VALUE 0x8E52 #define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 #define GL_TEXTURE_2D_MULTISAMPLE 0x9100 #define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 #define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 #define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 #define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 #define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 #define GL_TEXTURE_SAMPLES 0x9106 #define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 #define GL_SAMPLER_2D_MULTISAMPLE 0x9108 #define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 #define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A #define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B #define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C #define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D #define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E #define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F #define GL_MAX_INTEGER_SAMPLES 0x9110 typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVPROC) (GLenum pname, GLuint index, GLfloat* val); typedef void (GLAPIENTRY * PFNGLSAMPLEMASKIPROC) (GLuint index, GLbitfield mask); typedef void (GLAPIENTRY * PFNGLTEXIMAGE2DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); #define glGetMultisamplefv GLEW_GET_FUN(__glewGetMultisamplefv) #define glSampleMaski GLEW_GET_FUN(__glewSampleMaski) #define glTexImage2DMultisample GLEW_GET_FUN(__glewTexImage2DMultisample) #define glTexImage3DMultisample GLEW_GET_FUN(__glewTexImage3DMultisample) #define GLEW_ARB_texture_multisample GLEW_GET_VAR(__GLEW_ARB_texture_multisample) #endif /* GL_ARB_texture_multisample */ /* -------------------- GL_ARB_texture_non_power_of_two -------------------- */ #ifndef GL_ARB_texture_non_power_of_two #define GL_ARB_texture_non_power_of_two 1 #define GLEW_ARB_texture_non_power_of_two GLEW_GET_VAR(__GLEW_ARB_texture_non_power_of_two) #endif /* GL_ARB_texture_non_power_of_two */ /* ---------------------- GL_ARB_texture_query_levels ---------------------- */ #ifndef GL_ARB_texture_query_levels #define GL_ARB_texture_query_levels 1 #define GLEW_ARB_texture_query_levels GLEW_GET_VAR(__GLEW_ARB_texture_query_levels) #endif /* GL_ARB_texture_query_levels */ /* ------------------------ GL_ARB_texture_query_lod ----------------------- */ #ifndef GL_ARB_texture_query_lod #define GL_ARB_texture_query_lod 1 #define GLEW_ARB_texture_query_lod GLEW_GET_VAR(__GLEW_ARB_texture_query_lod) #endif /* GL_ARB_texture_query_lod */ /* ------------------------ GL_ARB_texture_rectangle ----------------------- */ #ifndef GL_ARB_texture_rectangle #define GL_ARB_texture_rectangle 1 #define GL_TEXTURE_RECTANGLE_ARB 0x84F5 #define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6 #define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 #define GL_SAMPLER_2D_RECT_ARB 0x8B63 #define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 #define GLEW_ARB_texture_rectangle GLEW_GET_VAR(__GLEW_ARB_texture_rectangle) #endif /* GL_ARB_texture_rectangle */ /* --------------------------- GL_ARB_texture_rg --------------------------- */ #ifndef GL_ARB_texture_rg #define GL_ARB_texture_rg 1 #define GL_COMPRESSED_RED 0x8225 #define GL_COMPRESSED_RG 0x8226 #define GL_RG 0x8227 #define GL_RG_INTEGER 0x8228 #define GL_R8 0x8229 #define GL_R16 0x822A #define GL_RG8 0x822B #define GL_RG16 0x822C #define GL_R16F 0x822D #define GL_R32F 0x822E #define GL_RG16F 0x822F #define GL_RG32F 0x8230 #define GL_R8I 0x8231 #define GL_R8UI 0x8232 #define GL_R16I 0x8233 #define GL_R16UI 0x8234 #define GL_R32I 0x8235 #define GL_R32UI 0x8236 #define GL_RG8I 0x8237 #define GL_RG8UI 0x8238 #define GL_RG16I 0x8239 #define GL_RG16UI 0x823A #define GL_RG32I 0x823B #define GL_RG32UI 0x823C #define GLEW_ARB_texture_rg GLEW_GET_VAR(__GLEW_ARB_texture_rg) #endif /* GL_ARB_texture_rg */ /* ----------------------- GL_ARB_texture_rgb10_a2ui ----------------------- */ #ifndef GL_ARB_texture_rgb10_a2ui #define GL_ARB_texture_rgb10_a2ui 1 #define GL_RGB10_A2UI 0x906F #define GLEW_ARB_texture_rgb10_a2ui GLEW_GET_VAR(__GLEW_ARB_texture_rgb10_a2ui) #endif /* GL_ARB_texture_rgb10_a2ui */ /* ------------------------ GL_ARB_texture_stencil8 ------------------------ */ #ifndef GL_ARB_texture_stencil8 #define GL_ARB_texture_stencil8 1 #define GL_STENCIL_INDEX 0x1901 #define GL_STENCIL_INDEX8 0x8D48 #define GLEW_ARB_texture_stencil8 GLEW_GET_VAR(__GLEW_ARB_texture_stencil8) #endif /* GL_ARB_texture_stencil8 */ /* ------------------------- GL_ARB_texture_storage ------------------------ */ #ifndef GL_ARB_texture_storage #define GL_ARB_texture_storage 1 #define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F typedef void (GLAPIENTRY * PFNGLTEXSTORAGE1DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); typedef void (GLAPIENTRY * PFNGLTEXSTORAGE2DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLTEXSTORAGE3DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); #define glTexStorage1D GLEW_GET_FUN(__glewTexStorage1D) #define glTexStorage2D GLEW_GET_FUN(__glewTexStorage2D) #define glTexStorage3D GLEW_GET_FUN(__glewTexStorage3D) #define glTextureStorage1DEXT GLEW_GET_FUN(__glewTextureStorage1DEXT) #define glTextureStorage2DEXT GLEW_GET_FUN(__glewTextureStorage2DEXT) #define glTextureStorage3DEXT GLEW_GET_FUN(__glewTextureStorage3DEXT) #define GLEW_ARB_texture_storage GLEW_GET_VAR(__GLEW_ARB_texture_storage) #endif /* GL_ARB_texture_storage */ /* ------------------- GL_ARB_texture_storage_multisample ------------------ */ #ifndef GL_ARB_texture_storage_multisample #define GL_ARB_texture_storage_multisample 1 typedef void (GLAPIENTRY * PFNGLTEXSTORAGE2DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); typedef void (GLAPIENTRY * PFNGLTEXSTORAGE3DMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC) (GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC) (GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); #define glTexStorage2DMultisample GLEW_GET_FUN(__glewTexStorage2DMultisample) #define glTexStorage3DMultisample GLEW_GET_FUN(__glewTexStorage3DMultisample) #define glTextureStorage2DMultisampleEXT GLEW_GET_FUN(__glewTextureStorage2DMultisampleEXT) #define glTextureStorage3DMultisampleEXT GLEW_GET_FUN(__glewTextureStorage3DMultisampleEXT) #define GLEW_ARB_texture_storage_multisample GLEW_GET_VAR(__GLEW_ARB_texture_storage_multisample) #endif /* GL_ARB_texture_storage_multisample */ /* ------------------------- GL_ARB_texture_swizzle ------------------------ */ #ifndef GL_ARB_texture_swizzle #define GL_ARB_texture_swizzle 1 #define GL_TEXTURE_SWIZZLE_R 0x8E42 #define GL_TEXTURE_SWIZZLE_G 0x8E43 #define GL_TEXTURE_SWIZZLE_B 0x8E44 #define GL_TEXTURE_SWIZZLE_A 0x8E45 #define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 #define GLEW_ARB_texture_swizzle GLEW_GET_VAR(__GLEW_ARB_texture_swizzle) #endif /* GL_ARB_texture_swizzle */ /* -------------------------- GL_ARB_texture_view -------------------------- */ #ifndef GL_ARB_texture_view #define GL_ARB_texture_view 1 #define GL_TEXTURE_VIEW_MIN_LEVEL 0x82DB #define GL_TEXTURE_VIEW_NUM_LEVELS 0x82DC #define GL_TEXTURE_VIEW_MIN_LAYER 0x82DD #define GL_TEXTURE_VIEW_NUM_LAYERS 0x82DE #define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF typedef void (GLAPIENTRY * PFNGLTEXTUREVIEWPROC) (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); #define glTextureView GLEW_GET_FUN(__glewTextureView) #define GLEW_ARB_texture_view GLEW_GET_VAR(__GLEW_ARB_texture_view) #endif /* GL_ARB_texture_view */ /* --------------------------- GL_ARB_timer_query -------------------------- */ #ifndef GL_ARB_timer_query #define GL_ARB_timer_query 1 #define GL_TIME_ELAPSED 0x88BF #define GL_TIMESTAMP 0x8E28 typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VPROC) (GLuint id, GLenum pname, GLint64* params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VPROC) (GLuint id, GLenum pname, GLuint64* params); typedef void (GLAPIENTRY * PFNGLQUERYCOUNTERPROC) (GLuint id, GLenum target); #define glGetQueryObjecti64v GLEW_GET_FUN(__glewGetQueryObjecti64v) #define glGetQueryObjectui64v GLEW_GET_FUN(__glewGetQueryObjectui64v) #define glQueryCounter GLEW_GET_FUN(__glewQueryCounter) #define GLEW_ARB_timer_query GLEW_GET_VAR(__GLEW_ARB_timer_query) #endif /* GL_ARB_timer_query */ /* ----------------------- GL_ARB_transform_feedback2 ---------------------- */ #ifndef GL_ARB_transform_feedback2 #define GL_ARB_transform_feedback2 1 #define GL_TRANSFORM_FEEDBACK 0x8E22 #define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23 #define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24 #define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25 typedef void (GLAPIENTRY * PFNGLBINDTRANSFORMFEEDBACKPROC) (GLenum target, GLuint id); typedef void (GLAPIENTRY * PFNGLDELETETRANSFORMFEEDBACKSPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKPROC) (GLenum mode, GLuint id); typedef void (GLAPIENTRY * PFNGLGENTRANSFORMFEEDBACKSPROC) (GLsizei n, GLuint* ids); typedef GLboolean (GLAPIENTRY * PFNGLISTRANSFORMFEEDBACKPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLPAUSETRANSFORMFEEDBACKPROC) (void); typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKPROC) (void); #define glBindTransformFeedback GLEW_GET_FUN(__glewBindTransformFeedback) #define glDeleteTransformFeedbacks GLEW_GET_FUN(__glewDeleteTransformFeedbacks) #define glDrawTransformFeedback GLEW_GET_FUN(__glewDrawTransformFeedback) #define glGenTransformFeedbacks GLEW_GET_FUN(__glewGenTransformFeedbacks) #define glIsTransformFeedback GLEW_GET_FUN(__glewIsTransformFeedback) #define glPauseTransformFeedback GLEW_GET_FUN(__glewPauseTransformFeedback) #define glResumeTransformFeedback GLEW_GET_FUN(__glewResumeTransformFeedback) #define GLEW_ARB_transform_feedback2 GLEW_GET_VAR(__GLEW_ARB_transform_feedback2) #endif /* GL_ARB_transform_feedback2 */ /* ----------------------- GL_ARB_transform_feedback3 ---------------------- */ #ifndef GL_ARB_transform_feedback3 #define GL_ARB_transform_feedback3 1 #define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS 0x8E70 #define GL_MAX_VERTEX_STREAMS 0x8E71 typedef void (GLAPIENTRY * PFNGLBEGINQUERYINDEXEDPROC) (GLenum target, GLuint index, GLuint id); typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC) (GLenum mode, GLuint id, GLuint stream); typedef void (GLAPIENTRY * PFNGLENDQUERYINDEXEDPROC) (GLenum target, GLuint index); typedef void (GLAPIENTRY * PFNGLGETQUERYINDEXEDIVPROC) (GLenum target, GLuint index, GLenum pname, GLint* params); #define glBeginQueryIndexed GLEW_GET_FUN(__glewBeginQueryIndexed) #define glDrawTransformFeedbackStream GLEW_GET_FUN(__glewDrawTransformFeedbackStream) #define glEndQueryIndexed GLEW_GET_FUN(__glewEndQueryIndexed) #define glGetQueryIndexediv GLEW_GET_FUN(__glewGetQueryIndexediv) #define GLEW_ARB_transform_feedback3 GLEW_GET_VAR(__GLEW_ARB_transform_feedback3) #endif /* GL_ARB_transform_feedback3 */ /* ------------------ GL_ARB_transform_feedback_instanced ------------------ */ #ifndef GL_ARB_transform_feedback_instanced #define GL_ARB_transform_feedback_instanced 1 typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC) (GLenum mode, GLuint id, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC) (GLenum mode, GLuint id, GLuint stream, GLsizei primcount); #define glDrawTransformFeedbackInstanced GLEW_GET_FUN(__glewDrawTransformFeedbackInstanced) #define glDrawTransformFeedbackStreamInstanced GLEW_GET_FUN(__glewDrawTransformFeedbackStreamInstanced) #define GLEW_ARB_transform_feedback_instanced GLEW_GET_VAR(__GLEW_ARB_transform_feedback_instanced) #endif /* GL_ARB_transform_feedback_instanced */ /* ---------------- GL_ARB_transform_feedback_overflow_query --------------- */ #ifndef GL_ARB_transform_feedback_overflow_query #define GL_ARB_transform_feedback_overflow_query 1 #define GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB 0x82EC #define GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB 0x82ED #define GLEW_ARB_transform_feedback_overflow_query GLEW_GET_VAR(__GLEW_ARB_transform_feedback_overflow_query) #endif /* GL_ARB_transform_feedback_overflow_query */ /* ------------------------ GL_ARB_transpose_matrix ------------------------ */ #ifndef GL_ARB_transpose_matrix #define GL_ARB_transpose_matrix 1 #define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX_ARB 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX_ARB 0x84E6 typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (GLdouble m[16]); typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]); typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (GLdouble m[16]); typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]); #define glLoadTransposeMatrixdARB GLEW_GET_FUN(__glewLoadTransposeMatrixdARB) #define glLoadTransposeMatrixfARB GLEW_GET_FUN(__glewLoadTransposeMatrixfARB) #define glMultTransposeMatrixdARB GLEW_GET_FUN(__glewMultTransposeMatrixdARB) #define glMultTransposeMatrixfARB GLEW_GET_FUN(__glewMultTransposeMatrixfARB) #define GLEW_ARB_transpose_matrix GLEW_GET_VAR(__GLEW_ARB_transpose_matrix) #endif /* GL_ARB_transpose_matrix */ /* ---------------------- GL_ARB_uniform_buffer_object --------------------- */ #ifndef GL_ARB_uniform_buffer_object #define GL_ARB_uniform_buffer_object 1 #define GL_UNIFORM_BUFFER 0x8A11 #define GL_UNIFORM_BUFFER_BINDING 0x8A28 #define GL_UNIFORM_BUFFER_START 0x8A29 #define GL_UNIFORM_BUFFER_SIZE 0x8A2A #define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B #define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C #define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D #define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E #define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F #define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 #define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 #define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 #define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 #define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 #define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 #define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 #define GL_UNIFORM_TYPE 0x8A37 #define GL_UNIFORM_SIZE 0x8A38 #define GL_UNIFORM_NAME_LENGTH 0x8A39 #define GL_UNIFORM_BLOCK_INDEX 0x8A3A #define GL_UNIFORM_OFFSET 0x8A3B #define GL_UNIFORM_ARRAY_STRIDE 0x8A3C #define GL_UNIFORM_MATRIX_STRIDE 0x8A3D #define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E #define GL_UNIFORM_BLOCK_BINDING 0x8A3F #define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 #define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 #define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 #define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 #define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 #define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 #define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 #define GL_INVALID_INDEX 0xFFFFFFFF typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer); typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName); typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMBLOCKIVPROC) (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMNAMEPROC) (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName); typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMSIVPROC) (GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint* data); typedef GLuint (GLAPIENTRY * PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const GLchar* uniformBlockName); typedef void (GLAPIENTRY * PFNGLGETUNIFORMINDICESPROC) (GLuint program, GLsizei uniformCount, const GLchar* const * uniformNames, GLuint* uniformIndices); typedef void (GLAPIENTRY * PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); #define glBindBufferBase GLEW_GET_FUN(__glewBindBufferBase) #define glBindBufferRange GLEW_GET_FUN(__glewBindBufferRange) #define glGetActiveUniformBlockName GLEW_GET_FUN(__glewGetActiveUniformBlockName) #define glGetActiveUniformBlockiv GLEW_GET_FUN(__glewGetActiveUniformBlockiv) #define glGetActiveUniformName GLEW_GET_FUN(__glewGetActiveUniformName) #define glGetActiveUniformsiv GLEW_GET_FUN(__glewGetActiveUniformsiv) #define glGetIntegeri_v GLEW_GET_FUN(__glewGetIntegeri_v) #define glGetUniformBlockIndex GLEW_GET_FUN(__glewGetUniformBlockIndex) #define glGetUniformIndices GLEW_GET_FUN(__glewGetUniformIndices) #define glUniformBlockBinding GLEW_GET_FUN(__glewUniformBlockBinding) #define GLEW_ARB_uniform_buffer_object GLEW_GET_VAR(__GLEW_ARB_uniform_buffer_object) #endif /* GL_ARB_uniform_buffer_object */ /* ------------------------ GL_ARB_vertex_array_bgra ----------------------- */ #ifndef GL_ARB_vertex_array_bgra #define GL_ARB_vertex_array_bgra 1 #define GL_BGRA 0x80E1 #define GLEW_ARB_vertex_array_bgra GLEW_GET_VAR(__GLEW_ARB_vertex_array_bgra) #endif /* GL_ARB_vertex_array_bgra */ /* ----------------------- GL_ARB_vertex_array_object ---------------------- */ #ifndef GL_ARB_vertex_array_object #define GL_ARB_vertex_array_object 1 #define GL_VERTEX_ARRAY_BINDING 0x85B5 typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYPROC) (GLuint array); typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint* arrays); typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint* arrays); typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYPROC) (GLuint array); #define glBindVertexArray GLEW_GET_FUN(__glewBindVertexArray) #define glDeleteVertexArrays GLEW_GET_FUN(__glewDeleteVertexArrays) #define glGenVertexArrays GLEW_GET_FUN(__glewGenVertexArrays) #define glIsVertexArray GLEW_GET_FUN(__glewIsVertexArray) #define GLEW_ARB_vertex_array_object GLEW_GET_VAR(__GLEW_ARB_vertex_array_object) #endif /* GL_ARB_vertex_array_object */ /* ----------------------- GL_ARB_vertex_attrib_64bit ---------------------- */ #ifndef GL_ARB_vertex_attrib_64bit #define GL_ARB_vertex_attrib_64bit 1 typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLDVPROC) (GLuint index, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DPROC) (GLuint index, GLdouble x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLPOINTERPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer); #define glGetVertexAttribLdv GLEW_GET_FUN(__glewGetVertexAttribLdv) #define glVertexAttribL1d GLEW_GET_FUN(__glewVertexAttribL1d) #define glVertexAttribL1dv GLEW_GET_FUN(__glewVertexAttribL1dv) #define glVertexAttribL2d GLEW_GET_FUN(__glewVertexAttribL2d) #define glVertexAttribL2dv GLEW_GET_FUN(__glewVertexAttribL2dv) #define glVertexAttribL3d GLEW_GET_FUN(__glewVertexAttribL3d) #define glVertexAttribL3dv GLEW_GET_FUN(__glewVertexAttribL3dv) #define glVertexAttribL4d GLEW_GET_FUN(__glewVertexAttribL4d) #define glVertexAttribL4dv GLEW_GET_FUN(__glewVertexAttribL4dv) #define glVertexAttribLPointer GLEW_GET_FUN(__glewVertexAttribLPointer) #define GLEW_ARB_vertex_attrib_64bit GLEW_GET_VAR(__GLEW_ARB_vertex_attrib_64bit) #endif /* GL_ARB_vertex_attrib_64bit */ /* ---------------------- GL_ARB_vertex_attrib_binding --------------------- */ #ifndef GL_ARB_vertex_attrib_binding #define GL_ARB_vertex_attrib_binding 1 #define GL_VERTEX_ATTRIB_BINDING 0x82D4 #define GL_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D5 #define GL_VERTEX_BINDING_DIVISOR 0x82D6 #define GL_VERTEX_BINDING_OFFSET 0x82D7 #define GL_VERTEX_BINDING_STRIDE 0x82D8 #define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D9 #define GL_MAX_VERTEX_ATTRIB_BINDINGS 0x82DA #define GL_VERTEX_BINDING_BUFFER 0x8F4F typedef void (GLAPIENTRY * PFNGLBINDVERTEXBUFFERPROC) (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC) (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC) (GLuint vaobj, GLuint attribindex, GLuint bindingindex); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC) (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC) (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC) (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC) (GLuint vaobj, GLuint bindingindex, GLuint divisor); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBBINDINGPROC) (GLuint attribindex, GLuint bindingindex); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBFORMATPROC) (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIFORMATPROC) (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLFORMATPROC) (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); typedef void (GLAPIENTRY * PFNGLVERTEXBINDINGDIVISORPROC) (GLuint bindingindex, GLuint divisor); #define glBindVertexBuffer GLEW_GET_FUN(__glewBindVertexBuffer) #define glVertexArrayBindVertexBufferEXT GLEW_GET_FUN(__glewVertexArrayBindVertexBufferEXT) #define glVertexArrayVertexAttribBindingEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribBindingEXT) #define glVertexArrayVertexAttribFormatEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribFormatEXT) #define glVertexArrayVertexAttribIFormatEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribIFormatEXT) #define glVertexArrayVertexAttribLFormatEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribLFormatEXT) #define glVertexArrayVertexBindingDivisorEXT GLEW_GET_FUN(__glewVertexArrayVertexBindingDivisorEXT) #define glVertexAttribBinding GLEW_GET_FUN(__glewVertexAttribBinding) #define glVertexAttribFormat GLEW_GET_FUN(__glewVertexAttribFormat) #define glVertexAttribIFormat GLEW_GET_FUN(__glewVertexAttribIFormat) #define glVertexAttribLFormat GLEW_GET_FUN(__glewVertexAttribLFormat) #define glVertexBindingDivisor GLEW_GET_FUN(__glewVertexBindingDivisor) #define GLEW_ARB_vertex_attrib_binding GLEW_GET_VAR(__GLEW_ARB_vertex_attrib_binding) #endif /* GL_ARB_vertex_attrib_binding */ /* -------------------------- GL_ARB_vertex_blend -------------------------- */ #ifndef GL_ARB_vertex_blend #define GL_ARB_vertex_blend 1 #define GL_MODELVIEW0_ARB 0x1700 #define GL_MODELVIEW1_ARB 0x850A #define GL_MAX_VERTEX_UNITS_ARB 0x86A4 #define GL_ACTIVE_VERTEX_UNITS_ARB 0x86A5 #define GL_WEIGHT_SUM_UNITY_ARB 0x86A6 #define GL_VERTEX_BLEND_ARB 0x86A7 #define GL_CURRENT_WEIGHT_ARB 0x86A8 #define GL_WEIGHT_ARRAY_TYPE_ARB 0x86A9 #define GL_WEIGHT_ARRAY_STRIDE_ARB 0x86AA #define GL_WEIGHT_ARRAY_SIZE_ARB 0x86AB #define GL_WEIGHT_ARRAY_POINTER_ARB 0x86AC #define GL_WEIGHT_ARRAY_ARB 0x86AD #define GL_MODELVIEW2_ARB 0x8722 #define GL_MODELVIEW3_ARB 0x8723 #define GL_MODELVIEW4_ARB 0x8724 #define GL_MODELVIEW5_ARB 0x8725 #define GL_MODELVIEW6_ARB 0x8726 #define GL_MODELVIEW7_ARB 0x8727 #define GL_MODELVIEW8_ARB 0x8728 #define GL_MODELVIEW9_ARB 0x8729 #define GL_MODELVIEW10_ARB 0x872A #define GL_MODELVIEW11_ARB 0x872B #define GL_MODELVIEW12_ARB 0x872C #define GL_MODELVIEW13_ARB 0x872D #define GL_MODELVIEW14_ARB 0x872E #define GL_MODELVIEW15_ARB 0x872F #define GL_MODELVIEW16_ARB 0x8730 #define GL_MODELVIEW17_ARB 0x8731 #define GL_MODELVIEW18_ARB 0x8732 #define GL_MODELVIEW19_ARB 0x8733 #define GL_MODELVIEW20_ARB 0x8734 #define GL_MODELVIEW21_ARB 0x8735 #define GL_MODELVIEW22_ARB 0x8736 #define GL_MODELVIEW23_ARB 0x8737 #define GL_MODELVIEW24_ARB 0x8738 #define GL_MODELVIEW25_ARB 0x8739 #define GL_MODELVIEW26_ARB 0x873A #define GL_MODELVIEW27_ARB 0x873B #define GL_MODELVIEW28_ARB 0x873C #define GL_MODELVIEW29_ARB 0x873D #define GL_MODELVIEW30_ARB 0x873E #define GL_MODELVIEW31_ARB 0x873F typedef void (GLAPIENTRY * PFNGLVERTEXBLENDARBPROC) (GLint count); typedef void (GLAPIENTRY * PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); typedef void (GLAPIENTRY * PFNGLWEIGHTBVARBPROC) (GLint size, GLbyte *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTDVARBPROC) (GLint size, GLdouble *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTFVARBPROC) (GLint size, GLfloat *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTIVARBPROC) (GLint size, GLint *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTSVARBPROC) (GLint size, GLshort *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTUBVARBPROC) (GLint size, GLubyte *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTUIVARBPROC) (GLint size, GLuint *weights); typedef void (GLAPIENTRY * PFNGLWEIGHTUSVARBPROC) (GLint size, GLushort *weights); #define glVertexBlendARB GLEW_GET_FUN(__glewVertexBlendARB) #define glWeightPointerARB GLEW_GET_FUN(__glewWeightPointerARB) #define glWeightbvARB GLEW_GET_FUN(__glewWeightbvARB) #define glWeightdvARB GLEW_GET_FUN(__glewWeightdvARB) #define glWeightfvARB GLEW_GET_FUN(__glewWeightfvARB) #define glWeightivARB GLEW_GET_FUN(__glewWeightivARB) #define glWeightsvARB GLEW_GET_FUN(__glewWeightsvARB) #define glWeightubvARB GLEW_GET_FUN(__glewWeightubvARB) #define glWeightuivARB GLEW_GET_FUN(__glewWeightuivARB) #define glWeightusvARB GLEW_GET_FUN(__glewWeightusvARB) #define GLEW_ARB_vertex_blend GLEW_GET_VAR(__GLEW_ARB_vertex_blend) #endif /* GL_ARB_vertex_blend */ /* ---------------------- GL_ARB_vertex_buffer_object ---------------------- */ #ifndef GL_ARB_vertex_buffer_object #define GL_ARB_vertex_buffer_object 1 #define GL_BUFFER_SIZE_ARB 0x8764 #define GL_BUFFER_USAGE_ARB 0x8765 #define GL_ARRAY_BUFFER_ARB 0x8892 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893 #define GL_ARRAY_BUFFER_BINDING_ARB 0x8894 #define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895 #define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896 #define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897 #define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898 #define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D #define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F #define GL_READ_ONLY_ARB 0x88B8 #define GL_WRITE_ONLY_ARB 0x88B9 #define GL_READ_WRITE_ARB 0x88BA #define GL_BUFFER_ACCESS_ARB 0x88BB #define GL_BUFFER_MAPPED_ARB 0x88BC #define GL_BUFFER_MAP_POINTER_ARB 0x88BD #define GL_STREAM_DRAW_ARB 0x88E0 #define GL_STREAM_READ_ARB 0x88E1 #define GL_STREAM_COPY_ARB 0x88E2 #define GL_STATIC_DRAW_ARB 0x88E4 #define GL_STATIC_READ_ARB 0x88E5 #define GL_STATIC_COPY_ARB 0x88E6 #define GL_DYNAMIC_DRAW_ARB 0x88E8 #define GL_DYNAMIC_READ_ARB 0x88E9 #define GL_DYNAMIC_COPY_ARB 0x88EA typedef ptrdiff_t GLintptrARB; typedef ptrdiff_t GLsizeiptrARB; typedef void (GLAPIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); typedef void (GLAPIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const void *data, GLenum usage); typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data); typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint* buffers); typedef void (GLAPIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint* buffers); typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, void** params); typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data); typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERARBPROC) (GLuint buffer); typedef void * (GLAPIENTRY * PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERARBPROC) (GLenum target); #define glBindBufferARB GLEW_GET_FUN(__glewBindBufferARB) #define glBufferDataARB GLEW_GET_FUN(__glewBufferDataARB) #define glBufferSubDataARB GLEW_GET_FUN(__glewBufferSubDataARB) #define glDeleteBuffersARB GLEW_GET_FUN(__glewDeleteBuffersARB) #define glGenBuffersARB GLEW_GET_FUN(__glewGenBuffersARB) #define glGetBufferParameterivARB GLEW_GET_FUN(__glewGetBufferParameterivARB) #define glGetBufferPointervARB GLEW_GET_FUN(__glewGetBufferPointervARB) #define glGetBufferSubDataARB GLEW_GET_FUN(__glewGetBufferSubDataARB) #define glIsBufferARB GLEW_GET_FUN(__glewIsBufferARB) #define glMapBufferARB GLEW_GET_FUN(__glewMapBufferARB) #define glUnmapBufferARB GLEW_GET_FUN(__glewUnmapBufferARB) #define GLEW_ARB_vertex_buffer_object GLEW_GET_VAR(__GLEW_ARB_vertex_buffer_object) #endif /* GL_ARB_vertex_buffer_object */ /* ------------------------- GL_ARB_vertex_program ------------------------- */ #ifndef GL_ARB_vertex_program #define GL_ARB_vertex_program 1 #define GL_COLOR_SUM_ARB 0x8458 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF typedef void (GLAPIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint* programs); typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (GLAPIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint* programs); typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, void *string); typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, void** pointer); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const void *string); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); #define glBindProgramARB GLEW_GET_FUN(__glewBindProgramARB) #define glDeleteProgramsARB GLEW_GET_FUN(__glewDeleteProgramsARB) #define glDisableVertexAttribArrayARB GLEW_GET_FUN(__glewDisableVertexAttribArrayARB) #define glEnableVertexAttribArrayARB GLEW_GET_FUN(__glewEnableVertexAttribArrayARB) #define glGenProgramsARB GLEW_GET_FUN(__glewGenProgramsARB) #define glGetProgramEnvParameterdvARB GLEW_GET_FUN(__glewGetProgramEnvParameterdvARB) #define glGetProgramEnvParameterfvARB GLEW_GET_FUN(__glewGetProgramEnvParameterfvARB) #define glGetProgramLocalParameterdvARB GLEW_GET_FUN(__glewGetProgramLocalParameterdvARB) #define glGetProgramLocalParameterfvARB GLEW_GET_FUN(__glewGetProgramLocalParameterfvARB) #define glGetProgramStringARB GLEW_GET_FUN(__glewGetProgramStringARB) #define glGetProgramivARB GLEW_GET_FUN(__glewGetProgramivARB) #define glGetVertexAttribPointervARB GLEW_GET_FUN(__glewGetVertexAttribPointervARB) #define glGetVertexAttribdvARB GLEW_GET_FUN(__glewGetVertexAttribdvARB) #define glGetVertexAttribfvARB GLEW_GET_FUN(__glewGetVertexAttribfvARB) #define glGetVertexAttribivARB GLEW_GET_FUN(__glewGetVertexAttribivARB) #define glIsProgramARB GLEW_GET_FUN(__glewIsProgramARB) #define glProgramEnvParameter4dARB GLEW_GET_FUN(__glewProgramEnvParameter4dARB) #define glProgramEnvParameter4dvARB GLEW_GET_FUN(__glewProgramEnvParameter4dvARB) #define glProgramEnvParameter4fARB GLEW_GET_FUN(__glewProgramEnvParameter4fARB) #define glProgramEnvParameter4fvARB GLEW_GET_FUN(__glewProgramEnvParameter4fvARB) #define glProgramLocalParameter4dARB GLEW_GET_FUN(__glewProgramLocalParameter4dARB) #define glProgramLocalParameter4dvARB GLEW_GET_FUN(__glewProgramLocalParameter4dvARB) #define glProgramLocalParameter4fARB GLEW_GET_FUN(__glewProgramLocalParameter4fARB) #define glProgramLocalParameter4fvARB GLEW_GET_FUN(__glewProgramLocalParameter4fvARB) #define glProgramStringARB GLEW_GET_FUN(__glewProgramStringARB) #define glVertexAttrib1dARB GLEW_GET_FUN(__glewVertexAttrib1dARB) #define glVertexAttrib1dvARB GLEW_GET_FUN(__glewVertexAttrib1dvARB) #define glVertexAttrib1fARB GLEW_GET_FUN(__glewVertexAttrib1fARB) #define glVertexAttrib1fvARB GLEW_GET_FUN(__glewVertexAttrib1fvARB) #define glVertexAttrib1sARB GLEW_GET_FUN(__glewVertexAttrib1sARB) #define glVertexAttrib1svARB GLEW_GET_FUN(__glewVertexAttrib1svARB) #define glVertexAttrib2dARB GLEW_GET_FUN(__glewVertexAttrib2dARB) #define glVertexAttrib2dvARB GLEW_GET_FUN(__glewVertexAttrib2dvARB) #define glVertexAttrib2fARB GLEW_GET_FUN(__glewVertexAttrib2fARB) #define glVertexAttrib2fvARB GLEW_GET_FUN(__glewVertexAttrib2fvARB) #define glVertexAttrib2sARB GLEW_GET_FUN(__glewVertexAttrib2sARB) #define glVertexAttrib2svARB GLEW_GET_FUN(__glewVertexAttrib2svARB) #define glVertexAttrib3dARB GLEW_GET_FUN(__glewVertexAttrib3dARB) #define glVertexAttrib3dvARB GLEW_GET_FUN(__glewVertexAttrib3dvARB) #define glVertexAttrib3fARB GLEW_GET_FUN(__glewVertexAttrib3fARB) #define glVertexAttrib3fvARB GLEW_GET_FUN(__glewVertexAttrib3fvARB) #define glVertexAttrib3sARB GLEW_GET_FUN(__glewVertexAttrib3sARB) #define glVertexAttrib3svARB GLEW_GET_FUN(__glewVertexAttrib3svARB) #define glVertexAttrib4NbvARB GLEW_GET_FUN(__glewVertexAttrib4NbvARB) #define glVertexAttrib4NivARB GLEW_GET_FUN(__glewVertexAttrib4NivARB) #define glVertexAttrib4NsvARB GLEW_GET_FUN(__glewVertexAttrib4NsvARB) #define glVertexAttrib4NubARB GLEW_GET_FUN(__glewVertexAttrib4NubARB) #define glVertexAttrib4NubvARB GLEW_GET_FUN(__glewVertexAttrib4NubvARB) #define glVertexAttrib4NuivARB GLEW_GET_FUN(__glewVertexAttrib4NuivARB) #define glVertexAttrib4NusvARB GLEW_GET_FUN(__glewVertexAttrib4NusvARB) #define glVertexAttrib4bvARB GLEW_GET_FUN(__glewVertexAttrib4bvARB) #define glVertexAttrib4dARB GLEW_GET_FUN(__glewVertexAttrib4dARB) #define glVertexAttrib4dvARB GLEW_GET_FUN(__glewVertexAttrib4dvARB) #define glVertexAttrib4fARB GLEW_GET_FUN(__glewVertexAttrib4fARB) #define glVertexAttrib4fvARB GLEW_GET_FUN(__glewVertexAttrib4fvARB) #define glVertexAttrib4ivARB GLEW_GET_FUN(__glewVertexAttrib4ivARB) #define glVertexAttrib4sARB GLEW_GET_FUN(__glewVertexAttrib4sARB) #define glVertexAttrib4svARB GLEW_GET_FUN(__glewVertexAttrib4svARB) #define glVertexAttrib4ubvARB GLEW_GET_FUN(__glewVertexAttrib4ubvARB) #define glVertexAttrib4uivARB GLEW_GET_FUN(__glewVertexAttrib4uivARB) #define glVertexAttrib4usvARB GLEW_GET_FUN(__glewVertexAttrib4usvARB) #define glVertexAttribPointerARB GLEW_GET_FUN(__glewVertexAttribPointerARB) #define GLEW_ARB_vertex_program GLEW_GET_VAR(__GLEW_ARB_vertex_program) #endif /* GL_ARB_vertex_program */ /* -------------------------- GL_ARB_vertex_shader ------------------------- */ #ifndef GL_ARB_vertex_shader #define GL_ARB_vertex_shader 1 #define GL_VERTEX_SHADER_ARB 0x8B31 #define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A #define GL_MAX_VARYING_FLOATS_ARB 0x8B4B #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D #define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89 #define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB* name); typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name); typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB* name); #define glBindAttribLocationARB GLEW_GET_FUN(__glewBindAttribLocationARB) #define glGetActiveAttribARB GLEW_GET_FUN(__glewGetActiveAttribARB) #define glGetAttribLocationARB GLEW_GET_FUN(__glewGetAttribLocationARB) #define GLEW_ARB_vertex_shader GLEW_GET_VAR(__GLEW_ARB_vertex_shader) #endif /* GL_ARB_vertex_shader */ /* ------------------- GL_ARB_vertex_type_10f_11f_11f_rev ------------------ */ #ifndef GL_ARB_vertex_type_10f_11f_11f_rev #define GL_ARB_vertex_type_10f_11f_11f_rev 1 #define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B #define GLEW_ARB_vertex_type_10f_11f_11f_rev GLEW_GET_VAR(__GLEW_ARB_vertex_type_10f_11f_11f_rev) #endif /* GL_ARB_vertex_type_10f_11f_11f_rev */ /* ------------------- GL_ARB_vertex_type_2_10_10_10_rev ------------------- */ #ifndef GL_ARB_vertex_type_2_10_10_10_rev #define GL_ARB_vertex_type_2_10_10_10_rev 1 #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_INT_2_10_10_10_REV 0x8D9F typedef void (GLAPIENTRY * PFNGLCOLORP3UIPROC) (GLenum type, GLuint color); typedef void (GLAPIENTRY * PFNGLCOLORP3UIVPROC) (GLenum type, const GLuint* color); typedef void (GLAPIENTRY * PFNGLCOLORP4UIPROC) (GLenum type, GLuint color); typedef void (GLAPIENTRY * PFNGLCOLORP4UIVPROC) (GLenum type, const GLuint* color); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP1UIPROC) (GLenum texture, GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP1UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP2UIPROC) (GLenum texture, GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP2UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP3UIPROC) (GLenum texture, GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP3UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP4UIPROC) (GLenum texture, GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDP4UIVPROC) (GLenum texture, GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLNORMALP3UIPROC) (GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLNORMALP3UIVPROC) (GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORP3UIPROC) (GLenum type, GLuint color); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORP3UIVPROC) (GLenum type, const GLuint* color); typedef void (GLAPIENTRY * PFNGLTEXCOORDP1UIPROC) (GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP1UIVPROC) (GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP2UIPROC) (GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP2UIVPROC) (GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP3UIPROC) (GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP3UIVPROC) (GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP4UIPROC) (GLenum type, GLuint coords); typedef void (GLAPIENTRY * PFNGLTEXCOORDP4UIVPROC) (GLenum type, const GLuint* coords); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP1UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP1UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP2UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP2UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP3UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP3UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP4UIPROC) (GLuint index, GLenum type, GLboolean normalized, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBP4UIVPROC) (GLuint index, GLenum type, GLboolean normalized, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXP2UIPROC) (GLenum type, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXP2UIVPROC) (GLenum type, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXP3UIPROC) (GLenum type, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXP3UIVPROC) (GLenum type, const GLuint* value); typedef void (GLAPIENTRY * PFNGLVERTEXP4UIPROC) (GLenum type, GLuint value); typedef void (GLAPIENTRY * PFNGLVERTEXP4UIVPROC) (GLenum type, const GLuint* value); #define glColorP3ui GLEW_GET_FUN(__glewColorP3ui) #define glColorP3uiv GLEW_GET_FUN(__glewColorP3uiv) #define glColorP4ui GLEW_GET_FUN(__glewColorP4ui) #define glColorP4uiv GLEW_GET_FUN(__glewColorP4uiv) #define glMultiTexCoordP1ui GLEW_GET_FUN(__glewMultiTexCoordP1ui) #define glMultiTexCoordP1uiv GLEW_GET_FUN(__glewMultiTexCoordP1uiv) #define glMultiTexCoordP2ui GLEW_GET_FUN(__glewMultiTexCoordP2ui) #define glMultiTexCoordP2uiv GLEW_GET_FUN(__glewMultiTexCoordP2uiv) #define glMultiTexCoordP3ui GLEW_GET_FUN(__glewMultiTexCoordP3ui) #define glMultiTexCoordP3uiv GLEW_GET_FUN(__glewMultiTexCoordP3uiv) #define glMultiTexCoordP4ui GLEW_GET_FUN(__glewMultiTexCoordP4ui) #define glMultiTexCoordP4uiv GLEW_GET_FUN(__glewMultiTexCoordP4uiv) #define glNormalP3ui GLEW_GET_FUN(__glewNormalP3ui) #define glNormalP3uiv GLEW_GET_FUN(__glewNormalP3uiv) #define glSecondaryColorP3ui GLEW_GET_FUN(__glewSecondaryColorP3ui) #define glSecondaryColorP3uiv GLEW_GET_FUN(__glewSecondaryColorP3uiv) #define glTexCoordP1ui GLEW_GET_FUN(__glewTexCoordP1ui) #define glTexCoordP1uiv GLEW_GET_FUN(__glewTexCoordP1uiv) #define glTexCoordP2ui GLEW_GET_FUN(__glewTexCoordP2ui) #define glTexCoordP2uiv GLEW_GET_FUN(__glewTexCoordP2uiv) #define glTexCoordP3ui GLEW_GET_FUN(__glewTexCoordP3ui) #define glTexCoordP3uiv GLEW_GET_FUN(__glewTexCoordP3uiv) #define glTexCoordP4ui GLEW_GET_FUN(__glewTexCoordP4ui) #define glTexCoordP4uiv GLEW_GET_FUN(__glewTexCoordP4uiv) #define glVertexAttribP1ui GLEW_GET_FUN(__glewVertexAttribP1ui) #define glVertexAttribP1uiv GLEW_GET_FUN(__glewVertexAttribP1uiv) #define glVertexAttribP2ui GLEW_GET_FUN(__glewVertexAttribP2ui) #define glVertexAttribP2uiv GLEW_GET_FUN(__glewVertexAttribP2uiv) #define glVertexAttribP3ui GLEW_GET_FUN(__glewVertexAttribP3ui) #define glVertexAttribP3uiv GLEW_GET_FUN(__glewVertexAttribP3uiv) #define glVertexAttribP4ui GLEW_GET_FUN(__glewVertexAttribP4ui) #define glVertexAttribP4uiv GLEW_GET_FUN(__glewVertexAttribP4uiv) #define glVertexP2ui GLEW_GET_FUN(__glewVertexP2ui) #define glVertexP2uiv GLEW_GET_FUN(__glewVertexP2uiv) #define glVertexP3ui GLEW_GET_FUN(__glewVertexP3ui) #define glVertexP3uiv GLEW_GET_FUN(__glewVertexP3uiv) #define glVertexP4ui GLEW_GET_FUN(__glewVertexP4ui) #define glVertexP4uiv GLEW_GET_FUN(__glewVertexP4uiv) #define GLEW_ARB_vertex_type_2_10_10_10_rev GLEW_GET_VAR(__GLEW_ARB_vertex_type_2_10_10_10_rev) #endif /* GL_ARB_vertex_type_2_10_10_10_rev */ /* ------------------------- GL_ARB_viewport_array ------------------------- */ #ifndef GL_ARB_viewport_array #define GL_ARB_viewport_array 1 #define GL_DEPTH_RANGE 0x0B70 #define GL_VIEWPORT 0x0BA2 #define GL_SCISSOR_BOX 0x0C10 #define GL_SCISSOR_TEST 0x0C11 #define GL_MAX_VIEWPORTS 0x825B #define GL_VIEWPORT_SUBPIXEL_BITS 0x825C #define GL_VIEWPORT_BOUNDS_RANGE 0x825D #define GL_LAYER_PROVOKING_VERTEX 0x825E #define GL_VIEWPORT_INDEX_PROVOKING_VERTEX 0x825F #define GL_UNDEFINED_VERTEX 0x8260 #define GL_FIRST_VERTEX_CONVENTION 0x8E4D #define GL_LAST_VERTEX_CONVENTION 0x8E4E #define GL_PROVOKING_VERTEX 0x8E4F typedef void (GLAPIENTRY * PFNGLDEPTHRANGEARRAYVPROC) (GLuint first, GLsizei count, const GLclampd * v); typedef void (GLAPIENTRY * PFNGLDEPTHRANGEINDEXEDPROC) (GLuint index, GLclampd n, GLclampd f); typedef void (GLAPIENTRY * PFNGLGETDOUBLEI_VPROC) (GLenum target, GLuint index, GLdouble* data); typedef void (GLAPIENTRY * PFNGLGETFLOATI_VPROC) (GLenum target, GLuint index, GLfloat* data); typedef void (GLAPIENTRY * PFNGLSCISSORARRAYVPROC) (GLuint first, GLsizei count, const GLint * v); typedef void (GLAPIENTRY * PFNGLSCISSORINDEXEDPROC) (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLSCISSORINDEXEDVPROC) (GLuint index, const GLint * v); typedef void (GLAPIENTRY * PFNGLVIEWPORTARRAYVPROC) (GLuint first, GLsizei count, const GLfloat * v); typedef void (GLAPIENTRY * PFNGLVIEWPORTINDEXEDFPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); typedef void (GLAPIENTRY * PFNGLVIEWPORTINDEXEDFVPROC) (GLuint index, const GLfloat * v); #define glDepthRangeArrayv GLEW_GET_FUN(__glewDepthRangeArrayv) #define glDepthRangeIndexed GLEW_GET_FUN(__glewDepthRangeIndexed) #define glGetDoublei_v GLEW_GET_FUN(__glewGetDoublei_v) #define glGetFloati_v GLEW_GET_FUN(__glewGetFloati_v) #define glScissorArrayv GLEW_GET_FUN(__glewScissorArrayv) #define glScissorIndexed GLEW_GET_FUN(__glewScissorIndexed) #define glScissorIndexedv GLEW_GET_FUN(__glewScissorIndexedv) #define glViewportArrayv GLEW_GET_FUN(__glewViewportArrayv) #define glViewportIndexedf GLEW_GET_FUN(__glewViewportIndexedf) #define glViewportIndexedfv GLEW_GET_FUN(__glewViewportIndexedfv) #define GLEW_ARB_viewport_array GLEW_GET_VAR(__GLEW_ARB_viewport_array) #endif /* GL_ARB_viewport_array */ /* --------------------------- GL_ARB_window_pos --------------------------- */ #ifndef GL_ARB_window_pos #define GL_ARB_window_pos 1 typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVARBPROC) (const GLdouble* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVARBPROC) (const GLfloat* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVARBPROC) (const GLint* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVARBPROC) (const GLshort* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVARBPROC) (const GLdouble* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVARBPROC) (const GLfloat* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVARBPROC) (const GLint* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort* p); #define glWindowPos2dARB GLEW_GET_FUN(__glewWindowPos2dARB) #define glWindowPos2dvARB GLEW_GET_FUN(__glewWindowPos2dvARB) #define glWindowPos2fARB GLEW_GET_FUN(__glewWindowPos2fARB) #define glWindowPos2fvARB GLEW_GET_FUN(__glewWindowPos2fvARB) #define glWindowPos2iARB GLEW_GET_FUN(__glewWindowPos2iARB) #define glWindowPos2ivARB GLEW_GET_FUN(__glewWindowPos2ivARB) #define glWindowPos2sARB GLEW_GET_FUN(__glewWindowPos2sARB) #define glWindowPos2svARB GLEW_GET_FUN(__glewWindowPos2svARB) #define glWindowPos3dARB GLEW_GET_FUN(__glewWindowPos3dARB) #define glWindowPos3dvARB GLEW_GET_FUN(__glewWindowPos3dvARB) #define glWindowPos3fARB GLEW_GET_FUN(__glewWindowPos3fARB) #define glWindowPos3fvARB GLEW_GET_FUN(__glewWindowPos3fvARB) #define glWindowPos3iARB GLEW_GET_FUN(__glewWindowPos3iARB) #define glWindowPos3ivARB GLEW_GET_FUN(__glewWindowPos3ivARB) #define glWindowPos3sARB GLEW_GET_FUN(__glewWindowPos3sARB) #define glWindowPos3svARB GLEW_GET_FUN(__glewWindowPos3svARB) #define GLEW_ARB_window_pos GLEW_GET_VAR(__GLEW_ARB_window_pos) #endif /* GL_ARB_window_pos */ /* ------------------------- GL_ATIX_point_sprites ------------------------- */ #ifndef GL_ATIX_point_sprites #define GL_ATIX_point_sprites 1 #define GL_TEXTURE_POINT_MODE_ATIX 0x60B0 #define GL_TEXTURE_POINT_ONE_COORD_ATIX 0x60B1 #define GL_TEXTURE_POINT_SPRITE_ATIX 0x60B2 #define GL_POINT_SPRITE_CULL_MODE_ATIX 0x60B3 #define GL_POINT_SPRITE_CULL_CENTER_ATIX 0x60B4 #define GL_POINT_SPRITE_CULL_CLIP_ATIX 0x60B5 #define GLEW_ATIX_point_sprites GLEW_GET_VAR(__GLEW_ATIX_point_sprites) #endif /* GL_ATIX_point_sprites */ /* ---------------------- GL_ATIX_texture_env_combine3 --------------------- */ #ifndef GL_ATIX_texture_env_combine3 #define GL_ATIX_texture_env_combine3 1 #define GL_MODULATE_ADD_ATIX 0x8744 #define GL_MODULATE_SIGNED_ADD_ATIX 0x8745 #define GL_MODULATE_SUBTRACT_ATIX 0x8746 #define GLEW_ATIX_texture_env_combine3 GLEW_GET_VAR(__GLEW_ATIX_texture_env_combine3) #endif /* GL_ATIX_texture_env_combine3 */ /* ----------------------- GL_ATIX_texture_env_route ----------------------- */ #ifndef GL_ATIX_texture_env_route #define GL_ATIX_texture_env_route 1 #define GL_SECONDARY_COLOR_ATIX 0x8747 #define GL_TEXTURE_OUTPUT_RGB_ATIX 0x8748 #define GL_TEXTURE_OUTPUT_ALPHA_ATIX 0x8749 #define GLEW_ATIX_texture_env_route GLEW_GET_VAR(__GLEW_ATIX_texture_env_route) #endif /* GL_ATIX_texture_env_route */ /* ---------------- GL_ATIX_vertex_shader_output_point_size ---------------- */ #ifndef GL_ATIX_vertex_shader_output_point_size #define GL_ATIX_vertex_shader_output_point_size 1 #define GL_OUTPUT_POINT_SIZE_ATIX 0x610E #define GLEW_ATIX_vertex_shader_output_point_size GLEW_GET_VAR(__GLEW_ATIX_vertex_shader_output_point_size) #endif /* GL_ATIX_vertex_shader_output_point_size */ /* -------------------------- GL_ATI_draw_buffers -------------------------- */ #ifndef GL_ATI_draw_buffers #define GL_ATI_draw_buffers 1 #define GL_MAX_DRAW_BUFFERS_ATI 0x8824 #define GL_DRAW_BUFFER0_ATI 0x8825 #define GL_DRAW_BUFFER1_ATI 0x8826 #define GL_DRAW_BUFFER2_ATI 0x8827 #define GL_DRAW_BUFFER3_ATI 0x8828 #define GL_DRAW_BUFFER4_ATI 0x8829 #define GL_DRAW_BUFFER5_ATI 0x882A #define GL_DRAW_BUFFER6_ATI 0x882B #define GL_DRAW_BUFFER7_ATI 0x882C #define GL_DRAW_BUFFER8_ATI 0x882D #define GL_DRAW_BUFFER9_ATI 0x882E #define GL_DRAW_BUFFER10_ATI 0x882F #define GL_DRAW_BUFFER11_ATI 0x8830 #define GL_DRAW_BUFFER12_ATI 0x8831 #define GL_DRAW_BUFFER13_ATI 0x8832 #define GL_DRAW_BUFFER14_ATI 0x8833 #define GL_DRAW_BUFFER15_ATI 0x8834 typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum* bufs); #define glDrawBuffersATI GLEW_GET_FUN(__glewDrawBuffersATI) #define GLEW_ATI_draw_buffers GLEW_GET_VAR(__GLEW_ATI_draw_buffers) #endif /* GL_ATI_draw_buffers */ /* -------------------------- GL_ATI_element_array ------------------------- */ #ifndef GL_ATI_element_array #define GL_ATI_element_array 1 #define GL_ELEMENT_ARRAY_ATI 0x8768 #define GL_ELEMENT_ARRAY_TYPE_ATI 0x8769 #define GL_ELEMENT_ARRAY_POINTER_ATI 0x876A typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count); typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count); typedef void (GLAPIENTRY * PFNGLELEMENTPOINTERATIPROC) (GLenum type, const void *pointer); #define glDrawElementArrayATI GLEW_GET_FUN(__glewDrawElementArrayATI) #define glDrawRangeElementArrayATI GLEW_GET_FUN(__glewDrawRangeElementArrayATI) #define glElementPointerATI GLEW_GET_FUN(__glewElementPointerATI) #define GLEW_ATI_element_array GLEW_GET_VAR(__GLEW_ATI_element_array) #endif /* GL_ATI_element_array */ /* ------------------------- GL_ATI_envmap_bumpmap ------------------------- */ #ifndef GL_ATI_envmap_bumpmap #define GL_ATI_envmap_bumpmap 1 #define GL_BUMP_ROT_MATRIX_ATI 0x8775 #define GL_BUMP_ROT_MATRIX_SIZE_ATI 0x8776 #define GL_BUMP_NUM_TEX_UNITS_ATI 0x8777 #define GL_BUMP_TEX_UNITS_ATI 0x8778 #define GL_DUDV_ATI 0x8779 #define GL_DU8DV8_ATI 0x877A #define GL_BUMP_ENVMAP_ATI 0x877B #define GL_BUMP_TARGET_ATI 0x877C typedef void (GLAPIENTRY * PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); typedef void (GLAPIENTRY * PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); typedef void (GLAPIENTRY * PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); typedef void (GLAPIENTRY * PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); #define glGetTexBumpParameterfvATI GLEW_GET_FUN(__glewGetTexBumpParameterfvATI) #define glGetTexBumpParameterivATI GLEW_GET_FUN(__glewGetTexBumpParameterivATI) #define glTexBumpParameterfvATI GLEW_GET_FUN(__glewTexBumpParameterfvATI) #define glTexBumpParameterivATI GLEW_GET_FUN(__glewTexBumpParameterivATI) #define GLEW_ATI_envmap_bumpmap GLEW_GET_VAR(__GLEW_ATI_envmap_bumpmap) #endif /* GL_ATI_envmap_bumpmap */ /* ------------------------- GL_ATI_fragment_shader ------------------------ */ #ifndef GL_ATI_fragment_shader #define GL_ATI_fragment_shader 1 #define GL_2X_BIT_ATI 0x00000001 #define GL_RED_BIT_ATI 0x00000001 #define GL_4X_BIT_ATI 0x00000002 #define GL_COMP_BIT_ATI 0x00000002 #define GL_GREEN_BIT_ATI 0x00000002 #define GL_8X_BIT_ATI 0x00000004 #define GL_BLUE_BIT_ATI 0x00000004 #define GL_NEGATE_BIT_ATI 0x00000004 #define GL_BIAS_BIT_ATI 0x00000008 #define GL_HALF_BIT_ATI 0x00000008 #define GL_QUARTER_BIT_ATI 0x00000010 #define GL_EIGHTH_BIT_ATI 0x00000020 #define GL_SATURATE_BIT_ATI 0x00000040 #define GL_FRAGMENT_SHADER_ATI 0x8920 #define GL_REG_0_ATI 0x8921 #define GL_REG_1_ATI 0x8922 #define GL_REG_2_ATI 0x8923 #define GL_REG_3_ATI 0x8924 #define GL_REG_4_ATI 0x8925 #define GL_REG_5_ATI 0x8926 #define GL_CON_0_ATI 0x8941 #define GL_CON_1_ATI 0x8942 #define GL_CON_2_ATI 0x8943 #define GL_CON_3_ATI 0x8944 #define GL_CON_4_ATI 0x8945 #define GL_CON_5_ATI 0x8946 #define GL_CON_6_ATI 0x8947 #define GL_CON_7_ATI 0x8948 #define GL_MOV_ATI 0x8961 #define GL_ADD_ATI 0x8963 #define GL_MUL_ATI 0x8964 #define GL_SUB_ATI 0x8965 #define GL_DOT3_ATI 0x8966 #define GL_DOT4_ATI 0x8967 #define GL_MAD_ATI 0x8968 #define GL_LERP_ATI 0x8969 #define GL_CND_ATI 0x896A #define GL_CND0_ATI 0x896B #define GL_DOT2_ADD_ATI 0x896C #define GL_SECONDARY_INTERPOLATOR_ATI 0x896D #define GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E #define GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F #define GL_NUM_PASSES_ATI 0x8970 #define GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971 #define GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972 #define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973 #define GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974 #define GL_COLOR_ALPHA_PAIRING_ATI 0x8975 #define GL_SWIZZLE_STR_ATI 0x8976 #define GL_SWIZZLE_STQ_ATI 0x8977 #define GL_SWIZZLE_STR_DR_ATI 0x8978 #define GL_SWIZZLE_STQ_DQ_ATI 0x8979 #define GL_SWIZZLE_STRQ_ATI 0x897A #define GL_SWIZZLE_STRQ_DQ_ATI 0x897B typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); typedef void (GLAPIENTRY * PFNGLBEGINFRAGMENTSHADERATIPROC) (void); typedef void (GLAPIENTRY * PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); typedef void (GLAPIENTRY * PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLENDFRAGMENTSHADERATIPROC) (void); typedef GLuint (GLAPIENTRY * PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range); typedef void (GLAPIENTRY * PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle); typedef void (GLAPIENTRY * PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle); typedef void (GLAPIENTRY * PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat* value); #define glAlphaFragmentOp1ATI GLEW_GET_FUN(__glewAlphaFragmentOp1ATI) #define glAlphaFragmentOp2ATI GLEW_GET_FUN(__glewAlphaFragmentOp2ATI) #define glAlphaFragmentOp3ATI GLEW_GET_FUN(__glewAlphaFragmentOp3ATI) #define glBeginFragmentShaderATI GLEW_GET_FUN(__glewBeginFragmentShaderATI) #define glBindFragmentShaderATI GLEW_GET_FUN(__glewBindFragmentShaderATI) #define glColorFragmentOp1ATI GLEW_GET_FUN(__glewColorFragmentOp1ATI) #define glColorFragmentOp2ATI GLEW_GET_FUN(__glewColorFragmentOp2ATI) #define glColorFragmentOp3ATI GLEW_GET_FUN(__glewColorFragmentOp3ATI) #define glDeleteFragmentShaderATI GLEW_GET_FUN(__glewDeleteFragmentShaderATI) #define glEndFragmentShaderATI GLEW_GET_FUN(__glewEndFragmentShaderATI) #define glGenFragmentShadersATI GLEW_GET_FUN(__glewGenFragmentShadersATI) #define glPassTexCoordATI GLEW_GET_FUN(__glewPassTexCoordATI) #define glSampleMapATI GLEW_GET_FUN(__glewSampleMapATI) #define glSetFragmentShaderConstantATI GLEW_GET_FUN(__glewSetFragmentShaderConstantATI) #define GLEW_ATI_fragment_shader GLEW_GET_VAR(__GLEW_ATI_fragment_shader) #endif /* GL_ATI_fragment_shader */ /* ------------------------ GL_ATI_map_object_buffer ----------------------- */ #ifndef GL_ATI_map_object_buffer #define GL_ATI_map_object_buffer 1 typedef void * (GLAPIENTRY * PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer); #define glMapObjectBufferATI GLEW_GET_FUN(__glewMapObjectBufferATI) #define glUnmapObjectBufferATI GLEW_GET_FUN(__glewUnmapObjectBufferATI) #define GLEW_ATI_map_object_buffer GLEW_GET_VAR(__GLEW_ATI_map_object_buffer) #endif /* GL_ATI_map_object_buffer */ /* ----------------------------- GL_ATI_meminfo ---------------------------- */ #ifndef GL_ATI_meminfo #define GL_ATI_meminfo 1 #define GL_VBO_FREE_MEMORY_ATI 0x87FB #define GL_TEXTURE_FREE_MEMORY_ATI 0x87FC #define GL_RENDERBUFFER_FREE_MEMORY_ATI 0x87FD #define GLEW_ATI_meminfo GLEW_GET_VAR(__GLEW_ATI_meminfo) #endif /* GL_ATI_meminfo */ /* -------------------------- GL_ATI_pn_triangles -------------------------- */ #ifndef GL_ATI_pn_triangles #define GL_ATI_pn_triangles 1 #define GL_PN_TRIANGLES_ATI 0x87F0 #define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1 #define GL_PN_TRIANGLES_POINT_MODE_ATI 0x87F2 #define GL_PN_TRIANGLES_NORMAL_MODE_ATI 0x87F3 #define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4 #define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5 #define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6 #define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7 #define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8 typedef void (GLAPIENTRY * PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param); #define glPNTrianglesfATI GLEW_GET_FUN(__glewPNTrianglesfATI) #define glPNTrianglesiATI GLEW_GET_FUN(__glewPNTrianglesiATI) #define GLEW_ATI_pn_triangles GLEW_GET_VAR(__GLEW_ATI_pn_triangles) #endif /* GL_ATI_pn_triangles */ /* ------------------------ GL_ATI_separate_stencil ------------------------ */ #ifndef GL_ATI_separate_stencil #define GL_ATI_separate_stencil 1 #define GL_STENCIL_BACK_FUNC_ATI 0x8800 #define GL_STENCIL_BACK_FAIL_ATI 0x8801 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802 #define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803 typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); #define glStencilFuncSeparateATI GLEW_GET_FUN(__glewStencilFuncSeparateATI) #define glStencilOpSeparateATI GLEW_GET_FUN(__glewStencilOpSeparateATI) #define GLEW_ATI_separate_stencil GLEW_GET_VAR(__GLEW_ATI_separate_stencil) #endif /* GL_ATI_separate_stencil */ /* ----------------------- GL_ATI_shader_texture_lod ----------------------- */ #ifndef GL_ATI_shader_texture_lod #define GL_ATI_shader_texture_lod 1 #define GLEW_ATI_shader_texture_lod GLEW_GET_VAR(__GLEW_ATI_shader_texture_lod) #endif /* GL_ATI_shader_texture_lod */ /* ---------------------- GL_ATI_text_fragment_shader ---------------------- */ #ifndef GL_ATI_text_fragment_shader #define GL_ATI_text_fragment_shader 1 #define GL_TEXT_FRAGMENT_SHADER_ATI 0x8200 #define GLEW_ATI_text_fragment_shader GLEW_GET_VAR(__GLEW_ATI_text_fragment_shader) #endif /* GL_ATI_text_fragment_shader */ /* --------------------- GL_ATI_texture_compression_3dc -------------------- */ #ifndef GL_ATI_texture_compression_3dc #define GL_ATI_texture_compression_3dc 1 #define GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI 0x8837 #define GLEW_ATI_texture_compression_3dc GLEW_GET_VAR(__GLEW_ATI_texture_compression_3dc) #endif /* GL_ATI_texture_compression_3dc */ /* ---------------------- GL_ATI_texture_env_combine3 ---------------------- */ #ifndef GL_ATI_texture_env_combine3 #define GL_ATI_texture_env_combine3 1 #define GL_MODULATE_ADD_ATI 0x8744 #define GL_MODULATE_SIGNED_ADD_ATI 0x8745 #define GL_MODULATE_SUBTRACT_ATI 0x8746 #define GLEW_ATI_texture_env_combine3 GLEW_GET_VAR(__GLEW_ATI_texture_env_combine3) #endif /* GL_ATI_texture_env_combine3 */ /* -------------------------- GL_ATI_texture_float ------------------------- */ #ifndef GL_ATI_texture_float #define GL_ATI_texture_float 1 #define GL_RGBA_FLOAT32_ATI 0x8814 #define GL_RGB_FLOAT32_ATI 0x8815 #define GL_ALPHA_FLOAT32_ATI 0x8816 #define GL_INTENSITY_FLOAT32_ATI 0x8817 #define GL_LUMINANCE_FLOAT32_ATI 0x8818 #define GL_LUMINANCE_ALPHA_FLOAT32_ATI 0x8819 #define GL_RGBA_FLOAT16_ATI 0x881A #define GL_RGB_FLOAT16_ATI 0x881B #define GL_ALPHA_FLOAT16_ATI 0x881C #define GL_INTENSITY_FLOAT16_ATI 0x881D #define GL_LUMINANCE_FLOAT16_ATI 0x881E #define GL_LUMINANCE_ALPHA_FLOAT16_ATI 0x881F #define GLEW_ATI_texture_float GLEW_GET_VAR(__GLEW_ATI_texture_float) #endif /* GL_ATI_texture_float */ /* ----------------------- GL_ATI_texture_mirror_once ---------------------- */ #ifndef GL_ATI_texture_mirror_once #define GL_ATI_texture_mirror_once 1 #define GL_MIRROR_CLAMP_ATI 0x8742 #define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x8743 #define GLEW_ATI_texture_mirror_once GLEW_GET_VAR(__GLEW_ATI_texture_mirror_once) #endif /* GL_ATI_texture_mirror_once */ /* ----------------------- GL_ATI_vertex_array_object ---------------------- */ #ifndef GL_ATI_vertex_array_object #define GL_ATI_vertex_array_object 1 #define GL_STATIC_ATI 0x8760 #define GL_DYNAMIC_ATI 0x8761 #define GL_PRESERVE_ATI 0x8762 #define GL_DISCARD_ATI 0x8763 #define GL_OBJECT_BUFFER_SIZE_ATI 0x8764 #define GL_OBJECT_BUFFER_USAGE_ATI 0x8765 #define GL_ARRAY_OBJECT_BUFFER_ATI 0x8766 #define GL_ARRAY_OBJECT_OFFSET_ATI 0x8767 typedef void (GLAPIENTRY * PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); typedef void (GLAPIENTRY * PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer); typedef GLuint (GLAPIENTRY * PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const void *pointer, GLenum usage); typedef void (GLAPIENTRY * PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve); typedef void (GLAPIENTRY * PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); #define glArrayObjectATI GLEW_GET_FUN(__glewArrayObjectATI) #define glFreeObjectBufferATI GLEW_GET_FUN(__glewFreeObjectBufferATI) #define glGetArrayObjectfvATI GLEW_GET_FUN(__glewGetArrayObjectfvATI) #define glGetArrayObjectivATI GLEW_GET_FUN(__glewGetArrayObjectivATI) #define glGetObjectBufferfvATI GLEW_GET_FUN(__glewGetObjectBufferfvATI) #define glGetObjectBufferivATI GLEW_GET_FUN(__glewGetObjectBufferivATI) #define glGetVariantArrayObjectfvATI GLEW_GET_FUN(__glewGetVariantArrayObjectfvATI) #define glGetVariantArrayObjectivATI GLEW_GET_FUN(__glewGetVariantArrayObjectivATI) #define glIsObjectBufferATI GLEW_GET_FUN(__glewIsObjectBufferATI) #define glNewObjectBufferATI GLEW_GET_FUN(__glewNewObjectBufferATI) #define glUpdateObjectBufferATI GLEW_GET_FUN(__glewUpdateObjectBufferATI) #define glVariantArrayObjectATI GLEW_GET_FUN(__glewVariantArrayObjectATI) #define GLEW_ATI_vertex_array_object GLEW_GET_VAR(__GLEW_ATI_vertex_array_object) #endif /* GL_ATI_vertex_array_object */ /* ------------------- GL_ATI_vertex_attrib_array_object ------------------- */ #ifndef GL_ATI_vertex_attrib_array_object #define GL_ATI_vertex_attrib_array_object 1 typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint index, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint index, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset); #define glGetVertexAttribArrayObjectfvATI GLEW_GET_FUN(__glewGetVertexAttribArrayObjectfvATI) #define glGetVertexAttribArrayObjectivATI GLEW_GET_FUN(__glewGetVertexAttribArrayObjectivATI) #define glVertexAttribArrayObjectATI GLEW_GET_FUN(__glewVertexAttribArrayObjectATI) #define GLEW_ATI_vertex_attrib_array_object GLEW_GET_VAR(__GLEW_ATI_vertex_attrib_array_object) #endif /* GL_ATI_vertex_attrib_array_object */ /* ------------------------- GL_ATI_vertex_streams ------------------------- */ #ifndef GL_ATI_vertex_streams #define GL_ATI_vertex_streams 1 #define GL_MAX_VERTEX_STREAMS_ATI 0x876B #define GL_VERTEX_SOURCE_ATI 0x876C #define GL_VERTEX_STREAM0_ATI 0x876D #define GL_VERTEX_STREAM1_ATI 0x876E #define GL_VERTEX_STREAM2_ATI 0x876F #define GL_VERTEX_STREAM3_ATI 0x8770 #define GL_VERTEX_STREAM4_ATI 0x8771 #define GL_VERTEX_STREAM5_ATI 0x8772 #define GL_VERTEX_STREAM6_ATI 0x8773 #define GL_VERTEX_STREAM7_ATI 0x8774 typedef void (GLAPIENTRY * PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *coords); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *coords); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (GLAPIENTRY * PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1DATIPROC) (GLenum stream, GLdouble x); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1FATIPROC) (GLenum stream, GLfloat x); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1IATIPROC) (GLenum stream, GLint x); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1IVATIPROC) (GLenum stream, const GLint *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1SATIPROC) (GLenum stream, GLshort x); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM1SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *coords); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *coords); #define glClientActiveVertexStreamATI GLEW_GET_FUN(__glewClientActiveVertexStreamATI) #define glNormalStream3bATI GLEW_GET_FUN(__glewNormalStream3bATI) #define glNormalStream3bvATI GLEW_GET_FUN(__glewNormalStream3bvATI) #define glNormalStream3dATI GLEW_GET_FUN(__glewNormalStream3dATI) #define glNormalStream3dvATI GLEW_GET_FUN(__glewNormalStream3dvATI) #define glNormalStream3fATI GLEW_GET_FUN(__glewNormalStream3fATI) #define glNormalStream3fvATI GLEW_GET_FUN(__glewNormalStream3fvATI) #define glNormalStream3iATI GLEW_GET_FUN(__glewNormalStream3iATI) #define glNormalStream3ivATI GLEW_GET_FUN(__glewNormalStream3ivATI) #define glNormalStream3sATI GLEW_GET_FUN(__glewNormalStream3sATI) #define glNormalStream3svATI GLEW_GET_FUN(__glewNormalStream3svATI) #define glVertexBlendEnvfATI GLEW_GET_FUN(__glewVertexBlendEnvfATI) #define glVertexBlendEnviATI GLEW_GET_FUN(__glewVertexBlendEnviATI) #define glVertexStream1dATI GLEW_GET_FUN(__glewVertexStream1dATI) #define glVertexStream1dvATI GLEW_GET_FUN(__glewVertexStream1dvATI) #define glVertexStream1fATI GLEW_GET_FUN(__glewVertexStream1fATI) #define glVertexStream1fvATI GLEW_GET_FUN(__glewVertexStream1fvATI) #define glVertexStream1iATI GLEW_GET_FUN(__glewVertexStream1iATI) #define glVertexStream1ivATI GLEW_GET_FUN(__glewVertexStream1ivATI) #define glVertexStream1sATI GLEW_GET_FUN(__glewVertexStream1sATI) #define glVertexStream1svATI GLEW_GET_FUN(__glewVertexStream1svATI) #define glVertexStream2dATI GLEW_GET_FUN(__glewVertexStream2dATI) #define glVertexStream2dvATI GLEW_GET_FUN(__glewVertexStream2dvATI) #define glVertexStream2fATI GLEW_GET_FUN(__glewVertexStream2fATI) #define glVertexStream2fvATI GLEW_GET_FUN(__glewVertexStream2fvATI) #define glVertexStream2iATI GLEW_GET_FUN(__glewVertexStream2iATI) #define glVertexStream2ivATI GLEW_GET_FUN(__glewVertexStream2ivATI) #define glVertexStream2sATI GLEW_GET_FUN(__glewVertexStream2sATI) #define glVertexStream2svATI GLEW_GET_FUN(__glewVertexStream2svATI) #define glVertexStream3dATI GLEW_GET_FUN(__glewVertexStream3dATI) #define glVertexStream3dvATI GLEW_GET_FUN(__glewVertexStream3dvATI) #define glVertexStream3fATI GLEW_GET_FUN(__glewVertexStream3fATI) #define glVertexStream3fvATI GLEW_GET_FUN(__glewVertexStream3fvATI) #define glVertexStream3iATI GLEW_GET_FUN(__glewVertexStream3iATI) #define glVertexStream3ivATI GLEW_GET_FUN(__glewVertexStream3ivATI) #define glVertexStream3sATI GLEW_GET_FUN(__glewVertexStream3sATI) #define glVertexStream3svATI GLEW_GET_FUN(__glewVertexStream3svATI) #define glVertexStream4dATI GLEW_GET_FUN(__glewVertexStream4dATI) #define glVertexStream4dvATI GLEW_GET_FUN(__glewVertexStream4dvATI) #define glVertexStream4fATI GLEW_GET_FUN(__glewVertexStream4fATI) #define glVertexStream4fvATI GLEW_GET_FUN(__glewVertexStream4fvATI) #define glVertexStream4iATI GLEW_GET_FUN(__glewVertexStream4iATI) #define glVertexStream4ivATI GLEW_GET_FUN(__glewVertexStream4ivATI) #define glVertexStream4sATI GLEW_GET_FUN(__glewVertexStream4sATI) #define glVertexStream4svATI GLEW_GET_FUN(__glewVertexStream4svATI) #define GLEW_ATI_vertex_streams GLEW_GET_VAR(__GLEW_ATI_vertex_streams) #endif /* GL_ATI_vertex_streams */ /* --------------------------- GL_EXT_422_pixels --------------------------- */ #ifndef GL_EXT_422_pixels #define GL_EXT_422_pixels 1 #define GL_422_EXT 0x80CC #define GL_422_REV_EXT 0x80CD #define GL_422_AVERAGE_EXT 0x80CE #define GL_422_REV_AVERAGE_EXT 0x80CF #define GLEW_EXT_422_pixels GLEW_GET_VAR(__GLEW_EXT_422_pixels) #endif /* GL_EXT_422_pixels */ /* ---------------------------- GL_EXT_Cg_shader --------------------------- */ #ifndef GL_EXT_Cg_shader #define GL_EXT_Cg_shader 1 #define GL_CG_VERTEX_SHADER_EXT 0x890E #define GL_CG_FRAGMENT_SHADER_EXT 0x890F #define GLEW_EXT_Cg_shader GLEW_GET_VAR(__GLEW_EXT_Cg_shader) #endif /* GL_EXT_Cg_shader */ /* ------------------------------ GL_EXT_abgr ------------------------------ */ #ifndef GL_EXT_abgr #define GL_EXT_abgr 1 #define GL_ABGR_EXT 0x8000 #define GLEW_EXT_abgr GLEW_GET_VAR(__GLEW_EXT_abgr) #endif /* GL_EXT_abgr */ /* ------------------------------ GL_EXT_bgra ------------------------------ */ #ifndef GL_EXT_bgra #define GL_EXT_bgra 1 #define GL_BGR_EXT 0x80E0 #define GL_BGRA_EXT 0x80E1 #define GLEW_EXT_bgra GLEW_GET_VAR(__GLEW_EXT_bgra) #endif /* GL_EXT_bgra */ /* ------------------------ GL_EXT_bindable_uniform ------------------------ */ #ifndef GL_EXT_bindable_uniform #define GL_EXT_bindable_uniform 1 #define GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT 0x8DE2 #define GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT 0x8DE3 #define GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT 0x8DE4 #define GL_MAX_BINDABLE_UNIFORM_SIZE_EXT 0x8DED #define GL_UNIFORM_BUFFER_EXT 0x8DEE #define GL_UNIFORM_BUFFER_BINDING_EXT 0x8DEF typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMBUFFERSIZEEXTPROC) (GLuint program, GLint location); typedef GLintptr (GLAPIENTRY * PFNGLGETUNIFORMOFFSETEXTPROC) (GLuint program, GLint location); typedef void (GLAPIENTRY * PFNGLUNIFORMBUFFEREXTPROC) (GLuint program, GLint location, GLuint buffer); #define glGetUniformBufferSizeEXT GLEW_GET_FUN(__glewGetUniformBufferSizeEXT) #define glGetUniformOffsetEXT GLEW_GET_FUN(__glewGetUniformOffsetEXT) #define glUniformBufferEXT GLEW_GET_FUN(__glewUniformBufferEXT) #define GLEW_EXT_bindable_uniform GLEW_GET_VAR(__GLEW_EXT_bindable_uniform) #endif /* GL_EXT_bindable_uniform */ /* --------------------------- GL_EXT_blend_color -------------------------- */ #ifndef GL_EXT_blend_color #define GL_EXT_blend_color 1 #define GL_CONSTANT_COLOR_EXT 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002 #define GL_CONSTANT_ALPHA_EXT 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004 #define GL_BLEND_COLOR_EXT 0x8005 typedef void (GLAPIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); #define glBlendColorEXT GLEW_GET_FUN(__glewBlendColorEXT) #define GLEW_EXT_blend_color GLEW_GET_VAR(__GLEW_EXT_blend_color) #endif /* GL_EXT_blend_color */ /* --------------------- GL_EXT_blend_equation_separate -------------------- */ #ifndef GL_EXT_blend_equation_separate #define GL_EXT_blend_equation_separate 1 #define GL_BLEND_EQUATION_RGB_EXT 0x8009 #define GL_BLEND_EQUATION_ALPHA_EXT 0x883D typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha); #define glBlendEquationSeparateEXT GLEW_GET_FUN(__glewBlendEquationSeparateEXT) #define GLEW_EXT_blend_equation_separate GLEW_GET_VAR(__GLEW_EXT_blend_equation_separate) #endif /* GL_EXT_blend_equation_separate */ /* ----------------------- GL_EXT_blend_func_separate ---------------------- */ #ifndef GL_EXT_blend_func_separate #define GL_EXT_blend_func_separate 1 #define GL_BLEND_DST_RGB_EXT 0x80C8 #define GL_BLEND_SRC_RGB_EXT 0x80C9 #define GL_BLEND_DST_ALPHA_EXT 0x80CA #define GL_BLEND_SRC_ALPHA_EXT 0x80CB typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); #define glBlendFuncSeparateEXT GLEW_GET_FUN(__glewBlendFuncSeparateEXT) #define GLEW_EXT_blend_func_separate GLEW_GET_VAR(__GLEW_EXT_blend_func_separate) #endif /* GL_EXT_blend_func_separate */ /* ------------------------- GL_EXT_blend_logic_op ------------------------- */ #ifndef GL_EXT_blend_logic_op #define GL_EXT_blend_logic_op 1 #define GLEW_EXT_blend_logic_op GLEW_GET_VAR(__GLEW_EXT_blend_logic_op) #endif /* GL_EXT_blend_logic_op */ /* -------------------------- GL_EXT_blend_minmax -------------------------- */ #ifndef GL_EXT_blend_minmax #define GL_EXT_blend_minmax 1 #define GL_FUNC_ADD_EXT 0x8006 #define GL_MIN_EXT 0x8007 #define GL_MAX_EXT 0x8008 #define GL_BLEND_EQUATION_EXT 0x8009 typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); #define glBlendEquationEXT GLEW_GET_FUN(__glewBlendEquationEXT) #define GLEW_EXT_blend_minmax GLEW_GET_VAR(__GLEW_EXT_blend_minmax) #endif /* GL_EXT_blend_minmax */ /* ------------------------- GL_EXT_blend_subtract ------------------------- */ #ifndef GL_EXT_blend_subtract #define GL_EXT_blend_subtract 1 #define GL_FUNC_SUBTRACT_EXT 0x800A #define GL_FUNC_REVERSE_SUBTRACT_EXT 0x800B #define GLEW_EXT_blend_subtract GLEW_GET_VAR(__GLEW_EXT_blend_subtract) #endif /* GL_EXT_blend_subtract */ /* ------------------------ GL_EXT_clip_volume_hint ------------------------ */ #ifndef GL_EXT_clip_volume_hint #define GL_EXT_clip_volume_hint 1 #define GL_CLIP_VOLUME_CLIPPING_HINT_EXT 0x80F0 #define GLEW_EXT_clip_volume_hint GLEW_GET_VAR(__GLEW_EXT_clip_volume_hint) #endif /* GL_EXT_clip_volume_hint */ /* ------------------------------ GL_EXT_cmyka ----------------------------- */ #ifndef GL_EXT_cmyka #define GL_EXT_cmyka 1 #define GL_CMYK_EXT 0x800C #define GL_CMYKA_EXT 0x800D #define GL_PACK_CMYK_HINT_EXT 0x800E #define GL_UNPACK_CMYK_HINT_EXT 0x800F #define GLEW_EXT_cmyka GLEW_GET_VAR(__GLEW_EXT_cmyka) #endif /* GL_EXT_cmyka */ /* ------------------------- GL_EXT_color_subtable ------------------------- */ #ifndef GL_EXT_color_subtable #define GL_EXT_color_subtable 1 typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); #define glColorSubTableEXT GLEW_GET_FUN(__glewColorSubTableEXT) #define glCopyColorSubTableEXT GLEW_GET_FUN(__glewCopyColorSubTableEXT) #define GLEW_EXT_color_subtable GLEW_GET_VAR(__GLEW_EXT_color_subtable) #endif /* GL_EXT_color_subtable */ /* ---------------------- GL_EXT_compiled_vertex_array --------------------- */ #ifndef GL_EXT_compiled_vertex_array #define GL_EXT_compiled_vertex_array 1 #define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT 0x81A8 #define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT 0x81A9 typedef void (GLAPIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); typedef void (GLAPIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void); #define glLockArraysEXT GLEW_GET_FUN(__glewLockArraysEXT) #define glUnlockArraysEXT GLEW_GET_FUN(__glewUnlockArraysEXT) #define GLEW_EXT_compiled_vertex_array GLEW_GET_VAR(__GLEW_EXT_compiled_vertex_array) #endif /* GL_EXT_compiled_vertex_array */ /* --------------------------- GL_EXT_convolution -------------------------- */ #ifndef GL_EXT_convolution #define GL_EXT_convolution 1 #define GL_CONVOLUTION_1D_EXT 0x8010 #define GL_CONVOLUTION_2D_EXT 0x8011 #define GL_SEPARABLE_2D_EXT 0x8012 #define GL_CONVOLUTION_BORDER_MODE_EXT 0x8013 #define GL_CONVOLUTION_FILTER_SCALE_EXT 0x8014 #define GL_CONVOLUTION_FILTER_BIAS_EXT 0x8015 #define GL_REDUCE_EXT 0x8016 #define GL_CONVOLUTION_FORMAT_EXT 0x8017 #define GL_CONVOLUTION_WIDTH_EXT 0x8018 #define GL_CONVOLUTION_HEIGHT_EXT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH_EXT 0x801A #define GL_MAX_CONVOLUTION_HEIGHT_EXT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F #define GL_POST_CONVOLUTION_RED_BIAS_EXT 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023 typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, void *image); typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, void *row, void *column, void *span); typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column); #define glConvolutionFilter1DEXT GLEW_GET_FUN(__glewConvolutionFilter1DEXT) #define glConvolutionFilter2DEXT GLEW_GET_FUN(__glewConvolutionFilter2DEXT) #define glConvolutionParameterfEXT GLEW_GET_FUN(__glewConvolutionParameterfEXT) #define glConvolutionParameterfvEXT GLEW_GET_FUN(__glewConvolutionParameterfvEXT) #define glConvolutionParameteriEXT GLEW_GET_FUN(__glewConvolutionParameteriEXT) #define glConvolutionParameterivEXT GLEW_GET_FUN(__glewConvolutionParameterivEXT) #define glCopyConvolutionFilter1DEXT GLEW_GET_FUN(__glewCopyConvolutionFilter1DEXT) #define glCopyConvolutionFilter2DEXT GLEW_GET_FUN(__glewCopyConvolutionFilter2DEXT) #define glGetConvolutionFilterEXT GLEW_GET_FUN(__glewGetConvolutionFilterEXT) #define glGetConvolutionParameterfvEXT GLEW_GET_FUN(__glewGetConvolutionParameterfvEXT) #define glGetConvolutionParameterivEXT GLEW_GET_FUN(__glewGetConvolutionParameterivEXT) #define glGetSeparableFilterEXT GLEW_GET_FUN(__glewGetSeparableFilterEXT) #define glSeparableFilter2DEXT GLEW_GET_FUN(__glewSeparableFilter2DEXT) #define GLEW_EXT_convolution GLEW_GET_VAR(__GLEW_EXT_convolution) #endif /* GL_EXT_convolution */ /* ------------------------ GL_EXT_coordinate_frame ------------------------ */ #ifndef GL_EXT_coordinate_frame #define GL_EXT_coordinate_frame 1 #define GL_TANGENT_ARRAY_EXT 0x8439 #define GL_BINORMAL_ARRAY_EXT 0x843A #define GL_CURRENT_TANGENT_EXT 0x843B #define GL_CURRENT_BINORMAL_EXT 0x843C #define GL_TANGENT_ARRAY_TYPE_EXT 0x843E #define GL_TANGENT_ARRAY_STRIDE_EXT 0x843F #define GL_BINORMAL_ARRAY_TYPE_EXT 0x8440 #define GL_BINORMAL_ARRAY_STRIDE_EXT 0x8441 #define GL_TANGENT_ARRAY_POINTER_EXT 0x8442 #define GL_BINORMAL_ARRAY_POINTER_EXT 0x8443 #define GL_MAP1_TANGENT_EXT 0x8444 #define GL_MAP2_TANGENT_EXT 0x8445 #define GL_MAP1_BINORMAL_EXT 0x8446 #define GL_MAP2_BINORMAL_EXT 0x8447 typedef void (GLAPIENTRY * PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, void *pointer); typedef void (GLAPIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, void *pointer); #define glBinormalPointerEXT GLEW_GET_FUN(__glewBinormalPointerEXT) #define glTangentPointerEXT GLEW_GET_FUN(__glewTangentPointerEXT) #define GLEW_EXT_coordinate_frame GLEW_GET_VAR(__GLEW_EXT_coordinate_frame) #endif /* GL_EXT_coordinate_frame */ /* -------------------------- GL_EXT_copy_texture -------------------------- */ #ifndef GL_EXT_copy_texture #define GL_EXT_copy_texture 1 typedef void (GLAPIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); typedef void (GLAPIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); #define glCopyTexImage1DEXT GLEW_GET_FUN(__glewCopyTexImage1DEXT) #define glCopyTexImage2DEXT GLEW_GET_FUN(__glewCopyTexImage2DEXT) #define glCopyTexSubImage1DEXT GLEW_GET_FUN(__glewCopyTexSubImage1DEXT) #define glCopyTexSubImage2DEXT GLEW_GET_FUN(__glewCopyTexSubImage2DEXT) #define glCopyTexSubImage3DEXT GLEW_GET_FUN(__glewCopyTexSubImage3DEXT) #define GLEW_EXT_copy_texture GLEW_GET_VAR(__GLEW_EXT_copy_texture) #endif /* GL_EXT_copy_texture */ /* --------------------------- GL_EXT_cull_vertex -------------------------- */ #ifndef GL_EXT_cull_vertex #define GL_EXT_cull_vertex 1 #define GL_CULL_VERTEX_EXT 0x81AA #define GL_CULL_VERTEX_EYE_POSITION_EXT 0x81AB #define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC typedef void (GLAPIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat* params); #define glCullParameterdvEXT GLEW_GET_FUN(__glewCullParameterdvEXT) #define glCullParameterfvEXT GLEW_GET_FUN(__glewCullParameterfvEXT) #define GLEW_EXT_cull_vertex GLEW_GET_VAR(__GLEW_EXT_cull_vertex) #endif /* GL_EXT_cull_vertex */ /* --------------------------- GL_EXT_debug_label -------------------------- */ #ifndef GL_EXT_debug_label #define GL_EXT_debug_label 1 #define GL_PROGRAM_PIPELINE_OBJECT_EXT 0x8A4F #define GL_PROGRAM_OBJECT_EXT 0x8B40 #define GL_SHADER_OBJECT_EXT 0x8B48 #define GL_BUFFER_OBJECT_EXT 0x9151 #define GL_QUERY_OBJECT_EXT 0x9153 #define GL_VERTEX_ARRAY_OBJECT_EXT 0x9154 typedef void (GLAPIENTRY * PFNGLGETOBJECTLABELEXTPROC) (GLenum type, GLuint object, GLsizei bufSize, GLsizei* length, GLchar *label); typedef void (GLAPIENTRY * PFNGLLABELOBJECTEXTPROC) (GLenum type, GLuint object, GLsizei length, const GLchar* label); #define glGetObjectLabelEXT GLEW_GET_FUN(__glewGetObjectLabelEXT) #define glLabelObjectEXT GLEW_GET_FUN(__glewLabelObjectEXT) #define GLEW_EXT_debug_label GLEW_GET_VAR(__GLEW_EXT_debug_label) #endif /* GL_EXT_debug_label */ /* -------------------------- GL_EXT_debug_marker -------------------------- */ #ifndef GL_EXT_debug_marker #define GL_EXT_debug_marker 1 typedef void (GLAPIENTRY * PFNGLINSERTEVENTMARKEREXTPROC) (GLsizei length, const GLchar* marker); typedef void (GLAPIENTRY * PFNGLPOPGROUPMARKEREXTPROC) (void); typedef void (GLAPIENTRY * PFNGLPUSHGROUPMARKEREXTPROC) (GLsizei length, const GLchar* marker); #define glInsertEventMarkerEXT GLEW_GET_FUN(__glewInsertEventMarkerEXT) #define glPopGroupMarkerEXT GLEW_GET_FUN(__glewPopGroupMarkerEXT) #define glPushGroupMarkerEXT GLEW_GET_FUN(__glewPushGroupMarkerEXT) #define GLEW_EXT_debug_marker GLEW_GET_VAR(__GLEW_EXT_debug_marker) #endif /* GL_EXT_debug_marker */ /* ------------------------ GL_EXT_depth_bounds_test ----------------------- */ #ifndef GL_EXT_depth_bounds_test #define GL_EXT_depth_bounds_test 1 #define GL_DEPTH_BOUNDS_TEST_EXT 0x8890 #define GL_DEPTH_BOUNDS_EXT 0x8891 typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax); #define glDepthBoundsEXT GLEW_GET_FUN(__glewDepthBoundsEXT) #define GLEW_EXT_depth_bounds_test GLEW_GET_VAR(__GLEW_EXT_depth_bounds_test) #endif /* GL_EXT_depth_bounds_test */ /* ----------------------- GL_EXT_direct_state_access ---------------------- */ #ifndef GL_EXT_direct_state_access #define GL_EXT_direct_state_access 1 #define GL_PROGRAM_MATRIX_EXT 0x8E2D #define GL_TRANSPOSE_PROGRAM_MATRIX_EXT 0x8E2E #define GL_PROGRAM_MATRIX_STACK_DEPTH_EXT 0x8E2F typedef void (GLAPIENTRY * PFNGLBINDMULTITEXTUREEXTPROC) (GLenum texunit, GLenum target, GLuint texture); typedef GLenum (GLAPIENTRY * PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) (GLuint framebuffer, GLenum target); typedef void (GLAPIENTRY * PFNGLCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEIEXTPROC) (GLenum array, GLuint index); typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC) (GLuint vaobj, GLuint index); typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXARRAYEXTPROC) (GLuint vaobj, GLenum array); typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEIEXTPROC) (GLenum array, GLuint index); typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYATTRIBEXTPROC) (GLuint vaobj, GLuint index); typedef void (GLAPIENTRY * PFNGLENABLEVERTEXARRAYEXTPROC) (GLuint vaobj, GLenum array); typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) (GLuint framebuffer, GLsizei n, const GLenum* bufs); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERREADBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); typedef void (GLAPIENTRY * PFNGLGENERATEMULTITEXMIPMAPEXTPROC) (GLenum texunit, GLenum target); typedef void (GLAPIENTRY * PFNGLGENERATETEXTUREMIPMAPEXTPROC) (GLuint texture, GLenum target); typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, void *img); typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, void *img); typedef void (GLAPIENTRY * PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum target, GLuint index, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETDOUBLEI_VEXTPROC) (GLenum pname, GLuint index, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum target, GLuint index, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETFLOATI_VEXTPROC) (GLenum pname, GLuint index, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels); typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) (GLuint buffer, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) (GLuint buffer, GLenum pname, void** params); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data); typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum pname, void *string); typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMIVEXTPROC) (GLuint program, GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) (GLuint renderbuffer, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum target, GLuint index, void** params); typedef void (GLAPIENTRY * PFNGLGETPOINTERI_VEXTPROC) (GLenum pname, GLuint index, void** params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels); typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYINTEGERVEXTPROC) (GLuint vaobj, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, void** param); typedef void (GLAPIENTRY * PFNGLGETVERTEXARRAYPOINTERVEXTPROC) (GLuint vaobj, GLenum pname, void** param); typedef void * (GLAPIENTRY * PFNGLMAPNAMEDBUFFEREXTPROC) (GLuint buffer, GLenum access); typedef void * (GLAPIENTRY * PFNGLMAPNAMEDBUFFERRANGEEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access); typedef void (GLAPIENTRY * PFNGLMATRIXFRUSTUMEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f); typedef void (GLAPIENTRY * PFNGLMATRIXLOADIDENTITYEXTPROC) (GLenum matrixMode); typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m); typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEFEXTPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXLOADDEXTPROC) (GLenum matrixMode, const GLdouble* m); typedef void (GLAPIENTRY * PFNGLMATRIXLOADFEXTPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEFEXTPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULTDEXTPROC) (GLenum matrixMode, const GLdouble* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULTFEXTPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXORTHOEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f); typedef void (GLAPIENTRY * PFNGLMATRIXPOPEXTPROC) (GLenum matrixMode); typedef void (GLAPIENTRY * PFNGLMATRIXPUSHEXTPROC) (GLenum matrixMode); typedef void (GLAPIENTRY * PFNGLMATRIXROTATEDEXTPROC) (GLenum matrixMode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLMATRIXROTATEFEXTPROC) (GLenum matrixMode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLMATRIXSCALEDEXTPROC) (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLMATRIXSCALEFEXTPROC) (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEDEXTPROC) (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEFEXTPROC) (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLMULTITEXBUFFEREXTPROC) (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDPOINTEREXTPROC) (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLMULTITEXENVFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLMULTITEXENVIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLMULTITEXGENDEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble param); typedef void (GLAPIENTRY * PFNGLMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLMULTITEXGENFEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLMULTITEXGENIEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLuint* params); typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat* param); typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* param); typedef void (GLAPIENTRY * PFNGLMULTITEXRENDERBUFFEREXTPROC) (GLenum texunit, GLenum target, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage); typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data); typedef void (GLAPIENTRY * PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC) (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLint* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLuint* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint* params); typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum format, GLsizei len, const void *string); typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat v0); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint v0); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIEXTPROC) (GLuint program, GLint location, GLuint v0); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLuint* params); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLfloat* param); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* param); typedef void (GLAPIENTRY * PFNGLTEXTURERENDERBUFFEREXTPROC) (GLuint texture, GLenum target, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYCOLOROFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYINDEXOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYNORMALOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC) (GLuint vaobj, GLuint index, GLuint divisor); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); #define glBindMultiTextureEXT GLEW_GET_FUN(__glewBindMultiTextureEXT) #define glCheckNamedFramebufferStatusEXT GLEW_GET_FUN(__glewCheckNamedFramebufferStatusEXT) #define glClientAttribDefaultEXT GLEW_GET_FUN(__glewClientAttribDefaultEXT) #define glCompressedMultiTexImage1DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage1DEXT) #define glCompressedMultiTexImage2DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage2DEXT) #define glCompressedMultiTexImage3DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage3DEXT) #define glCompressedMultiTexSubImage1DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage1DEXT) #define glCompressedMultiTexSubImage2DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage2DEXT) #define glCompressedMultiTexSubImage3DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage3DEXT) #define glCompressedTextureImage1DEXT GLEW_GET_FUN(__glewCompressedTextureImage1DEXT) #define glCompressedTextureImage2DEXT GLEW_GET_FUN(__glewCompressedTextureImage2DEXT) #define glCompressedTextureImage3DEXT GLEW_GET_FUN(__glewCompressedTextureImage3DEXT) #define glCompressedTextureSubImage1DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage1DEXT) #define glCompressedTextureSubImage2DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage2DEXT) #define glCompressedTextureSubImage3DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage3DEXT) #define glCopyMultiTexImage1DEXT GLEW_GET_FUN(__glewCopyMultiTexImage1DEXT) #define glCopyMultiTexImage2DEXT GLEW_GET_FUN(__glewCopyMultiTexImage2DEXT) #define glCopyMultiTexSubImage1DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage1DEXT) #define glCopyMultiTexSubImage2DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage2DEXT) #define glCopyMultiTexSubImage3DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage3DEXT) #define glCopyTextureImage1DEXT GLEW_GET_FUN(__glewCopyTextureImage1DEXT) #define glCopyTextureImage2DEXT GLEW_GET_FUN(__glewCopyTextureImage2DEXT) #define glCopyTextureSubImage1DEXT GLEW_GET_FUN(__glewCopyTextureSubImage1DEXT) #define glCopyTextureSubImage2DEXT GLEW_GET_FUN(__glewCopyTextureSubImage2DEXT) #define glCopyTextureSubImage3DEXT GLEW_GET_FUN(__glewCopyTextureSubImage3DEXT) #define glDisableClientStateIndexedEXT GLEW_GET_FUN(__glewDisableClientStateIndexedEXT) #define glDisableClientStateiEXT GLEW_GET_FUN(__glewDisableClientStateiEXT) #define glDisableVertexArrayAttribEXT GLEW_GET_FUN(__glewDisableVertexArrayAttribEXT) #define glDisableVertexArrayEXT GLEW_GET_FUN(__glewDisableVertexArrayEXT) #define glEnableClientStateIndexedEXT GLEW_GET_FUN(__glewEnableClientStateIndexedEXT) #define glEnableClientStateiEXT GLEW_GET_FUN(__glewEnableClientStateiEXT) #define glEnableVertexArrayAttribEXT GLEW_GET_FUN(__glewEnableVertexArrayAttribEXT) #define glEnableVertexArrayEXT GLEW_GET_FUN(__glewEnableVertexArrayEXT) #define glFlushMappedNamedBufferRangeEXT GLEW_GET_FUN(__glewFlushMappedNamedBufferRangeEXT) #define glFramebufferDrawBufferEXT GLEW_GET_FUN(__glewFramebufferDrawBufferEXT) #define glFramebufferDrawBuffersEXT GLEW_GET_FUN(__glewFramebufferDrawBuffersEXT) #define glFramebufferReadBufferEXT GLEW_GET_FUN(__glewFramebufferReadBufferEXT) #define glGenerateMultiTexMipmapEXT GLEW_GET_FUN(__glewGenerateMultiTexMipmapEXT) #define glGenerateTextureMipmapEXT GLEW_GET_FUN(__glewGenerateTextureMipmapEXT) #define glGetCompressedMultiTexImageEXT GLEW_GET_FUN(__glewGetCompressedMultiTexImageEXT) #define glGetCompressedTextureImageEXT GLEW_GET_FUN(__glewGetCompressedTextureImageEXT) #define glGetDoubleIndexedvEXT GLEW_GET_FUN(__glewGetDoubleIndexedvEXT) #define glGetDoublei_vEXT GLEW_GET_FUN(__glewGetDoublei_vEXT) #define glGetFloatIndexedvEXT GLEW_GET_FUN(__glewGetFloatIndexedvEXT) #define glGetFloati_vEXT GLEW_GET_FUN(__glewGetFloati_vEXT) #define glGetFramebufferParameterivEXT GLEW_GET_FUN(__glewGetFramebufferParameterivEXT) #define glGetMultiTexEnvfvEXT GLEW_GET_FUN(__glewGetMultiTexEnvfvEXT) #define glGetMultiTexEnvivEXT GLEW_GET_FUN(__glewGetMultiTexEnvivEXT) #define glGetMultiTexGendvEXT GLEW_GET_FUN(__glewGetMultiTexGendvEXT) #define glGetMultiTexGenfvEXT GLEW_GET_FUN(__glewGetMultiTexGenfvEXT) #define glGetMultiTexGenivEXT GLEW_GET_FUN(__glewGetMultiTexGenivEXT) #define glGetMultiTexImageEXT GLEW_GET_FUN(__glewGetMultiTexImageEXT) #define glGetMultiTexLevelParameterfvEXT GLEW_GET_FUN(__glewGetMultiTexLevelParameterfvEXT) #define glGetMultiTexLevelParameterivEXT GLEW_GET_FUN(__glewGetMultiTexLevelParameterivEXT) #define glGetMultiTexParameterIivEXT GLEW_GET_FUN(__glewGetMultiTexParameterIivEXT) #define glGetMultiTexParameterIuivEXT GLEW_GET_FUN(__glewGetMultiTexParameterIuivEXT) #define glGetMultiTexParameterfvEXT GLEW_GET_FUN(__glewGetMultiTexParameterfvEXT) #define glGetMultiTexParameterivEXT GLEW_GET_FUN(__glewGetMultiTexParameterivEXT) #define glGetNamedBufferParameterivEXT GLEW_GET_FUN(__glewGetNamedBufferParameterivEXT) #define glGetNamedBufferPointervEXT GLEW_GET_FUN(__glewGetNamedBufferPointervEXT) #define glGetNamedBufferSubDataEXT GLEW_GET_FUN(__glewGetNamedBufferSubDataEXT) #define glGetNamedFramebufferAttachmentParameterivEXT GLEW_GET_FUN(__glewGetNamedFramebufferAttachmentParameterivEXT) #define glGetNamedProgramLocalParameterIivEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterIivEXT) #define glGetNamedProgramLocalParameterIuivEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterIuivEXT) #define glGetNamedProgramLocalParameterdvEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterdvEXT) #define glGetNamedProgramLocalParameterfvEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterfvEXT) #define glGetNamedProgramStringEXT GLEW_GET_FUN(__glewGetNamedProgramStringEXT) #define glGetNamedProgramivEXT GLEW_GET_FUN(__glewGetNamedProgramivEXT) #define glGetNamedRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetNamedRenderbufferParameterivEXT) #define glGetPointerIndexedvEXT GLEW_GET_FUN(__glewGetPointerIndexedvEXT) #define glGetPointeri_vEXT GLEW_GET_FUN(__glewGetPointeri_vEXT) #define glGetTextureImageEXT GLEW_GET_FUN(__glewGetTextureImageEXT) #define glGetTextureLevelParameterfvEXT GLEW_GET_FUN(__glewGetTextureLevelParameterfvEXT) #define glGetTextureLevelParameterivEXT GLEW_GET_FUN(__glewGetTextureLevelParameterivEXT) #define glGetTextureParameterIivEXT GLEW_GET_FUN(__glewGetTextureParameterIivEXT) #define glGetTextureParameterIuivEXT GLEW_GET_FUN(__glewGetTextureParameterIuivEXT) #define glGetTextureParameterfvEXT GLEW_GET_FUN(__glewGetTextureParameterfvEXT) #define glGetTextureParameterivEXT GLEW_GET_FUN(__glewGetTextureParameterivEXT) #define glGetVertexArrayIntegeri_vEXT GLEW_GET_FUN(__glewGetVertexArrayIntegeri_vEXT) #define glGetVertexArrayIntegervEXT GLEW_GET_FUN(__glewGetVertexArrayIntegervEXT) #define glGetVertexArrayPointeri_vEXT GLEW_GET_FUN(__glewGetVertexArrayPointeri_vEXT) #define glGetVertexArrayPointervEXT GLEW_GET_FUN(__glewGetVertexArrayPointervEXT) #define glMapNamedBufferEXT GLEW_GET_FUN(__glewMapNamedBufferEXT) #define glMapNamedBufferRangeEXT GLEW_GET_FUN(__glewMapNamedBufferRangeEXT) #define glMatrixFrustumEXT GLEW_GET_FUN(__glewMatrixFrustumEXT) #define glMatrixLoadIdentityEXT GLEW_GET_FUN(__glewMatrixLoadIdentityEXT) #define glMatrixLoadTransposedEXT GLEW_GET_FUN(__glewMatrixLoadTransposedEXT) #define glMatrixLoadTransposefEXT GLEW_GET_FUN(__glewMatrixLoadTransposefEXT) #define glMatrixLoaddEXT GLEW_GET_FUN(__glewMatrixLoaddEXT) #define glMatrixLoadfEXT GLEW_GET_FUN(__glewMatrixLoadfEXT) #define glMatrixMultTransposedEXT GLEW_GET_FUN(__glewMatrixMultTransposedEXT) #define glMatrixMultTransposefEXT GLEW_GET_FUN(__glewMatrixMultTransposefEXT) #define glMatrixMultdEXT GLEW_GET_FUN(__glewMatrixMultdEXT) #define glMatrixMultfEXT GLEW_GET_FUN(__glewMatrixMultfEXT) #define glMatrixOrthoEXT GLEW_GET_FUN(__glewMatrixOrthoEXT) #define glMatrixPopEXT GLEW_GET_FUN(__glewMatrixPopEXT) #define glMatrixPushEXT GLEW_GET_FUN(__glewMatrixPushEXT) #define glMatrixRotatedEXT GLEW_GET_FUN(__glewMatrixRotatedEXT) #define glMatrixRotatefEXT GLEW_GET_FUN(__glewMatrixRotatefEXT) #define glMatrixScaledEXT GLEW_GET_FUN(__glewMatrixScaledEXT) #define glMatrixScalefEXT GLEW_GET_FUN(__glewMatrixScalefEXT) #define glMatrixTranslatedEXT GLEW_GET_FUN(__glewMatrixTranslatedEXT) #define glMatrixTranslatefEXT GLEW_GET_FUN(__glewMatrixTranslatefEXT) #define glMultiTexBufferEXT GLEW_GET_FUN(__glewMultiTexBufferEXT) #define glMultiTexCoordPointerEXT GLEW_GET_FUN(__glewMultiTexCoordPointerEXT) #define glMultiTexEnvfEXT GLEW_GET_FUN(__glewMultiTexEnvfEXT) #define glMultiTexEnvfvEXT GLEW_GET_FUN(__glewMultiTexEnvfvEXT) #define glMultiTexEnviEXT GLEW_GET_FUN(__glewMultiTexEnviEXT) #define glMultiTexEnvivEXT GLEW_GET_FUN(__glewMultiTexEnvivEXT) #define glMultiTexGendEXT GLEW_GET_FUN(__glewMultiTexGendEXT) #define glMultiTexGendvEXT GLEW_GET_FUN(__glewMultiTexGendvEXT) #define glMultiTexGenfEXT GLEW_GET_FUN(__glewMultiTexGenfEXT) #define glMultiTexGenfvEXT GLEW_GET_FUN(__glewMultiTexGenfvEXT) #define glMultiTexGeniEXT GLEW_GET_FUN(__glewMultiTexGeniEXT) #define glMultiTexGenivEXT GLEW_GET_FUN(__glewMultiTexGenivEXT) #define glMultiTexImage1DEXT GLEW_GET_FUN(__glewMultiTexImage1DEXT) #define glMultiTexImage2DEXT GLEW_GET_FUN(__glewMultiTexImage2DEXT) #define glMultiTexImage3DEXT GLEW_GET_FUN(__glewMultiTexImage3DEXT) #define glMultiTexParameterIivEXT GLEW_GET_FUN(__glewMultiTexParameterIivEXT) #define glMultiTexParameterIuivEXT GLEW_GET_FUN(__glewMultiTexParameterIuivEXT) #define glMultiTexParameterfEXT GLEW_GET_FUN(__glewMultiTexParameterfEXT) #define glMultiTexParameterfvEXT GLEW_GET_FUN(__glewMultiTexParameterfvEXT) #define glMultiTexParameteriEXT GLEW_GET_FUN(__glewMultiTexParameteriEXT) #define glMultiTexParameterivEXT GLEW_GET_FUN(__glewMultiTexParameterivEXT) #define glMultiTexRenderbufferEXT GLEW_GET_FUN(__glewMultiTexRenderbufferEXT) #define glMultiTexSubImage1DEXT GLEW_GET_FUN(__glewMultiTexSubImage1DEXT) #define glMultiTexSubImage2DEXT GLEW_GET_FUN(__glewMultiTexSubImage2DEXT) #define glMultiTexSubImage3DEXT GLEW_GET_FUN(__glewMultiTexSubImage3DEXT) #define glNamedBufferDataEXT GLEW_GET_FUN(__glewNamedBufferDataEXT) #define glNamedBufferSubDataEXT GLEW_GET_FUN(__glewNamedBufferSubDataEXT) #define glNamedCopyBufferSubDataEXT GLEW_GET_FUN(__glewNamedCopyBufferSubDataEXT) #define glNamedFramebufferRenderbufferEXT GLEW_GET_FUN(__glewNamedFramebufferRenderbufferEXT) #define glNamedFramebufferTexture1DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture1DEXT) #define glNamedFramebufferTexture2DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture2DEXT) #define glNamedFramebufferTexture3DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture3DEXT) #define glNamedFramebufferTextureEXT GLEW_GET_FUN(__glewNamedFramebufferTextureEXT) #define glNamedFramebufferTextureFaceEXT GLEW_GET_FUN(__glewNamedFramebufferTextureFaceEXT) #define glNamedFramebufferTextureLayerEXT GLEW_GET_FUN(__glewNamedFramebufferTextureLayerEXT) #define glNamedProgramLocalParameter4dEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4dEXT) #define glNamedProgramLocalParameter4dvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4dvEXT) #define glNamedProgramLocalParameter4fEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4fEXT) #define glNamedProgramLocalParameter4fvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4fvEXT) #define glNamedProgramLocalParameterI4iEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4iEXT) #define glNamedProgramLocalParameterI4ivEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4ivEXT) #define glNamedProgramLocalParameterI4uiEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4uiEXT) #define glNamedProgramLocalParameterI4uivEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4uivEXT) #define glNamedProgramLocalParameters4fvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameters4fvEXT) #define glNamedProgramLocalParametersI4ivEXT GLEW_GET_FUN(__glewNamedProgramLocalParametersI4ivEXT) #define glNamedProgramLocalParametersI4uivEXT GLEW_GET_FUN(__glewNamedProgramLocalParametersI4uivEXT) #define glNamedProgramStringEXT GLEW_GET_FUN(__glewNamedProgramStringEXT) #define glNamedRenderbufferStorageEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageEXT) #define glNamedRenderbufferStorageMultisampleCoverageEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleCoverageEXT) #define glNamedRenderbufferStorageMultisampleEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleEXT) #define glProgramUniform1fEXT GLEW_GET_FUN(__glewProgramUniform1fEXT) #define glProgramUniform1fvEXT GLEW_GET_FUN(__glewProgramUniform1fvEXT) #define glProgramUniform1iEXT GLEW_GET_FUN(__glewProgramUniform1iEXT) #define glProgramUniform1ivEXT GLEW_GET_FUN(__glewProgramUniform1ivEXT) #define glProgramUniform1uiEXT GLEW_GET_FUN(__glewProgramUniform1uiEXT) #define glProgramUniform1uivEXT GLEW_GET_FUN(__glewProgramUniform1uivEXT) #define glProgramUniform2fEXT GLEW_GET_FUN(__glewProgramUniform2fEXT) #define glProgramUniform2fvEXT GLEW_GET_FUN(__glewProgramUniform2fvEXT) #define glProgramUniform2iEXT GLEW_GET_FUN(__glewProgramUniform2iEXT) #define glProgramUniform2ivEXT GLEW_GET_FUN(__glewProgramUniform2ivEXT) #define glProgramUniform2uiEXT GLEW_GET_FUN(__glewProgramUniform2uiEXT) #define glProgramUniform2uivEXT GLEW_GET_FUN(__glewProgramUniform2uivEXT) #define glProgramUniform3fEXT GLEW_GET_FUN(__glewProgramUniform3fEXT) #define glProgramUniform3fvEXT GLEW_GET_FUN(__glewProgramUniform3fvEXT) #define glProgramUniform3iEXT GLEW_GET_FUN(__glewProgramUniform3iEXT) #define glProgramUniform3ivEXT GLEW_GET_FUN(__glewProgramUniform3ivEXT) #define glProgramUniform3uiEXT GLEW_GET_FUN(__glewProgramUniform3uiEXT) #define glProgramUniform3uivEXT GLEW_GET_FUN(__glewProgramUniform3uivEXT) #define glProgramUniform4fEXT GLEW_GET_FUN(__glewProgramUniform4fEXT) #define glProgramUniform4fvEXT GLEW_GET_FUN(__glewProgramUniform4fvEXT) #define glProgramUniform4iEXT GLEW_GET_FUN(__glewProgramUniform4iEXT) #define glProgramUniform4ivEXT GLEW_GET_FUN(__glewProgramUniform4ivEXT) #define glProgramUniform4uiEXT GLEW_GET_FUN(__glewProgramUniform4uiEXT) #define glProgramUniform4uivEXT GLEW_GET_FUN(__glewProgramUniform4uivEXT) #define glProgramUniformMatrix2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2fvEXT) #define glProgramUniformMatrix2x3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x3fvEXT) #define glProgramUniformMatrix2x4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x4fvEXT) #define glProgramUniformMatrix3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3fvEXT) #define glProgramUniformMatrix3x2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x2fvEXT) #define glProgramUniformMatrix3x4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x4fvEXT) #define glProgramUniformMatrix4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4fvEXT) #define glProgramUniformMatrix4x2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x2fvEXT) #define glProgramUniformMatrix4x3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x3fvEXT) #define glPushClientAttribDefaultEXT GLEW_GET_FUN(__glewPushClientAttribDefaultEXT) #define glTextureBufferEXT GLEW_GET_FUN(__glewTextureBufferEXT) #define glTextureImage1DEXT GLEW_GET_FUN(__glewTextureImage1DEXT) #define glTextureImage2DEXT GLEW_GET_FUN(__glewTextureImage2DEXT) #define glTextureImage3DEXT GLEW_GET_FUN(__glewTextureImage3DEXT) #define glTextureParameterIivEXT GLEW_GET_FUN(__glewTextureParameterIivEXT) #define glTextureParameterIuivEXT GLEW_GET_FUN(__glewTextureParameterIuivEXT) #define glTextureParameterfEXT GLEW_GET_FUN(__glewTextureParameterfEXT) #define glTextureParameterfvEXT GLEW_GET_FUN(__glewTextureParameterfvEXT) #define glTextureParameteriEXT GLEW_GET_FUN(__glewTextureParameteriEXT) #define glTextureParameterivEXT GLEW_GET_FUN(__glewTextureParameterivEXT) #define glTextureRenderbufferEXT GLEW_GET_FUN(__glewTextureRenderbufferEXT) #define glTextureSubImage1DEXT GLEW_GET_FUN(__glewTextureSubImage1DEXT) #define glTextureSubImage2DEXT GLEW_GET_FUN(__glewTextureSubImage2DEXT) #define glTextureSubImage3DEXT GLEW_GET_FUN(__glewTextureSubImage3DEXT) #define glUnmapNamedBufferEXT GLEW_GET_FUN(__glewUnmapNamedBufferEXT) #define glVertexArrayColorOffsetEXT GLEW_GET_FUN(__glewVertexArrayColorOffsetEXT) #define glVertexArrayEdgeFlagOffsetEXT GLEW_GET_FUN(__glewVertexArrayEdgeFlagOffsetEXT) #define glVertexArrayFogCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayFogCoordOffsetEXT) #define glVertexArrayIndexOffsetEXT GLEW_GET_FUN(__glewVertexArrayIndexOffsetEXT) #define glVertexArrayMultiTexCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayMultiTexCoordOffsetEXT) #define glVertexArrayNormalOffsetEXT GLEW_GET_FUN(__glewVertexArrayNormalOffsetEXT) #define glVertexArraySecondaryColorOffsetEXT GLEW_GET_FUN(__glewVertexArraySecondaryColorOffsetEXT) #define glVertexArrayTexCoordOffsetEXT GLEW_GET_FUN(__glewVertexArrayTexCoordOffsetEXT) #define glVertexArrayVertexAttribDivisorEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribDivisorEXT) #define glVertexArrayVertexAttribIOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribIOffsetEXT) #define glVertexArrayVertexAttribOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribOffsetEXT) #define glVertexArrayVertexOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexOffsetEXT) #define GLEW_EXT_direct_state_access GLEW_GET_VAR(__GLEW_EXT_direct_state_access) #endif /* GL_EXT_direct_state_access */ /* -------------------------- GL_EXT_draw_buffers2 ------------------------- */ #ifndef GL_EXT_draw_buffers2 #define GL_EXT_draw_buffers2 1 typedef void (GLAPIENTRY * PFNGLCOLORMASKINDEXEDEXTPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); typedef void (GLAPIENTRY * PFNGLDISABLEINDEXEDEXTPROC) (GLenum target, GLuint index); typedef void (GLAPIENTRY * PFNGLENABLEINDEXEDEXTPROC) (GLenum target, GLuint index); typedef void (GLAPIENTRY * PFNGLGETBOOLEANINDEXEDVEXTPROC) (GLenum value, GLuint index, GLboolean* data); typedef void (GLAPIENTRY * PFNGLGETINTEGERINDEXEDVEXTPROC) (GLenum value, GLuint index, GLint* data); typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target, GLuint index); #define glColorMaskIndexedEXT GLEW_GET_FUN(__glewColorMaskIndexedEXT) #define glDisableIndexedEXT GLEW_GET_FUN(__glewDisableIndexedEXT) #define glEnableIndexedEXT GLEW_GET_FUN(__glewEnableIndexedEXT) #define glGetBooleanIndexedvEXT GLEW_GET_FUN(__glewGetBooleanIndexedvEXT) #define glGetIntegerIndexedvEXT GLEW_GET_FUN(__glewGetIntegerIndexedvEXT) #define glIsEnabledIndexedEXT GLEW_GET_FUN(__glewIsEnabledIndexedEXT) #define GLEW_EXT_draw_buffers2 GLEW_GET_VAR(__GLEW_EXT_draw_buffers2) #endif /* GL_EXT_draw_buffers2 */ /* ------------------------- GL_EXT_draw_instanced ------------------------- */ #ifndef GL_EXT_draw_instanced #define GL_EXT_draw_instanced 1 typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); #define glDrawArraysInstancedEXT GLEW_GET_FUN(__glewDrawArraysInstancedEXT) #define glDrawElementsInstancedEXT GLEW_GET_FUN(__glewDrawElementsInstancedEXT) #define GLEW_EXT_draw_instanced GLEW_GET_VAR(__GLEW_EXT_draw_instanced) #endif /* GL_EXT_draw_instanced */ /* ----------------------- GL_EXT_draw_range_elements ---------------------- */ #ifndef GL_EXT_draw_range_elements #define GL_EXT_draw_range_elements 1 #define GL_MAX_ELEMENTS_VERTICES_EXT 0x80E8 #define GL_MAX_ELEMENTS_INDICES_EXT 0x80E9 typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); #define glDrawRangeElementsEXT GLEW_GET_FUN(__glewDrawRangeElementsEXT) #define GLEW_EXT_draw_range_elements GLEW_GET_VAR(__GLEW_EXT_draw_range_elements) #endif /* GL_EXT_draw_range_elements */ /* ---------------------------- GL_EXT_fog_coord --------------------------- */ #ifndef GL_EXT_fog_coord #define GL_EXT_fog_coord 1 #define GL_FOG_COORDINATE_SOURCE_EXT 0x8450 #define GL_FOG_COORDINATE_EXT 0x8451 #define GL_FRAGMENT_DEPTH_EXT 0x8452 #define GL_CURRENT_FOG_COORDINATE_EXT 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 #define GL_FOG_COORDINATE_ARRAY_EXT 0x8457 typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord); typedef void (GLAPIENTRY * PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord); typedef void (GLAPIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord); typedef void (GLAPIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord); #define glFogCoordPointerEXT GLEW_GET_FUN(__glewFogCoordPointerEXT) #define glFogCoorddEXT GLEW_GET_FUN(__glewFogCoorddEXT) #define glFogCoorddvEXT GLEW_GET_FUN(__glewFogCoorddvEXT) #define glFogCoordfEXT GLEW_GET_FUN(__glewFogCoordfEXT) #define glFogCoordfvEXT GLEW_GET_FUN(__glewFogCoordfvEXT) #define GLEW_EXT_fog_coord GLEW_GET_VAR(__GLEW_EXT_fog_coord) #endif /* GL_EXT_fog_coord */ /* ------------------------ GL_EXT_fragment_lighting ----------------------- */ #ifndef GL_EXT_fragment_lighting #define GL_EXT_fragment_lighting 1 #define GL_FRAGMENT_LIGHTING_EXT 0x8400 #define GL_FRAGMENT_COLOR_MATERIAL_EXT 0x8401 #define GL_FRAGMENT_COLOR_MATERIAL_FACE_EXT 0x8402 #define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_EXT 0x8403 #define GL_MAX_FRAGMENT_LIGHTS_EXT 0x8404 #define GL_MAX_ACTIVE_LIGHTS_EXT 0x8405 #define GL_CURRENT_RASTER_NORMAL_EXT 0x8406 #define GL_LIGHT_ENV_MODE_EXT 0x8407 #define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT 0x8408 #define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT 0x8409 #define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_EXT 0x840A #define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT 0x840B #define GL_FRAGMENT_LIGHT0_EXT 0x840C #define GL_FRAGMENT_LIGHT7_EXT 0x8413 typedef void (GLAPIENTRY * PFNGLFRAGMENTCOLORMATERIALEXTPROC) (GLenum face, GLenum mode); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFEXTPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFVEXTPROC) (GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIEXTPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIVEXTPROC) (GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFEXTPROC) (GLenum light, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFVEXTPROC) (GLenum light, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIEXTPROC) (GLenum light, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIVEXTPROC) (GLenum light, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFEXTPROC) (GLenum face, GLenum pname, const GLfloat param); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFVEXTPROC) (GLenum face, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIEXTPROC) (GLenum face, GLenum pname, const GLint param); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIVEXTPROC) (GLenum face, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTFVEXTPROC) (GLenum light, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTIVEXTPROC) (GLenum light, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALFVEXTPROC) (GLenum face, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVEXTPROC) (GLenum face, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLLIGHTENVIEXTPROC) (GLenum pname, GLint param); #define glFragmentColorMaterialEXT GLEW_GET_FUN(__glewFragmentColorMaterialEXT) #define glFragmentLightModelfEXT GLEW_GET_FUN(__glewFragmentLightModelfEXT) #define glFragmentLightModelfvEXT GLEW_GET_FUN(__glewFragmentLightModelfvEXT) #define glFragmentLightModeliEXT GLEW_GET_FUN(__glewFragmentLightModeliEXT) #define glFragmentLightModelivEXT GLEW_GET_FUN(__glewFragmentLightModelivEXT) #define glFragmentLightfEXT GLEW_GET_FUN(__glewFragmentLightfEXT) #define glFragmentLightfvEXT GLEW_GET_FUN(__glewFragmentLightfvEXT) #define glFragmentLightiEXT GLEW_GET_FUN(__glewFragmentLightiEXT) #define glFragmentLightivEXT GLEW_GET_FUN(__glewFragmentLightivEXT) #define glFragmentMaterialfEXT GLEW_GET_FUN(__glewFragmentMaterialfEXT) #define glFragmentMaterialfvEXT GLEW_GET_FUN(__glewFragmentMaterialfvEXT) #define glFragmentMaterialiEXT GLEW_GET_FUN(__glewFragmentMaterialiEXT) #define glFragmentMaterialivEXT GLEW_GET_FUN(__glewFragmentMaterialivEXT) #define glGetFragmentLightfvEXT GLEW_GET_FUN(__glewGetFragmentLightfvEXT) #define glGetFragmentLightivEXT GLEW_GET_FUN(__glewGetFragmentLightivEXT) #define glGetFragmentMaterialfvEXT GLEW_GET_FUN(__glewGetFragmentMaterialfvEXT) #define glGetFragmentMaterialivEXT GLEW_GET_FUN(__glewGetFragmentMaterialivEXT) #define glLightEnviEXT GLEW_GET_FUN(__glewLightEnviEXT) #define GLEW_EXT_fragment_lighting GLEW_GET_VAR(__GLEW_EXT_fragment_lighting) #endif /* GL_EXT_fragment_lighting */ /* ------------------------ GL_EXT_framebuffer_blit ------------------------ */ #ifndef GL_EXT_framebuffer_blit #define GL_EXT_framebuffer_blit 1 #define GL_DRAW_FRAMEBUFFER_BINDING_EXT 0x8CA6 #define GL_READ_FRAMEBUFFER_EXT 0x8CA8 #define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9 #define GL_READ_FRAMEBUFFER_BINDING_EXT 0x8CAA typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); #define glBlitFramebufferEXT GLEW_GET_FUN(__glewBlitFramebufferEXT) #define GLEW_EXT_framebuffer_blit GLEW_GET_VAR(__GLEW_EXT_framebuffer_blit) #endif /* GL_EXT_framebuffer_blit */ /* --------------------- GL_EXT_framebuffer_multisample -------------------- */ #ifndef GL_EXT_framebuffer_multisample #define GL_EXT_framebuffer_multisample 1 #define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB #define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56 #define GL_MAX_SAMPLES_EXT 0x8D57 typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); #define glRenderbufferStorageMultisampleEXT GLEW_GET_FUN(__glewRenderbufferStorageMultisampleEXT) #define GLEW_EXT_framebuffer_multisample GLEW_GET_VAR(__GLEW_EXT_framebuffer_multisample) #endif /* GL_EXT_framebuffer_multisample */ /* --------------- GL_EXT_framebuffer_multisample_blit_scaled -------------- */ #ifndef GL_EXT_framebuffer_multisample_blit_scaled #define GL_EXT_framebuffer_multisample_blit_scaled 1 #define GL_SCALED_RESOLVE_FASTEST_EXT 0x90BA #define GL_SCALED_RESOLVE_NICEST_EXT 0x90BB #define GLEW_EXT_framebuffer_multisample_blit_scaled GLEW_GET_VAR(__GLEW_EXT_framebuffer_multisample_blit_scaled) #endif /* GL_EXT_framebuffer_multisample_blit_scaled */ /* ----------------------- GL_EXT_framebuffer_object ----------------------- */ #ifndef GL_EXT_framebuffer_object #define GL_EXT_framebuffer_object 1 #define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 #define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 #define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 #define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 #define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6 #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 #define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA #define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB #define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC #define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD #define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF #define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 #define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 #define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 #define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 #define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 #define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 #define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 #define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 #define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 #define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 #define GL_COLOR_ATTACHMENT10_EXT 0x8CEA #define GL_COLOR_ATTACHMENT11_EXT 0x8CEB #define GL_COLOR_ATTACHMENT12_EXT 0x8CEC #define GL_COLOR_ATTACHMENT13_EXT 0x8CED #define GL_COLOR_ATTACHMENT14_EXT 0x8CEE #define GL_COLOR_ATTACHMENT15_EXT 0x8CEF #define GL_DEPTH_ATTACHMENT_EXT 0x8D00 #define GL_STENCIL_ATTACHMENT_EXT 0x8D20 #define GL_FRAMEBUFFER_EXT 0x8D40 #define GL_RENDERBUFFER_EXT 0x8D41 #define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 #define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 #define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 #define GL_STENCIL_INDEX1_EXT 0x8D46 #define GL_STENCIL_INDEX4_EXT 0x8D47 #define GL_STENCIL_INDEX8_EXT 0x8D48 #define GL_STENCIL_INDEX16_EXT 0x8D49 #define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50 #define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51 #define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52 #define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53 #define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54 #define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55 typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer); typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer); typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint* framebuffers); typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint* renderbuffers); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint* framebuffers); typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint* renderbuffers); typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); #define glBindFramebufferEXT GLEW_GET_FUN(__glewBindFramebufferEXT) #define glBindRenderbufferEXT GLEW_GET_FUN(__glewBindRenderbufferEXT) #define glCheckFramebufferStatusEXT GLEW_GET_FUN(__glewCheckFramebufferStatusEXT) #define glDeleteFramebuffersEXT GLEW_GET_FUN(__glewDeleteFramebuffersEXT) #define glDeleteRenderbuffersEXT GLEW_GET_FUN(__glewDeleteRenderbuffersEXT) #define glFramebufferRenderbufferEXT GLEW_GET_FUN(__glewFramebufferRenderbufferEXT) #define glFramebufferTexture1DEXT GLEW_GET_FUN(__glewFramebufferTexture1DEXT) #define glFramebufferTexture2DEXT GLEW_GET_FUN(__glewFramebufferTexture2DEXT) #define glFramebufferTexture3DEXT GLEW_GET_FUN(__glewFramebufferTexture3DEXT) #define glGenFramebuffersEXT GLEW_GET_FUN(__glewGenFramebuffersEXT) #define glGenRenderbuffersEXT GLEW_GET_FUN(__glewGenRenderbuffersEXT) #define glGenerateMipmapEXT GLEW_GET_FUN(__glewGenerateMipmapEXT) #define glGetFramebufferAttachmentParameterivEXT GLEW_GET_FUN(__glewGetFramebufferAttachmentParameterivEXT) #define glGetRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetRenderbufferParameterivEXT) #define glIsFramebufferEXT GLEW_GET_FUN(__glewIsFramebufferEXT) #define glIsRenderbufferEXT GLEW_GET_FUN(__glewIsRenderbufferEXT) #define glRenderbufferStorageEXT GLEW_GET_FUN(__glewRenderbufferStorageEXT) #define GLEW_EXT_framebuffer_object GLEW_GET_VAR(__GLEW_EXT_framebuffer_object) #endif /* GL_EXT_framebuffer_object */ /* ------------------------ GL_EXT_framebuffer_sRGB ------------------------ */ #ifndef GL_EXT_framebuffer_sRGB #define GL_EXT_framebuffer_sRGB 1 #define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9 #define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA #define GLEW_EXT_framebuffer_sRGB GLEW_GET_VAR(__GLEW_EXT_framebuffer_sRGB) #endif /* GL_EXT_framebuffer_sRGB */ /* ------------------------ GL_EXT_geometry_shader4 ------------------------ */ #ifndef GL_EXT_geometry_shader4 #define GL_EXT_geometry_shader4 1 #define GL_LINES_ADJACENCY_EXT 0xA #define GL_LINE_STRIP_ADJACENCY_EXT 0xB #define GL_TRIANGLES_ADJACENCY_EXT 0xC #define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD #define GL_PROGRAM_POINT_SIZE_EXT 0x8642 #define GL_MAX_VARYING_COMPONENTS_EXT 0x8B4B #define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4 #define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7 #define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8 #define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9 #define GL_GEOMETRY_SHADER_EXT 0x8DD9 #define GL_GEOMETRY_VERTICES_OUT_EXT 0x8DDA #define GL_GEOMETRY_INPUT_TYPE_EXT 0x8DDB #define GL_GEOMETRY_OUTPUT_TYPE_EXT 0x8DDC #define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT 0x8DDD #define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT 0x8DDE #define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF #define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0 #define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value); #define glFramebufferTextureEXT GLEW_GET_FUN(__glewFramebufferTextureEXT) #define glFramebufferTextureFaceEXT GLEW_GET_FUN(__glewFramebufferTextureFaceEXT) #define glProgramParameteriEXT GLEW_GET_FUN(__glewProgramParameteriEXT) #define GLEW_EXT_geometry_shader4 GLEW_GET_VAR(__GLEW_EXT_geometry_shader4) #endif /* GL_EXT_geometry_shader4 */ /* --------------------- GL_EXT_gpu_program_parameters --------------------- */ #ifndef GL_EXT_gpu_program_parameters #define GL_EXT_gpu_program_parameters 1 typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat* params); #define glProgramEnvParameters4fvEXT GLEW_GET_FUN(__glewProgramEnvParameters4fvEXT) #define glProgramLocalParameters4fvEXT GLEW_GET_FUN(__glewProgramLocalParameters4fvEXT) #define GLEW_EXT_gpu_program_parameters GLEW_GET_VAR(__GLEW_EXT_gpu_program_parameters) #endif /* GL_EXT_gpu_program_parameters */ /* --------------------------- GL_EXT_gpu_shader4 -------------------------- */ #ifndef GL_EXT_gpu_shader4 #define GL_EXT_gpu_shader4 1 #define GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD #define GL_SAMPLER_1D_ARRAY_EXT 0x8DC0 #define GL_SAMPLER_2D_ARRAY_EXT 0x8DC1 #define GL_SAMPLER_BUFFER_EXT 0x8DC2 #define GL_SAMPLER_1D_ARRAY_SHADOW_EXT 0x8DC3 #define GL_SAMPLER_2D_ARRAY_SHADOW_EXT 0x8DC4 #define GL_SAMPLER_CUBE_SHADOW_EXT 0x8DC5 #define GL_UNSIGNED_INT_VEC2_EXT 0x8DC6 #define GL_UNSIGNED_INT_VEC3_EXT 0x8DC7 #define GL_UNSIGNED_INT_VEC4_EXT 0x8DC8 #define GL_INT_SAMPLER_1D_EXT 0x8DC9 #define GL_INT_SAMPLER_2D_EXT 0x8DCA #define GL_INT_SAMPLER_3D_EXT 0x8DCB #define GL_INT_SAMPLER_CUBE_EXT 0x8DCC #define GL_INT_SAMPLER_2D_RECT_EXT 0x8DCD #define GL_INT_SAMPLER_1D_ARRAY_EXT 0x8DCE #define GL_INT_SAMPLER_2D_ARRAY_EXT 0x8DCF #define GL_INT_SAMPLER_BUFFER_EXT 0x8DD0 #define GL_UNSIGNED_INT_SAMPLER_1D_EXT 0x8DD1 #define GL_UNSIGNED_INT_SAMPLER_2D_EXT 0x8DD2 #define GL_UNSIGNED_INT_SAMPLER_3D_EXT 0x8DD3 #define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT 0x8DD4 #define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5 #define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6 #define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7 #define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8 typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONEXTPROC) (GLuint program, GLuint color, const GLchar *name); typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONEXTPROC) (GLuint program, const GLchar *name); typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVEXTPROC) (GLuint program, GLint location, GLuint *params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVEXTPROC) (GLuint index, GLenum pname, GLint *params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVEXTPROC) (GLuint index, GLenum pname, GLuint *params); typedef void (GLAPIENTRY * PFNGLUNIFORM1UIEXTPROC) (GLint location, GLuint v0); typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); typedef void (GLAPIENTRY * PFNGLUNIFORM2UIEXTPROC) (GLint location, GLuint v0, GLuint v1); typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); typedef void (GLAPIENTRY * PFNGLUNIFORM3UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); typedef void (GLAPIENTRY * PFNGLUNIFORM4UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IEXTPROC) (GLuint index, GLint x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVEXTPROC) (GLuint index, const GLint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIEXTPROC) (GLuint index, GLuint x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVEXTPROC) (GLuint index, const GLuint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IEXTPROC) (GLuint index, GLint x, GLint y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVEXTPROC) (GLuint index, const GLint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIEXTPROC) (GLuint index, GLuint x, GLuint y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVEXTPROC) (GLuint index, const GLuint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IEXTPROC) (GLuint index, GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVEXTPROC) (GLuint index, const GLint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVEXTPROC) (GLuint index, const GLuint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVEXTPROC) (GLuint index, const GLbyte *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVEXTPROC) (GLuint index, const GLint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVEXTPROC) (GLuint index, const GLshort *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVEXTPROC) (GLuint index, const GLubyte *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVEXTPROC) (GLuint index, const GLuint *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVEXTPROC) (GLuint index, const GLushort *v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); #define glBindFragDataLocationEXT GLEW_GET_FUN(__glewBindFragDataLocationEXT) #define glGetFragDataLocationEXT GLEW_GET_FUN(__glewGetFragDataLocationEXT) #define glGetUniformuivEXT GLEW_GET_FUN(__glewGetUniformuivEXT) #define glGetVertexAttribIivEXT GLEW_GET_FUN(__glewGetVertexAttribIivEXT) #define glGetVertexAttribIuivEXT GLEW_GET_FUN(__glewGetVertexAttribIuivEXT) #define glUniform1uiEXT GLEW_GET_FUN(__glewUniform1uiEXT) #define glUniform1uivEXT GLEW_GET_FUN(__glewUniform1uivEXT) #define glUniform2uiEXT GLEW_GET_FUN(__glewUniform2uiEXT) #define glUniform2uivEXT GLEW_GET_FUN(__glewUniform2uivEXT) #define glUniform3uiEXT GLEW_GET_FUN(__glewUniform3uiEXT) #define glUniform3uivEXT GLEW_GET_FUN(__glewUniform3uivEXT) #define glUniform4uiEXT GLEW_GET_FUN(__glewUniform4uiEXT) #define glUniform4uivEXT GLEW_GET_FUN(__glewUniform4uivEXT) #define glVertexAttribI1iEXT GLEW_GET_FUN(__glewVertexAttribI1iEXT) #define glVertexAttribI1ivEXT GLEW_GET_FUN(__glewVertexAttribI1ivEXT) #define glVertexAttribI1uiEXT GLEW_GET_FUN(__glewVertexAttribI1uiEXT) #define glVertexAttribI1uivEXT GLEW_GET_FUN(__glewVertexAttribI1uivEXT) #define glVertexAttribI2iEXT GLEW_GET_FUN(__glewVertexAttribI2iEXT) #define glVertexAttribI2ivEXT GLEW_GET_FUN(__glewVertexAttribI2ivEXT) #define glVertexAttribI2uiEXT GLEW_GET_FUN(__glewVertexAttribI2uiEXT) #define glVertexAttribI2uivEXT GLEW_GET_FUN(__glewVertexAttribI2uivEXT) #define glVertexAttribI3iEXT GLEW_GET_FUN(__glewVertexAttribI3iEXT) #define glVertexAttribI3ivEXT GLEW_GET_FUN(__glewVertexAttribI3ivEXT) #define glVertexAttribI3uiEXT GLEW_GET_FUN(__glewVertexAttribI3uiEXT) #define glVertexAttribI3uivEXT GLEW_GET_FUN(__glewVertexAttribI3uivEXT) #define glVertexAttribI4bvEXT GLEW_GET_FUN(__glewVertexAttribI4bvEXT) #define glVertexAttribI4iEXT GLEW_GET_FUN(__glewVertexAttribI4iEXT) #define glVertexAttribI4ivEXT GLEW_GET_FUN(__glewVertexAttribI4ivEXT) #define glVertexAttribI4svEXT GLEW_GET_FUN(__glewVertexAttribI4svEXT) #define glVertexAttribI4ubvEXT GLEW_GET_FUN(__glewVertexAttribI4ubvEXT) #define glVertexAttribI4uiEXT GLEW_GET_FUN(__glewVertexAttribI4uiEXT) #define glVertexAttribI4uivEXT GLEW_GET_FUN(__glewVertexAttribI4uivEXT) #define glVertexAttribI4usvEXT GLEW_GET_FUN(__glewVertexAttribI4usvEXT) #define glVertexAttribIPointerEXT GLEW_GET_FUN(__glewVertexAttribIPointerEXT) #define GLEW_EXT_gpu_shader4 GLEW_GET_VAR(__GLEW_EXT_gpu_shader4) #endif /* GL_EXT_gpu_shader4 */ /* ---------------------------- GL_EXT_histogram --------------------------- */ #ifndef GL_EXT_histogram #define GL_EXT_histogram 1 #define GL_HISTOGRAM_EXT 0x8024 #define GL_PROXY_HISTOGRAM_EXT 0x8025 #define GL_HISTOGRAM_WIDTH_EXT 0x8026 #define GL_HISTOGRAM_FORMAT_EXT 0x8027 #define GL_HISTOGRAM_RED_SIZE_EXT 0x8028 #define GL_HISTOGRAM_GREEN_SIZE_EXT 0x8029 #define GL_HISTOGRAM_BLUE_SIZE_EXT 0x802A #define GL_HISTOGRAM_ALPHA_SIZE_EXT 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE_EXT 0x802C #define GL_HISTOGRAM_SINK_EXT 0x802D #define GL_MINMAX_EXT 0x802E #define GL_MINMAX_FORMAT_EXT 0x802F #define GL_MINMAX_SINK_EXT 0x8030 typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values); typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void *values); typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); typedef void (GLAPIENTRY * PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink); typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMEXTPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLRESETMINMAXEXTPROC) (GLenum target); #define glGetHistogramEXT GLEW_GET_FUN(__glewGetHistogramEXT) #define glGetHistogramParameterfvEXT GLEW_GET_FUN(__glewGetHistogramParameterfvEXT) #define glGetHistogramParameterivEXT GLEW_GET_FUN(__glewGetHistogramParameterivEXT) #define glGetMinmaxEXT GLEW_GET_FUN(__glewGetMinmaxEXT) #define glGetMinmaxParameterfvEXT GLEW_GET_FUN(__glewGetMinmaxParameterfvEXT) #define glGetMinmaxParameterivEXT GLEW_GET_FUN(__glewGetMinmaxParameterivEXT) #define glHistogramEXT GLEW_GET_FUN(__glewHistogramEXT) #define glMinmaxEXT GLEW_GET_FUN(__glewMinmaxEXT) #define glResetHistogramEXT GLEW_GET_FUN(__glewResetHistogramEXT) #define glResetMinmaxEXT GLEW_GET_FUN(__glewResetMinmaxEXT) #define GLEW_EXT_histogram GLEW_GET_VAR(__GLEW_EXT_histogram) #endif /* GL_EXT_histogram */ /* ----------------------- GL_EXT_index_array_formats ---------------------- */ #ifndef GL_EXT_index_array_formats #define GL_EXT_index_array_formats 1 #define GLEW_EXT_index_array_formats GLEW_GET_VAR(__GLEW_EXT_index_array_formats) #endif /* GL_EXT_index_array_formats */ /* --------------------------- GL_EXT_index_func --------------------------- */ #ifndef GL_EXT_index_func #define GL_EXT_index_func 1 typedef void (GLAPIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLfloat ref); #define glIndexFuncEXT GLEW_GET_FUN(__glewIndexFuncEXT) #define GLEW_EXT_index_func GLEW_GET_VAR(__GLEW_EXT_index_func) #endif /* GL_EXT_index_func */ /* ------------------------- GL_EXT_index_material ------------------------- */ #ifndef GL_EXT_index_material #define GL_EXT_index_material 1 typedef void (GLAPIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode); #define glIndexMaterialEXT GLEW_GET_FUN(__glewIndexMaterialEXT) #define GLEW_EXT_index_material GLEW_GET_VAR(__GLEW_EXT_index_material) #endif /* GL_EXT_index_material */ /* -------------------------- GL_EXT_index_texture ------------------------- */ #ifndef GL_EXT_index_texture #define GL_EXT_index_texture 1 #define GLEW_EXT_index_texture GLEW_GET_VAR(__GLEW_EXT_index_texture) #endif /* GL_EXT_index_texture */ /* -------------------------- GL_EXT_light_texture ------------------------- */ #ifndef GL_EXT_light_texture #define GL_EXT_light_texture 1 #define GL_FRAGMENT_MATERIAL_EXT 0x8349 #define GL_FRAGMENT_NORMAL_EXT 0x834A #define GL_FRAGMENT_COLOR_EXT 0x834C #define GL_ATTENUATION_EXT 0x834D #define GL_SHADOW_ATTENUATION_EXT 0x834E #define GL_TEXTURE_APPLICATION_MODE_EXT 0x834F #define GL_TEXTURE_LIGHT_EXT 0x8350 #define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351 #define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352 typedef void (GLAPIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode); typedef void (GLAPIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname); typedef void (GLAPIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode); #define glApplyTextureEXT GLEW_GET_FUN(__glewApplyTextureEXT) #define glTextureLightEXT GLEW_GET_FUN(__glewTextureLightEXT) #define glTextureMaterialEXT GLEW_GET_FUN(__glewTextureMaterialEXT) #define GLEW_EXT_light_texture GLEW_GET_VAR(__GLEW_EXT_light_texture) #endif /* GL_EXT_light_texture */ /* ------------------------- GL_EXT_misc_attribute ------------------------- */ #ifndef GL_EXT_misc_attribute #define GL_EXT_misc_attribute 1 #define GLEW_EXT_misc_attribute GLEW_GET_VAR(__GLEW_EXT_misc_attribute) #endif /* GL_EXT_misc_attribute */ /* ------------------------ GL_EXT_multi_draw_arrays ----------------------- */ #ifndef GL_EXT_multi_draw_arrays #define GL_EXT_multi_draw_arrays 1 typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, const GLint* first, const GLsizei *count, GLsizei primcount); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, GLsizei* count, GLenum type, const void *const *indices, GLsizei primcount); #define glMultiDrawArraysEXT GLEW_GET_FUN(__glewMultiDrawArraysEXT) #define glMultiDrawElementsEXT GLEW_GET_FUN(__glewMultiDrawElementsEXT) #define GLEW_EXT_multi_draw_arrays GLEW_GET_VAR(__GLEW_EXT_multi_draw_arrays) #endif /* GL_EXT_multi_draw_arrays */ /* --------------------------- GL_EXT_multisample -------------------------- */ #ifndef GL_EXT_multisample #define GL_EXT_multisample 1 #define GL_MULTISAMPLE_EXT 0x809D #define GL_SAMPLE_ALPHA_TO_MASK_EXT 0x809E #define GL_SAMPLE_ALPHA_TO_ONE_EXT 0x809F #define GL_SAMPLE_MASK_EXT 0x80A0 #define GL_1PASS_EXT 0x80A1 #define GL_2PASS_0_EXT 0x80A2 #define GL_2PASS_1_EXT 0x80A3 #define GL_4PASS_0_EXT 0x80A4 #define GL_4PASS_1_EXT 0x80A5 #define GL_4PASS_2_EXT 0x80A6 #define GL_4PASS_3_EXT 0x80A7 #define GL_SAMPLE_BUFFERS_EXT 0x80A8 #define GL_SAMPLES_EXT 0x80A9 #define GL_SAMPLE_MASK_VALUE_EXT 0x80AA #define GL_SAMPLE_MASK_INVERT_EXT 0x80AB #define GL_SAMPLE_PATTERN_EXT 0x80AC #define GL_MULTISAMPLE_BIT_EXT 0x20000000 typedef void (GLAPIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert); typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern); #define glSampleMaskEXT GLEW_GET_FUN(__glewSampleMaskEXT) #define glSamplePatternEXT GLEW_GET_FUN(__glewSamplePatternEXT) #define GLEW_EXT_multisample GLEW_GET_VAR(__GLEW_EXT_multisample) #endif /* GL_EXT_multisample */ /* ---------------------- GL_EXT_packed_depth_stencil ---------------------- */ #ifndef GL_EXT_packed_depth_stencil #define GL_EXT_packed_depth_stencil 1 #define GL_DEPTH_STENCIL_EXT 0x84F9 #define GL_UNSIGNED_INT_24_8_EXT 0x84FA #define GL_DEPTH24_STENCIL8_EXT 0x88F0 #define GL_TEXTURE_STENCIL_SIZE_EXT 0x88F1 #define GLEW_EXT_packed_depth_stencil GLEW_GET_VAR(__GLEW_EXT_packed_depth_stencil) #endif /* GL_EXT_packed_depth_stencil */ /* -------------------------- GL_EXT_packed_float -------------------------- */ #ifndef GL_EXT_packed_float #define GL_EXT_packed_float 1 #define GL_R11F_G11F_B10F_EXT 0x8C3A #define GL_UNSIGNED_INT_10F_11F_11F_REV_EXT 0x8C3B #define GL_RGBA_SIGNED_COMPONENTS_EXT 0x8C3C #define GLEW_EXT_packed_float GLEW_GET_VAR(__GLEW_EXT_packed_float) #endif /* GL_EXT_packed_float */ /* -------------------------- GL_EXT_packed_pixels ------------------------- */ #ifndef GL_EXT_packed_pixels #define GL_EXT_packed_pixels 1 #define GL_UNSIGNED_BYTE_3_3_2_EXT 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4_EXT 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 #define GL_UNSIGNED_INT_8_8_8_8_EXT 0x8035 #define GL_UNSIGNED_INT_10_10_10_2_EXT 0x8036 #define GLEW_EXT_packed_pixels GLEW_GET_VAR(__GLEW_EXT_packed_pixels) #endif /* GL_EXT_packed_pixels */ /* ------------------------ GL_EXT_paletted_texture ------------------------ */ #ifndef GL_EXT_paletted_texture #define GL_EXT_paletted_texture 1 #define GL_TEXTURE_1D 0x0DE0 #define GL_TEXTURE_2D 0x0DE1 #define GL_PROXY_TEXTURE_1D 0x8063 #define GL_PROXY_TEXTURE_2D 0x8064 #define GL_COLOR_TABLE_FORMAT_EXT 0x80D8 #define GL_COLOR_TABLE_WIDTH_EXT 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_EXT 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_EXT 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_EXT 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_EXT 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED #define GL_TEXTURE_CUBE_MAP_ARB 0x8513 #define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B typedef void (GLAPIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *data); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, void *data); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); #define glColorTableEXT GLEW_GET_FUN(__glewColorTableEXT) #define glGetColorTableEXT GLEW_GET_FUN(__glewGetColorTableEXT) #define glGetColorTableParameterfvEXT GLEW_GET_FUN(__glewGetColorTableParameterfvEXT) #define glGetColorTableParameterivEXT GLEW_GET_FUN(__glewGetColorTableParameterivEXT) #define GLEW_EXT_paletted_texture GLEW_GET_VAR(__GLEW_EXT_paletted_texture) #endif /* GL_EXT_paletted_texture */ /* ----------------------- GL_EXT_pixel_buffer_object ---------------------- */ #ifndef GL_EXT_pixel_buffer_object #define GL_EXT_pixel_buffer_object 1 #define GL_PIXEL_PACK_BUFFER_EXT 0x88EB #define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC #define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED #define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF #define GLEW_EXT_pixel_buffer_object GLEW_GET_VAR(__GLEW_EXT_pixel_buffer_object) #endif /* GL_EXT_pixel_buffer_object */ /* ------------------------- GL_EXT_pixel_transform ------------------------ */ #ifndef GL_EXT_pixel_transform #define GL_EXT_pixel_transform 1 #define GL_PIXEL_TRANSFORM_2D_EXT 0x8330 #define GL_PIXEL_MAG_FILTER_EXT 0x8331 #define GL_PIXEL_MIN_FILTER_EXT 0x8332 #define GL_PIXEL_CUBIC_WEIGHT_EXT 0x8333 #define GL_CUBIC_EXT 0x8334 #define GL_AVERAGE_EXT 0x8335 #define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336 #define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337 #define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT 0x8338 typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, const GLfloat param); typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, const GLint param); typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); #define glGetPixelTransformParameterfvEXT GLEW_GET_FUN(__glewGetPixelTransformParameterfvEXT) #define glGetPixelTransformParameterivEXT GLEW_GET_FUN(__glewGetPixelTransformParameterivEXT) #define glPixelTransformParameterfEXT GLEW_GET_FUN(__glewPixelTransformParameterfEXT) #define glPixelTransformParameterfvEXT GLEW_GET_FUN(__glewPixelTransformParameterfvEXT) #define glPixelTransformParameteriEXT GLEW_GET_FUN(__glewPixelTransformParameteriEXT) #define glPixelTransformParameterivEXT GLEW_GET_FUN(__glewPixelTransformParameterivEXT) #define GLEW_EXT_pixel_transform GLEW_GET_VAR(__GLEW_EXT_pixel_transform) #endif /* GL_EXT_pixel_transform */ /* ------------------- GL_EXT_pixel_transform_color_table ------------------ */ #ifndef GL_EXT_pixel_transform_color_table #define GL_EXT_pixel_transform_color_table 1 #define GLEW_EXT_pixel_transform_color_table GLEW_GET_VAR(__GLEW_EXT_pixel_transform_color_table) #endif /* GL_EXT_pixel_transform_color_table */ /* ------------------------ GL_EXT_point_parameters ------------------------ */ #ifndef GL_EXT_point_parameters #define GL_EXT_point_parameters 1 #define GL_POINT_SIZE_MIN_EXT 0x8126 #define GL_POINT_SIZE_MAX_EXT 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128 #define GL_DISTANCE_ATTENUATION_EXT 0x8129 typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat* params); #define glPointParameterfEXT GLEW_GET_FUN(__glewPointParameterfEXT) #define glPointParameterfvEXT GLEW_GET_FUN(__glewPointParameterfvEXT) #define GLEW_EXT_point_parameters GLEW_GET_VAR(__GLEW_EXT_point_parameters) #endif /* GL_EXT_point_parameters */ /* ------------------------- GL_EXT_polygon_offset ------------------------- */ #ifndef GL_EXT_polygon_offset #define GL_EXT_polygon_offset 1 #define GL_POLYGON_OFFSET_EXT 0x8037 #define GL_POLYGON_OFFSET_FACTOR_EXT 0x8038 #define GL_POLYGON_OFFSET_BIAS_EXT 0x8039 typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias); #define glPolygonOffsetEXT GLEW_GET_FUN(__glewPolygonOffsetEXT) #define GLEW_EXT_polygon_offset GLEW_GET_VAR(__GLEW_EXT_polygon_offset) #endif /* GL_EXT_polygon_offset */ /* ---------------------- GL_EXT_polygon_offset_clamp ---------------------- */ #ifndef GL_EXT_polygon_offset_clamp #define GL_EXT_polygon_offset_clamp 1 #define GL_POLYGON_OFFSET_CLAMP_EXT 0x8E1B typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETCLAMPEXTPROC) (GLfloat factor, GLfloat units, GLfloat clamp); #define glPolygonOffsetClampEXT GLEW_GET_FUN(__glewPolygonOffsetClampEXT) #define GLEW_EXT_polygon_offset_clamp GLEW_GET_VAR(__GLEW_EXT_polygon_offset_clamp) #endif /* GL_EXT_polygon_offset_clamp */ /* ----------------------- GL_EXT_post_depth_coverage ---------------------- */ #ifndef GL_EXT_post_depth_coverage #define GL_EXT_post_depth_coverage 1 #define GLEW_EXT_post_depth_coverage GLEW_GET_VAR(__GLEW_EXT_post_depth_coverage) #endif /* GL_EXT_post_depth_coverage */ /* ------------------------ GL_EXT_provoking_vertex ------------------------ */ #ifndef GL_EXT_provoking_vertex #define GL_EXT_provoking_vertex 1 #define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT 0x8E4C #define GL_FIRST_VERTEX_CONVENTION_EXT 0x8E4D #define GL_LAST_VERTEX_CONVENTION_EXT 0x8E4E #define GL_PROVOKING_VERTEX_EXT 0x8E4F typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXEXTPROC) (GLenum mode); #define glProvokingVertexEXT GLEW_GET_FUN(__glewProvokingVertexEXT) #define GLEW_EXT_provoking_vertex GLEW_GET_VAR(__GLEW_EXT_provoking_vertex) #endif /* GL_EXT_provoking_vertex */ /* ----------------------- GL_EXT_raster_multisample ----------------------- */ #ifndef GL_EXT_raster_multisample #define GL_EXT_raster_multisample 1 #define GL_COLOR_SAMPLES_NV 0x8E20 #define GL_RASTER_MULTISAMPLE_EXT 0x9327 #define GL_RASTER_SAMPLES_EXT 0x9328 #define GL_MAX_RASTER_SAMPLES_EXT 0x9329 #define GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT 0x932A #define GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT 0x932B #define GL_EFFECTIVE_RASTER_SAMPLES_EXT 0x932C #define GL_DEPTH_SAMPLES_NV 0x932D #define GL_STENCIL_SAMPLES_NV 0x932E #define GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV 0x932F #define GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV 0x9330 #define GL_COVERAGE_MODULATION_TABLE_NV 0x9331 #define GL_COVERAGE_MODULATION_NV 0x9332 #define GL_COVERAGE_MODULATION_TABLE_SIZE_NV 0x9333 typedef void (GLAPIENTRY * PFNGLCOVERAGEMODULATIONNVPROC) (GLenum components); typedef void (GLAPIENTRY * PFNGLCOVERAGEMODULATIONTABLENVPROC) (GLsizei n, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLGETCOVERAGEMODULATIONTABLENVPROC) (GLsizei bufsize, GLfloat* v); typedef void (GLAPIENTRY * PFNGLRASTERSAMPLESEXTPROC) (GLuint samples, GLboolean fixedsamplelocations); #define glCoverageModulationNV GLEW_GET_FUN(__glewCoverageModulationNV) #define glCoverageModulationTableNV GLEW_GET_FUN(__glewCoverageModulationTableNV) #define glGetCoverageModulationTableNV GLEW_GET_FUN(__glewGetCoverageModulationTableNV) #define glRasterSamplesEXT GLEW_GET_FUN(__glewRasterSamplesEXT) #define GLEW_EXT_raster_multisample GLEW_GET_VAR(__GLEW_EXT_raster_multisample) #endif /* GL_EXT_raster_multisample */ /* ------------------------- GL_EXT_rescale_normal ------------------------- */ #ifndef GL_EXT_rescale_normal #define GL_EXT_rescale_normal 1 #define GL_RESCALE_NORMAL_EXT 0x803A #define GLEW_EXT_rescale_normal GLEW_GET_VAR(__GLEW_EXT_rescale_normal) #endif /* GL_EXT_rescale_normal */ /* -------------------------- GL_EXT_scene_marker -------------------------- */ #ifndef GL_EXT_scene_marker #define GL_EXT_scene_marker 1 typedef void (GLAPIENTRY * PFNGLBEGINSCENEEXTPROC) (void); typedef void (GLAPIENTRY * PFNGLENDSCENEEXTPROC) (void); #define glBeginSceneEXT GLEW_GET_FUN(__glewBeginSceneEXT) #define glEndSceneEXT GLEW_GET_FUN(__glewEndSceneEXT) #define GLEW_EXT_scene_marker GLEW_GET_VAR(__GLEW_EXT_scene_marker) #endif /* GL_EXT_scene_marker */ /* ------------------------- GL_EXT_secondary_color ------------------------ */ #ifndef GL_EXT_secondary_color #define GL_EXT_secondary_color 1 #define GL_COLOR_SUM_EXT 0x8458 #define GL_CURRENT_SECONDARY_COLOR_EXT 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D #define GL_SECONDARY_COLOR_ARRAY_EXT 0x845E typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const void *pointer); #define glSecondaryColor3bEXT GLEW_GET_FUN(__glewSecondaryColor3bEXT) #define glSecondaryColor3bvEXT GLEW_GET_FUN(__glewSecondaryColor3bvEXT) #define glSecondaryColor3dEXT GLEW_GET_FUN(__glewSecondaryColor3dEXT) #define glSecondaryColor3dvEXT GLEW_GET_FUN(__glewSecondaryColor3dvEXT) #define glSecondaryColor3fEXT GLEW_GET_FUN(__glewSecondaryColor3fEXT) #define glSecondaryColor3fvEXT GLEW_GET_FUN(__glewSecondaryColor3fvEXT) #define glSecondaryColor3iEXT GLEW_GET_FUN(__glewSecondaryColor3iEXT) #define glSecondaryColor3ivEXT GLEW_GET_FUN(__glewSecondaryColor3ivEXT) #define glSecondaryColor3sEXT GLEW_GET_FUN(__glewSecondaryColor3sEXT) #define glSecondaryColor3svEXT GLEW_GET_FUN(__glewSecondaryColor3svEXT) #define glSecondaryColor3ubEXT GLEW_GET_FUN(__glewSecondaryColor3ubEXT) #define glSecondaryColor3ubvEXT GLEW_GET_FUN(__glewSecondaryColor3ubvEXT) #define glSecondaryColor3uiEXT GLEW_GET_FUN(__glewSecondaryColor3uiEXT) #define glSecondaryColor3uivEXT GLEW_GET_FUN(__glewSecondaryColor3uivEXT) #define glSecondaryColor3usEXT GLEW_GET_FUN(__glewSecondaryColor3usEXT) #define glSecondaryColor3usvEXT GLEW_GET_FUN(__glewSecondaryColor3usvEXT) #define glSecondaryColorPointerEXT GLEW_GET_FUN(__glewSecondaryColorPointerEXT) #define GLEW_EXT_secondary_color GLEW_GET_VAR(__GLEW_EXT_secondary_color) #endif /* GL_EXT_secondary_color */ /* --------------------- GL_EXT_separate_shader_objects -------------------- */ #ifndef GL_EXT_separate_shader_objects #define GL_EXT_separate_shader_objects 1 #define GL_ACTIVE_PROGRAM_EXT 0x8B8D typedef void (GLAPIENTRY * PFNGLACTIVEPROGRAMEXTPROC) (GLuint program); typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROGRAMEXTPROC) (GLenum type, const GLchar* string); typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint program); #define glActiveProgramEXT GLEW_GET_FUN(__glewActiveProgramEXT) #define glCreateShaderProgramEXT GLEW_GET_FUN(__glewCreateShaderProgramEXT) #define glUseShaderProgramEXT GLEW_GET_FUN(__glewUseShaderProgramEXT) #define GLEW_EXT_separate_shader_objects GLEW_GET_VAR(__GLEW_EXT_separate_shader_objects) #endif /* GL_EXT_separate_shader_objects */ /* --------------------- GL_EXT_separate_specular_color -------------------- */ #ifndef GL_EXT_separate_specular_color #define GL_EXT_separate_specular_color 1 #define GL_LIGHT_MODEL_COLOR_CONTROL_EXT 0x81F8 #define GL_SINGLE_COLOR_EXT 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR_EXT 0x81FA #define GLEW_EXT_separate_specular_color GLEW_GET_VAR(__GLEW_EXT_separate_specular_color) #endif /* GL_EXT_separate_specular_color */ /* ------------------- GL_EXT_shader_image_load_formatted ------------------ */ #ifndef GL_EXT_shader_image_load_formatted #define GL_EXT_shader_image_load_formatted 1 #define GLEW_EXT_shader_image_load_formatted GLEW_GET_VAR(__GLEW_EXT_shader_image_load_formatted) #endif /* GL_EXT_shader_image_load_formatted */ /* --------------------- GL_EXT_shader_image_load_store -------------------- */ #ifndef GL_EXT_shader_image_load_store #define GL_EXT_shader_image_load_store 1 #define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT 0x00000001 #define GL_ELEMENT_ARRAY_BARRIER_BIT_EXT 0x00000002 #define GL_UNIFORM_BARRIER_BIT_EXT 0x00000004 #define GL_TEXTURE_FETCH_BARRIER_BIT_EXT 0x00000008 #define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT 0x00000020 #define GL_COMMAND_BARRIER_BIT_EXT 0x00000040 #define GL_PIXEL_BUFFER_BARRIER_BIT_EXT 0x00000080 #define GL_TEXTURE_UPDATE_BARRIER_BIT_EXT 0x00000100 #define GL_BUFFER_UPDATE_BARRIER_BIT_EXT 0x00000200 #define GL_FRAMEBUFFER_BARRIER_BIT_EXT 0x00000400 #define GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT 0x00000800 #define GL_ATOMIC_COUNTER_BARRIER_BIT_EXT 0x00001000 #define GL_MAX_IMAGE_UNITS_EXT 0x8F38 #define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT 0x8F39 #define GL_IMAGE_BINDING_NAME_EXT 0x8F3A #define GL_IMAGE_BINDING_LEVEL_EXT 0x8F3B #define GL_IMAGE_BINDING_LAYERED_EXT 0x8F3C #define GL_IMAGE_BINDING_LAYER_EXT 0x8F3D #define GL_IMAGE_BINDING_ACCESS_EXT 0x8F3E #define GL_IMAGE_1D_EXT 0x904C #define GL_IMAGE_2D_EXT 0x904D #define GL_IMAGE_3D_EXT 0x904E #define GL_IMAGE_2D_RECT_EXT 0x904F #define GL_IMAGE_CUBE_EXT 0x9050 #define GL_IMAGE_BUFFER_EXT 0x9051 #define GL_IMAGE_1D_ARRAY_EXT 0x9052 #define GL_IMAGE_2D_ARRAY_EXT 0x9053 #define GL_IMAGE_CUBE_MAP_ARRAY_EXT 0x9054 #define GL_IMAGE_2D_MULTISAMPLE_EXT 0x9055 #define GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9056 #define GL_INT_IMAGE_1D_EXT 0x9057 #define GL_INT_IMAGE_2D_EXT 0x9058 #define GL_INT_IMAGE_3D_EXT 0x9059 #define GL_INT_IMAGE_2D_RECT_EXT 0x905A #define GL_INT_IMAGE_CUBE_EXT 0x905B #define GL_INT_IMAGE_BUFFER_EXT 0x905C #define GL_INT_IMAGE_1D_ARRAY_EXT 0x905D #define GL_INT_IMAGE_2D_ARRAY_EXT 0x905E #define GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x905F #define GL_INT_IMAGE_2D_MULTISAMPLE_EXT 0x9060 #define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x9061 #define GL_UNSIGNED_INT_IMAGE_1D_EXT 0x9062 #define GL_UNSIGNED_INT_IMAGE_2D_EXT 0x9063 #define GL_UNSIGNED_INT_IMAGE_3D_EXT 0x9064 #define GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT 0x9065 #define GL_UNSIGNED_INT_IMAGE_CUBE_EXT 0x9066 #define GL_UNSIGNED_INT_IMAGE_BUFFER_EXT 0x9067 #define GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT 0x9068 #define GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT 0x9069 #define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x906A #define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT 0x906B #define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT 0x906C #define GL_MAX_IMAGE_SAMPLES_EXT 0x906D #define GL_IMAGE_BINDING_FORMAT_EXT 0x906E #define GL_ALL_BARRIER_BITS_EXT 0xFFFFFFFF typedef void (GLAPIENTRY * PFNGLBINDIMAGETEXTUREEXTPROC) (GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format); typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers); #define glBindImageTextureEXT GLEW_GET_FUN(__glewBindImageTextureEXT) #define glMemoryBarrierEXT GLEW_GET_FUN(__glewMemoryBarrierEXT) #define GLEW_EXT_shader_image_load_store GLEW_GET_VAR(__GLEW_EXT_shader_image_load_store) #endif /* GL_EXT_shader_image_load_store */ /* ----------------------- GL_EXT_shader_integer_mix ----------------------- */ #ifndef GL_EXT_shader_integer_mix #define GL_EXT_shader_integer_mix 1 #define GLEW_EXT_shader_integer_mix GLEW_GET_VAR(__GLEW_EXT_shader_integer_mix) #endif /* GL_EXT_shader_integer_mix */ /* -------------------------- GL_EXT_shadow_funcs -------------------------- */ #ifndef GL_EXT_shadow_funcs #define GL_EXT_shadow_funcs 1 #define GLEW_EXT_shadow_funcs GLEW_GET_VAR(__GLEW_EXT_shadow_funcs) #endif /* GL_EXT_shadow_funcs */ /* --------------------- GL_EXT_shared_texture_palette --------------------- */ #ifndef GL_EXT_shared_texture_palette #define GL_EXT_shared_texture_palette 1 #define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB #define GLEW_EXT_shared_texture_palette GLEW_GET_VAR(__GLEW_EXT_shared_texture_palette) #endif /* GL_EXT_shared_texture_palette */ /* ------------------------- GL_EXT_sparse_texture2 ------------------------ */ #ifndef GL_EXT_sparse_texture2 #define GL_EXT_sparse_texture2 1 #define GLEW_EXT_sparse_texture2 GLEW_GET_VAR(__GLEW_EXT_sparse_texture2) #endif /* GL_EXT_sparse_texture2 */ /* ------------------------ GL_EXT_stencil_clear_tag ----------------------- */ #ifndef GL_EXT_stencil_clear_tag #define GL_EXT_stencil_clear_tag 1 #define GL_STENCIL_TAG_BITS_EXT 0x88F2 #define GL_STENCIL_CLEAR_TAG_VALUE_EXT 0x88F3 #define GLEW_EXT_stencil_clear_tag GLEW_GET_VAR(__GLEW_EXT_stencil_clear_tag) #endif /* GL_EXT_stencil_clear_tag */ /* ------------------------ GL_EXT_stencil_two_side ------------------------ */ #ifndef GL_EXT_stencil_two_side #define GL_EXT_stencil_two_side 1 #define GL_STENCIL_TEST_TWO_SIDE_EXT 0x8910 #define GL_ACTIVE_STENCIL_FACE_EXT 0x8911 typedef void (GLAPIENTRY * PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face); #define glActiveStencilFaceEXT GLEW_GET_FUN(__glewActiveStencilFaceEXT) #define GLEW_EXT_stencil_two_side GLEW_GET_VAR(__GLEW_EXT_stencil_two_side) #endif /* GL_EXT_stencil_two_side */ /* -------------------------- GL_EXT_stencil_wrap -------------------------- */ #ifndef GL_EXT_stencil_wrap #define GL_EXT_stencil_wrap 1 #define GL_INCR_WRAP_EXT 0x8507 #define GL_DECR_WRAP_EXT 0x8508 #define GLEW_EXT_stencil_wrap GLEW_GET_VAR(__GLEW_EXT_stencil_wrap) #endif /* GL_EXT_stencil_wrap */ /* --------------------------- GL_EXT_subtexture --------------------------- */ #ifndef GL_EXT_subtexture #define GL_EXT_subtexture 1 typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); #define glTexSubImage1DEXT GLEW_GET_FUN(__glewTexSubImage1DEXT) #define glTexSubImage2DEXT GLEW_GET_FUN(__glewTexSubImage2DEXT) #define glTexSubImage3DEXT GLEW_GET_FUN(__glewTexSubImage3DEXT) #define GLEW_EXT_subtexture GLEW_GET_VAR(__GLEW_EXT_subtexture) #endif /* GL_EXT_subtexture */ /* ----------------------------- GL_EXT_texture ---------------------------- */ #ifndef GL_EXT_texture #define GL_EXT_texture 1 #define GL_ALPHA4_EXT 0x803B #define GL_ALPHA8_EXT 0x803C #define GL_ALPHA12_EXT 0x803D #define GL_ALPHA16_EXT 0x803E #define GL_LUMINANCE4_EXT 0x803F #define GL_LUMINANCE8_EXT 0x8040 #define GL_LUMINANCE12_EXT 0x8041 #define GL_LUMINANCE16_EXT 0x8042 #define GL_LUMINANCE4_ALPHA4_EXT 0x8043 #define GL_LUMINANCE6_ALPHA2_EXT 0x8044 #define GL_LUMINANCE8_ALPHA8_EXT 0x8045 #define GL_LUMINANCE12_ALPHA4_EXT 0x8046 #define GL_LUMINANCE12_ALPHA12_EXT 0x8047 #define GL_LUMINANCE16_ALPHA16_EXT 0x8048 #define GL_INTENSITY_EXT 0x8049 #define GL_INTENSITY4_EXT 0x804A #define GL_INTENSITY8_EXT 0x804B #define GL_INTENSITY12_EXT 0x804C #define GL_INTENSITY16_EXT 0x804D #define GL_RGB2_EXT 0x804E #define GL_RGB4_EXT 0x804F #define GL_RGB5_EXT 0x8050 #define GL_RGB8_EXT 0x8051 #define GL_RGB10_EXT 0x8052 #define GL_RGB12_EXT 0x8053 #define GL_RGB16_EXT 0x8054 #define GL_RGBA2_EXT 0x8055 #define GL_RGBA4_EXT 0x8056 #define GL_RGB5_A1_EXT 0x8057 #define GL_RGBA8_EXT 0x8058 #define GL_RGB10_A2_EXT 0x8059 #define GL_RGBA12_EXT 0x805A #define GL_RGBA16_EXT 0x805B #define GL_TEXTURE_RED_SIZE_EXT 0x805C #define GL_TEXTURE_GREEN_SIZE_EXT 0x805D #define GL_TEXTURE_BLUE_SIZE_EXT 0x805E #define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F #define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060 #define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061 #define GL_REPLACE_EXT 0x8062 #define GL_PROXY_TEXTURE_1D_EXT 0x8063 #define GL_PROXY_TEXTURE_2D_EXT 0x8064 #define GLEW_EXT_texture GLEW_GET_VAR(__GLEW_EXT_texture) #endif /* GL_EXT_texture */ /* ---------------------------- GL_EXT_texture3D --------------------------- */ #ifndef GL_EXT_texture3D #define GL_EXT_texture3D 1 #define GL_PACK_SKIP_IMAGES_EXT 0x806B #define GL_PACK_IMAGE_HEIGHT_EXT 0x806C #define GL_UNPACK_SKIP_IMAGES_EXT 0x806D #define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E #define GL_TEXTURE_3D_EXT 0x806F #define GL_PROXY_TEXTURE_3D_EXT 0x8070 #define GL_TEXTURE_DEPTH_EXT 0x8071 #define GL_TEXTURE_WRAP_R_EXT 0x8072 #define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); #define glTexImage3DEXT GLEW_GET_FUN(__glewTexImage3DEXT) #define GLEW_EXT_texture3D GLEW_GET_VAR(__GLEW_EXT_texture3D) #endif /* GL_EXT_texture3D */ /* -------------------------- GL_EXT_texture_array ------------------------- */ #ifndef GL_EXT_texture_array #define GL_EXT_texture_array 1 #define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT 0x884E #define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT 0x88FF #define GL_TEXTURE_1D_ARRAY_EXT 0x8C18 #define GL_PROXY_TEXTURE_1D_ARRAY_EXT 0x8C19 #define GL_TEXTURE_2D_ARRAY_EXT 0x8C1A #define GL_PROXY_TEXTURE_2D_ARRAY_EXT 0x8C1B #define GL_TEXTURE_BINDING_1D_ARRAY_EXT 0x8C1C #define GL_TEXTURE_BINDING_2D_ARRAY_EXT 0x8C1D typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); #define glFramebufferTextureLayerEXT GLEW_GET_FUN(__glewFramebufferTextureLayerEXT) #define GLEW_EXT_texture_array GLEW_GET_VAR(__GLEW_EXT_texture_array) #endif /* GL_EXT_texture_array */ /* ---------------------- GL_EXT_texture_buffer_object --------------------- */ #ifndef GL_EXT_texture_buffer_object #define GL_EXT_texture_buffer_object 1 #define GL_TEXTURE_BUFFER_EXT 0x8C2A #define GL_MAX_TEXTURE_BUFFER_SIZE_EXT 0x8C2B #define GL_TEXTURE_BINDING_BUFFER_EXT 0x8C2C #define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D #define GL_TEXTURE_BUFFER_FORMAT_EXT 0x8C2E typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum internalformat, GLuint buffer); #define glTexBufferEXT GLEW_GET_FUN(__glewTexBufferEXT) #define GLEW_EXT_texture_buffer_object GLEW_GET_VAR(__GLEW_EXT_texture_buffer_object) #endif /* GL_EXT_texture_buffer_object */ /* -------------------- GL_EXT_texture_compression_dxt1 -------------------- */ #ifndef GL_EXT_texture_compression_dxt1 #define GL_EXT_texture_compression_dxt1 1 #define GLEW_EXT_texture_compression_dxt1 GLEW_GET_VAR(__GLEW_EXT_texture_compression_dxt1) #endif /* GL_EXT_texture_compression_dxt1 */ /* -------------------- GL_EXT_texture_compression_latc -------------------- */ #ifndef GL_EXT_texture_compression_latc #define GL_EXT_texture_compression_latc 1 #define GL_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70 #define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71 #define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72 #define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73 #define GLEW_EXT_texture_compression_latc GLEW_GET_VAR(__GLEW_EXT_texture_compression_latc) #endif /* GL_EXT_texture_compression_latc */ /* -------------------- GL_EXT_texture_compression_rgtc -------------------- */ #ifndef GL_EXT_texture_compression_rgtc #define GL_EXT_texture_compression_rgtc 1 #define GL_COMPRESSED_RED_RGTC1_EXT 0x8DBB #define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC #define GL_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD #define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE #define GLEW_EXT_texture_compression_rgtc GLEW_GET_VAR(__GLEW_EXT_texture_compression_rgtc) #endif /* GL_EXT_texture_compression_rgtc */ /* -------------------- GL_EXT_texture_compression_s3tc -------------------- */ #ifndef GL_EXT_texture_compression_s3tc #define GL_EXT_texture_compression_s3tc 1 #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 #define GLEW_EXT_texture_compression_s3tc GLEW_GET_VAR(__GLEW_EXT_texture_compression_s3tc) #endif /* GL_EXT_texture_compression_s3tc */ /* ------------------------ GL_EXT_texture_cube_map ------------------------ */ #ifndef GL_EXT_texture_cube_map #define GL_EXT_texture_cube_map 1 #define GL_NORMAL_MAP_EXT 0x8511 #define GL_REFLECTION_MAP_EXT 0x8512 #define GL_TEXTURE_CUBE_MAP_EXT 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C #define GLEW_EXT_texture_cube_map GLEW_GET_VAR(__GLEW_EXT_texture_cube_map) #endif /* GL_EXT_texture_cube_map */ /* ----------------------- GL_EXT_texture_edge_clamp ----------------------- */ #ifndef GL_EXT_texture_edge_clamp #define GL_EXT_texture_edge_clamp 1 #define GL_CLAMP_TO_EDGE_EXT 0x812F #define GLEW_EXT_texture_edge_clamp GLEW_GET_VAR(__GLEW_EXT_texture_edge_clamp) #endif /* GL_EXT_texture_edge_clamp */ /* --------------------------- GL_EXT_texture_env -------------------------- */ #ifndef GL_EXT_texture_env #define GL_EXT_texture_env 1 #define GLEW_EXT_texture_env GLEW_GET_VAR(__GLEW_EXT_texture_env) #endif /* GL_EXT_texture_env */ /* ------------------------- GL_EXT_texture_env_add ------------------------ */ #ifndef GL_EXT_texture_env_add #define GL_EXT_texture_env_add 1 #define GLEW_EXT_texture_env_add GLEW_GET_VAR(__GLEW_EXT_texture_env_add) #endif /* GL_EXT_texture_env_add */ /* ----------------------- GL_EXT_texture_env_combine ---------------------- */ #ifndef GL_EXT_texture_env_combine #define GL_EXT_texture_env_combine 1 #define GL_COMBINE_EXT 0x8570 #define GL_COMBINE_RGB_EXT 0x8571 #define GL_COMBINE_ALPHA_EXT 0x8572 #define GL_RGB_SCALE_EXT 0x8573 #define GL_ADD_SIGNED_EXT 0x8574 #define GL_INTERPOLATE_EXT 0x8575 #define GL_CONSTANT_EXT 0x8576 #define GL_PRIMARY_COLOR_EXT 0x8577 #define GL_PREVIOUS_EXT 0x8578 #define GL_SOURCE0_RGB_EXT 0x8580 #define GL_SOURCE1_RGB_EXT 0x8581 #define GL_SOURCE2_RGB_EXT 0x8582 #define GL_SOURCE0_ALPHA_EXT 0x8588 #define GL_SOURCE1_ALPHA_EXT 0x8589 #define GL_SOURCE2_ALPHA_EXT 0x858A #define GL_OPERAND0_RGB_EXT 0x8590 #define GL_OPERAND1_RGB_EXT 0x8591 #define GL_OPERAND2_RGB_EXT 0x8592 #define GL_OPERAND0_ALPHA_EXT 0x8598 #define GL_OPERAND1_ALPHA_EXT 0x8599 #define GL_OPERAND2_ALPHA_EXT 0x859A #define GLEW_EXT_texture_env_combine GLEW_GET_VAR(__GLEW_EXT_texture_env_combine) #endif /* GL_EXT_texture_env_combine */ /* ------------------------ GL_EXT_texture_env_dot3 ------------------------ */ #ifndef GL_EXT_texture_env_dot3 #define GL_EXT_texture_env_dot3 1 #define GL_DOT3_RGB_EXT 0x8740 #define GL_DOT3_RGBA_EXT 0x8741 #define GLEW_EXT_texture_env_dot3 GLEW_GET_VAR(__GLEW_EXT_texture_env_dot3) #endif /* GL_EXT_texture_env_dot3 */ /* ------------------- GL_EXT_texture_filter_anisotropic ------------------- */ #ifndef GL_EXT_texture_filter_anisotropic #define GL_EXT_texture_filter_anisotropic 1 #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF #define GLEW_EXT_texture_filter_anisotropic GLEW_GET_VAR(__GLEW_EXT_texture_filter_anisotropic) #endif /* GL_EXT_texture_filter_anisotropic */ /* ---------------------- GL_EXT_texture_filter_minmax --------------------- */ #ifndef GL_EXT_texture_filter_minmax #define GL_EXT_texture_filter_minmax 1 #define GL_TEXTURE_REDUCTION_MODE_EXT 0x9366 #define GL_WEIGHTED_AVERAGE_EXT 0x9367 #define GLEW_EXT_texture_filter_minmax GLEW_GET_VAR(__GLEW_EXT_texture_filter_minmax) #endif /* GL_EXT_texture_filter_minmax */ /* ------------------------- GL_EXT_texture_integer ------------------------ */ #ifndef GL_EXT_texture_integer #define GL_EXT_texture_integer 1 #define GL_RGBA32UI_EXT 0x8D70 #define GL_RGB32UI_EXT 0x8D71 #define GL_ALPHA32UI_EXT 0x8D72 #define GL_INTENSITY32UI_EXT 0x8D73 #define GL_LUMINANCE32UI_EXT 0x8D74 #define GL_LUMINANCE_ALPHA32UI_EXT 0x8D75 #define GL_RGBA16UI_EXT 0x8D76 #define GL_RGB16UI_EXT 0x8D77 #define GL_ALPHA16UI_EXT 0x8D78 #define GL_INTENSITY16UI_EXT 0x8D79 #define GL_LUMINANCE16UI_EXT 0x8D7A #define GL_LUMINANCE_ALPHA16UI_EXT 0x8D7B #define GL_RGBA8UI_EXT 0x8D7C #define GL_RGB8UI_EXT 0x8D7D #define GL_ALPHA8UI_EXT 0x8D7E #define GL_INTENSITY8UI_EXT 0x8D7F #define GL_LUMINANCE8UI_EXT 0x8D80 #define GL_LUMINANCE_ALPHA8UI_EXT 0x8D81 #define GL_RGBA32I_EXT 0x8D82 #define GL_RGB32I_EXT 0x8D83 #define GL_ALPHA32I_EXT 0x8D84 #define GL_INTENSITY32I_EXT 0x8D85 #define GL_LUMINANCE32I_EXT 0x8D86 #define GL_LUMINANCE_ALPHA32I_EXT 0x8D87 #define GL_RGBA16I_EXT 0x8D88 #define GL_RGB16I_EXT 0x8D89 #define GL_ALPHA16I_EXT 0x8D8A #define GL_INTENSITY16I_EXT 0x8D8B #define GL_LUMINANCE16I_EXT 0x8D8C #define GL_LUMINANCE_ALPHA16I_EXT 0x8D8D #define GL_RGBA8I_EXT 0x8D8E #define GL_RGB8I_EXT 0x8D8F #define GL_ALPHA8I_EXT 0x8D90 #define GL_INTENSITY8I_EXT 0x8D91 #define GL_LUMINANCE8I_EXT 0x8D92 #define GL_LUMINANCE_ALPHA8I_EXT 0x8D93 #define GL_RED_INTEGER_EXT 0x8D94 #define GL_GREEN_INTEGER_EXT 0x8D95 #define GL_BLUE_INTEGER_EXT 0x8D96 #define GL_ALPHA_INTEGER_EXT 0x8D97 #define GL_RGB_INTEGER_EXT 0x8D98 #define GL_RGBA_INTEGER_EXT 0x8D99 #define GL_BGR_INTEGER_EXT 0x8D9A #define GL_BGRA_INTEGER_EXT 0x8D9B #define GL_LUMINANCE_INTEGER_EXT 0x8D9C #define GL_LUMINANCE_ALPHA_INTEGER_EXT 0x8D9D #define GL_RGBA_INTEGER_MODE_EXT 0x8D9E typedef void (GLAPIENTRY * PFNGLCLEARCOLORIIEXTPROC) (GLint red, GLint green, GLint blue, GLint alpha); typedef void (GLAPIENTRY * PFNGLCLEARCOLORIUIEXTPROC) (GLuint red, GLuint green, GLuint blue, GLuint alpha); typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, GLuint *params); typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, const GLuint *params); #define glClearColorIiEXT GLEW_GET_FUN(__glewClearColorIiEXT) #define glClearColorIuiEXT GLEW_GET_FUN(__glewClearColorIuiEXT) #define glGetTexParameterIivEXT GLEW_GET_FUN(__glewGetTexParameterIivEXT) #define glGetTexParameterIuivEXT GLEW_GET_FUN(__glewGetTexParameterIuivEXT) #define glTexParameterIivEXT GLEW_GET_FUN(__glewTexParameterIivEXT) #define glTexParameterIuivEXT GLEW_GET_FUN(__glewTexParameterIuivEXT) #define GLEW_EXT_texture_integer GLEW_GET_VAR(__GLEW_EXT_texture_integer) #endif /* GL_EXT_texture_integer */ /* ------------------------ GL_EXT_texture_lod_bias ------------------------ */ #ifndef GL_EXT_texture_lod_bias #define GL_EXT_texture_lod_bias 1 #define GL_MAX_TEXTURE_LOD_BIAS_EXT 0x84FD #define GL_TEXTURE_FILTER_CONTROL_EXT 0x8500 #define GL_TEXTURE_LOD_BIAS_EXT 0x8501 #define GLEW_EXT_texture_lod_bias GLEW_GET_VAR(__GLEW_EXT_texture_lod_bias) #endif /* GL_EXT_texture_lod_bias */ /* ---------------------- GL_EXT_texture_mirror_clamp ---------------------- */ #ifndef GL_EXT_texture_mirror_clamp #define GL_EXT_texture_mirror_clamp 1 #define GL_MIRROR_CLAMP_EXT 0x8742 #define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 #define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912 #define GLEW_EXT_texture_mirror_clamp GLEW_GET_VAR(__GLEW_EXT_texture_mirror_clamp) #endif /* GL_EXT_texture_mirror_clamp */ /* ------------------------- GL_EXT_texture_object ------------------------- */ #ifndef GL_EXT_texture_object #define GL_EXT_texture_object 1 #define GL_TEXTURE_PRIORITY_EXT 0x8066 #define GL_TEXTURE_RESIDENT_EXT 0x8067 #define GL_TEXTURE_1D_BINDING_EXT 0x8068 #define GL_TEXTURE_2D_BINDING_EXT 0x8069 #define GL_TEXTURE_3D_BINDING_EXT 0x806A typedef GLboolean (GLAPIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint* textures, GLboolean* residences); typedef void (GLAPIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture); typedef void (GLAPIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint* textures); typedef void (GLAPIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint* textures); typedef GLboolean (GLAPIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture); typedef void (GLAPIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint* textures, const GLclampf* priorities); #define glAreTexturesResidentEXT GLEW_GET_FUN(__glewAreTexturesResidentEXT) #define glBindTextureEXT GLEW_GET_FUN(__glewBindTextureEXT) #define glDeleteTexturesEXT GLEW_GET_FUN(__glewDeleteTexturesEXT) #define glGenTexturesEXT GLEW_GET_FUN(__glewGenTexturesEXT) #define glIsTextureEXT GLEW_GET_FUN(__glewIsTextureEXT) #define glPrioritizeTexturesEXT GLEW_GET_FUN(__glewPrioritizeTexturesEXT) #define GLEW_EXT_texture_object GLEW_GET_VAR(__GLEW_EXT_texture_object) #endif /* GL_EXT_texture_object */ /* --------------------- GL_EXT_texture_perturb_normal --------------------- */ #ifndef GL_EXT_texture_perturb_normal #define GL_EXT_texture_perturb_normal 1 #define GL_PERTURB_EXT 0x85AE #define GL_TEXTURE_NORMAL_EXT 0x85AF typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); #define glTextureNormalEXT GLEW_GET_FUN(__glewTextureNormalEXT) #define GLEW_EXT_texture_perturb_normal GLEW_GET_VAR(__GLEW_EXT_texture_perturb_normal) #endif /* GL_EXT_texture_perturb_normal */ /* ------------------------ GL_EXT_texture_rectangle ----------------------- */ #ifndef GL_EXT_texture_rectangle #define GL_EXT_texture_rectangle 1 #define GL_TEXTURE_RECTANGLE_EXT 0x84F5 #define GL_TEXTURE_BINDING_RECTANGLE_EXT 0x84F6 #define GL_PROXY_TEXTURE_RECTANGLE_EXT 0x84F7 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT 0x84F8 #define GLEW_EXT_texture_rectangle GLEW_GET_VAR(__GLEW_EXT_texture_rectangle) #endif /* GL_EXT_texture_rectangle */ /* -------------------------- GL_EXT_texture_sRGB -------------------------- */ #ifndef GL_EXT_texture_sRGB #define GL_EXT_texture_sRGB 1 #define GL_SRGB_EXT 0x8C40 #define GL_SRGB8_EXT 0x8C41 #define GL_SRGB_ALPHA_EXT 0x8C42 #define GL_SRGB8_ALPHA8_EXT 0x8C43 #define GL_SLUMINANCE_ALPHA_EXT 0x8C44 #define GL_SLUMINANCE8_ALPHA8_EXT 0x8C45 #define GL_SLUMINANCE_EXT 0x8C46 #define GL_SLUMINANCE8_EXT 0x8C47 #define GL_COMPRESSED_SRGB_EXT 0x8C48 #define GL_COMPRESSED_SRGB_ALPHA_EXT 0x8C49 #define GL_COMPRESSED_SLUMINANCE_EXT 0x8C4A #define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT 0x8C4B #define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C #define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D #define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E #define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F #define GLEW_EXT_texture_sRGB GLEW_GET_VAR(__GLEW_EXT_texture_sRGB) #endif /* GL_EXT_texture_sRGB */ /* ----------------------- GL_EXT_texture_sRGB_decode ---------------------- */ #ifndef GL_EXT_texture_sRGB_decode #define GL_EXT_texture_sRGB_decode 1 #define GL_TEXTURE_SRGB_DECODE_EXT 0x8A48 #define GL_DECODE_EXT 0x8A49 #define GL_SKIP_DECODE_EXT 0x8A4A #define GLEW_EXT_texture_sRGB_decode GLEW_GET_VAR(__GLEW_EXT_texture_sRGB_decode) #endif /* GL_EXT_texture_sRGB_decode */ /* --------------------- GL_EXT_texture_shared_exponent -------------------- */ #ifndef GL_EXT_texture_shared_exponent #define GL_EXT_texture_shared_exponent 1 #define GL_RGB9_E5_EXT 0x8C3D #define GL_UNSIGNED_INT_5_9_9_9_REV_EXT 0x8C3E #define GL_TEXTURE_SHARED_SIZE_EXT 0x8C3F #define GLEW_EXT_texture_shared_exponent GLEW_GET_VAR(__GLEW_EXT_texture_shared_exponent) #endif /* GL_EXT_texture_shared_exponent */ /* -------------------------- GL_EXT_texture_snorm ------------------------- */ #ifndef GL_EXT_texture_snorm #define GL_EXT_texture_snorm 1 #define GL_RED_SNORM 0x8F90 #define GL_RG_SNORM 0x8F91 #define GL_RGB_SNORM 0x8F92 #define GL_RGBA_SNORM 0x8F93 #define GL_R8_SNORM 0x8F94 #define GL_RG8_SNORM 0x8F95 #define GL_RGB8_SNORM 0x8F96 #define GL_RGBA8_SNORM 0x8F97 #define GL_R16_SNORM 0x8F98 #define GL_RG16_SNORM 0x8F99 #define GL_RGB16_SNORM 0x8F9A #define GL_RGBA16_SNORM 0x8F9B #define GL_SIGNED_NORMALIZED 0x8F9C #define GL_ALPHA_SNORM 0x9010 #define GL_LUMINANCE_SNORM 0x9011 #define GL_LUMINANCE_ALPHA_SNORM 0x9012 #define GL_INTENSITY_SNORM 0x9013 #define GL_ALPHA8_SNORM 0x9014 #define GL_LUMINANCE8_SNORM 0x9015 #define GL_LUMINANCE8_ALPHA8_SNORM 0x9016 #define GL_INTENSITY8_SNORM 0x9017 #define GL_ALPHA16_SNORM 0x9018 #define GL_LUMINANCE16_SNORM 0x9019 #define GL_LUMINANCE16_ALPHA16_SNORM 0x901A #define GL_INTENSITY16_SNORM 0x901B #define GLEW_EXT_texture_snorm GLEW_GET_VAR(__GLEW_EXT_texture_snorm) #endif /* GL_EXT_texture_snorm */ /* ------------------------- GL_EXT_texture_swizzle ------------------------ */ #ifndef GL_EXT_texture_swizzle #define GL_EXT_texture_swizzle 1 #define GL_TEXTURE_SWIZZLE_R_EXT 0x8E42 #define GL_TEXTURE_SWIZZLE_G_EXT 0x8E43 #define GL_TEXTURE_SWIZZLE_B_EXT 0x8E44 #define GL_TEXTURE_SWIZZLE_A_EXT 0x8E45 #define GL_TEXTURE_SWIZZLE_RGBA_EXT 0x8E46 #define GLEW_EXT_texture_swizzle GLEW_GET_VAR(__GLEW_EXT_texture_swizzle) #endif /* GL_EXT_texture_swizzle */ /* --------------------------- GL_EXT_timer_query -------------------------- */ #ifndef GL_EXT_timer_query #define GL_EXT_timer_query 1 #define GL_TIME_ELAPSED_EXT 0x88BF typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VEXTPROC) (GLuint id, GLenum pname, GLint64EXT *params); typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLenum pname, GLuint64EXT *params); #define glGetQueryObjecti64vEXT GLEW_GET_FUN(__glewGetQueryObjecti64vEXT) #define glGetQueryObjectui64vEXT GLEW_GET_FUN(__glewGetQueryObjectui64vEXT) #define GLEW_EXT_timer_query GLEW_GET_VAR(__GLEW_EXT_timer_query) #endif /* GL_EXT_timer_query */ /* ----------------------- GL_EXT_transform_feedback ----------------------- */ #ifndef GL_EXT_transform_feedback #define GL_EXT_transform_feedback 1 #define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT 0x8C76 #define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT 0x8C7F #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT 0x8C80 #define GL_TRANSFORM_FEEDBACK_VARYINGS_EXT 0x8C83 #define GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT 0x8C84 #define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT 0x8C85 #define GL_PRIMITIVES_GENERATED_EXT 0x8C87 #define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT 0x8C88 #define GL_RASTERIZER_DISCARD_EXT 0x8C89 #define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT 0x8C8A #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT 0x8C8B #define GL_INTERLEAVED_ATTRIBS_EXT 0x8C8C #define GL_SEPARATE_ATTRIBS_EXT 0x8C8D #define GL_TRANSFORM_FEEDBACK_BUFFER_EXT 0x8C8E #define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT 0x8C8F typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKEXTPROC) (GLenum primitiveMode); typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEEXTPROC) (GLenum target, GLuint index, GLuint buffer); typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKEXTPROC) (void); typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei *size, GLenum *type, GLchar *name); typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) (GLuint program, GLsizei count, const GLchar * const* varyings, GLenum bufferMode); #define glBeginTransformFeedbackEXT GLEW_GET_FUN(__glewBeginTransformFeedbackEXT) #define glBindBufferBaseEXT GLEW_GET_FUN(__glewBindBufferBaseEXT) #define glBindBufferOffsetEXT GLEW_GET_FUN(__glewBindBufferOffsetEXT) #define glBindBufferRangeEXT GLEW_GET_FUN(__glewBindBufferRangeEXT) #define glEndTransformFeedbackEXT GLEW_GET_FUN(__glewEndTransformFeedbackEXT) #define glGetTransformFeedbackVaryingEXT GLEW_GET_FUN(__glewGetTransformFeedbackVaryingEXT) #define glTransformFeedbackVaryingsEXT GLEW_GET_FUN(__glewTransformFeedbackVaryingsEXT) #define GLEW_EXT_transform_feedback GLEW_GET_VAR(__GLEW_EXT_transform_feedback) #endif /* GL_EXT_transform_feedback */ /* -------------------------- GL_EXT_vertex_array -------------------------- */ #ifndef GL_EXT_vertex_array #define GL_EXT_vertex_array 1 #define GL_DOUBLE_EXT 0x140A #define GL_VERTEX_ARRAY_EXT 0x8074 #define GL_NORMAL_ARRAY_EXT 0x8075 #define GL_COLOR_ARRAY_EXT 0x8076 #define GL_INDEX_ARRAY_EXT 0x8077 #define GL_TEXTURE_COORD_ARRAY_EXT 0x8078 #define GL_EDGE_FLAG_ARRAY_EXT 0x8079 #define GL_VERTEX_ARRAY_SIZE_EXT 0x807A #define GL_VERTEX_ARRAY_TYPE_EXT 0x807B #define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C #define GL_VERTEX_ARRAY_COUNT_EXT 0x807D #define GL_NORMAL_ARRAY_TYPE_EXT 0x807E #define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F #define GL_NORMAL_ARRAY_COUNT_EXT 0x8080 #define GL_COLOR_ARRAY_SIZE_EXT 0x8081 #define GL_COLOR_ARRAY_TYPE_EXT 0x8082 #define GL_COLOR_ARRAY_STRIDE_EXT 0x8083 #define GL_COLOR_ARRAY_COUNT_EXT 0x8084 #define GL_INDEX_ARRAY_TYPE_EXT 0x8085 #define GL_INDEX_ARRAY_STRIDE_EXT 0x8086 #define GL_INDEX_ARRAY_COUNT_EXT 0x8087 #define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 #define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 #define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A #define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B #define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C #define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D #define GL_VERTEX_ARRAY_POINTER_EXT 0x808E #define GL_NORMAL_ARRAY_POINTER_EXT 0x808F #define GL_COLOR_ARRAY_POINTER_EXT 0x8090 #define GL_INDEX_ARRAY_POINTER_EXT 0x8091 #define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 #define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 typedef void (GLAPIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i); typedef void (GLAPIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer); typedef void (GLAPIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean* pointer); typedef void (GLAPIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void *pointer); typedef void (GLAPIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void *pointer); typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer); typedef void (GLAPIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer); #define glArrayElementEXT GLEW_GET_FUN(__glewArrayElementEXT) #define glColorPointerEXT GLEW_GET_FUN(__glewColorPointerEXT) #define glDrawArraysEXT GLEW_GET_FUN(__glewDrawArraysEXT) #define glEdgeFlagPointerEXT GLEW_GET_FUN(__glewEdgeFlagPointerEXT) #define glIndexPointerEXT GLEW_GET_FUN(__glewIndexPointerEXT) #define glNormalPointerEXT GLEW_GET_FUN(__glewNormalPointerEXT) #define glTexCoordPointerEXT GLEW_GET_FUN(__glewTexCoordPointerEXT) #define glVertexPointerEXT GLEW_GET_FUN(__glewVertexPointerEXT) #define GLEW_EXT_vertex_array GLEW_GET_VAR(__GLEW_EXT_vertex_array) #endif /* GL_EXT_vertex_array */ /* ------------------------ GL_EXT_vertex_array_bgra ----------------------- */ #ifndef GL_EXT_vertex_array_bgra #define GL_EXT_vertex_array_bgra 1 #define GL_BGRA 0x80E1 #define GLEW_EXT_vertex_array_bgra GLEW_GET_VAR(__GLEW_EXT_vertex_array_bgra) #endif /* GL_EXT_vertex_array_bgra */ /* ----------------------- GL_EXT_vertex_attrib_64bit ---------------------- */ #ifndef GL_EXT_vertex_attrib_64bit #define GL_EXT_vertex_attrib_64bit 1 #define GL_DOUBLE_MAT2_EXT 0x8F46 #define GL_DOUBLE_MAT3_EXT 0x8F47 #define GL_DOUBLE_MAT4_EXT 0x8F48 #define GL_DOUBLE_MAT2x3_EXT 0x8F49 #define GL_DOUBLE_MAT2x4_EXT 0x8F4A #define GL_DOUBLE_MAT3x2_EXT 0x8F4B #define GL_DOUBLE_MAT3x4_EXT 0x8F4C #define GL_DOUBLE_MAT4x2_EXT 0x8F4D #define GL_DOUBLE_MAT4x3_EXT 0x8F4E #define GL_DOUBLE_VEC2_EXT 0x8FFC #define GL_DOUBLE_VEC3_EXT 0x8FFD #define GL_DOUBLE_VEC4_EXT 0x8FFE typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLDVEXTPROC) (GLuint index, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC) (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DEXTPROC) (GLuint index, GLdouble x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1DVEXTPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DEXTPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2DVEXTPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3DVEXTPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DEXTPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4DVEXTPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); #define glGetVertexAttribLdvEXT GLEW_GET_FUN(__glewGetVertexAttribLdvEXT) #define glVertexArrayVertexAttribLOffsetEXT GLEW_GET_FUN(__glewVertexArrayVertexAttribLOffsetEXT) #define glVertexAttribL1dEXT GLEW_GET_FUN(__glewVertexAttribL1dEXT) #define glVertexAttribL1dvEXT GLEW_GET_FUN(__glewVertexAttribL1dvEXT) #define glVertexAttribL2dEXT GLEW_GET_FUN(__glewVertexAttribL2dEXT) #define glVertexAttribL2dvEXT GLEW_GET_FUN(__glewVertexAttribL2dvEXT) #define glVertexAttribL3dEXT GLEW_GET_FUN(__glewVertexAttribL3dEXT) #define glVertexAttribL3dvEXT GLEW_GET_FUN(__glewVertexAttribL3dvEXT) #define glVertexAttribL4dEXT GLEW_GET_FUN(__glewVertexAttribL4dEXT) #define glVertexAttribL4dvEXT GLEW_GET_FUN(__glewVertexAttribL4dvEXT) #define glVertexAttribLPointerEXT GLEW_GET_FUN(__glewVertexAttribLPointerEXT) #define GLEW_EXT_vertex_attrib_64bit GLEW_GET_VAR(__GLEW_EXT_vertex_attrib_64bit) #endif /* GL_EXT_vertex_attrib_64bit */ /* -------------------------- GL_EXT_vertex_shader ------------------------- */ #ifndef GL_EXT_vertex_shader #define GL_EXT_vertex_shader 1 #define GL_VERTEX_SHADER_EXT 0x8780 #define GL_VERTEX_SHADER_BINDING_EXT 0x8781 #define GL_OP_INDEX_EXT 0x8782 #define GL_OP_NEGATE_EXT 0x8783 #define GL_OP_DOT3_EXT 0x8784 #define GL_OP_DOT4_EXT 0x8785 #define GL_OP_MUL_EXT 0x8786 #define GL_OP_ADD_EXT 0x8787 #define GL_OP_MADD_EXT 0x8788 #define GL_OP_FRAC_EXT 0x8789 #define GL_OP_MAX_EXT 0x878A #define GL_OP_MIN_EXT 0x878B #define GL_OP_SET_GE_EXT 0x878C #define GL_OP_SET_LT_EXT 0x878D #define GL_OP_CLAMP_EXT 0x878E #define GL_OP_FLOOR_EXT 0x878F #define GL_OP_ROUND_EXT 0x8790 #define GL_OP_EXP_BASE_2_EXT 0x8791 #define GL_OP_LOG_BASE_2_EXT 0x8792 #define GL_OP_POWER_EXT 0x8793 #define GL_OP_RECIP_EXT 0x8794 #define GL_OP_RECIP_SQRT_EXT 0x8795 #define GL_OP_SUB_EXT 0x8796 #define GL_OP_CROSS_PRODUCT_EXT 0x8797 #define GL_OP_MULTIPLY_MATRIX_EXT 0x8798 #define GL_OP_MOV_EXT 0x8799 #define GL_OUTPUT_VERTEX_EXT 0x879A #define GL_OUTPUT_COLOR0_EXT 0x879B #define GL_OUTPUT_COLOR1_EXT 0x879C #define GL_OUTPUT_TEXTURE_COORD0_EXT 0x879D #define GL_OUTPUT_TEXTURE_COORD1_EXT 0x879E #define GL_OUTPUT_TEXTURE_COORD2_EXT 0x879F #define GL_OUTPUT_TEXTURE_COORD3_EXT 0x87A0 #define GL_OUTPUT_TEXTURE_COORD4_EXT 0x87A1 #define GL_OUTPUT_TEXTURE_COORD5_EXT 0x87A2 #define GL_OUTPUT_TEXTURE_COORD6_EXT 0x87A3 #define GL_OUTPUT_TEXTURE_COORD7_EXT 0x87A4 #define GL_OUTPUT_TEXTURE_COORD8_EXT 0x87A5 #define GL_OUTPUT_TEXTURE_COORD9_EXT 0x87A6 #define GL_OUTPUT_TEXTURE_COORD10_EXT 0x87A7 #define GL_OUTPUT_TEXTURE_COORD11_EXT 0x87A8 #define GL_OUTPUT_TEXTURE_COORD12_EXT 0x87A9 #define GL_OUTPUT_TEXTURE_COORD13_EXT 0x87AA #define GL_OUTPUT_TEXTURE_COORD14_EXT 0x87AB #define GL_OUTPUT_TEXTURE_COORD15_EXT 0x87AC #define GL_OUTPUT_TEXTURE_COORD16_EXT 0x87AD #define GL_OUTPUT_TEXTURE_COORD17_EXT 0x87AE #define GL_OUTPUT_TEXTURE_COORD18_EXT 0x87AF #define GL_OUTPUT_TEXTURE_COORD19_EXT 0x87B0 #define GL_OUTPUT_TEXTURE_COORD20_EXT 0x87B1 #define GL_OUTPUT_TEXTURE_COORD21_EXT 0x87B2 #define GL_OUTPUT_TEXTURE_COORD22_EXT 0x87B3 #define GL_OUTPUT_TEXTURE_COORD23_EXT 0x87B4 #define GL_OUTPUT_TEXTURE_COORD24_EXT 0x87B5 #define GL_OUTPUT_TEXTURE_COORD25_EXT 0x87B6 #define GL_OUTPUT_TEXTURE_COORD26_EXT 0x87B7 #define GL_OUTPUT_TEXTURE_COORD27_EXT 0x87B8 #define GL_OUTPUT_TEXTURE_COORD28_EXT 0x87B9 #define GL_OUTPUT_TEXTURE_COORD29_EXT 0x87BA #define GL_OUTPUT_TEXTURE_COORD30_EXT 0x87BB #define GL_OUTPUT_TEXTURE_COORD31_EXT 0x87BC #define GL_OUTPUT_FOG_EXT 0x87BD #define GL_SCALAR_EXT 0x87BE #define GL_VECTOR_EXT 0x87BF #define GL_MATRIX_EXT 0x87C0 #define GL_VARIANT_EXT 0x87C1 #define GL_INVARIANT_EXT 0x87C2 #define GL_LOCAL_CONSTANT_EXT 0x87C3 #define GL_LOCAL_EXT 0x87C4 #define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5 #define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6 #define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7 #define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8 #define GL_MAX_VERTEX_SHADER_LOCALS_EXT 0x87C9 #define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA #define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB #define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CC #define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CD #define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE #define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF #define GL_VERTEX_SHADER_VARIANTS_EXT 0x87D0 #define GL_VERTEX_SHADER_INVARIANTS_EXT 0x87D1 #define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2 #define GL_VERTEX_SHADER_LOCALS_EXT 0x87D3 #define GL_VERTEX_SHADER_OPTIMIZED_EXT 0x87D4 #define GL_X_EXT 0x87D5 #define GL_Y_EXT 0x87D6 #define GL_Z_EXT 0x87D7 #define GL_W_EXT 0x87D8 #define GL_NEGATIVE_X_EXT 0x87D9 #define GL_NEGATIVE_Y_EXT 0x87DA #define GL_NEGATIVE_Z_EXT 0x87DB #define GL_NEGATIVE_W_EXT 0x87DC #define GL_ZERO_EXT 0x87DD #define GL_ONE_EXT 0x87DE #define GL_NEGATIVE_ONE_EXT 0x87DF #define GL_NORMALIZED_RANGE_EXT 0x87E0 #define GL_FULL_RANGE_EXT 0x87E1 #define GL_CURRENT_VERTEX_EXT 0x87E2 #define GL_MVP_MATRIX_EXT 0x87E3 #define GL_VARIANT_VALUE_EXT 0x87E4 #define GL_VARIANT_DATATYPE_EXT 0x87E5 #define GL_VARIANT_ARRAY_STRIDE_EXT 0x87E6 #define GL_VARIANT_ARRAY_TYPE_EXT 0x87E7 #define GL_VARIANT_ARRAY_EXT 0x87E8 #define GL_VARIANT_ARRAY_POINTER_EXT 0x87E9 #define GL_INVARIANT_VALUE_EXT 0x87EA #define GL_INVARIANT_DATATYPE_EXT 0x87EB #define GL_LOCAL_CONSTANT_VALUE_EXT 0x87EC #define GL_LOCAL_CONSTANT_DATATYPE_EXT 0x87ED typedef void (GLAPIENTRY * PFNGLBEGINVERTEXSHADEREXTPROC) (void); typedef GLuint (GLAPIENTRY * PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value); typedef GLuint (GLAPIENTRY * PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value); typedef GLuint (GLAPIENTRY * PFNGLBINDPARAMETEREXTPROC) (GLenum value); typedef GLuint (GLAPIENTRY * PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value); typedef GLuint (GLAPIENTRY * PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value); typedef void (GLAPIENTRY * PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLENDVERTEXSHADEREXTPROC) (void); typedef void (GLAPIENTRY * PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); typedef GLuint (GLAPIENTRY * PFNGLGENSYMBOLSEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components); typedef GLuint (GLAPIENTRY * PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range); typedef void (GLAPIENTRY * PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); typedef void (GLAPIENTRY * PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); typedef void (GLAPIENTRY * PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); typedef void (GLAPIENTRY * PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); typedef void (GLAPIENTRY * PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); typedef void (GLAPIENTRY * PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); typedef void (GLAPIENTRY * PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, void **data); typedef void (GLAPIENTRY * PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); typedef GLboolean (GLAPIENTRY * PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap); typedef void (GLAPIENTRY * PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, void *addr); typedef void (GLAPIENTRY * PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, void *addr); typedef void (GLAPIENTRY * PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1); typedef void (GLAPIENTRY * PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2); typedef void (GLAPIENTRY * PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3); typedef void (GLAPIENTRY * PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); typedef void (GLAPIENTRY * PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, void *addr); typedef void (GLAPIENTRY * PFNGLVARIANTBVEXTPROC) (GLuint id, GLbyte *addr); typedef void (GLAPIENTRY * PFNGLVARIANTDVEXTPROC) (GLuint id, GLdouble *addr); typedef void (GLAPIENTRY * PFNGLVARIANTFVEXTPROC) (GLuint id, GLfloat *addr); typedef void (GLAPIENTRY * PFNGLVARIANTIVEXTPROC) (GLuint id, GLint *addr); typedef void (GLAPIENTRY * PFNGLVARIANTSVEXTPROC) (GLuint id, GLshort *addr); typedef void (GLAPIENTRY * PFNGLVARIANTUBVEXTPROC) (GLuint id, GLubyte *addr); typedef void (GLAPIENTRY * PFNGLVARIANTUIVEXTPROC) (GLuint id, GLuint *addr); typedef void (GLAPIENTRY * PFNGLVARIANTUSVEXTPROC) (GLuint id, GLushort *addr); typedef void (GLAPIENTRY * PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); #define glBeginVertexShaderEXT GLEW_GET_FUN(__glewBeginVertexShaderEXT) #define glBindLightParameterEXT GLEW_GET_FUN(__glewBindLightParameterEXT) #define glBindMaterialParameterEXT GLEW_GET_FUN(__glewBindMaterialParameterEXT) #define glBindParameterEXT GLEW_GET_FUN(__glewBindParameterEXT) #define glBindTexGenParameterEXT GLEW_GET_FUN(__glewBindTexGenParameterEXT) #define glBindTextureUnitParameterEXT GLEW_GET_FUN(__glewBindTextureUnitParameterEXT) #define glBindVertexShaderEXT GLEW_GET_FUN(__glewBindVertexShaderEXT) #define glDeleteVertexShaderEXT GLEW_GET_FUN(__glewDeleteVertexShaderEXT) #define glDisableVariantClientStateEXT GLEW_GET_FUN(__glewDisableVariantClientStateEXT) #define glEnableVariantClientStateEXT GLEW_GET_FUN(__glewEnableVariantClientStateEXT) #define glEndVertexShaderEXT GLEW_GET_FUN(__glewEndVertexShaderEXT) #define glExtractComponentEXT GLEW_GET_FUN(__glewExtractComponentEXT) #define glGenSymbolsEXT GLEW_GET_FUN(__glewGenSymbolsEXT) #define glGenVertexShadersEXT GLEW_GET_FUN(__glewGenVertexShadersEXT) #define glGetInvariantBooleanvEXT GLEW_GET_FUN(__glewGetInvariantBooleanvEXT) #define glGetInvariantFloatvEXT GLEW_GET_FUN(__glewGetInvariantFloatvEXT) #define glGetInvariantIntegervEXT GLEW_GET_FUN(__glewGetInvariantIntegervEXT) #define glGetLocalConstantBooleanvEXT GLEW_GET_FUN(__glewGetLocalConstantBooleanvEXT) #define glGetLocalConstantFloatvEXT GLEW_GET_FUN(__glewGetLocalConstantFloatvEXT) #define glGetLocalConstantIntegervEXT GLEW_GET_FUN(__glewGetLocalConstantIntegervEXT) #define glGetVariantBooleanvEXT GLEW_GET_FUN(__glewGetVariantBooleanvEXT) #define glGetVariantFloatvEXT GLEW_GET_FUN(__glewGetVariantFloatvEXT) #define glGetVariantIntegervEXT GLEW_GET_FUN(__glewGetVariantIntegervEXT) #define glGetVariantPointervEXT GLEW_GET_FUN(__glewGetVariantPointervEXT) #define glInsertComponentEXT GLEW_GET_FUN(__glewInsertComponentEXT) #define glIsVariantEnabledEXT GLEW_GET_FUN(__glewIsVariantEnabledEXT) #define glSetInvariantEXT GLEW_GET_FUN(__glewSetInvariantEXT) #define glSetLocalConstantEXT GLEW_GET_FUN(__glewSetLocalConstantEXT) #define glShaderOp1EXT GLEW_GET_FUN(__glewShaderOp1EXT) #define glShaderOp2EXT GLEW_GET_FUN(__glewShaderOp2EXT) #define glShaderOp3EXT GLEW_GET_FUN(__glewShaderOp3EXT) #define glSwizzleEXT GLEW_GET_FUN(__glewSwizzleEXT) #define glVariantPointerEXT GLEW_GET_FUN(__glewVariantPointerEXT) #define glVariantbvEXT GLEW_GET_FUN(__glewVariantbvEXT) #define glVariantdvEXT GLEW_GET_FUN(__glewVariantdvEXT) #define glVariantfvEXT GLEW_GET_FUN(__glewVariantfvEXT) #define glVariantivEXT GLEW_GET_FUN(__glewVariantivEXT) #define glVariantsvEXT GLEW_GET_FUN(__glewVariantsvEXT) #define glVariantubvEXT GLEW_GET_FUN(__glewVariantubvEXT) #define glVariantuivEXT GLEW_GET_FUN(__glewVariantuivEXT) #define glVariantusvEXT GLEW_GET_FUN(__glewVariantusvEXT) #define glWriteMaskEXT GLEW_GET_FUN(__glewWriteMaskEXT) #define GLEW_EXT_vertex_shader GLEW_GET_VAR(__GLEW_EXT_vertex_shader) #endif /* GL_EXT_vertex_shader */ /* ------------------------ GL_EXT_vertex_weighting ------------------------ */ #ifndef GL_EXT_vertex_weighting #define GL_EXT_vertex_weighting 1 #define GL_MODELVIEW0_STACK_DEPTH_EXT 0x0BA3 #define GL_MODELVIEW0_MATRIX_EXT 0x0BA6 #define GL_MODELVIEW0_EXT 0x1700 #define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502 #define GL_MODELVIEW1_MATRIX_EXT 0x8506 #define GL_VERTEX_WEIGHTING_EXT 0x8509 #define GL_MODELVIEW1_EXT 0x850A #define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B #define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C #define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D #define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E #define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F #define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510 typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight); typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (GLfloat* weight); #define glVertexWeightPointerEXT GLEW_GET_FUN(__glewVertexWeightPointerEXT) #define glVertexWeightfEXT GLEW_GET_FUN(__glewVertexWeightfEXT) #define glVertexWeightfvEXT GLEW_GET_FUN(__glewVertexWeightfvEXT) #define GLEW_EXT_vertex_weighting GLEW_GET_VAR(__GLEW_EXT_vertex_weighting) #endif /* GL_EXT_vertex_weighting */ /* ------------------------- GL_EXT_x11_sync_object ------------------------ */ #ifndef GL_EXT_x11_sync_object #define GL_EXT_x11_sync_object 1 #define GL_SYNC_X11_FENCE_EXT 0x90E1 typedef GLsync (GLAPIENTRY * PFNGLIMPORTSYNCEXTPROC) (GLenum external_sync_type, GLintptr external_sync, GLbitfield flags); #define glImportSyncEXT GLEW_GET_FUN(__glewImportSyncEXT) #define GLEW_EXT_x11_sync_object GLEW_GET_VAR(__GLEW_EXT_x11_sync_object) #endif /* GL_EXT_x11_sync_object */ /* ---------------------- GL_GREMEDY_frame_terminator ---------------------- */ #ifndef GL_GREMEDY_frame_terminator #define GL_GREMEDY_frame_terminator 1 typedef void (GLAPIENTRY * PFNGLFRAMETERMINATORGREMEDYPROC) (void); #define glFrameTerminatorGREMEDY GLEW_GET_FUN(__glewFrameTerminatorGREMEDY) #define GLEW_GREMEDY_frame_terminator GLEW_GET_VAR(__GLEW_GREMEDY_frame_terminator) #endif /* GL_GREMEDY_frame_terminator */ /* ------------------------ GL_GREMEDY_string_marker ----------------------- */ #ifndef GL_GREMEDY_string_marker #define GL_GREMEDY_string_marker 1 typedef void (GLAPIENTRY * PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const void *string); #define glStringMarkerGREMEDY GLEW_GET_FUN(__glewStringMarkerGREMEDY) #define GLEW_GREMEDY_string_marker GLEW_GET_VAR(__GLEW_GREMEDY_string_marker) #endif /* GL_GREMEDY_string_marker */ /* --------------------- GL_HP_convolution_border_modes -------------------- */ #ifndef GL_HP_convolution_border_modes #define GL_HP_convolution_border_modes 1 #define GLEW_HP_convolution_border_modes GLEW_GET_VAR(__GLEW_HP_convolution_border_modes) #endif /* GL_HP_convolution_border_modes */ /* ------------------------- GL_HP_image_transform ------------------------- */ #ifndef GL_HP_image_transform #define GL_HP_image_transform 1 typedef void (GLAPIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, const GLfloat param); typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, const GLint param); typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint* params); #define glGetImageTransformParameterfvHP GLEW_GET_FUN(__glewGetImageTransformParameterfvHP) #define glGetImageTransformParameterivHP GLEW_GET_FUN(__glewGetImageTransformParameterivHP) #define glImageTransformParameterfHP GLEW_GET_FUN(__glewImageTransformParameterfHP) #define glImageTransformParameterfvHP GLEW_GET_FUN(__glewImageTransformParameterfvHP) #define glImageTransformParameteriHP GLEW_GET_FUN(__glewImageTransformParameteriHP) #define glImageTransformParameterivHP GLEW_GET_FUN(__glewImageTransformParameterivHP) #define GLEW_HP_image_transform GLEW_GET_VAR(__GLEW_HP_image_transform) #endif /* GL_HP_image_transform */ /* -------------------------- GL_HP_occlusion_test ------------------------- */ #ifndef GL_HP_occlusion_test #define GL_HP_occlusion_test 1 #define GLEW_HP_occlusion_test GLEW_GET_VAR(__GLEW_HP_occlusion_test) #endif /* GL_HP_occlusion_test */ /* ------------------------- GL_HP_texture_lighting ------------------------ */ #ifndef GL_HP_texture_lighting #define GL_HP_texture_lighting 1 #define GLEW_HP_texture_lighting GLEW_GET_VAR(__GLEW_HP_texture_lighting) #endif /* GL_HP_texture_lighting */ /* --------------------------- GL_IBM_cull_vertex -------------------------- */ #ifndef GL_IBM_cull_vertex #define GL_IBM_cull_vertex 1 #define GL_CULL_VERTEX_IBM 103050 #define GLEW_IBM_cull_vertex GLEW_GET_VAR(__GLEW_IBM_cull_vertex) #endif /* GL_IBM_cull_vertex */ /* ---------------------- GL_IBM_multimode_draw_arrays --------------------- */ #ifndef GL_IBM_multimode_draw_arrays #define GL_IBM_multimode_draw_arrays 1 typedef void (GLAPIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum* mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride); typedef void (GLAPIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum* mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei primcount, GLint modestride); #define glMultiModeDrawArraysIBM GLEW_GET_FUN(__glewMultiModeDrawArraysIBM) #define glMultiModeDrawElementsIBM GLEW_GET_FUN(__glewMultiModeDrawElementsIBM) #define GLEW_IBM_multimode_draw_arrays GLEW_GET_VAR(__GLEW_IBM_multimode_draw_arrays) #endif /* GL_IBM_multimode_draw_arrays */ /* ------------------------- GL_IBM_rasterpos_clip ------------------------- */ #ifndef GL_IBM_rasterpos_clip #define GL_IBM_rasterpos_clip 1 #define GL_RASTER_POSITION_UNCLIPPED_IBM 103010 #define GLEW_IBM_rasterpos_clip GLEW_GET_VAR(__GLEW_IBM_rasterpos_clip) #endif /* GL_IBM_rasterpos_clip */ /* --------------------------- GL_IBM_static_data -------------------------- */ #ifndef GL_IBM_static_data #define GL_IBM_static_data 1 #define GL_ALL_STATIC_DATA_IBM 103060 #define GL_STATIC_VERTEX_ARRAY_IBM 103061 #define GLEW_IBM_static_data GLEW_GET_VAR(__GLEW_IBM_static_data) #endif /* GL_IBM_static_data */ /* --------------------- GL_IBM_texture_mirrored_repeat -------------------- */ #ifndef GL_IBM_texture_mirrored_repeat #define GL_IBM_texture_mirrored_repeat 1 #define GL_MIRRORED_REPEAT_IBM 0x8370 #define GLEW_IBM_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_IBM_texture_mirrored_repeat) #endif /* GL_IBM_texture_mirrored_repeat */ /* ----------------------- GL_IBM_vertex_array_lists ----------------------- */ #ifndef GL_IBM_vertex_array_lists #define GL_IBM_vertex_array_lists 1 #define GL_VERTEX_ARRAY_LIST_IBM 103070 #define GL_NORMAL_ARRAY_LIST_IBM 103071 #define GL_COLOR_ARRAY_LIST_IBM 103072 #define GL_INDEX_ARRAY_LIST_IBM 103073 #define GL_TEXTURE_COORD_ARRAY_LIST_IBM 103074 #define GL_EDGE_FLAG_ARRAY_LIST_IBM 103075 #define GL_FOG_COORDINATE_ARRAY_LIST_IBM 103076 #define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077 #define GL_VERTEX_ARRAY_LIST_STRIDE_IBM 103080 #define GL_NORMAL_ARRAY_LIST_STRIDE_IBM 103081 #define GL_COLOR_ARRAY_LIST_STRIDE_IBM 103082 #define GL_INDEX_ARRAY_LIST_STRIDE_IBM 103083 #define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084 #define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085 #define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086 #define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087 typedef void (GLAPIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean ** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const void** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const void** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const void** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride); typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride); #define glColorPointerListIBM GLEW_GET_FUN(__glewColorPointerListIBM) #define glEdgeFlagPointerListIBM GLEW_GET_FUN(__glewEdgeFlagPointerListIBM) #define glFogCoordPointerListIBM GLEW_GET_FUN(__glewFogCoordPointerListIBM) #define glIndexPointerListIBM GLEW_GET_FUN(__glewIndexPointerListIBM) #define glNormalPointerListIBM GLEW_GET_FUN(__glewNormalPointerListIBM) #define glSecondaryColorPointerListIBM GLEW_GET_FUN(__glewSecondaryColorPointerListIBM) #define glTexCoordPointerListIBM GLEW_GET_FUN(__glewTexCoordPointerListIBM) #define glVertexPointerListIBM GLEW_GET_FUN(__glewVertexPointerListIBM) #define GLEW_IBM_vertex_array_lists GLEW_GET_VAR(__GLEW_IBM_vertex_array_lists) #endif /* GL_IBM_vertex_array_lists */ /* -------------------------- GL_INGR_color_clamp -------------------------- */ #ifndef GL_INGR_color_clamp #define GL_INGR_color_clamp 1 #define GL_RED_MIN_CLAMP_INGR 0x8560 #define GL_GREEN_MIN_CLAMP_INGR 0x8561 #define GL_BLUE_MIN_CLAMP_INGR 0x8562 #define GL_ALPHA_MIN_CLAMP_INGR 0x8563 #define GL_RED_MAX_CLAMP_INGR 0x8564 #define GL_GREEN_MAX_CLAMP_INGR 0x8565 #define GL_BLUE_MAX_CLAMP_INGR 0x8566 #define GL_ALPHA_MAX_CLAMP_INGR 0x8567 #define GLEW_INGR_color_clamp GLEW_GET_VAR(__GLEW_INGR_color_clamp) #endif /* GL_INGR_color_clamp */ /* ------------------------- GL_INGR_interlace_read ------------------------ */ #ifndef GL_INGR_interlace_read #define GL_INGR_interlace_read 1 #define GL_INTERLACE_READ_INGR 0x8568 #define GLEW_INGR_interlace_read GLEW_GET_VAR(__GLEW_INGR_interlace_read) #endif /* GL_INGR_interlace_read */ /* ------------------- GL_INTEL_fragment_shader_ordering ------------------- */ #ifndef GL_INTEL_fragment_shader_ordering #define GL_INTEL_fragment_shader_ordering 1 #define GLEW_INTEL_fragment_shader_ordering GLEW_GET_VAR(__GLEW_INTEL_fragment_shader_ordering) #endif /* GL_INTEL_fragment_shader_ordering */ /* ----------------------- GL_INTEL_framebuffer_CMAA ----------------------- */ #ifndef GL_INTEL_framebuffer_CMAA #define GL_INTEL_framebuffer_CMAA 1 #define GLEW_INTEL_framebuffer_CMAA GLEW_GET_VAR(__GLEW_INTEL_framebuffer_CMAA) #endif /* GL_INTEL_framebuffer_CMAA */ /* -------------------------- GL_INTEL_map_texture ------------------------- */ #ifndef GL_INTEL_map_texture #define GL_INTEL_map_texture 1 #define GL_LAYOUT_DEFAULT_INTEL 0 #define GL_LAYOUT_LINEAR_INTEL 1 #define GL_LAYOUT_LINEAR_CPU_CACHED_INTEL 2 #define GL_TEXTURE_MEMORY_LAYOUT_INTEL 0x83FF typedef void * (GLAPIENTRY * PFNGLMAPTEXTURE2DINTELPROC) (GLuint texture, GLint level, GLbitfield access, GLint* stride, GLenum *layout); typedef void (GLAPIENTRY * PFNGLSYNCTEXTUREINTELPROC) (GLuint texture); typedef void (GLAPIENTRY * PFNGLUNMAPTEXTURE2DINTELPROC) (GLuint texture, GLint level); #define glMapTexture2DINTEL GLEW_GET_FUN(__glewMapTexture2DINTEL) #define glSyncTextureINTEL GLEW_GET_FUN(__glewSyncTextureINTEL) #define glUnmapTexture2DINTEL GLEW_GET_FUN(__glewUnmapTexture2DINTEL) #define GLEW_INTEL_map_texture GLEW_GET_VAR(__GLEW_INTEL_map_texture) #endif /* GL_INTEL_map_texture */ /* ------------------------ GL_INTEL_parallel_arrays ----------------------- */ #ifndef GL_INTEL_parallel_arrays #define GL_INTEL_parallel_arrays 1 #define GL_PARALLEL_ARRAYS_INTEL 0x83F4 #define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5 #define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6 #define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7 #define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8 typedef void (GLAPIENTRY * PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); typedef void (GLAPIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const void** pointer); typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); #define glColorPointervINTEL GLEW_GET_FUN(__glewColorPointervINTEL) #define glNormalPointervINTEL GLEW_GET_FUN(__glewNormalPointervINTEL) #define glTexCoordPointervINTEL GLEW_GET_FUN(__glewTexCoordPointervINTEL) #define glVertexPointervINTEL GLEW_GET_FUN(__glewVertexPointervINTEL) #define GLEW_INTEL_parallel_arrays GLEW_GET_VAR(__GLEW_INTEL_parallel_arrays) #endif /* GL_INTEL_parallel_arrays */ /* ----------------------- GL_INTEL_performance_query ---------------------- */ #ifndef GL_INTEL_performance_query #define GL_INTEL_performance_query 1 #define GL_PERFQUERY_SINGLE_CONTEXT_INTEL 0x0000 #define GL_PERFQUERY_GLOBAL_CONTEXT_INTEL 0x0001 #define GL_PERFQUERY_DONOT_FLUSH_INTEL 0x83F9 #define GL_PERFQUERY_FLUSH_INTEL 0x83FA #define GL_PERFQUERY_WAIT_INTEL 0x83FB #define GL_PERFQUERY_COUNTER_EVENT_INTEL 0x94F0 #define GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL 0x94F1 #define GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL 0x94F2 #define GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL 0x94F3 #define GL_PERFQUERY_COUNTER_RAW_INTEL 0x94F4 #define GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL 0x94F5 #define GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL 0x94F8 #define GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL 0x94F9 #define GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL 0x94FA #define GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL 0x94FB #define GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL 0x94FC #define GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL 0x94FD #define GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL 0x94FE #define GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL 0x94FF #define GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL 0x9500 typedef void (GLAPIENTRY * PFNGLBEGINPERFQUERYINTELPROC) (GLuint queryHandle); typedef void (GLAPIENTRY * PFNGLCREATEPERFQUERYINTELPROC) (GLuint queryId, GLuint* queryHandle); typedef void (GLAPIENTRY * PFNGLDELETEPERFQUERYINTELPROC) (GLuint queryHandle); typedef void (GLAPIENTRY * PFNGLENDPERFQUERYINTELPROC) (GLuint queryHandle); typedef void (GLAPIENTRY * PFNGLGETFIRSTPERFQUERYIDINTELPROC) (GLuint* queryId); typedef void (GLAPIENTRY * PFNGLGETNEXTPERFQUERYIDINTELPROC) (GLuint queryId, GLuint* nextQueryId); typedef void (GLAPIENTRY * PFNGLGETPERFCOUNTERINFOINTELPROC) (GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar* counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue); typedef void (GLAPIENTRY * PFNGLGETPERFQUERYDATAINTELPROC) (GLuint queryHandle, GLuint flags, GLsizei dataSize, void *data, GLuint *bytesWritten); typedef void (GLAPIENTRY * PFNGLGETPERFQUERYIDBYNAMEINTELPROC) (GLchar* queryName, GLuint *queryId); typedef void (GLAPIENTRY * PFNGLGETPERFQUERYINFOINTELPROC) (GLuint queryId, GLuint queryNameLength, GLchar* queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask); #define glBeginPerfQueryINTEL GLEW_GET_FUN(__glewBeginPerfQueryINTEL) #define glCreatePerfQueryINTEL GLEW_GET_FUN(__glewCreatePerfQueryINTEL) #define glDeletePerfQueryINTEL GLEW_GET_FUN(__glewDeletePerfQueryINTEL) #define glEndPerfQueryINTEL GLEW_GET_FUN(__glewEndPerfQueryINTEL) #define glGetFirstPerfQueryIdINTEL GLEW_GET_FUN(__glewGetFirstPerfQueryIdINTEL) #define glGetNextPerfQueryIdINTEL GLEW_GET_FUN(__glewGetNextPerfQueryIdINTEL) #define glGetPerfCounterInfoINTEL GLEW_GET_FUN(__glewGetPerfCounterInfoINTEL) #define glGetPerfQueryDataINTEL GLEW_GET_FUN(__glewGetPerfQueryDataINTEL) #define glGetPerfQueryIdByNameINTEL GLEW_GET_FUN(__glewGetPerfQueryIdByNameINTEL) #define glGetPerfQueryInfoINTEL GLEW_GET_FUN(__glewGetPerfQueryInfoINTEL) #define GLEW_INTEL_performance_query GLEW_GET_VAR(__GLEW_INTEL_performance_query) #endif /* GL_INTEL_performance_query */ /* ------------------------ GL_INTEL_texture_scissor ----------------------- */ #ifndef GL_INTEL_texture_scissor #define GL_INTEL_texture_scissor 1 typedef void (GLAPIENTRY * PFNGLTEXSCISSORFUNCINTELPROC) (GLenum target, GLenum lfunc, GLenum hfunc); typedef void (GLAPIENTRY * PFNGLTEXSCISSORINTELPROC) (GLenum target, GLclampf tlow, GLclampf thigh); #define glTexScissorFuncINTEL GLEW_GET_FUN(__glewTexScissorFuncINTEL) #define glTexScissorINTEL GLEW_GET_FUN(__glewTexScissorINTEL) #define GLEW_INTEL_texture_scissor GLEW_GET_VAR(__GLEW_INTEL_texture_scissor) #endif /* GL_INTEL_texture_scissor */ /* --------------------- GL_KHR_blend_equation_advanced -------------------- */ #ifndef GL_KHR_blend_equation_advanced #define GL_KHR_blend_equation_advanced 1 #define GL_BLEND_ADVANCED_COHERENT_KHR 0x9285 #define GL_MULTIPLY_KHR 0x9294 #define GL_SCREEN_KHR 0x9295 #define GL_OVERLAY_KHR 0x9296 #define GL_DARKEN_KHR 0x9297 #define GL_LIGHTEN_KHR 0x9298 #define GL_COLORDODGE_KHR 0x9299 #define GL_COLORBURN_KHR 0x929A #define GL_HARDLIGHT_KHR 0x929B #define GL_SOFTLIGHT_KHR 0x929C #define GL_DIFFERENCE_KHR 0x929E #define GL_EXCLUSION_KHR 0x92A0 #define GL_HSL_HUE_KHR 0x92AD #define GL_HSL_SATURATION_KHR 0x92AE #define GL_HSL_COLOR_KHR 0x92AF #define GL_HSL_LUMINOSITY_KHR 0x92B0 typedef void (GLAPIENTRY * PFNGLBLENDBARRIERKHRPROC) (void); #define glBlendBarrierKHR GLEW_GET_FUN(__glewBlendBarrierKHR) #define GLEW_KHR_blend_equation_advanced GLEW_GET_VAR(__GLEW_KHR_blend_equation_advanced) #endif /* GL_KHR_blend_equation_advanced */ /* ---------------- GL_KHR_blend_equation_advanced_coherent ---------------- */ #ifndef GL_KHR_blend_equation_advanced_coherent #define GL_KHR_blend_equation_advanced_coherent 1 #define GLEW_KHR_blend_equation_advanced_coherent GLEW_GET_VAR(__GLEW_KHR_blend_equation_advanced_coherent) #endif /* GL_KHR_blend_equation_advanced_coherent */ /* ---------------------- GL_KHR_context_flush_control --------------------- */ #ifndef GL_KHR_context_flush_control #define GL_KHR_context_flush_control 1 #define GL_CONTEXT_RELEASE_BEHAVIOR 0x82FB #define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82FC #define GLEW_KHR_context_flush_control GLEW_GET_VAR(__GLEW_KHR_context_flush_control) #endif /* GL_KHR_context_flush_control */ /* ------------------------------ GL_KHR_debug ----------------------------- */ #ifndef GL_KHR_debug #define GL_KHR_debug 1 #define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002 #define GL_STACK_OVERFLOW 0x0503 #define GL_STACK_UNDERFLOW 0x0504 #define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242 #define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243 #define GL_DEBUG_CALLBACK_FUNCTION 0x8244 #define GL_DEBUG_CALLBACK_USER_PARAM 0x8245 #define GL_DEBUG_SOURCE_API 0x8246 #define GL_DEBUG_SOURCE_WINDOW_SYSTEM 0x8247 #define GL_DEBUG_SOURCE_SHADER_COMPILER 0x8248 #define GL_DEBUG_SOURCE_THIRD_PARTY 0x8249 #define GL_DEBUG_SOURCE_APPLICATION 0x824A #define GL_DEBUG_SOURCE_OTHER 0x824B #define GL_DEBUG_TYPE_ERROR 0x824C #define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D #define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR 0x824E #define GL_DEBUG_TYPE_PORTABILITY 0x824F #define GL_DEBUG_TYPE_PERFORMANCE 0x8250 #define GL_DEBUG_TYPE_OTHER 0x8251 #define GL_DEBUG_TYPE_MARKER 0x8268 #define GL_DEBUG_TYPE_PUSH_GROUP 0x8269 #define GL_DEBUG_TYPE_POP_GROUP 0x826A #define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B #define GL_MAX_DEBUG_GROUP_STACK_DEPTH 0x826C #define GL_DEBUG_GROUP_STACK_DEPTH 0x826D #define GL_BUFFER 0x82E0 #define GL_SHADER 0x82E1 #define GL_PROGRAM 0x82E2 #define GL_QUERY 0x82E3 #define GL_PROGRAM_PIPELINE 0x82E4 #define GL_SAMPLER 0x82E6 #define GL_DISPLAY_LIST 0x82E7 #define GL_MAX_LABEL_LENGTH 0x82E8 #define GL_MAX_DEBUG_MESSAGE_LENGTH 0x9143 #define GL_MAX_DEBUG_LOGGED_MESSAGES 0x9144 #define GL_DEBUG_LOGGED_MESSAGES 0x9145 #define GL_DEBUG_SEVERITY_HIGH 0x9146 #define GL_DEBUG_SEVERITY_MEDIUM 0x9147 #define GL_DEBUG_SEVERITY_LOW 0x9148 #define GL_DEBUG_OUTPUT 0x92E0 typedef void (GLAPIENTRY *GLDEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECALLBACKPROC) (GLDEBUGPROC callback, const void *userParam); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECONTROLPROC) (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled); typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTPROC) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf); typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGPROC) (GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog); typedef void (GLAPIENTRY * PFNGLGETOBJECTLABELPROC) (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar *label); typedef void (GLAPIENTRY * PFNGLGETOBJECTPTRLABELPROC) (const void *ptr, GLsizei bufSize, GLsizei* length, GLchar *label); typedef void (GLAPIENTRY * PFNGLOBJECTLABELPROC) (GLenum identifier, GLuint name, GLsizei length, const GLchar* label); typedef void (GLAPIENTRY * PFNGLOBJECTPTRLABELPROC) (const void *ptr, GLsizei length, const GLchar* label); typedef void (GLAPIENTRY * PFNGLPOPDEBUGGROUPPROC) (void); typedef void (GLAPIENTRY * PFNGLPUSHDEBUGGROUPPROC) (GLenum source, GLuint id, GLsizei length, const GLchar * message); #define glDebugMessageCallback GLEW_GET_FUN(__glewDebugMessageCallback) #define glDebugMessageControl GLEW_GET_FUN(__glewDebugMessageControl) #define glDebugMessageInsert GLEW_GET_FUN(__glewDebugMessageInsert) #define glGetDebugMessageLog GLEW_GET_FUN(__glewGetDebugMessageLog) #define glGetObjectLabel GLEW_GET_FUN(__glewGetObjectLabel) #define glGetObjectPtrLabel GLEW_GET_FUN(__glewGetObjectPtrLabel) #define glObjectLabel GLEW_GET_FUN(__glewObjectLabel) #define glObjectPtrLabel GLEW_GET_FUN(__glewObjectPtrLabel) #define glPopDebugGroup GLEW_GET_FUN(__glewPopDebugGroup) #define glPushDebugGroup GLEW_GET_FUN(__glewPushDebugGroup) #define GLEW_KHR_debug GLEW_GET_VAR(__GLEW_KHR_debug) #endif /* GL_KHR_debug */ /* ---------------------------- GL_KHR_no_error ---------------------------- */ #ifndef GL_KHR_no_error #define GL_KHR_no_error 1 #define GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR 0x00000008 #define GLEW_KHR_no_error GLEW_GET_VAR(__GLEW_KHR_no_error) #endif /* GL_KHR_no_error */ /* ------------------ GL_KHR_robust_buffer_access_behavior ----------------- */ #ifndef GL_KHR_robust_buffer_access_behavior #define GL_KHR_robust_buffer_access_behavior 1 #define GLEW_KHR_robust_buffer_access_behavior GLEW_GET_VAR(__GLEW_KHR_robust_buffer_access_behavior) #endif /* GL_KHR_robust_buffer_access_behavior */ /* --------------------------- GL_KHR_robustness --------------------------- */ #ifndef GL_KHR_robustness #define GL_KHR_robustness 1 #define GL_CONTEXT_LOST 0x0507 #define GL_LOSE_CONTEXT_ON_RESET 0x8252 #define GL_GUILTY_CONTEXT_RESET 0x8253 #define GL_INNOCENT_CONTEXT_RESET 0x8254 #define GL_UNKNOWN_CONTEXT_RESET 0x8255 #define GL_RESET_NOTIFICATION_STRATEGY 0x8256 #define GL_NO_RESET_NOTIFICATION 0x8261 #define GL_CONTEXT_ROBUST_ACCESS 0x90F3 typedef void (GLAPIENTRY * PFNGLGETNUNIFORMFVPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMIVPROC) (GLuint program, GLint location, GLsizei bufSize, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNUNIFORMUIVPROC) (GLuint program, GLint location, GLsizei bufSize, GLuint* params); typedef void (GLAPIENTRY * PFNGLREADNPIXELSPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data); #define glGetnUniformfv GLEW_GET_FUN(__glewGetnUniformfv) #define glGetnUniformiv GLEW_GET_FUN(__glewGetnUniformiv) #define glGetnUniformuiv GLEW_GET_FUN(__glewGetnUniformuiv) #define glReadnPixels GLEW_GET_FUN(__glewReadnPixels) #define GLEW_KHR_robustness GLEW_GET_VAR(__GLEW_KHR_robustness) #endif /* GL_KHR_robustness */ /* ------------------ GL_KHR_texture_compression_astc_hdr ------------------ */ #ifndef GL_KHR_texture_compression_astc_hdr #define GL_KHR_texture_compression_astc_hdr 1 #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0 #define GL_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1 #define GL_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2 #define GL_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3 #define GL_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4 #define GL_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5 #define GL_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6 #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7 #define GL_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8 #define GL_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9 #define GL_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA #define GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB #define GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC #define GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD #define GLEW_KHR_texture_compression_astc_hdr GLEW_GET_VAR(__GLEW_KHR_texture_compression_astc_hdr) #endif /* GL_KHR_texture_compression_astc_hdr */ /* ------------------ GL_KHR_texture_compression_astc_ldr ------------------ */ #ifndef GL_KHR_texture_compression_astc_ldr #define GL_KHR_texture_compression_astc_ldr 1 #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0 #define GL_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1 #define GL_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2 #define GL_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3 #define GL_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4 #define GL_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5 #define GL_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6 #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7 #define GL_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8 #define GL_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9 #define GL_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA #define GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB #define GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC #define GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD #define GLEW_KHR_texture_compression_astc_ldr GLEW_GET_VAR(__GLEW_KHR_texture_compression_astc_ldr) #endif /* GL_KHR_texture_compression_astc_ldr */ /* -------------------------- GL_KTX_buffer_region ------------------------- */ #ifndef GL_KTX_buffer_region #define GL_KTX_buffer_region 1 #define GL_KTX_FRONT_REGION 0x0 #define GL_KTX_BACK_REGION 0x1 #define GL_KTX_Z_REGION 0x2 #define GL_KTX_STENCIL_REGION 0x3 typedef GLuint (GLAPIENTRY * PFNGLBUFFERREGIONENABLEDPROC) (void); typedef void (GLAPIENTRY * PFNGLDELETEBUFFERREGIONPROC) (GLenum region); typedef void (GLAPIENTRY * PFNGLDRAWBUFFERREGIONPROC) (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest); typedef GLuint (GLAPIENTRY * PFNGLNEWBUFFERREGIONPROC) (GLenum region); typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONPROC) (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height); #define glBufferRegionEnabled GLEW_GET_FUN(__glewBufferRegionEnabled) #define glDeleteBufferRegion GLEW_GET_FUN(__glewDeleteBufferRegion) #define glDrawBufferRegion GLEW_GET_FUN(__glewDrawBufferRegion) #define glNewBufferRegion GLEW_GET_FUN(__glewNewBufferRegion) #define glReadBufferRegion GLEW_GET_FUN(__glewReadBufferRegion) #define GLEW_KTX_buffer_region GLEW_GET_VAR(__GLEW_KTX_buffer_region) #endif /* GL_KTX_buffer_region */ /* ------------------------- GL_MESAX_texture_stack ------------------------ */ #ifndef GL_MESAX_texture_stack #define GL_MESAX_texture_stack 1 #define GL_TEXTURE_1D_STACK_MESAX 0x8759 #define GL_TEXTURE_2D_STACK_MESAX 0x875A #define GL_PROXY_TEXTURE_1D_STACK_MESAX 0x875B #define GL_PROXY_TEXTURE_2D_STACK_MESAX 0x875C #define GL_TEXTURE_1D_STACK_BINDING_MESAX 0x875D #define GL_TEXTURE_2D_STACK_BINDING_MESAX 0x875E #define GLEW_MESAX_texture_stack GLEW_GET_VAR(__GLEW_MESAX_texture_stack) #endif /* GL_MESAX_texture_stack */ /* -------------------------- GL_MESA_pack_invert -------------------------- */ #ifndef GL_MESA_pack_invert #define GL_MESA_pack_invert 1 #define GL_PACK_INVERT_MESA 0x8758 #define GLEW_MESA_pack_invert GLEW_GET_VAR(__GLEW_MESA_pack_invert) #endif /* GL_MESA_pack_invert */ /* ------------------------- GL_MESA_resize_buffers ------------------------ */ #ifndef GL_MESA_resize_buffers #define GL_MESA_resize_buffers 1 typedef void (GLAPIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void); #define glResizeBuffersMESA GLEW_GET_FUN(__glewResizeBuffersMESA) #define GLEW_MESA_resize_buffers GLEW_GET_VAR(__GLEW_MESA_resize_buffers) #endif /* GL_MESA_resize_buffers */ /* --------------------------- GL_MESA_window_pos -------------------------- */ #ifndef GL_MESA_window_pos #define GL_MESA_window_pos 1 typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVMESAPROC) (const GLint* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVMESAPROC) (const GLshort* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVMESAPROC) (const GLint* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVMESAPROC) (const GLshort* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4IVMESAPROC) (const GLint* p); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAPIENTRY * PFNGLWINDOWPOS4SVMESAPROC) (const GLshort* p); #define glWindowPos2dMESA GLEW_GET_FUN(__glewWindowPos2dMESA) #define glWindowPos2dvMESA GLEW_GET_FUN(__glewWindowPos2dvMESA) #define glWindowPos2fMESA GLEW_GET_FUN(__glewWindowPos2fMESA) #define glWindowPos2fvMESA GLEW_GET_FUN(__glewWindowPos2fvMESA) #define glWindowPos2iMESA GLEW_GET_FUN(__glewWindowPos2iMESA) #define glWindowPos2ivMESA GLEW_GET_FUN(__glewWindowPos2ivMESA) #define glWindowPos2sMESA GLEW_GET_FUN(__glewWindowPos2sMESA) #define glWindowPos2svMESA GLEW_GET_FUN(__glewWindowPos2svMESA) #define glWindowPos3dMESA GLEW_GET_FUN(__glewWindowPos3dMESA) #define glWindowPos3dvMESA GLEW_GET_FUN(__glewWindowPos3dvMESA) #define glWindowPos3fMESA GLEW_GET_FUN(__glewWindowPos3fMESA) #define glWindowPos3fvMESA GLEW_GET_FUN(__glewWindowPos3fvMESA) #define glWindowPos3iMESA GLEW_GET_FUN(__glewWindowPos3iMESA) #define glWindowPos3ivMESA GLEW_GET_FUN(__glewWindowPos3ivMESA) #define glWindowPos3sMESA GLEW_GET_FUN(__glewWindowPos3sMESA) #define glWindowPos3svMESA GLEW_GET_FUN(__glewWindowPos3svMESA) #define glWindowPos4dMESA GLEW_GET_FUN(__glewWindowPos4dMESA) #define glWindowPos4dvMESA GLEW_GET_FUN(__glewWindowPos4dvMESA) #define glWindowPos4fMESA GLEW_GET_FUN(__glewWindowPos4fMESA) #define glWindowPos4fvMESA GLEW_GET_FUN(__glewWindowPos4fvMESA) #define glWindowPos4iMESA GLEW_GET_FUN(__glewWindowPos4iMESA) #define glWindowPos4ivMESA GLEW_GET_FUN(__glewWindowPos4ivMESA) #define glWindowPos4sMESA GLEW_GET_FUN(__glewWindowPos4sMESA) #define glWindowPos4svMESA GLEW_GET_FUN(__glewWindowPos4svMESA) #define GLEW_MESA_window_pos GLEW_GET_VAR(__GLEW_MESA_window_pos) #endif /* GL_MESA_window_pos */ /* ------------------------- GL_MESA_ycbcr_texture ------------------------- */ #ifndef GL_MESA_ycbcr_texture #define GL_MESA_ycbcr_texture 1 #define GL_UNSIGNED_SHORT_8_8_MESA 0x85BA #define GL_UNSIGNED_SHORT_8_8_REV_MESA 0x85BB #define GL_YCBCR_MESA 0x8757 #define GLEW_MESA_ycbcr_texture GLEW_GET_VAR(__GLEW_MESA_ycbcr_texture) #endif /* GL_MESA_ycbcr_texture */ /* ----------------------- GL_NVX_conditional_render ----------------------- */ #ifndef GL_NVX_conditional_render #define GL_NVX_conditional_render 1 typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERNVXPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERNVXPROC) (void); #define glBeginConditionalRenderNVX GLEW_GET_FUN(__glewBeginConditionalRenderNVX) #define glEndConditionalRenderNVX GLEW_GET_FUN(__glewEndConditionalRenderNVX) #define GLEW_NVX_conditional_render GLEW_GET_VAR(__GLEW_NVX_conditional_render) #endif /* GL_NVX_conditional_render */ /* ------------------------- GL_NVX_gpu_memory_info ------------------------ */ #ifndef GL_NVX_gpu_memory_info #define GL_NVX_gpu_memory_info 1 #define GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX 0x9047 #define GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX 0x9048 #define GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX 0x9049 #define GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX 0x904A #define GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX 0x904B #define GLEW_NVX_gpu_memory_info GLEW_GET_VAR(__GLEW_NVX_gpu_memory_info) #endif /* GL_NVX_gpu_memory_info */ /* ------------------- GL_NV_bindless_multi_draw_indirect ------------------ */ #ifndef GL_NV_bindless_multi_draw_indirect #define GL_NV_bindless_multi_draw_indirect 1 typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC) (GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC) (GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount); #define glMultiDrawArraysIndirectBindlessNV GLEW_GET_FUN(__glewMultiDrawArraysIndirectBindlessNV) #define glMultiDrawElementsIndirectBindlessNV GLEW_GET_FUN(__glewMultiDrawElementsIndirectBindlessNV) #define GLEW_NV_bindless_multi_draw_indirect GLEW_GET_VAR(__GLEW_NV_bindless_multi_draw_indirect) #endif /* GL_NV_bindless_multi_draw_indirect */ /* ---------------- GL_NV_bindless_multi_draw_indirect_count --------------- */ #ifndef GL_NV_bindless_multi_draw_indirect_count #define GL_NV_bindless_multi_draw_indirect_count 1 typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC) (GLenum mode, const void *indirect, GLintptr drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount); typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC) (GLenum mode, GLenum type, const void *indirect, GLintptr drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount); #define glMultiDrawArraysIndirectBindlessCountNV GLEW_GET_FUN(__glewMultiDrawArraysIndirectBindlessCountNV) #define glMultiDrawElementsIndirectBindlessCountNV GLEW_GET_FUN(__glewMultiDrawElementsIndirectBindlessCountNV) #define GLEW_NV_bindless_multi_draw_indirect_count GLEW_GET_VAR(__GLEW_NV_bindless_multi_draw_indirect_count) #endif /* GL_NV_bindless_multi_draw_indirect_count */ /* ------------------------- GL_NV_bindless_texture ------------------------ */ #ifndef GL_NV_bindless_texture #define GL_NV_bindless_texture 1 typedef GLuint64 (GLAPIENTRY * PFNGLGETIMAGEHANDLENVPROC) (GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format); typedef GLuint64 (GLAPIENTRY * PFNGLGETTEXTUREHANDLENVPROC) (GLuint texture); typedef GLuint64 (GLAPIENTRY * PFNGLGETTEXTURESAMPLERHANDLENVPROC) (GLuint texture, GLuint sampler); typedef GLboolean (GLAPIENTRY * PFNGLISIMAGEHANDLERESIDENTNVPROC) (GLuint64 handle); typedef GLboolean (GLAPIENTRY * PFNGLISTEXTUREHANDLERESIDENTNVPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLMAKEIMAGEHANDLERESIDENTNVPROC) (GLuint64 handle, GLenum access); typedef void (GLAPIENTRY * PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLMAKETEXTUREHANDLERESIDENTNVPROC) (GLuint64 handle); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC) (GLuint program, GLint location, GLuint64 value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* values); typedef void (GLAPIENTRY * PFNGLUNIFORMHANDLEUI64NVPROC) (GLint location, GLuint64 value); typedef void (GLAPIENTRY * PFNGLUNIFORMHANDLEUI64VNVPROC) (GLint location, GLsizei count, const GLuint64* value); #define glGetImageHandleNV GLEW_GET_FUN(__glewGetImageHandleNV) #define glGetTextureHandleNV GLEW_GET_FUN(__glewGetTextureHandleNV) #define glGetTextureSamplerHandleNV GLEW_GET_FUN(__glewGetTextureSamplerHandleNV) #define glIsImageHandleResidentNV GLEW_GET_FUN(__glewIsImageHandleResidentNV) #define glIsTextureHandleResidentNV GLEW_GET_FUN(__glewIsTextureHandleResidentNV) #define glMakeImageHandleNonResidentNV GLEW_GET_FUN(__glewMakeImageHandleNonResidentNV) #define glMakeImageHandleResidentNV GLEW_GET_FUN(__glewMakeImageHandleResidentNV) #define glMakeTextureHandleNonResidentNV GLEW_GET_FUN(__glewMakeTextureHandleNonResidentNV) #define glMakeTextureHandleResidentNV GLEW_GET_FUN(__glewMakeTextureHandleResidentNV) #define glProgramUniformHandleui64NV GLEW_GET_FUN(__glewProgramUniformHandleui64NV) #define glProgramUniformHandleui64vNV GLEW_GET_FUN(__glewProgramUniformHandleui64vNV) #define glUniformHandleui64NV GLEW_GET_FUN(__glewUniformHandleui64NV) #define glUniformHandleui64vNV GLEW_GET_FUN(__glewUniformHandleui64vNV) #define GLEW_NV_bindless_texture GLEW_GET_VAR(__GLEW_NV_bindless_texture) #endif /* GL_NV_bindless_texture */ /* --------------------- GL_NV_blend_equation_advanced --------------------- */ #ifndef GL_NV_blend_equation_advanced #define GL_NV_blend_equation_advanced 1 #define GL_XOR_NV 0x1506 #define GL_RED_NV 0x1903 #define GL_GREEN_NV 0x1904 #define GL_BLUE_NV 0x1905 #define GL_BLEND_PREMULTIPLIED_SRC_NV 0x9280 #define GL_BLEND_OVERLAP_NV 0x9281 #define GL_UNCORRELATED_NV 0x9282 #define GL_DISJOINT_NV 0x9283 #define GL_CONJOINT_NV 0x9284 #define GL_BLEND_ADVANCED_COHERENT_NV 0x9285 #define GL_SRC_NV 0x9286 #define GL_DST_NV 0x9287 #define GL_SRC_OVER_NV 0x9288 #define GL_DST_OVER_NV 0x9289 #define GL_SRC_IN_NV 0x928A #define GL_DST_IN_NV 0x928B #define GL_SRC_OUT_NV 0x928C #define GL_DST_OUT_NV 0x928D #define GL_SRC_ATOP_NV 0x928E #define GL_DST_ATOP_NV 0x928F #define GL_PLUS_NV 0x9291 #define GL_PLUS_DARKER_NV 0x9292 #define GL_MULTIPLY_NV 0x9294 #define GL_SCREEN_NV 0x9295 #define GL_OVERLAY_NV 0x9296 #define GL_DARKEN_NV 0x9297 #define GL_LIGHTEN_NV 0x9298 #define GL_COLORDODGE_NV 0x9299 #define GL_COLORBURN_NV 0x929A #define GL_HARDLIGHT_NV 0x929B #define GL_SOFTLIGHT_NV 0x929C #define GL_DIFFERENCE_NV 0x929E #define GL_MINUS_NV 0x929F #define GL_EXCLUSION_NV 0x92A0 #define GL_CONTRAST_NV 0x92A1 #define GL_INVERT_RGB_NV 0x92A3 #define GL_LINEARDODGE_NV 0x92A4 #define GL_LINEARBURN_NV 0x92A5 #define GL_VIVIDLIGHT_NV 0x92A6 #define GL_LINEARLIGHT_NV 0x92A7 #define GL_PINLIGHT_NV 0x92A8 #define GL_HARDMIX_NV 0x92A9 #define GL_HSL_HUE_NV 0x92AD #define GL_HSL_SATURATION_NV 0x92AE #define GL_HSL_COLOR_NV 0x92AF #define GL_HSL_LUMINOSITY_NV 0x92B0 #define GL_PLUS_CLAMPED_NV 0x92B1 #define GL_PLUS_CLAMPED_ALPHA_NV 0x92B2 #define GL_MINUS_CLAMPED_NV 0x92B3 #define GL_INVERT_OVG_NV 0x92B4 typedef void (GLAPIENTRY * PFNGLBLENDBARRIERNVPROC) (void); typedef void (GLAPIENTRY * PFNGLBLENDPARAMETERINVPROC) (GLenum pname, GLint value); #define glBlendBarrierNV GLEW_GET_FUN(__glewBlendBarrierNV) #define glBlendParameteriNV GLEW_GET_FUN(__glewBlendParameteriNV) #define GLEW_NV_blend_equation_advanced GLEW_GET_VAR(__GLEW_NV_blend_equation_advanced) #endif /* GL_NV_blend_equation_advanced */ /* ----------------- GL_NV_blend_equation_advanced_coherent ---------------- */ #ifndef GL_NV_blend_equation_advanced_coherent #define GL_NV_blend_equation_advanced_coherent 1 #define GLEW_NV_blend_equation_advanced_coherent GLEW_GET_VAR(__GLEW_NV_blend_equation_advanced_coherent) #endif /* GL_NV_blend_equation_advanced_coherent */ /* --------------------------- GL_NV_blend_square -------------------------- */ #ifndef GL_NV_blend_square #define GL_NV_blend_square 1 #define GLEW_NV_blend_square GLEW_GET_VAR(__GLEW_NV_blend_square) #endif /* GL_NV_blend_square */ /* ------------------------- GL_NV_compute_program5 ------------------------ */ #ifndef GL_NV_compute_program5 #define GL_NV_compute_program5 1 #define GL_COMPUTE_PROGRAM_NV 0x90FB #define GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV 0x90FC #define GLEW_NV_compute_program5 GLEW_GET_VAR(__GLEW_NV_compute_program5) #endif /* GL_NV_compute_program5 */ /* ------------------------ GL_NV_conditional_render ----------------------- */ #ifndef GL_NV_conditional_render #define GL_NV_conditional_render 1 #define GL_QUERY_WAIT_NV 0x8E13 #define GL_QUERY_NO_WAIT_NV 0x8E14 #define GL_QUERY_BY_REGION_WAIT_NV 0x8E15 #define GL_QUERY_BY_REGION_NO_WAIT_NV 0x8E16 typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERNVPROC) (GLuint id, GLenum mode); typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERNVPROC) (void); #define glBeginConditionalRenderNV GLEW_GET_FUN(__glewBeginConditionalRenderNV) #define glEndConditionalRenderNV GLEW_GET_FUN(__glewEndConditionalRenderNV) #define GLEW_NV_conditional_render GLEW_GET_VAR(__GLEW_NV_conditional_render) #endif /* GL_NV_conditional_render */ /* ----------------------- GL_NV_conservative_raster ----------------------- */ #ifndef GL_NV_conservative_raster #define GL_NV_conservative_raster 1 #define GL_CONSERVATIVE_RASTERIZATION_NV 0x9346 #define GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV 0x9347 #define GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV 0x9348 #define GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV 0x9349 typedef void (GLAPIENTRY * PFNGLSUBPIXELPRECISIONBIASNVPROC) (GLuint xbits, GLuint ybits); #define glSubpixelPrecisionBiasNV GLEW_GET_FUN(__glewSubpixelPrecisionBiasNV) #define GLEW_NV_conservative_raster GLEW_GET_VAR(__GLEW_NV_conservative_raster) #endif /* GL_NV_conservative_raster */ /* -------------------- GL_NV_conservative_raster_dilate ------------------- */ #ifndef GL_NV_conservative_raster_dilate #define GL_NV_conservative_raster_dilate 1 #define GL_CONSERVATIVE_RASTER_DILATE_NV 0x9379 #define GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV 0x937A #define GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV 0x937B typedef void (GLAPIENTRY * PFNGLCONSERVATIVERASTERPARAMETERFNVPROC) (GLenum pname, GLfloat value); #define glConservativeRasterParameterfNV GLEW_GET_FUN(__glewConservativeRasterParameterfNV) #define GLEW_NV_conservative_raster_dilate GLEW_GET_VAR(__GLEW_NV_conservative_raster_dilate) #endif /* GL_NV_conservative_raster_dilate */ /* ----------------------- GL_NV_copy_depth_to_color ----------------------- */ #ifndef GL_NV_copy_depth_to_color #define GL_NV_copy_depth_to_color 1 #define GL_DEPTH_STENCIL_TO_RGBA_NV 0x886E #define GL_DEPTH_STENCIL_TO_BGRA_NV 0x886F #define GLEW_NV_copy_depth_to_color GLEW_GET_VAR(__GLEW_NV_copy_depth_to_color) #endif /* GL_NV_copy_depth_to_color */ /* ---------------------------- GL_NV_copy_image --------------------------- */ #ifndef GL_NV_copy_image #define GL_NV_copy_image 1 typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATANVPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); #define glCopyImageSubDataNV GLEW_GET_FUN(__glewCopyImageSubDataNV) #define GLEW_NV_copy_image GLEW_GET_VAR(__GLEW_NV_copy_image) #endif /* GL_NV_copy_image */ /* -------------------------- GL_NV_deep_texture3D ------------------------- */ #ifndef GL_NV_deep_texture3D #define GL_NV_deep_texture3D 1 #define GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV 0x90D0 #define GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV 0x90D1 #define GLEW_NV_deep_texture3D GLEW_GET_VAR(__GLEW_NV_deep_texture3D) #endif /* GL_NV_deep_texture3D */ /* ------------------------ GL_NV_depth_buffer_float ----------------------- */ #ifndef GL_NV_depth_buffer_float #define GL_NV_depth_buffer_float 1 #define GL_DEPTH_COMPONENT32F_NV 0x8DAB #define GL_DEPTH32F_STENCIL8_NV 0x8DAC #define GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV 0x8DAD #define GL_DEPTH_BUFFER_FLOAT_MODE_NV 0x8DAF typedef void (GLAPIENTRY * PFNGLCLEARDEPTHDNVPROC) (GLdouble depth); typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSDNVPROC) (GLdouble zmin, GLdouble zmax); typedef void (GLAPIENTRY * PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFar); #define glClearDepthdNV GLEW_GET_FUN(__glewClearDepthdNV) #define glDepthBoundsdNV GLEW_GET_FUN(__glewDepthBoundsdNV) #define glDepthRangedNV GLEW_GET_FUN(__glewDepthRangedNV) #define GLEW_NV_depth_buffer_float GLEW_GET_VAR(__GLEW_NV_depth_buffer_float) #endif /* GL_NV_depth_buffer_float */ /* --------------------------- GL_NV_depth_clamp --------------------------- */ #ifndef GL_NV_depth_clamp #define GL_NV_depth_clamp 1 #define GL_DEPTH_CLAMP_NV 0x864F #define GLEW_NV_depth_clamp GLEW_GET_VAR(__GLEW_NV_depth_clamp) #endif /* GL_NV_depth_clamp */ /* ---------------------- GL_NV_depth_range_unclamped ---------------------- */ #ifndef GL_NV_depth_range_unclamped #define GL_NV_depth_range_unclamped 1 #define GL_SAMPLE_COUNT_BITS_NV 0x8864 #define GL_CURRENT_SAMPLE_COUNT_QUERY_NV 0x8865 #define GL_QUERY_RESULT_NV 0x8866 #define GL_QUERY_RESULT_AVAILABLE_NV 0x8867 #define GL_SAMPLE_COUNT_NV 0x8914 #define GLEW_NV_depth_range_unclamped GLEW_GET_VAR(__GLEW_NV_depth_range_unclamped) #endif /* GL_NV_depth_range_unclamped */ /* --------------------------- GL_NV_draw_texture -------------------------- */ #ifndef GL_NV_draw_texture #define GL_NV_draw_texture 1 typedef void (GLAPIENTRY * PFNGLDRAWTEXTURENVPROC) (GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1); #define glDrawTextureNV GLEW_GET_FUN(__glewDrawTextureNV) #define GLEW_NV_draw_texture GLEW_GET_VAR(__GLEW_NV_draw_texture) #endif /* GL_NV_draw_texture */ /* ---------------------------- GL_NV_evaluators --------------------------- */ #ifndef GL_NV_evaluators #define GL_NV_evaluators 1 #define GL_EVAL_2D_NV 0x86C0 #define GL_EVAL_TRIANGULAR_2D_NV 0x86C1 #define GL_MAP_TESSELLATION_NV 0x86C2 #define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3 #define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4 #define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5 #define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6 #define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7 #define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8 #define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9 #define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA #define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB #define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC #define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD #define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE #define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF #define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0 #define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1 #define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2 #define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3 #define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4 #define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5 #define GL_MAX_MAP_TESSELLATION_NV 0x86D6 #define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7 typedef void (GLAPIENTRY * PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode); typedef void (GLAPIENTRY * PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void *points); typedef void (GLAPIENTRY * PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void *points); typedef void (GLAPIENTRY * PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint* params); #define glEvalMapsNV GLEW_GET_FUN(__glewEvalMapsNV) #define glGetMapAttribParameterfvNV GLEW_GET_FUN(__glewGetMapAttribParameterfvNV) #define glGetMapAttribParameterivNV GLEW_GET_FUN(__glewGetMapAttribParameterivNV) #define glGetMapControlPointsNV GLEW_GET_FUN(__glewGetMapControlPointsNV) #define glGetMapParameterfvNV GLEW_GET_FUN(__glewGetMapParameterfvNV) #define glGetMapParameterivNV GLEW_GET_FUN(__glewGetMapParameterivNV) #define glMapControlPointsNV GLEW_GET_FUN(__glewMapControlPointsNV) #define glMapParameterfvNV GLEW_GET_FUN(__glewMapParameterfvNV) #define glMapParameterivNV GLEW_GET_FUN(__glewMapParameterivNV) #define GLEW_NV_evaluators GLEW_GET_VAR(__GLEW_NV_evaluators) #endif /* GL_NV_evaluators */ /* ----------------------- GL_NV_explicit_multisample ---------------------- */ #ifndef GL_NV_explicit_multisample #define GL_NV_explicit_multisample 1 #define GL_SAMPLE_POSITION_NV 0x8E50 #define GL_SAMPLE_MASK_NV 0x8E51 #define GL_SAMPLE_MASK_VALUE_NV 0x8E52 #define GL_TEXTURE_BINDING_RENDERBUFFER_NV 0x8E53 #define GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV 0x8E54 #define GL_TEXTURE_RENDERBUFFER_NV 0x8E55 #define GL_SAMPLER_RENDERBUFFER_NV 0x8E56 #define GL_INT_SAMPLER_RENDERBUFFER_NV 0x8E57 #define GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV 0x8E58 #define GL_MAX_SAMPLE_MASK_WORDS_NV 0x8E59 typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVNVPROC) (GLenum pname, GLuint index, GLfloat* val); typedef void (GLAPIENTRY * PFNGLSAMPLEMASKINDEXEDNVPROC) (GLuint index, GLbitfield mask); typedef void (GLAPIENTRY * PFNGLTEXRENDERBUFFERNVPROC) (GLenum target, GLuint renderbuffer); #define glGetMultisamplefvNV GLEW_GET_FUN(__glewGetMultisamplefvNV) #define glSampleMaskIndexedNV GLEW_GET_FUN(__glewSampleMaskIndexedNV) #define glTexRenderbufferNV GLEW_GET_FUN(__glewTexRenderbufferNV) #define GLEW_NV_explicit_multisample GLEW_GET_VAR(__GLEW_NV_explicit_multisample) #endif /* GL_NV_explicit_multisample */ /* ------------------------------ GL_NV_fence ------------------------------ */ #ifndef GL_NV_fence #define GL_NV_fence 1 #define GL_ALL_COMPLETED_NV 0x84F2 #define GL_FENCE_STATUS_NV 0x84F3 #define GL_FENCE_CONDITION_NV 0x84F4 typedef void (GLAPIENTRY * PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint* fences); typedef void (GLAPIENTRY * PFNGLFINISHFENCENVPROC) (GLuint fence); typedef void (GLAPIENTRY * PFNGLGENFENCESNVPROC) (GLsizei n, GLuint* fences); typedef void (GLAPIENTRY * PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISFENCENVPROC) (GLuint fence); typedef void (GLAPIENTRY * PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition); typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCENVPROC) (GLuint fence); #define glDeleteFencesNV GLEW_GET_FUN(__glewDeleteFencesNV) #define glFinishFenceNV GLEW_GET_FUN(__glewFinishFenceNV) #define glGenFencesNV GLEW_GET_FUN(__glewGenFencesNV) #define glGetFenceivNV GLEW_GET_FUN(__glewGetFenceivNV) #define glIsFenceNV GLEW_GET_FUN(__glewIsFenceNV) #define glSetFenceNV GLEW_GET_FUN(__glewSetFenceNV) #define glTestFenceNV GLEW_GET_FUN(__glewTestFenceNV) #define GLEW_NV_fence GLEW_GET_VAR(__GLEW_NV_fence) #endif /* GL_NV_fence */ /* -------------------------- GL_NV_fill_rectangle ------------------------- */ #ifndef GL_NV_fill_rectangle #define GL_NV_fill_rectangle 1 #define GL_FILL_RECTANGLE_NV 0x933C #define GLEW_NV_fill_rectangle GLEW_GET_VAR(__GLEW_NV_fill_rectangle) #endif /* GL_NV_fill_rectangle */ /* --------------------------- GL_NV_float_buffer -------------------------- */ #ifndef GL_NV_float_buffer #define GL_NV_float_buffer 1 #define GL_FLOAT_R_NV 0x8880 #define GL_FLOAT_RG_NV 0x8881 #define GL_FLOAT_RGB_NV 0x8882 #define GL_FLOAT_RGBA_NV 0x8883 #define GL_FLOAT_R16_NV 0x8884 #define GL_FLOAT_R32_NV 0x8885 #define GL_FLOAT_RG16_NV 0x8886 #define GL_FLOAT_RG32_NV 0x8887 #define GL_FLOAT_RGB16_NV 0x8888 #define GL_FLOAT_RGB32_NV 0x8889 #define GL_FLOAT_RGBA16_NV 0x888A #define GL_FLOAT_RGBA32_NV 0x888B #define GL_TEXTURE_FLOAT_COMPONENTS_NV 0x888C #define GL_FLOAT_CLEAR_COLOR_VALUE_NV 0x888D #define GL_FLOAT_RGBA_MODE_NV 0x888E #define GLEW_NV_float_buffer GLEW_GET_VAR(__GLEW_NV_float_buffer) #endif /* GL_NV_float_buffer */ /* --------------------------- GL_NV_fog_distance -------------------------- */ #ifndef GL_NV_fog_distance #define GL_NV_fog_distance 1 #define GL_FOG_DISTANCE_MODE_NV 0x855A #define GL_EYE_RADIAL_NV 0x855B #define GL_EYE_PLANE_ABSOLUTE_NV 0x855C #define GLEW_NV_fog_distance GLEW_GET_VAR(__GLEW_NV_fog_distance) #endif /* GL_NV_fog_distance */ /* -------------------- GL_NV_fragment_coverage_to_color ------------------- */ #ifndef GL_NV_fragment_coverage_to_color #define GL_NV_fragment_coverage_to_color 1 #define GL_FRAGMENT_COVERAGE_TO_COLOR_NV 0x92DD #define GL_FRAGMENT_COVERAGE_COLOR_NV 0x92DE typedef void (GLAPIENTRY * PFNGLFRAGMENTCOVERAGECOLORNVPROC) (GLuint color); #define glFragmentCoverageColorNV GLEW_GET_FUN(__glewFragmentCoverageColorNV) #define GLEW_NV_fragment_coverage_to_color GLEW_GET_VAR(__GLEW_NV_fragment_coverage_to_color) #endif /* GL_NV_fragment_coverage_to_color */ /* ------------------------- GL_NV_fragment_program ------------------------ */ #ifndef GL_NV_fragment_program #define GL_NV_fragment_program 1 #define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 #define GL_FRAGMENT_PROGRAM_NV 0x8870 #define GL_MAX_TEXTURE_COORDS_NV 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 #define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 #define GL_PROGRAM_ERROR_STRING_NV 0x8874 typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLdouble *params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLfloat *params); typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, const GLdouble v[]); typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, const GLfloat v[]); #define glGetProgramNamedParameterdvNV GLEW_GET_FUN(__glewGetProgramNamedParameterdvNV) #define glGetProgramNamedParameterfvNV GLEW_GET_FUN(__glewGetProgramNamedParameterfvNV) #define glProgramNamedParameter4dNV GLEW_GET_FUN(__glewProgramNamedParameter4dNV) #define glProgramNamedParameter4dvNV GLEW_GET_FUN(__glewProgramNamedParameter4dvNV) #define glProgramNamedParameter4fNV GLEW_GET_FUN(__glewProgramNamedParameter4fNV) #define glProgramNamedParameter4fvNV GLEW_GET_FUN(__glewProgramNamedParameter4fvNV) #define GLEW_NV_fragment_program GLEW_GET_VAR(__GLEW_NV_fragment_program) #endif /* GL_NV_fragment_program */ /* ------------------------ GL_NV_fragment_program2 ------------------------ */ #ifndef GL_NV_fragment_program2 #define GL_NV_fragment_program2 1 #define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 #define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 #define GL_MAX_PROGRAM_IF_DEPTH_NV 0x88F6 #define GL_MAX_PROGRAM_LOOP_DEPTH_NV 0x88F7 #define GL_MAX_PROGRAM_LOOP_COUNT_NV 0x88F8 #define GLEW_NV_fragment_program2 GLEW_GET_VAR(__GLEW_NV_fragment_program2) #endif /* GL_NV_fragment_program2 */ /* ------------------------ GL_NV_fragment_program4 ------------------------ */ #ifndef GL_NV_fragment_program4 #define GL_NV_fragment_program4 1 #define GLEW_NV_fragment_program4 GLEW_GET_VAR(__GLEW_NV_fragment_program4) #endif /* GL_NV_fragment_program4 */ /* --------------------- GL_NV_fragment_program_option --------------------- */ #ifndef GL_NV_fragment_program_option #define GL_NV_fragment_program_option 1 #define GLEW_NV_fragment_program_option GLEW_GET_VAR(__GLEW_NV_fragment_program_option) #endif /* GL_NV_fragment_program_option */ /* -------------------- GL_NV_fragment_shader_interlock -------------------- */ #ifndef GL_NV_fragment_shader_interlock #define GL_NV_fragment_shader_interlock 1 #define GLEW_NV_fragment_shader_interlock GLEW_GET_VAR(__GLEW_NV_fragment_shader_interlock) #endif /* GL_NV_fragment_shader_interlock */ /* -------------------- GL_NV_framebuffer_mixed_samples -------------------- */ #ifndef GL_NV_framebuffer_mixed_samples #define GL_NV_framebuffer_mixed_samples 1 #define GL_COLOR_SAMPLES_NV 0x8E20 #define GL_RASTER_MULTISAMPLE_EXT 0x9327 #define GL_RASTER_SAMPLES_EXT 0x9328 #define GL_MAX_RASTER_SAMPLES_EXT 0x9329 #define GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT 0x932A #define GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT 0x932B #define GL_EFFECTIVE_RASTER_SAMPLES_EXT 0x932C #define GL_DEPTH_SAMPLES_NV 0x932D #define GL_STENCIL_SAMPLES_NV 0x932E #define GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV 0x932F #define GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV 0x9330 #define GL_COVERAGE_MODULATION_TABLE_NV 0x9331 #define GL_COVERAGE_MODULATION_NV 0x9332 #define GL_COVERAGE_MODULATION_TABLE_SIZE_NV 0x9333 #define GLEW_NV_framebuffer_mixed_samples GLEW_GET_VAR(__GLEW_NV_framebuffer_mixed_samples) #endif /* GL_NV_framebuffer_mixed_samples */ /* ----------------- GL_NV_framebuffer_multisample_coverage ---------------- */ #ifndef GL_NV_framebuffer_multisample_coverage #define GL_NV_framebuffer_multisample_coverage 1 #define GL_RENDERBUFFER_COVERAGE_SAMPLES_NV 0x8CAB #define GL_RENDERBUFFER_COLOR_SAMPLES_NV 0x8E10 #define GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV 0x8E11 #define GL_MULTISAMPLE_COVERAGE_MODES_NV 0x8E12 typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); #define glRenderbufferStorageMultisampleCoverageNV GLEW_GET_FUN(__glewRenderbufferStorageMultisampleCoverageNV) #define GLEW_NV_framebuffer_multisample_coverage GLEW_GET_VAR(__GLEW_NV_framebuffer_multisample_coverage) #endif /* GL_NV_framebuffer_multisample_coverage */ /* ------------------------ GL_NV_geometry_program4 ------------------------ */ #ifndef GL_NV_geometry_program4 #define GL_NV_geometry_program4 1 #define GL_GEOMETRY_PROGRAM_NV 0x8C26 #define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV 0x8C27 #define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV 0x8C28 typedef void (GLAPIENTRY * PFNGLPROGRAMVERTEXLIMITNVPROC) (GLenum target, GLint limit); #define glProgramVertexLimitNV GLEW_GET_FUN(__glewProgramVertexLimitNV) #define GLEW_NV_geometry_program4 GLEW_GET_VAR(__GLEW_NV_geometry_program4) #endif /* GL_NV_geometry_program4 */ /* ------------------------- GL_NV_geometry_shader4 ------------------------ */ #ifndef GL_NV_geometry_shader4 #define GL_NV_geometry_shader4 1 #define GLEW_NV_geometry_shader4 GLEW_GET_VAR(__GLEW_NV_geometry_shader4) #endif /* GL_NV_geometry_shader4 */ /* ------------------- GL_NV_geometry_shader_passthrough ------------------- */ #ifndef GL_NV_geometry_shader_passthrough #define GL_NV_geometry_shader_passthrough 1 #define GLEW_NV_geometry_shader_passthrough GLEW_GET_VAR(__GLEW_NV_geometry_shader_passthrough) #endif /* GL_NV_geometry_shader_passthrough */ /* --------------------------- GL_NV_gpu_program4 -------------------------- */ #ifndef GL_NV_gpu_program4 #define GL_NV_gpu_program4 1 #define GL_MIN_PROGRAM_TEXEL_OFFSET_NV 0x8904 #define GL_MAX_PROGRAM_TEXEL_OFFSET_NV 0x8905 #define GL_PROGRAM_ATTRIB_COMPONENTS_NV 0x8906 #define GL_PROGRAM_RESULT_COMPONENTS_NV 0x8907 #define GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV 0x8908 #define GL_MAX_PROGRAM_RESULT_COMPONENTS_NV 0x8909 #define GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV 0x8DA5 #define GL_MAX_PROGRAM_GENERIC_RESULTS_NV 0x8DA6 typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params); #define glProgramEnvParameterI4iNV GLEW_GET_FUN(__glewProgramEnvParameterI4iNV) #define glProgramEnvParameterI4ivNV GLEW_GET_FUN(__glewProgramEnvParameterI4ivNV) #define glProgramEnvParameterI4uiNV GLEW_GET_FUN(__glewProgramEnvParameterI4uiNV) #define glProgramEnvParameterI4uivNV GLEW_GET_FUN(__glewProgramEnvParameterI4uivNV) #define glProgramEnvParametersI4ivNV GLEW_GET_FUN(__glewProgramEnvParametersI4ivNV) #define glProgramEnvParametersI4uivNV GLEW_GET_FUN(__glewProgramEnvParametersI4uivNV) #define glProgramLocalParameterI4iNV GLEW_GET_FUN(__glewProgramLocalParameterI4iNV) #define glProgramLocalParameterI4ivNV GLEW_GET_FUN(__glewProgramLocalParameterI4ivNV) #define glProgramLocalParameterI4uiNV GLEW_GET_FUN(__glewProgramLocalParameterI4uiNV) #define glProgramLocalParameterI4uivNV GLEW_GET_FUN(__glewProgramLocalParameterI4uivNV) #define glProgramLocalParametersI4ivNV GLEW_GET_FUN(__glewProgramLocalParametersI4ivNV) #define glProgramLocalParametersI4uivNV GLEW_GET_FUN(__glewProgramLocalParametersI4uivNV) #define GLEW_NV_gpu_program4 GLEW_GET_VAR(__GLEW_NV_gpu_program4) #endif /* GL_NV_gpu_program4 */ /* --------------------------- GL_NV_gpu_program5 -------------------------- */ #ifndef GL_NV_gpu_program5 #define GL_NV_gpu_program5 1 #define GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV 0x8E5A #define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5B #define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV 0x8E5C #define GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV 0x8E5D #define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV 0x8E5E #define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV 0x8E5F #define GLEW_NV_gpu_program5 GLEW_GET_VAR(__GLEW_NV_gpu_program5) #endif /* GL_NV_gpu_program5 */ /* -------------------- GL_NV_gpu_program5_mem_extended -------------------- */ #ifndef GL_NV_gpu_program5_mem_extended #define GL_NV_gpu_program5_mem_extended 1 #define GLEW_NV_gpu_program5_mem_extended GLEW_GET_VAR(__GLEW_NV_gpu_program5_mem_extended) #endif /* GL_NV_gpu_program5_mem_extended */ /* ------------------------- GL_NV_gpu_program_fp64 ------------------------ */ #ifndef GL_NV_gpu_program_fp64 #define GL_NV_gpu_program_fp64 1 #define GLEW_NV_gpu_program_fp64 GLEW_GET_VAR(__GLEW_NV_gpu_program_fp64) #endif /* GL_NV_gpu_program_fp64 */ /* --------------------------- GL_NV_gpu_shader5 --------------------------- */ #ifndef GL_NV_gpu_shader5 #define GL_NV_gpu_shader5 1 #define GL_INT64_NV 0x140E #define GL_UNSIGNED_INT64_NV 0x140F #define GL_INT8_NV 0x8FE0 #define GL_INT8_VEC2_NV 0x8FE1 #define GL_INT8_VEC3_NV 0x8FE2 #define GL_INT8_VEC4_NV 0x8FE3 #define GL_INT16_NV 0x8FE4 #define GL_INT16_VEC2_NV 0x8FE5 #define GL_INT16_VEC3_NV 0x8FE6 #define GL_INT16_VEC4_NV 0x8FE7 #define GL_INT64_VEC2_NV 0x8FE9 #define GL_INT64_VEC3_NV 0x8FEA #define GL_INT64_VEC4_NV 0x8FEB #define GL_UNSIGNED_INT8_NV 0x8FEC #define GL_UNSIGNED_INT8_VEC2_NV 0x8FED #define GL_UNSIGNED_INT8_VEC3_NV 0x8FEE #define GL_UNSIGNED_INT8_VEC4_NV 0x8FEF #define GL_UNSIGNED_INT16_NV 0x8FF0 #define GL_UNSIGNED_INT16_VEC2_NV 0x8FF1 #define GL_UNSIGNED_INT16_VEC3_NV 0x8FF2 #define GL_UNSIGNED_INT16_VEC4_NV 0x8FF3 #define GL_UNSIGNED_INT64_VEC2_NV 0x8FF5 #define GL_UNSIGNED_INT64_VEC3_NV 0x8FF6 #define GL_UNSIGNED_INT64_VEC4_NV 0x8FF7 #define GL_FLOAT16_NV 0x8FF8 #define GL_FLOAT16_VEC2_NV 0x8FF9 #define GL_FLOAT16_VEC3_NV 0x8FFA #define GL_FLOAT16_VEC4_NV 0x8FFB typedef void (GLAPIENTRY * PFNGLGETUNIFORMI64VNVPROC) (GLuint program, GLint location, GLint64EXT* params); typedef void (GLAPIENTRY * PFNGLGETUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLuint64EXT* params); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64NVPROC) (GLuint program, GLint location, GLint64EXT x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64NVPROC) (GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4I64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64NVPROC) (GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM1I64NVPROC) (GLint location, GLint64EXT x); typedef void (GLAPIENTRY * PFNGLUNIFORM1I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64NVPROC) (GLint location, GLuint64EXT x); typedef void (GLAPIENTRY * PFNGLUNIFORM1UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y); typedef void (GLAPIENTRY * PFNGLUNIFORM2I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y); typedef void (GLAPIENTRY * PFNGLUNIFORM2UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z); typedef void (GLAPIENTRY * PFNGLUNIFORM3I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); typedef void (GLAPIENTRY * PFNGLUNIFORM3UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4I64NVPROC) (GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); typedef void (GLAPIENTRY * PFNGLUNIFORM4I64VNVPROC) (GLint location, GLsizei count, const GLint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64NVPROC) (GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); typedef void (GLAPIENTRY * PFNGLUNIFORM4UI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); #define glGetUniformi64vNV GLEW_GET_FUN(__glewGetUniformi64vNV) #define glGetUniformui64vNV GLEW_GET_FUN(__glewGetUniformui64vNV) #define glProgramUniform1i64NV GLEW_GET_FUN(__glewProgramUniform1i64NV) #define glProgramUniform1i64vNV GLEW_GET_FUN(__glewProgramUniform1i64vNV) #define glProgramUniform1ui64NV GLEW_GET_FUN(__glewProgramUniform1ui64NV) #define glProgramUniform1ui64vNV GLEW_GET_FUN(__glewProgramUniform1ui64vNV) #define glProgramUniform2i64NV GLEW_GET_FUN(__glewProgramUniform2i64NV) #define glProgramUniform2i64vNV GLEW_GET_FUN(__glewProgramUniform2i64vNV) #define glProgramUniform2ui64NV GLEW_GET_FUN(__glewProgramUniform2ui64NV) #define glProgramUniform2ui64vNV GLEW_GET_FUN(__glewProgramUniform2ui64vNV) #define glProgramUniform3i64NV GLEW_GET_FUN(__glewProgramUniform3i64NV) #define glProgramUniform3i64vNV GLEW_GET_FUN(__glewProgramUniform3i64vNV) #define glProgramUniform3ui64NV GLEW_GET_FUN(__glewProgramUniform3ui64NV) #define glProgramUniform3ui64vNV GLEW_GET_FUN(__glewProgramUniform3ui64vNV) #define glProgramUniform4i64NV GLEW_GET_FUN(__glewProgramUniform4i64NV) #define glProgramUniform4i64vNV GLEW_GET_FUN(__glewProgramUniform4i64vNV) #define glProgramUniform4ui64NV GLEW_GET_FUN(__glewProgramUniform4ui64NV) #define glProgramUniform4ui64vNV GLEW_GET_FUN(__glewProgramUniform4ui64vNV) #define glUniform1i64NV GLEW_GET_FUN(__glewUniform1i64NV) #define glUniform1i64vNV GLEW_GET_FUN(__glewUniform1i64vNV) #define glUniform1ui64NV GLEW_GET_FUN(__glewUniform1ui64NV) #define glUniform1ui64vNV GLEW_GET_FUN(__glewUniform1ui64vNV) #define glUniform2i64NV GLEW_GET_FUN(__glewUniform2i64NV) #define glUniform2i64vNV GLEW_GET_FUN(__glewUniform2i64vNV) #define glUniform2ui64NV GLEW_GET_FUN(__glewUniform2ui64NV) #define glUniform2ui64vNV GLEW_GET_FUN(__glewUniform2ui64vNV) #define glUniform3i64NV GLEW_GET_FUN(__glewUniform3i64NV) #define glUniform3i64vNV GLEW_GET_FUN(__glewUniform3i64vNV) #define glUniform3ui64NV GLEW_GET_FUN(__glewUniform3ui64NV) #define glUniform3ui64vNV GLEW_GET_FUN(__glewUniform3ui64vNV) #define glUniform4i64NV GLEW_GET_FUN(__glewUniform4i64NV) #define glUniform4i64vNV GLEW_GET_FUN(__glewUniform4i64vNV) #define glUniform4ui64NV GLEW_GET_FUN(__glewUniform4ui64NV) #define glUniform4ui64vNV GLEW_GET_FUN(__glewUniform4ui64vNV) #define GLEW_NV_gpu_shader5 GLEW_GET_VAR(__GLEW_NV_gpu_shader5) #endif /* GL_NV_gpu_shader5 */ /* ---------------------------- GL_NV_half_float --------------------------- */ #ifndef GL_NV_half_float #define GL_NV_half_float 1 #define GL_HALF_FLOAT_NV 0x140B typedef unsigned short GLhalf; typedef void (GLAPIENTRY * PFNGLCOLOR3HNVPROC) (GLhalf red, GLhalf green, GLhalf blue); typedef void (GLAPIENTRY * PFNGLCOLOR3HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLCOLOR4HNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha); typedef void (GLAPIENTRY * PFNGLCOLOR4HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLFOGCOORDHNVPROC) (GLhalf fog); typedef void (GLAPIENTRY * PFNGLFOGCOORDHVNVPROC) (const GLhalf* fog); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalf s); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalf s, GLhalf t); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLNORMAL3HNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz); typedef void (GLAPIENTRY * PFNGLNORMAL3HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HNVPROC) (GLhalf red, GLhalf green, GLhalf blue); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLTEXCOORD1HNVPROC) (GLhalf s); typedef void (GLAPIENTRY * PFNGLTEXCOORD1HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLTEXCOORD2HNVPROC) (GLhalf s, GLhalf t); typedef void (GLAPIENTRY * PFNGLTEXCOORD2HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLTEXCOORD3HNVPROC) (GLhalf s, GLhalf t, GLhalf r); typedef void (GLAPIENTRY * PFNGLTEXCOORD3HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLTEXCOORD4HNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q); typedef void (GLAPIENTRY * PFNGLTEXCOORD4HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEX2HNVPROC) (GLhalf x, GLhalf y); typedef void (GLAPIENTRY * PFNGLVERTEX2HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEX3HNVPROC) (GLhalf x, GLhalf y, GLhalf z); typedef void (GLAPIENTRY * PFNGLVERTEX3HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEX4HNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w); typedef void (GLAPIENTRY * PFNGLVERTEX4HVNVPROC) (const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalf x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalf x, GLhalf y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHNVPROC) (GLhalf weight); typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalf* weight); #define glColor3hNV GLEW_GET_FUN(__glewColor3hNV) #define glColor3hvNV GLEW_GET_FUN(__glewColor3hvNV) #define glColor4hNV GLEW_GET_FUN(__glewColor4hNV) #define glColor4hvNV GLEW_GET_FUN(__glewColor4hvNV) #define glFogCoordhNV GLEW_GET_FUN(__glewFogCoordhNV) #define glFogCoordhvNV GLEW_GET_FUN(__glewFogCoordhvNV) #define glMultiTexCoord1hNV GLEW_GET_FUN(__glewMultiTexCoord1hNV) #define glMultiTexCoord1hvNV GLEW_GET_FUN(__glewMultiTexCoord1hvNV) #define glMultiTexCoord2hNV GLEW_GET_FUN(__glewMultiTexCoord2hNV) #define glMultiTexCoord2hvNV GLEW_GET_FUN(__glewMultiTexCoord2hvNV) #define glMultiTexCoord3hNV GLEW_GET_FUN(__glewMultiTexCoord3hNV) #define glMultiTexCoord3hvNV GLEW_GET_FUN(__glewMultiTexCoord3hvNV) #define glMultiTexCoord4hNV GLEW_GET_FUN(__glewMultiTexCoord4hNV) #define glMultiTexCoord4hvNV GLEW_GET_FUN(__glewMultiTexCoord4hvNV) #define glNormal3hNV GLEW_GET_FUN(__glewNormal3hNV) #define glNormal3hvNV GLEW_GET_FUN(__glewNormal3hvNV) #define glSecondaryColor3hNV GLEW_GET_FUN(__glewSecondaryColor3hNV) #define glSecondaryColor3hvNV GLEW_GET_FUN(__glewSecondaryColor3hvNV) #define glTexCoord1hNV GLEW_GET_FUN(__glewTexCoord1hNV) #define glTexCoord1hvNV GLEW_GET_FUN(__glewTexCoord1hvNV) #define glTexCoord2hNV GLEW_GET_FUN(__glewTexCoord2hNV) #define glTexCoord2hvNV GLEW_GET_FUN(__glewTexCoord2hvNV) #define glTexCoord3hNV GLEW_GET_FUN(__glewTexCoord3hNV) #define glTexCoord3hvNV GLEW_GET_FUN(__glewTexCoord3hvNV) #define glTexCoord4hNV GLEW_GET_FUN(__glewTexCoord4hNV) #define glTexCoord4hvNV GLEW_GET_FUN(__glewTexCoord4hvNV) #define glVertex2hNV GLEW_GET_FUN(__glewVertex2hNV) #define glVertex2hvNV GLEW_GET_FUN(__glewVertex2hvNV) #define glVertex3hNV GLEW_GET_FUN(__glewVertex3hNV) #define glVertex3hvNV GLEW_GET_FUN(__glewVertex3hvNV) #define glVertex4hNV GLEW_GET_FUN(__glewVertex4hNV) #define glVertex4hvNV GLEW_GET_FUN(__glewVertex4hvNV) #define glVertexAttrib1hNV GLEW_GET_FUN(__glewVertexAttrib1hNV) #define glVertexAttrib1hvNV GLEW_GET_FUN(__glewVertexAttrib1hvNV) #define glVertexAttrib2hNV GLEW_GET_FUN(__glewVertexAttrib2hNV) #define glVertexAttrib2hvNV GLEW_GET_FUN(__glewVertexAttrib2hvNV) #define glVertexAttrib3hNV GLEW_GET_FUN(__glewVertexAttrib3hNV) #define glVertexAttrib3hvNV GLEW_GET_FUN(__glewVertexAttrib3hvNV) #define glVertexAttrib4hNV GLEW_GET_FUN(__glewVertexAttrib4hNV) #define glVertexAttrib4hvNV GLEW_GET_FUN(__glewVertexAttrib4hvNV) #define glVertexAttribs1hvNV GLEW_GET_FUN(__glewVertexAttribs1hvNV) #define glVertexAttribs2hvNV GLEW_GET_FUN(__glewVertexAttribs2hvNV) #define glVertexAttribs3hvNV GLEW_GET_FUN(__glewVertexAttribs3hvNV) #define glVertexAttribs4hvNV GLEW_GET_FUN(__glewVertexAttribs4hvNV) #define glVertexWeighthNV GLEW_GET_FUN(__glewVertexWeighthNV) #define glVertexWeighthvNV GLEW_GET_FUN(__glewVertexWeighthvNV) #define GLEW_NV_half_float GLEW_GET_VAR(__GLEW_NV_half_float) #endif /* GL_NV_half_float */ /* ------------------- GL_NV_internalformat_sample_query ------------------- */ #ifndef GL_NV_internalformat_sample_query #define GL_NV_internalformat_sample_query 1 #define GL_MULTISAMPLES_NV 0x9371 #define GL_SUPERSAMPLE_SCALE_X_NV 0x9372 #define GL_SUPERSAMPLE_SCALE_Y_NV 0x9373 #define GL_CONFORMANT_NV 0x9374 typedef void (GLAPIENTRY * PFNGLGETINTERNALFORMATSAMPLEIVNVPROC) (GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint* params); #define glGetInternalformatSampleivNV GLEW_GET_FUN(__glewGetInternalformatSampleivNV) #define GLEW_NV_internalformat_sample_query GLEW_GET_VAR(__GLEW_NV_internalformat_sample_query) #endif /* GL_NV_internalformat_sample_query */ /* ------------------------ GL_NV_light_max_exponent ----------------------- */ #ifndef GL_NV_light_max_exponent #define GL_NV_light_max_exponent 1 #define GL_MAX_SHININESS_NV 0x8504 #define GL_MAX_SPOT_EXPONENT_NV 0x8505 #define GLEW_NV_light_max_exponent GLEW_GET_VAR(__GLEW_NV_light_max_exponent) #endif /* GL_NV_light_max_exponent */ /* ----------------------- GL_NV_multisample_coverage ---------------------- */ #ifndef GL_NV_multisample_coverage #define GL_NV_multisample_coverage 1 #define GL_COLOR_SAMPLES_NV 0x8E20 #define GLEW_NV_multisample_coverage GLEW_GET_VAR(__GLEW_NV_multisample_coverage) #endif /* GL_NV_multisample_coverage */ /* --------------------- GL_NV_multisample_filter_hint --------------------- */ #ifndef GL_NV_multisample_filter_hint #define GL_NV_multisample_filter_hint 1 #define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534 #define GLEW_NV_multisample_filter_hint GLEW_GET_VAR(__GLEW_NV_multisample_filter_hint) #endif /* GL_NV_multisample_filter_hint */ /* ------------------------- GL_NV_occlusion_query ------------------------- */ #ifndef GL_NV_occlusion_query #define GL_NV_occlusion_query 1 #define GL_PIXEL_COUNTER_BITS_NV 0x8864 #define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865 #define GL_PIXEL_COUNT_NV 0x8866 #define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867 typedef void (GLAPIENTRY * PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLENDOCCLUSIONQUERYNVPROC) (void); typedef void (GLAPIENTRY * PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint* params); typedef GLboolean (GLAPIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); #define glBeginOcclusionQueryNV GLEW_GET_FUN(__glewBeginOcclusionQueryNV) #define glDeleteOcclusionQueriesNV GLEW_GET_FUN(__glewDeleteOcclusionQueriesNV) #define glEndOcclusionQueryNV GLEW_GET_FUN(__glewEndOcclusionQueryNV) #define glGenOcclusionQueriesNV GLEW_GET_FUN(__glewGenOcclusionQueriesNV) #define glGetOcclusionQueryivNV GLEW_GET_FUN(__glewGetOcclusionQueryivNV) #define glGetOcclusionQueryuivNV GLEW_GET_FUN(__glewGetOcclusionQueryuivNV) #define glIsOcclusionQueryNV GLEW_GET_FUN(__glewIsOcclusionQueryNV) #define GLEW_NV_occlusion_query GLEW_GET_VAR(__GLEW_NV_occlusion_query) #endif /* GL_NV_occlusion_query */ /* ----------------------- GL_NV_packed_depth_stencil ---------------------- */ #ifndef GL_NV_packed_depth_stencil #define GL_NV_packed_depth_stencil 1 #define GL_DEPTH_STENCIL_NV 0x84F9 #define GL_UNSIGNED_INT_24_8_NV 0x84FA #define GLEW_NV_packed_depth_stencil GLEW_GET_VAR(__GLEW_NV_packed_depth_stencil) #endif /* GL_NV_packed_depth_stencil */ /* --------------------- GL_NV_parameter_buffer_object --------------------- */ #ifndef GL_NV_parameter_buffer_object #define GL_NV_parameter_buffer_object 1 #define GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV 0x8DA0 #define GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV 0x8DA1 #define GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV 0x8DA2 #define GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV 0x8DA3 #define GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV 0x8DA4 typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params); typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params); #define glProgramBufferParametersIivNV GLEW_GET_FUN(__glewProgramBufferParametersIivNV) #define glProgramBufferParametersIuivNV GLEW_GET_FUN(__glewProgramBufferParametersIuivNV) #define glProgramBufferParametersfvNV GLEW_GET_FUN(__glewProgramBufferParametersfvNV) #define GLEW_NV_parameter_buffer_object GLEW_GET_VAR(__GLEW_NV_parameter_buffer_object) #endif /* GL_NV_parameter_buffer_object */ /* --------------------- GL_NV_parameter_buffer_object2 -------------------- */ #ifndef GL_NV_parameter_buffer_object2 #define GL_NV_parameter_buffer_object2 1 #define GLEW_NV_parameter_buffer_object2 GLEW_GET_VAR(__GLEW_NV_parameter_buffer_object2) #endif /* GL_NV_parameter_buffer_object2 */ /* -------------------------- GL_NV_path_rendering ------------------------- */ #ifndef GL_NV_path_rendering #define GL_NV_path_rendering 1 #define GL_CLOSE_PATH_NV 0x00 #define GL_BOLD_BIT_NV 0x01 #define GL_GLYPH_WIDTH_BIT_NV 0x01 #define GL_GLYPH_HEIGHT_BIT_NV 0x02 #define GL_ITALIC_BIT_NV 0x02 #define GL_MOVE_TO_NV 0x02 #define GL_RELATIVE_MOVE_TO_NV 0x03 #define GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV 0x04 #define GL_LINE_TO_NV 0x04 #define GL_RELATIVE_LINE_TO_NV 0x05 #define GL_HORIZONTAL_LINE_TO_NV 0x06 #define GL_RELATIVE_HORIZONTAL_LINE_TO_NV 0x07 #define GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV 0x08 #define GL_VERTICAL_LINE_TO_NV 0x08 #define GL_RELATIVE_VERTICAL_LINE_TO_NV 0x09 #define GL_QUADRATIC_CURVE_TO_NV 0x0A #define GL_RELATIVE_QUADRATIC_CURVE_TO_NV 0x0B #define GL_CUBIC_CURVE_TO_NV 0x0C #define GL_RELATIVE_CUBIC_CURVE_TO_NV 0x0D #define GL_SMOOTH_QUADRATIC_CURVE_TO_NV 0x0E #define GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV 0x0F #define GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV 0x10 #define GL_SMOOTH_CUBIC_CURVE_TO_NV 0x10 #define GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV 0x11 #define GL_SMALL_CCW_ARC_TO_NV 0x12 #define GL_RELATIVE_SMALL_CCW_ARC_TO_NV 0x13 #define GL_SMALL_CW_ARC_TO_NV 0x14 #define GL_RELATIVE_SMALL_CW_ARC_TO_NV 0x15 #define GL_LARGE_CCW_ARC_TO_NV 0x16 #define GL_RELATIVE_LARGE_CCW_ARC_TO_NV 0x17 #define GL_LARGE_CW_ARC_TO_NV 0x18 #define GL_RELATIVE_LARGE_CW_ARC_TO_NV 0x19 #define GL_CONIC_CURVE_TO_NV 0x1A #define GL_RELATIVE_CONIC_CURVE_TO_NV 0x1B #define GL_GLYPH_VERTICAL_BEARING_X_BIT_NV 0x20 #define GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV 0x40 #define GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV 0x80 #define GL_ROUNDED_RECT_NV 0xE8 #define GL_RELATIVE_ROUNDED_RECT_NV 0xE9 #define GL_ROUNDED_RECT2_NV 0xEA #define GL_RELATIVE_ROUNDED_RECT2_NV 0xEB #define GL_ROUNDED_RECT4_NV 0xEC #define GL_RELATIVE_ROUNDED_RECT4_NV 0xED #define GL_ROUNDED_RECT8_NV 0xEE #define GL_RELATIVE_ROUNDED_RECT8_NV 0xEF #define GL_RESTART_PATH_NV 0xF0 #define GL_DUP_FIRST_CUBIC_CURVE_TO_NV 0xF2 #define GL_DUP_LAST_CUBIC_CURVE_TO_NV 0xF4 #define GL_RECT_NV 0xF6 #define GL_RELATIVE_RECT_NV 0xF7 #define GL_CIRCULAR_CCW_ARC_TO_NV 0xF8 #define GL_CIRCULAR_CW_ARC_TO_NV 0xFA #define GL_CIRCULAR_TANGENT_ARC_TO_NV 0xFC #define GL_ARC_TO_NV 0xFE #define GL_RELATIVE_ARC_TO_NV 0xFF #define GL_GLYPH_HAS_KERNING_BIT_NV 0x100 #define GL_PRIMARY_COLOR_NV 0x852C #define GL_SECONDARY_COLOR_NV 0x852D #define GL_PRIMARY_COLOR 0x8577 #define GL_PATH_FORMAT_SVG_NV 0x9070 #define GL_PATH_FORMAT_PS_NV 0x9071 #define GL_STANDARD_FONT_NAME_NV 0x9072 #define GL_SYSTEM_FONT_NAME_NV 0x9073 #define GL_FILE_NAME_NV 0x9074 #define GL_PATH_STROKE_WIDTH_NV 0x9075 #define GL_PATH_END_CAPS_NV 0x9076 #define GL_PATH_INITIAL_END_CAP_NV 0x9077 #define GL_PATH_TERMINAL_END_CAP_NV 0x9078 #define GL_PATH_JOIN_STYLE_NV 0x9079 #define GL_PATH_MITER_LIMIT_NV 0x907A #define GL_PATH_DASH_CAPS_NV 0x907B #define GL_PATH_INITIAL_DASH_CAP_NV 0x907C #define GL_PATH_TERMINAL_DASH_CAP_NV 0x907D #define GL_PATH_DASH_OFFSET_NV 0x907E #define GL_PATH_CLIENT_LENGTH_NV 0x907F #define GL_PATH_FILL_MODE_NV 0x9080 #define GL_PATH_FILL_MASK_NV 0x9081 #define GL_PATH_FILL_COVER_MODE_NV 0x9082 #define GL_PATH_STROKE_COVER_MODE_NV 0x9083 #define GL_PATH_STROKE_MASK_NV 0x9084 #define GL_PATH_STROKE_BOUND_NV 0x9086 #define GL_COUNT_UP_NV 0x9088 #define GL_COUNT_DOWN_NV 0x9089 #define GL_PATH_OBJECT_BOUNDING_BOX_NV 0x908A #define GL_CONVEX_HULL_NV 0x908B #define GL_BOUNDING_BOX_NV 0x908D #define GL_TRANSLATE_X_NV 0x908E #define GL_TRANSLATE_Y_NV 0x908F #define GL_TRANSLATE_2D_NV 0x9090 #define GL_TRANSLATE_3D_NV 0x9091 #define GL_AFFINE_2D_NV 0x9092 #define GL_AFFINE_3D_NV 0x9094 #define GL_TRANSPOSE_AFFINE_2D_NV 0x9096 #define GL_TRANSPOSE_AFFINE_3D_NV 0x9098 #define GL_UTF8_NV 0x909A #define GL_UTF16_NV 0x909B #define GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV 0x909C #define GL_PATH_COMMAND_COUNT_NV 0x909D #define GL_PATH_COORD_COUNT_NV 0x909E #define GL_PATH_DASH_ARRAY_COUNT_NV 0x909F #define GL_PATH_COMPUTED_LENGTH_NV 0x90A0 #define GL_PATH_FILL_BOUNDING_BOX_NV 0x90A1 #define GL_PATH_STROKE_BOUNDING_BOX_NV 0x90A2 #define GL_SQUARE_NV 0x90A3 #define GL_ROUND_NV 0x90A4 #define GL_TRIANGULAR_NV 0x90A5 #define GL_BEVEL_NV 0x90A6 #define GL_MITER_REVERT_NV 0x90A7 #define GL_MITER_TRUNCATE_NV 0x90A8 #define GL_SKIP_MISSING_GLYPH_NV 0x90A9 #define GL_USE_MISSING_GLYPH_NV 0x90AA #define GL_PATH_ERROR_POSITION_NV 0x90AB #define GL_PATH_FOG_GEN_MODE_NV 0x90AC #define GL_ACCUM_ADJACENT_PAIRS_NV 0x90AD #define GL_ADJACENT_PAIRS_NV 0x90AE #define GL_FIRST_TO_REST_NV 0x90AF #define GL_PATH_GEN_MODE_NV 0x90B0 #define GL_PATH_GEN_COEFF_NV 0x90B1 #define GL_PATH_GEN_COLOR_FORMAT_NV 0x90B2 #define GL_PATH_GEN_COMPONENTS_NV 0x90B3 #define GL_PATH_DASH_OFFSET_RESET_NV 0x90B4 #define GL_MOVE_TO_RESETS_NV 0x90B5 #define GL_MOVE_TO_CONTINUES_NV 0x90B6 #define GL_PATH_STENCIL_FUNC_NV 0x90B7 #define GL_PATH_STENCIL_REF_NV 0x90B8 #define GL_PATH_STENCIL_VALUE_MASK_NV 0x90B9 #define GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV 0x90BD #define GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV 0x90BE #define GL_PATH_COVER_DEPTH_FUNC_NV 0x90BF #define GL_FONT_GLYPHS_AVAILABLE_NV 0x9368 #define GL_FONT_TARGET_UNAVAILABLE_NV 0x9369 #define GL_FONT_UNAVAILABLE_NV 0x936A #define GL_FONT_UNINTELLIGIBLE_NV 0x936B #define GL_STANDARD_FONT_FORMAT_NV 0x936C #define GL_FRAGMENT_INPUT_NV 0x936D #define GL_FONT_X_MIN_BOUNDS_BIT_NV 0x00010000 #define GL_FONT_Y_MIN_BOUNDS_BIT_NV 0x00020000 #define GL_FONT_X_MAX_BOUNDS_BIT_NV 0x00040000 #define GL_FONT_Y_MAX_BOUNDS_BIT_NV 0x00080000 #define GL_FONT_UNITS_PER_EM_BIT_NV 0x00100000 #define GL_FONT_ASCENDER_BIT_NV 0x00200000 #define GL_FONT_DESCENDER_BIT_NV 0x00400000 #define GL_FONT_HEIGHT_BIT_NV 0x00800000 #define GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV 0x01000000 #define GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV 0x02000000 #define GL_FONT_UNDERLINE_POSITION_BIT_NV 0x04000000 #define GL_FONT_UNDERLINE_THICKNESS_BIT_NV 0x08000000 #define GL_FONT_HAS_KERNING_BIT_NV 0x10000000 #define GL_FONT_NUM_GLYPH_INDICES_BIT_NV 0x20000000 typedef void (GLAPIENTRY * PFNGLCOPYPATHNVPROC) (GLuint resultPath, GLuint srcPath); typedef void (GLAPIENTRY * PFNGLCOVERFILLPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues); typedef void (GLAPIENTRY * PFNGLCOVERFILLPATHNVPROC) (GLuint path, GLenum coverMode); typedef void (GLAPIENTRY * PFNGLCOVERSTROKEPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues); typedef void (GLAPIENTRY * PFNGLCOVERSTROKEPATHNVPROC) (GLuint path, GLenum coverMode); typedef void (GLAPIENTRY * PFNGLDELETEPATHSNVPROC) (GLuint path, GLsizei range); typedef GLuint (GLAPIENTRY * PFNGLGENPATHSNVPROC) (GLsizei range); typedef void (GLAPIENTRY * PFNGLGETPATHCOLORGENFVNVPROC) (GLenum color, GLenum pname, GLfloat* value); typedef void (GLAPIENTRY * PFNGLGETPATHCOLORGENIVNVPROC) (GLenum color, GLenum pname, GLint* value); typedef void (GLAPIENTRY * PFNGLGETPATHCOMMANDSNVPROC) (GLuint path, GLubyte* commands); typedef void (GLAPIENTRY * PFNGLGETPATHCOORDSNVPROC) (GLuint path, GLfloat* coords); typedef void (GLAPIENTRY * PFNGLGETPATHDASHARRAYNVPROC) (GLuint path, GLfloat* dashArray); typedef GLfloat (GLAPIENTRY * PFNGLGETPATHLENGTHNVPROC) (GLuint path, GLsizei startSegment, GLsizei numSegments); typedef void (GLAPIENTRY * PFNGLGETPATHMETRICRANGENVPROC) (GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics); typedef void (GLAPIENTRY * PFNGLGETPATHMETRICSNVPROC) (GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics); typedef void (GLAPIENTRY * PFNGLGETPATHPARAMETERFVNVPROC) (GLuint path, GLenum pname, GLfloat* value); typedef void (GLAPIENTRY * PFNGLGETPATHPARAMETERIVNVPROC) (GLuint path, GLenum pname, GLint* value); typedef void (GLAPIENTRY * PFNGLGETPATHSPACINGNVPROC) (GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing); typedef void (GLAPIENTRY * PFNGLGETPATHTEXGENFVNVPROC) (GLenum texCoordSet, GLenum pname, GLfloat* value); typedef void (GLAPIENTRY * PFNGLGETPATHTEXGENIVNVPROC) (GLenum texCoordSet, GLenum pname, GLint* value); typedef void (GLAPIENTRY * PFNGLGETPROGRAMRESOURCEFVNVPROC) (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei *length, GLfloat *params); typedef void (GLAPIENTRY * PFNGLINTERPOLATEPATHSNVPROC) (GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight); typedef GLboolean (GLAPIENTRY * PFNGLISPATHNVPROC) (GLuint path); typedef GLboolean (GLAPIENTRY * PFNGLISPOINTINFILLPATHNVPROC) (GLuint path, GLuint mask, GLfloat x, GLfloat y); typedef GLboolean (GLAPIENTRY * PFNGLISPOINTINSTROKEPATHNVPROC) (GLuint path, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLMATRIXLOAD3X2FNVPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXLOAD3X3FNVPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULT3X2FNVPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULT3X3FNVPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC) (GLenum matrixMode, const GLfloat* m); typedef void (GLAPIENTRY * PFNGLPATHCOLORGENNVPROC) (GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs); typedef void (GLAPIENTRY * PFNGLPATHCOMMANDSNVPROC) (GLuint path, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void*coords); typedef void (GLAPIENTRY * PFNGLPATHCOORDSNVPROC) (GLuint path, GLsizei numCoords, GLenum coordType, const void *coords); typedef void (GLAPIENTRY * PFNGLPATHCOVERDEPTHFUNCNVPROC) (GLenum zfunc); typedef void (GLAPIENTRY * PFNGLPATHDASHARRAYNVPROC) (GLuint path, GLsizei dashCount, const GLfloat* dashArray); typedef void (GLAPIENTRY * PFNGLPATHFOGGENNVPROC) (GLenum genMode); typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXARRAYNVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale); typedef GLenum (GLAPIENTRY * PFNGLPATHGLYPHINDEXRANGENVPROC) (GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2]); typedef void (GLAPIENTRY * PFNGLPATHGLYPHRANGENVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); typedef void (GLAPIENTRY * PFNGLPATHGLYPHSNVPROC) (GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void*charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); typedef GLenum (GLAPIENTRY * PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC) (GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale); typedef void (GLAPIENTRY * PFNGLPATHPARAMETERFNVPROC) (GLuint path, GLenum pname, GLfloat value); typedef void (GLAPIENTRY * PFNGLPATHPARAMETERFVNVPROC) (GLuint path, GLenum pname, const GLfloat* value); typedef void (GLAPIENTRY * PFNGLPATHPARAMETERINVPROC) (GLuint path, GLenum pname, GLint value); typedef void (GLAPIENTRY * PFNGLPATHPARAMETERIVNVPROC) (GLuint path, GLenum pname, const GLint* value); typedef void (GLAPIENTRY * PFNGLPATHSTENCILDEPTHOFFSETNVPROC) (GLfloat factor, GLfloat units); typedef void (GLAPIENTRY * PFNGLPATHSTENCILFUNCNVPROC) (GLenum func, GLint ref, GLuint mask); typedef void (GLAPIENTRY * PFNGLPATHSTRINGNVPROC) (GLuint path, GLenum format, GLsizei length, const void *pathString); typedef void (GLAPIENTRY * PFNGLPATHSUBCOMMANDSNVPROC) (GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void*coords); typedef void (GLAPIENTRY * PFNGLPATHSUBCOORDSNVPROC) (GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords); typedef void (GLAPIENTRY * PFNGLPATHTEXGENNVPROC) (GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat* coeffs); typedef GLboolean (GLAPIENTRY * PFNGLPOINTALONGPATHNVPROC) (GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY); typedef void (GLAPIENTRY * PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC) (GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat* coeffs); typedef void (GLAPIENTRY * PFNGLSTENCILFILLPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues); typedef void (GLAPIENTRY * PFNGLSTENCILFILLPATHNVPROC) (GLuint path, GLenum fillMode, GLuint mask); typedef void (GLAPIENTRY * PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues); typedef void (GLAPIENTRY * PFNGLSTENCILSTROKEPATHNVPROC) (GLuint path, GLint reference, GLuint mask); typedef void (GLAPIENTRY * PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues); typedef void (GLAPIENTRY * PFNGLSTENCILTHENCOVERFILLPATHNVPROC) (GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode); typedef void (GLAPIENTRY * PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC) (GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues); typedef void (GLAPIENTRY * PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC) (GLuint path, GLint reference, GLuint mask, GLenum coverMode); typedef void (GLAPIENTRY * PFNGLTRANSFORMPATHNVPROC) (GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat* transformValues); typedef void (GLAPIENTRY * PFNGLWEIGHTPATHSNVPROC) (GLuint resultPath, GLsizei numPaths, const GLuint paths[], const GLfloat weights[]); #define glCopyPathNV GLEW_GET_FUN(__glewCopyPathNV) #define glCoverFillPathInstancedNV GLEW_GET_FUN(__glewCoverFillPathInstancedNV) #define glCoverFillPathNV GLEW_GET_FUN(__glewCoverFillPathNV) #define glCoverStrokePathInstancedNV GLEW_GET_FUN(__glewCoverStrokePathInstancedNV) #define glCoverStrokePathNV GLEW_GET_FUN(__glewCoverStrokePathNV) #define glDeletePathsNV GLEW_GET_FUN(__glewDeletePathsNV) #define glGenPathsNV GLEW_GET_FUN(__glewGenPathsNV) #define glGetPathColorGenfvNV GLEW_GET_FUN(__glewGetPathColorGenfvNV) #define glGetPathColorGenivNV GLEW_GET_FUN(__glewGetPathColorGenivNV) #define glGetPathCommandsNV GLEW_GET_FUN(__glewGetPathCommandsNV) #define glGetPathCoordsNV GLEW_GET_FUN(__glewGetPathCoordsNV) #define glGetPathDashArrayNV GLEW_GET_FUN(__glewGetPathDashArrayNV) #define glGetPathLengthNV GLEW_GET_FUN(__glewGetPathLengthNV) #define glGetPathMetricRangeNV GLEW_GET_FUN(__glewGetPathMetricRangeNV) #define glGetPathMetricsNV GLEW_GET_FUN(__glewGetPathMetricsNV) #define glGetPathParameterfvNV GLEW_GET_FUN(__glewGetPathParameterfvNV) #define glGetPathParameterivNV GLEW_GET_FUN(__glewGetPathParameterivNV) #define glGetPathSpacingNV GLEW_GET_FUN(__glewGetPathSpacingNV) #define glGetPathTexGenfvNV GLEW_GET_FUN(__glewGetPathTexGenfvNV) #define glGetPathTexGenivNV GLEW_GET_FUN(__glewGetPathTexGenivNV) #define glGetProgramResourcefvNV GLEW_GET_FUN(__glewGetProgramResourcefvNV) #define glInterpolatePathsNV GLEW_GET_FUN(__glewInterpolatePathsNV) #define glIsPathNV GLEW_GET_FUN(__glewIsPathNV) #define glIsPointInFillPathNV GLEW_GET_FUN(__glewIsPointInFillPathNV) #define glIsPointInStrokePathNV GLEW_GET_FUN(__glewIsPointInStrokePathNV) #define glMatrixLoad3x2fNV GLEW_GET_FUN(__glewMatrixLoad3x2fNV) #define glMatrixLoad3x3fNV GLEW_GET_FUN(__glewMatrixLoad3x3fNV) #define glMatrixLoadTranspose3x3fNV GLEW_GET_FUN(__glewMatrixLoadTranspose3x3fNV) #define glMatrixMult3x2fNV GLEW_GET_FUN(__glewMatrixMult3x2fNV) #define glMatrixMult3x3fNV GLEW_GET_FUN(__glewMatrixMult3x3fNV) #define glMatrixMultTranspose3x3fNV GLEW_GET_FUN(__glewMatrixMultTranspose3x3fNV) #define glPathColorGenNV GLEW_GET_FUN(__glewPathColorGenNV) #define glPathCommandsNV GLEW_GET_FUN(__glewPathCommandsNV) #define glPathCoordsNV GLEW_GET_FUN(__glewPathCoordsNV) #define glPathCoverDepthFuncNV GLEW_GET_FUN(__glewPathCoverDepthFuncNV) #define glPathDashArrayNV GLEW_GET_FUN(__glewPathDashArrayNV) #define glPathFogGenNV GLEW_GET_FUN(__glewPathFogGenNV) #define glPathGlyphIndexArrayNV GLEW_GET_FUN(__glewPathGlyphIndexArrayNV) #define glPathGlyphIndexRangeNV GLEW_GET_FUN(__glewPathGlyphIndexRangeNV) #define glPathGlyphRangeNV GLEW_GET_FUN(__glewPathGlyphRangeNV) #define glPathGlyphsNV GLEW_GET_FUN(__glewPathGlyphsNV) #define glPathMemoryGlyphIndexArrayNV GLEW_GET_FUN(__glewPathMemoryGlyphIndexArrayNV) #define glPathParameterfNV GLEW_GET_FUN(__glewPathParameterfNV) #define glPathParameterfvNV GLEW_GET_FUN(__glewPathParameterfvNV) #define glPathParameteriNV GLEW_GET_FUN(__glewPathParameteriNV) #define glPathParameterivNV GLEW_GET_FUN(__glewPathParameterivNV) #define glPathStencilDepthOffsetNV GLEW_GET_FUN(__glewPathStencilDepthOffsetNV) #define glPathStencilFuncNV GLEW_GET_FUN(__glewPathStencilFuncNV) #define glPathStringNV GLEW_GET_FUN(__glewPathStringNV) #define glPathSubCommandsNV GLEW_GET_FUN(__glewPathSubCommandsNV) #define glPathSubCoordsNV GLEW_GET_FUN(__glewPathSubCoordsNV) #define glPathTexGenNV GLEW_GET_FUN(__glewPathTexGenNV) #define glPointAlongPathNV GLEW_GET_FUN(__glewPointAlongPathNV) #define glProgramPathFragmentInputGenNV GLEW_GET_FUN(__glewProgramPathFragmentInputGenNV) #define glStencilFillPathInstancedNV GLEW_GET_FUN(__glewStencilFillPathInstancedNV) #define glStencilFillPathNV GLEW_GET_FUN(__glewStencilFillPathNV) #define glStencilStrokePathInstancedNV GLEW_GET_FUN(__glewStencilStrokePathInstancedNV) #define glStencilStrokePathNV GLEW_GET_FUN(__glewStencilStrokePathNV) #define glStencilThenCoverFillPathInstancedNV GLEW_GET_FUN(__glewStencilThenCoverFillPathInstancedNV) #define glStencilThenCoverFillPathNV GLEW_GET_FUN(__glewStencilThenCoverFillPathNV) #define glStencilThenCoverStrokePathInstancedNV GLEW_GET_FUN(__glewStencilThenCoverStrokePathInstancedNV) #define glStencilThenCoverStrokePathNV GLEW_GET_FUN(__glewStencilThenCoverStrokePathNV) #define glTransformPathNV GLEW_GET_FUN(__glewTransformPathNV) #define glWeightPathsNV GLEW_GET_FUN(__glewWeightPathsNV) #define GLEW_NV_path_rendering GLEW_GET_VAR(__GLEW_NV_path_rendering) #endif /* GL_NV_path_rendering */ /* -------------------- GL_NV_path_rendering_shared_edge ------------------- */ #ifndef GL_NV_path_rendering_shared_edge #define GL_NV_path_rendering_shared_edge 1 #define GL_SHARED_EDGE_NV 0xC0 #define GLEW_NV_path_rendering_shared_edge GLEW_GET_VAR(__GLEW_NV_path_rendering_shared_edge) #endif /* GL_NV_path_rendering_shared_edge */ /* ------------------------- GL_NV_pixel_data_range ------------------------ */ #ifndef GL_NV_pixel_data_range #define GL_NV_pixel_data_range 1 #define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878 #define GL_READ_PIXEL_DATA_RANGE_NV 0x8879 #define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A #define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B #define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C #define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D typedef void (GLAPIENTRY * PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, void *pointer); #define glFlushPixelDataRangeNV GLEW_GET_FUN(__glewFlushPixelDataRangeNV) #define glPixelDataRangeNV GLEW_GET_FUN(__glewPixelDataRangeNV) #define GLEW_NV_pixel_data_range GLEW_GET_VAR(__GLEW_NV_pixel_data_range) #endif /* GL_NV_pixel_data_range */ /* --------------------------- GL_NV_point_sprite -------------------------- */ #ifndef GL_NV_point_sprite #define GL_NV_point_sprite 1 #define GL_POINT_SPRITE_NV 0x8861 #define GL_COORD_REPLACE_NV 0x8862 #define GL_POINT_SPRITE_R_MODE_NV 0x8863 typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint* params); #define glPointParameteriNV GLEW_GET_FUN(__glewPointParameteriNV) #define glPointParameterivNV GLEW_GET_FUN(__glewPointParameterivNV) #define GLEW_NV_point_sprite GLEW_GET_VAR(__GLEW_NV_point_sprite) #endif /* GL_NV_point_sprite */ /* -------------------------- GL_NV_present_video -------------------------- */ #ifndef GL_NV_present_video #define GL_NV_present_video 1 #define GL_FRAME_NV 0x8E26 #define GL_FIELDS_NV 0x8E27 #define GL_CURRENT_TIME_NV 0x8E28 #define GL_NUM_FILL_STREAMS_NV 0x8E29 #define GL_PRESENT_TIME_NV 0x8E2A #define GL_PRESENT_DURATION_NV 0x8E2B typedef void (GLAPIENTRY * PFNGLGETVIDEOI64VNVPROC) (GLuint video_slot, GLenum pname, GLint64EXT* params); typedef void (GLAPIENTRY * PFNGLGETVIDEOIVNVPROC) (GLuint video_slot, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVIDEOUI64VNVPROC) (GLuint video_slot, GLenum pname, GLuint64EXT* params); typedef void (GLAPIENTRY * PFNGLGETVIDEOUIVNVPROC) (GLuint video_slot, GLenum pname, GLuint* params); typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEDUALFILLNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3); typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEKEYEDNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1); #define glGetVideoi64vNV GLEW_GET_FUN(__glewGetVideoi64vNV) #define glGetVideoivNV GLEW_GET_FUN(__glewGetVideoivNV) #define glGetVideoui64vNV GLEW_GET_FUN(__glewGetVideoui64vNV) #define glGetVideouivNV GLEW_GET_FUN(__glewGetVideouivNV) #define glPresentFrameDualFillNV GLEW_GET_FUN(__glewPresentFrameDualFillNV) #define glPresentFrameKeyedNV GLEW_GET_FUN(__glewPresentFrameKeyedNV) #define GLEW_NV_present_video GLEW_GET_VAR(__GLEW_NV_present_video) #endif /* GL_NV_present_video */ /* ------------------------ GL_NV_primitive_restart ------------------------ */ #ifndef GL_NV_primitive_restart #define GL_NV_primitive_restart 1 #define GL_PRIMITIVE_RESTART_NV 0x8558 #define GL_PRIMITIVE_RESTART_INDEX_NV 0x8559 typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index); typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void); #define glPrimitiveRestartIndexNV GLEW_GET_FUN(__glewPrimitiveRestartIndexNV) #define glPrimitiveRestartNV GLEW_GET_FUN(__glewPrimitiveRestartNV) #define GLEW_NV_primitive_restart GLEW_GET_VAR(__GLEW_NV_primitive_restart) #endif /* GL_NV_primitive_restart */ /* ------------------------ GL_NV_register_combiners ----------------------- */ #ifndef GL_NV_register_combiners #define GL_NV_register_combiners 1 #define GL_REGISTER_COMBINERS_NV 0x8522 #define GL_VARIABLE_A_NV 0x8523 #define GL_VARIABLE_B_NV 0x8524 #define GL_VARIABLE_C_NV 0x8525 #define GL_VARIABLE_D_NV 0x8526 #define GL_VARIABLE_E_NV 0x8527 #define GL_VARIABLE_F_NV 0x8528 #define GL_VARIABLE_G_NV 0x8529 #define GL_CONSTANT_COLOR0_NV 0x852A #define GL_CONSTANT_COLOR1_NV 0x852B #define GL_PRIMARY_COLOR_NV 0x852C #define GL_SECONDARY_COLOR_NV 0x852D #define GL_SPARE0_NV 0x852E #define GL_SPARE1_NV 0x852F #define GL_DISCARD_NV 0x8530 #define GL_E_TIMES_F_NV 0x8531 #define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532 #define GL_UNSIGNED_IDENTITY_NV 0x8536 #define GL_UNSIGNED_INVERT_NV 0x8537 #define GL_EXPAND_NORMAL_NV 0x8538 #define GL_EXPAND_NEGATE_NV 0x8539 #define GL_HALF_BIAS_NORMAL_NV 0x853A #define GL_HALF_BIAS_NEGATE_NV 0x853B #define GL_SIGNED_IDENTITY_NV 0x853C #define GL_SIGNED_NEGATE_NV 0x853D #define GL_SCALE_BY_TWO_NV 0x853E #define GL_SCALE_BY_FOUR_NV 0x853F #define GL_SCALE_BY_ONE_HALF_NV 0x8540 #define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541 #define GL_COMBINER_INPUT_NV 0x8542 #define GL_COMBINER_MAPPING_NV 0x8543 #define GL_COMBINER_COMPONENT_USAGE_NV 0x8544 #define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545 #define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546 #define GL_COMBINER_MUX_SUM_NV 0x8547 #define GL_COMBINER_SCALE_NV 0x8548 #define GL_COMBINER_BIAS_NV 0x8549 #define GL_COMBINER_AB_OUTPUT_NV 0x854A #define GL_COMBINER_CD_OUTPUT_NV 0x854B #define GL_COMBINER_SUM_OUTPUT_NV 0x854C #define GL_MAX_GENERAL_COMBINERS_NV 0x854D #define GL_NUM_GENERAL_COMBINERS_NV 0x854E #define GL_COLOR_SUM_CLAMP_NV 0x854F #define GL_COMBINER0_NV 0x8550 #define GL_COMBINER1_NV 0x8551 #define GL_COMBINER2_NV 0x8552 #define GL_COMBINER3_NV 0x8553 #define GL_COMBINER4_NV 0x8554 #define GL_COMBINER5_NV 0x8555 #define GL_COMBINER6_NV 0x8556 #define GL_COMBINER7_NV 0x8557 typedef void (GLAPIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); typedef void (GLAPIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint* params); #define glCombinerInputNV GLEW_GET_FUN(__glewCombinerInputNV) #define glCombinerOutputNV GLEW_GET_FUN(__glewCombinerOutputNV) #define glCombinerParameterfNV GLEW_GET_FUN(__glewCombinerParameterfNV) #define glCombinerParameterfvNV GLEW_GET_FUN(__glewCombinerParameterfvNV) #define glCombinerParameteriNV GLEW_GET_FUN(__glewCombinerParameteriNV) #define glCombinerParameterivNV GLEW_GET_FUN(__glewCombinerParameterivNV) #define glFinalCombinerInputNV GLEW_GET_FUN(__glewFinalCombinerInputNV) #define glGetCombinerInputParameterfvNV GLEW_GET_FUN(__glewGetCombinerInputParameterfvNV) #define glGetCombinerInputParameterivNV GLEW_GET_FUN(__glewGetCombinerInputParameterivNV) #define glGetCombinerOutputParameterfvNV GLEW_GET_FUN(__glewGetCombinerOutputParameterfvNV) #define glGetCombinerOutputParameterivNV GLEW_GET_FUN(__glewGetCombinerOutputParameterivNV) #define glGetFinalCombinerInputParameterfvNV GLEW_GET_FUN(__glewGetFinalCombinerInputParameterfvNV) #define glGetFinalCombinerInputParameterivNV GLEW_GET_FUN(__glewGetFinalCombinerInputParameterivNV) #define GLEW_NV_register_combiners GLEW_GET_VAR(__GLEW_NV_register_combiners) #endif /* GL_NV_register_combiners */ /* ----------------------- GL_NV_register_combiners2 ----------------------- */ #ifndef GL_NV_register_combiners2 #define GL_NV_register_combiners2 1 #define GL_PER_STAGE_CONSTANTS_NV 0x8535 typedef void (GLAPIENTRY * PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat* params); #define glCombinerStageParameterfvNV GLEW_GET_FUN(__glewCombinerStageParameterfvNV) #define glGetCombinerStageParameterfvNV GLEW_GET_FUN(__glewGetCombinerStageParameterfvNV) #define GLEW_NV_register_combiners2 GLEW_GET_VAR(__GLEW_NV_register_combiners2) #endif /* GL_NV_register_combiners2 */ /* ------------------------- GL_NV_sample_locations ------------------------ */ #ifndef GL_NV_sample_locations #define GL_NV_sample_locations 1 #define GL_SAMPLE_LOCATION_NV 0x8E50 #define GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV 0x933D #define GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV 0x933E #define GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV 0x933F #define GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV 0x9340 #define GL_PROGRAMMABLE_SAMPLE_LOCATION_NV 0x9341 #define GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV 0x9342 #define GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV 0x9343 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC) (GLenum target, GLuint start, GLsizei count, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC) (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v); #define glFramebufferSampleLocationsfvNV GLEW_GET_FUN(__glewFramebufferSampleLocationsfvNV) #define glNamedFramebufferSampleLocationsfvNV GLEW_GET_FUN(__glewNamedFramebufferSampleLocationsfvNV) #define GLEW_NV_sample_locations GLEW_GET_VAR(__GLEW_NV_sample_locations) #endif /* GL_NV_sample_locations */ /* ------------------ GL_NV_sample_mask_override_coverage ------------------ */ #ifndef GL_NV_sample_mask_override_coverage #define GL_NV_sample_mask_override_coverage 1 #define GLEW_NV_sample_mask_override_coverage GLEW_GET_VAR(__GLEW_NV_sample_mask_override_coverage) #endif /* GL_NV_sample_mask_override_coverage */ /* ---------------------- GL_NV_shader_atomic_counters --------------------- */ #ifndef GL_NV_shader_atomic_counters #define GL_NV_shader_atomic_counters 1 #define GLEW_NV_shader_atomic_counters GLEW_GET_VAR(__GLEW_NV_shader_atomic_counters) #endif /* GL_NV_shader_atomic_counters */ /* ----------------------- GL_NV_shader_atomic_float ----------------------- */ #ifndef GL_NV_shader_atomic_float #define GL_NV_shader_atomic_float 1 #define GLEW_NV_shader_atomic_float GLEW_GET_VAR(__GLEW_NV_shader_atomic_float) #endif /* GL_NV_shader_atomic_float */ /* -------------------- GL_NV_shader_atomic_fp16_vector -------------------- */ #ifndef GL_NV_shader_atomic_fp16_vector #define GL_NV_shader_atomic_fp16_vector 1 #define GLEW_NV_shader_atomic_fp16_vector GLEW_GET_VAR(__GLEW_NV_shader_atomic_fp16_vector) #endif /* GL_NV_shader_atomic_fp16_vector */ /* ----------------------- GL_NV_shader_atomic_int64 ----------------------- */ #ifndef GL_NV_shader_atomic_int64 #define GL_NV_shader_atomic_int64 1 #define GLEW_NV_shader_atomic_int64 GLEW_GET_VAR(__GLEW_NV_shader_atomic_int64) #endif /* GL_NV_shader_atomic_int64 */ /* ------------------------ GL_NV_shader_buffer_load ----------------------- */ #ifndef GL_NV_shader_buffer_load #define GL_NV_shader_buffer_load 1 #define GL_BUFFER_GPU_ADDRESS_NV 0x8F1D #define GL_GPU_ADDRESS_NV 0x8F34 #define GL_MAX_SHADER_BUFFER_ADDRESS_NV 0x8F35 typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERUI64VNVPROC) (GLenum target, GLenum pname, GLuint64EXT* params); typedef void (GLAPIENTRY * PFNGLGETINTEGERUI64VNVPROC) (GLenum value, GLuint64EXT* result); typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC) (GLuint buffer, GLenum pname, GLuint64EXT* params); typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERRESIDENTNVPROC) (GLenum target); typedef GLboolean (GLAPIENTRY * PFNGLISNAMEDBUFFERRESIDENTNVPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLMAKEBUFFERNONRESIDENTNVPROC) (GLenum target); typedef void (GLAPIENTRY * PFNGLMAKEBUFFERRESIDENTNVPROC) (GLenum target, GLenum access); typedef void (GLAPIENTRY * PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC) (GLuint buffer); typedef void (GLAPIENTRY * PFNGLMAKENAMEDBUFFERRESIDENTNVPROC) (GLuint buffer, GLenum access); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMUI64NVPROC) (GLuint program, GLint location, GLuint64EXT value); typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMUI64VNVPROC) (GLuint program, GLint location, GLsizei count, const GLuint64EXT* value); typedef void (GLAPIENTRY * PFNGLUNIFORMUI64NVPROC) (GLint location, GLuint64EXT value); typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei count, const GLuint64EXT* value); #define glGetBufferParameterui64vNV GLEW_GET_FUN(__glewGetBufferParameterui64vNV) #define glGetIntegerui64vNV GLEW_GET_FUN(__glewGetIntegerui64vNV) #define glGetNamedBufferParameterui64vNV GLEW_GET_FUN(__glewGetNamedBufferParameterui64vNV) #define glIsBufferResidentNV GLEW_GET_FUN(__glewIsBufferResidentNV) #define glIsNamedBufferResidentNV GLEW_GET_FUN(__glewIsNamedBufferResidentNV) #define glMakeBufferNonResidentNV GLEW_GET_FUN(__glewMakeBufferNonResidentNV) #define glMakeBufferResidentNV GLEW_GET_FUN(__glewMakeBufferResidentNV) #define glMakeNamedBufferNonResidentNV GLEW_GET_FUN(__glewMakeNamedBufferNonResidentNV) #define glMakeNamedBufferResidentNV GLEW_GET_FUN(__glewMakeNamedBufferResidentNV) #define glProgramUniformui64NV GLEW_GET_FUN(__glewProgramUniformui64NV) #define glProgramUniformui64vNV GLEW_GET_FUN(__glewProgramUniformui64vNV) #define glUniformui64NV GLEW_GET_FUN(__glewUniformui64NV) #define glUniformui64vNV GLEW_GET_FUN(__glewUniformui64vNV) #define GLEW_NV_shader_buffer_load GLEW_GET_VAR(__GLEW_NV_shader_buffer_load) #endif /* GL_NV_shader_buffer_load */ /* ------------------- GL_NV_shader_storage_buffer_object ------------------ */ #ifndef GL_NV_shader_storage_buffer_object #define GL_NV_shader_storage_buffer_object 1 #define GLEW_NV_shader_storage_buffer_object GLEW_GET_VAR(__GLEW_NV_shader_storage_buffer_object) #endif /* GL_NV_shader_storage_buffer_object */ /* ----------------------- GL_NV_shader_thread_group ----------------------- */ #ifndef GL_NV_shader_thread_group #define GL_NV_shader_thread_group 1 #define GL_WARP_SIZE_NV 0x9339 #define GL_WARPS_PER_SM_NV 0x933A #define GL_SM_COUNT_NV 0x933B #define GLEW_NV_shader_thread_group GLEW_GET_VAR(__GLEW_NV_shader_thread_group) #endif /* GL_NV_shader_thread_group */ /* ---------------------- GL_NV_shader_thread_shuffle ---------------------- */ #ifndef GL_NV_shader_thread_shuffle #define GL_NV_shader_thread_shuffle 1 #define GLEW_NV_shader_thread_shuffle GLEW_GET_VAR(__GLEW_NV_shader_thread_shuffle) #endif /* GL_NV_shader_thread_shuffle */ /* ---------------------- GL_NV_tessellation_program5 ---------------------- */ #ifndef GL_NV_tessellation_program5 #define GL_NV_tessellation_program5 1 #define GL_MAX_PROGRAM_PATCH_ATTRIBS_NV 0x86D8 #define GL_TESS_CONTROL_PROGRAM_NV 0x891E #define GL_TESS_EVALUATION_PROGRAM_NV 0x891F #define GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV 0x8C74 #define GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV 0x8C75 #define GLEW_NV_tessellation_program5 GLEW_GET_VAR(__GLEW_NV_tessellation_program5) #endif /* GL_NV_tessellation_program5 */ /* -------------------------- GL_NV_texgen_emboss -------------------------- */ #ifndef GL_NV_texgen_emboss #define GL_NV_texgen_emboss 1 #define GL_EMBOSS_LIGHT_NV 0x855D #define GL_EMBOSS_CONSTANT_NV 0x855E #define GL_EMBOSS_MAP_NV 0x855F #define GLEW_NV_texgen_emboss GLEW_GET_VAR(__GLEW_NV_texgen_emboss) #endif /* GL_NV_texgen_emboss */ /* ------------------------ GL_NV_texgen_reflection ------------------------ */ #ifndef GL_NV_texgen_reflection #define GL_NV_texgen_reflection 1 #define GL_NORMAL_MAP_NV 0x8511 #define GL_REFLECTION_MAP_NV 0x8512 #define GLEW_NV_texgen_reflection GLEW_GET_VAR(__GLEW_NV_texgen_reflection) #endif /* GL_NV_texgen_reflection */ /* ------------------------- GL_NV_texture_barrier ------------------------- */ #ifndef GL_NV_texture_barrier #define GL_NV_texture_barrier 1 typedef void (GLAPIENTRY * PFNGLTEXTUREBARRIERNVPROC) (void); #define glTextureBarrierNV GLEW_GET_FUN(__glewTextureBarrierNV) #define GLEW_NV_texture_barrier GLEW_GET_VAR(__GLEW_NV_texture_barrier) #endif /* GL_NV_texture_barrier */ /* --------------------- GL_NV_texture_compression_vtc --------------------- */ #ifndef GL_NV_texture_compression_vtc #define GL_NV_texture_compression_vtc 1 #define GLEW_NV_texture_compression_vtc GLEW_GET_VAR(__GLEW_NV_texture_compression_vtc) #endif /* GL_NV_texture_compression_vtc */ /* ----------------------- GL_NV_texture_env_combine4 ---------------------- */ #ifndef GL_NV_texture_env_combine4 #define GL_NV_texture_env_combine4 1 #define GL_COMBINE4_NV 0x8503 #define GL_SOURCE3_RGB_NV 0x8583 #define GL_SOURCE3_ALPHA_NV 0x858B #define GL_OPERAND3_RGB_NV 0x8593 #define GL_OPERAND3_ALPHA_NV 0x859B #define GLEW_NV_texture_env_combine4 GLEW_GET_VAR(__GLEW_NV_texture_env_combine4) #endif /* GL_NV_texture_env_combine4 */ /* ---------------------- GL_NV_texture_expand_normal ---------------------- */ #ifndef GL_NV_texture_expand_normal #define GL_NV_texture_expand_normal 1 #define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F #define GLEW_NV_texture_expand_normal GLEW_GET_VAR(__GLEW_NV_texture_expand_normal) #endif /* GL_NV_texture_expand_normal */ /* ----------------------- GL_NV_texture_multisample ----------------------- */ #ifndef GL_NV_texture_multisample #define GL_NV_texture_multisample 1 #define GL_TEXTURE_COVERAGE_SAMPLES_NV 0x9045 #define GL_TEXTURE_COLOR_SAMPLES_NV 0x9046 typedef void (GLAPIENTRY * PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations); typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC) (GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC) (GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC) (GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations); typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) (GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations); #define glTexImage2DMultisampleCoverageNV GLEW_GET_FUN(__glewTexImage2DMultisampleCoverageNV) #define glTexImage3DMultisampleCoverageNV GLEW_GET_FUN(__glewTexImage3DMultisampleCoverageNV) #define glTextureImage2DMultisampleCoverageNV GLEW_GET_FUN(__glewTextureImage2DMultisampleCoverageNV) #define glTextureImage2DMultisampleNV GLEW_GET_FUN(__glewTextureImage2DMultisampleNV) #define glTextureImage3DMultisampleCoverageNV GLEW_GET_FUN(__glewTextureImage3DMultisampleCoverageNV) #define glTextureImage3DMultisampleNV GLEW_GET_FUN(__glewTextureImage3DMultisampleNV) #define GLEW_NV_texture_multisample GLEW_GET_VAR(__GLEW_NV_texture_multisample) #endif /* GL_NV_texture_multisample */ /* ------------------------ GL_NV_texture_rectangle ------------------------ */ #ifndef GL_NV_texture_rectangle #define GL_NV_texture_rectangle 1 #define GL_TEXTURE_RECTANGLE_NV 0x84F5 #define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6 #define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8 #define GLEW_NV_texture_rectangle GLEW_GET_VAR(__GLEW_NV_texture_rectangle) #endif /* GL_NV_texture_rectangle */ /* -------------------------- GL_NV_texture_shader ------------------------- */ #ifndef GL_NV_texture_shader #define GL_NV_texture_shader 1 #define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C #define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D #define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E #define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9 #define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA #define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB #define GL_DSDT_MAG_INTENSITY_NV 0x86DC #define GL_SHADER_CONSISTENT_NV 0x86DD #define GL_TEXTURE_SHADER_NV 0x86DE #define GL_SHADER_OPERATION_NV 0x86DF #define GL_CULL_MODES_NV 0x86E0 #define GL_OFFSET_TEXTURE_2D_MATRIX_NV 0x86E1 #define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1 #define GL_OFFSET_TEXTURE_2D_SCALE_NV 0x86E2 #define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2 #define GL_OFFSET_TEXTURE_2D_BIAS_NV 0x86E3 #define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3 #define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4 #define GL_CONST_EYE_NV 0x86E5 #define GL_PASS_THROUGH_NV 0x86E6 #define GL_CULL_FRAGMENT_NV 0x86E7 #define GL_OFFSET_TEXTURE_2D_NV 0x86E8 #define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9 #define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA #define GL_DOT_PRODUCT_NV 0x86EC #define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED #define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE #define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0 #define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1 #define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2 #define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3 #define GL_HILO_NV 0x86F4 #define GL_DSDT_NV 0x86F5 #define GL_DSDT_MAG_NV 0x86F6 #define GL_DSDT_MAG_VIB_NV 0x86F7 #define GL_HILO16_NV 0x86F8 #define GL_SIGNED_HILO_NV 0x86F9 #define GL_SIGNED_HILO16_NV 0x86FA #define GL_SIGNED_RGBA_NV 0x86FB #define GL_SIGNED_RGBA8_NV 0x86FC #define GL_SIGNED_RGB_NV 0x86FE #define GL_SIGNED_RGB8_NV 0x86FF #define GL_SIGNED_LUMINANCE_NV 0x8701 #define GL_SIGNED_LUMINANCE8_NV 0x8702 #define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 #define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 #define GL_SIGNED_ALPHA_NV 0x8705 #define GL_SIGNED_ALPHA8_NV 0x8706 #define GL_SIGNED_INTENSITY_NV 0x8707 #define GL_SIGNED_INTENSITY8_NV 0x8708 #define GL_DSDT8_NV 0x8709 #define GL_DSDT8_MAG8_NV 0x870A #define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B #define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C #define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D #define GL_HI_SCALE_NV 0x870E #define GL_LO_SCALE_NV 0x870F #define GL_DS_SCALE_NV 0x8710 #define GL_DT_SCALE_NV 0x8711 #define GL_MAGNITUDE_SCALE_NV 0x8712 #define GL_VIBRANCE_SCALE_NV 0x8713 #define GL_HI_BIAS_NV 0x8714 #define GL_LO_BIAS_NV 0x8715 #define GL_DS_BIAS_NV 0x8716 #define GL_DT_BIAS_NV 0x8717 #define GL_MAGNITUDE_BIAS_NV 0x8718 #define GL_VIBRANCE_BIAS_NV 0x8719 #define GL_TEXTURE_BORDER_VALUES_NV 0x871A #define GL_TEXTURE_HI_SIZE_NV 0x871B #define GL_TEXTURE_LO_SIZE_NV 0x871C #define GL_TEXTURE_DS_SIZE_NV 0x871D #define GL_TEXTURE_DT_SIZE_NV 0x871E #define GL_TEXTURE_MAG_SIZE_NV 0x871F #define GLEW_NV_texture_shader GLEW_GET_VAR(__GLEW_NV_texture_shader) #endif /* GL_NV_texture_shader */ /* ------------------------- GL_NV_texture_shader2 ------------------------- */ #ifndef GL_NV_texture_shader2 #define GL_NV_texture_shader2 1 #define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA #define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB #define GL_DSDT_MAG_INTENSITY_NV 0x86DC #define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF #define GL_HILO_NV 0x86F4 #define GL_DSDT_NV 0x86F5 #define GL_DSDT_MAG_NV 0x86F6 #define GL_DSDT_MAG_VIB_NV 0x86F7 #define GL_HILO16_NV 0x86F8 #define GL_SIGNED_HILO_NV 0x86F9 #define GL_SIGNED_HILO16_NV 0x86FA #define GL_SIGNED_RGBA_NV 0x86FB #define GL_SIGNED_RGBA8_NV 0x86FC #define GL_SIGNED_RGB_NV 0x86FE #define GL_SIGNED_RGB8_NV 0x86FF #define GL_SIGNED_LUMINANCE_NV 0x8701 #define GL_SIGNED_LUMINANCE8_NV 0x8702 #define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 #define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 #define GL_SIGNED_ALPHA_NV 0x8705 #define GL_SIGNED_ALPHA8_NV 0x8706 #define GL_SIGNED_INTENSITY_NV 0x8707 #define GL_SIGNED_INTENSITY8_NV 0x8708 #define GL_DSDT8_NV 0x8709 #define GL_DSDT8_MAG8_NV 0x870A #define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B #define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C #define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D #define GLEW_NV_texture_shader2 GLEW_GET_VAR(__GLEW_NV_texture_shader2) #endif /* GL_NV_texture_shader2 */ /* ------------------------- GL_NV_texture_shader3 ------------------------- */ #ifndef GL_NV_texture_shader3 #define GL_NV_texture_shader3 1 #define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850 #define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851 #define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852 #define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853 #define GL_OFFSET_HILO_TEXTURE_2D_NV 0x8854 #define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855 #define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856 #define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857 #define GL_DEPENDENT_HILO_TEXTURE_2D_NV 0x8858 #define GL_DEPENDENT_RGB_TEXTURE_3D_NV 0x8859 #define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A #define GL_DOT_PRODUCT_PASS_THROUGH_NV 0x885B #define GL_DOT_PRODUCT_TEXTURE_1D_NV 0x885C #define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D #define GL_HILO8_NV 0x885E #define GL_SIGNED_HILO8_NV 0x885F #define GL_FORCE_BLUE_TO_ONE_NV 0x8860 #define GLEW_NV_texture_shader3 GLEW_GET_VAR(__GLEW_NV_texture_shader3) #endif /* GL_NV_texture_shader3 */ /* ------------------------ GL_NV_transform_feedback ----------------------- */ #ifndef GL_NV_transform_feedback #define GL_NV_transform_feedback 1 #define GL_BACK_PRIMARY_COLOR_NV 0x8C77 #define GL_BACK_SECONDARY_COLOR_NV 0x8C78 #define GL_TEXTURE_COORD_NV 0x8C79 #define GL_CLIP_DISTANCE_NV 0x8C7A #define GL_VERTEX_ID_NV 0x8C7B #define GL_PRIMITIVE_ID_NV 0x8C7C #define GL_GENERIC_ATTRIB_NV 0x8C7D #define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV 0x8C7E #define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV 0x8C7F #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV 0x8C80 #define GL_ACTIVE_VARYINGS_NV 0x8C81 #define GL_ACTIVE_VARYING_MAX_LENGTH_NV 0x8C82 #define GL_TRANSFORM_FEEDBACK_VARYINGS_NV 0x8C83 #define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV 0x8C84 #define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV 0x8C85 #define GL_TRANSFORM_FEEDBACK_RECORD_NV 0x8C86 #define GL_PRIMITIVES_GENERATED_NV 0x8C87 #define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV 0x8C88 #define GL_RASTERIZER_DISCARD_NV 0x8C89 #define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV 0x8C8A #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV 0x8C8B #define GL_INTERLEAVED_ATTRIBS_NV 0x8C8C #define GL_SEPARATE_ATTRIBS_NV 0x8C8D #define GL_TRANSFORM_FEEDBACK_BUFFER_NV 0x8C8E #define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV 0x8C8F typedef void (GLAPIENTRY * PFNGLACTIVEVARYINGNVPROC) (GLuint program, const GLchar *name); typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKNVPROC) (GLenum primitiveMode); typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASENVPROC) (GLenum target, GLuint index, GLuint buffer); typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGENVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKNVPROC) (void); typedef void (GLAPIENTRY * PFNGLGETACTIVEVARYINGNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) (GLuint program, GLuint index, GLint *location); typedef GLint (GLAPIENTRY * PFNGLGETVARYINGLOCATIONNVPROC) (GLuint program, const GLchar *name); typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) (GLuint count, const GLint *attribs, GLenum bufferMode); typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode); #define glActiveVaryingNV GLEW_GET_FUN(__glewActiveVaryingNV) #define glBeginTransformFeedbackNV GLEW_GET_FUN(__glewBeginTransformFeedbackNV) #define glBindBufferBaseNV GLEW_GET_FUN(__glewBindBufferBaseNV) #define glBindBufferOffsetNV GLEW_GET_FUN(__glewBindBufferOffsetNV) #define glBindBufferRangeNV GLEW_GET_FUN(__glewBindBufferRangeNV) #define glEndTransformFeedbackNV GLEW_GET_FUN(__glewEndTransformFeedbackNV) #define glGetActiveVaryingNV GLEW_GET_FUN(__glewGetActiveVaryingNV) #define glGetTransformFeedbackVaryingNV GLEW_GET_FUN(__glewGetTransformFeedbackVaryingNV) #define glGetVaryingLocationNV GLEW_GET_FUN(__glewGetVaryingLocationNV) #define glTransformFeedbackAttribsNV GLEW_GET_FUN(__glewTransformFeedbackAttribsNV) #define glTransformFeedbackVaryingsNV GLEW_GET_FUN(__glewTransformFeedbackVaryingsNV) #define GLEW_NV_transform_feedback GLEW_GET_VAR(__GLEW_NV_transform_feedback) #endif /* GL_NV_transform_feedback */ /* ----------------------- GL_NV_transform_feedback2 ----------------------- */ #ifndef GL_NV_transform_feedback2 #define GL_NV_transform_feedback2 1 #define GL_TRANSFORM_FEEDBACK_NV 0x8E22 #define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV 0x8E23 #define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV 0x8E24 #define GL_TRANSFORM_FEEDBACK_BINDING_NV 0x8E25 typedef void (GLAPIENTRY * PFNGLBINDTRANSFORMFEEDBACKNVPROC) (GLenum target, GLuint id); typedef void (GLAPIENTRY * PFNGLDELETETRANSFORMFEEDBACKSNVPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKNVPROC) (GLenum mode, GLuint id); typedef void (GLAPIENTRY * PFNGLGENTRANSFORMFEEDBACKSNVPROC) (GLsizei n, GLuint* ids); typedef GLboolean (GLAPIENTRY * PFNGLISTRANSFORMFEEDBACKNVPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLPAUSETRANSFORMFEEDBACKNVPROC) (void); typedef void (GLAPIENTRY * PFNGLRESUMETRANSFORMFEEDBACKNVPROC) (void); #define glBindTransformFeedbackNV GLEW_GET_FUN(__glewBindTransformFeedbackNV) #define glDeleteTransformFeedbacksNV GLEW_GET_FUN(__glewDeleteTransformFeedbacksNV) #define glDrawTransformFeedbackNV GLEW_GET_FUN(__glewDrawTransformFeedbackNV) #define glGenTransformFeedbacksNV GLEW_GET_FUN(__glewGenTransformFeedbacksNV) #define glIsTransformFeedbackNV GLEW_GET_FUN(__glewIsTransformFeedbackNV) #define glPauseTransformFeedbackNV GLEW_GET_FUN(__glewPauseTransformFeedbackNV) #define glResumeTransformFeedbackNV GLEW_GET_FUN(__glewResumeTransformFeedbackNV) #define GLEW_NV_transform_feedback2 GLEW_GET_VAR(__GLEW_NV_transform_feedback2) #endif /* GL_NV_transform_feedback2 */ /* ------------------ GL_NV_uniform_buffer_unified_memory ------------------ */ #ifndef GL_NV_uniform_buffer_unified_memory #define GL_NV_uniform_buffer_unified_memory 1 #define GL_UNIFORM_BUFFER_UNIFIED_NV 0x936E #define GL_UNIFORM_BUFFER_ADDRESS_NV 0x936F #define GL_UNIFORM_BUFFER_LENGTH_NV 0x9370 #define GLEW_NV_uniform_buffer_unified_memory GLEW_GET_VAR(__GLEW_NV_uniform_buffer_unified_memory) #endif /* GL_NV_uniform_buffer_unified_memory */ /* -------------------------- GL_NV_vdpau_interop -------------------------- */ #ifndef GL_NV_vdpau_interop #define GL_NV_vdpau_interop 1 #define GL_SURFACE_STATE_NV 0x86EB #define GL_SURFACE_REGISTERED_NV 0x86FD #define GL_SURFACE_MAPPED_NV 0x8700 #define GL_WRITE_DISCARD_NV 0x88BE typedef GLintptr GLvdpauSurfaceNV; typedef void (GLAPIENTRY * PFNGLVDPAUFININVPROC) (void); typedef void (GLAPIENTRY * PFNGLVDPAUGETSURFACEIVNVPROC) (GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei* length, GLint *values); typedef void (GLAPIENTRY * PFNGLVDPAUINITNVPROC) (const void* vdpDevice, const void*getProcAddress); typedef void (GLAPIENTRY * PFNGLVDPAUISSURFACENVPROC) (GLvdpauSurfaceNV surface); typedef void (GLAPIENTRY * PFNGLVDPAUMAPSURFACESNVPROC) (GLsizei numSurfaces, const GLvdpauSurfaceNV* surfaces); typedef GLvdpauSurfaceNV (GLAPIENTRY * PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC) (const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames); typedef GLvdpauSurfaceNV (GLAPIENTRY * PFNGLVDPAUREGISTERVIDEOSURFACENVPROC) (const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames); typedef void (GLAPIENTRY * PFNGLVDPAUSURFACEACCESSNVPROC) (GLvdpauSurfaceNV surface, GLenum access); typedef void (GLAPIENTRY * PFNGLVDPAUUNMAPSURFACESNVPROC) (GLsizei numSurface, const GLvdpauSurfaceNV* surfaces); typedef void (GLAPIENTRY * PFNGLVDPAUUNREGISTERSURFACENVPROC) (GLvdpauSurfaceNV surface); #define glVDPAUFiniNV GLEW_GET_FUN(__glewVDPAUFiniNV) #define glVDPAUGetSurfaceivNV GLEW_GET_FUN(__glewVDPAUGetSurfaceivNV) #define glVDPAUInitNV GLEW_GET_FUN(__glewVDPAUInitNV) #define glVDPAUIsSurfaceNV GLEW_GET_FUN(__glewVDPAUIsSurfaceNV) #define glVDPAUMapSurfacesNV GLEW_GET_FUN(__glewVDPAUMapSurfacesNV) #define glVDPAURegisterOutputSurfaceNV GLEW_GET_FUN(__glewVDPAURegisterOutputSurfaceNV) #define glVDPAURegisterVideoSurfaceNV GLEW_GET_FUN(__glewVDPAURegisterVideoSurfaceNV) #define glVDPAUSurfaceAccessNV GLEW_GET_FUN(__glewVDPAUSurfaceAccessNV) #define glVDPAUUnmapSurfacesNV GLEW_GET_FUN(__glewVDPAUUnmapSurfacesNV) #define glVDPAUUnregisterSurfaceNV GLEW_GET_FUN(__glewVDPAUUnregisterSurfaceNV) #define GLEW_NV_vdpau_interop GLEW_GET_VAR(__GLEW_NV_vdpau_interop) #endif /* GL_NV_vdpau_interop */ /* ------------------------ GL_NV_vertex_array_range ----------------------- */ #ifndef GL_NV_vertex_array_range #define GL_NV_vertex_array_range 1 #define GL_VERTEX_ARRAY_RANGE_NV 0x851D #define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E #define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F #define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520 #define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521 typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void); typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, void *pointer); #define glFlushVertexArrayRangeNV GLEW_GET_FUN(__glewFlushVertexArrayRangeNV) #define glVertexArrayRangeNV GLEW_GET_FUN(__glewVertexArrayRangeNV) #define GLEW_NV_vertex_array_range GLEW_GET_VAR(__GLEW_NV_vertex_array_range) #endif /* GL_NV_vertex_array_range */ /* ----------------------- GL_NV_vertex_array_range2 ----------------------- */ #ifndef GL_NV_vertex_array_range2 #define GL_NV_vertex_array_range2 1 #define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533 #define GLEW_NV_vertex_array_range2 GLEW_GET_VAR(__GLEW_NV_vertex_array_range2) #endif /* GL_NV_vertex_array_range2 */ /* ------------------- GL_NV_vertex_attrib_integer_64bit ------------------- */ #ifndef GL_NV_vertex_attrib_integer_64bit #define GL_NV_vertex_attrib_integer_64bit 1 #define GL_INT64_NV 0x140E #define GL_UNSIGNED_INT64_NV 0x140F typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLI64VNVPROC) (GLuint index, GLenum pname, GLint64EXT* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBLUI64VNVPROC) (GLuint index, GLenum pname, GLuint64EXT* params); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1I64NVPROC) (GLuint index, GLint64EXT x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1I64VNVPROC) (GLuint index, const GLint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64NVPROC) (GLuint index, GLuint64EXT x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL1UI64VNVPROC) (GLuint index, const GLuint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2I64VNVPROC) (GLuint index, const GLint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL2UI64VNVPROC) (GLuint index, const GLuint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3I64VNVPROC) (GLuint index, const GLint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL3UI64VNVPROC) (GLuint index, const GLuint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4I64NVPROC) (GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4I64VNVPROC) (GLuint index, const GLint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4UI64NVPROC) (GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBL4UI64VNVPROC) (GLuint index, const GLuint64EXT* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBLFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride); #define glGetVertexAttribLi64vNV GLEW_GET_FUN(__glewGetVertexAttribLi64vNV) #define glGetVertexAttribLui64vNV GLEW_GET_FUN(__glewGetVertexAttribLui64vNV) #define glVertexAttribL1i64NV GLEW_GET_FUN(__glewVertexAttribL1i64NV) #define glVertexAttribL1i64vNV GLEW_GET_FUN(__glewVertexAttribL1i64vNV) #define glVertexAttribL1ui64NV GLEW_GET_FUN(__glewVertexAttribL1ui64NV) #define glVertexAttribL1ui64vNV GLEW_GET_FUN(__glewVertexAttribL1ui64vNV) #define glVertexAttribL2i64NV GLEW_GET_FUN(__glewVertexAttribL2i64NV) #define glVertexAttribL2i64vNV GLEW_GET_FUN(__glewVertexAttribL2i64vNV) #define glVertexAttribL2ui64NV GLEW_GET_FUN(__glewVertexAttribL2ui64NV) #define glVertexAttribL2ui64vNV GLEW_GET_FUN(__glewVertexAttribL2ui64vNV) #define glVertexAttribL3i64NV GLEW_GET_FUN(__glewVertexAttribL3i64NV) #define glVertexAttribL3i64vNV GLEW_GET_FUN(__glewVertexAttribL3i64vNV) #define glVertexAttribL3ui64NV GLEW_GET_FUN(__glewVertexAttribL3ui64NV) #define glVertexAttribL3ui64vNV GLEW_GET_FUN(__glewVertexAttribL3ui64vNV) #define glVertexAttribL4i64NV GLEW_GET_FUN(__glewVertexAttribL4i64NV) #define glVertexAttribL4i64vNV GLEW_GET_FUN(__glewVertexAttribL4i64vNV) #define glVertexAttribL4ui64NV GLEW_GET_FUN(__glewVertexAttribL4ui64NV) #define glVertexAttribL4ui64vNV GLEW_GET_FUN(__glewVertexAttribL4ui64vNV) #define glVertexAttribLFormatNV GLEW_GET_FUN(__glewVertexAttribLFormatNV) #define GLEW_NV_vertex_attrib_integer_64bit GLEW_GET_VAR(__GLEW_NV_vertex_attrib_integer_64bit) #endif /* GL_NV_vertex_attrib_integer_64bit */ /* ------------------- GL_NV_vertex_buffer_unified_memory ------------------ */ #ifndef GL_NV_vertex_buffer_unified_memory #define GL_NV_vertex_buffer_unified_memory 1 #define GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV 0x8F1E #define GL_ELEMENT_ARRAY_UNIFIED_NV 0x8F1F #define GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV 0x8F20 #define GL_VERTEX_ARRAY_ADDRESS_NV 0x8F21 #define GL_NORMAL_ARRAY_ADDRESS_NV 0x8F22 #define GL_COLOR_ARRAY_ADDRESS_NV 0x8F23 #define GL_INDEX_ARRAY_ADDRESS_NV 0x8F24 #define GL_TEXTURE_COORD_ARRAY_ADDRESS_NV 0x8F25 #define GL_EDGE_FLAG_ARRAY_ADDRESS_NV 0x8F26 #define GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV 0x8F27 #define GL_FOG_COORD_ARRAY_ADDRESS_NV 0x8F28 #define GL_ELEMENT_ARRAY_ADDRESS_NV 0x8F29 #define GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV 0x8F2A #define GL_VERTEX_ARRAY_LENGTH_NV 0x8F2B #define GL_NORMAL_ARRAY_LENGTH_NV 0x8F2C #define GL_COLOR_ARRAY_LENGTH_NV 0x8F2D #define GL_INDEX_ARRAY_LENGTH_NV 0x8F2E #define GL_TEXTURE_COORD_ARRAY_LENGTH_NV 0x8F2F #define GL_EDGE_FLAG_ARRAY_LENGTH_NV 0x8F30 #define GL_SECONDARY_COLOR_ARRAY_LENGTH_NV 0x8F31 #define GL_FOG_COORD_ARRAY_LENGTH_NV 0x8F32 #define GL_ELEMENT_ARRAY_LENGTH_NV 0x8F33 #define GL_DRAW_INDIRECT_UNIFIED_NV 0x8F40 #define GL_DRAW_INDIRECT_ADDRESS_NV 0x8F41 #define GL_DRAW_INDIRECT_LENGTH_NV 0x8F42 typedef void (GLAPIENTRY * PFNGLBUFFERADDRESSRANGENVPROC) (GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length); typedef void (GLAPIENTRY * PFNGLCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLEDGEFLAGFORMATNVPROC) (GLsizei stride); typedef void (GLAPIENTRY * PFNGLFOGCOORDFORMATNVPROC) (GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT result[]); typedef void (GLAPIENTRY * PFNGLINDEXFORMATNVPROC) (GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLNORMALFORMATNVPROC) (GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLTEXCOORDFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIFORMATNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride); typedef void (GLAPIENTRY * PFNGLVERTEXFORMATNVPROC) (GLint size, GLenum type, GLsizei stride); #define glBufferAddressRangeNV GLEW_GET_FUN(__glewBufferAddressRangeNV) #define glColorFormatNV GLEW_GET_FUN(__glewColorFormatNV) #define glEdgeFlagFormatNV GLEW_GET_FUN(__glewEdgeFlagFormatNV) #define glFogCoordFormatNV GLEW_GET_FUN(__glewFogCoordFormatNV) #define glGetIntegerui64i_vNV GLEW_GET_FUN(__glewGetIntegerui64i_vNV) #define glIndexFormatNV GLEW_GET_FUN(__glewIndexFormatNV) #define glNormalFormatNV GLEW_GET_FUN(__glewNormalFormatNV) #define glSecondaryColorFormatNV GLEW_GET_FUN(__glewSecondaryColorFormatNV) #define glTexCoordFormatNV GLEW_GET_FUN(__glewTexCoordFormatNV) #define glVertexAttribFormatNV GLEW_GET_FUN(__glewVertexAttribFormatNV) #define glVertexAttribIFormatNV GLEW_GET_FUN(__glewVertexAttribIFormatNV) #define glVertexFormatNV GLEW_GET_FUN(__glewVertexFormatNV) #define GLEW_NV_vertex_buffer_unified_memory GLEW_GET_VAR(__GLEW_NV_vertex_buffer_unified_memory) #endif /* GL_NV_vertex_buffer_unified_memory */ /* -------------------------- GL_NV_vertex_program ------------------------- */ #ifndef GL_NV_vertex_program #define GL_NV_vertex_program 1 #define GL_VERTEX_PROGRAM_NV 0x8620 #define GL_VERTEX_STATE_PROGRAM_NV 0x8621 #define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 #define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 #define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 #define GL_CURRENT_ATTRIB_NV 0x8626 #define GL_PROGRAM_LENGTH_NV 0x8627 #define GL_PROGRAM_STRING_NV 0x8628 #define GL_MODELVIEW_PROJECTION_NV 0x8629 #define GL_IDENTITY_NV 0x862A #define GL_INVERSE_NV 0x862B #define GL_TRANSPOSE_NV 0x862C #define GL_INVERSE_TRANSPOSE_NV 0x862D #define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E #define GL_MAX_TRACK_MATRICES_NV 0x862F #define GL_MATRIX0_NV 0x8630 #define GL_MATRIX1_NV 0x8631 #define GL_MATRIX2_NV 0x8632 #define GL_MATRIX3_NV 0x8633 #define GL_MATRIX4_NV 0x8634 #define GL_MATRIX5_NV 0x8635 #define GL_MATRIX6_NV 0x8636 #define GL_MATRIX7_NV 0x8637 #define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 #define GL_CURRENT_MATRIX_NV 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 #define GL_PROGRAM_PARAMETER_NV 0x8644 #define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 #define GL_PROGRAM_TARGET_NV 0x8646 #define GL_PROGRAM_RESIDENT_NV 0x8647 #define GL_TRACK_MATRIX_NV 0x8648 #define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 #define GL_VERTEX_PROGRAM_BINDING_NV 0x864A #define GL_PROGRAM_ERROR_POSITION_NV 0x864B #define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 #define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 #define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 #define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 #define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 #define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 #define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 #define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 #define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 #define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 #define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A #define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B #define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C #define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D #define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E #define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F #define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 #define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 #define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 #define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 #define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 #define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 #define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 #define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 #define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 #define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 #define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A #define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B #define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C #define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D #define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E #define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F #define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 #define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 #define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 #define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 #define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 #define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 #define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 #define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 #define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 #define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 #define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A #define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B #define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C #define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D #define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E #define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F typedef GLboolean (GLAPIENTRY * PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint* ids, GLboolean *residences); typedef void (GLAPIENTRY * PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint* ids); typedef void (GLAPIENTRY * PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte* program); typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, void** pointer); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint* params); typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMNVPROC) (GLuint id); typedef void (GLAPIENTRY * PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte* program); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLsizei num, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLsizei num, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, GLuint* ids); typedef void (GLAPIENTRY * PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei n, const GLubyte* v); #define glAreProgramsResidentNV GLEW_GET_FUN(__glewAreProgramsResidentNV) #define glBindProgramNV GLEW_GET_FUN(__glewBindProgramNV) #define glDeleteProgramsNV GLEW_GET_FUN(__glewDeleteProgramsNV) #define glExecuteProgramNV GLEW_GET_FUN(__glewExecuteProgramNV) #define glGenProgramsNV GLEW_GET_FUN(__glewGenProgramsNV) #define glGetProgramParameterdvNV GLEW_GET_FUN(__glewGetProgramParameterdvNV) #define glGetProgramParameterfvNV GLEW_GET_FUN(__glewGetProgramParameterfvNV) #define glGetProgramStringNV GLEW_GET_FUN(__glewGetProgramStringNV) #define glGetProgramivNV GLEW_GET_FUN(__glewGetProgramivNV) #define glGetTrackMatrixivNV GLEW_GET_FUN(__glewGetTrackMatrixivNV) #define glGetVertexAttribPointervNV GLEW_GET_FUN(__glewGetVertexAttribPointervNV) #define glGetVertexAttribdvNV GLEW_GET_FUN(__glewGetVertexAttribdvNV) #define glGetVertexAttribfvNV GLEW_GET_FUN(__glewGetVertexAttribfvNV) #define glGetVertexAttribivNV GLEW_GET_FUN(__glewGetVertexAttribivNV) #define glIsProgramNV GLEW_GET_FUN(__glewIsProgramNV) #define glLoadProgramNV GLEW_GET_FUN(__glewLoadProgramNV) #define glProgramParameter4dNV GLEW_GET_FUN(__glewProgramParameter4dNV) #define glProgramParameter4dvNV GLEW_GET_FUN(__glewProgramParameter4dvNV) #define glProgramParameter4fNV GLEW_GET_FUN(__glewProgramParameter4fNV) #define glProgramParameter4fvNV GLEW_GET_FUN(__glewProgramParameter4fvNV) #define glProgramParameters4dvNV GLEW_GET_FUN(__glewProgramParameters4dvNV) #define glProgramParameters4fvNV GLEW_GET_FUN(__glewProgramParameters4fvNV) #define glRequestResidentProgramsNV GLEW_GET_FUN(__glewRequestResidentProgramsNV) #define glTrackMatrixNV GLEW_GET_FUN(__glewTrackMatrixNV) #define glVertexAttrib1dNV GLEW_GET_FUN(__glewVertexAttrib1dNV) #define glVertexAttrib1dvNV GLEW_GET_FUN(__glewVertexAttrib1dvNV) #define glVertexAttrib1fNV GLEW_GET_FUN(__glewVertexAttrib1fNV) #define glVertexAttrib1fvNV GLEW_GET_FUN(__glewVertexAttrib1fvNV) #define glVertexAttrib1sNV GLEW_GET_FUN(__glewVertexAttrib1sNV) #define glVertexAttrib1svNV GLEW_GET_FUN(__glewVertexAttrib1svNV) #define glVertexAttrib2dNV GLEW_GET_FUN(__glewVertexAttrib2dNV) #define glVertexAttrib2dvNV GLEW_GET_FUN(__glewVertexAttrib2dvNV) #define glVertexAttrib2fNV GLEW_GET_FUN(__glewVertexAttrib2fNV) #define glVertexAttrib2fvNV GLEW_GET_FUN(__glewVertexAttrib2fvNV) #define glVertexAttrib2sNV GLEW_GET_FUN(__glewVertexAttrib2sNV) #define glVertexAttrib2svNV GLEW_GET_FUN(__glewVertexAttrib2svNV) #define glVertexAttrib3dNV GLEW_GET_FUN(__glewVertexAttrib3dNV) #define glVertexAttrib3dvNV GLEW_GET_FUN(__glewVertexAttrib3dvNV) #define glVertexAttrib3fNV GLEW_GET_FUN(__glewVertexAttrib3fNV) #define glVertexAttrib3fvNV GLEW_GET_FUN(__glewVertexAttrib3fvNV) #define glVertexAttrib3sNV GLEW_GET_FUN(__glewVertexAttrib3sNV) #define glVertexAttrib3svNV GLEW_GET_FUN(__glewVertexAttrib3svNV) #define glVertexAttrib4dNV GLEW_GET_FUN(__glewVertexAttrib4dNV) #define glVertexAttrib4dvNV GLEW_GET_FUN(__glewVertexAttrib4dvNV) #define glVertexAttrib4fNV GLEW_GET_FUN(__glewVertexAttrib4fNV) #define glVertexAttrib4fvNV GLEW_GET_FUN(__glewVertexAttrib4fvNV) #define glVertexAttrib4sNV GLEW_GET_FUN(__glewVertexAttrib4sNV) #define glVertexAttrib4svNV GLEW_GET_FUN(__glewVertexAttrib4svNV) #define glVertexAttrib4ubNV GLEW_GET_FUN(__glewVertexAttrib4ubNV) #define glVertexAttrib4ubvNV GLEW_GET_FUN(__glewVertexAttrib4ubvNV) #define glVertexAttribPointerNV GLEW_GET_FUN(__glewVertexAttribPointerNV) #define glVertexAttribs1dvNV GLEW_GET_FUN(__glewVertexAttribs1dvNV) #define glVertexAttribs1fvNV GLEW_GET_FUN(__glewVertexAttribs1fvNV) #define glVertexAttribs1svNV GLEW_GET_FUN(__glewVertexAttribs1svNV) #define glVertexAttribs2dvNV GLEW_GET_FUN(__glewVertexAttribs2dvNV) #define glVertexAttribs2fvNV GLEW_GET_FUN(__glewVertexAttribs2fvNV) #define glVertexAttribs2svNV GLEW_GET_FUN(__glewVertexAttribs2svNV) #define glVertexAttribs3dvNV GLEW_GET_FUN(__glewVertexAttribs3dvNV) #define glVertexAttribs3fvNV GLEW_GET_FUN(__glewVertexAttribs3fvNV) #define glVertexAttribs3svNV GLEW_GET_FUN(__glewVertexAttribs3svNV) #define glVertexAttribs4dvNV GLEW_GET_FUN(__glewVertexAttribs4dvNV) #define glVertexAttribs4fvNV GLEW_GET_FUN(__glewVertexAttribs4fvNV) #define glVertexAttribs4svNV GLEW_GET_FUN(__glewVertexAttribs4svNV) #define glVertexAttribs4ubvNV GLEW_GET_FUN(__glewVertexAttribs4ubvNV) #define GLEW_NV_vertex_program GLEW_GET_VAR(__GLEW_NV_vertex_program) #endif /* GL_NV_vertex_program */ /* ------------------------ GL_NV_vertex_program1_1 ------------------------ */ #ifndef GL_NV_vertex_program1_1 #define GL_NV_vertex_program1_1 1 #define GLEW_NV_vertex_program1_1 GLEW_GET_VAR(__GLEW_NV_vertex_program1_1) #endif /* GL_NV_vertex_program1_1 */ /* ------------------------- GL_NV_vertex_program2 ------------------------- */ #ifndef GL_NV_vertex_program2 #define GL_NV_vertex_program2 1 #define GLEW_NV_vertex_program2 GLEW_GET_VAR(__GLEW_NV_vertex_program2) #endif /* GL_NV_vertex_program2 */ /* ---------------------- GL_NV_vertex_program2_option --------------------- */ #ifndef GL_NV_vertex_program2_option #define GL_NV_vertex_program2_option 1 #define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 #define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 #define GLEW_NV_vertex_program2_option GLEW_GET_VAR(__GLEW_NV_vertex_program2_option) #endif /* GL_NV_vertex_program2_option */ /* ------------------------- GL_NV_vertex_program3 ------------------------- */ #ifndef GL_NV_vertex_program3 #define GL_NV_vertex_program3 1 #define MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C #define GLEW_NV_vertex_program3 GLEW_GET_VAR(__GLEW_NV_vertex_program3) #endif /* GL_NV_vertex_program3 */ /* ------------------------- GL_NV_vertex_program4 ------------------------- */ #ifndef GL_NV_vertex_program4 #define GL_NV_vertex_program4 1 #define GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV 0x88FD #define GLEW_NV_vertex_program4 GLEW_GET_VAR(__GLEW_NV_vertex_program4) #endif /* GL_NV_vertex_program4 */ /* -------------------------- GL_NV_video_capture -------------------------- */ #ifndef GL_NV_video_capture #define GL_NV_video_capture 1 #define GL_VIDEO_BUFFER_NV 0x9020 #define GL_VIDEO_BUFFER_BINDING_NV 0x9021 #define GL_FIELD_UPPER_NV 0x9022 #define GL_FIELD_LOWER_NV 0x9023 #define GL_NUM_VIDEO_CAPTURE_STREAMS_NV 0x9024 #define GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV 0x9025 #define GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV 0x9026 #define GL_LAST_VIDEO_CAPTURE_STATUS_NV 0x9027 #define GL_VIDEO_BUFFER_PITCH_NV 0x9028 #define GL_VIDEO_COLOR_CONVERSION_MATRIX_NV 0x9029 #define GL_VIDEO_COLOR_CONVERSION_MAX_NV 0x902A #define GL_VIDEO_COLOR_CONVERSION_MIN_NV 0x902B #define GL_VIDEO_COLOR_CONVERSION_OFFSET_NV 0x902C #define GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV 0x902D #define GL_PARTIAL_SUCCESS_NV 0x902E #define GL_SUCCESS_NV 0x902F #define GL_FAILURE_NV 0x9030 #define GL_YCBYCR8_422_NV 0x9031 #define GL_YCBAYCR8A_4224_NV 0x9032 #define GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV 0x9033 #define GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV 0x9034 #define GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV 0x9035 #define GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV 0x9036 #define GL_Z4Y12Z4CB12Z4CR12_444_NV 0x9037 #define GL_VIDEO_CAPTURE_FRAME_WIDTH_NV 0x9038 #define GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV 0x9039 #define GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV 0x903A #define GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV 0x903B #define GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV 0x903C typedef void (GLAPIENTRY * PFNGLBEGINVIDEOCAPTURENVPROC) (GLuint video_capture_slot); typedef void (GLAPIENTRY * PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset); typedef void (GLAPIENTRY * PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC) (GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture); typedef void (GLAPIENTRY * PFNGLENDVIDEOCAPTURENVPROC) (GLuint video_capture_slot); typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTURESTREAMDVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params); typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTURESTREAMFVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTURESTREAMIVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETVIDEOCAPTUREIVNVPROC) (GLuint video_capture_slot, GLenum pname, GLint* params); typedef GLenum (GLAPIENTRY * PFNGLVIDEOCAPTURENVPROC) (GLuint video_capture_slot, GLuint* sequence_num, GLuint64EXT *capture_time); typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params); typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC) (GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint* params); #define glBeginVideoCaptureNV GLEW_GET_FUN(__glewBeginVideoCaptureNV) #define glBindVideoCaptureStreamBufferNV GLEW_GET_FUN(__glewBindVideoCaptureStreamBufferNV) #define glBindVideoCaptureStreamTextureNV GLEW_GET_FUN(__glewBindVideoCaptureStreamTextureNV) #define glEndVideoCaptureNV GLEW_GET_FUN(__glewEndVideoCaptureNV) #define glGetVideoCaptureStreamdvNV GLEW_GET_FUN(__glewGetVideoCaptureStreamdvNV) #define glGetVideoCaptureStreamfvNV GLEW_GET_FUN(__glewGetVideoCaptureStreamfvNV) #define glGetVideoCaptureStreamivNV GLEW_GET_FUN(__glewGetVideoCaptureStreamivNV) #define glGetVideoCaptureivNV GLEW_GET_FUN(__glewGetVideoCaptureivNV) #define glVideoCaptureNV GLEW_GET_FUN(__glewVideoCaptureNV) #define glVideoCaptureStreamParameterdvNV GLEW_GET_FUN(__glewVideoCaptureStreamParameterdvNV) #define glVideoCaptureStreamParameterfvNV GLEW_GET_FUN(__glewVideoCaptureStreamParameterfvNV) #define glVideoCaptureStreamParameterivNV GLEW_GET_FUN(__glewVideoCaptureStreamParameterivNV) #define GLEW_NV_video_capture GLEW_GET_VAR(__GLEW_NV_video_capture) #endif /* GL_NV_video_capture */ /* ------------------------- GL_NV_viewport_array2 ------------------------- */ #ifndef GL_NV_viewport_array2 #define GL_NV_viewport_array2 1 #define GLEW_NV_viewport_array2 GLEW_GET_VAR(__GLEW_NV_viewport_array2) #endif /* GL_NV_viewport_array2 */ /* ------------------------ GL_OES_byte_coordinates ------------------------ */ #ifndef GL_OES_byte_coordinates #define GL_OES_byte_coordinates 1 #define GLEW_OES_byte_coordinates GLEW_GET_VAR(__GLEW_OES_byte_coordinates) #endif /* GL_OES_byte_coordinates */ /* ------------------- GL_OES_compressed_paletted_texture ------------------ */ #ifndef GL_OES_compressed_paletted_texture #define GL_OES_compressed_paletted_texture 1 #define GL_PALETTE4_RGB8_OES 0x8B90 #define GL_PALETTE4_RGBA8_OES 0x8B91 #define GL_PALETTE4_R5_G6_B5_OES 0x8B92 #define GL_PALETTE4_RGBA4_OES 0x8B93 #define GL_PALETTE4_RGB5_A1_OES 0x8B94 #define GL_PALETTE8_RGB8_OES 0x8B95 #define GL_PALETTE8_RGBA8_OES 0x8B96 #define GL_PALETTE8_R5_G6_B5_OES 0x8B97 #define GL_PALETTE8_RGBA4_OES 0x8B98 #define GL_PALETTE8_RGB5_A1_OES 0x8B99 #define GLEW_OES_compressed_paletted_texture GLEW_GET_VAR(__GLEW_OES_compressed_paletted_texture) #endif /* GL_OES_compressed_paletted_texture */ /* --------------------------- GL_OES_read_format -------------------------- */ #ifndef GL_OES_read_format #define GL_OES_read_format 1 #define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A #define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B #define GLEW_OES_read_format GLEW_GET_VAR(__GLEW_OES_read_format) #endif /* GL_OES_read_format */ /* ------------------------ GL_OES_single_precision ------------------------ */ #ifndef GL_OES_single_precision #define GL_OES_single_precision 1 typedef void (GLAPIENTRY * PFNGLCLEARDEPTHFOESPROC) (GLclampf depth); typedef void (GLAPIENTRY * PFNGLCLIPPLANEFOESPROC) (GLenum plane, const GLfloat* equation); typedef void (GLAPIENTRY * PFNGLDEPTHRANGEFOESPROC) (GLclampf n, GLclampf f); typedef void (GLAPIENTRY * PFNGLFRUSTUMFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); typedef void (GLAPIENTRY * PFNGLGETCLIPPLANEFOESPROC) (GLenum plane, GLfloat* equation); typedef void (GLAPIENTRY * PFNGLORTHOFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); #define glClearDepthfOES GLEW_GET_FUN(__glewClearDepthfOES) #define glClipPlanefOES GLEW_GET_FUN(__glewClipPlanefOES) #define glDepthRangefOES GLEW_GET_FUN(__glewDepthRangefOES) #define glFrustumfOES GLEW_GET_FUN(__glewFrustumfOES) #define glGetClipPlanefOES GLEW_GET_FUN(__glewGetClipPlanefOES) #define glOrthofOES GLEW_GET_FUN(__glewOrthofOES) #define GLEW_OES_single_precision GLEW_GET_VAR(__GLEW_OES_single_precision) #endif /* GL_OES_single_precision */ /* ---------------------------- GL_OML_interlace --------------------------- */ #ifndef GL_OML_interlace #define GL_OML_interlace 1 #define GL_INTERLACE_OML 0x8980 #define GL_INTERLACE_READ_OML 0x8981 #define GLEW_OML_interlace GLEW_GET_VAR(__GLEW_OML_interlace) #endif /* GL_OML_interlace */ /* ---------------------------- GL_OML_resample ---------------------------- */ #ifndef GL_OML_resample #define GL_OML_resample 1 #define GL_PACK_RESAMPLE_OML 0x8984 #define GL_UNPACK_RESAMPLE_OML 0x8985 #define GL_RESAMPLE_REPLICATE_OML 0x8986 #define GL_RESAMPLE_ZERO_FILL_OML 0x8987 #define GL_RESAMPLE_AVERAGE_OML 0x8988 #define GL_RESAMPLE_DECIMATE_OML 0x8989 #define GLEW_OML_resample GLEW_GET_VAR(__GLEW_OML_resample) #endif /* GL_OML_resample */ /* ---------------------------- GL_OML_subsample --------------------------- */ #ifndef GL_OML_subsample #define GL_OML_subsample 1 #define GL_FORMAT_SUBSAMPLE_24_24_OML 0x8982 #define GL_FORMAT_SUBSAMPLE_244_244_OML 0x8983 #define GLEW_OML_subsample GLEW_GET_VAR(__GLEW_OML_subsample) #endif /* GL_OML_subsample */ /* ---------------------------- GL_OVR_multiview --------------------------- */ #ifndef GL_OVR_multiview #define GL_OVR_multiview 1 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR 0x9630 #define GL_MAX_VIEWS_OVR 0x9631 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR 0x9632 #define GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR 0x9633 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #define glFramebufferTextureMultiviewOVR GLEW_GET_FUN(__glewFramebufferTextureMultiviewOVR) #define GLEW_OVR_multiview GLEW_GET_VAR(__GLEW_OVR_multiview) #endif /* GL_OVR_multiview */ /* --------------------------- GL_OVR_multiview2 --------------------------- */ #ifndef GL_OVR_multiview2 #define GL_OVR_multiview2 1 #define GLEW_OVR_multiview2 GLEW_GET_VAR(__GLEW_OVR_multiview2) #endif /* GL_OVR_multiview2 */ /* --------------------------- GL_PGI_misc_hints --------------------------- */ #ifndef GL_PGI_misc_hints #define GL_PGI_misc_hints 1 #define GL_PREFER_DOUBLEBUFFER_HINT_PGI 107000 #define GL_CONSERVE_MEMORY_HINT_PGI 107005 #define GL_RECLAIM_MEMORY_HINT_PGI 107006 #define GL_NATIVE_GRAPHICS_HANDLE_PGI 107010 #define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 107011 #define GL_NATIVE_GRAPHICS_END_HINT_PGI 107012 #define GL_ALWAYS_FAST_HINT_PGI 107020 #define GL_ALWAYS_SOFT_HINT_PGI 107021 #define GL_ALLOW_DRAW_OBJ_HINT_PGI 107022 #define GL_ALLOW_DRAW_WIN_HINT_PGI 107023 #define GL_ALLOW_DRAW_FRG_HINT_PGI 107024 #define GL_ALLOW_DRAW_MEM_HINT_PGI 107025 #define GL_STRICT_DEPTHFUNC_HINT_PGI 107030 #define GL_STRICT_LIGHTING_HINT_PGI 107031 #define GL_STRICT_SCISSOR_HINT_PGI 107032 #define GL_FULL_STIPPLE_HINT_PGI 107033 #define GL_CLIP_NEAR_HINT_PGI 107040 #define GL_CLIP_FAR_HINT_PGI 107041 #define GL_WIDE_LINE_HINT_PGI 107042 #define GL_BACK_NORMALS_HINT_PGI 107043 #define GLEW_PGI_misc_hints GLEW_GET_VAR(__GLEW_PGI_misc_hints) #endif /* GL_PGI_misc_hints */ /* -------------------------- GL_PGI_vertex_hints -------------------------- */ #ifndef GL_PGI_vertex_hints #define GL_PGI_vertex_hints 1 #define GL_VERTEX23_BIT_PGI 0x00000004 #define GL_VERTEX4_BIT_PGI 0x00000008 #define GL_COLOR3_BIT_PGI 0x00010000 #define GL_COLOR4_BIT_PGI 0x00020000 #define GL_EDGEFLAG_BIT_PGI 0x00040000 #define GL_INDEX_BIT_PGI 0x00080000 #define GL_MAT_AMBIENT_BIT_PGI 0x00100000 #define GL_VERTEX_DATA_HINT_PGI 107050 #define GL_VERTEX_CONSISTENT_HINT_PGI 107051 #define GL_MATERIAL_SIDE_HINT_PGI 107052 #define GL_MAX_VERTEX_HINT_PGI 107053 #define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000 #define GL_MAT_DIFFUSE_BIT_PGI 0x00400000 #define GL_MAT_EMISSION_BIT_PGI 0x00800000 #define GL_MAT_COLOR_INDEXES_BIT_PGI 0x01000000 #define GL_MAT_SHININESS_BIT_PGI 0x02000000 #define GL_MAT_SPECULAR_BIT_PGI 0x04000000 #define GL_NORMAL_BIT_PGI 0x08000000 #define GL_TEXCOORD1_BIT_PGI 0x10000000 #define GL_TEXCOORD2_BIT_PGI 0x20000000 #define GL_TEXCOORD3_BIT_PGI 0x40000000 #define GL_TEXCOORD4_BIT_PGI 0x80000000 #define GLEW_PGI_vertex_hints GLEW_GET_VAR(__GLEW_PGI_vertex_hints) #endif /* GL_PGI_vertex_hints */ /* ---------------------- GL_REGAL_ES1_0_compatibility --------------------- */ #ifndef GL_REGAL_ES1_0_compatibility #define GL_REGAL_ES1_0_compatibility 1 typedef int GLclampx; typedef void (GLAPIENTRY * PFNGLALPHAFUNCXPROC) (GLenum func, GLclampx ref); typedef void (GLAPIENTRY * PFNGLCLEARCOLORXPROC) (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha); typedef void (GLAPIENTRY * PFNGLCLEARDEPTHXPROC) (GLclampx depth); typedef void (GLAPIENTRY * PFNGLCOLOR4XPROC) (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); typedef void (GLAPIENTRY * PFNGLDEPTHRANGEXPROC) (GLclampx zNear, GLclampx zFar); typedef void (GLAPIENTRY * PFNGLFOGXPROC) (GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLFOGXVPROC) (GLenum pname, const GLfixed* params); typedef void (GLAPIENTRY * PFNGLFRUSTUMFPROC) (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); typedef void (GLAPIENTRY * PFNGLFRUSTUMXPROC) (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); typedef void (GLAPIENTRY * PFNGLLIGHTMODELXPROC) (GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLLIGHTMODELXVPROC) (GLenum pname, const GLfixed* params); typedef void (GLAPIENTRY * PFNGLLIGHTXPROC) (GLenum light, GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLLIGHTXVPROC) (GLenum light, GLenum pname, const GLfixed* params); typedef void (GLAPIENTRY * PFNGLLINEWIDTHXPROC) (GLfixed width); typedef void (GLAPIENTRY * PFNGLLOADMATRIXXPROC) (const GLfixed* m); typedef void (GLAPIENTRY * PFNGLMATERIALXPROC) (GLenum face, GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLMATERIALXVPROC) (GLenum face, GLenum pname, const GLfixed* params); typedef void (GLAPIENTRY * PFNGLMULTMATRIXXPROC) (const GLfixed* m); typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4XPROC) (GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q); typedef void (GLAPIENTRY * PFNGLNORMAL3XPROC) (GLfixed nx, GLfixed ny, GLfixed nz); typedef void (GLAPIENTRY * PFNGLORTHOFPROC) (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); typedef void (GLAPIENTRY * PFNGLORTHOXPROC) (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar); typedef void (GLAPIENTRY * PFNGLPOINTSIZEXPROC) (GLfixed size); typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETXPROC) (GLfixed factor, GLfixed units); typedef void (GLAPIENTRY * PFNGLROTATEXPROC) (GLfixed angle, GLfixed x, GLfixed y, GLfixed z); typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEXPROC) (GLclampx value, GLboolean invert); typedef void (GLAPIENTRY * PFNGLSCALEXPROC) (GLfixed x, GLfixed y, GLfixed z); typedef void (GLAPIENTRY * PFNGLTEXENVXPROC) (GLenum target, GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLTEXENVXVPROC) (GLenum target, GLenum pname, const GLfixed* params); typedef void (GLAPIENTRY * PFNGLTEXPARAMETERXPROC) (GLenum target, GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLTRANSLATEXPROC) (GLfixed x, GLfixed y, GLfixed z); #define glAlphaFuncx GLEW_GET_FUN(__glewAlphaFuncx) #define glClearColorx GLEW_GET_FUN(__glewClearColorx) #define glClearDepthx GLEW_GET_FUN(__glewClearDepthx) #define glColor4x GLEW_GET_FUN(__glewColor4x) #define glDepthRangex GLEW_GET_FUN(__glewDepthRangex) #define glFogx GLEW_GET_FUN(__glewFogx) #define glFogxv GLEW_GET_FUN(__glewFogxv) #define glFrustumf GLEW_GET_FUN(__glewFrustumf) #define glFrustumx GLEW_GET_FUN(__glewFrustumx) #define glLightModelx GLEW_GET_FUN(__glewLightModelx) #define glLightModelxv GLEW_GET_FUN(__glewLightModelxv) #define glLightx GLEW_GET_FUN(__glewLightx) #define glLightxv GLEW_GET_FUN(__glewLightxv) #define glLineWidthx GLEW_GET_FUN(__glewLineWidthx) #define glLoadMatrixx GLEW_GET_FUN(__glewLoadMatrixx) #define glMaterialx GLEW_GET_FUN(__glewMaterialx) #define glMaterialxv GLEW_GET_FUN(__glewMaterialxv) #define glMultMatrixx GLEW_GET_FUN(__glewMultMatrixx) #define glMultiTexCoord4x GLEW_GET_FUN(__glewMultiTexCoord4x) #define glNormal3x GLEW_GET_FUN(__glewNormal3x) #define glOrthof GLEW_GET_FUN(__glewOrthof) #define glOrthox GLEW_GET_FUN(__glewOrthox) #define glPointSizex GLEW_GET_FUN(__glewPointSizex) #define glPolygonOffsetx GLEW_GET_FUN(__glewPolygonOffsetx) #define glRotatex GLEW_GET_FUN(__glewRotatex) #define glSampleCoveragex GLEW_GET_FUN(__glewSampleCoveragex) #define glScalex GLEW_GET_FUN(__glewScalex) #define glTexEnvx GLEW_GET_FUN(__glewTexEnvx) #define glTexEnvxv GLEW_GET_FUN(__glewTexEnvxv) #define glTexParameterx GLEW_GET_FUN(__glewTexParameterx) #define glTranslatex GLEW_GET_FUN(__glewTranslatex) #define GLEW_REGAL_ES1_0_compatibility GLEW_GET_VAR(__GLEW_REGAL_ES1_0_compatibility) #endif /* GL_REGAL_ES1_0_compatibility */ /* ---------------------- GL_REGAL_ES1_1_compatibility --------------------- */ #ifndef GL_REGAL_ES1_1_compatibility #define GL_REGAL_ES1_1_compatibility 1 typedef void (GLAPIENTRY * PFNGLCLIPPLANEFPROC) (GLenum plane, const GLfloat* equation); typedef void (GLAPIENTRY * PFNGLCLIPPLANEXPROC) (GLenum plane, const GLfixed* equation); typedef void (GLAPIENTRY * PFNGLGETCLIPPLANEFPROC) (GLenum pname, GLfloat eqn[4]); typedef void (GLAPIENTRY * PFNGLGETCLIPPLANEXPROC) (GLenum pname, GLfixed eqn[4]); typedef void (GLAPIENTRY * PFNGLGETFIXEDVPROC) (GLenum pname, GLfixed* params); typedef void (GLAPIENTRY * PFNGLGETLIGHTXVPROC) (GLenum light, GLenum pname, GLfixed* params); typedef void (GLAPIENTRY * PFNGLGETMATERIALXVPROC) (GLenum face, GLenum pname, GLfixed* params); typedef void (GLAPIENTRY * PFNGLGETTEXENVXVPROC) (GLenum env, GLenum pname, GLfixed* params); typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERXVPROC) (GLenum target, GLenum pname, GLfixed* params); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERXPROC) (GLenum pname, GLfixed param); typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERXVPROC) (GLenum pname, const GLfixed* params); typedef void (GLAPIENTRY * PFNGLPOINTSIZEPOINTEROESPROC) (GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLTEXPARAMETERXVPROC) (GLenum target, GLenum pname, const GLfixed* params); #define glClipPlanef GLEW_GET_FUN(__glewClipPlanef) #define glClipPlanex GLEW_GET_FUN(__glewClipPlanex) #define glGetClipPlanef GLEW_GET_FUN(__glewGetClipPlanef) #define glGetClipPlanex GLEW_GET_FUN(__glewGetClipPlanex) #define glGetFixedv GLEW_GET_FUN(__glewGetFixedv) #define glGetLightxv GLEW_GET_FUN(__glewGetLightxv) #define glGetMaterialxv GLEW_GET_FUN(__glewGetMaterialxv) #define glGetTexEnvxv GLEW_GET_FUN(__glewGetTexEnvxv) #define glGetTexParameterxv GLEW_GET_FUN(__glewGetTexParameterxv) #define glPointParameterx GLEW_GET_FUN(__glewPointParameterx) #define glPointParameterxv GLEW_GET_FUN(__glewPointParameterxv) #define glPointSizePointerOES GLEW_GET_FUN(__glewPointSizePointerOES) #define glTexParameterxv GLEW_GET_FUN(__glewTexParameterxv) #define GLEW_REGAL_ES1_1_compatibility GLEW_GET_VAR(__GLEW_REGAL_ES1_1_compatibility) #endif /* GL_REGAL_ES1_1_compatibility */ /* ---------------------------- GL_REGAL_enable ---------------------------- */ #ifndef GL_REGAL_enable #define GL_REGAL_enable 1 #define GL_ERROR_REGAL 0x9322 #define GL_DEBUG_REGAL 0x9323 #define GL_LOG_REGAL 0x9324 #define GL_EMULATION_REGAL 0x9325 #define GL_DRIVER_REGAL 0x9326 #define GL_MISSING_REGAL 0x9360 #define GL_TRACE_REGAL 0x9361 #define GL_CACHE_REGAL 0x9362 #define GL_CODE_REGAL 0x9363 #define GL_STATISTICS_REGAL 0x9364 #define GLEW_REGAL_enable GLEW_GET_VAR(__GLEW_REGAL_enable) #endif /* GL_REGAL_enable */ /* ------------------------- GL_REGAL_error_string ------------------------- */ #ifndef GL_REGAL_error_string #define GL_REGAL_error_string 1 typedef const GLchar* (GLAPIENTRY * PFNGLERRORSTRINGREGALPROC) (GLenum error); #define glErrorStringREGAL GLEW_GET_FUN(__glewErrorStringREGAL) #define GLEW_REGAL_error_string GLEW_GET_VAR(__GLEW_REGAL_error_string) #endif /* GL_REGAL_error_string */ /* ------------------------ GL_REGAL_extension_query ----------------------- */ #ifndef GL_REGAL_extension_query #define GL_REGAL_extension_query 1 typedef GLboolean (GLAPIENTRY * PFNGLGETEXTENSIONREGALPROC) (const GLchar* ext); typedef GLboolean (GLAPIENTRY * PFNGLISSUPPORTEDREGALPROC) (const GLchar* ext); #define glGetExtensionREGAL GLEW_GET_FUN(__glewGetExtensionREGAL) #define glIsSupportedREGAL GLEW_GET_FUN(__glewIsSupportedREGAL) #define GLEW_REGAL_extension_query GLEW_GET_VAR(__GLEW_REGAL_extension_query) #endif /* GL_REGAL_extension_query */ /* ------------------------------ GL_REGAL_log ----------------------------- */ #ifndef GL_REGAL_log #define GL_REGAL_log 1 #define GL_LOG_ERROR_REGAL 0x9319 #define GL_LOG_WARNING_REGAL 0x931A #define GL_LOG_INFO_REGAL 0x931B #define GL_LOG_APP_REGAL 0x931C #define GL_LOG_DRIVER_REGAL 0x931D #define GL_LOG_INTERNAL_REGAL 0x931E #define GL_LOG_DEBUG_REGAL 0x931F #define GL_LOG_STATUS_REGAL 0x9320 #define GL_LOG_HTTP_REGAL 0x9321 typedef void (APIENTRY *GLLOGPROCREGAL)(GLenum stream, GLsizei length, const GLchar *message, void *context); typedef void (GLAPIENTRY * PFNGLLOGMESSAGECALLBACKREGALPROC) (GLLOGPROCREGAL callback); #define glLogMessageCallbackREGAL GLEW_GET_FUN(__glewLogMessageCallbackREGAL) #define GLEW_REGAL_log GLEW_GET_VAR(__GLEW_REGAL_log) #endif /* GL_REGAL_log */ /* ------------------------- GL_REGAL_proc_address ------------------------- */ #ifndef GL_REGAL_proc_address #define GL_REGAL_proc_address 1 typedef void * (GLAPIENTRY * PFNGLGETPROCADDRESSREGALPROC) (const GLchar *name); #define glGetProcAddressREGAL GLEW_GET_FUN(__glewGetProcAddressREGAL) #define GLEW_REGAL_proc_address GLEW_GET_VAR(__GLEW_REGAL_proc_address) #endif /* GL_REGAL_proc_address */ /* ----------------------- GL_REND_screen_coordinates ---------------------- */ #ifndef GL_REND_screen_coordinates #define GL_REND_screen_coordinates 1 #define GL_SCREEN_COORDINATES_REND 0x8490 #define GL_INVERTED_SCREEN_W_REND 0x8491 #define GLEW_REND_screen_coordinates GLEW_GET_VAR(__GLEW_REND_screen_coordinates) #endif /* GL_REND_screen_coordinates */ /* ------------------------------- GL_S3_s3tc ------------------------------ */ #ifndef GL_S3_s3tc #define GL_S3_s3tc 1 #define GL_RGB_S3TC 0x83A0 #define GL_RGB4_S3TC 0x83A1 #define GL_RGBA_S3TC 0x83A2 #define GL_RGBA4_S3TC 0x83A3 #define GL_RGBA_DXT5_S3TC 0x83A4 #define GL_RGBA4_DXT5_S3TC 0x83A5 #define GLEW_S3_s3tc GLEW_GET_VAR(__GLEW_S3_s3tc) #endif /* GL_S3_s3tc */ /* -------------------------- GL_SGIS_color_range -------------------------- */ #ifndef GL_SGIS_color_range #define GL_SGIS_color_range 1 #define GL_EXTENDED_RANGE_SGIS 0x85A5 #define GL_MIN_RED_SGIS 0x85A6 #define GL_MAX_RED_SGIS 0x85A7 #define GL_MIN_GREEN_SGIS 0x85A8 #define GL_MAX_GREEN_SGIS 0x85A9 #define GL_MIN_BLUE_SGIS 0x85AA #define GL_MAX_BLUE_SGIS 0x85AB #define GL_MIN_ALPHA_SGIS 0x85AC #define GL_MAX_ALPHA_SGIS 0x85AD #define GLEW_SGIS_color_range GLEW_GET_VAR(__GLEW_SGIS_color_range) #endif /* GL_SGIS_color_range */ /* ------------------------- GL_SGIS_detail_texture ------------------------ */ #ifndef GL_SGIS_detail_texture #define GL_SGIS_detail_texture 1 typedef void (GLAPIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat* points); typedef void (GLAPIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat* points); #define glDetailTexFuncSGIS GLEW_GET_FUN(__glewDetailTexFuncSGIS) #define glGetDetailTexFuncSGIS GLEW_GET_FUN(__glewGetDetailTexFuncSGIS) #define GLEW_SGIS_detail_texture GLEW_GET_VAR(__GLEW_SGIS_detail_texture) #endif /* GL_SGIS_detail_texture */ /* -------------------------- GL_SGIS_fog_function ------------------------- */ #ifndef GL_SGIS_fog_function #define GL_SGIS_fog_function 1 typedef void (GLAPIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat* points); typedef void (GLAPIENTRY * PFNGLGETFOGFUNCSGISPROC) (GLfloat* points); #define glFogFuncSGIS GLEW_GET_FUN(__glewFogFuncSGIS) #define glGetFogFuncSGIS GLEW_GET_FUN(__glewGetFogFuncSGIS) #define GLEW_SGIS_fog_function GLEW_GET_VAR(__GLEW_SGIS_fog_function) #endif /* GL_SGIS_fog_function */ /* ------------------------ GL_SGIS_generate_mipmap ------------------------ */ #ifndef GL_SGIS_generate_mipmap #define GL_SGIS_generate_mipmap 1 #define GL_GENERATE_MIPMAP_SGIS 0x8191 #define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192 #define GLEW_SGIS_generate_mipmap GLEW_GET_VAR(__GLEW_SGIS_generate_mipmap) #endif /* GL_SGIS_generate_mipmap */ /* -------------------------- GL_SGIS_multisample -------------------------- */ #ifndef GL_SGIS_multisample #define GL_SGIS_multisample 1 #define GL_MULTISAMPLE_SGIS 0x809D #define GL_SAMPLE_ALPHA_TO_MASK_SGIS 0x809E #define GL_SAMPLE_ALPHA_TO_ONE_SGIS 0x809F #define GL_SAMPLE_MASK_SGIS 0x80A0 #define GL_1PASS_SGIS 0x80A1 #define GL_2PASS_0_SGIS 0x80A2 #define GL_2PASS_1_SGIS 0x80A3 #define GL_4PASS_0_SGIS 0x80A4 #define GL_4PASS_1_SGIS 0x80A5 #define GL_4PASS_2_SGIS 0x80A6 #define GL_4PASS_3_SGIS 0x80A7 #define GL_SAMPLE_BUFFERS_SGIS 0x80A8 #define GL_SAMPLES_SGIS 0x80A9 #define GL_SAMPLE_MASK_VALUE_SGIS 0x80AA #define GL_SAMPLE_MASK_INVERT_SGIS 0x80AB #define GL_SAMPLE_PATTERN_SGIS 0x80AC typedef void (GLAPIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert); typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); #define glSampleMaskSGIS GLEW_GET_FUN(__glewSampleMaskSGIS) #define glSamplePatternSGIS GLEW_GET_FUN(__glewSamplePatternSGIS) #define GLEW_SGIS_multisample GLEW_GET_VAR(__GLEW_SGIS_multisample) #endif /* GL_SGIS_multisample */ /* ------------------------- GL_SGIS_pixel_texture ------------------------- */ #ifndef GL_SGIS_pixel_texture #define GL_SGIS_pixel_texture 1 #define GLEW_SGIS_pixel_texture GLEW_GET_VAR(__GLEW_SGIS_pixel_texture) #endif /* GL_SGIS_pixel_texture */ /* ----------------------- GL_SGIS_point_line_texgen ----------------------- */ #ifndef GL_SGIS_point_line_texgen #define GL_SGIS_point_line_texgen 1 #define GL_EYE_DISTANCE_TO_POINT_SGIS 0x81F0 #define GL_OBJECT_DISTANCE_TO_POINT_SGIS 0x81F1 #define GL_EYE_DISTANCE_TO_LINE_SGIS 0x81F2 #define GL_OBJECT_DISTANCE_TO_LINE_SGIS 0x81F3 #define GL_EYE_POINT_SGIS 0x81F4 #define GL_OBJECT_POINT_SGIS 0x81F5 #define GL_EYE_LINE_SGIS 0x81F6 #define GL_OBJECT_LINE_SGIS 0x81F7 #define GLEW_SGIS_point_line_texgen GLEW_GET_VAR(__GLEW_SGIS_point_line_texgen) #endif /* GL_SGIS_point_line_texgen */ /* ------------------------ GL_SGIS_sharpen_texture ------------------------ */ #ifndef GL_SGIS_sharpen_texture #define GL_SGIS_sharpen_texture 1 typedef void (GLAPIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat* points); typedef void (GLAPIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat* points); #define glGetSharpenTexFuncSGIS GLEW_GET_FUN(__glewGetSharpenTexFuncSGIS) #define glSharpenTexFuncSGIS GLEW_GET_FUN(__glewSharpenTexFuncSGIS) #define GLEW_SGIS_sharpen_texture GLEW_GET_VAR(__GLEW_SGIS_sharpen_texture) #endif /* GL_SGIS_sharpen_texture */ /* --------------------------- GL_SGIS_texture4D --------------------------- */ #ifndef GL_SGIS_texture4D #define GL_SGIS_texture4D 1 typedef void (GLAPIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void *pixels); typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const void *pixels); #define glTexImage4DSGIS GLEW_GET_FUN(__glewTexImage4DSGIS) #define glTexSubImage4DSGIS GLEW_GET_FUN(__glewTexSubImage4DSGIS) #define GLEW_SGIS_texture4D GLEW_GET_VAR(__GLEW_SGIS_texture4D) #endif /* GL_SGIS_texture4D */ /* ---------------------- GL_SGIS_texture_border_clamp --------------------- */ #ifndef GL_SGIS_texture_border_clamp #define GL_SGIS_texture_border_clamp 1 #define GL_CLAMP_TO_BORDER_SGIS 0x812D #define GLEW_SGIS_texture_border_clamp GLEW_GET_VAR(__GLEW_SGIS_texture_border_clamp) #endif /* GL_SGIS_texture_border_clamp */ /* ----------------------- GL_SGIS_texture_edge_clamp ---------------------- */ #ifndef GL_SGIS_texture_edge_clamp #define GL_SGIS_texture_edge_clamp 1 #define GL_CLAMP_TO_EDGE_SGIS 0x812F #define GLEW_SGIS_texture_edge_clamp GLEW_GET_VAR(__GLEW_SGIS_texture_edge_clamp) #endif /* GL_SGIS_texture_edge_clamp */ /* ------------------------ GL_SGIS_texture_filter4 ------------------------ */ #ifndef GL_SGIS_texture_filter4 #define GL_SGIS_texture_filter4 1 typedef void (GLAPIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat* weights); typedef void (GLAPIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat* weights); #define glGetTexFilterFuncSGIS GLEW_GET_FUN(__glewGetTexFilterFuncSGIS) #define glTexFilterFuncSGIS GLEW_GET_FUN(__glewTexFilterFuncSGIS) #define GLEW_SGIS_texture_filter4 GLEW_GET_VAR(__GLEW_SGIS_texture_filter4) #endif /* GL_SGIS_texture_filter4 */ /* -------------------------- GL_SGIS_texture_lod -------------------------- */ #ifndef GL_SGIS_texture_lod #define GL_SGIS_texture_lod 1 #define GL_TEXTURE_MIN_LOD_SGIS 0x813A #define GL_TEXTURE_MAX_LOD_SGIS 0x813B #define GL_TEXTURE_BASE_LEVEL_SGIS 0x813C #define GL_TEXTURE_MAX_LEVEL_SGIS 0x813D #define GLEW_SGIS_texture_lod GLEW_GET_VAR(__GLEW_SGIS_texture_lod) #endif /* GL_SGIS_texture_lod */ /* ------------------------- GL_SGIS_texture_select ------------------------ */ #ifndef GL_SGIS_texture_select #define GL_SGIS_texture_select 1 #define GLEW_SGIS_texture_select GLEW_GET_VAR(__GLEW_SGIS_texture_select) #endif /* GL_SGIS_texture_select */ /* ----------------------------- GL_SGIX_async ----------------------------- */ #ifndef GL_SGIX_async #define GL_SGIX_async 1 #define GL_ASYNC_MARKER_SGIX 0x8329 typedef void (GLAPIENTRY * PFNGLASYNCMARKERSGIXPROC) (GLuint marker); typedef void (GLAPIENTRY * PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range); typedef GLint (GLAPIENTRY * PFNGLFINISHASYNCSGIXPROC) (GLuint* markerp); typedef GLuint (GLAPIENTRY * PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range); typedef GLboolean (GLAPIENTRY * PFNGLISASYNCMARKERSGIXPROC) (GLuint marker); typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); #define glAsyncMarkerSGIX GLEW_GET_FUN(__glewAsyncMarkerSGIX) #define glDeleteAsyncMarkersSGIX GLEW_GET_FUN(__glewDeleteAsyncMarkersSGIX) #define glFinishAsyncSGIX GLEW_GET_FUN(__glewFinishAsyncSGIX) #define glGenAsyncMarkersSGIX GLEW_GET_FUN(__glewGenAsyncMarkersSGIX) #define glIsAsyncMarkerSGIX GLEW_GET_FUN(__glewIsAsyncMarkerSGIX) #define glPollAsyncSGIX GLEW_GET_FUN(__glewPollAsyncSGIX) #define GLEW_SGIX_async GLEW_GET_VAR(__GLEW_SGIX_async) #endif /* GL_SGIX_async */ /* ------------------------ GL_SGIX_async_histogram ------------------------ */ #ifndef GL_SGIX_async_histogram #define GL_SGIX_async_histogram 1 #define GL_ASYNC_HISTOGRAM_SGIX 0x832C #define GL_MAX_ASYNC_HISTOGRAM_SGIX 0x832D #define GLEW_SGIX_async_histogram GLEW_GET_VAR(__GLEW_SGIX_async_histogram) #endif /* GL_SGIX_async_histogram */ /* -------------------------- GL_SGIX_async_pixel -------------------------- */ #ifndef GL_SGIX_async_pixel #define GL_SGIX_async_pixel 1 #define GL_ASYNC_TEX_IMAGE_SGIX 0x835C #define GL_ASYNC_DRAW_PIXELS_SGIX 0x835D #define GL_ASYNC_READ_PIXELS_SGIX 0x835E #define GL_MAX_ASYNC_TEX_IMAGE_SGIX 0x835F #define GL_MAX_ASYNC_DRAW_PIXELS_SGIX 0x8360 #define GL_MAX_ASYNC_READ_PIXELS_SGIX 0x8361 #define GLEW_SGIX_async_pixel GLEW_GET_VAR(__GLEW_SGIX_async_pixel) #endif /* GL_SGIX_async_pixel */ /* ----------------------- GL_SGIX_blend_alpha_minmax ---------------------- */ #ifndef GL_SGIX_blend_alpha_minmax #define GL_SGIX_blend_alpha_minmax 1 #define GL_ALPHA_MIN_SGIX 0x8320 #define GL_ALPHA_MAX_SGIX 0x8321 #define GLEW_SGIX_blend_alpha_minmax GLEW_GET_VAR(__GLEW_SGIX_blend_alpha_minmax) #endif /* GL_SGIX_blend_alpha_minmax */ /* ---------------------------- GL_SGIX_clipmap ---------------------------- */ #ifndef GL_SGIX_clipmap #define GL_SGIX_clipmap 1 #define GLEW_SGIX_clipmap GLEW_GET_VAR(__GLEW_SGIX_clipmap) #endif /* GL_SGIX_clipmap */ /* ---------------------- GL_SGIX_convolution_accuracy --------------------- */ #ifndef GL_SGIX_convolution_accuracy #define GL_SGIX_convolution_accuracy 1 #define GL_CONVOLUTION_HINT_SGIX 0x8316 #define GLEW_SGIX_convolution_accuracy GLEW_GET_VAR(__GLEW_SGIX_convolution_accuracy) #endif /* GL_SGIX_convolution_accuracy */ /* ------------------------- GL_SGIX_depth_texture ------------------------- */ #ifndef GL_SGIX_depth_texture #define GL_SGIX_depth_texture 1 #define GL_DEPTH_COMPONENT16_SGIX 0x81A5 #define GL_DEPTH_COMPONENT24_SGIX 0x81A6 #define GL_DEPTH_COMPONENT32_SGIX 0x81A7 #define GLEW_SGIX_depth_texture GLEW_GET_VAR(__GLEW_SGIX_depth_texture) #endif /* GL_SGIX_depth_texture */ /* -------------------------- GL_SGIX_flush_raster ------------------------- */ #ifndef GL_SGIX_flush_raster #define GL_SGIX_flush_raster 1 typedef void (GLAPIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void); #define glFlushRasterSGIX GLEW_GET_FUN(__glewFlushRasterSGIX) #define GLEW_SGIX_flush_raster GLEW_GET_VAR(__GLEW_SGIX_flush_raster) #endif /* GL_SGIX_flush_raster */ /* --------------------------- GL_SGIX_fog_offset -------------------------- */ #ifndef GL_SGIX_fog_offset #define GL_SGIX_fog_offset 1 #define GL_FOG_OFFSET_SGIX 0x8198 #define GL_FOG_OFFSET_VALUE_SGIX 0x8199 #define GLEW_SGIX_fog_offset GLEW_GET_VAR(__GLEW_SGIX_fog_offset) #endif /* GL_SGIX_fog_offset */ /* -------------------------- GL_SGIX_fog_texture -------------------------- */ #ifndef GL_SGIX_fog_texture #define GL_SGIX_fog_texture 1 #define GL_FOG_PATCHY_FACTOR_SGIX 0 #define GL_FRAGMENT_FOG_SGIX 0 #define GL_TEXTURE_FOG_SGIX 0 typedef void (GLAPIENTRY * PFNGLTEXTUREFOGSGIXPROC) (GLenum pname); #define glTextureFogSGIX GLEW_GET_FUN(__glewTextureFogSGIX) #define GLEW_SGIX_fog_texture GLEW_GET_VAR(__GLEW_SGIX_fog_texture) #endif /* GL_SGIX_fog_texture */ /* ------------------- GL_SGIX_fragment_specular_lighting ------------------ */ #ifndef GL_SGIX_fragment_specular_lighting #define GL_SGIX_fragment_specular_lighting 1 typedef void (GLAPIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, const GLfloat param); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, const GLint param); typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum value, GLfloat* data); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum value, GLint* data); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat* data); typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint* data); #define glFragmentColorMaterialSGIX GLEW_GET_FUN(__glewFragmentColorMaterialSGIX) #define glFragmentLightModelfSGIX GLEW_GET_FUN(__glewFragmentLightModelfSGIX) #define glFragmentLightModelfvSGIX GLEW_GET_FUN(__glewFragmentLightModelfvSGIX) #define glFragmentLightModeliSGIX GLEW_GET_FUN(__glewFragmentLightModeliSGIX) #define glFragmentLightModelivSGIX GLEW_GET_FUN(__glewFragmentLightModelivSGIX) #define glFragmentLightfSGIX GLEW_GET_FUN(__glewFragmentLightfSGIX) #define glFragmentLightfvSGIX GLEW_GET_FUN(__glewFragmentLightfvSGIX) #define glFragmentLightiSGIX GLEW_GET_FUN(__glewFragmentLightiSGIX) #define glFragmentLightivSGIX GLEW_GET_FUN(__glewFragmentLightivSGIX) #define glFragmentMaterialfSGIX GLEW_GET_FUN(__glewFragmentMaterialfSGIX) #define glFragmentMaterialfvSGIX GLEW_GET_FUN(__glewFragmentMaterialfvSGIX) #define glFragmentMaterialiSGIX GLEW_GET_FUN(__glewFragmentMaterialiSGIX) #define glFragmentMaterialivSGIX GLEW_GET_FUN(__glewFragmentMaterialivSGIX) #define glGetFragmentLightfvSGIX GLEW_GET_FUN(__glewGetFragmentLightfvSGIX) #define glGetFragmentLightivSGIX GLEW_GET_FUN(__glewGetFragmentLightivSGIX) #define glGetFragmentMaterialfvSGIX GLEW_GET_FUN(__glewGetFragmentMaterialfvSGIX) #define glGetFragmentMaterialivSGIX GLEW_GET_FUN(__glewGetFragmentMaterialivSGIX) #define GLEW_SGIX_fragment_specular_lighting GLEW_GET_VAR(__GLEW_SGIX_fragment_specular_lighting) #endif /* GL_SGIX_fragment_specular_lighting */ /* --------------------------- GL_SGIX_framezoom --------------------------- */ #ifndef GL_SGIX_framezoom #define GL_SGIX_framezoom 1 typedef void (GLAPIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor); #define glFrameZoomSGIX GLEW_GET_FUN(__glewFrameZoomSGIX) #define GLEW_SGIX_framezoom GLEW_GET_VAR(__GLEW_SGIX_framezoom) #endif /* GL_SGIX_framezoom */ /* --------------------------- GL_SGIX_interlace --------------------------- */ #ifndef GL_SGIX_interlace #define GL_SGIX_interlace 1 #define GL_INTERLACE_SGIX 0x8094 #define GLEW_SGIX_interlace GLEW_GET_VAR(__GLEW_SGIX_interlace) #endif /* GL_SGIX_interlace */ /* ------------------------- GL_SGIX_ir_instrument1 ------------------------ */ #ifndef GL_SGIX_ir_instrument1 #define GL_SGIX_ir_instrument1 1 #define GLEW_SGIX_ir_instrument1 GLEW_GET_VAR(__GLEW_SGIX_ir_instrument1) #endif /* GL_SGIX_ir_instrument1 */ /* ------------------------- GL_SGIX_list_priority ------------------------- */ #ifndef GL_SGIX_list_priority #define GL_SGIX_list_priority 1 #define GLEW_SGIX_list_priority GLEW_GET_VAR(__GLEW_SGIX_list_priority) #endif /* GL_SGIX_list_priority */ /* ------------------------- GL_SGIX_pixel_texture ------------------------- */ #ifndef GL_SGIX_pixel_texture #define GL_SGIX_pixel_texture 1 typedef void (GLAPIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode); #define glPixelTexGenSGIX GLEW_GET_FUN(__glewPixelTexGenSGIX) #define GLEW_SGIX_pixel_texture GLEW_GET_VAR(__GLEW_SGIX_pixel_texture) #endif /* GL_SGIX_pixel_texture */ /* ----------------------- GL_SGIX_pixel_texture_bits ---------------------- */ #ifndef GL_SGIX_pixel_texture_bits #define GL_SGIX_pixel_texture_bits 1 #define GLEW_SGIX_pixel_texture_bits GLEW_GET_VAR(__GLEW_SGIX_pixel_texture_bits) #endif /* GL_SGIX_pixel_texture_bits */ /* ------------------------ GL_SGIX_reference_plane ------------------------ */ #ifndef GL_SGIX_reference_plane #define GL_SGIX_reference_plane 1 typedef void (GLAPIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble* equation); #define glReferencePlaneSGIX GLEW_GET_FUN(__glewReferencePlaneSGIX) #define GLEW_SGIX_reference_plane GLEW_GET_VAR(__GLEW_SGIX_reference_plane) #endif /* GL_SGIX_reference_plane */ /* ---------------------------- GL_SGIX_resample --------------------------- */ #ifndef GL_SGIX_resample #define GL_SGIX_resample 1 #define GL_PACK_RESAMPLE_SGIX 0x842E #define GL_UNPACK_RESAMPLE_SGIX 0x842F #define GL_RESAMPLE_DECIMATE_SGIX 0x8430 #define GL_RESAMPLE_REPLICATE_SGIX 0x8433 #define GL_RESAMPLE_ZERO_FILL_SGIX 0x8434 #define GLEW_SGIX_resample GLEW_GET_VAR(__GLEW_SGIX_resample) #endif /* GL_SGIX_resample */ /* ----------------------------- GL_SGIX_shadow ---------------------------- */ #ifndef GL_SGIX_shadow #define GL_SGIX_shadow 1 #define GL_TEXTURE_COMPARE_SGIX 0x819A #define GL_TEXTURE_COMPARE_OPERATOR_SGIX 0x819B #define GL_TEXTURE_LEQUAL_R_SGIX 0x819C #define GL_TEXTURE_GEQUAL_R_SGIX 0x819D #define GLEW_SGIX_shadow GLEW_GET_VAR(__GLEW_SGIX_shadow) #endif /* GL_SGIX_shadow */ /* ------------------------- GL_SGIX_shadow_ambient ------------------------ */ #ifndef GL_SGIX_shadow_ambient #define GL_SGIX_shadow_ambient 1 #define GL_SHADOW_AMBIENT_SGIX 0x80BF #define GLEW_SGIX_shadow_ambient GLEW_GET_VAR(__GLEW_SGIX_shadow_ambient) #endif /* GL_SGIX_shadow_ambient */ /* ----------------------------- GL_SGIX_sprite ---------------------------- */ #ifndef GL_SGIX_sprite #define GL_SGIX_sprite 1 typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param); typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param); typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, GLint* params); #define glSpriteParameterfSGIX GLEW_GET_FUN(__glewSpriteParameterfSGIX) #define glSpriteParameterfvSGIX GLEW_GET_FUN(__glewSpriteParameterfvSGIX) #define glSpriteParameteriSGIX GLEW_GET_FUN(__glewSpriteParameteriSGIX) #define glSpriteParameterivSGIX GLEW_GET_FUN(__glewSpriteParameterivSGIX) #define GLEW_SGIX_sprite GLEW_GET_VAR(__GLEW_SGIX_sprite) #endif /* GL_SGIX_sprite */ /* ----------------------- GL_SGIX_tag_sample_buffer ----------------------- */ #ifndef GL_SGIX_tag_sample_buffer #define GL_SGIX_tag_sample_buffer 1 typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); #define glTagSampleBufferSGIX GLEW_GET_FUN(__glewTagSampleBufferSGIX) #define GLEW_SGIX_tag_sample_buffer GLEW_GET_VAR(__GLEW_SGIX_tag_sample_buffer) #endif /* GL_SGIX_tag_sample_buffer */ /* ------------------------ GL_SGIX_texture_add_env ------------------------ */ #ifndef GL_SGIX_texture_add_env #define GL_SGIX_texture_add_env 1 #define GLEW_SGIX_texture_add_env GLEW_GET_VAR(__GLEW_SGIX_texture_add_env) #endif /* GL_SGIX_texture_add_env */ /* -------------------- GL_SGIX_texture_coordinate_clamp ------------------- */ #ifndef GL_SGIX_texture_coordinate_clamp #define GL_SGIX_texture_coordinate_clamp 1 #define GL_TEXTURE_MAX_CLAMP_S_SGIX 0x8369 #define GL_TEXTURE_MAX_CLAMP_T_SGIX 0x836A #define GL_TEXTURE_MAX_CLAMP_R_SGIX 0x836B #define GLEW_SGIX_texture_coordinate_clamp GLEW_GET_VAR(__GLEW_SGIX_texture_coordinate_clamp) #endif /* GL_SGIX_texture_coordinate_clamp */ /* ------------------------ GL_SGIX_texture_lod_bias ----------------------- */ #ifndef GL_SGIX_texture_lod_bias #define GL_SGIX_texture_lod_bias 1 #define GLEW_SGIX_texture_lod_bias GLEW_GET_VAR(__GLEW_SGIX_texture_lod_bias) #endif /* GL_SGIX_texture_lod_bias */ /* ---------------------- GL_SGIX_texture_multi_buffer --------------------- */ #ifndef GL_SGIX_texture_multi_buffer #define GL_SGIX_texture_multi_buffer 1 #define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E #define GLEW_SGIX_texture_multi_buffer GLEW_GET_VAR(__GLEW_SGIX_texture_multi_buffer) #endif /* GL_SGIX_texture_multi_buffer */ /* ------------------------- GL_SGIX_texture_range ------------------------- */ #ifndef GL_SGIX_texture_range #define GL_SGIX_texture_range 1 #define GL_RGB_SIGNED_SGIX 0x85E0 #define GL_RGBA_SIGNED_SGIX 0x85E1 #define GL_ALPHA_SIGNED_SGIX 0x85E2 #define GL_LUMINANCE_SIGNED_SGIX 0x85E3 #define GL_INTENSITY_SIGNED_SGIX 0x85E4 #define GL_LUMINANCE_ALPHA_SIGNED_SGIX 0x85E5 #define GL_RGB16_SIGNED_SGIX 0x85E6 #define GL_RGBA16_SIGNED_SGIX 0x85E7 #define GL_ALPHA16_SIGNED_SGIX 0x85E8 #define GL_LUMINANCE16_SIGNED_SGIX 0x85E9 #define GL_INTENSITY16_SIGNED_SGIX 0x85EA #define GL_LUMINANCE16_ALPHA16_SIGNED_SGIX 0x85EB #define GL_RGB_EXTENDED_RANGE_SGIX 0x85EC #define GL_RGBA_EXTENDED_RANGE_SGIX 0x85ED #define GL_ALPHA_EXTENDED_RANGE_SGIX 0x85EE #define GL_LUMINANCE_EXTENDED_RANGE_SGIX 0x85EF #define GL_INTENSITY_EXTENDED_RANGE_SGIX 0x85F0 #define GL_LUMINANCE_ALPHA_EXTENDED_RANGE_SGIX 0x85F1 #define GL_RGB16_EXTENDED_RANGE_SGIX 0x85F2 #define GL_RGBA16_EXTENDED_RANGE_SGIX 0x85F3 #define GL_ALPHA16_EXTENDED_RANGE_SGIX 0x85F4 #define GL_LUMINANCE16_EXTENDED_RANGE_SGIX 0x85F5 #define GL_INTENSITY16_EXTENDED_RANGE_SGIX 0x85F6 #define GL_LUMINANCE16_ALPHA16_EXTENDED_RANGE_SGIX 0x85F7 #define GL_MIN_LUMINANCE_SGIS 0x85F8 #define GL_MAX_LUMINANCE_SGIS 0x85F9 #define GL_MIN_INTENSITY_SGIS 0x85FA #define GL_MAX_INTENSITY_SGIS 0x85FB #define GLEW_SGIX_texture_range GLEW_GET_VAR(__GLEW_SGIX_texture_range) #endif /* GL_SGIX_texture_range */ /* ----------------------- GL_SGIX_texture_scale_bias ---------------------- */ #ifndef GL_SGIX_texture_scale_bias #define GL_SGIX_texture_scale_bias 1 #define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179 #define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A #define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B #define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C #define GLEW_SGIX_texture_scale_bias GLEW_GET_VAR(__GLEW_SGIX_texture_scale_bias) #endif /* GL_SGIX_texture_scale_bias */ /* ------------------------- GL_SGIX_vertex_preclip ------------------------ */ #ifndef GL_SGIX_vertex_preclip #define GL_SGIX_vertex_preclip 1 #define GL_VERTEX_PRECLIP_SGIX 0x83EE #define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF #define GLEW_SGIX_vertex_preclip GLEW_GET_VAR(__GLEW_SGIX_vertex_preclip) #endif /* GL_SGIX_vertex_preclip */ /* ---------------------- GL_SGIX_vertex_preclip_hint ---------------------- */ #ifndef GL_SGIX_vertex_preclip_hint #define GL_SGIX_vertex_preclip_hint 1 #define GL_VERTEX_PRECLIP_SGIX 0x83EE #define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF #define GLEW_SGIX_vertex_preclip_hint GLEW_GET_VAR(__GLEW_SGIX_vertex_preclip_hint) #endif /* GL_SGIX_vertex_preclip_hint */ /* ----------------------------- GL_SGIX_ycrcb ----------------------------- */ #ifndef GL_SGIX_ycrcb #define GL_SGIX_ycrcb 1 #define GLEW_SGIX_ycrcb GLEW_GET_VAR(__GLEW_SGIX_ycrcb) #endif /* GL_SGIX_ycrcb */ /* -------------------------- GL_SGI_color_matrix -------------------------- */ #ifndef GL_SGI_color_matrix #define GL_SGI_color_matrix 1 #define GL_COLOR_MATRIX_SGI 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB #define GLEW_SGI_color_matrix GLEW_GET_VAR(__GLEW_SGI_color_matrix) #endif /* GL_SGI_color_matrix */ /* --------------------------- GL_SGI_color_table -------------------------- */ #ifndef GL_SGI_color_table #define GL_SGI_color_table 1 #define GL_COLOR_TABLE_SGI 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 #define GL_PROXY_COLOR_TABLE_SGI 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 #define GL_COLOR_TABLE_SCALE_SGI 0x80D6 #define GL_COLOR_TABLE_BIAS_SGI 0x80D7 #define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 #define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat* params); typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint* params); typedef void (GLAPIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table); typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, void *table); #define glColorTableParameterfvSGI GLEW_GET_FUN(__glewColorTableParameterfvSGI) #define glColorTableParameterivSGI GLEW_GET_FUN(__glewColorTableParameterivSGI) #define glColorTableSGI GLEW_GET_FUN(__glewColorTableSGI) #define glCopyColorTableSGI GLEW_GET_FUN(__glewCopyColorTableSGI) #define glGetColorTableParameterfvSGI GLEW_GET_FUN(__glewGetColorTableParameterfvSGI) #define glGetColorTableParameterivSGI GLEW_GET_FUN(__glewGetColorTableParameterivSGI) #define glGetColorTableSGI GLEW_GET_FUN(__glewGetColorTableSGI) #define GLEW_SGI_color_table GLEW_GET_VAR(__GLEW_SGI_color_table) #endif /* GL_SGI_color_table */ /* ----------------------- GL_SGI_texture_color_table ---------------------- */ #ifndef GL_SGI_texture_color_table #define GL_SGI_texture_color_table 1 #define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC #define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD #define GLEW_SGI_texture_color_table GLEW_GET_VAR(__GLEW_SGI_texture_color_table) #endif /* GL_SGI_texture_color_table */ /* ------------------------- GL_SUNX_constant_data ------------------------- */ #ifndef GL_SUNX_constant_data #define GL_SUNX_constant_data 1 #define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5 #define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6 typedef void (GLAPIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void); #define glFinishTextureSUNX GLEW_GET_FUN(__glewFinishTextureSUNX) #define GLEW_SUNX_constant_data GLEW_GET_VAR(__GLEW_SUNX_constant_data) #endif /* GL_SUNX_constant_data */ /* -------------------- GL_SUN_convolution_border_modes -------------------- */ #ifndef GL_SUN_convolution_border_modes #define GL_SUN_convolution_border_modes 1 #define GL_WRAP_BORDER_SUN 0x81D4 #define GLEW_SUN_convolution_border_modes GLEW_GET_VAR(__GLEW_SUN_convolution_border_modes) #endif /* GL_SUN_convolution_border_modes */ /* -------------------------- GL_SUN_global_alpha -------------------------- */ #ifndef GL_SUN_global_alpha #define GL_SUN_global_alpha 1 #define GL_GLOBAL_ALPHA_SUN 0x81D9 #define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor); typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor); #define glGlobalAlphaFactorbSUN GLEW_GET_FUN(__glewGlobalAlphaFactorbSUN) #define glGlobalAlphaFactordSUN GLEW_GET_FUN(__glewGlobalAlphaFactordSUN) #define glGlobalAlphaFactorfSUN GLEW_GET_FUN(__glewGlobalAlphaFactorfSUN) #define glGlobalAlphaFactoriSUN GLEW_GET_FUN(__glewGlobalAlphaFactoriSUN) #define glGlobalAlphaFactorsSUN GLEW_GET_FUN(__glewGlobalAlphaFactorsSUN) #define glGlobalAlphaFactorubSUN GLEW_GET_FUN(__glewGlobalAlphaFactorubSUN) #define glGlobalAlphaFactoruiSUN GLEW_GET_FUN(__glewGlobalAlphaFactoruiSUN) #define glGlobalAlphaFactorusSUN GLEW_GET_FUN(__glewGlobalAlphaFactorusSUN) #define GLEW_SUN_global_alpha GLEW_GET_VAR(__GLEW_SUN_global_alpha) #endif /* GL_SUN_global_alpha */ /* --------------------------- GL_SUN_mesh_array --------------------------- */ #ifndef GL_SUN_mesh_array #define GL_SUN_mesh_array 1 #define GL_QUAD_MESH_SUN 0x8614 #define GL_TRIANGLE_MESH_SUN 0x8615 #define GLEW_SUN_mesh_array GLEW_GET_VAR(__GLEW_SUN_mesh_array) #endif /* GL_SUN_mesh_array */ /* ------------------------ GL_SUN_read_video_pixels ----------------------- */ #ifndef GL_SUN_read_video_pixels #define GL_SUN_read_video_pixels 1 typedef void (GLAPIENTRY * PFNGLREADVIDEOPIXELSSUNPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels); #define glReadVideoPixelsSUN GLEW_GET_FUN(__glewReadVideoPixelsSUN) #define GLEW_SUN_read_video_pixels GLEW_GET_VAR(__GLEW_SUN_read_video_pixels) #endif /* GL_SUN_read_video_pixels */ /* --------------------------- GL_SUN_slice_accum -------------------------- */ #ifndef GL_SUN_slice_accum #define GL_SUN_slice_accum 1 #define GL_SLICE_ACCUM_SUN 0x85CC #define GLEW_SUN_slice_accum GLEW_GET_VAR(__GLEW_SUN_slice_accum) #endif /* GL_SUN_slice_accum */ /* -------------------------- GL_SUN_triangle_list ------------------------- */ #ifndef GL_SUN_triangle_list #define GL_SUN_triangle_list 1 #define GL_RESTART_SUN 0x01 #define GL_REPLACE_MIDDLE_SUN 0x02 #define GL_REPLACE_OLDEST_SUN 0x03 #define GL_TRIANGLE_LIST_SUN 0x81D7 #define GL_REPLACEMENT_CODE_SUN 0x81D8 #define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0 #define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1 #define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2 #define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3 #define GL_R1UI_V3F_SUN 0x85C4 #define GL_R1UI_C4UB_V3F_SUN 0x85C5 #define GL_R1UI_C3F_V3F_SUN 0x85C6 #define GL_R1UI_N3F_V3F_SUN 0x85C7 #define GL_R1UI_C4F_N3F_V3F_SUN 0x85C8 #define GL_R1UI_T2F_V3F_SUN 0x85C9 #define GL_R1UI_T2F_N3F_V3F_SUN 0x85CA #define GL_R1UI_T2F_C4F_N3F_V3F_SUN 0x85CB typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const void *pointer); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte* code); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint* code); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort* code); #define glReplacementCodePointerSUN GLEW_GET_FUN(__glewReplacementCodePointerSUN) #define glReplacementCodeubSUN GLEW_GET_FUN(__glewReplacementCodeubSUN) #define glReplacementCodeubvSUN GLEW_GET_FUN(__glewReplacementCodeubvSUN) #define glReplacementCodeuiSUN GLEW_GET_FUN(__glewReplacementCodeuiSUN) #define glReplacementCodeuivSUN GLEW_GET_FUN(__glewReplacementCodeuivSUN) #define glReplacementCodeusSUN GLEW_GET_FUN(__glewReplacementCodeusSUN) #define glReplacementCodeusvSUN GLEW_GET_FUN(__glewReplacementCodeusvSUN) #define GLEW_SUN_triangle_list GLEW_GET_VAR(__GLEW_SUN_triangle_list) #endif /* GL_SUN_triangle_list */ /* ----------------------------- GL_SUN_vertex ----------------------------- */ #ifndef GL_SUN_vertex #define GL_SUN_vertex 1 typedef void (GLAPIENTRY * PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat* c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* c, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y); typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte* c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte* c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint* rc, const GLubyte *c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat* tc, const GLubyte *c, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); typedef void (GLAPIENTRY * PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat* tc, const GLfloat *v); #define glColor3fVertex3fSUN GLEW_GET_FUN(__glewColor3fVertex3fSUN) #define glColor3fVertex3fvSUN GLEW_GET_FUN(__glewColor3fVertex3fvSUN) #define glColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewColor4fNormal3fVertex3fSUN) #define glColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewColor4fNormal3fVertex3fvSUN) #define glColor4ubVertex2fSUN GLEW_GET_FUN(__glewColor4ubVertex2fSUN) #define glColor4ubVertex2fvSUN GLEW_GET_FUN(__glewColor4ubVertex2fvSUN) #define glColor4ubVertex3fSUN GLEW_GET_FUN(__glewColor4ubVertex3fSUN) #define glColor4ubVertex3fvSUN GLEW_GET_FUN(__glewColor4ubVertex3fvSUN) #define glNormal3fVertex3fSUN GLEW_GET_FUN(__glewNormal3fVertex3fSUN) #define glNormal3fVertex3fvSUN GLEW_GET_FUN(__glewNormal3fVertex3fvSUN) #define glReplacementCodeuiColor3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor3fVertex3fSUN) #define glReplacementCodeuiColor3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor3fVertex3fvSUN) #define glReplacementCodeuiColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4fNormal3fVertex3fSUN) #define glReplacementCodeuiColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4fNormal3fVertex3fvSUN) #define glReplacementCodeuiColor4ubVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4ubVertex3fSUN) #define glReplacementCodeuiColor4ubVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4ubVertex3fvSUN) #define glReplacementCodeuiNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiNormal3fVertex3fSUN) #define glReplacementCodeuiNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiNormal3fVertex3fvSUN) #define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) #define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) #define glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) #define glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) #define glReplacementCodeuiTexCoord2fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fVertex3fSUN) #define glReplacementCodeuiTexCoord2fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fVertex3fvSUN) #define glReplacementCodeuiVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiVertex3fSUN) #define glReplacementCodeuiVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiVertex3fvSUN) #define glTexCoord2fColor3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor3fVertex3fSUN) #define glTexCoord2fColor3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor3fVertex3fvSUN) #define glTexCoord2fColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor4fNormal3fVertex3fSUN) #define glTexCoord2fColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor4fNormal3fVertex3fvSUN) #define glTexCoord2fColor4ubVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor4ubVertex3fSUN) #define glTexCoord2fColor4ubVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor4ubVertex3fvSUN) #define glTexCoord2fNormal3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fNormal3fVertex3fSUN) #define glTexCoord2fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fNormal3fVertex3fvSUN) #define glTexCoord2fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fVertex3fSUN) #define glTexCoord2fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fVertex3fvSUN) #define glTexCoord4fColor4fNormal3fVertex4fSUN GLEW_GET_FUN(__glewTexCoord4fColor4fNormal3fVertex4fSUN) #define glTexCoord4fColor4fNormal3fVertex4fvSUN GLEW_GET_FUN(__glewTexCoord4fColor4fNormal3fVertex4fvSUN) #define glTexCoord4fVertex4fSUN GLEW_GET_FUN(__glewTexCoord4fVertex4fSUN) #define glTexCoord4fVertex4fvSUN GLEW_GET_FUN(__glewTexCoord4fVertex4fvSUN) #define GLEW_SUN_vertex GLEW_GET_VAR(__GLEW_SUN_vertex) #endif /* GL_SUN_vertex */ /* -------------------------- GL_WIN_phong_shading ------------------------- */ #ifndef GL_WIN_phong_shading #define GL_WIN_phong_shading 1 #define GL_PHONG_WIN 0x80EA #define GL_PHONG_HINT_WIN 0x80EB #define GLEW_WIN_phong_shading GLEW_GET_VAR(__GLEW_WIN_phong_shading) #endif /* GL_WIN_phong_shading */ /* -------------------------- GL_WIN_specular_fog -------------------------- */ #ifndef GL_WIN_specular_fog #define GL_WIN_specular_fog 1 #define GL_FOG_SPECULAR_TEXTURE_WIN 0x80EC #define GLEW_WIN_specular_fog GLEW_GET_VAR(__GLEW_WIN_specular_fog) #endif /* GL_WIN_specular_fog */ /* ---------------------------- GL_WIN_swap_hint --------------------------- */ #ifndef GL_WIN_swap_hint #define GL_WIN_swap_hint 1 typedef void (GLAPIENTRY * PFNGLADDSWAPHINTRECTWINPROC) (GLint x, GLint y, GLsizei width, GLsizei height); #define glAddSwapHintRectWIN GLEW_GET_FUN(__glewAddSwapHintRectWIN) #define GLEW_WIN_swap_hint GLEW_GET_VAR(__GLEW_WIN_swap_hint) #endif /* GL_WIN_swap_hint */ /* ------------------------------------------------------------------------- */ #if defined(GLEW_MX) && defined(_WIN32) #define GLEW_FUN_EXPORT #else #define GLEW_FUN_EXPORT GLEWAPI #endif /* GLEW_MX */ #if defined(GLEW_MX) #define GLEW_VAR_EXPORT #else #define GLEW_VAR_EXPORT GLEWAPI #endif /* GLEW_MX */ #if defined(GLEW_MX) && defined(_WIN32) struct GLEWContextStruct { #endif /* GLEW_MX */ GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements; GLEW_FUN_EXPORT PFNGLTEXIMAGE3DPROC __glewTexImage3D; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D; GLEW_FUN_EXPORT PFNGLACTIVETEXTUREPROC __glewActiveTexture; GLEW_FUN_EXPORT PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D; GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage; GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd; GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf; GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd; GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv; GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage; GLEW_FUN_EXPORT PFNGLBLENDCOLORPROC __glewBlendColor; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONPROC __glewBlendEquation; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate; GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer; GLEW_FUN_EXPORT PFNGLFOGCOORDDPROC __glewFogCoordd; GLEW_FUN_EXPORT PFNGLFOGCOORDDVPROC __glewFogCoorddv; GLEW_FUN_EXPORT PFNGLFOGCOORDFPROC __glewFogCoordf; GLEW_FUN_EXPORT PFNGLFOGCOORDFVPROC __glewFogCoordfv; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFPROC __glewPointParameterf; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIPROC __glewPointParameteri; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer; GLEW_FUN_EXPORT PFNGLWINDOWPOS2DPROC __glewWindowPos2d; GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv; GLEW_FUN_EXPORT PFNGLWINDOWPOS2FPROC __glewWindowPos2f; GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv; GLEW_FUN_EXPORT PFNGLWINDOWPOS2IPROC __glewWindowPos2i; GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv; GLEW_FUN_EXPORT PFNGLWINDOWPOS2SPROC __glewWindowPos2s; GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv; GLEW_FUN_EXPORT PFNGLWINDOWPOS3DPROC __glewWindowPos3d; GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv; GLEW_FUN_EXPORT PFNGLWINDOWPOS3FPROC __glewWindowPos3f; GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv; GLEW_FUN_EXPORT PFNGLWINDOWPOS3IPROC __glewWindowPos3i; GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SPROC __glewWindowPos3s; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv; GLEW_FUN_EXPORT PFNGLBEGINQUERYPROC __glewBeginQuery; GLEW_FUN_EXPORT PFNGLBINDBUFFERPROC __glewBindBuffer; GLEW_FUN_EXPORT PFNGLBUFFERDATAPROC __glewBufferData; GLEW_FUN_EXPORT PFNGLBUFFERSUBDATAPROC __glewBufferSubData; GLEW_FUN_EXPORT PFNGLDELETEBUFFERSPROC __glewDeleteBuffers; GLEW_FUN_EXPORT PFNGLDELETEQUERIESPROC __glewDeleteQueries; GLEW_FUN_EXPORT PFNGLENDQUERYPROC __glewEndQuery; GLEW_FUN_EXPORT PFNGLGENBUFFERSPROC __glewGenBuffers; GLEW_FUN_EXPORT PFNGLGENQUERIESPROC __glewGenQueries; GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv; GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv; GLEW_FUN_EXPORT PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv; GLEW_FUN_EXPORT PFNGLGETQUERYIVPROC __glewGetQueryiv; GLEW_FUN_EXPORT PFNGLISBUFFERPROC __glewIsBuffer; GLEW_FUN_EXPORT PFNGLISQUERYPROC __glewIsQuery; GLEW_FUN_EXPORT PFNGLMAPBUFFERPROC __glewMapBuffer; GLEW_FUN_EXPORT PFNGLUNMAPBUFFERPROC __glewUnmapBuffer; GLEW_FUN_EXPORT PFNGLATTACHSHADERPROC __glewAttachShader; GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate; GLEW_FUN_EXPORT PFNGLCOMPILESHADERPROC __glewCompileShader; GLEW_FUN_EXPORT PFNGLCREATEPROGRAMPROC __glewCreateProgram; GLEW_FUN_EXPORT PFNGLCREATESHADERPROC __glewCreateShader; GLEW_FUN_EXPORT PFNGLDELETEPROGRAMPROC __glewDeleteProgram; GLEW_FUN_EXPORT PFNGLDELETESHADERPROC __glewDeleteShader; GLEW_FUN_EXPORT PFNGLDETACHSHADERPROC __glewDetachShader; GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray; GLEW_FUN_EXPORT PFNGLDRAWBUFFERSPROC __glewDrawBuffers; GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray; GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib; GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform; GLEW_FUN_EXPORT PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders; GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation; GLEW_FUN_EXPORT PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog; GLEW_FUN_EXPORT PFNGLGETPROGRAMIVPROC __glewGetProgramiv; GLEW_FUN_EXPORT PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog; GLEW_FUN_EXPORT PFNGLGETSHADERSOURCEPROC __glewGetShaderSource; GLEW_FUN_EXPORT PFNGLGETSHADERIVPROC __glewGetShaderiv; GLEW_FUN_EXPORT PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation; GLEW_FUN_EXPORT PFNGLGETUNIFORMFVPROC __glewGetUniformfv; GLEW_FUN_EXPORT PFNGLGETUNIFORMIVPROC __glewGetUniformiv; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv; GLEW_FUN_EXPORT PFNGLISPROGRAMPROC __glewIsProgram; GLEW_FUN_EXPORT PFNGLISSHADERPROC __glewIsShader; GLEW_FUN_EXPORT PFNGLLINKPROGRAMPROC __glewLinkProgram; GLEW_FUN_EXPORT PFNGLSHADERSOURCEPROC __glewShaderSource; GLEW_FUN_EXPORT PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate; GLEW_FUN_EXPORT PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate; GLEW_FUN_EXPORT PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate; GLEW_FUN_EXPORT PFNGLUNIFORM1FPROC __glewUniform1f; GLEW_FUN_EXPORT PFNGLUNIFORM1FVPROC __glewUniform1fv; GLEW_FUN_EXPORT PFNGLUNIFORM1IPROC __glewUniform1i; GLEW_FUN_EXPORT PFNGLUNIFORM1IVPROC __glewUniform1iv; GLEW_FUN_EXPORT PFNGLUNIFORM2FPROC __glewUniform2f; GLEW_FUN_EXPORT PFNGLUNIFORM2FVPROC __glewUniform2fv; GLEW_FUN_EXPORT PFNGLUNIFORM2IPROC __glewUniform2i; GLEW_FUN_EXPORT PFNGLUNIFORM2IVPROC __glewUniform2iv; GLEW_FUN_EXPORT PFNGLUNIFORM3FPROC __glewUniform3f; GLEW_FUN_EXPORT PFNGLUNIFORM3FVPROC __glewUniform3fv; GLEW_FUN_EXPORT PFNGLUNIFORM3IPROC __glewUniform3i; GLEW_FUN_EXPORT PFNGLUNIFORM3IVPROC __glewUniform3iv; GLEW_FUN_EXPORT PFNGLUNIFORM4FPROC __glewUniform4f; GLEW_FUN_EXPORT PFNGLUNIFORM4FVPROC __glewUniform4fv; GLEW_FUN_EXPORT PFNGLUNIFORM4IPROC __glewUniform4i; GLEW_FUN_EXPORT PFNGLUNIFORM4IVPROC __glewUniform4iv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv; GLEW_FUN_EXPORT PFNGLUSEPROGRAMPROC __glewUseProgram; GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMPROC __glewValidateProgram; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv; GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender; GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback; GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation; GLEW_FUN_EXPORT PFNGLCLAMPCOLORPROC __glewClampColor; GLEW_FUN_EXPORT PFNGLCLEARBUFFERFIPROC __glewClearBufferfi; GLEW_FUN_EXPORT PFNGLCLEARBUFFERFVPROC __glewClearBufferfv; GLEW_FUN_EXPORT PFNGLCLEARBUFFERIVPROC __glewClearBufferiv; GLEW_FUN_EXPORT PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv; GLEW_FUN_EXPORT PFNGLCOLORMASKIPROC __glewColorMaski; GLEW_FUN_EXPORT PFNGLDISABLEIPROC __glewDisablei; GLEW_FUN_EXPORT PFNGLENABLEIPROC __glewEnablei; GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender; GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback; GLEW_FUN_EXPORT PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v; GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation; GLEW_FUN_EXPORT PFNGLGETSTRINGIPROC __glewGetStringi; GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv; GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv; GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying; GLEW_FUN_EXPORT PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv; GLEW_FUN_EXPORT PFNGLISENABLEDIPROC __glewIsEnabledi; GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv; GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv; GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings; GLEW_FUN_EXPORT PFNGLUNIFORM1UIPROC __glewUniform1ui; GLEW_FUN_EXPORT PFNGLUNIFORM1UIVPROC __glewUniform1uiv; GLEW_FUN_EXPORT PFNGLUNIFORM2UIPROC __glewUniform2ui; GLEW_FUN_EXPORT PFNGLUNIFORM2UIVPROC __glewUniform2uiv; GLEW_FUN_EXPORT PFNGLUNIFORM3UIPROC __glewUniform3ui; GLEW_FUN_EXPORT PFNGLUNIFORM3UIVPROC __glewUniform3uiv; GLEW_FUN_EXPORT PFNGLUNIFORM4UIPROC __glewUniform4ui; GLEW_FUN_EXPORT PFNGLUNIFORM4UIVPROC __glewUniform4uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer; GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced; GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex; GLEW_FUN_EXPORT PFNGLTEXBUFFERPROC __glewTexBuffer; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture; GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v; GLEW_FUN_EXPORT PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIPROC __glewBlendEquationi; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei; GLEW_FUN_EXPORT PFNGLBLENDFUNCIPROC __glewBlendFunci; GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading; GLEW_FUN_EXPORT PFNGLGETGRAPHICSRESETSTATUSPROC __glewGetGraphicsResetStatus; GLEW_FUN_EXPORT PFNGLGETNCOMPRESSEDTEXIMAGEPROC __glewGetnCompressedTexImage; GLEW_FUN_EXPORT PFNGLGETNTEXIMAGEPROC __glewGetnTexImage; GLEW_FUN_EXPORT PFNGLGETNUNIFORMDVPROC __glewGetnUniformdv; GLEW_FUN_EXPORT PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD; GLEW_FUN_EXPORT PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD; GLEW_FUN_EXPORT PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPARAMETERIAMDPROC __glewVertexAttribParameteriAMD; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD; GLEW_FUN_EXPORT PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD; GLEW_FUN_EXPORT PFNGLGENNAMESAMDPROC __glewGenNamesAMD; GLEW_FUN_EXPORT PFNGLISNAMEAMDPROC __glewIsNameAMD; GLEW_FUN_EXPORT PFNGLQUERYOBJECTPARAMETERUIAMDPROC __glewQueryObjectParameteruiAMD; GLEW_FUN_EXPORT PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD; GLEW_FUN_EXPORT PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD; GLEW_FUN_EXPORT PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD; GLEW_FUN_EXPORT PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD; GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD; GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD; GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD; GLEW_FUN_EXPORT PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD; GLEW_FUN_EXPORT PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD; GLEW_FUN_EXPORT PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD; GLEW_FUN_EXPORT PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD; GLEW_FUN_EXPORT PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD; GLEW_FUN_EXPORT PFNGLTEXSTORAGESPARSEAMDPROC __glewTexStorageSparseAMD; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGESPARSEAMDPROC __glewTextureStorageSparseAMD; GLEW_FUN_EXPORT PFNGLSTENCILOPVALUEAMDPROC __glewStencilOpValueAMD; GLEW_FUN_EXPORT PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD; GLEW_FUN_EXPORT PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD; GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERANGLEPROC __glewBlitFramebufferANGLE; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC __glewRenderbufferStorageMultisampleANGLE; GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDANGLEPROC __glewDrawArraysInstancedANGLE; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDANGLEPROC __glewDrawElementsInstancedANGLE; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORANGLEPROC __glewVertexAttribDivisorANGLE; GLEW_FUN_EXPORT PFNGLBEGINQUERYANGLEPROC __glewBeginQueryANGLE; GLEW_FUN_EXPORT PFNGLDELETEQUERIESANGLEPROC __glewDeleteQueriesANGLE; GLEW_FUN_EXPORT PFNGLENDQUERYANGLEPROC __glewEndQueryANGLE; GLEW_FUN_EXPORT PFNGLGENQUERIESANGLEPROC __glewGenQueriesANGLE; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VANGLEPROC __glewGetQueryObjecti64vANGLE; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVANGLEPROC __glewGetQueryObjectivANGLE; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VANGLEPROC __glewGetQueryObjectui64vANGLE; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVANGLEPROC __glewGetQueryObjectuivANGLE; GLEW_FUN_EXPORT PFNGLGETQUERYIVANGLEPROC __glewGetQueryivANGLE; GLEW_FUN_EXPORT PFNGLISQUERYANGLEPROC __glewIsQueryANGLE; GLEW_FUN_EXPORT PFNGLQUERYCOUNTERANGLEPROC __glewQueryCounterANGLE; GLEW_FUN_EXPORT PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC __glewGetTranslatedShaderSourceANGLE; GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE; GLEW_FUN_EXPORT PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE; GLEW_FUN_EXPORT PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE; GLEW_FUN_EXPORT PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE; GLEW_FUN_EXPORT PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE; GLEW_FUN_EXPORT PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE; GLEW_FUN_EXPORT PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE; GLEW_FUN_EXPORT PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE; GLEW_FUN_EXPORT PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE; GLEW_FUN_EXPORT PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE; GLEW_FUN_EXPORT PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE; GLEW_FUN_EXPORT PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE; GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE; GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE; GLEW_FUN_EXPORT PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE; GLEW_FUN_EXPORT PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE; GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE; GLEW_FUN_EXPORT PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE; GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE; GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE; GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE; GLEW_FUN_EXPORT PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE; GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE; GLEW_FUN_EXPORT PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE; GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE; GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE; GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE; GLEW_FUN_EXPORT PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE; GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE; GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE; GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE; GLEW_FUN_EXPORT PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE; GLEW_FUN_EXPORT PFNGLCLEARDEPTHFPROC __glewClearDepthf; GLEW_FUN_EXPORT PFNGLDEPTHRANGEFPROC __glewDepthRangef; GLEW_FUN_EXPORT PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat; GLEW_FUN_EXPORT PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler; GLEW_FUN_EXPORT PFNGLSHADERBINARYPROC __glewShaderBinary; GLEW_FUN_EXPORT PFNGLMEMORYBARRIERBYREGIONPROC __glewMemoryBarrierByRegion; GLEW_FUN_EXPORT PFNGLPRIMITIVEBOUNDINGBOXARBPROC __glewPrimitiveBoundingBoxARB; GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance; GLEW_FUN_EXPORT PFNGLGETIMAGEHANDLEARBPROC __glewGetImageHandleARB; GLEW_FUN_EXPORT PFNGLGETTEXTUREHANDLEARBPROC __glewGetTextureHandleARB; GLEW_FUN_EXPORT PFNGLGETTEXTURESAMPLERHANDLEARBPROC __glewGetTextureSamplerHandleARB; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLUI64VARBPROC __glewGetVertexAttribLui64vARB; GLEW_FUN_EXPORT PFNGLISIMAGEHANDLERESIDENTARBPROC __glewIsImageHandleResidentARB; GLEW_FUN_EXPORT PFNGLISTEXTUREHANDLERESIDENTARBPROC __glewIsTextureHandleResidentARB; GLEW_FUN_EXPORT PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC __glewMakeImageHandleNonResidentARB; GLEW_FUN_EXPORT PFNGLMAKEIMAGEHANDLERESIDENTARBPROC __glewMakeImageHandleResidentARB; GLEW_FUN_EXPORT PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC __glewMakeTextureHandleNonResidentARB; GLEW_FUN_EXPORT PFNGLMAKETEXTUREHANDLERESIDENTARBPROC __glewMakeTextureHandleResidentARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC __glewProgramUniformHandleui64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC __glewProgramUniformHandleui64vARB; GLEW_FUN_EXPORT PFNGLUNIFORMHANDLEUI64ARBPROC __glewUniformHandleui64ARB; GLEW_FUN_EXPORT PFNGLUNIFORMHANDLEUI64VARBPROC __glewUniformHandleui64vARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64ARBPROC __glewVertexAttribL1ui64ARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64VARBPROC __glewVertexAttribL1ui64vARB; GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed; GLEW_FUN_EXPORT PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex; GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEPROC __glewBufferStorage; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT; GLEW_FUN_EXPORT PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB; GLEW_FUN_EXPORT PFNGLCLEARBUFFERDATAPROC __glewClearBufferData; GLEW_FUN_EXPORT PFNGLCLEARBUFFERSUBDATAPROC __glewClearBufferSubData; GLEW_FUN_EXPORT PFNGLCLEARNAMEDBUFFERDATAEXTPROC __glewClearNamedBufferDataEXT; GLEW_FUN_EXPORT PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC __glewClearNamedBufferSubDataEXT; GLEW_FUN_EXPORT PFNGLCLEARTEXIMAGEPROC __glewClearTexImage; GLEW_FUN_EXPORT PFNGLCLEARTEXSUBIMAGEPROC __glewClearTexSubImage; GLEW_FUN_EXPORT PFNGLCLIPCONTROLPROC __glewClipControl; GLEW_FUN_EXPORT PFNGLCLAMPCOLORARBPROC __glewClampColorARB; GLEW_FUN_EXPORT PFNGLDISPATCHCOMPUTEPROC __glewDispatchCompute; GLEW_FUN_EXPORT PFNGLDISPATCHCOMPUTEINDIRECTPROC __glewDispatchComputeIndirect; GLEW_FUN_EXPORT PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC __glewDispatchComputeGroupSizeARB; GLEW_FUN_EXPORT PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData; GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATAPROC __glewCopyImageSubData; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB; GLEW_FUN_EXPORT PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB; GLEW_FUN_EXPORT PFNGLBINDTEXTUREUNITPROC __glewBindTextureUnit; GLEW_FUN_EXPORT PFNGLBLITNAMEDFRAMEBUFFERPROC __glewBlitNamedFramebuffer; GLEW_FUN_EXPORT PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC __glewCheckNamedFramebufferStatus; GLEW_FUN_EXPORT PFNGLCLEARNAMEDBUFFERDATAPROC __glewClearNamedBufferData; GLEW_FUN_EXPORT PFNGLCLEARNAMEDBUFFERSUBDATAPROC __glewClearNamedBufferSubData; GLEW_FUN_EXPORT PFNGLCLEARNAMEDFRAMEBUFFERFIPROC __glewClearNamedFramebufferfi; GLEW_FUN_EXPORT PFNGLCLEARNAMEDFRAMEBUFFERFVPROC __glewClearNamedFramebufferfv; GLEW_FUN_EXPORT PFNGLCLEARNAMEDFRAMEBUFFERIVPROC __glewClearNamedFramebufferiv; GLEW_FUN_EXPORT PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC __glewClearNamedFramebufferuiv; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC __glewCompressedTextureSubImage1D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC __glewCompressedTextureSubImage2D; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC __glewCompressedTextureSubImage3D; GLEW_FUN_EXPORT PFNGLCOPYNAMEDBUFFERSUBDATAPROC __glewCopyNamedBufferSubData; GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE1DPROC __glewCopyTextureSubImage1D; GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE2DPROC __glewCopyTextureSubImage2D; GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE3DPROC __glewCopyTextureSubImage3D; GLEW_FUN_EXPORT PFNGLCREATEBUFFERSPROC __glewCreateBuffers; GLEW_FUN_EXPORT PFNGLCREATEFRAMEBUFFERSPROC __glewCreateFramebuffers; GLEW_FUN_EXPORT PFNGLCREATEPROGRAMPIPELINESPROC __glewCreateProgramPipelines; GLEW_FUN_EXPORT PFNGLCREATEQUERIESPROC __glewCreateQueries; GLEW_FUN_EXPORT PFNGLCREATERENDERBUFFERSPROC __glewCreateRenderbuffers; GLEW_FUN_EXPORT PFNGLCREATESAMPLERSPROC __glewCreateSamplers; GLEW_FUN_EXPORT PFNGLCREATETEXTURESPROC __glewCreateTextures; GLEW_FUN_EXPORT PFNGLCREATETRANSFORMFEEDBACKSPROC __glewCreateTransformFeedbacks; GLEW_FUN_EXPORT PFNGLCREATEVERTEXARRAYSPROC __glewCreateVertexArrays; GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYATTRIBPROC __glewDisableVertexArrayAttrib; GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYATTRIBPROC __glewEnableVertexArrayAttrib; GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC __glewFlushMappedNamedBufferRange; GLEW_FUN_EXPORT PFNGLGENERATETEXTUREMIPMAPPROC __glewGenerateTextureMipmap; GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC __glewGetCompressedTextureImage; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERI64VPROC __glewGetNamedBufferParameteri64v; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERIVPROC __glewGetNamedBufferParameteriv; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPOINTERVPROC __glewGetNamedBufferPointerv; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERSUBDATAPROC __glewGetNamedBufferSubData; GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetNamedFramebufferAttachmentParameteriv; GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC __glewGetNamedFramebufferParameteriv; GLEW_FUN_EXPORT PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC __glewGetNamedRenderbufferParameteriv; GLEW_FUN_EXPORT PFNGLGETQUERYBUFFEROBJECTI64VPROC __glewGetQueryBufferObjecti64v; GLEW_FUN_EXPORT PFNGLGETQUERYBUFFEROBJECTIVPROC __glewGetQueryBufferObjectiv; GLEW_FUN_EXPORT PFNGLGETQUERYBUFFEROBJECTUI64VPROC __glewGetQueryBufferObjectui64v; GLEW_FUN_EXPORT PFNGLGETQUERYBUFFEROBJECTUIVPROC __glewGetQueryBufferObjectuiv; GLEW_FUN_EXPORT PFNGLGETTEXTUREIMAGEPROC __glewGetTextureImage; GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERFVPROC __glewGetTextureLevelParameterfv; GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERIVPROC __glewGetTextureLevelParameteriv; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIIVPROC __glewGetTextureParameterIiv; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIUIVPROC __glewGetTextureParameterIuiv; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERFVPROC __glewGetTextureParameterfv; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIVPROC __glewGetTextureParameteriv; GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKI64_VPROC __glewGetTransformFeedbacki64_v; GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKI_VPROC __glewGetTransformFeedbacki_v; GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKIVPROC __glewGetTransformFeedbackiv; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINDEXED64IVPROC __glewGetVertexArrayIndexed64iv; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINDEXEDIVPROC __glewGetVertexArrayIndexediv; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYIVPROC __glewGetVertexArrayiv; GLEW_FUN_EXPORT PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC __glewInvalidateNamedFramebufferData; GLEW_FUN_EXPORT PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC __glewInvalidateNamedFramebufferSubData; GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFERPROC __glewMapNamedBuffer; GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFERRANGEPROC __glewMapNamedBufferRange; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERDATAPROC __glewNamedBufferData; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEPROC __glewNamedBufferStorage; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSUBDATAPROC __glewNamedBufferSubData; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC __glewNamedFramebufferDrawBuffer; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC __glewNamedFramebufferDrawBuffers; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC __glewNamedFramebufferParameteri; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC __glewNamedFramebufferReadBuffer; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC __glewNamedFramebufferRenderbuffer; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREPROC __glewNamedFramebufferTexture; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC __glewNamedFramebufferTextureLayer; GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEPROC __glewNamedRenderbufferStorage; GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewNamedRenderbufferStorageMultisample; GLEW_FUN_EXPORT PFNGLTEXTUREBUFFERPROC __glewTextureBuffer; GLEW_FUN_EXPORT PFNGLTEXTUREBUFFERRANGEPROC __glewTextureBufferRange; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIIVPROC __glewTextureParameterIiv; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIUIVPROC __glewTextureParameterIuiv; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFPROC __glewTextureParameterf; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFVPROC __glewTextureParameterfv; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIPROC __glewTextureParameteri; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIVPROC __glewTextureParameteriv; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DPROC __glewTextureStorage1D; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DPROC __glewTextureStorage2D; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC __glewTextureStorage2DMultisample; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DPROC __glewTextureStorage3D; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC __glewTextureStorage3DMultisample; GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE1DPROC __glewTextureSubImage1D; GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE2DPROC __glewTextureSubImage2D; GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE3DPROC __glewTextureSubImage3D; GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC __glewTransformFeedbackBufferBase; GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC __glewTransformFeedbackBufferRange; GLEW_FUN_EXPORT PFNGLUNMAPNAMEDBUFFERPROC __glewUnmapNamedBuffer; GLEW_FUN_EXPORT PFNGLVERTEXARRAYATTRIBBINDINGPROC __glewVertexArrayAttribBinding; GLEW_FUN_EXPORT PFNGLVERTEXARRAYATTRIBFORMATPROC __glewVertexArrayAttribFormat; GLEW_FUN_EXPORT PFNGLVERTEXARRAYATTRIBIFORMATPROC __glewVertexArrayAttribIFormat; GLEW_FUN_EXPORT PFNGLVERTEXARRAYATTRIBLFORMATPROC __glewVertexArrayAttribLFormat; GLEW_FUN_EXPORT PFNGLVERTEXARRAYBINDINGDIVISORPROC __glewVertexArrayBindingDivisor; GLEW_FUN_EXPORT PFNGLVERTEXARRAYELEMENTBUFFERPROC __glewVertexArrayElementBuffer; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXBUFFERPROC __glewVertexArrayVertexBuffer; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXBUFFERSPROC __glewVertexArrayVertexBuffers; GLEW_FUN_EXPORT PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB; GLEW_FUN_EXPORT PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex; GLEW_FUN_EXPORT PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERPARAMETERIPROC __glewFramebufferParameteri; GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERIVPROC __glewGetFramebufferParameteriv; GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC __glewGetNamedFramebufferParameterivEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC __glewNamedFramebufferParameteriEXT; GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer; GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer; GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer; GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus; GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers; GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer; GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers; GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers; GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap; GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv; GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv; GLEW_FUN_EXPORT PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer; GLEW_FUN_EXPORT PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary; GLEW_FUN_EXPORT PFNGLPROGRAMBINARYPROC __glewProgramBinary; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri; GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC __glewGetCompressedTextureSubImage; GLEW_FUN_EXPORT PFNGLGETTEXTURESUBIMAGEPROC __glewGetTextureSubImage; GLEW_FUN_EXPORT PFNGLGETUNIFORMDVPROC __glewGetUniformdv; GLEW_FUN_EXPORT PFNGLUNIFORM1DPROC __glewUniform1d; GLEW_FUN_EXPORT PFNGLUNIFORM1DVPROC __glewUniform1dv; GLEW_FUN_EXPORT PFNGLUNIFORM2DPROC __glewUniform2d; GLEW_FUN_EXPORT PFNGLUNIFORM2DVPROC __glewUniform2dv; GLEW_FUN_EXPORT PFNGLUNIFORM3DPROC __glewUniform3d; GLEW_FUN_EXPORT PFNGLUNIFORM3DVPROC __glewUniform3dv; GLEW_FUN_EXPORT PFNGLUNIFORM4DPROC __glewUniform4d; GLEW_FUN_EXPORT PFNGLUNIFORM4DVPROC __glewUniform4dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv; GLEW_FUN_EXPORT PFNGLGETUNIFORMI64VARBPROC __glewGetUniformi64vARB; GLEW_FUN_EXPORT PFNGLGETUNIFORMUI64VARBPROC __glewGetUniformui64vARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMI64VARBPROC __glewGetnUniformi64vARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMUI64VARBPROC __glewGetnUniformui64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64ARBPROC __glewProgramUniform1i64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64VARBPROC __glewProgramUniform1i64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64ARBPROC __glewProgramUniform1ui64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64VARBPROC __glewProgramUniform1ui64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64ARBPROC __glewProgramUniform2i64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64VARBPROC __glewProgramUniform2i64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64ARBPROC __glewProgramUniform2ui64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64VARBPROC __glewProgramUniform2ui64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64ARBPROC __glewProgramUniform3i64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64VARBPROC __glewProgramUniform3i64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64ARBPROC __glewProgramUniform3ui64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64VARBPROC __glewProgramUniform3ui64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64ARBPROC __glewProgramUniform4i64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64VARBPROC __glewProgramUniform4i64vARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64ARBPROC __glewProgramUniform4ui64ARB; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64VARBPROC __glewProgramUniform4ui64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM1I64ARBPROC __glewUniform1i64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM1I64VARBPROC __glewUniform1i64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM1UI64ARBPROC __glewUniform1ui64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM1UI64VARBPROC __glewUniform1ui64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM2I64ARBPROC __glewUniform2i64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM2I64VARBPROC __glewUniform2i64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM2UI64ARBPROC __glewUniform2ui64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM2UI64VARBPROC __glewUniform2ui64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM3I64ARBPROC __glewUniform3i64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM3I64VARBPROC __glewUniform3i64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM3UI64ARBPROC __glewUniform3ui64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM3UI64VARBPROC __glewUniform3ui64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM4I64ARBPROC __glewUniform4i64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM4I64VARBPROC __glewUniform4i64vARB; GLEW_FUN_EXPORT PFNGLUNIFORM4UI64ARBPROC __glewUniform4ui64ARB; GLEW_FUN_EXPORT PFNGLUNIFORM4UI64VARBPROC __glewUniform4ui64vARB; GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEPROC __glewColorSubTable; GLEW_FUN_EXPORT PFNGLCOLORTABLEPROC __glewColorTable; GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv; GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv; GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D; GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv; GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable; GLEW_FUN_EXPORT PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable; GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D; GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPROC __glewGetColorTable; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv; GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter; GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv; GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv; GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPROC __glewGetHistogram; GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv; GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv; GLEW_FUN_EXPORT PFNGLGETMINMAXPROC __glewGetMinmax; GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv; GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv; GLEW_FUN_EXPORT PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter; GLEW_FUN_EXPORT PFNGLHISTOGRAMPROC __glewHistogram; GLEW_FUN_EXPORT PFNGLMINMAXPROC __glewMinmax; GLEW_FUN_EXPORT PFNGLRESETHISTOGRAMPROC __glewResetHistogram; GLEW_FUN_EXPORT PFNGLRESETMINMAXPROC __glewResetMinmax; GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC __glewMultiDrawArraysIndirectCountARB; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC __glewMultiDrawElementsIndirectCountARB; GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB; GLEW_FUN_EXPORT PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ; GLEW_FUN_EXPORT PFNGLGETINTERNALFORMATI64VPROC __glewGetInternalformati64v; GLEW_FUN_EXPORT PFNGLINVALIDATEBUFFERDATAPROC __glewInvalidateBufferData; GLEW_FUN_EXPORT PFNGLINVALIDATEBUFFERSUBDATAPROC __glewInvalidateBufferSubData; GLEW_FUN_EXPORT PFNGLINVALIDATEFRAMEBUFFERPROC __glewInvalidateFramebuffer; GLEW_FUN_EXPORT PFNGLINVALIDATESUBFRAMEBUFFERPROC __glewInvalidateSubFramebuffer; GLEW_FUN_EXPORT PFNGLINVALIDATETEXIMAGEPROC __glewInvalidateTexImage; GLEW_FUN_EXPORT PFNGLINVALIDATETEXSUBIMAGEPROC __glewInvalidateTexSubImage; GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange; GLEW_FUN_EXPORT PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange; GLEW_FUN_EXPORT PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB; GLEW_FUN_EXPORT PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB; GLEW_FUN_EXPORT PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB; GLEW_FUN_EXPORT PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB; GLEW_FUN_EXPORT PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB; GLEW_FUN_EXPORT PFNGLBINDBUFFERSBASEPROC __glewBindBuffersBase; GLEW_FUN_EXPORT PFNGLBINDBUFFERSRANGEPROC __glewBindBuffersRange; GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTURESPROC __glewBindImageTextures; GLEW_FUN_EXPORT PFNGLBINDSAMPLERSPROC __glewBindSamplers; GLEW_FUN_EXPORT PFNGLBINDTEXTURESPROC __glewBindTextures; GLEW_FUN_EXPORT PFNGLBINDVERTEXBUFFERSPROC __glewBindVertexBuffers; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTPROC __glewMultiDrawArraysIndirect; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTPROC __glewMultiDrawElementsIndirect; GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB; GLEW_FUN_EXPORT PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB; GLEW_FUN_EXPORT PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB; GLEW_FUN_EXPORT PFNGLBEGINQUERYARBPROC __glewBeginQueryARB; GLEW_FUN_EXPORT PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB; GLEW_FUN_EXPORT PFNGLENDQUERYARBPROC __glewEndQueryARB; GLEW_FUN_EXPORT PFNGLGENQUERIESARBPROC __glewGenQueriesARB; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB; GLEW_FUN_EXPORT PFNGLGETQUERYIVARBPROC __glewGetQueryivARB; GLEW_FUN_EXPORT PFNGLISQUERYARBPROC __glewIsQueryARB; GLEW_FUN_EXPORT PFNGLMAXSHADERCOMPILERTHREADSARBPROC __glewMaxShaderCompilerThreadsARB; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC __glewGetProgramResourceLocationIndex; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCENAMEPROC __glewGetProgramResourceName; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCEIVPROC __glewGetProgramResourceiv; GLEW_FUN_EXPORT PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex; GLEW_FUN_EXPORT PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB; GLEW_FUN_EXPORT PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB; GLEW_FUN_EXPORT PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB; GLEW_FUN_EXPORT PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB; GLEW_FUN_EXPORT PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB; GLEW_FUN_EXPORT PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB; GLEW_FUN_EXPORT PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB; GLEW_FUN_EXPORT PFNGLGETNMAPIVARBPROC __glewGetnMapivARB; GLEW_FUN_EXPORT PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB; GLEW_FUN_EXPORT PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB; GLEW_FUN_EXPORT PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB; GLEW_FUN_EXPORT PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB; GLEW_FUN_EXPORT PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB; GLEW_FUN_EXPORT PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB; GLEW_FUN_EXPORT PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB; GLEW_FUN_EXPORT PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB; GLEW_FUN_EXPORT PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB; GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB; GLEW_FUN_EXPORT PFNGLBINDSAMPLERPROC __glewBindSampler; GLEW_FUN_EXPORT PFNGLDELETESAMPLERSPROC __glewDeleteSamplers; GLEW_FUN_EXPORT PFNGLGENSAMPLERSPROC __glewGenSamplers; GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv; GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv; GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv; GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv; GLEW_FUN_EXPORT PFNGLISSAMPLERPROC __glewIsSampler; GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv; GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv; GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf; GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv; GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri; GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv; GLEW_FUN_EXPORT PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram; GLEW_FUN_EXPORT PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline; GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv; GLEW_FUN_EXPORT PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines; GLEW_FUN_EXPORT PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines; GLEW_FUN_EXPORT PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog; GLEW_FUN_EXPORT PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv; GLEW_FUN_EXPORT PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv; GLEW_FUN_EXPORT PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages; GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline; GLEW_FUN_EXPORT PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv; GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture; GLEW_FUN_EXPORT PFNGLMEMORYBARRIERPROC __glewMemoryBarrier; GLEW_FUN_EXPORT PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB; GLEW_FUN_EXPORT PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB; GLEW_FUN_EXPORT PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB; GLEW_FUN_EXPORT PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB; GLEW_FUN_EXPORT PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB; GLEW_FUN_EXPORT PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB; GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB; GLEW_FUN_EXPORT PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB; GLEW_FUN_EXPORT PFNGLGETHANDLEARBPROC __glewGetHandleARB; GLEW_FUN_EXPORT PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB; GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB; GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB; GLEW_FUN_EXPORT PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB; GLEW_FUN_EXPORT PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB; GLEW_FUN_EXPORT PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB; GLEW_FUN_EXPORT PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB; GLEW_FUN_EXPORT PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB; GLEW_FUN_EXPORT PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB; GLEW_FUN_EXPORT PFNGLUNIFORM1FARBPROC __glewUniform1fARB; GLEW_FUN_EXPORT PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB; GLEW_FUN_EXPORT PFNGLUNIFORM1IARBPROC __glewUniform1iARB; GLEW_FUN_EXPORT PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB; GLEW_FUN_EXPORT PFNGLUNIFORM2FARBPROC __glewUniform2fARB; GLEW_FUN_EXPORT PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB; GLEW_FUN_EXPORT PFNGLUNIFORM2IARBPROC __glewUniform2iARB; GLEW_FUN_EXPORT PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB; GLEW_FUN_EXPORT PFNGLUNIFORM3FARBPROC __glewUniform3fARB; GLEW_FUN_EXPORT PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB; GLEW_FUN_EXPORT PFNGLUNIFORM3IARBPROC __glewUniform3iARB; GLEW_FUN_EXPORT PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB; GLEW_FUN_EXPORT PFNGLUNIFORM4FARBPROC __glewUniform4fARB; GLEW_FUN_EXPORT PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB; GLEW_FUN_EXPORT PFNGLUNIFORM4IARBPROC __glewUniform4iARB; GLEW_FUN_EXPORT PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB; GLEW_FUN_EXPORT PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB; GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB; GLEW_FUN_EXPORT PFNGLSHADERSTORAGEBLOCKBINDINGPROC __glewShaderStorageBlockBinding; GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName; GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName; GLEW_FUN_EXPORT PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv; GLEW_FUN_EXPORT PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv; GLEW_FUN_EXPORT PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex; GLEW_FUN_EXPORT PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation; GLEW_FUN_EXPORT PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv; GLEW_FUN_EXPORT PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv; GLEW_FUN_EXPORT PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB; GLEW_FUN_EXPORT PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB; GLEW_FUN_EXPORT PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB; GLEW_FUN_EXPORT PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB; GLEW_FUN_EXPORT PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB; GLEW_FUN_EXPORT PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB; GLEW_FUN_EXPORT PFNGLBUFFERPAGECOMMITMENTARBPROC __glewBufferPageCommitmentARB; GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTARBPROC __glewTexPageCommitmentARB; GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT; GLEW_FUN_EXPORT PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync; GLEW_FUN_EXPORT PFNGLDELETESYNCPROC __glewDeleteSync; GLEW_FUN_EXPORT PFNGLFENCESYNCPROC __glewFenceSync; GLEW_FUN_EXPORT PFNGLGETINTEGER64VPROC __glewGetInteger64v; GLEW_FUN_EXPORT PFNGLGETSYNCIVPROC __glewGetSynciv; GLEW_FUN_EXPORT PFNGLISSYNCPROC __glewIsSync; GLEW_FUN_EXPORT PFNGLWAITSYNCPROC __glewWaitSync; GLEW_FUN_EXPORT PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv; GLEW_FUN_EXPORT PFNGLPATCHPARAMETERIPROC __glewPatchParameteri; GLEW_FUN_EXPORT PFNGLTEXTUREBARRIERPROC __glewTextureBarrier; GLEW_FUN_EXPORT PFNGLTEXBUFFERARBPROC __glewTexBufferARB; GLEW_FUN_EXPORT PFNGLTEXBUFFERRANGEPROC __glewTexBufferRange; GLEW_FUN_EXPORT PFNGLTEXTUREBUFFERRANGEEXTPROC __glewTextureBufferRangeEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB; GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB; GLEW_FUN_EXPORT PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv; GLEW_FUN_EXPORT PFNGLSAMPLEMASKIPROC __glewSampleMaski; GLEW_FUN_EXPORT PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample; GLEW_FUN_EXPORT PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample; GLEW_FUN_EXPORT PFNGLTEXSTORAGE1DPROC __glewTexStorage1D; GLEW_FUN_EXPORT PFNGLTEXSTORAGE2DPROC __glewTexStorage2D; GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DPROC __glewTexStorage3D; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT; GLEW_FUN_EXPORT PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample; GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC __glewTextureStorage2DMultisampleEXT; GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC __glewTextureStorage3DMultisampleEXT; GLEW_FUN_EXPORT PFNGLTEXTUREVIEWPROC __glewTextureView; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v; GLEW_FUN_EXPORT PFNGLQUERYCOUNTERPROC __glewQueryCounter; GLEW_FUN_EXPORT PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback; GLEW_FUN_EXPORT PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks; GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback; GLEW_FUN_EXPORT PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks; GLEW_FUN_EXPORT PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback; GLEW_FUN_EXPORT PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback; GLEW_FUN_EXPORT PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback; GLEW_FUN_EXPORT PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed; GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream; GLEW_FUN_EXPORT PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed; GLEW_FUN_EXPORT PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv; GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced; GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced; GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB; GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB; GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB; GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB; GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEPROC __glewBindBufferBase; GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange; GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName; GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv; GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName; GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv; GLEW_FUN_EXPORT PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v; GLEW_FUN_EXPORT PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex; GLEW_FUN_EXPORT PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices; GLEW_FUN_EXPORT PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding; GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray; GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays; GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays; GLEW_FUN_EXPORT PFNGLISVERTEXARRAYPROC __glewIsVertexArray; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer; GLEW_FUN_EXPORT PFNGLBINDVERTEXBUFFERPROC __glewBindVertexBuffer; GLEW_FUN_EXPORT PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC __glewVertexArrayBindVertexBufferEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC __glewVertexArrayVertexAttribBindingEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC __glewVertexArrayVertexAttribFormatEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC __glewVertexArrayVertexAttribIFormatEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC __glewVertexArrayVertexAttribLFormatEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC __glewVertexArrayVertexBindingDivisorEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBBINDINGPROC __glewVertexAttribBinding; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBFORMATPROC __glewVertexAttribFormat; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIFORMATPROC __glewVertexAttribIFormat; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLFORMATPROC __glewVertexAttribLFormat; GLEW_FUN_EXPORT PFNGLVERTEXBINDINGDIVISORPROC __glewVertexBindingDivisor; GLEW_FUN_EXPORT PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB; GLEW_FUN_EXPORT PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB; GLEW_FUN_EXPORT PFNGLWEIGHTBVARBPROC __glewWeightbvARB; GLEW_FUN_EXPORT PFNGLWEIGHTDVARBPROC __glewWeightdvARB; GLEW_FUN_EXPORT PFNGLWEIGHTFVARBPROC __glewWeightfvARB; GLEW_FUN_EXPORT PFNGLWEIGHTIVARBPROC __glewWeightivARB; GLEW_FUN_EXPORT PFNGLWEIGHTSVARBPROC __glewWeightsvARB; GLEW_FUN_EXPORT PFNGLWEIGHTUBVARBPROC __glewWeightubvARB; GLEW_FUN_EXPORT PFNGLWEIGHTUIVARBPROC __glewWeightuivARB; GLEW_FUN_EXPORT PFNGLWEIGHTUSVARBPROC __glewWeightusvARB; GLEW_FUN_EXPORT PFNGLBINDBUFFERARBPROC __glewBindBufferARB; GLEW_FUN_EXPORT PFNGLBUFFERDATAARBPROC __glewBufferDataARB; GLEW_FUN_EXPORT PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB; GLEW_FUN_EXPORT PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB; GLEW_FUN_EXPORT PFNGLGENBUFFERSARBPROC __glewGenBuffersARB; GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB; GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB; GLEW_FUN_EXPORT PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB; GLEW_FUN_EXPORT PFNGLISBUFFERARBPROC __glewIsBufferARB; GLEW_FUN_EXPORT PFNGLMAPBUFFERARBPROC __glewMapBufferARB; GLEW_FUN_EXPORT PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB; GLEW_FUN_EXPORT PFNGLBINDPROGRAMARBPROC __glewBindProgramARB; GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB; GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB; GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB; GLEW_FUN_EXPORT PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB; GLEW_FUN_EXPORT PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB; GLEW_FUN_EXPORT PFNGLISPROGRAMARBPROC __glewIsProgramARB; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB; GLEW_FUN_EXPORT PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB; GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB; GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB; GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB; GLEW_FUN_EXPORT PFNGLCOLORP3UIPROC __glewColorP3ui; GLEW_FUN_EXPORT PFNGLCOLORP3UIVPROC __glewColorP3uiv; GLEW_FUN_EXPORT PFNGLCOLORP4UIPROC __glewColorP4ui; GLEW_FUN_EXPORT PFNGLCOLORP4UIVPROC __glewColorP4uiv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv; GLEW_FUN_EXPORT PFNGLNORMALP3UIPROC __glewNormalP3ui; GLEW_FUN_EXPORT PFNGLNORMALP3UIVPROC __glewNormalP3uiv; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv; GLEW_FUN_EXPORT PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui; GLEW_FUN_EXPORT PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv; GLEW_FUN_EXPORT PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui; GLEW_FUN_EXPORT PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv; GLEW_FUN_EXPORT PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui; GLEW_FUN_EXPORT PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv; GLEW_FUN_EXPORT PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui; GLEW_FUN_EXPORT PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv; GLEW_FUN_EXPORT PFNGLVERTEXP2UIPROC __glewVertexP2ui; GLEW_FUN_EXPORT PFNGLVERTEXP2UIVPROC __glewVertexP2uiv; GLEW_FUN_EXPORT PFNGLVERTEXP3UIPROC __glewVertexP3ui; GLEW_FUN_EXPORT PFNGLVERTEXP3UIVPROC __glewVertexP3uiv; GLEW_FUN_EXPORT PFNGLVERTEXP4UIPROC __glewVertexP4ui; GLEW_FUN_EXPORT PFNGLVERTEXP4UIVPROC __glewVertexP4uiv; GLEW_FUN_EXPORT PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv; GLEW_FUN_EXPORT PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed; GLEW_FUN_EXPORT PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v; GLEW_FUN_EXPORT PFNGLGETFLOATI_VPROC __glewGetFloati_v; GLEW_FUN_EXPORT PFNGLSCISSORARRAYVPROC __glewScissorArrayv; GLEW_FUN_EXPORT PFNGLSCISSORINDEXEDPROC __glewScissorIndexed; GLEW_FUN_EXPORT PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv; GLEW_FUN_EXPORT PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv; GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf; GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv; GLEW_FUN_EXPORT PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB; GLEW_FUN_EXPORT PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI; GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI; GLEW_FUN_EXPORT PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI; GLEW_FUN_EXPORT PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI; GLEW_FUN_EXPORT PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI; GLEW_FUN_EXPORT PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI; GLEW_FUN_EXPORT PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI; GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI; GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI; GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI; GLEW_FUN_EXPORT PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI; GLEW_FUN_EXPORT PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI; GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI; GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI; GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI; GLEW_FUN_EXPORT PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI; GLEW_FUN_EXPORT PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI; GLEW_FUN_EXPORT PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI; GLEW_FUN_EXPORT PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI; GLEW_FUN_EXPORT PFNGLSAMPLEMAPATIPROC __glewSampleMapATI; GLEW_FUN_EXPORT PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI; GLEW_FUN_EXPORT PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI; GLEW_FUN_EXPORT PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI; GLEW_FUN_EXPORT PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI; GLEW_FUN_EXPORT PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI; GLEW_FUN_EXPORT PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI; GLEW_FUN_EXPORT PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI; GLEW_FUN_EXPORT PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI; GLEW_FUN_EXPORT PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI; GLEW_FUN_EXPORT PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI; GLEW_FUN_EXPORT PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI; GLEW_FUN_EXPORT PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI; GLEW_FUN_EXPORT PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI; GLEW_FUN_EXPORT PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI; GLEW_FUN_EXPORT PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI; GLEW_FUN_EXPORT PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI; GLEW_FUN_EXPORT PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI; GLEW_FUN_EXPORT PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI; GLEW_FUN_EXPORT PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI; GLEW_FUN_EXPORT PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI; GLEW_FUN_EXPORT PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI; GLEW_FUN_EXPORT PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI; GLEW_FUN_EXPORT PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1DATIPROC __glewVertexStream1dATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1DVATIPROC __glewVertexStream1dvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1FATIPROC __glewVertexStream1fATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1FVATIPROC __glewVertexStream1fvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1IATIPROC __glewVertexStream1iATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1IVATIPROC __glewVertexStream1ivATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1SATIPROC __glewVertexStream1sATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM1SVATIPROC __glewVertexStream1svATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI; GLEW_FUN_EXPORT PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT; GLEW_FUN_EXPORT PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT; GLEW_FUN_EXPORT PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT; GLEW_FUN_EXPORT PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT; GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT; GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT; GLEW_FUN_EXPORT PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT; GLEW_FUN_EXPORT PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT; GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT; GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT; GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT; GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT; GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT; GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT; GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT; GLEW_FUN_EXPORT PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT; GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT; GLEW_FUN_EXPORT PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT; GLEW_FUN_EXPORT PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT; GLEW_FUN_EXPORT PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT; GLEW_FUN_EXPORT PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETOBJECTLABELEXTPROC __glewGetObjectLabelEXT; GLEW_FUN_EXPORT PFNGLLABELOBJECTEXTPROC __glewLabelObjectEXT; GLEW_FUN_EXPORT PFNGLINSERTEVENTMARKEREXTPROC __glewInsertEventMarkerEXT; GLEW_FUN_EXPORT PFNGLPOPGROUPMARKEREXTPROC __glewPopGroupMarkerEXT; GLEW_FUN_EXPORT PFNGLPUSHGROUPMARKEREXTPROC __glewPushGroupMarkerEXT; GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT; GLEW_FUN_EXPORT PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT; GLEW_FUN_EXPORT PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT; GLEW_FUN_EXPORT PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT; GLEW_FUN_EXPORT PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT; GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT; GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT; GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT; GLEW_FUN_EXPORT PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT; GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT; GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT; GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT; GLEW_FUN_EXPORT PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT; GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT; GLEW_FUN_EXPORT PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT; GLEW_FUN_EXPORT PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT; GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT; GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT; GLEW_FUN_EXPORT PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT; GLEW_FUN_EXPORT PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT; GLEW_FUN_EXPORT PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT; GLEW_FUN_EXPORT PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT; GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT; GLEW_FUN_EXPORT PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT; GLEW_FUN_EXPORT PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT; GLEW_FUN_EXPORT PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT; GLEW_FUN_EXPORT PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT; GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT; GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT; GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT; GLEW_FUN_EXPORT PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT; GLEW_FUN_EXPORT PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT; GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT; GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT; GLEW_FUN_EXPORT PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT; GLEW_FUN_EXPORT PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT; GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT; GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT; GLEW_FUN_EXPORT PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT; GLEW_FUN_EXPORT PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT; GLEW_FUN_EXPORT PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT; GLEW_FUN_EXPORT PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT; GLEW_FUN_EXPORT PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT; GLEW_FUN_EXPORT PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT; GLEW_FUN_EXPORT PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT; GLEW_FUN_EXPORT PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT; GLEW_FUN_EXPORT PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT; GLEW_FUN_EXPORT PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT; GLEW_FUN_EXPORT PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT; GLEW_FUN_EXPORT PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT; GLEW_FUN_EXPORT PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT; GLEW_FUN_EXPORT PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT; GLEW_FUN_EXPORT PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT; GLEW_FUN_EXPORT PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT; GLEW_FUN_EXPORT PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT; GLEW_FUN_EXPORT PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT; GLEW_FUN_EXPORT PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT; GLEW_FUN_EXPORT PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT; GLEW_FUN_EXPORT PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT; GLEW_FUN_EXPORT PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT; GLEW_FUN_EXPORT PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT; GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT; GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT; GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT; GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT; GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT; GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT; GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT; GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT; GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT; GLEW_FUN_EXPORT PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT; GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT; GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT; GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT; GLEW_FUN_EXPORT PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT; GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT; GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT; GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT; GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT; GLEW_FUN_EXPORT PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT; GLEW_FUN_EXPORT PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT; GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT; GLEW_FUN_EXPORT PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT; GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT; GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT; GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT; GLEW_FUN_EXPORT PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC __glewVertexArrayVertexAttribDivisorEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT; GLEW_FUN_EXPORT PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT; GLEW_FUN_EXPORT PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT; GLEW_FUN_EXPORT PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT; GLEW_FUN_EXPORT PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT; GLEW_FUN_EXPORT PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT; GLEW_FUN_EXPORT PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT; GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT; GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT; GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT; GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT; GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT; GLEW_FUN_EXPORT PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT; GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT; GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT; GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT; GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT; GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT; GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT; GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT; GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT; GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT; GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT; GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT; GLEW_FUN_EXPORT PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT; GLEW_FUN_EXPORT PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT; GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT; GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT; GLEW_FUN_EXPORT PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT; GLEW_FUN_EXPORT PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT; GLEW_FUN_EXPORT PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT; GLEW_FUN_EXPORT PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT; GLEW_FUN_EXPORT PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT; GLEW_FUN_EXPORT PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT; GLEW_FUN_EXPORT PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT; GLEW_FUN_EXPORT PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT; GLEW_FUN_EXPORT PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT; GLEW_FUN_EXPORT PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT; GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT; GLEW_FUN_EXPORT PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT; GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT; GLEW_FUN_EXPORT PFNGLHISTOGRAMEXTPROC __glewHistogramEXT; GLEW_FUN_EXPORT PFNGLMINMAXEXTPROC __glewMinmaxEXT; GLEW_FUN_EXPORT PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT; GLEW_FUN_EXPORT PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT; GLEW_FUN_EXPORT PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT; GLEW_FUN_EXPORT PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT; GLEW_FUN_EXPORT PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT; GLEW_FUN_EXPORT PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT; GLEW_FUN_EXPORT PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT; GLEW_FUN_EXPORT PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT; GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT; GLEW_FUN_EXPORT PFNGLCOLORTABLEEXTPROC __glewColorTableEXT; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT; GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT; GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT; GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT; GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT; GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT; GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT; GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT; GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETCLAMPEXTPROC __glewPolygonOffsetClampEXT; GLEW_FUN_EXPORT PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT; GLEW_FUN_EXPORT PFNGLCOVERAGEMODULATIONNVPROC __glewCoverageModulationNV; GLEW_FUN_EXPORT PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTableNV; GLEW_FUN_EXPORT PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV; GLEW_FUN_EXPORT PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT; GLEW_FUN_EXPORT PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT; GLEW_FUN_EXPORT PFNGLENDSCENEEXTPROC __glewEndSceneEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT; GLEW_FUN_EXPORT PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT; GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT; GLEW_FUN_EXPORT PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT; GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT; GLEW_FUN_EXPORT PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT; GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT; GLEW_FUN_EXPORT PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT; GLEW_FUN_EXPORT PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT; GLEW_FUN_EXPORT PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT; GLEW_FUN_EXPORT PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT; GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT; GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT; GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT; GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT; GLEW_FUN_EXPORT PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT; GLEW_FUN_EXPORT PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT; GLEW_FUN_EXPORT PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT; GLEW_FUN_EXPORT PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT; GLEW_FUN_EXPORT PFNGLISTEXTUREEXTPROC __glewIsTextureEXT; GLEW_FUN_EXPORT PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT; GLEW_FUN_EXPORT PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT; GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT; GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT; GLEW_FUN_EXPORT PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT; GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT; GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT; GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT; GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT; GLEW_FUN_EXPORT PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT; GLEW_FUN_EXPORT PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT; GLEW_FUN_EXPORT PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT; GLEW_FUN_EXPORT PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT; GLEW_FUN_EXPORT PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT; GLEW_FUN_EXPORT PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT; GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT; GLEW_FUN_EXPORT PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT; GLEW_FUN_EXPORT PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT; GLEW_FUN_EXPORT PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT; GLEW_FUN_EXPORT PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT; GLEW_FUN_EXPORT PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT; GLEW_FUN_EXPORT PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT; GLEW_FUN_EXPORT PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT; GLEW_FUN_EXPORT PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT; GLEW_FUN_EXPORT PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT; GLEW_FUN_EXPORT PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT; GLEW_FUN_EXPORT PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT; GLEW_FUN_EXPORT PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT; GLEW_FUN_EXPORT PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT; GLEW_FUN_EXPORT PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT; GLEW_FUN_EXPORT PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT; GLEW_FUN_EXPORT PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT; GLEW_FUN_EXPORT PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT; GLEW_FUN_EXPORT PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT; GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT; GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT; GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT; GLEW_FUN_EXPORT PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT; GLEW_FUN_EXPORT PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT; GLEW_FUN_EXPORT PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT; GLEW_FUN_EXPORT PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT; GLEW_FUN_EXPORT PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT; GLEW_FUN_EXPORT PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT; GLEW_FUN_EXPORT PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT; GLEW_FUN_EXPORT PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT; GLEW_FUN_EXPORT PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT; GLEW_FUN_EXPORT PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT; GLEW_FUN_EXPORT PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT; GLEW_FUN_EXPORT PFNGLSWIZZLEEXTPROC __glewSwizzleEXT; GLEW_FUN_EXPORT PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT; GLEW_FUN_EXPORT PFNGLVARIANTBVEXTPROC __glewVariantbvEXT; GLEW_FUN_EXPORT PFNGLVARIANTDVEXTPROC __glewVariantdvEXT; GLEW_FUN_EXPORT PFNGLVARIANTFVEXTPROC __glewVariantfvEXT; GLEW_FUN_EXPORT PFNGLVARIANTIVEXTPROC __glewVariantivEXT; GLEW_FUN_EXPORT PFNGLVARIANTSVEXTPROC __glewVariantsvEXT; GLEW_FUN_EXPORT PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT; GLEW_FUN_EXPORT PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT; GLEW_FUN_EXPORT PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT; GLEW_FUN_EXPORT PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT; GLEW_FUN_EXPORT PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT; GLEW_FUN_EXPORT PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY; GLEW_FUN_EXPORT PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY; GLEW_FUN_EXPORT PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP; GLEW_FUN_EXPORT PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP; GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP; GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP; GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP; GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP; GLEW_FUN_EXPORT PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM; GLEW_FUN_EXPORT PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM; GLEW_FUN_EXPORT PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM; GLEW_FUN_EXPORT PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM; GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM; GLEW_FUN_EXPORT PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM; GLEW_FUN_EXPORT PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM; GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM; GLEW_FUN_EXPORT PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM; GLEW_FUN_EXPORT PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL; GLEW_FUN_EXPORT PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL; GLEW_FUN_EXPORT PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL; GLEW_FUN_EXPORT PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL; GLEW_FUN_EXPORT PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL; GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL; GLEW_FUN_EXPORT PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL; GLEW_FUN_EXPORT PFNGLBEGINPERFQUERYINTELPROC __glewBeginPerfQueryINTEL; GLEW_FUN_EXPORT PFNGLCREATEPERFQUERYINTELPROC __glewCreatePerfQueryINTEL; GLEW_FUN_EXPORT PFNGLDELETEPERFQUERYINTELPROC __glewDeletePerfQueryINTEL; GLEW_FUN_EXPORT PFNGLENDPERFQUERYINTELPROC __glewEndPerfQueryINTEL; GLEW_FUN_EXPORT PFNGLGETFIRSTPERFQUERYIDINTELPROC __glewGetFirstPerfQueryIdINTEL; GLEW_FUN_EXPORT PFNGLGETNEXTPERFQUERYIDINTELPROC __glewGetNextPerfQueryIdINTEL; GLEW_FUN_EXPORT PFNGLGETPERFCOUNTERINFOINTELPROC __glewGetPerfCounterInfoINTEL; GLEW_FUN_EXPORT PFNGLGETPERFQUERYDATAINTELPROC __glewGetPerfQueryDataINTEL; GLEW_FUN_EXPORT PFNGLGETPERFQUERYIDBYNAMEINTELPROC __glewGetPerfQueryIdByNameINTEL; GLEW_FUN_EXPORT PFNGLGETPERFQUERYINFOINTELPROC __glewGetPerfQueryInfoINTEL; GLEW_FUN_EXPORT PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL; GLEW_FUN_EXPORT PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL; GLEW_FUN_EXPORT PFNGLBLENDBARRIERKHRPROC __glewBlendBarrierKHR; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECALLBACKPROC __glewDebugMessageCallback; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECONTROLPROC __glewDebugMessageControl; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGEINSERTPROC __glewDebugMessageInsert; GLEW_FUN_EXPORT PFNGLGETDEBUGMESSAGELOGPROC __glewGetDebugMessageLog; GLEW_FUN_EXPORT PFNGLGETOBJECTLABELPROC __glewGetObjectLabel; GLEW_FUN_EXPORT PFNGLGETOBJECTPTRLABELPROC __glewGetObjectPtrLabel; GLEW_FUN_EXPORT PFNGLOBJECTLABELPROC __glewObjectLabel; GLEW_FUN_EXPORT PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel; GLEW_FUN_EXPORT PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup; GLEW_FUN_EXPORT PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup; GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVPROC __glewGetnUniformfv; GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVPROC __glewGetnUniformiv; GLEW_FUN_EXPORT PFNGLGETNUNIFORMUIVPROC __glewGetnUniformuiv; GLEW_FUN_EXPORT PFNGLREADNPIXELSPROC __glewReadnPixels; GLEW_FUN_EXPORT PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled; GLEW_FUN_EXPORT PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion; GLEW_FUN_EXPORT PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion; GLEW_FUN_EXPORT PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion; GLEW_FUN_EXPORT PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion; GLEW_FUN_EXPORT PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA; GLEW_FUN_EXPORT PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA; GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERNVXPROC __glewBeginConditionalRenderNVX; GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERNVXPROC __glewEndConditionalRenderNVX; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC __glewMultiDrawArraysIndirectBindlessNV; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC __glewMultiDrawElementsIndirectBindlessNV; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC __glewMultiDrawArraysIndirectBindlessCountNV; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC __glewMultiDrawElementsIndirectBindlessCountNV; GLEW_FUN_EXPORT PFNGLGETIMAGEHANDLENVPROC __glewGetImageHandleNV; GLEW_FUN_EXPORT PFNGLGETTEXTUREHANDLENVPROC __glewGetTextureHandleNV; GLEW_FUN_EXPORT PFNGLGETTEXTURESAMPLERHANDLENVPROC __glewGetTextureSamplerHandleNV; GLEW_FUN_EXPORT PFNGLISIMAGEHANDLERESIDENTNVPROC __glewIsImageHandleResidentNV; GLEW_FUN_EXPORT PFNGLISTEXTUREHANDLERESIDENTNVPROC __glewIsTextureHandleResidentNV; GLEW_FUN_EXPORT PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC __glewMakeImageHandleNonResidentNV; GLEW_FUN_EXPORT PFNGLMAKEIMAGEHANDLERESIDENTNVPROC __glewMakeImageHandleResidentNV; GLEW_FUN_EXPORT PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC __glewMakeTextureHandleNonResidentNV; GLEW_FUN_EXPORT PFNGLMAKETEXTUREHANDLERESIDENTNVPROC __glewMakeTextureHandleResidentNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC __glewProgramUniformHandleui64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC __glewProgramUniformHandleui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORMHANDLEUI64NVPROC __glewUniformHandleui64NV; GLEW_FUN_EXPORT PFNGLUNIFORMHANDLEUI64VNVPROC __glewUniformHandleui64vNV; GLEW_FUN_EXPORT PFNGLBLENDBARRIERNVPROC __glewBlendBarrierNV; GLEW_FUN_EXPORT PFNGLBLENDPARAMETERINVPROC __glewBlendParameteriNV; GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV; GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV; GLEW_FUN_EXPORT PFNGLSUBPIXELPRECISIONBIASNVPROC __glewSubpixelPrecisionBiasNV; GLEW_FUN_EXPORT PFNGLCONSERVATIVERASTERPARAMETERFNVPROC __glewConservativeRasterParameterfNV; GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV; GLEW_FUN_EXPORT PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV; GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV; GLEW_FUN_EXPORT PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV; GLEW_FUN_EXPORT PFNGLDRAWTEXTURENVPROC __glewDrawTextureNV; GLEW_FUN_EXPORT PFNGLEVALMAPSNVPROC __glewEvalMapsNV; GLEW_FUN_EXPORT PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV; GLEW_FUN_EXPORT PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV; GLEW_FUN_EXPORT PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV; GLEW_FUN_EXPORT PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV; GLEW_FUN_EXPORT PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV; GLEW_FUN_EXPORT PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV; GLEW_FUN_EXPORT PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV; GLEW_FUN_EXPORT PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV; GLEW_FUN_EXPORT PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV; GLEW_FUN_EXPORT PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV; GLEW_FUN_EXPORT PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV; GLEW_FUN_EXPORT PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV; GLEW_FUN_EXPORT PFNGLFINISHFENCENVPROC __glewFinishFenceNV; GLEW_FUN_EXPORT PFNGLGENFENCESNVPROC __glewGenFencesNV; GLEW_FUN_EXPORT PFNGLGETFENCEIVNVPROC __glewGetFenceivNV; GLEW_FUN_EXPORT PFNGLISFENCENVPROC __glewIsFenceNV; GLEW_FUN_EXPORT PFNGLSETFENCENVPROC __glewSetFenceNV; GLEW_FUN_EXPORT PFNGLTESTFENCENVPROC __glewTestFenceNV; GLEW_FUN_EXPORT PFNGLFRAGMENTCOVERAGECOLORNVPROC __glewFragmentCoverageColorNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV; GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV; GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV; GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV; GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV; GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV; GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV; GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV; GLEW_FUN_EXPORT PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV; GLEW_FUN_EXPORT PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV; GLEW_FUN_EXPORT PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV; GLEW_FUN_EXPORT PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV; GLEW_FUN_EXPORT PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV; GLEW_FUN_EXPORT PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV; GLEW_FUN_EXPORT PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV; GLEW_FUN_EXPORT PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV; GLEW_FUN_EXPORT PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV; GLEW_FUN_EXPORT PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV; GLEW_FUN_EXPORT PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV; GLEW_FUN_EXPORT PFNGLCOLOR3HNVPROC __glewColor3hNV; GLEW_FUN_EXPORT PFNGLCOLOR3HVNVPROC __glewColor3hvNV; GLEW_FUN_EXPORT PFNGLCOLOR4HNVPROC __glewColor4hNV; GLEW_FUN_EXPORT PFNGLCOLOR4HVNVPROC __glewColor4hvNV; GLEW_FUN_EXPORT PFNGLFOGCOORDHNVPROC __glewFogCoordhNV; GLEW_FUN_EXPORT PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV; GLEW_FUN_EXPORT PFNGLNORMAL3HNVPROC __glewNormal3hNV; GLEW_FUN_EXPORT PFNGLNORMAL3HVNVPROC __glewNormal3hvNV; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV; GLEW_FUN_EXPORT PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV; GLEW_FUN_EXPORT PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV; GLEW_FUN_EXPORT PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV; GLEW_FUN_EXPORT PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV; GLEW_FUN_EXPORT PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV; GLEW_FUN_EXPORT PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV; GLEW_FUN_EXPORT PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV; GLEW_FUN_EXPORT PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV; GLEW_FUN_EXPORT PFNGLVERTEX2HNVPROC __glewVertex2hNV; GLEW_FUN_EXPORT PFNGLVERTEX2HVNVPROC __glewVertex2hvNV; GLEW_FUN_EXPORT PFNGLVERTEX3HNVPROC __glewVertex3hNV; GLEW_FUN_EXPORT PFNGLVERTEX3HVNVPROC __glewVertex3hvNV; GLEW_FUN_EXPORT PFNGLVERTEX4HNVPROC __glewVertex4hNV; GLEW_FUN_EXPORT PFNGLVERTEX4HVNVPROC __glewVertex4hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV; GLEW_FUN_EXPORT PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV; GLEW_FUN_EXPORT PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV; GLEW_FUN_EXPORT PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV; GLEW_FUN_EXPORT PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV; GLEW_FUN_EXPORT PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV; GLEW_FUN_EXPORT PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV; GLEW_FUN_EXPORT PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV; GLEW_FUN_EXPORT PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV; GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV; GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV; GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV; GLEW_FUN_EXPORT PFNGLCOPYPATHNVPROC __glewCopyPathNV; GLEW_FUN_EXPORT PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV; GLEW_FUN_EXPORT PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV; GLEW_FUN_EXPORT PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV; GLEW_FUN_EXPORT PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV; GLEW_FUN_EXPORT PFNGLDELETEPATHSNVPROC __glewDeletePathsNV; GLEW_FUN_EXPORT PFNGLGENPATHSNVPROC __glewGenPathsNV; GLEW_FUN_EXPORT PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV; GLEW_FUN_EXPORT PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV; GLEW_FUN_EXPORT PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV; GLEW_FUN_EXPORT PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV; GLEW_FUN_EXPORT PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV; GLEW_FUN_EXPORT PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV; GLEW_FUN_EXPORT PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV; GLEW_FUN_EXPORT PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV; GLEW_FUN_EXPORT PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV; GLEW_FUN_EXPORT PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV; GLEW_FUN_EXPORT PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV; GLEW_FUN_EXPORT PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV; GLEW_FUN_EXPORT PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCEFVNVPROC __glewGetProgramResourcefvNV; GLEW_FUN_EXPORT PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV; GLEW_FUN_EXPORT PFNGLISPATHNVPROC __glewIsPathNV; GLEW_FUN_EXPORT PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV; GLEW_FUN_EXPORT PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV; GLEW_FUN_EXPORT PFNGLMATRIXLOAD3X2FNVPROC __glewMatrixLoad3x2fNV; GLEW_FUN_EXPORT PFNGLMATRIXLOAD3X3FNVPROC __glewMatrixLoad3x3fNV; GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC __glewMatrixLoadTranspose3x3fNV; GLEW_FUN_EXPORT PFNGLMATRIXMULT3X2FNVPROC __glewMatrixMult3x2fNV; GLEW_FUN_EXPORT PFNGLMATRIXMULT3X3FNVPROC __glewMatrixMult3x3fNV; GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC __glewMatrixMultTranspose3x3fNV; GLEW_FUN_EXPORT PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV; GLEW_FUN_EXPORT PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV; GLEW_FUN_EXPORT PFNGLPATHCOORDSNVPROC __glewPathCoordsNV; GLEW_FUN_EXPORT PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV; GLEW_FUN_EXPORT PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV; GLEW_FUN_EXPORT PFNGLPATHFOGGENNVPROC __glewPathFogGenNV; GLEW_FUN_EXPORT PFNGLPATHGLYPHINDEXARRAYNVPROC __glewPathGlyphIndexArrayNV; GLEW_FUN_EXPORT PFNGLPATHGLYPHINDEXRANGENVPROC __glewPathGlyphIndexRangeNV; GLEW_FUN_EXPORT PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV; GLEW_FUN_EXPORT PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV; GLEW_FUN_EXPORT PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC __glewPathMemoryGlyphIndexArrayNV; GLEW_FUN_EXPORT PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV; GLEW_FUN_EXPORT PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV; GLEW_FUN_EXPORT PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV; GLEW_FUN_EXPORT PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV; GLEW_FUN_EXPORT PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV; GLEW_FUN_EXPORT PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV; GLEW_FUN_EXPORT PFNGLPATHSTRINGNVPROC __glewPathStringNV; GLEW_FUN_EXPORT PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV; GLEW_FUN_EXPORT PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV; GLEW_FUN_EXPORT PFNGLPATHTEXGENNVPROC __glewPathTexGenNV; GLEW_FUN_EXPORT PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV; GLEW_FUN_EXPORT PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC __glewProgramPathFragmentInputGenNV; GLEW_FUN_EXPORT PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV; GLEW_FUN_EXPORT PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV; GLEW_FUN_EXPORT PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV; GLEW_FUN_EXPORT PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV; GLEW_FUN_EXPORT PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC __glewStencilThenCoverFillPathInstancedNV; GLEW_FUN_EXPORT PFNGLSTENCILTHENCOVERFILLPATHNVPROC __glewStencilThenCoverFillPathNV; GLEW_FUN_EXPORT PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC __glewStencilThenCoverStrokePathInstancedNV; GLEW_FUN_EXPORT PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC __glewStencilThenCoverStrokePathNV; GLEW_FUN_EXPORT PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV; GLEW_FUN_EXPORT PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV; GLEW_FUN_EXPORT PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV; GLEW_FUN_EXPORT PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV; GLEW_FUN_EXPORT PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV; GLEW_FUN_EXPORT PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV; GLEW_FUN_EXPORT PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV; GLEW_FUN_EXPORT PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV; GLEW_FUN_EXPORT PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV; GLEW_FUN_EXPORT PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV; GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV; GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV; GLEW_FUN_EXPORT PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV; GLEW_FUN_EXPORT PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV; GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV; GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV; GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV; GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV; GLEW_FUN_EXPORT PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV; GLEW_FUN_EXPORT PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV; GLEW_FUN_EXPORT PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV; GLEW_FUN_EXPORT PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV; GLEW_FUN_EXPORT PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV; GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV; GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV; GLEW_FUN_EXPORT PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV; GLEW_FUN_EXPORT PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewFramebufferSampleLocationsfvNV; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewNamedFramebufferSampleLocationsfvNV; GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV; GLEW_FUN_EXPORT PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV; GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV; GLEW_FUN_EXPORT PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV; GLEW_FUN_EXPORT PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV; GLEW_FUN_EXPORT PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV; GLEW_FUN_EXPORT PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV; GLEW_FUN_EXPORT PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV; GLEW_FUN_EXPORT PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV; GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORMUI64NVPROC __glewUniformui64NV; GLEW_FUN_EXPORT PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV; GLEW_FUN_EXPORT PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV; GLEW_FUN_EXPORT PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV; GLEW_FUN_EXPORT PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV; GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV; GLEW_FUN_EXPORT PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV; GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV; GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV; GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV; GLEW_FUN_EXPORT PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV; GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV; GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV; GLEW_FUN_EXPORT PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV; GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV; GLEW_FUN_EXPORT PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV; GLEW_FUN_EXPORT PFNGLVDPAUFININVPROC __glewVDPAUFiniNV; GLEW_FUN_EXPORT PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV; GLEW_FUN_EXPORT PFNGLVDPAUINITNVPROC __glewVDPAUInitNV; GLEW_FUN_EXPORT PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV; GLEW_FUN_EXPORT PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV; GLEW_FUN_EXPORT PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV; GLEW_FUN_EXPORT PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV; GLEW_FUN_EXPORT PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV; GLEW_FUN_EXPORT PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV; GLEW_FUN_EXPORT PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV; GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV; GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV; GLEW_FUN_EXPORT PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV; GLEW_FUN_EXPORT PFNGLCOLORFORMATNVPROC __glewColorFormatNV; GLEW_FUN_EXPORT PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV; GLEW_FUN_EXPORT PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV; GLEW_FUN_EXPORT PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV; GLEW_FUN_EXPORT PFNGLINDEXFORMATNVPROC __glewIndexFormatNV; GLEW_FUN_EXPORT PFNGLNORMALFORMATNVPROC __glewNormalFormatNV; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV; GLEW_FUN_EXPORT PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV; GLEW_FUN_EXPORT PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV; GLEW_FUN_EXPORT PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV; GLEW_FUN_EXPORT PFNGLBINDPROGRAMNVPROC __glewBindProgramNV; GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV; GLEW_FUN_EXPORT PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV; GLEW_FUN_EXPORT PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV; GLEW_FUN_EXPORT PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV; GLEW_FUN_EXPORT PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV; GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV; GLEW_FUN_EXPORT PFNGLISPROGRAMNVPROC __glewIsProgramNV; GLEW_FUN_EXPORT PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV; GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV; GLEW_FUN_EXPORT PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV; GLEW_FUN_EXPORT PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV; GLEW_FUN_EXPORT PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV; GLEW_FUN_EXPORT PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV; GLEW_FUN_EXPORT PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV; GLEW_FUN_EXPORT PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV; GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV; GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV; GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV; GLEW_FUN_EXPORT PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV; GLEW_FUN_EXPORT PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV; GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV; GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV; GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV; GLEW_FUN_EXPORT PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES; GLEW_FUN_EXPORT PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES; GLEW_FUN_EXPORT PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES; GLEW_FUN_EXPORT PFNGLFRUSTUMFOESPROC __glewFrustumfOES; GLEW_FUN_EXPORT PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES; GLEW_FUN_EXPORT PFNGLORTHOFOESPROC __glewOrthofOES; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR; GLEW_FUN_EXPORT PFNGLALPHAFUNCXPROC __glewAlphaFuncx; GLEW_FUN_EXPORT PFNGLCLEARCOLORXPROC __glewClearColorx; GLEW_FUN_EXPORT PFNGLCLEARDEPTHXPROC __glewClearDepthx; GLEW_FUN_EXPORT PFNGLCOLOR4XPROC __glewColor4x; GLEW_FUN_EXPORT PFNGLDEPTHRANGEXPROC __glewDepthRangex; GLEW_FUN_EXPORT PFNGLFOGXPROC __glewFogx; GLEW_FUN_EXPORT PFNGLFOGXVPROC __glewFogxv; GLEW_FUN_EXPORT PFNGLFRUSTUMFPROC __glewFrustumf; GLEW_FUN_EXPORT PFNGLFRUSTUMXPROC __glewFrustumx; GLEW_FUN_EXPORT PFNGLLIGHTMODELXPROC __glewLightModelx; GLEW_FUN_EXPORT PFNGLLIGHTMODELXVPROC __glewLightModelxv; GLEW_FUN_EXPORT PFNGLLIGHTXPROC __glewLightx; GLEW_FUN_EXPORT PFNGLLIGHTXVPROC __glewLightxv; GLEW_FUN_EXPORT PFNGLLINEWIDTHXPROC __glewLineWidthx; GLEW_FUN_EXPORT PFNGLLOADMATRIXXPROC __glewLoadMatrixx; GLEW_FUN_EXPORT PFNGLMATERIALXPROC __glewMaterialx; GLEW_FUN_EXPORT PFNGLMATERIALXVPROC __glewMaterialxv; GLEW_FUN_EXPORT PFNGLMULTMATRIXXPROC __glewMultMatrixx; GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4XPROC __glewMultiTexCoord4x; GLEW_FUN_EXPORT PFNGLNORMAL3XPROC __glewNormal3x; GLEW_FUN_EXPORT PFNGLORTHOFPROC __glewOrthof; GLEW_FUN_EXPORT PFNGLORTHOXPROC __glewOrthox; GLEW_FUN_EXPORT PFNGLPOINTSIZEXPROC __glewPointSizex; GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETXPROC __glewPolygonOffsetx; GLEW_FUN_EXPORT PFNGLROTATEXPROC __glewRotatex; GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEXPROC __glewSampleCoveragex; GLEW_FUN_EXPORT PFNGLSCALEXPROC __glewScalex; GLEW_FUN_EXPORT PFNGLTEXENVXPROC __glewTexEnvx; GLEW_FUN_EXPORT PFNGLTEXENVXVPROC __glewTexEnvxv; GLEW_FUN_EXPORT PFNGLTEXPARAMETERXPROC __glewTexParameterx; GLEW_FUN_EXPORT PFNGLTRANSLATEXPROC __glewTranslatex; GLEW_FUN_EXPORT PFNGLCLIPPLANEFPROC __glewClipPlanef; GLEW_FUN_EXPORT PFNGLCLIPPLANEXPROC __glewClipPlanex; GLEW_FUN_EXPORT PFNGLGETCLIPPLANEFPROC __glewGetClipPlanef; GLEW_FUN_EXPORT PFNGLGETCLIPPLANEXPROC __glewGetClipPlanex; GLEW_FUN_EXPORT PFNGLGETFIXEDVPROC __glewGetFixedv; GLEW_FUN_EXPORT PFNGLGETLIGHTXVPROC __glewGetLightxv; GLEW_FUN_EXPORT PFNGLGETMATERIALXVPROC __glewGetMaterialxv; GLEW_FUN_EXPORT PFNGLGETTEXENVXVPROC __glewGetTexEnvxv; GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERXVPROC __glewGetTexParameterxv; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERXPROC __glewPointParameterx; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERXVPROC __glewPointParameterxv; GLEW_FUN_EXPORT PFNGLPOINTSIZEPOINTEROESPROC __glewPointSizePointerOES; GLEW_FUN_EXPORT PFNGLTEXPARAMETERXVPROC __glewTexParameterxv; GLEW_FUN_EXPORT PFNGLERRORSTRINGREGALPROC __glewErrorStringREGAL; GLEW_FUN_EXPORT PFNGLGETEXTENSIONREGALPROC __glewGetExtensionREGAL; GLEW_FUN_EXPORT PFNGLISSUPPORTEDREGALPROC __glewIsSupportedREGAL; GLEW_FUN_EXPORT PFNGLLOGMESSAGECALLBACKREGALPROC __glewLogMessageCallbackREGAL; GLEW_FUN_EXPORT PFNGLGETPROCADDRESSREGALPROC __glewGetProcAddressREGAL; GLEW_FUN_EXPORT PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS; GLEW_FUN_EXPORT PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS; GLEW_FUN_EXPORT PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS; GLEW_FUN_EXPORT PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS; GLEW_FUN_EXPORT PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS; GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS; GLEW_FUN_EXPORT PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS; GLEW_FUN_EXPORT PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS; GLEW_FUN_EXPORT PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS; GLEW_FUN_EXPORT PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS; GLEW_FUN_EXPORT PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS; GLEW_FUN_EXPORT PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX; GLEW_FUN_EXPORT PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX; GLEW_FUN_EXPORT PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX; GLEW_FUN_EXPORT PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX; GLEW_FUN_EXPORT PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX; GLEW_FUN_EXPORT PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX; GLEW_FUN_EXPORT PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX; GLEW_FUN_EXPORT PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX; GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX; GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX; GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX; GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX; GLEW_FUN_EXPORT PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX; GLEW_FUN_EXPORT PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX; GLEW_FUN_EXPORT PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX; GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX; GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX; GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX; GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX; GLEW_FUN_EXPORT PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX; GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI; GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI; GLEW_FUN_EXPORT PFNGLCOLORTABLESGIPROC __glewColorTableSGI; GLEW_FUN_EXPORT PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI; GLEW_FUN_EXPORT PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI; GLEW_FUN_EXPORT PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN; GLEW_FUN_EXPORT PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN; GLEW_FUN_EXPORT PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN; GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN; GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN; GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN; GLEW_FUN_EXPORT PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN; GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN; GLEW_FUN_EXPORT PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN; GLEW_FUN_EXPORT PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN; #if defined(GLEW_MX) && !defined(_WIN32) struct GLEWContextStruct { #endif /* GLEW_MX */ GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_1; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2_1; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_3; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_4; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_5; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_0; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_1; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_0; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_1; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_2; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_3; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_0; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_1; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_2; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_3; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_4; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_5; GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_tbuffer; GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_texture_compression_FXT1; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_blend_minmax_factor; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_conservative_depth; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_debug_output; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_depth_clamp_separate; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_draw_buffers_blend; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gcn_shader; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gpu_shader_int64; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_interleaved_elements; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_multi_draw_indirect; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_name_gen_delete; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_occlusion_query_event; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_performance_monitor; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_pinned_memory; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_query_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_sample_positions; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_seamless_cubemap_per_texture; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_atomic_counter_ops; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_export; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_value_export; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_trinary_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_sparse_texture; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_stencil_operation_extended; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_texture_texture4; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_transform_feedback3_lines_triangles; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_transform_feedback4; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_layer; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_tessellator; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_viewport_index; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_depth_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_framebuffer_blit; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_framebuffer_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_instanced_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_pack_reverse_row_order; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_program_binary; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_texture_compression_dxt1; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_texture_compression_dxt3; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_texture_compression_dxt5; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_texture_usage; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_timer_query; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_translated_shader_source; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_aux_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_client_storage; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_element_array; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_fence; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_float_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_flush_buffer_range; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_object_purgeable; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_pixel_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_rgb_422; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_row_bytes; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_specular_vector; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_range; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_transform_hint; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_range; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_program_evaluators; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_ycbcr_422; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_ES2_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_ES3_1_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_ES3_2_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_ES3_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_arrays_of_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_base_instance; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_bindless_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_blend_func_extended; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_buffer_storage; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_cl_event; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_clear_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_clear_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_clip_control; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_color_buffer_float; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compressed_texture_pixel_storage; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compute_shader; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_compute_variable_group_size; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_conditional_render_inverted; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_conservative_depth; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_copy_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_copy_image; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_cull_distance; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_debug_output; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_buffer_float; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_derivative_control; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_direct_state_access; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers_blend; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_elements_base_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_indirect; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_instanced; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_enhanced_layouts; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_explicit_attrib_location; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_explicit_uniform_location; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_coord_conventions; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_layer_viewport; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program_shadow; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_shader; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_shader_interlock; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_no_attachments; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_sRGB; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_geometry_shader4; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_get_program_binary; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_get_texture_sub_image; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader5; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader_fp64; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_gpu_shader_int64; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_pixel; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_imaging; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_indirect_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_instanced_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_internalformat_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_internalformat_query2; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_invalidate_subdata; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_map_buffer_alignment; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_map_buffer_range; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_matrix_palette; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multi_bind; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multi_draw_indirect; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multitexture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query2; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_parallel_shader_compile; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pipeline_statistics_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pixel_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_sprite; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_post_depth_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_program_interface_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_provoking_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_query_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_robust_buffer_access_behavior; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_robustness; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_robustness_application_isolation; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_robustness_share_group_isolation; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sample_locations; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sample_shading; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sampler_objects; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_seamless_cube_map; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_seamless_cubemap_per_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_separate_shader_objects; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_atomic_counter_ops; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_atomic_counters; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_ballot; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_bit_encoding; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_clock; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_draw_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_group_vote; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_image_load_store; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_image_size; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_objects; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_precision; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_stencil_export; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_storage_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_subroutine; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_texture_image_samples; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_texture_lod; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_viewport_layer_array; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_100; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_420pack; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_include; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_packing; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow_ambient; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_texture2; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_texture_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_stencil_texturing; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sync; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_tessellation_shader; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_barrier; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_border_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object_rgb32; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_range; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_bptc; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_rgtc; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map_array; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_add; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_combine; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_crossbar; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_dot3; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_filter_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_float; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_gather; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_mirror_clamp_to_edge; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_mirrored_repeat; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_non_power_of_two; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_query_levels; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_query_lod; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rectangle; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rg; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rgb10_a2ui; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_stencil8; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_storage; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_storage_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_swizzle; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_view; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_timer_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback2; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback3; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback_instanced; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transform_feedback_overflow_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transpose_matrix; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_uniform_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_bgra; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_attrib_64bit; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_attrib_binding; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_blend; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_program; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_shader; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_type_10f_11f_11f_rev; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_viewport_array; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_point_sprites; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_combine3; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_route; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_vertex_shader_output_point_size; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_draw_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_element_array; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_envmap_bumpmap; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_fragment_shader; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_map_object_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_meminfo; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_pn_triangles; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_separate_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_shader_texture_lod; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_text_fragment_shader; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_compression_3dc; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_env_combine3; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_float; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_mirror_once; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_attrib_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_streams; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_422_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_Cg_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bgra; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bindable_uniform; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_color; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_equation_separate; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_func_separate; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_logic_op; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_subtract; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_volume_hint; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cmyka; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_color_subtable; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_compiled_vertex_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_convolution; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_coordinate_frame; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_copy_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cull_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_debug_label; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_debug_marker; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_depth_bounds_test; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_direct_state_access; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_buffers2; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_instanced; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_range_elements; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_lighting; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_sRGB; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_geometry_shader4; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_program_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_shader4; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_histogram; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_array_formats; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_func; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_material; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_light_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_misc_attribute; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_float; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_paletted_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform_color_table; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_point_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_post_depth_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_provoking_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_raster_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_rescale_normal; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_scene_marker; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_shader_objects; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_formatted; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_store; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_integer_mix; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_sparse_texture2; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_clear_tag; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_two_side; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_wrap; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_subtexture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture3D; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_dxt1; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_latc; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_rgtc; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_s3tc; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_cube_map; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_edge_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_add; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_combine; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_dot3; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_filter_anisotropic; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_filter_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_integer; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_lod_bias; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_mirror_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_perturb_normal; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_rectangle; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB_decode; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_snorm; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_timer_query; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_transform_feedback; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array_bgra; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_attrib_64bit; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_weighting; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_x11_sync_object; GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_frame_terminator; GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_string_marker; GLEW_VAR_EXPORT GLboolean __GLEW_HP_convolution_border_modes; GLEW_VAR_EXPORT GLboolean __GLEW_HP_image_transform; GLEW_VAR_EXPORT GLboolean __GLEW_HP_occlusion_test; GLEW_VAR_EXPORT GLboolean __GLEW_HP_texture_lighting; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_cull_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_multimode_draw_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_rasterpos_clip; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_static_data; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_texture_mirrored_repeat; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_vertex_array_lists; GLEW_VAR_EXPORT GLboolean __GLEW_INGR_color_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_INGR_interlace_read; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_fragment_shader_ordering; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_framebuffer_CMAA; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_map_texture; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_parallel_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_performance_query; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_texture_scissor; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_blend_equation_advanced; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_blend_equation_advanced_coherent; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_context_flush_control; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_debug; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_no_error; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_robust_buffer_access_behavior; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_robustness; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_hdr; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_ldr; GLEW_VAR_EXPORT GLboolean __GLEW_KTX_buffer_region; GLEW_VAR_EXPORT GLboolean __GLEW_MESAX_texture_stack; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_pack_invert; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_resize_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_window_pos; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture; GLEW_VAR_EXPORT GLboolean __GLEW_NVX_conditional_render; GLEW_VAR_EXPORT GLboolean __GLEW_NVX_gpu_memory_info; GLEW_VAR_EXPORT GLboolean __GLEW_NV_bindless_multi_draw_indirect; GLEW_VAR_EXPORT GLboolean __GLEW_NV_bindless_multi_draw_indirect_count; GLEW_VAR_EXPORT GLboolean __GLEW_NV_bindless_texture; GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_equation_advanced; GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_equation_advanced_coherent; GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_square; GLEW_VAR_EXPORT GLboolean __GLEW_NV_compute_program5; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conditional_render; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster_dilate; GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_depth_to_color; GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_image; GLEW_VAR_EXPORT GLboolean __GLEW_NV_deep_texture3D; GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_buffer_float; GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_range_unclamped; GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_texture; GLEW_VAR_EXPORT GLboolean __GLEW_NV_evaluators; GLEW_VAR_EXPORT GLboolean __GLEW_NV_explicit_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fence; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fill_rectangle; GLEW_VAR_EXPORT GLboolean __GLEW_NV_float_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fog_distance; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_coverage_to_color; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program_option; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_shader_interlock; GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_mixed_samples; GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_multisample_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_program4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader_passthrough; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program5; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program5_mem_extended; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program_fp64; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_shader5; GLEW_VAR_EXPORT GLboolean __GLEW_NV_half_float; GLEW_VAR_EXPORT GLboolean __GLEW_NV_internalformat_sample_query; GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint; GLEW_VAR_EXPORT GLboolean __GLEW_NV_occlusion_query; GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_path_rendering; GLEW_VAR_EXPORT GLboolean __GLEW_NV_path_rendering_shared_edge; GLEW_VAR_EXPORT GLboolean __GLEW_NV_pixel_data_range; GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite; GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video; GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart; GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners; GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_sample_locations; GLEW_VAR_EXPORT GLboolean __GLEW_NV_sample_mask_override_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_counters; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_float; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_fp16_vector; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_int64; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_buffer_load; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_storage_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_thread_group; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_thread_shuffle; GLEW_VAR_EXPORT GLboolean __GLEW_NV_tessellation_program5; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_emboss; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_reflection; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_barrier; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_vtc; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_env_combine4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_expand_normal; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3; GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback; GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_uniform_buffer_unified_memory; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vdpau_interop; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_attrib_integer_64bit; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_buffer_unified_memory; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program1_1; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2_option; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program3; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_video_capture; GLEW_VAR_EXPORT GLboolean __GLEW_NV_viewport_array2; GLEW_VAR_EXPORT GLboolean __GLEW_OES_byte_coordinates; GLEW_VAR_EXPORT GLboolean __GLEW_OES_compressed_paletted_texture; GLEW_VAR_EXPORT GLboolean __GLEW_OES_read_format; GLEW_VAR_EXPORT GLboolean __GLEW_OES_single_precision; GLEW_VAR_EXPORT GLboolean __GLEW_OML_interlace; GLEW_VAR_EXPORT GLboolean __GLEW_OML_resample; GLEW_VAR_EXPORT GLboolean __GLEW_OML_subsample; GLEW_VAR_EXPORT GLboolean __GLEW_OVR_multiview; GLEW_VAR_EXPORT GLboolean __GLEW_OVR_multiview2; GLEW_VAR_EXPORT GLboolean __GLEW_PGI_misc_hints; GLEW_VAR_EXPORT GLboolean __GLEW_PGI_vertex_hints; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_0_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_1_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_enable; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_error_string; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_extension_query; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_log; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_proc_address; GLEW_VAR_EXPORT GLboolean __GLEW_REND_screen_coordinates; GLEW_VAR_EXPORT GLboolean __GLEW_S3_s3tc; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_color_range; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_detail_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_fog_function; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_generate_mipmap; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_pixel_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_point_line_texgen; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_sharpen_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture4D; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_border_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_edge_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_filter4; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_lod; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_select; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_histogram; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_pixel; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_blend_alpha_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_clipmap; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_convolution_accuracy; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_depth_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_flush_raster; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_offset; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fragment_specular_lighting; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_framezoom; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_interlace; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ir_instrument1; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_list_priority; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture_bits; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_reference_plane; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_resample; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow_ambient; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_sprite; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_tag_sample_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_add_env; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_coordinate_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_lod_bias; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_multi_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_range; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_scale_bias; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip_hint; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ycrcb; GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_matrix; GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_table; GLEW_VAR_EXPORT GLboolean __GLEW_SGI_texture_color_table; GLEW_VAR_EXPORT GLboolean __GLEW_SUNX_constant_data; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_convolution_border_modes; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_global_alpha; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_mesh_array; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_read_video_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_slice_accum; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_triangle_list; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_phong_shading; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_specular_fog; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; #ifdef GLEW_MX }; /* GLEWContextStruct */ #endif /* GLEW_MX */ /* ------------------------------------------------------------------------- */ /* error codes */ #define GLEW_OK 0 #define GLEW_NO_ERROR 0 #define GLEW_ERROR_NO_GL_VERSION 1 /* missing GL version */ #define GLEW_ERROR_GL_VERSION_10_ONLY 2 /* Need at least OpenGL 1.1 */ #define GLEW_ERROR_GLX_VERSION_11_ONLY 3 /* Need at least GLX 1.2 */ /* string codes */ #define GLEW_VERSION 1 #define GLEW_VERSION_MAJOR 2 #define GLEW_VERSION_MINOR 3 #define GLEW_VERSION_MICRO 4 /* ------------------------------------------------------------------------- */ /* GLEW version info */ /* VERSION 1.13.0 VERSION_MAJOR 1 VERSION_MINOR 13 VERSION_MICRO 0 */ /* API */ #ifdef GLEW_MX typedef struct GLEWContextStruct GLEWContext; GLEWAPI GLenum GLEWAPIENTRY glewContextInit (GLEWContext *ctx); GLEWAPI GLboolean GLEWAPIENTRY glewContextIsSupported (const GLEWContext *ctx, const char *name); #define glewInit() glewContextInit(glewGetContext()) #define glewIsSupported(x) glewContextIsSupported(glewGetContext(), x) #define glewIsExtensionSupported(x) glewIsSupported(x) #define GLEW_GET_VAR(x) (*(const GLboolean*)&(glewGetContext()->x)) #ifdef _WIN32 # define GLEW_GET_FUN(x) glewGetContext()->x #else # define GLEW_GET_FUN(x) x #endif #else /* GLEW_MX */ GLEWAPI GLenum GLEWAPIENTRY glewInit (void); GLEWAPI GLboolean GLEWAPIENTRY glewIsSupported (const char *name); #define glewIsExtensionSupported(x) glewIsSupported(x) #define GLEW_GET_VAR(x) (*(const GLboolean*)&x) #define GLEW_GET_FUN(x) x #endif /* GLEW_MX */ GLEWAPI GLboolean glewExperimental; GLEWAPI GLboolean GLEWAPIENTRY glewGetExtension (const char *name); GLEWAPI const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error); GLEWAPI const GLubyte * GLEWAPIENTRY glewGetString (GLenum name); #ifdef __cplusplus } #endif #ifdef GLEW_APIENTRY_DEFINED #undef GLEW_APIENTRY_DEFINED #undef APIENTRY #endif #ifdef GLEW_CALLBACK_DEFINED #undef GLEW_CALLBACK_DEFINED #undef CALLBACK #endif #ifdef GLEW_WINGDIAPI_DEFINED #undef GLEW_WINGDIAPI_DEFINED #undef WINGDIAPI #endif #undef GLAPI /* #undef GLEWAPI */ #endif /* __glew_h__ */ Slic3r-version_1.31.6/xs/src/glew/include/GL/glxew.h000066400000000000000000002166641301441720000221200ustar00rootroot00000000000000/* ** The OpenGL Extension Wrangler Library ** Copyright (C) 2008-2015, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are met: ** ** * Redistributions of source code must retain the above copyright notice, ** this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright notice, ** this list of conditions and the following disclaimer in the documentation ** and/or other materials provided with the distribution. ** * The name of the author may be used to endorse or promote products ** derived from this software without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF ** THE POSSIBILITY OF SUCH DAMAGE. */ /* * Mesa 3-D graphics library * Version: 7.0 * * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* ** Copyright (c) 2007 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a ** copy of this software and/or associated documentation files (the ** "Materials"), to deal in the Materials without restriction, including ** without limitation the rights to use, copy, modify, merge, publish, ** distribute, sublicense, and/or sell copies of the Materials, and to ** permit persons to whom the Materials are furnished to do so, subject to ** the following conditions: ** ** The above copyright notice and this permission notice shall be included ** in all copies or substantial portions of the Materials. ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. */ #ifndef __glxew_h__ #define __glxew_h__ #define __GLXEW_H__ #ifdef __glxext_h_ #error glxext.h included before glxew.h #endif #if defined(GLX_H) || defined(__GLX_glx_h__) || defined(__glx_h__) #error glx.h included before glxew.h #endif #define __glxext_h_ #define GLX_H #define __GLX_glx_h__ #define __glx_h__ #include #include #include #include #ifdef __cplusplus extern "C" { #endif /* ---------------------------- GLX_VERSION_1_0 --------------------------- */ #ifndef GLX_VERSION_1_0 #define GLX_VERSION_1_0 1 #define GLX_USE_GL 1 #define GLX_BUFFER_SIZE 2 #define GLX_LEVEL 3 #define GLX_RGBA 4 #define GLX_DOUBLEBUFFER 5 #define GLX_STEREO 6 #define GLX_AUX_BUFFERS 7 #define GLX_RED_SIZE 8 #define GLX_GREEN_SIZE 9 #define GLX_BLUE_SIZE 10 #define GLX_ALPHA_SIZE 11 #define GLX_DEPTH_SIZE 12 #define GLX_STENCIL_SIZE 13 #define GLX_ACCUM_RED_SIZE 14 #define GLX_ACCUM_GREEN_SIZE 15 #define GLX_ACCUM_BLUE_SIZE 16 #define GLX_ACCUM_ALPHA_SIZE 17 #define GLX_BAD_SCREEN 1 #define GLX_BAD_ATTRIBUTE 2 #define GLX_NO_EXTENSION 3 #define GLX_BAD_VISUAL 4 #define GLX_BAD_CONTEXT 5 #define GLX_BAD_VALUE 6 #define GLX_BAD_ENUM 7 typedef XID GLXDrawable; typedef XID GLXPixmap; #ifdef __sun typedef struct __glXContextRec *GLXContext; #else typedef struct __GLXcontextRec *GLXContext; #endif typedef unsigned int GLXVideoDeviceNV; extern Bool glXQueryExtension (Display *dpy, int *errorBase, int *eventBase); extern Bool glXQueryVersion (Display *dpy, int *major, int *minor); extern int glXGetConfig (Display *dpy, XVisualInfo *vis, int attrib, int *value); extern XVisualInfo* glXChooseVisual (Display *dpy, int screen, int *attribList); extern GLXPixmap glXCreateGLXPixmap (Display *dpy, XVisualInfo *vis, Pixmap pixmap); extern void glXDestroyGLXPixmap (Display *dpy, GLXPixmap pix); extern GLXContext glXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct); extern void glXDestroyContext (Display *dpy, GLXContext ctx); extern Bool glXIsDirect (Display *dpy, GLXContext ctx); extern void glXCopyContext (Display *dpy, GLXContext src, GLXContext dst, GLulong mask); extern Bool glXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx); extern GLXContext glXGetCurrentContext (void); extern GLXDrawable glXGetCurrentDrawable (void); extern void glXWaitGL (void); extern void glXWaitX (void); extern void glXSwapBuffers (Display *dpy, GLXDrawable drawable); extern void glXUseXFont (Font font, int first, int count, int listBase); #define GLXEW_VERSION_1_0 GLXEW_GET_VAR(__GLXEW_VERSION_1_0) #endif /* GLX_VERSION_1_0 */ /* ---------------------------- GLX_VERSION_1_1 --------------------------- */ #ifndef GLX_VERSION_1_1 #define GLX_VERSION_1_1 #define GLX_VENDOR 0x1 #define GLX_VERSION 0x2 #define GLX_EXTENSIONS 0x3 extern const char* glXQueryExtensionsString (Display *dpy, int screen); extern const char* glXGetClientString (Display *dpy, int name); extern const char* glXQueryServerString (Display *dpy, int screen, int name); #define GLXEW_VERSION_1_1 GLXEW_GET_VAR(__GLXEW_VERSION_1_1) #endif /* GLX_VERSION_1_1 */ /* ---------------------------- GLX_VERSION_1_2 ---------------------------- */ #ifndef GLX_VERSION_1_2 #define GLX_VERSION_1_2 1 typedef Display* ( * PFNGLXGETCURRENTDISPLAYPROC) (void); #define glXGetCurrentDisplay GLXEW_GET_FUN(__glewXGetCurrentDisplay) #define GLXEW_VERSION_1_2 GLXEW_GET_VAR(__GLXEW_VERSION_1_2) #endif /* GLX_VERSION_1_2 */ /* ---------------------------- GLX_VERSION_1_3 ---------------------------- */ #ifndef GLX_VERSION_1_3 #define GLX_VERSION_1_3 1 #define GLX_FRONT_LEFT_BUFFER_BIT 0x00000001 #define GLX_RGBA_BIT 0x00000001 #define GLX_WINDOW_BIT 0x00000001 #define GLX_COLOR_INDEX_BIT 0x00000002 #define GLX_FRONT_RIGHT_BUFFER_BIT 0x00000002 #define GLX_PIXMAP_BIT 0x00000002 #define GLX_BACK_LEFT_BUFFER_BIT 0x00000004 #define GLX_PBUFFER_BIT 0x00000004 #define GLX_BACK_RIGHT_BUFFER_BIT 0x00000008 #define GLX_AUX_BUFFERS_BIT 0x00000010 #define GLX_CONFIG_CAVEAT 0x20 #define GLX_DEPTH_BUFFER_BIT 0x00000020 #define GLX_X_VISUAL_TYPE 0x22 #define GLX_TRANSPARENT_TYPE 0x23 #define GLX_TRANSPARENT_INDEX_VALUE 0x24 #define GLX_TRANSPARENT_RED_VALUE 0x25 #define GLX_TRANSPARENT_GREEN_VALUE 0x26 #define GLX_TRANSPARENT_BLUE_VALUE 0x27 #define GLX_TRANSPARENT_ALPHA_VALUE 0x28 #define GLX_STENCIL_BUFFER_BIT 0x00000040 #define GLX_ACCUM_BUFFER_BIT 0x00000080 #define GLX_NONE 0x8000 #define GLX_SLOW_CONFIG 0x8001 #define GLX_TRUE_COLOR 0x8002 #define GLX_DIRECT_COLOR 0x8003 #define GLX_PSEUDO_COLOR 0x8004 #define GLX_STATIC_COLOR 0x8005 #define GLX_GRAY_SCALE 0x8006 #define GLX_STATIC_GRAY 0x8007 #define GLX_TRANSPARENT_RGB 0x8008 #define GLX_TRANSPARENT_INDEX 0x8009 #define GLX_VISUAL_ID 0x800B #define GLX_SCREEN 0x800C #define GLX_NON_CONFORMANT_CONFIG 0x800D #define GLX_DRAWABLE_TYPE 0x8010 #define GLX_RENDER_TYPE 0x8011 #define GLX_X_RENDERABLE 0x8012 #define GLX_FBCONFIG_ID 0x8013 #define GLX_RGBA_TYPE 0x8014 #define GLX_COLOR_INDEX_TYPE 0x8015 #define GLX_MAX_PBUFFER_WIDTH 0x8016 #define GLX_MAX_PBUFFER_HEIGHT 0x8017 #define GLX_MAX_PBUFFER_PIXELS 0x8018 #define GLX_PRESERVED_CONTENTS 0x801B #define GLX_LARGEST_PBUFFER 0x801C #define GLX_WIDTH 0x801D #define GLX_HEIGHT 0x801E #define GLX_EVENT_MASK 0x801F #define GLX_DAMAGED 0x8020 #define GLX_SAVED 0x8021 #define GLX_WINDOW 0x8022 #define GLX_PBUFFER 0x8023 #define GLX_PBUFFER_HEIGHT 0x8040 #define GLX_PBUFFER_WIDTH 0x8041 #define GLX_PBUFFER_CLOBBER_MASK 0x08000000 #define GLX_DONT_CARE 0xFFFFFFFF typedef XID GLXFBConfigID; typedef XID GLXPbuffer; typedef XID GLXWindow; typedef struct __GLXFBConfigRec *GLXFBConfig; typedef struct { int event_type; int draw_type; unsigned long serial; Bool send_event; Display *display; GLXDrawable drawable; unsigned int buffer_mask; unsigned int aux_buffer; int x, y; int width, height; int count; } GLXPbufferClobberEvent; typedef union __GLXEvent { GLXPbufferClobberEvent glxpbufferclobber; long pad[24]; } GLXEvent; typedef GLXFBConfig* ( * PFNGLXCHOOSEFBCONFIGPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements); typedef GLXContext ( * PFNGLXCREATENEWCONTEXTPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct); typedef GLXPbuffer ( * PFNGLXCREATEPBUFFERPROC) (Display *dpy, GLXFBConfig config, const int *attrib_list); typedef GLXPixmap ( * PFNGLXCREATEPIXMAPPROC) (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list); typedef GLXWindow ( * PFNGLXCREATEWINDOWPROC) (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list); typedef void ( * PFNGLXDESTROYPBUFFERPROC) (Display *dpy, GLXPbuffer pbuf); typedef void ( * PFNGLXDESTROYPIXMAPPROC) (Display *dpy, GLXPixmap pixmap); typedef void ( * PFNGLXDESTROYWINDOWPROC) (Display *dpy, GLXWindow win); typedef GLXDrawable ( * PFNGLXGETCURRENTREADDRAWABLEPROC) (void); typedef int ( * PFNGLXGETFBCONFIGATTRIBPROC) (Display *dpy, GLXFBConfig config, int attribute, int *value); typedef GLXFBConfig* ( * PFNGLXGETFBCONFIGSPROC) (Display *dpy, int screen, int *nelements); typedef void ( * PFNGLXGETSELECTEDEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask); typedef XVisualInfo* ( * PFNGLXGETVISUALFROMFBCONFIGPROC) (Display *dpy, GLXFBConfig config); typedef Bool ( * PFNGLXMAKECONTEXTCURRENTPROC) (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx); typedef int ( * PFNGLXQUERYCONTEXTPROC) (Display *dpy, GLXContext ctx, int attribute, int *value); typedef void ( * PFNGLXQUERYDRAWABLEPROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value); typedef void ( * PFNGLXSELECTEVENTPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask); #define glXChooseFBConfig GLXEW_GET_FUN(__glewXChooseFBConfig) #define glXCreateNewContext GLXEW_GET_FUN(__glewXCreateNewContext) #define glXCreatePbuffer GLXEW_GET_FUN(__glewXCreatePbuffer) #define glXCreatePixmap GLXEW_GET_FUN(__glewXCreatePixmap) #define glXCreateWindow GLXEW_GET_FUN(__glewXCreateWindow) #define glXDestroyPbuffer GLXEW_GET_FUN(__glewXDestroyPbuffer) #define glXDestroyPixmap GLXEW_GET_FUN(__glewXDestroyPixmap) #define glXDestroyWindow GLXEW_GET_FUN(__glewXDestroyWindow) #define glXGetCurrentReadDrawable GLXEW_GET_FUN(__glewXGetCurrentReadDrawable) #define glXGetFBConfigAttrib GLXEW_GET_FUN(__glewXGetFBConfigAttrib) #define glXGetFBConfigs GLXEW_GET_FUN(__glewXGetFBConfigs) #define glXGetSelectedEvent GLXEW_GET_FUN(__glewXGetSelectedEvent) #define glXGetVisualFromFBConfig GLXEW_GET_FUN(__glewXGetVisualFromFBConfig) #define glXMakeContextCurrent GLXEW_GET_FUN(__glewXMakeContextCurrent) #define glXQueryContext GLXEW_GET_FUN(__glewXQueryContext) #define glXQueryDrawable GLXEW_GET_FUN(__glewXQueryDrawable) #define glXSelectEvent GLXEW_GET_FUN(__glewXSelectEvent) #define GLXEW_VERSION_1_3 GLXEW_GET_VAR(__GLXEW_VERSION_1_3) #endif /* GLX_VERSION_1_3 */ /* ---------------------------- GLX_VERSION_1_4 ---------------------------- */ #ifndef GLX_VERSION_1_4 #define GLX_VERSION_1_4 1 #define GLX_SAMPLE_BUFFERS 100000 #define GLX_SAMPLES 100001 extern void ( * glXGetProcAddress (const GLubyte *procName)) (void); #define GLXEW_VERSION_1_4 GLXEW_GET_VAR(__GLXEW_VERSION_1_4) #endif /* GLX_VERSION_1_4 */ /* -------------------------- GLX_3DFX_multisample ------------------------- */ #ifndef GLX_3DFX_multisample #define GLX_3DFX_multisample 1 #define GLX_SAMPLE_BUFFERS_3DFX 0x8050 #define GLX_SAMPLES_3DFX 0x8051 #define GLXEW_3DFX_multisample GLXEW_GET_VAR(__GLXEW_3DFX_multisample) #endif /* GLX_3DFX_multisample */ /* ------------------------ GLX_AMD_gpu_association ------------------------ */ #ifndef GLX_AMD_gpu_association #define GLX_AMD_gpu_association 1 #define GLX_GPU_VENDOR_AMD 0x1F00 #define GLX_GPU_RENDERER_STRING_AMD 0x1F01 #define GLX_GPU_OPENGL_VERSION_STRING_AMD 0x1F02 #define GLX_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2 #define GLX_GPU_RAM_AMD 0x21A3 #define GLX_GPU_CLOCK_AMD 0x21A4 #define GLX_GPU_NUM_PIPES_AMD 0x21A5 #define GLX_GPU_NUM_SIMD_AMD 0x21A6 #define GLX_GPU_NUM_RB_AMD 0x21A7 #define GLX_GPU_NUM_SPI_AMD 0x21A8 typedef void ( * PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC) (GLXContext dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); typedef GLXContext ( * PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC) (unsigned int id, GLXContext share_list); typedef GLXContext ( * PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (unsigned int id, GLXContext share_context, const int* attribList); typedef Bool ( * PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC) (GLXContext ctx); typedef unsigned int ( * PFNGLXGETCONTEXTGPUIDAMDPROC) (GLXContext ctx); typedef GLXContext ( * PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void); typedef unsigned int ( * PFNGLXGETGPUIDSAMDPROC) (unsigned int maxCount, unsigned int* ids); typedef int ( * PFNGLXGETGPUINFOAMDPROC) (unsigned int id, int property, GLenum dataType, unsigned int size, void* data); typedef Bool ( * PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (GLXContext ctx); #define glXBlitContextFramebufferAMD GLXEW_GET_FUN(__glewXBlitContextFramebufferAMD) #define glXCreateAssociatedContextAMD GLXEW_GET_FUN(__glewXCreateAssociatedContextAMD) #define glXCreateAssociatedContextAttribsAMD GLXEW_GET_FUN(__glewXCreateAssociatedContextAttribsAMD) #define glXDeleteAssociatedContextAMD GLXEW_GET_FUN(__glewXDeleteAssociatedContextAMD) #define glXGetContextGPUIDAMD GLXEW_GET_FUN(__glewXGetContextGPUIDAMD) #define glXGetCurrentAssociatedContextAMD GLXEW_GET_FUN(__glewXGetCurrentAssociatedContextAMD) #define glXGetGPUIDsAMD GLXEW_GET_FUN(__glewXGetGPUIDsAMD) #define glXGetGPUInfoAMD GLXEW_GET_FUN(__glewXGetGPUInfoAMD) #define glXMakeAssociatedContextCurrentAMD GLXEW_GET_FUN(__glewXMakeAssociatedContextCurrentAMD) #define GLXEW_AMD_gpu_association GLXEW_GET_VAR(__GLXEW_AMD_gpu_association) #endif /* GLX_AMD_gpu_association */ /* --------------------- GLX_ARB_context_flush_control --------------------- */ #ifndef GLX_ARB_context_flush_control #define GLX_ARB_context_flush_control 1 #define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0x0000 #define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097 #define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098 #define GLXEW_ARB_context_flush_control GLXEW_GET_VAR(__GLXEW_ARB_context_flush_control) #endif /* GLX_ARB_context_flush_control */ /* ------------------------- GLX_ARB_create_context ------------------------ */ #ifndef GLX_ARB_create_context #define GLX_ARB_create_context 1 #define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001 #define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 #define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091 #define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092 #define GLX_CONTEXT_FLAGS_ARB 0x2094 typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list); #define glXCreateContextAttribsARB GLXEW_GET_FUN(__glewXCreateContextAttribsARB) #define GLXEW_ARB_create_context GLXEW_GET_VAR(__GLXEW_ARB_create_context) #endif /* GLX_ARB_create_context */ /* --------------------- GLX_ARB_create_context_profile -------------------- */ #ifndef GLX_ARB_create_context_profile #define GLX_ARB_create_context_profile 1 #define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 #define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 #define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126 #define GLXEW_ARB_create_context_profile GLXEW_GET_VAR(__GLXEW_ARB_create_context_profile) #endif /* GLX_ARB_create_context_profile */ /* ------------------- GLX_ARB_create_context_robustness ------------------- */ #ifndef GLX_ARB_create_context_robustness #define GLX_ARB_create_context_robustness 1 #define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 #define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252 #define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 #define GLX_NO_RESET_NOTIFICATION_ARB 0x8261 #define GLXEW_ARB_create_context_robustness GLXEW_GET_VAR(__GLXEW_ARB_create_context_robustness) #endif /* GLX_ARB_create_context_robustness */ /* ------------------------- GLX_ARB_fbconfig_float ------------------------ */ #ifndef GLX_ARB_fbconfig_float #define GLX_ARB_fbconfig_float 1 #define GLX_RGBA_FLOAT_BIT_ARB 0x00000004 #define GLX_RGBA_FLOAT_TYPE_ARB 0x20B9 #define GLXEW_ARB_fbconfig_float GLXEW_GET_VAR(__GLXEW_ARB_fbconfig_float) #endif /* GLX_ARB_fbconfig_float */ /* ------------------------ GLX_ARB_framebuffer_sRGB ----------------------- */ #ifndef GLX_ARB_framebuffer_sRGB #define GLX_ARB_framebuffer_sRGB 1 #define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2 #define GLXEW_ARB_framebuffer_sRGB GLXEW_GET_VAR(__GLXEW_ARB_framebuffer_sRGB) #endif /* GLX_ARB_framebuffer_sRGB */ /* ------------------------ GLX_ARB_get_proc_address ----------------------- */ #ifndef GLX_ARB_get_proc_address #define GLX_ARB_get_proc_address 1 extern void ( * glXGetProcAddressARB (const GLubyte *procName)) (void); #define GLXEW_ARB_get_proc_address GLXEW_GET_VAR(__GLXEW_ARB_get_proc_address) #endif /* GLX_ARB_get_proc_address */ /* -------------------------- GLX_ARB_multisample -------------------------- */ #ifndef GLX_ARB_multisample #define GLX_ARB_multisample 1 #define GLX_SAMPLE_BUFFERS_ARB 100000 #define GLX_SAMPLES_ARB 100001 #define GLXEW_ARB_multisample GLXEW_GET_VAR(__GLXEW_ARB_multisample) #endif /* GLX_ARB_multisample */ /* ---------------- GLX_ARB_robustness_application_isolation --------------- */ #ifndef GLX_ARB_robustness_application_isolation #define GLX_ARB_robustness_application_isolation 1 #define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008 #define GLXEW_ARB_robustness_application_isolation GLXEW_GET_VAR(__GLXEW_ARB_robustness_application_isolation) #endif /* GLX_ARB_robustness_application_isolation */ /* ---------------- GLX_ARB_robustness_share_group_isolation --------------- */ #ifndef GLX_ARB_robustness_share_group_isolation #define GLX_ARB_robustness_share_group_isolation 1 #define GLX_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008 #define GLXEW_ARB_robustness_share_group_isolation GLXEW_GET_VAR(__GLXEW_ARB_robustness_share_group_isolation) #endif /* GLX_ARB_robustness_share_group_isolation */ /* ---------------------- GLX_ARB_vertex_buffer_object --------------------- */ #ifndef GLX_ARB_vertex_buffer_object #define GLX_ARB_vertex_buffer_object 1 #define GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB 0x2095 #define GLXEW_ARB_vertex_buffer_object GLXEW_GET_VAR(__GLXEW_ARB_vertex_buffer_object) #endif /* GLX_ARB_vertex_buffer_object */ /* ----------------------- GLX_ATI_pixel_format_float ---------------------- */ #ifndef GLX_ATI_pixel_format_float #define GLX_ATI_pixel_format_float 1 #define GLX_RGBA_FLOAT_ATI_BIT 0x00000100 #define GLXEW_ATI_pixel_format_float GLXEW_GET_VAR(__GLXEW_ATI_pixel_format_float) #endif /* GLX_ATI_pixel_format_float */ /* ------------------------- GLX_ATI_render_texture ------------------------ */ #ifndef GLX_ATI_render_texture #define GLX_ATI_render_texture 1 #define GLX_BIND_TO_TEXTURE_RGB_ATI 0x9800 #define GLX_BIND_TO_TEXTURE_RGBA_ATI 0x9801 #define GLX_TEXTURE_FORMAT_ATI 0x9802 #define GLX_TEXTURE_TARGET_ATI 0x9803 #define GLX_MIPMAP_TEXTURE_ATI 0x9804 #define GLX_TEXTURE_RGB_ATI 0x9805 #define GLX_TEXTURE_RGBA_ATI 0x9806 #define GLX_NO_TEXTURE_ATI 0x9807 #define GLX_TEXTURE_CUBE_MAP_ATI 0x9808 #define GLX_TEXTURE_1D_ATI 0x9809 #define GLX_TEXTURE_2D_ATI 0x980A #define GLX_MIPMAP_LEVEL_ATI 0x980B #define GLX_CUBE_MAP_FACE_ATI 0x980C #define GLX_TEXTURE_CUBE_MAP_POSITIVE_X_ATI 0x980D #define GLX_TEXTURE_CUBE_MAP_NEGATIVE_X_ATI 0x980E #define GLX_TEXTURE_CUBE_MAP_POSITIVE_Y_ATI 0x980F #define GLX_TEXTURE_CUBE_MAP_NEGATIVE_Y_ATI 0x9810 #define GLX_TEXTURE_CUBE_MAP_POSITIVE_Z_ATI 0x9811 #define GLX_TEXTURE_CUBE_MAP_NEGATIVE_Z_ATI 0x9812 #define GLX_FRONT_LEFT_ATI 0x9813 #define GLX_FRONT_RIGHT_ATI 0x9814 #define GLX_BACK_LEFT_ATI 0x9815 #define GLX_BACK_RIGHT_ATI 0x9816 #define GLX_AUX0_ATI 0x9817 #define GLX_AUX1_ATI 0x9818 #define GLX_AUX2_ATI 0x9819 #define GLX_AUX3_ATI 0x981A #define GLX_AUX4_ATI 0x981B #define GLX_AUX5_ATI 0x981C #define GLX_AUX6_ATI 0x981D #define GLX_AUX7_ATI 0x981E #define GLX_AUX8_ATI 0x981F #define GLX_AUX9_ATI 0x9820 #define GLX_BIND_TO_TEXTURE_LUMINANCE_ATI 0x9821 #define GLX_BIND_TO_TEXTURE_INTENSITY_ATI 0x9822 typedef void ( * PFNGLXBINDTEXIMAGEATIPROC) (Display *dpy, GLXPbuffer pbuf, int buffer); typedef void ( * PFNGLXDRAWABLEATTRIBATIPROC) (Display *dpy, GLXDrawable draw, const int *attrib_list); typedef void ( * PFNGLXRELEASETEXIMAGEATIPROC) (Display *dpy, GLXPbuffer pbuf, int buffer); #define glXBindTexImageATI GLXEW_GET_FUN(__glewXBindTexImageATI) #define glXDrawableAttribATI GLXEW_GET_FUN(__glewXDrawableAttribATI) #define glXReleaseTexImageATI GLXEW_GET_FUN(__glewXReleaseTexImageATI) #define GLXEW_ATI_render_texture GLXEW_GET_VAR(__GLXEW_ATI_render_texture) #endif /* GLX_ATI_render_texture */ /* --------------------------- GLX_EXT_buffer_age -------------------------- */ #ifndef GLX_EXT_buffer_age #define GLX_EXT_buffer_age 1 #define GLX_BACK_BUFFER_AGE_EXT 0x20F4 #define GLXEW_EXT_buffer_age GLXEW_GET_VAR(__GLXEW_EXT_buffer_age) #endif /* GLX_EXT_buffer_age */ /* ------------------- GLX_EXT_create_context_es2_profile ------------------ */ #ifndef GLX_EXT_create_context_es2_profile #define GLX_EXT_create_context_es2_profile 1 #define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 #define GLXEW_EXT_create_context_es2_profile GLXEW_GET_VAR(__GLXEW_EXT_create_context_es2_profile) #endif /* GLX_EXT_create_context_es2_profile */ /* ------------------- GLX_EXT_create_context_es_profile ------------------- */ #ifndef GLX_EXT_create_context_es_profile #define GLX_EXT_create_context_es_profile 1 #define GLX_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004 #define GLXEW_EXT_create_context_es_profile GLXEW_GET_VAR(__GLXEW_EXT_create_context_es_profile) #endif /* GLX_EXT_create_context_es_profile */ /* --------------------- GLX_EXT_fbconfig_packed_float --------------------- */ #ifndef GLX_EXT_fbconfig_packed_float #define GLX_EXT_fbconfig_packed_float 1 #define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008 #define GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1 #define GLXEW_EXT_fbconfig_packed_float GLXEW_GET_VAR(__GLXEW_EXT_fbconfig_packed_float) #endif /* GLX_EXT_fbconfig_packed_float */ /* ------------------------ GLX_EXT_framebuffer_sRGB ----------------------- */ #ifndef GLX_EXT_framebuffer_sRGB #define GLX_EXT_framebuffer_sRGB 1 #define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20B2 #define GLXEW_EXT_framebuffer_sRGB GLXEW_GET_VAR(__GLXEW_EXT_framebuffer_sRGB) #endif /* GLX_EXT_framebuffer_sRGB */ /* ------------------------- GLX_EXT_import_context ------------------------ */ #ifndef GLX_EXT_import_context #define GLX_EXT_import_context 1 #define GLX_SHARE_CONTEXT_EXT 0x800A #define GLX_VISUAL_ID_EXT 0x800B #define GLX_SCREEN_EXT 0x800C typedef XID GLXContextID; typedef void ( * PFNGLXFREECONTEXTEXTPROC) (Display* dpy, GLXContext context); typedef GLXContextID ( * PFNGLXGETCONTEXTIDEXTPROC) (const GLXContext context); typedef GLXContext ( * PFNGLXIMPORTCONTEXTEXTPROC) (Display* dpy, GLXContextID contextID); typedef int ( * PFNGLXQUERYCONTEXTINFOEXTPROC) (Display* dpy, GLXContext context, int attribute,int *value); #define glXFreeContextEXT GLXEW_GET_FUN(__glewXFreeContextEXT) #define glXGetContextIDEXT GLXEW_GET_FUN(__glewXGetContextIDEXT) #define glXImportContextEXT GLXEW_GET_FUN(__glewXImportContextEXT) #define glXQueryContextInfoEXT GLXEW_GET_FUN(__glewXQueryContextInfoEXT) #define GLXEW_EXT_import_context GLXEW_GET_VAR(__GLXEW_EXT_import_context) #endif /* GLX_EXT_import_context */ /* -------------------------- GLX_EXT_scene_marker ------------------------- */ #ifndef GLX_EXT_scene_marker #define GLX_EXT_scene_marker 1 #define GLXEW_EXT_scene_marker GLXEW_GET_VAR(__GLXEW_EXT_scene_marker) #endif /* GLX_EXT_scene_marker */ /* -------------------------- GLX_EXT_stereo_tree -------------------------- */ #ifndef GLX_EXT_stereo_tree #define GLX_EXT_stereo_tree 1 #define GLX_STEREO_NOTIFY_EXT 0x00000000 #define GLX_STEREO_NOTIFY_MASK_EXT 0x00000001 #define GLX_STEREO_TREE_EXT 0x20F5 #define GLXEW_EXT_stereo_tree GLXEW_GET_VAR(__GLXEW_EXT_stereo_tree) #endif /* GLX_EXT_stereo_tree */ /* -------------------------- GLX_EXT_swap_control ------------------------- */ #ifndef GLX_EXT_swap_control #define GLX_EXT_swap_control 1 #define GLX_SWAP_INTERVAL_EXT 0x20F1 #define GLX_MAX_SWAP_INTERVAL_EXT 0x20F2 typedef void ( * PFNGLXSWAPINTERVALEXTPROC) (Display* dpy, GLXDrawable drawable, int interval); #define glXSwapIntervalEXT GLXEW_GET_FUN(__glewXSwapIntervalEXT) #define GLXEW_EXT_swap_control GLXEW_GET_VAR(__GLXEW_EXT_swap_control) #endif /* GLX_EXT_swap_control */ /* ----------------------- GLX_EXT_swap_control_tear ----------------------- */ #ifndef GLX_EXT_swap_control_tear #define GLX_EXT_swap_control_tear 1 #define GLX_LATE_SWAPS_TEAR_EXT 0x20F3 #define GLXEW_EXT_swap_control_tear GLXEW_GET_VAR(__GLXEW_EXT_swap_control_tear) #endif /* GLX_EXT_swap_control_tear */ /* ---------------------- GLX_EXT_texture_from_pixmap ---------------------- */ #ifndef GLX_EXT_texture_from_pixmap #define GLX_EXT_texture_from_pixmap 1 #define GLX_TEXTURE_1D_BIT_EXT 0x00000001 #define GLX_TEXTURE_2D_BIT_EXT 0x00000002 #define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004 #define GLX_BIND_TO_TEXTURE_RGB_EXT 0x20D0 #define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1 #define GLX_BIND_TO_MIPMAP_TEXTURE_EXT 0x20D2 #define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3 #define GLX_Y_INVERTED_EXT 0x20D4 #define GLX_TEXTURE_FORMAT_EXT 0x20D5 #define GLX_TEXTURE_TARGET_EXT 0x20D6 #define GLX_MIPMAP_TEXTURE_EXT 0x20D7 #define GLX_TEXTURE_FORMAT_NONE_EXT 0x20D8 #define GLX_TEXTURE_FORMAT_RGB_EXT 0x20D9 #define GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA #define GLX_TEXTURE_1D_EXT 0x20DB #define GLX_TEXTURE_2D_EXT 0x20DC #define GLX_TEXTURE_RECTANGLE_EXT 0x20DD #define GLX_FRONT_LEFT_EXT 0x20DE #define GLX_FRONT_RIGHT_EXT 0x20DF #define GLX_BACK_LEFT_EXT 0x20E0 #define GLX_BACK_RIGHT_EXT 0x20E1 #define GLX_AUX0_EXT 0x20E2 #define GLX_AUX1_EXT 0x20E3 #define GLX_AUX2_EXT 0x20E4 #define GLX_AUX3_EXT 0x20E5 #define GLX_AUX4_EXT 0x20E6 #define GLX_AUX5_EXT 0x20E7 #define GLX_AUX6_EXT 0x20E8 #define GLX_AUX7_EXT 0x20E9 #define GLX_AUX8_EXT 0x20EA #define GLX_AUX9_EXT 0x20EB typedef void ( * PFNGLXBINDTEXIMAGEEXTPROC) (Display* display, GLXDrawable drawable, int buffer, const int *attrib_list); typedef void ( * PFNGLXRELEASETEXIMAGEEXTPROC) (Display* display, GLXDrawable drawable, int buffer); #define glXBindTexImageEXT GLXEW_GET_FUN(__glewXBindTexImageEXT) #define glXReleaseTexImageEXT GLXEW_GET_FUN(__glewXReleaseTexImageEXT) #define GLXEW_EXT_texture_from_pixmap GLXEW_GET_VAR(__GLXEW_EXT_texture_from_pixmap) #endif /* GLX_EXT_texture_from_pixmap */ /* -------------------------- GLX_EXT_visual_info -------------------------- */ #ifndef GLX_EXT_visual_info #define GLX_EXT_visual_info 1 #define GLX_X_VISUAL_TYPE_EXT 0x22 #define GLX_TRANSPARENT_TYPE_EXT 0x23 #define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24 #define GLX_TRANSPARENT_RED_VALUE_EXT 0x25 #define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26 #define GLX_TRANSPARENT_BLUE_VALUE_EXT 0x27 #define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28 #define GLX_NONE_EXT 0x8000 #define GLX_TRUE_COLOR_EXT 0x8002 #define GLX_DIRECT_COLOR_EXT 0x8003 #define GLX_PSEUDO_COLOR_EXT 0x8004 #define GLX_STATIC_COLOR_EXT 0x8005 #define GLX_GRAY_SCALE_EXT 0x8006 #define GLX_STATIC_GRAY_EXT 0x8007 #define GLX_TRANSPARENT_RGB_EXT 0x8008 #define GLX_TRANSPARENT_INDEX_EXT 0x8009 #define GLXEW_EXT_visual_info GLXEW_GET_VAR(__GLXEW_EXT_visual_info) #endif /* GLX_EXT_visual_info */ /* ------------------------- GLX_EXT_visual_rating ------------------------- */ #ifndef GLX_EXT_visual_rating #define GLX_EXT_visual_rating 1 #define GLX_VISUAL_CAVEAT_EXT 0x20 #define GLX_SLOW_VISUAL_EXT 0x8001 #define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D #define GLXEW_EXT_visual_rating GLXEW_GET_VAR(__GLXEW_EXT_visual_rating) #endif /* GLX_EXT_visual_rating */ /* -------------------------- GLX_INTEL_swap_event ------------------------- */ #ifndef GLX_INTEL_swap_event #define GLX_INTEL_swap_event 1 #define GLX_EXCHANGE_COMPLETE_INTEL 0x8180 #define GLX_COPY_COMPLETE_INTEL 0x8181 #define GLX_FLIP_COMPLETE_INTEL 0x8182 #define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK 0x04000000 #define GLXEW_INTEL_swap_event GLXEW_GET_VAR(__GLXEW_INTEL_swap_event) #endif /* GLX_INTEL_swap_event */ /* -------------------------- GLX_MESA_agp_offset -------------------------- */ #ifndef GLX_MESA_agp_offset #define GLX_MESA_agp_offset 1 typedef unsigned int ( * PFNGLXGETAGPOFFSETMESAPROC) (const void* pointer); #define glXGetAGPOffsetMESA GLXEW_GET_FUN(__glewXGetAGPOffsetMESA) #define GLXEW_MESA_agp_offset GLXEW_GET_VAR(__GLXEW_MESA_agp_offset) #endif /* GLX_MESA_agp_offset */ /* ------------------------ GLX_MESA_copy_sub_buffer ----------------------- */ #ifndef GLX_MESA_copy_sub_buffer #define GLX_MESA_copy_sub_buffer 1 typedef void ( * PFNGLXCOPYSUBBUFFERMESAPROC) (Display* dpy, GLXDrawable drawable, int x, int y, int width, int height); #define glXCopySubBufferMESA GLXEW_GET_FUN(__glewXCopySubBufferMESA) #define GLXEW_MESA_copy_sub_buffer GLXEW_GET_VAR(__GLXEW_MESA_copy_sub_buffer) #endif /* GLX_MESA_copy_sub_buffer */ /* ------------------------ GLX_MESA_pixmap_colormap ----------------------- */ #ifndef GLX_MESA_pixmap_colormap #define GLX_MESA_pixmap_colormap 1 typedef GLXPixmap ( * PFNGLXCREATEGLXPIXMAPMESAPROC) (Display* dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap); #define glXCreateGLXPixmapMESA GLXEW_GET_FUN(__glewXCreateGLXPixmapMESA) #define GLXEW_MESA_pixmap_colormap GLXEW_GET_VAR(__GLXEW_MESA_pixmap_colormap) #endif /* GLX_MESA_pixmap_colormap */ /* ------------------------ GLX_MESA_query_renderer ------------------------ */ #ifndef GLX_MESA_query_renderer #define GLX_MESA_query_renderer 1 #define GLX_RENDERER_VENDOR_ID_MESA 0x8183 #define GLX_RENDERER_DEVICE_ID_MESA 0x8184 #define GLX_RENDERER_VERSION_MESA 0x8185 #define GLX_RENDERER_ACCELERATED_MESA 0x8186 #define GLX_RENDERER_VIDEO_MEMORY_MESA 0x8187 #define GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA 0x8188 #define GLX_RENDERER_PREFERRED_PROFILE_MESA 0x8189 #define GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA 0x818A #define GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA 0x818B #define GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA 0x818C #define GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA 0x818D #define GLX_RENDERER_ID_MESA 0x818E typedef Bool ( * PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC) (int attribute, unsigned int* value); typedef const char* ( * PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC) (int attribute); typedef Bool ( * PFNGLXQUERYRENDERERINTEGERMESAPROC) (Display* dpy, int screen, int renderer, int attribute, unsigned int *value); typedef const char* ( * PFNGLXQUERYRENDERERSTRINGMESAPROC) (Display *dpy, int screen, int renderer, int attribute); #define glXQueryCurrentRendererIntegerMESA GLXEW_GET_FUN(__glewXQueryCurrentRendererIntegerMESA) #define glXQueryCurrentRendererStringMESA GLXEW_GET_FUN(__glewXQueryCurrentRendererStringMESA) #define glXQueryRendererIntegerMESA GLXEW_GET_FUN(__glewXQueryRendererIntegerMESA) #define glXQueryRendererStringMESA GLXEW_GET_FUN(__glewXQueryRendererStringMESA) #define GLXEW_MESA_query_renderer GLXEW_GET_VAR(__GLXEW_MESA_query_renderer) #endif /* GLX_MESA_query_renderer */ /* ------------------------ GLX_MESA_release_buffers ----------------------- */ #ifndef GLX_MESA_release_buffers #define GLX_MESA_release_buffers 1 typedef Bool ( * PFNGLXRELEASEBUFFERSMESAPROC) (Display* dpy, GLXDrawable d); #define glXReleaseBuffersMESA GLXEW_GET_FUN(__glewXReleaseBuffersMESA) #define GLXEW_MESA_release_buffers GLXEW_GET_VAR(__GLXEW_MESA_release_buffers) #endif /* GLX_MESA_release_buffers */ /* ------------------------- GLX_MESA_set_3dfx_mode ------------------------ */ #ifndef GLX_MESA_set_3dfx_mode #define GLX_MESA_set_3dfx_mode 1 #define GLX_3DFX_WINDOW_MODE_MESA 0x1 #define GLX_3DFX_FULLSCREEN_MODE_MESA 0x2 typedef GLboolean ( * PFNGLXSET3DFXMODEMESAPROC) (GLint mode); #define glXSet3DfxModeMESA GLXEW_GET_FUN(__glewXSet3DfxModeMESA) #define GLXEW_MESA_set_3dfx_mode GLXEW_GET_VAR(__GLXEW_MESA_set_3dfx_mode) #endif /* GLX_MESA_set_3dfx_mode */ /* ------------------------- GLX_MESA_swap_control ------------------------- */ #ifndef GLX_MESA_swap_control #define GLX_MESA_swap_control 1 typedef int ( * PFNGLXGETSWAPINTERVALMESAPROC) (void); typedef int ( * PFNGLXSWAPINTERVALMESAPROC) (unsigned int interval); #define glXGetSwapIntervalMESA GLXEW_GET_FUN(__glewXGetSwapIntervalMESA) #define glXSwapIntervalMESA GLXEW_GET_FUN(__glewXSwapIntervalMESA) #define GLXEW_MESA_swap_control GLXEW_GET_VAR(__GLXEW_MESA_swap_control) #endif /* GLX_MESA_swap_control */ /* --------------------------- GLX_NV_copy_buffer -------------------------- */ #ifndef GLX_NV_copy_buffer #define GLX_NV_copy_buffer 1 typedef void ( * PFNGLXCOPYBUFFERSUBDATANVPROC) (Display* dpy, GLXContext readCtx, GLXContext writeCtx, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); typedef void ( * PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC) (Display* dpy, GLXContext readCtx, GLXContext writeCtx, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); #define glXCopyBufferSubDataNV GLXEW_GET_FUN(__glewXCopyBufferSubDataNV) #define glXNamedCopyBufferSubDataNV GLXEW_GET_FUN(__glewXNamedCopyBufferSubDataNV) #define GLXEW_NV_copy_buffer GLXEW_GET_VAR(__GLXEW_NV_copy_buffer) #endif /* GLX_NV_copy_buffer */ /* --------------------------- GLX_NV_copy_image --------------------------- */ #ifndef GLX_NV_copy_image #define GLX_NV_copy_image 1 typedef void ( * PFNGLXCOPYIMAGESUBDATANVPROC) (Display *dpy, GLXContext srcCtx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLXContext dstCtx, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); #define glXCopyImageSubDataNV GLXEW_GET_FUN(__glewXCopyImageSubDataNV) #define GLXEW_NV_copy_image GLXEW_GET_VAR(__GLXEW_NV_copy_image) #endif /* GLX_NV_copy_image */ /* ------------------------ GLX_NV_delay_before_swap ----------------------- */ #ifndef GLX_NV_delay_before_swap #define GLX_NV_delay_before_swap 1 typedef Bool ( * PFNGLXDELAYBEFORESWAPNVPROC) (Display* dpy, GLXDrawable drawable, GLfloat seconds); #define glXDelayBeforeSwapNV GLXEW_GET_FUN(__glewXDelayBeforeSwapNV) #define GLXEW_NV_delay_before_swap GLXEW_GET_VAR(__GLXEW_NV_delay_before_swap) #endif /* GLX_NV_delay_before_swap */ /* -------------------------- GLX_NV_float_buffer -------------------------- */ #ifndef GLX_NV_float_buffer #define GLX_NV_float_buffer 1 #define GLX_FLOAT_COMPONENTS_NV 0x20B0 #define GLXEW_NV_float_buffer GLXEW_GET_VAR(__GLXEW_NV_float_buffer) #endif /* GLX_NV_float_buffer */ /* ---------------------- GLX_NV_multisample_coverage ---------------------- */ #ifndef GLX_NV_multisample_coverage #define GLX_NV_multisample_coverage 1 #define GLX_COLOR_SAMPLES_NV 0x20B3 #define GLX_COVERAGE_SAMPLES_NV 100001 #define GLXEW_NV_multisample_coverage GLXEW_GET_VAR(__GLXEW_NV_multisample_coverage) #endif /* GLX_NV_multisample_coverage */ /* -------------------------- GLX_NV_present_video ------------------------- */ #ifndef GLX_NV_present_video #define GLX_NV_present_video 1 #define GLX_NUM_VIDEO_SLOTS_NV 0x20F0 typedef int ( * PFNGLXBINDVIDEODEVICENVPROC) (Display* dpy, unsigned int video_slot, unsigned int video_device, const int *attrib_list); typedef unsigned int* ( * PFNGLXENUMERATEVIDEODEVICESNVPROC) (Display *dpy, int screen, int *nelements); #define glXBindVideoDeviceNV GLXEW_GET_FUN(__glewXBindVideoDeviceNV) #define glXEnumerateVideoDevicesNV GLXEW_GET_FUN(__glewXEnumerateVideoDevicesNV) #define GLXEW_NV_present_video GLXEW_GET_VAR(__GLXEW_NV_present_video) #endif /* GLX_NV_present_video */ /* --------------------------- GLX_NV_swap_group --------------------------- */ #ifndef GLX_NV_swap_group #define GLX_NV_swap_group 1 typedef Bool ( * PFNGLXBINDSWAPBARRIERNVPROC) (Display* dpy, GLuint group, GLuint barrier); typedef Bool ( * PFNGLXJOINSWAPGROUPNVPROC) (Display* dpy, GLXDrawable drawable, GLuint group); typedef Bool ( * PFNGLXQUERYFRAMECOUNTNVPROC) (Display* dpy, int screen, GLuint *count); typedef Bool ( * PFNGLXQUERYMAXSWAPGROUPSNVPROC) (Display* dpy, int screen, GLuint *maxGroups, GLuint *maxBarriers); typedef Bool ( * PFNGLXQUERYSWAPGROUPNVPROC) (Display* dpy, GLXDrawable drawable, GLuint *group, GLuint *barrier); typedef Bool ( * PFNGLXRESETFRAMECOUNTNVPROC) (Display* dpy, int screen); #define glXBindSwapBarrierNV GLXEW_GET_FUN(__glewXBindSwapBarrierNV) #define glXJoinSwapGroupNV GLXEW_GET_FUN(__glewXJoinSwapGroupNV) #define glXQueryFrameCountNV GLXEW_GET_FUN(__glewXQueryFrameCountNV) #define glXQueryMaxSwapGroupsNV GLXEW_GET_FUN(__glewXQueryMaxSwapGroupsNV) #define glXQuerySwapGroupNV GLXEW_GET_FUN(__glewXQuerySwapGroupNV) #define glXResetFrameCountNV GLXEW_GET_FUN(__glewXResetFrameCountNV) #define GLXEW_NV_swap_group GLXEW_GET_VAR(__GLXEW_NV_swap_group) #endif /* GLX_NV_swap_group */ /* ----------------------- GLX_NV_vertex_array_range ----------------------- */ #ifndef GLX_NV_vertex_array_range #define GLX_NV_vertex_array_range 1 typedef void * ( * PFNGLXALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority); typedef void ( * PFNGLXFREEMEMORYNVPROC) (void *pointer); #define glXAllocateMemoryNV GLXEW_GET_FUN(__glewXAllocateMemoryNV) #define glXFreeMemoryNV GLXEW_GET_FUN(__glewXFreeMemoryNV) #define GLXEW_NV_vertex_array_range GLXEW_GET_VAR(__GLXEW_NV_vertex_array_range) #endif /* GLX_NV_vertex_array_range */ /* -------------------------- GLX_NV_video_capture ------------------------- */ #ifndef GLX_NV_video_capture #define GLX_NV_video_capture 1 #define GLX_DEVICE_ID_NV 0x20CD #define GLX_UNIQUE_ID_NV 0x20CE #define GLX_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF typedef XID GLXVideoCaptureDeviceNV; typedef int ( * PFNGLXBINDVIDEOCAPTUREDEVICENVPROC) (Display* dpy, unsigned int video_capture_slot, GLXVideoCaptureDeviceNV device); typedef GLXVideoCaptureDeviceNV * ( * PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC) (Display* dpy, int screen, int *nelements); typedef void ( * PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC) (Display* dpy, GLXVideoCaptureDeviceNV device); typedef int ( * PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC) (Display* dpy, GLXVideoCaptureDeviceNV device, int attribute, int *value); typedef void ( * PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) (Display* dpy, GLXVideoCaptureDeviceNV device); #define glXBindVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXBindVideoCaptureDeviceNV) #define glXEnumerateVideoCaptureDevicesNV GLXEW_GET_FUN(__glewXEnumerateVideoCaptureDevicesNV) #define glXLockVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXLockVideoCaptureDeviceNV) #define glXQueryVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXQueryVideoCaptureDeviceNV) #define glXReleaseVideoCaptureDeviceNV GLXEW_GET_FUN(__glewXReleaseVideoCaptureDeviceNV) #define GLXEW_NV_video_capture GLXEW_GET_VAR(__GLXEW_NV_video_capture) #endif /* GLX_NV_video_capture */ /* ---------------------------- GLX_NV_video_out --------------------------- */ #ifndef GLX_NV_video_out #define GLX_NV_video_out 1 #define GLX_VIDEO_OUT_COLOR_NV 0x20C3 #define GLX_VIDEO_OUT_ALPHA_NV 0x20C4 #define GLX_VIDEO_OUT_DEPTH_NV 0x20C5 #define GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 #define GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 #define GLX_VIDEO_OUT_FRAME_NV 0x20C8 #define GLX_VIDEO_OUT_FIELD_1_NV 0x20C9 #define GLX_VIDEO_OUT_FIELD_2_NV 0x20CA #define GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV 0x20CB #define GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV 0x20CC typedef int ( * PFNGLXBINDVIDEOIMAGENVPROC) (Display* dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer); typedef int ( * PFNGLXGETVIDEODEVICENVPROC) (Display* dpy, int screen, int numVideoDevices, GLXVideoDeviceNV *pVideoDevice); typedef int ( * PFNGLXGETVIDEOINFONVPROC) (Display* dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); typedef int ( * PFNGLXRELEASEVIDEODEVICENVPROC) (Display* dpy, int screen, GLXVideoDeviceNV VideoDevice); typedef int ( * PFNGLXRELEASEVIDEOIMAGENVPROC) (Display* dpy, GLXPbuffer pbuf); typedef int ( * PFNGLXSENDPBUFFERTOVIDEONVPROC) (Display* dpy, GLXPbuffer pbuf, int iBufferType, unsigned long *pulCounterPbuffer, GLboolean bBlock); #define glXBindVideoImageNV GLXEW_GET_FUN(__glewXBindVideoImageNV) #define glXGetVideoDeviceNV GLXEW_GET_FUN(__glewXGetVideoDeviceNV) #define glXGetVideoInfoNV GLXEW_GET_FUN(__glewXGetVideoInfoNV) #define glXReleaseVideoDeviceNV GLXEW_GET_FUN(__glewXReleaseVideoDeviceNV) #define glXReleaseVideoImageNV GLXEW_GET_FUN(__glewXReleaseVideoImageNV) #define glXSendPbufferToVideoNV GLXEW_GET_FUN(__glewXSendPbufferToVideoNV) #define GLXEW_NV_video_out GLXEW_GET_VAR(__GLXEW_NV_video_out) #endif /* GLX_NV_video_out */ /* -------------------------- GLX_OML_swap_method -------------------------- */ #ifndef GLX_OML_swap_method #define GLX_OML_swap_method 1 #define GLX_SWAP_METHOD_OML 0x8060 #define GLX_SWAP_EXCHANGE_OML 0x8061 #define GLX_SWAP_COPY_OML 0x8062 #define GLX_SWAP_UNDEFINED_OML 0x8063 #define GLXEW_OML_swap_method GLXEW_GET_VAR(__GLXEW_OML_swap_method) #endif /* GLX_OML_swap_method */ /* -------------------------- GLX_OML_sync_control ------------------------- */ #ifndef GLX_OML_sync_control #define GLX_OML_sync_control 1 typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display* dpy, GLXDrawable drawable, int32_t* numerator, int32_t* denominator); typedef Bool ( * PFNGLXGETSYNCVALUESOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t* ust, int64_t* msc, int64_t* sbc); typedef int64_t ( * PFNGLXSWAPBUFFERSMSCOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder); typedef Bool ( * PFNGLXWAITFORMSCOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t* ust, int64_t* msc, int64_t* sbc); typedef Bool ( * PFNGLXWAITFORSBCOMLPROC) (Display* dpy, GLXDrawable drawable, int64_t target_sbc, int64_t* ust, int64_t* msc, int64_t* sbc); #define glXGetMscRateOML GLXEW_GET_FUN(__glewXGetMscRateOML) #define glXGetSyncValuesOML GLXEW_GET_FUN(__glewXGetSyncValuesOML) #define glXSwapBuffersMscOML GLXEW_GET_FUN(__glewXSwapBuffersMscOML) #define glXWaitForMscOML GLXEW_GET_FUN(__glewXWaitForMscOML) #define glXWaitForSbcOML GLXEW_GET_FUN(__glewXWaitForSbcOML) #define GLXEW_OML_sync_control GLXEW_GET_VAR(__GLXEW_OML_sync_control) #endif /* GLX_OML_sync_control */ /* ------------------------ GLX_SGIS_blended_overlay ----------------------- */ #ifndef GLX_SGIS_blended_overlay #define GLX_SGIS_blended_overlay 1 #define GLX_BLENDED_RGBA_SGIS 0x8025 #define GLXEW_SGIS_blended_overlay GLXEW_GET_VAR(__GLXEW_SGIS_blended_overlay) #endif /* GLX_SGIS_blended_overlay */ /* -------------------------- GLX_SGIS_color_range ------------------------- */ #ifndef GLX_SGIS_color_range #define GLX_SGIS_color_range 1 #define GLXEW_SGIS_color_range GLXEW_GET_VAR(__GLXEW_SGIS_color_range) #endif /* GLX_SGIS_color_range */ /* -------------------------- GLX_SGIS_multisample ------------------------- */ #ifndef GLX_SGIS_multisample #define GLX_SGIS_multisample 1 #define GLX_SAMPLE_BUFFERS_SGIS 100000 #define GLX_SAMPLES_SGIS 100001 #define GLXEW_SGIS_multisample GLXEW_GET_VAR(__GLXEW_SGIS_multisample) #endif /* GLX_SGIS_multisample */ /* ---------------------- GLX_SGIS_shared_multisample ---------------------- */ #ifndef GLX_SGIS_shared_multisample #define GLX_SGIS_shared_multisample 1 #define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS 0x8026 #define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS 0x8027 #define GLXEW_SGIS_shared_multisample GLXEW_GET_VAR(__GLXEW_SGIS_shared_multisample) #endif /* GLX_SGIS_shared_multisample */ /* --------------------------- GLX_SGIX_fbconfig --------------------------- */ #ifndef GLX_SGIX_fbconfig #define GLX_SGIX_fbconfig 1 #define GLX_RGBA_BIT_SGIX 0x00000001 #define GLX_WINDOW_BIT_SGIX 0x00000001 #define GLX_COLOR_INDEX_BIT_SGIX 0x00000002 #define GLX_PIXMAP_BIT_SGIX 0x00000002 #define GLX_SCREEN_EXT 0x800C #define GLX_DRAWABLE_TYPE_SGIX 0x8010 #define GLX_RENDER_TYPE_SGIX 0x8011 #define GLX_X_RENDERABLE_SGIX 0x8012 #define GLX_FBCONFIG_ID_SGIX 0x8013 #define GLX_RGBA_TYPE_SGIX 0x8014 #define GLX_COLOR_INDEX_TYPE_SGIX 0x8015 typedef XID GLXFBConfigIDSGIX; typedef struct __GLXFBConfigRec *GLXFBConfigSGIX; typedef GLXFBConfigSGIX* ( * PFNGLXCHOOSEFBCONFIGSGIXPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements); typedef GLXContext ( * PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) (Display* dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct); typedef GLXPixmap ( * PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) (Display* dpy, GLXFBConfig config, Pixmap pixmap); typedef int ( * PFNGLXGETFBCONFIGATTRIBSGIXPROC) (Display* dpy, GLXFBConfigSGIX config, int attribute, int *value); typedef GLXFBConfigSGIX ( * PFNGLXGETFBCONFIGFROMVISUALSGIXPROC) (Display* dpy, XVisualInfo *vis); typedef XVisualInfo* ( * PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) (Display *dpy, GLXFBConfig config); #define glXChooseFBConfigSGIX GLXEW_GET_FUN(__glewXChooseFBConfigSGIX) #define glXCreateContextWithConfigSGIX GLXEW_GET_FUN(__glewXCreateContextWithConfigSGIX) #define glXCreateGLXPixmapWithConfigSGIX GLXEW_GET_FUN(__glewXCreateGLXPixmapWithConfigSGIX) #define glXGetFBConfigAttribSGIX GLXEW_GET_FUN(__glewXGetFBConfigAttribSGIX) #define glXGetFBConfigFromVisualSGIX GLXEW_GET_FUN(__glewXGetFBConfigFromVisualSGIX) #define glXGetVisualFromFBConfigSGIX GLXEW_GET_FUN(__glewXGetVisualFromFBConfigSGIX) #define GLXEW_SGIX_fbconfig GLXEW_GET_VAR(__GLXEW_SGIX_fbconfig) #endif /* GLX_SGIX_fbconfig */ /* --------------------------- GLX_SGIX_hyperpipe -------------------------- */ #ifndef GLX_SGIX_hyperpipe #define GLX_SGIX_hyperpipe 1 #define GLX_HYPERPIPE_DISPLAY_PIPE_SGIX 0x00000001 #define GLX_PIPE_RECT_SGIX 0x00000001 #define GLX_HYPERPIPE_RENDER_PIPE_SGIX 0x00000002 #define GLX_PIPE_RECT_LIMITS_SGIX 0x00000002 #define GLX_HYPERPIPE_STEREO_SGIX 0x00000003 #define GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX 0x00000004 #define GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX 80 #define GLX_BAD_HYPERPIPE_CONFIG_SGIX 91 #define GLX_BAD_HYPERPIPE_SGIX 92 #define GLX_HYPERPIPE_ID_SGIX 0x8030 typedef struct { char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; int networkId; } GLXHyperpipeNetworkSGIX; typedef struct { char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; int XOrigin; int YOrigin; int maxHeight; int maxWidth; } GLXPipeRectLimits; typedef struct { char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; int channel; unsigned int participationType; int timeSlice; } GLXHyperpipeConfigSGIX; typedef struct { char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX]; int srcXOrigin; int srcYOrigin; int srcWidth; int srcHeight; int destXOrigin; int destYOrigin; int destWidth; int destHeight; } GLXPipeRect; typedef int ( * PFNGLXBINDHYPERPIPESGIXPROC) (Display *dpy, int hpId); typedef int ( * PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) (Display *dpy, int hpId); typedef int ( * PFNGLXHYPERPIPEATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *attribList); typedef int ( * PFNGLXHYPERPIPECONFIGSGIXPROC) (Display *dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX *cfg, int *hpId); typedef int ( * PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *returnAttribList); typedef int ( * PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) (Display *dpy, int timeSlice, int attrib, int size, void *attribList, void *returnAttribList); typedef GLXHyperpipeConfigSGIX * ( * PFNGLXQUERYHYPERPIPECONFIGSGIXPROC) (Display *dpy, int hpId, int *npipes); typedef GLXHyperpipeNetworkSGIX * ( * PFNGLXQUERYHYPERPIPENETWORKSGIXPROC) (Display *dpy, int *npipes); #define glXBindHyperpipeSGIX GLXEW_GET_FUN(__glewXBindHyperpipeSGIX) #define glXDestroyHyperpipeConfigSGIX GLXEW_GET_FUN(__glewXDestroyHyperpipeConfigSGIX) #define glXHyperpipeAttribSGIX GLXEW_GET_FUN(__glewXHyperpipeAttribSGIX) #define glXHyperpipeConfigSGIX GLXEW_GET_FUN(__glewXHyperpipeConfigSGIX) #define glXQueryHyperpipeAttribSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeAttribSGIX) #define glXQueryHyperpipeBestAttribSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeBestAttribSGIX) #define glXQueryHyperpipeConfigSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeConfigSGIX) #define glXQueryHyperpipeNetworkSGIX GLXEW_GET_FUN(__glewXQueryHyperpipeNetworkSGIX) #define GLXEW_SGIX_hyperpipe GLXEW_GET_VAR(__GLXEW_SGIX_hyperpipe) #endif /* GLX_SGIX_hyperpipe */ /* ---------------------------- GLX_SGIX_pbuffer --------------------------- */ #ifndef GLX_SGIX_pbuffer #define GLX_SGIX_pbuffer 1 #define GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001 #define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002 #define GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004 #define GLX_PBUFFER_BIT_SGIX 0x00000004 #define GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008 #define GLX_AUX_BUFFERS_BIT_SGIX 0x00000010 #define GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020 #define GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040 #define GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080 #define GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100 #define GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016 #define GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017 #define GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018 #define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019 #define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A #define GLX_PRESERVED_CONTENTS_SGIX 0x801B #define GLX_LARGEST_PBUFFER_SGIX 0x801C #define GLX_WIDTH_SGIX 0x801D #define GLX_HEIGHT_SGIX 0x801E #define GLX_EVENT_MASK_SGIX 0x801F #define GLX_DAMAGED_SGIX 0x8020 #define GLX_SAVED_SGIX 0x8021 #define GLX_WINDOW_SGIX 0x8022 #define GLX_PBUFFER_SGIX 0x8023 #define GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000 typedef XID GLXPbufferSGIX; typedef struct { int type; unsigned long serial; Bool send_event; Display *display; GLXDrawable drawable; int event_type; int draw_type; unsigned int mask; int x, y; int width, height; int count; } GLXBufferClobberEventSGIX; typedef GLXPbuffer ( * PFNGLXCREATEGLXPBUFFERSGIXPROC) (Display* dpy, GLXFBConfig config, unsigned int width, unsigned int height, int *attrib_list); typedef void ( * PFNGLXDESTROYGLXPBUFFERSGIXPROC) (Display* dpy, GLXPbuffer pbuf); typedef void ( * PFNGLXGETSELECTEDEVENTSGIXPROC) (Display* dpy, GLXDrawable drawable, unsigned long *mask); typedef void ( * PFNGLXQUERYGLXPBUFFERSGIXPROC) (Display* dpy, GLXPbuffer pbuf, int attribute, unsigned int *value); typedef void ( * PFNGLXSELECTEVENTSGIXPROC) (Display* dpy, GLXDrawable drawable, unsigned long mask); #define glXCreateGLXPbufferSGIX GLXEW_GET_FUN(__glewXCreateGLXPbufferSGIX) #define glXDestroyGLXPbufferSGIX GLXEW_GET_FUN(__glewXDestroyGLXPbufferSGIX) #define glXGetSelectedEventSGIX GLXEW_GET_FUN(__glewXGetSelectedEventSGIX) #define glXQueryGLXPbufferSGIX GLXEW_GET_FUN(__glewXQueryGLXPbufferSGIX) #define glXSelectEventSGIX GLXEW_GET_FUN(__glewXSelectEventSGIX) #define GLXEW_SGIX_pbuffer GLXEW_GET_VAR(__GLXEW_SGIX_pbuffer) #endif /* GLX_SGIX_pbuffer */ /* ------------------------- GLX_SGIX_swap_barrier ------------------------- */ #ifndef GLX_SGIX_swap_barrier #define GLX_SGIX_swap_barrier 1 typedef void ( * PFNGLXBINDSWAPBARRIERSGIXPROC) (Display *dpy, GLXDrawable drawable, int barrier); typedef Bool ( * PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) (Display *dpy, int screen, int *max); #define glXBindSwapBarrierSGIX GLXEW_GET_FUN(__glewXBindSwapBarrierSGIX) #define glXQueryMaxSwapBarriersSGIX GLXEW_GET_FUN(__glewXQueryMaxSwapBarriersSGIX) #define GLXEW_SGIX_swap_barrier GLXEW_GET_VAR(__GLXEW_SGIX_swap_barrier) #endif /* GLX_SGIX_swap_barrier */ /* -------------------------- GLX_SGIX_swap_group -------------------------- */ #ifndef GLX_SGIX_swap_group #define GLX_SGIX_swap_group 1 typedef void ( * PFNGLXJOINSWAPGROUPSGIXPROC) (Display *dpy, GLXDrawable drawable, GLXDrawable member); #define glXJoinSwapGroupSGIX GLXEW_GET_FUN(__glewXJoinSwapGroupSGIX) #define GLXEW_SGIX_swap_group GLXEW_GET_VAR(__GLXEW_SGIX_swap_group) #endif /* GLX_SGIX_swap_group */ /* ------------------------- GLX_SGIX_video_resize ------------------------- */ #ifndef GLX_SGIX_video_resize #define GLX_SGIX_video_resize 1 #define GLX_SYNC_FRAME_SGIX 0x00000000 #define GLX_SYNC_SWAP_SGIX 0x00000001 typedef int ( * PFNGLXBINDCHANNELTOWINDOWSGIXPROC) (Display* display, int screen, int channel, Window window); typedef int ( * PFNGLXCHANNELRECTSGIXPROC) (Display* display, int screen, int channel, int x, int y, int w, int h); typedef int ( * PFNGLXCHANNELRECTSYNCSGIXPROC) (Display* display, int screen, int channel, GLenum synctype); typedef int ( * PFNGLXQUERYCHANNELDELTASSGIXPROC) (Display* display, int screen, int channel, int *x, int *y, int *w, int *h); typedef int ( * PFNGLXQUERYCHANNELRECTSGIXPROC) (Display* display, int screen, int channel, int *dx, int *dy, int *dw, int *dh); #define glXBindChannelToWindowSGIX GLXEW_GET_FUN(__glewXBindChannelToWindowSGIX) #define glXChannelRectSGIX GLXEW_GET_FUN(__glewXChannelRectSGIX) #define glXChannelRectSyncSGIX GLXEW_GET_FUN(__glewXChannelRectSyncSGIX) #define glXQueryChannelDeltasSGIX GLXEW_GET_FUN(__glewXQueryChannelDeltasSGIX) #define glXQueryChannelRectSGIX GLXEW_GET_FUN(__glewXQueryChannelRectSGIX) #define GLXEW_SGIX_video_resize GLXEW_GET_VAR(__GLXEW_SGIX_video_resize) #endif /* GLX_SGIX_video_resize */ /* ---------------------- GLX_SGIX_visual_select_group --------------------- */ #ifndef GLX_SGIX_visual_select_group #define GLX_SGIX_visual_select_group 1 #define GLX_VISUAL_SELECT_GROUP_SGIX 0x8028 #define GLXEW_SGIX_visual_select_group GLXEW_GET_VAR(__GLXEW_SGIX_visual_select_group) #endif /* GLX_SGIX_visual_select_group */ /* ---------------------------- GLX_SGI_cushion ---------------------------- */ #ifndef GLX_SGI_cushion #define GLX_SGI_cushion 1 typedef void ( * PFNGLXCUSHIONSGIPROC) (Display* dpy, Window window, float cushion); #define glXCushionSGI GLXEW_GET_FUN(__glewXCushionSGI) #define GLXEW_SGI_cushion GLXEW_GET_VAR(__GLXEW_SGI_cushion) #endif /* GLX_SGI_cushion */ /* ----------------------- GLX_SGI_make_current_read ----------------------- */ #ifndef GLX_SGI_make_current_read #define GLX_SGI_make_current_read 1 typedef GLXDrawable ( * PFNGLXGETCURRENTREADDRAWABLESGIPROC) (void); typedef Bool ( * PFNGLXMAKECURRENTREADSGIPROC) (Display* dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx); #define glXGetCurrentReadDrawableSGI GLXEW_GET_FUN(__glewXGetCurrentReadDrawableSGI) #define glXMakeCurrentReadSGI GLXEW_GET_FUN(__glewXMakeCurrentReadSGI) #define GLXEW_SGI_make_current_read GLXEW_GET_VAR(__GLXEW_SGI_make_current_read) #endif /* GLX_SGI_make_current_read */ /* -------------------------- GLX_SGI_swap_control ------------------------- */ #ifndef GLX_SGI_swap_control #define GLX_SGI_swap_control 1 typedef int ( * PFNGLXSWAPINTERVALSGIPROC) (int interval); #define glXSwapIntervalSGI GLXEW_GET_FUN(__glewXSwapIntervalSGI) #define GLXEW_SGI_swap_control GLXEW_GET_VAR(__GLXEW_SGI_swap_control) #endif /* GLX_SGI_swap_control */ /* --------------------------- GLX_SGI_video_sync -------------------------- */ #ifndef GLX_SGI_video_sync #define GLX_SGI_video_sync 1 typedef int ( * PFNGLXGETVIDEOSYNCSGIPROC) (unsigned int* count); typedef int ( * PFNGLXWAITVIDEOSYNCSGIPROC) (int divisor, int remainder, unsigned int* count); #define glXGetVideoSyncSGI GLXEW_GET_FUN(__glewXGetVideoSyncSGI) #define glXWaitVideoSyncSGI GLXEW_GET_FUN(__glewXWaitVideoSyncSGI) #define GLXEW_SGI_video_sync GLXEW_GET_VAR(__GLXEW_SGI_video_sync) #endif /* GLX_SGI_video_sync */ /* --------------------- GLX_SUN_get_transparent_index --------------------- */ #ifndef GLX_SUN_get_transparent_index #define GLX_SUN_get_transparent_index 1 typedef Status ( * PFNGLXGETTRANSPARENTINDEXSUNPROC) (Display* dpy, Window overlay, Window underlay, unsigned long *pTransparentIndex); #define glXGetTransparentIndexSUN GLXEW_GET_FUN(__glewXGetTransparentIndexSUN) #define GLXEW_SUN_get_transparent_index GLXEW_GET_VAR(__GLXEW_SUN_get_transparent_index) #endif /* GLX_SUN_get_transparent_index */ /* -------------------------- GLX_SUN_video_resize ------------------------- */ #ifndef GLX_SUN_video_resize #define GLX_SUN_video_resize 1 #define GLX_VIDEO_RESIZE_SUN 0x8171 #define GL_VIDEO_RESIZE_COMPENSATION_SUN 0x85CD typedef int ( * PFNGLXGETVIDEORESIZESUNPROC) (Display* display, GLXDrawable window, float* factor); typedef int ( * PFNGLXVIDEORESIZESUNPROC) (Display* display, GLXDrawable window, float factor); #define glXGetVideoResizeSUN GLXEW_GET_FUN(__glewXGetVideoResizeSUN) #define glXVideoResizeSUN GLXEW_GET_FUN(__glewXVideoResizeSUN) #define GLXEW_SUN_video_resize GLXEW_GET_VAR(__GLXEW_SUN_video_resize) #endif /* GLX_SUN_video_resize */ /* ------------------------------------------------------------------------- */ #ifdef GLEW_MX #define GLXEW_FUN_EXPORT GLEW_FUN_EXPORT #define GLXEW_VAR_EXPORT #else #define GLXEW_FUN_EXPORT GLEW_FUN_EXPORT #define GLXEW_VAR_EXPORT GLEW_VAR_EXPORT #endif /* GLEW_MX */ GLXEW_FUN_EXPORT PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay; GLXEW_FUN_EXPORT PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig; GLXEW_FUN_EXPORT PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext; GLXEW_FUN_EXPORT PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer; GLXEW_FUN_EXPORT PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap; GLXEW_FUN_EXPORT PFNGLXCREATEWINDOWPROC __glewXCreateWindow; GLXEW_FUN_EXPORT PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer; GLXEW_FUN_EXPORT PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap; GLXEW_FUN_EXPORT PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow; GLXEW_FUN_EXPORT PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable; GLXEW_FUN_EXPORT PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib; GLXEW_FUN_EXPORT PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs; GLXEW_FUN_EXPORT PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent; GLXEW_FUN_EXPORT PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig; GLXEW_FUN_EXPORT PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent; GLXEW_FUN_EXPORT PFNGLXQUERYCONTEXTPROC __glewXQueryContext; GLXEW_FUN_EXPORT PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable; GLXEW_FUN_EXPORT PFNGLXSELECTEVENTPROC __glewXSelectEvent; GLXEW_FUN_EXPORT PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC __glewXBlitContextFramebufferAMD; GLXEW_FUN_EXPORT PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC __glewXCreateAssociatedContextAMD; GLXEW_FUN_EXPORT PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __glewXCreateAssociatedContextAttribsAMD; GLXEW_FUN_EXPORT PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC __glewXDeleteAssociatedContextAMD; GLXEW_FUN_EXPORT PFNGLXGETCONTEXTGPUIDAMDPROC __glewXGetContextGPUIDAMD; GLXEW_FUN_EXPORT PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC __glewXGetCurrentAssociatedContextAMD; GLXEW_FUN_EXPORT PFNGLXGETGPUIDSAMDPROC __glewXGetGPUIDsAMD; GLXEW_FUN_EXPORT PFNGLXGETGPUINFOAMDPROC __glewXGetGPUInfoAMD; GLXEW_FUN_EXPORT PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __glewXMakeAssociatedContextCurrentAMD; GLXEW_FUN_EXPORT PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB; GLXEW_FUN_EXPORT PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI; GLXEW_FUN_EXPORT PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI; GLXEW_FUN_EXPORT PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI; GLXEW_FUN_EXPORT PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT; GLXEW_FUN_EXPORT PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT; GLXEW_FUN_EXPORT PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT; GLXEW_FUN_EXPORT PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT; GLXEW_FUN_EXPORT PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT; GLXEW_FUN_EXPORT PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT; GLXEW_FUN_EXPORT PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT; GLXEW_FUN_EXPORT PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA; GLXEW_FUN_EXPORT PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA; GLXEW_FUN_EXPORT PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA; GLXEW_FUN_EXPORT PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC __glewXQueryCurrentRendererIntegerMESA; GLXEW_FUN_EXPORT PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC __glewXQueryCurrentRendererStringMESA; GLXEW_FUN_EXPORT PFNGLXQUERYRENDERERINTEGERMESAPROC __glewXQueryRendererIntegerMESA; GLXEW_FUN_EXPORT PFNGLXQUERYRENDERERSTRINGMESAPROC __glewXQueryRendererStringMESA; GLXEW_FUN_EXPORT PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA; GLXEW_FUN_EXPORT PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA; GLXEW_FUN_EXPORT PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA; GLXEW_FUN_EXPORT PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA; GLXEW_FUN_EXPORT PFNGLXCOPYBUFFERSUBDATANVPROC __glewXCopyBufferSubDataNV; GLXEW_FUN_EXPORT PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC __glewXNamedCopyBufferSubDataNV; GLXEW_FUN_EXPORT PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV; GLXEW_FUN_EXPORT PFNGLXDELAYBEFORESWAPNVPROC __glewXDelayBeforeSwapNV; GLXEW_FUN_EXPORT PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV; GLXEW_FUN_EXPORT PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV; GLXEW_FUN_EXPORT PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV; GLXEW_FUN_EXPORT PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV; GLXEW_FUN_EXPORT PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV; GLXEW_FUN_EXPORT PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV; GLXEW_FUN_EXPORT PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV; GLXEW_FUN_EXPORT PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV; GLXEW_FUN_EXPORT PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV; GLXEW_FUN_EXPORT PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV; GLXEW_FUN_EXPORT PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV; GLXEW_FUN_EXPORT PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV; GLXEW_FUN_EXPORT PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV; GLXEW_FUN_EXPORT PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV; GLXEW_FUN_EXPORT PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV; GLXEW_FUN_EXPORT PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV; GLXEW_FUN_EXPORT PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV; GLXEW_FUN_EXPORT PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV; GLXEW_FUN_EXPORT PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV; GLXEW_FUN_EXPORT PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV; GLXEW_FUN_EXPORT PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV; GLXEW_FUN_EXPORT PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML; GLXEW_FUN_EXPORT PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML; GLXEW_FUN_EXPORT PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML; GLXEW_FUN_EXPORT PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML; GLXEW_FUN_EXPORT PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML; GLXEW_FUN_EXPORT PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX; GLXEW_FUN_EXPORT PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX; GLXEW_FUN_EXPORT PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX; GLXEW_FUN_EXPORT PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX; GLXEW_FUN_EXPORT PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX; GLXEW_FUN_EXPORT PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX; GLXEW_FUN_EXPORT PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX; GLXEW_FUN_EXPORT PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX; GLXEW_FUN_EXPORT PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX; GLXEW_FUN_EXPORT PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX; GLXEW_FUN_EXPORT PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX; GLXEW_FUN_EXPORT PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX; GLXEW_FUN_EXPORT PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX; GLXEW_FUN_EXPORT PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX; GLXEW_FUN_EXPORT PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX; GLXEW_FUN_EXPORT PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX; GLXEW_FUN_EXPORT PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX; GLXEW_FUN_EXPORT PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX; GLXEW_FUN_EXPORT PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX; GLXEW_FUN_EXPORT PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX; GLXEW_FUN_EXPORT PFNGLXCUSHIONSGIPROC __glewXCushionSGI; GLXEW_FUN_EXPORT PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI; GLXEW_FUN_EXPORT PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI; GLXEW_FUN_EXPORT PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI; GLXEW_FUN_EXPORT PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI; GLXEW_FUN_EXPORT PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI; GLXEW_FUN_EXPORT PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN; GLXEW_FUN_EXPORT PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN; GLXEW_FUN_EXPORT PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN; #if defined(GLEW_MX) struct GLXEWContextStruct { #endif /* GLEW_MX */ GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_0; GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_1; GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_2; GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_3; GLXEW_VAR_EXPORT GLboolean __GLXEW_VERSION_1_4; GLXEW_VAR_EXPORT GLboolean __GLXEW_3DFX_multisample; GLXEW_VAR_EXPORT GLboolean __GLXEW_AMD_gpu_association; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_context_flush_control; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context_profile; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context_robustness; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_fbconfig_float; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_framebuffer_sRGB; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_get_proc_address; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_multisample; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_robustness_application_isolation; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_robustness_share_group_isolation; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_vertex_buffer_object; GLXEW_VAR_EXPORT GLboolean __GLXEW_ATI_pixel_format_float; GLXEW_VAR_EXPORT GLboolean __GLXEW_ATI_render_texture; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_buffer_age; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_create_context_es2_profile; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_create_context_es_profile; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_fbconfig_packed_float; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_framebuffer_sRGB; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_import_context; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_scene_marker; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_stereo_tree; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_swap_control; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_swap_control_tear; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_texture_from_pixmap; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_visual_info; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_visual_rating; GLXEW_VAR_EXPORT GLboolean __GLXEW_INTEL_swap_event; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_agp_offset; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_copy_sub_buffer; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_pixmap_colormap; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_query_renderer; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_release_buffers; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_set_3dfx_mode; GLXEW_VAR_EXPORT GLboolean __GLXEW_MESA_swap_control; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_copy_buffer; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_copy_image; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_delay_before_swap; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_float_buffer; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_multisample_coverage; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_present_video; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_swap_group; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_vertex_array_range; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_video_capture; GLXEW_VAR_EXPORT GLboolean __GLXEW_NV_video_out; GLXEW_VAR_EXPORT GLboolean __GLXEW_OML_swap_method; GLXEW_VAR_EXPORT GLboolean __GLXEW_OML_sync_control; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIS_blended_overlay; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIS_color_range; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIS_multisample; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIS_shared_multisample; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_fbconfig; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_hyperpipe; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_pbuffer; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_swap_barrier; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_swap_group; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_video_resize; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGIX_visual_select_group; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGI_cushion; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGI_make_current_read; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGI_swap_control; GLXEW_VAR_EXPORT GLboolean __GLXEW_SGI_video_sync; GLXEW_VAR_EXPORT GLboolean __GLXEW_SUN_get_transparent_index; GLXEW_VAR_EXPORT GLboolean __GLXEW_SUN_video_resize; #ifdef GLEW_MX }; /* GLXEWContextStruct */ #endif /* GLEW_MX */ /* ------------------------------------------------------------------------ */ #ifdef GLEW_MX typedef struct GLXEWContextStruct GLXEWContext; GLEWAPI GLenum GLEWAPIENTRY glxewContextInit (GLXEWContext *ctx); GLEWAPI GLboolean GLEWAPIENTRY glxewContextIsSupported (const GLXEWContext *ctx, const char *name); #define glxewInit() glxewContextInit(glxewGetContext()) #define glxewIsSupported(x) glxewContextIsSupported(glxewGetContext(), x) #define GLXEW_GET_VAR(x) (*(const GLboolean*)&(glxewGetContext()->x)) #define GLXEW_GET_FUN(x) x #else /* GLEW_MX */ GLEWAPI GLenum GLEWAPIENTRY glxewInit (); GLEWAPI GLboolean GLEWAPIENTRY glxewIsSupported (const char *name); #define GLXEW_GET_VAR(x) (*(const GLboolean*)&x) #define GLXEW_GET_FUN(x) x #endif /* GLEW_MX */ GLEWAPI GLboolean GLEWAPIENTRY glxewGetExtension (const char *name); #ifdef __cplusplus } #endif #endif /* __glxew_h__ */ Slic3r-version_1.31.6/xs/src/glew/include/GL/wglew.h000066400000000000000000001737001301441720000221100ustar00rootroot00000000000000/* ** The OpenGL Extension Wrangler Library ** Copyright (C) 2008-2015, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are met: ** ** * Redistributions of source code must retain the above copyright notice, ** this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright notice, ** this list of conditions and the following disclaimer in the documentation ** and/or other materials provided with the distribution. ** * The name of the author may be used to endorse or promote products ** derived from this software without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF ** THE POSSIBILITY OF SUCH DAMAGE. */ /* ** Copyright (c) 2007 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a ** copy of this software and/or associated documentation files (the ** "Materials"), to deal in the Materials without restriction, including ** without limitation the rights to use, copy, modify, merge, publish, ** distribute, sublicense, and/or sell copies of the Materials, and to ** permit persons to whom the Materials are furnished to do so, subject to ** the following conditions: ** ** The above copyright notice and this permission notice shall be included ** in all copies or substantial portions of the Materials. ** ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. */ #ifndef __wglew_h__ #define __wglew_h__ #define __WGLEW_H__ #ifdef __wglext_h_ #error wglext.h included before wglew.h #endif #define __wglext_h_ #if !defined(WINAPI) # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN 1 # endif # ifdef NOGDI # undef NOGDI # endif #include # undef WIN32_LEAN_AND_MEAN #endif /* * GLEW_STATIC needs to be set when using the static version. * GLEW_BUILD is set when building the DLL version. */ #ifdef GLEW_STATIC # define GLEWAPI extern #else # ifdef GLEW_BUILD # define GLEWAPI extern __declspec(dllexport) # else # define GLEWAPI extern __declspec(dllimport) # endif #endif #ifdef __cplusplus extern "C" { #endif /* -------------------------- WGL_3DFX_multisample ------------------------- */ #ifndef WGL_3DFX_multisample #define WGL_3DFX_multisample 1 #define WGL_SAMPLE_BUFFERS_3DFX 0x2060 #define WGL_SAMPLES_3DFX 0x2061 #define WGLEW_3DFX_multisample WGLEW_GET_VAR(__WGLEW_3DFX_multisample) #endif /* WGL_3DFX_multisample */ /* ------------------------- WGL_3DL_stereo_control ------------------------ */ #ifndef WGL_3DL_stereo_control #define WGL_3DL_stereo_control 1 #define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055 #define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056 #define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057 #define WGL_STEREO_POLARITY_INVERT_3DL 0x2058 typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState); #define wglSetStereoEmitterState3DL WGLEW_GET_FUN(__wglewSetStereoEmitterState3DL) #define WGLEW_3DL_stereo_control WGLEW_GET_VAR(__WGLEW_3DL_stereo_control) #endif /* WGL_3DL_stereo_control */ /* ------------------------ WGL_AMD_gpu_association ------------------------ */ #ifndef WGL_AMD_gpu_association #define WGL_AMD_gpu_association 1 #define WGL_GPU_VENDOR_AMD 0x1F00 #define WGL_GPU_RENDERER_STRING_AMD 0x1F01 #define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02 #define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2 #define WGL_GPU_RAM_AMD 0x21A3 #define WGL_GPU_CLOCK_AMD 0x21A4 #define WGL_GPU_NUM_PIPES_AMD 0x21A5 #define WGL_GPU_NUM_SIMD_AMD 0x21A6 #define WGL_GPU_NUM_RB_AMD 0x21A7 #define WGL_GPU_NUM_SPI_AMD 0x21A8 typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id); typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int* attribList); typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc); typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc); typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void); typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT* ids); typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, INT property, GLenum dataType, UINT size, void* data); typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc); #define wglBlitContextFramebufferAMD WGLEW_GET_FUN(__wglewBlitContextFramebufferAMD) #define wglCreateAssociatedContextAMD WGLEW_GET_FUN(__wglewCreateAssociatedContextAMD) #define wglCreateAssociatedContextAttribsAMD WGLEW_GET_FUN(__wglewCreateAssociatedContextAttribsAMD) #define wglDeleteAssociatedContextAMD WGLEW_GET_FUN(__wglewDeleteAssociatedContextAMD) #define wglGetContextGPUIDAMD WGLEW_GET_FUN(__wglewGetContextGPUIDAMD) #define wglGetCurrentAssociatedContextAMD WGLEW_GET_FUN(__wglewGetCurrentAssociatedContextAMD) #define wglGetGPUIDsAMD WGLEW_GET_FUN(__wglewGetGPUIDsAMD) #define wglGetGPUInfoAMD WGLEW_GET_FUN(__wglewGetGPUInfoAMD) #define wglMakeAssociatedContextCurrentAMD WGLEW_GET_FUN(__wglewMakeAssociatedContextCurrentAMD) #define WGLEW_AMD_gpu_association WGLEW_GET_VAR(__WGLEW_AMD_gpu_association) #endif /* WGL_AMD_gpu_association */ /* ------------------------- WGL_ARB_buffer_region ------------------------- */ #ifndef WGL_ARB_buffer_region #define WGL_ARB_buffer_region 1 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001 #define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002 #define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004 #define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008 typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType); typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion); typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height); #define wglCreateBufferRegionARB WGLEW_GET_FUN(__wglewCreateBufferRegionARB) #define wglDeleteBufferRegionARB WGLEW_GET_FUN(__wglewDeleteBufferRegionARB) #define wglRestoreBufferRegionARB WGLEW_GET_FUN(__wglewRestoreBufferRegionARB) #define wglSaveBufferRegionARB WGLEW_GET_FUN(__wglewSaveBufferRegionARB) #define WGLEW_ARB_buffer_region WGLEW_GET_VAR(__WGLEW_ARB_buffer_region) #endif /* WGL_ARB_buffer_region */ /* --------------------- WGL_ARB_context_flush_control --------------------- */ #ifndef WGL_ARB_context_flush_control #define WGL_ARB_context_flush_control 1 #define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0x0000 #define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097 #define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098 #define WGLEW_ARB_context_flush_control WGLEW_GET_VAR(__WGLEW_ARB_context_flush_control) #endif /* WGL_ARB_context_flush_control */ /* ------------------------- WGL_ARB_create_context ------------------------ */ #ifndef WGL_ARB_create_context #define WGL_ARB_create_context 1 #define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 #define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 #define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 #define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 #define WGL_CONTEXT_FLAGS_ARB 0x2094 #define ERROR_INVALID_VERSION_ARB 0x2095 #define ERROR_INVALID_PROFILE_ARB 0x2096 typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int* attribList); #define wglCreateContextAttribsARB WGLEW_GET_FUN(__wglewCreateContextAttribsARB) #define WGLEW_ARB_create_context WGLEW_GET_VAR(__WGLEW_ARB_create_context) #endif /* WGL_ARB_create_context */ /* --------------------- WGL_ARB_create_context_profile -------------------- */ #ifndef WGL_ARB_create_context_profile #define WGL_ARB_create_context_profile 1 #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 #define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 #define WGLEW_ARB_create_context_profile WGLEW_GET_VAR(__WGLEW_ARB_create_context_profile) #endif /* WGL_ARB_create_context_profile */ /* ------------------- WGL_ARB_create_context_robustness ------------------- */ #ifndef WGL_ARB_create_context_robustness #define WGL_ARB_create_context_robustness 1 #define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 #define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252 #define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 #define WGL_NO_RESET_NOTIFICATION_ARB 0x8261 #define WGLEW_ARB_create_context_robustness WGLEW_GET_VAR(__WGLEW_ARB_create_context_robustness) #endif /* WGL_ARB_create_context_robustness */ /* ----------------------- WGL_ARB_extensions_string ----------------------- */ #ifndef WGL_ARB_extensions_string #define WGL_ARB_extensions_string 1 typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); #define wglGetExtensionsStringARB WGLEW_GET_FUN(__wglewGetExtensionsStringARB) #define WGLEW_ARB_extensions_string WGLEW_GET_VAR(__WGLEW_ARB_extensions_string) #endif /* WGL_ARB_extensions_string */ /* ------------------------ WGL_ARB_framebuffer_sRGB ----------------------- */ #ifndef WGL_ARB_framebuffer_sRGB #define WGL_ARB_framebuffer_sRGB 1 #define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9 #define WGLEW_ARB_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_ARB_framebuffer_sRGB) #endif /* WGL_ARB_framebuffer_sRGB */ /* ----------------------- WGL_ARB_make_current_read ----------------------- */ #ifndef WGL_ARB_make_current_read #define WGL_ARB_make_current_read 1 #define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043 #define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054 typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (VOID); typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); #define wglGetCurrentReadDCARB WGLEW_GET_FUN(__wglewGetCurrentReadDCARB) #define wglMakeContextCurrentARB WGLEW_GET_FUN(__wglewMakeContextCurrentARB) #define WGLEW_ARB_make_current_read WGLEW_GET_VAR(__WGLEW_ARB_make_current_read) #endif /* WGL_ARB_make_current_read */ /* -------------------------- WGL_ARB_multisample -------------------------- */ #ifndef WGL_ARB_multisample #define WGL_ARB_multisample 1 #define WGL_SAMPLE_BUFFERS_ARB 0x2041 #define WGL_SAMPLES_ARB 0x2042 #define WGLEW_ARB_multisample WGLEW_GET_VAR(__WGLEW_ARB_multisample) #endif /* WGL_ARB_multisample */ /* ---------------------------- WGL_ARB_pbuffer ---------------------------- */ #ifndef WGL_ARB_pbuffer #define WGL_ARB_pbuffer 1 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 #define WGL_PBUFFER_LARGEST_ARB 0x2033 #define WGL_PBUFFER_WIDTH_ARB 0x2034 #define WGL_PBUFFER_HEIGHT_ARB 0x2035 #define WGL_PBUFFER_LOST_ARB 0x2036 DECLARE_HANDLE(HPBUFFERARB); typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList); typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int* piValue); typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); #define wglCreatePbufferARB WGLEW_GET_FUN(__wglewCreatePbufferARB) #define wglDestroyPbufferARB WGLEW_GET_FUN(__wglewDestroyPbufferARB) #define wglGetPbufferDCARB WGLEW_GET_FUN(__wglewGetPbufferDCARB) #define wglQueryPbufferARB WGLEW_GET_FUN(__wglewQueryPbufferARB) #define wglReleasePbufferDCARB WGLEW_GET_FUN(__wglewReleasePbufferDCARB) #define WGLEW_ARB_pbuffer WGLEW_GET_VAR(__WGLEW_ARB_pbuffer) #endif /* WGL_ARB_pbuffer */ /* -------------------------- WGL_ARB_pixel_format ------------------------- */ #ifndef WGL_ARB_pixel_format #define WGL_ARB_pixel_format 1 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 #define WGL_DRAW_TO_WINDOW_ARB 0x2001 #define WGL_DRAW_TO_BITMAP_ARB 0x2002 #define WGL_ACCELERATION_ARB 0x2003 #define WGL_NEED_PALETTE_ARB 0x2004 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 #define WGL_SWAP_METHOD_ARB 0x2007 #define WGL_NUMBER_OVERLAYS_ARB 0x2008 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009 #define WGL_TRANSPARENT_ARB 0x200A #define WGL_SHARE_DEPTH_ARB 0x200C #define WGL_SHARE_STENCIL_ARB 0x200D #define WGL_SHARE_ACCUM_ARB 0x200E #define WGL_SUPPORT_GDI_ARB 0x200F #define WGL_SUPPORT_OPENGL_ARB 0x2010 #define WGL_DOUBLE_BUFFER_ARB 0x2011 #define WGL_STEREO_ARB 0x2012 #define WGL_PIXEL_TYPE_ARB 0x2013 #define WGL_COLOR_BITS_ARB 0x2014 #define WGL_RED_BITS_ARB 0x2015 #define WGL_RED_SHIFT_ARB 0x2016 #define WGL_GREEN_BITS_ARB 0x2017 #define WGL_GREEN_SHIFT_ARB 0x2018 #define WGL_BLUE_BITS_ARB 0x2019 #define WGL_BLUE_SHIFT_ARB 0x201A #define WGL_ALPHA_BITS_ARB 0x201B #define WGL_ALPHA_SHIFT_ARB 0x201C #define WGL_ACCUM_BITS_ARB 0x201D #define WGL_ACCUM_RED_BITS_ARB 0x201E #define WGL_ACCUM_GREEN_BITS_ARB 0x201F #define WGL_ACCUM_BLUE_BITS_ARB 0x2020 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 #define WGL_DEPTH_BITS_ARB 0x2022 #define WGL_STENCIL_BITS_ARB 0x2023 #define WGL_AUX_BUFFERS_ARB 0x2024 #define WGL_NO_ACCELERATION_ARB 0x2025 #define WGL_GENERIC_ACCELERATION_ARB 0x2026 #define WGL_FULL_ACCELERATION_ARB 0x2027 #define WGL_SWAP_EXCHANGE_ARB 0x2028 #define WGL_SWAP_COPY_ARB 0x2029 #define WGL_SWAP_UNDEFINED_ARB 0x202A #define WGL_TYPE_RGBA_ARB 0x202B #define WGL_TYPE_COLORINDEX_ARB 0x202C #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, FLOAT *pfValues); typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, int *piValues); #define wglChoosePixelFormatARB WGLEW_GET_FUN(__wglewChoosePixelFormatARB) #define wglGetPixelFormatAttribfvARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvARB) #define wglGetPixelFormatAttribivARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribivARB) #define WGLEW_ARB_pixel_format WGLEW_GET_VAR(__WGLEW_ARB_pixel_format) #endif /* WGL_ARB_pixel_format */ /* ----------------------- WGL_ARB_pixel_format_float ---------------------- */ #ifndef WGL_ARB_pixel_format_float #define WGL_ARB_pixel_format_float 1 #define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0 #define WGLEW_ARB_pixel_format_float WGLEW_GET_VAR(__WGLEW_ARB_pixel_format_float) #endif /* WGL_ARB_pixel_format_float */ /* ------------------------- WGL_ARB_render_texture ------------------------ */ #ifndef WGL_ARB_render_texture #define WGL_ARB_render_texture 1 #define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 #define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 #define WGL_TEXTURE_FORMAT_ARB 0x2072 #define WGL_TEXTURE_TARGET_ARB 0x2073 #define WGL_MIPMAP_TEXTURE_ARB 0x2074 #define WGL_TEXTURE_RGB_ARB 0x2075 #define WGL_TEXTURE_RGBA_ARB 0x2076 #define WGL_NO_TEXTURE_ARB 0x2077 #define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 #define WGL_TEXTURE_1D_ARB 0x2079 #define WGL_TEXTURE_2D_ARB 0x207A #define WGL_MIPMAP_LEVEL_ARB 0x207B #define WGL_CUBE_MAP_FACE_ARB 0x207C #define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 #define WGL_FRONT_LEFT_ARB 0x2083 #define WGL_FRONT_RIGHT_ARB 0x2084 #define WGL_BACK_LEFT_ARB 0x2085 #define WGL_BACK_RIGHT_ARB 0x2086 #define WGL_AUX0_ARB 0x2087 #define WGL_AUX1_ARB 0x2088 #define WGL_AUX2_ARB 0x2089 #define WGL_AUX3_ARB 0x208A #define WGL_AUX4_ARB 0x208B #define WGL_AUX5_ARB 0x208C #define WGL_AUX6_ARB 0x208D #define WGL_AUX7_ARB 0x208E #define WGL_AUX8_ARB 0x208F #define WGL_AUX9_ARB 0x2090 typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int* piAttribList); #define wglBindTexImageARB WGLEW_GET_FUN(__wglewBindTexImageARB) #define wglReleaseTexImageARB WGLEW_GET_FUN(__wglewReleaseTexImageARB) #define wglSetPbufferAttribARB WGLEW_GET_FUN(__wglewSetPbufferAttribARB) #define WGLEW_ARB_render_texture WGLEW_GET_VAR(__WGLEW_ARB_render_texture) #endif /* WGL_ARB_render_texture */ /* ---------------- WGL_ARB_robustness_application_isolation --------------- */ #ifndef WGL_ARB_robustness_application_isolation #define WGL_ARB_robustness_application_isolation 1 #define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008 #define WGLEW_ARB_robustness_application_isolation WGLEW_GET_VAR(__WGLEW_ARB_robustness_application_isolation) #endif /* WGL_ARB_robustness_application_isolation */ /* ---------------- WGL_ARB_robustness_share_group_isolation --------------- */ #ifndef WGL_ARB_robustness_share_group_isolation #define WGL_ARB_robustness_share_group_isolation 1 #define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008 #define WGLEW_ARB_robustness_share_group_isolation WGLEW_GET_VAR(__WGLEW_ARB_robustness_share_group_isolation) #endif /* WGL_ARB_robustness_share_group_isolation */ /* ----------------------- WGL_ATI_pixel_format_float ---------------------- */ #ifndef WGL_ATI_pixel_format_float #define WGL_ATI_pixel_format_float 1 #define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0 #define GL_RGBA_FLOAT_MODE_ATI 0x8820 #define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835 #define WGLEW_ATI_pixel_format_float WGLEW_GET_VAR(__WGLEW_ATI_pixel_format_float) #endif /* WGL_ATI_pixel_format_float */ /* -------------------- WGL_ATI_render_texture_rectangle ------------------- */ #ifndef WGL_ATI_render_texture_rectangle #define WGL_ATI_render_texture_rectangle 1 #define WGL_TEXTURE_RECTANGLE_ATI 0x21A5 #define WGLEW_ATI_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_ATI_render_texture_rectangle) #endif /* WGL_ATI_render_texture_rectangle */ /* ------------------- WGL_EXT_create_context_es2_profile ------------------ */ #ifndef WGL_EXT_create_context_es2_profile #define WGL_EXT_create_context_es2_profile 1 #define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 #define WGLEW_EXT_create_context_es2_profile WGLEW_GET_VAR(__WGLEW_EXT_create_context_es2_profile) #endif /* WGL_EXT_create_context_es2_profile */ /* ------------------- WGL_EXT_create_context_es_profile ------------------- */ #ifndef WGL_EXT_create_context_es_profile #define WGL_EXT_create_context_es_profile 1 #define WGL_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004 #define WGLEW_EXT_create_context_es_profile WGLEW_GET_VAR(__WGLEW_EXT_create_context_es_profile) #endif /* WGL_EXT_create_context_es_profile */ /* -------------------------- WGL_EXT_depth_float -------------------------- */ #ifndef WGL_EXT_depth_float #define WGL_EXT_depth_float 1 #define WGL_DEPTH_FLOAT_EXT 0x2040 #define WGLEW_EXT_depth_float WGLEW_GET_VAR(__WGLEW_EXT_depth_float) #endif /* WGL_EXT_depth_float */ /* ---------------------- WGL_EXT_display_color_table ---------------------- */ #ifndef WGL_EXT_display_color_table #define WGL_EXT_display_color_table 1 typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id); typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id); typedef void (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id); typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (GLushort* table, GLuint length); #define wglBindDisplayColorTableEXT WGLEW_GET_FUN(__wglewBindDisplayColorTableEXT) #define wglCreateDisplayColorTableEXT WGLEW_GET_FUN(__wglewCreateDisplayColorTableEXT) #define wglDestroyDisplayColorTableEXT WGLEW_GET_FUN(__wglewDestroyDisplayColorTableEXT) #define wglLoadDisplayColorTableEXT WGLEW_GET_FUN(__wglewLoadDisplayColorTableEXT) #define WGLEW_EXT_display_color_table WGLEW_GET_VAR(__WGLEW_EXT_display_color_table) #endif /* WGL_EXT_display_color_table */ /* ----------------------- WGL_EXT_extensions_string ----------------------- */ #ifndef WGL_EXT_extensions_string #define WGL_EXT_extensions_string 1 typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void); #define wglGetExtensionsStringEXT WGLEW_GET_FUN(__wglewGetExtensionsStringEXT) #define WGLEW_EXT_extensions_string WGLEW_GET_VAR(__WGLEW_EXT_extensions_string) #endif /* WGL_EXT_extensions_string */ /* ------------------------ WGL_EXT_framebuffer_sRGB ----------------------- */ #ifndef WGL_EXT_framebuffer_sRGB #define WGL_EXT_framebuffer_sRGB 1 #define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9 #define WGLEW_EXT_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_EXT_framebuffer_sRGB) #endif /* WGL_EXT_framebuffer_sRGB */ /* ----------------------- WGL_EXT_make_current_read ----------------------- */ #ifndef WGL_EXT_make_current_read #define WGL_EXT_make_current_read 1 #define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043 typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (VOID); typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); #define wglGetCurrentReadDCEXT WGLEW_GET_FUN(__wglewGetCurrentReadDCEXT) #define wglMakeContextCurrentEXT WGLEW_GET_FUN(__wglewMakeContextCurrentEXT) #define WGLEW_EXT_make_current_read WGLEW_GET_VAR(__WGLEW_EXT_make_current_read) #endif /* WGL_EXT_make_current_read */ /* -------------------------- WGL_EXT_multisample -------------------------- */ #ifndef WGL_EXT_multisample #define WGL_EXT_multisample 1 #define WGL_SAMPLE_BUFFERS_EXT 0x2041 #define WGL_SAMPLES_EXT 0x2042 #define WGLEW_EXT_multisample WGLEW_GET_VAR(__WGLEW_EXT_multisample) #endif /* WGL_EXT_multisample */ /* ---------------------------- WGL_EXT_pbuffer ---------------------------- */ #ifndef WGL_EXT_pbuffer #define WGL_EXT_pbuffer 1 #define WGL_DRAW_TO_PBUFFER_EXT 0x202D #define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E #define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F #define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030 #define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031 #define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032 #define WGL_PBUFFER_LARGEST_EXT 0x2033 #define WGL_PBUFFER_WIDTH_EXT 0x2034 #define WGL_PBUFFER_HEIGHT_EXT 0x2035 DECLARE_HANDLE(HPBUFFEREXT); typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList); typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer); typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer); typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int* piValue); typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC); #define wglCreatePbufferEXT WGLEW_GET_FUN(__wglewCreatePbufferEXT) #define wglDestroyPbufferEXT WGLEW_GET_FUN(__wglewDestroyPbufferEXT) #define wglGetPbufferDCEXT WGLEW_GET_FUN(__wglewGetPbufferDCEXT) #define wglQueryPbufferEXT WGLEW_GET_FUN(__wglewQueryPbufferEXT) #define wglReleasePbufferDCEXT WGLEW_GET_FUN(__wglewReleasePbufferDCEXT) #define WGLEW_EXT_pbuffer WGLEW_GET_VAR(__WGLEW_EXT_pbuffer) #endif /* WGL_EXT_pbuffer */ /* -------------------------- WGL_EXT_pixel_format ------------------------- */ #ifndef WGL_EXT_pixel_format #define WGL_EXT_pixel_format 1 #define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000 #define WGL_DRAW_TO_WINDOW_EXT 0x2001 #define WGL_DRAW_TO_BITMAP_EXT 0x2002 #define WGL_ACCELERATION_EXT 0x2003 #define WGL_NEED_PALETTE_EXT 0x2004 #define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005 #define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006 #define WGL_SWAP_METHOD_EXT 0x2007 #define WGL_NUMBER_OVERLAYS_EXT 0x2008 #define WGL_NUMBER_UNDERLAYS_EXT 0x2009 #define WGL_TRANSPARENT_EXT 0x200A #define WGL_TRANSPARENT_VALUE_EXT 0x200B #define WGL_SHARE_DEPTH_EXT 0x200C #define WGL_SHARE_STENCIL_EXT 0x200D #define WGL_SHARE_ACCUM_EXT 0x200E #define WGL_SUPPORT_GDI_EXT 0x200F #define WGL_SUPPORT_OPENGL_EXT 0x2010 #define WGL_DOUBLE_BUFFER_EXT 0x2011 #define WGL_STEREO_EXT 0x2012 #define WGL_PIXEL_TYPE_EXT 0x2013 #define WGL_COLOR_BITS_EXT 0x2014 #define WGL_RED_BITS_EXT 0x2015 #define WGL_RED_SHIFT_EXT 0x2016 #define WGL_GREEN_BITS_EXT 0x2017 #define WGL_GREEN_SHIFT_EXT 0x2018 #define WGL_BLUE_BITS_EXT 0x2019 #define WGL_BLUE_SHIFT_EXT 0x201A #define WGL_ALPHA_BITS_EXT 0x201B #define WGL_ALPHA_SHIFT_EXT 0x201C #define WGL_ACCUM_BITS_EXT 0x201D #define WGL_ACCUM_RED_BITS_EXT 0x201E #define WGL_ACCUM_GREEN_BITS_EXT 0x201F #define WGL_ACCUM_BLUE_BITS_EXT 0x2020 #define WGL_ACCUM_ALPHA_BITS_EXT 0x2021 #define WGL_DEPTH_BITS_EXT 0x2022 #define WGL_STENCIL_BITS_EXT 0x2023 #define WGL_AUX_BUFFERS_EXT 0x2024 #define WGL_NO_ACCELERATION_EXT 0x2025 #define WGL_GENERIC_ACCELERATION_EXT 0x2026 #define WGL_FULL_ACCELERATION_EXT 0x2027 #define WGL_SWAP_EXCHANGE_EXT 0x2028 #define WGL_SWAP_COPY_EXT 0x2029 #define WGL_SWAP_UNDEFINED_EXT 0x202A #define WGL_TYPE_RGBA_EXT 0x202B #define WGL_TYPE_COLORINDEX_EXT 0x202C typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, FLOAT *pfValues); typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, int *piValues); #define wglChoosePixelFormatEXT WGLEW_GET_FUN(__wglewChoosePixelFormatEXT) #define wglGetPixelFormatAttribfvEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvEXT) #define wglGetPixelFormatAttribivEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribivEXT) #define WGLEW_EXT_pixel_format WGLEW_GET_VAR(__WGLEW_EXT_pixel_format) #endif /* WGL_EXT_pixel_format */ /* ------------------- WGL_EXT_pixel_format_packed_float ------------------- */ #ifndef WGL_EXT_pixel_format_packed_float #define WGL_EXT_pixel_format_packed_float 1 #define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8 #define WGLEW_EXT_pixel_format_packed_float WGLEW_GET_VAR(__WGLEW_EXT_pixel_format_packed_float) #endif /* WGL_EXT_pixel_format_packed_float */ /* -------------------------- WGL_EXT_swap_control ------------------------- */ #ifndef WGL_EXT_swap_control #define WGL_EXT_swap_control 1 typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void); typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval); #define wglGetSwapIntervalEXT WGLEW_GET_FUN(__wglewGetSwapIntervalEXT) #define wglSwapIntervalEXT WGLEW_GET_FUN(__wglewSwapIntervalEXT) #define WGLEW_EXT_swap_control WGLEW_GET_VAR(__WGLEW_EXT_swap_control) #endif /* WGL_EXT_swap_control */ /* ----------------------- WGL_EXT_swap_control_tear ----------------------- */ #ifndef WGL_EXT_swap_control_tear #define WGL_EXT_swap_control_tear 1 #define WGLEW_EXT_swap_control_tear WGLEW_GET_VAR(__WGLEW_EXT_swap_control_tear) #endif /* WGL_EXT_swap_control_tear */ /* --------------------- WGL_I3D_digital_video_control --------------------- */ #ifndef WGL_I3D_digital_video_control #define WGL_I3D_digital_video_control 1 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050 #define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051 #define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052 #define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053 typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int* piValue); typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int* piValue); #define wglGetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewGetDigitalVideoParametersI3D) #define wglSetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewSetDigitalVideoParametersI3D) #define WGLEW_I3D_digital_video_control WGLEW_GET_VAR(__WGLEW_I3D_digital_video_control) #endif /* WGL_I3D_digital_video_control */ /* ----------------------------- WGL_I3D_gamma ----------------------------- */ #ifndef WGL_I3D_gamma #define WGL_I3D_gamma 1 #define WGL_GAMMA_TABLE_SIZE_I3D 0x204E #define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT* puRed, USHORT *puGreen, USHORT *puBlue); typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int* piValue); typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT* puRed, const USHORT *puGreen, const USHORT *puBlue); typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int* piValue); #define wglGetGammaTableI3D WGLEW_GET_FUN(__wglewGetGammaTableI3D) #define wglGetGammaTableParametersI3D WGLEW_GET_FUN(__wglewGetGammaTableParametersI3D) #define wglSetGammaTableI3D WGLEW_GET_FUN(__wglewSetGammaTableI3D) #define wglSetGammaTableParametersI3D WGLEW_GET_FUN(__wglewSetGammaTableParametersI3D) #define WGLEW_I3D_gamma WGLEW_GET_VAR(__WGLEW_I3D_gamma) #endif /* WGL_I3D_gamma */ /* ---------------------------- WGL_I3D_genlock ---------------------------- */ #ifndef WGL_I3D_genlock #define WGL_I3D_genlock 1 #define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044 #define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045 #define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046 #define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047 #define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048 #define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049 #define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A #define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B #define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC); typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC); typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate); typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay); typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge); typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource); typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT* uRate); typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT* uDelay); typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT* uEdge); typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT* uSource); typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL* pFlag); typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT* uMaxLineDelay, UINT *uMaxPixelDelay); #define wglDisableGenlockI3D WGLEW_GET_FUN(__wglewDisableGenlockI3D) #define wglEnableGenlockI3D WGLEW_GET_FUN(__wglewEnableGenlockI3D) #define wglGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGenlockSampleRateI3D) #define wglGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGenlockSourceDelayI3D) #define wglGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGenlockSourceEdgeI3D) #define wglGenlockSourceI3D WGLEW_GET_FUN(__wglewGenlockSourceI3D) #define wglGetGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGetGenlockSampleRateI3D) #define wglGetGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGetGenlockSourceDelayI3D) #define wglGetGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGetGenlockSourceEdgeI3D) #define wglGetGenlockSourceI3D WGLEW_GET_FUN(__wglewGetGenlockSourceI3D) #define wglIsEnabledGenlockI3D WGLEW_GET_FUN(__wglewIsEnabledGenlockI3D) #define wglQueryGenlockMaxSourceDelayI3D WGLEW_GET_FUN(__wglewQueryGenlockMaxSourceDelayI3D) #define WGLEW_I3D_genlock WGLEW_GET_VAR(__WGLEW_I3D_genlock) #endif /* WGL_I3D_genlock */ /* -------------------------- WGL_I3D_image_buffer ------------------------- */ #ifndef WGL_I3D_image_buffer #define WGL_I3D_image_buffer 1 #define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001 #define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002 typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hdc, HANDLE* pEvent, LPVOID *pAddress, DWORD *pSize, UINT count); typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags); typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress); typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hdc, LPVOID* pAddress, UINT count); #define wglAssociateImageBufferEventsI3D WGLEW_GET_FUN(__wglewAssociateImageBufferEventsI3D) #define wglCreateImageBufferI3D WGLEW_GET_FUN(__wglewCreateImageBufferI3D) #define wglDestroyImageBufferI3D WGLEW_GET_FUN(__wglewDestroyImageBufferI3D) #define wglReleaseImageBufferEventsI3D WGLEW_GET_FUN(__wglewReleaseImageBufferEventsI3D) #define WGLEW_I3D_image_buffer WGLEW_GET_VAR(__WGLEW_I3D_image_buffer) #endif /* WGL_I3D_image_buffer */ /* ------------------------ WGL_I3D_swap_frame_lock ------------------------ */ #ifndef WGL_I3D_swap_frame_lock #define WGL_I3D_swap_frame_lock 1 typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (VOID); typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (VOID); typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL* pFlag); typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL* pFlag); #define wglDisableFrameLockI3D WGLEW_GET_FUN(__wglewDisableFrameLockI3D) #define wglEnableFrameLockI3D WGLEW_GET_FUN(__wglewEnableFrameLockI3D) #define wglIsEnabledFrameLockI3D WGLEW_GET_FUN(__wglewIsEnabledFrameLockI3D) #define wglQueryFrameLockMasterI3D WGLEW_GET_FUN(__wglewQueryFrameLockMasterI3D) #define WGLEW_I3D_swap_frame_lock WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_lock) #endif /* WGL_I3D_swap_frame_lock */ /* ------------------------ WGL_I3D_swap_frame_usage ----------------------- */ #ifndef WGL_I3D_swap_frame_usage #define WGL_I3D_swap_frame_usage 1 typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void); typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void); typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float* pUsage); typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD* pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); #define wglBeginFrameTrackingI3D WGLEW_GET_FUN(__wglewBeginFrameTrackingI3D) #define wglEndFrameTrackingI3D WGLEW_GET_FUN(__wglewEndFrameTrackingI3D) #define wglGetFrameUsageI3D WGLEW_GET_FUN(__wglewGetFrameUsageI3D) #define wglQueryFrameTrackingI3D WGLEW_GET_FUN(__wglewQueryFrameTrackingI3D) #define WGLEW_I3D_swap_frame_usage WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_usage) #endif /* WGL_I3D_swap_frame_usage */ /* --------------------------- WGL_NV_DX_interop --------------------------- */ #ifndef WGL_NV_DX_interop #define WGL_NV_DX_interop 1 #define WGL_ACCESS_READ_ONLY_NV 0x0000 #define WGL_ACCESS_READ_WRITE_NV 0x0001 #define WGL_ACCESS_WRITE_DISCARD_NV 0x0002 typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice); typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE* hObjects); typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSNVPROC) (HANDLE hObject, GLenum access); typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICENVPROC) (void* dxDevice); typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void* dxObject, GLuint name, GLenum type, GLenum access); typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void* dxObject, HANDLE shareHandle); typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE* hObjects); typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject); #define wglDXCloseDeviceNV WGLEW_GET_FUN(__wglewDXCloseDeviceNV) #define wglDXLockObjectsNV WGLEW_GET_FUN(__wglewDXLockObjectsNV) #define wglDXObjectAccessNV WGLEW_GET_FUN(__wglewDXObjectAccessNV) #define wglDXOpenDeviceNV WGLEW_GET_FUN(__wglewDXOpenDeviceNV) #define wglDXRegisterObjectNV WGLEW_GET_FUN(__wglewDXRegisterObjectNV) #define wglDXSetResourceShareHandleNV WGLEW_GET_FUN(__wglewDXSetResourceShareHandleNV) #define wglDXUnlockObjectsNV WGLEW_GET_FUN(__wglewDXUnlockObjectsNV) #define wglDXUnregisterObjectNV WGLEW_GET_FUN(__wglewDXUnregisterObjectNV) #define WGLEW_NV_DX_interop WGLEW_GET_VAR(__WGLEW_NV_DX_interop) #endif /* WGL_NV_DX_interop */ /* --------------------------- WGL_NV_DX_interop2 -------------------------- */ #ifndef WGL_NV_DX_interop2 #define WGL_NV_DX_interop2 1 #define WGLEW_NV_DX_interop2 WGLEW_GET_VAR(__WGLEW_NV_DX_interop2) #endif /* WGL_NV_DX_interop2 */ /* --------------------------- WGL_NV_copy_image --------------------------- */ #ifndef WGL_NV_copy_image #define WGL_NV_copy_image 1 typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); #define wglCopyImageSubDataNV WGLEW_GET_FUN(__wglewCopyImageSubDataNV) #define WGLEW_NV_copy_image WGLEW_GET_VAR(__WGLEW_NV_copy_image) #endif /* WGL_NV_copy_image */ /* ------------------------ WGL_NV_delay_before_swap ----------------------- */ #ifndef WGL_NV_delay_before_swap #define WGL_NV_delay_before_swap 1 typedef BOOL (WINAPI * PFNWGLDELAYBEFORESWAPNVPROC) (HDC hDC, GLfloat seconds); #define wglDelayBeforeSwapNV WGLEW_GET_FUN(__wglewDelayBeforeSwapNV) #define WGLEW_NV_delay_before_swap WGLEW_GET_VAR(__WGLEW_NV_delay_before_swap) #endif /* WGL_NV_delay_before_swap */ /* -------------------------- WGL_NV_float_buffer -------------------------- */ #ifndef WGL_NV_float_buffer #define WGL_NV_float_buffer 1 #define WGL_FLOAT_COMPONENTS_NV 0x20B0 #define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1 #define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2 #define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3 #define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4 #define WGL_TEXTURE_FLOAT_R_NV 0x20B5 #define WGL_TEXTURE_FLOAT_RG_NV 0x20B6 #define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7 #define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8 #define WGLEW_NV_float_buffer WGLEW_GET_VAR(__WGLEW_NV_float_buffer) #endif /* WGL_NV_float_buffer */ /* -------------------------- WGL_NV_gpu_affinity -------------------------- */ #ifndef WGL_NV_gpu_affinity #define WGL_NV_gpu_affinity 1 #define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0 #define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1 DECLARE_HANDLE(HGPUNV); typedef struct _GPU_DEVICE { DWORD cb; CHAR DeviceName[32]; CHAR DeviceString[128]; DWORD Flags; RECT rcVirtualScreen; } GPU_DEVICE, *PGPU_DEVICE; typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList); typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc); typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu); #define wglCreateAffinityDCNV WGLEW_GET_FUN(__wglewCreateAffinityDCNV) #define wglDeleteDCNV WGLEW_GET_FUN(__wglewDeleteDCNV) #define wglEnumGpuDevicesNV WGLEW_GET_FUN(__wglewEnumGpuDevicesNV) #define wglEnumGpusFromAffinityDCNV WGLEW_GET_FUN(__wglewEnumGpusFromAffinityDCNV) #define wglEnumGpusNV WGLEW_GET_FUN(__wglewEnumGpusNV) #define WGLEW_NV_gpu_affinity WGLEW_GET_VAR(__WGLEW_NV_gpu_affinity) #endif /* WGL_NV_gpu_affinity */ /* ---------------------- WGL_NV_multisample_coverage ---------------------- */ #ifndef WGL_NV_multisample_coverage #define WGL_NV_multisample_coverage 1 #define WGL_COVERAGE_SAMPLES_NV 0x2042 #define WGL_COLOR_SAMPLES_NV 0x20B9 #define WGLEW_NV_multisample_coverage WGLEW_GET_VAR(__WGLEW_NV_multisample_coverage) #endif /* WGL_NV_multisample_coverage */ /* -------------------------- WGL_NV_present_video ------------------------- */ #ifndef WGL_NV_present_video #define WGL_NV_present_video 1 #define WGL_NUM_VIDEO_SLOTS_NV 0x20F0 DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV); typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDc, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int* piAttribList); typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDc, HVIDEOOUTPUTDEVICENV* phDeviceList); typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int* piValue); #define wglBindVideoDeviceNV WGLEW_GET_FUN(__wglewBindVideoDeviceNV) #define wglEnumerateVideoDevicesNV WGLEW_GET_FUN(__wglewEnumerateVideoDevicesNV) #define wglQueryCurrentContextNV WGLEW_GET_FUN(__wglewQueryCurrentContextNV) #define WGLEW_NV_present_video WGLEW_GET_VAR(__WGLEW_NV_present_video) #endif /* WGL_NV_present_video */ /* ---------------------- WGL_NV_render_depth_texture ---------------------- */ #ifndef WGL_NV_render_depth_texture #define WGL_NV_render_depth_texture 1 #define WGL_NO_TEXTURE_ARB 0x2077 #define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3 #define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4 #define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5 #define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6 #define WGL_DEPTH_COMPONENT_NV 0x20A7 #define WGLEW_NV_render_depth_texture WGLEW_GET_VAR(__WGLEW_NV_render_depth_texture) #endif /* WGL_NV_render_depth_texture */ /* -------------------- WGL_NV_render_texture_rectangle -------------------- */ #ifndef WGL_NV_render_texture_rectangle #define WGL_NV_render_texture_rectangle 1 #define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0 #define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1 #define WGL_TEXTURE_RECTANGLE_NV 0x20A2 #define WGLEW_NV_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_NV_render_texture_rectangle) #endif /* WGL_NV_render_texture_rectangle */ /* --------------------------- WGL_NV_swap_group --------------------------- */ #ifndef WGL_NV_swap_group #define WGL_NV_swap_group 1 typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier); typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group); typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint* count); typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint* maxGroups, GLuint *maxBarriers); typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint* group, GLuint *barrier); typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC); #define wglBindSwapBarrierNV WGLEW_GET_FUN(__wglewBindSwapBarrierNV) #define wglJoinSwapGroupNV WGLEW_GET_FUN(__wglewJoinSwapGroupNV) #define wglQueryFrameCountNV WGLEW_GET_FUN(__wglewQueryFrameCountNV) #define wglQueryMaxSwapGroupsNV WGLEW_GET_FUN(__wglewQueryMaxSwapGroupsNV) #define wglQuerySwapGroupNV WGLEW_GET_FUN(__wglewQuerySwapGroupNV) #define wglResetFrameCountNV WGLEW_GET_FUN(__wglewResetFrameCountNV) #define WGLEW_NV_swap_group WGLEW_GET_VAR(__WGLEW_NV_swap_group) #endif /* WGL_NV_swap_group */ /* ----------------------- WGL_NV_vertex_array_range ----------------------- */ #ifndef WGL_NV_vertex_array_range #define WGL_NV_vertex_array_range 1 typedef void * (WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority); typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer); #define wglAllocateMemoryNV WGLEW_GET_FUN(__wglewAllocateMemoryNV) #define wglFreeMemoryNV WGLEW_GET_FUN(__wglewFreeMemoryNV) #define WGLEW_NV_vertex_array_range WGLEW_GET_VAR(__WGLEW_NV_vertex_array_range) #endif /* WGL_NV_vertex_array_range */ /* -------------------------- WGL_NV_video_capture ------------------------- */ #ifndef WGL_NV_video_capture #define WGL_NV_video_capture 1 #define WGL_UNIQUE_ID_NV 0x20CE #define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF DECLARE_HANDLE(HVIDEOINPUTDEVICENV); typedef BOOL (WINAPI * PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice); typedef UINT (WINAPI * PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) (HDC hDc, HVIDEOINPUTDEVICENV* phDeviceList); typedef BOOL (WINAPI * PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); typedef BOOL (WINAPI * PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int* piValue); typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); #define wglBindVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewBindVideoCaptureDeviceNV) #define wglEnumerateVideoCaptureDevicesNV WGLEW_GET_FUN(__wglewEnumerateVideoCaptureDevicesNV) #define wglLockVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewLockVideoCaptureDeviceNV) #define wglQueryVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewQueryVideoCaptureDeviceNV) #define wglReleaseVideoCaptureDeviceNV WGLEW_GET_FUN(__wglewReleaseVideoCaptureDeviceNV) #define WGLEW_NV_video_capture WGLEW_GET_VAR(__WGLEW_NV_video_capture) #endif /* WGL_NV_video_capture */ /* -------------------------- WGL_NV_video_output -------------------------- */ #ifndef WGL_NV_video_output #define WGL_NV_video_output 1 #define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0 #define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1 #define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2 #define WGL_VIDEO_OUT_COLOR_NV 0x20C3 #define WGL_VIDEO_OUT_ALPHA_NV 0x20C4 #define WGL_VIDEO_OUT_DEPTH_NV 0x20C5 #define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 #define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 #define WGL_VIDEO_OUT_FRAME 0x20C8 #define WGL_VIDEO_OUT_FIELD_1 0x20C9 #define WGL_VIDEO_OUT_FIELD_2 0x20CA #define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB #define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC DECLARE_HANDLE(HPVIDEODEV); typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV* hVideoDevice); typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long* pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice); typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer); typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long* pulCounterPbuffer, BOOL bBlock); #define wglBindVideoImageNV WGLEW_GET_FUN(__wglewBindVideoImageNV) #define wglGetVideoDeviceNV WGLEW_GET_FUN(__wglewGetVideoDeviceNV) #define wglGetVideoInfoNV WGLEW_GET_FUN(__wglewGetVideoInfoNV) #define wglReleaseVideoDeviceNV WGLEW_GET_FUN(__wglewReleaseVideoDeviceNV) #define wglReleaseVideoImageNV WGLEW_GET_FUN(__wglewReleaseVideoImageNV) #define wglSendPbufferToVideoNV WGLEW_GET_FUN(__wglewSendPbufferToVideoNV) #define WGLEW_NV_video_output WGLEW_GET_VAR(__WGLEW_NV_video_output) #endif /* WGL_NV_video_output */ /* -------------------------- WGL_OML_sync_control ------------------------- */ #ifndef WGL_OML_sync_control #define WGL_OML_sync_control 1 typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32* numerator, INT32 *denominator); typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64* ust, INT64 *msc, INT64 *sbc); typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64* ust, INT64 *msc, INT64 *sbc); typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64* ust, INT64 *msc, INT64 *sbc); #define wglGetMscRateOML WGLEW_GET_FUN(__wglewGetMscRateOML) #define wglGetSyncValuesOML WGLEW_GET_FUN(__wglewGetSyncValuesOML) #define wglSwapBuffersMscOML WGLEW_GET_FUN(__wglewSwapBuffersMscOML) #define wglSwapLayerBuffersMscOML WGLEW_GET_FUN(__wglewSwapLayerBuffersMscOML) #define wglWaitForMscOML WGLEW_GET_FUN(__wglewWaitForMscOML) #define wglWaitForSbcOML WGLEW_GET_FUN(__wglewWaitForSbcOML) #define WGLEW_OML_sync_control WGLEW_GET_VAR(__WGLEW_OML_sync_control) #endif /* WGL_OML_sync_control */ /* ------------------------------------------------------------------------- */ #ifdef GLEW_MX #define WGLEW_FUN_EXPORT #define WGLEW_VAR_EXPORT #else #define WGLEW_FUN_EXPORT GLEW_FUN_EXPORT #define WGLEW_VAR_EXPORT GLEW_VAR_EXPORT #endif /* GLEW_MX */ #ifdef GLEW_MX struct WGLEWContextStruct { #endif /* GLEW_MX */ WGLEW_FUN_EXPORT PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL; WGLEW_FUN_EXPORT PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD; WGLEW_FUN_EXPORT PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD; WGLEW_FUN_EXPORT PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD; WGLEW_FUN_EXPORT PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD; WGLEW_FUN_EXPORT PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD; WGLEW_FUN_EXPORT PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD; WGLEW_FUN_EXPORT PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD; WGLEW_FUN_EXPORT PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD; WGLEW_FUN_EXPORT PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD; WGLEW_FUN_EXPORT PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB; WGLEW_FUN_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB; WGLEW_FUN_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB; WGLEW_FUN_EXPORT PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB; WGLEW_FUN_EXPORT PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB; WGLEW_FUN_EXPORT PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB; WGLEW_FUN_EXPORT PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB; WGLEW_FUN_EXPORT PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB; WGLEW_FUN_EXPORT PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB; WGLEW_FUN_EXPORT PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB; WGLEW_FUN_EXPORT PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB; WGLEW_FUN_EXPORT PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB; WGLEW_FUN_EXPORT PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB; WGLEW_FUN_EXPORT PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB; WGLEW_FUN_EXPORT PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB; WGLEW_FUN_EXPORT PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB; WGLEW_FUN_EXPORT PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB; WGLEW_FUN_EXPORT PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB; WGLEW_FUN_EXPORT PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB; WGLEW_FUN_EXPORT PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT; WGLEW_FUN_EXPORT PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT; WGLEW_FUN_EXPORT PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT; WGLEW_FUN_EXPORT PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT; WGLEW_FUN_EXPORT PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT; WGLEW_FUN_EXPORT PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT; WGLEW_FUN_EXPORT PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT; WGLEW_FUN_EXPORT PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT; WGLEW_FUN_EXPORT PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT; WGLEW_FUN_EXPORT PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT; WGLEW_FUN_EXPORT PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT; WGLEW_FUN_EXPORT PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT; WGLEW_FUN_EXPORT PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT; WGLEW_FUN_EXPORT PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT; WGLEW_FUN_EXPORT PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT; WGLEW_FUN_EXPORT PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT; WGLEW_FUN_EXPORT PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT; WGLEW_FUN_EXPORT PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D; WGLEW_FUN_EXPORT PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D; WGLEW_FUN_EXPORT PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D; WGLEW_FUN_EXPORT PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D; WGLEW_FUN_EXPORT PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D; WGLEW_FUN_EXPORT PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D; WGLEW_FUN_EXPORT PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D; WGLEW_FUN_EXPORT PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D; WGLEW_FUN_EXPORT PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D; WGLEW_FUN_EXPORT PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D; WGLEW_FUN_EXPORT PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D; WGLEW_FUN_EXPORT PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D; WGLEW_FUN_EXPORT PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D; WGLEW_FUN_EXPORT PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D; WGLEW_FUN_EXPORT PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D; WGLEW_FUN_EXPORT PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D; WGLEW_FUN_EXPORT PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D; WGLEW_FUN_EXPORT PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D; WGLEW_FUN_EXPORT PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D; WGLEW_FUN_EXPORT PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D; WGLEW_FUN_EXPORT PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D; WGLEW_FUN_EXPORT PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D; WGLEW_FUN_EXPORT PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D; WGLEW_FUN_EXPORT PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D; WGLEW_FUN_EXPORT PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D; WGLEW_FUN_EXPORT PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D; WGLEW_FUN_EXPORT PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D; WGLEW_FUN_EXPORT PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D; WGLEW_FUN_EXPORT PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D; WGLEW_FUN_EXPORT PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D; WGLEW_FUN_EXPORT PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV; WGLEW_FUN_EXPORT PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV; WGLEW_FUN_EXPORT PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV; WGLEW_FUN_EXPORT PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV; WGLEW_FUN_EXPORT PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV; WGLEW_FUN_EXPORT PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV; WGLEW_FUN_EXPORT PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV; WGLEW_FUN_EXPORT PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV; WGLEW_FUN_EXPORT PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV; WGLEW_FUN_EXPORT PFNWGLDELAYBEFORESWAPNVPROC __wglewDelayBeforeSwapNV; WGLEW_FUN_EXPORT PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV; WGLEW_FUN_EXPORT PFNWGLDELETEDCNVPROC __wglewDeleteDCNV; WGLEW_FUN_EXPORT PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV; WGLEW_FUN_EXPORT PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV; WGLEW_FUN_EXPORT PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV; WGLEW_FUN_EXPORT PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV; WGLEW_FUN_EXPORT PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV; WGLEW_FUN_EXPORT PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV; WGLEW_FUN_EXPORT PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV; WGLEW_FUN_EXPORT PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV; WGLEW_FUN_EXPORT PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV; WGLEW_FUN_EXPORT PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV; WGLEW_FUN_EXPORT PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV; WGLEW_FUN_EXPORT PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV; WGLEW_FUN_EXPORT PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV; WGLEW_FUN_EXPORT PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV; WGLEW_FUN_EXPORT PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV; WGLEW_FUN_EXPORT PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV; WGLEW_FUN_EXPORT PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV; WGLEW_FUN_EXPORT PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV; WGLEW_FUN_EXPORT PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV; WGLEW_FUN_EXPORT PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV; WGLEW_FUN_EXPORT PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV; WGLEW_FUN_EXPORT PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV; WGLEW_FUN_EXPORT PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV; WGLEW_FUN_EXPORT PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV; WGLEW_FUN_EXPORT PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV; WGLEW_FUN_EXPORT PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML; WGLEW_FUN_EXPORT PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML; WGLEW_FUN_EXPORT PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML; WGLEW_FUN_EXPORT PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML; WGLEW_FUN_EXPORT PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML; WGLEW_FUN_EXPORT PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML; WGLEW_VAR_EXPORT GLboolean __WGLEW_3DFX_multisample; WGLEW_VAR_EXPORT GLboolean __WGLEW_3DL_stereo_control; WGLEW_VAR_EXPORT GLboolean __WGLEW_AMD_gpu_association; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_buffer_region; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_context_flush_control; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context_profile; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context_robustness; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_extensions_string; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_framebuffer_sRGB; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_make_current_read; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_multisample; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_pbuffer; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_pixel_format; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_pixel_format_float; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_render_texture; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_robustness_application_isolation; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_robustness_share_group_isolation; WGLEW_VAR_EXPORT GLboolean __WGLEW_ATI_pixel_format_float; WGLEW_VAR_EXPORT GLboolean __WGLEW_ATI_render_texture_rectangle; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_create_context_es2_profile; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_create_context_es_profile; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_depth_float; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_display_color_table; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_extensions_string; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_framebuffer_sRGB; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_make_current_read; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_multisample; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_pbuffer; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_pixel_format; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_pixel_format_packed_float; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_swap_control; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_swap_control_tear; WGLEW_VAR_EXPORT GLboolean __WGLEW_I3D_digital_video_control; WGLEW_VAR_EXPORT GLboolean __WGLEW_I3D_gamma; WGLEW_VAR_EXPORT GLboolean __WGLEW_I3D_genlock; WGLEW_VAR_EXPORT GLboolean __WGLEW_I3D_image_buffer; WGLEW_VAR_EXPORT GLboolean __WGLEW_I3D_swap_frame_lock; WGLEW_VAR_EXPORT GLboolean __WGLEW_I3D_swap_frame_usage; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_DX_interop; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_DX_interop2; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_copy_image; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_delay_before_swap; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_float_buffer; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_gpu_affinity; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_multisample_coverage; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_present_video; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_render_depth_texture; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_render_texture_rectangle; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_swap_group; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_vertex_array_range; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_video_capture; WGLEW_VAR_EXPORT GLboolean __WGLEW_NV_video_output; WGLEW_VAR_EXPORT GLboolean __WGLEW_OML_sync_control; #ifdef GLEW_MX }; /* WGLEWContextStruct */ #endif /* GLEW_MX */ /* ------------------------------------------------------------------------- */ #ifdef GLEW_MX typedef struct WGLEWContextStruct WGLEWContext; GLEWAPI GLenum GLEWAPIENTRY wglewContextInit (WGLEWContext *ctx); GLEWAPI GLboolean GLEWAPIENTRY wglewContextIsSupported (const WGLEWContext *ctx, const char *name); #define wglewInit() wglewContextInit(wglewGetContext()) #define wglewIsSupported(x) wglewContextIsSupported(wglewGetContext(), x) #define WGLEW_GET_VAR(x) (*(const GLboolean*)&(wglewGetContext()->x)) #define WGLEW_GET_FUN(x) wglewGetContext()->x #else /* GLEW_MX */ GLEWAPI GLenum GLEWAPIENTRY wglewInit (); GLEWAPI GLboolean GLEWAPIENTRY wglewIsSupported (const char *name); #define WGLEW_GET_VAR(x) (*(const GLboolean*)&x) #define WGLEW_GET_FUN(x) x #endif /* GLEW_MX */ GLEWAPI GLboolean GLEWAPIENTRY wglewGetExtension (const char *name); #ifdef __cplusplus } #endif #undef GLEWAPI #endif /* __wglew_h__ */ Slic3r-version_1.31.6/xs/src/glew/src/000077500000000000000000000000001301441720000174445ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/glew/src/glew.c000066400000000000000000035306171301441720000205650ustar00rootroot00000000000000/* ** The OpenGL Extension Wrangler Library ** Copyright (C) 2008-2015, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are met: ** ** * Redistributions of source code must retain the above copyright notice, ** this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright notice, ** this list of conditions and the following disclaimer in the documentation ** and/or other materials provided with the distribution. ** * The name of the author may be used to endorse or promote products ** derived from this software without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF ** THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef SLIC3R_GUI #include #if defined(_WIN32) # include #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) # include #endif #include /* For size_t */ /* * Define glewGetContext and related helper macros. */ #ifdef GLEW_MX # define glewGetContext() ctx # ifdef _WIN32 # define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx # define GLEW_CONTEXT_ARG_VAR_INIT ctx # define wglewGetContext() ctx # define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx # define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx # else /* _WIN32 */ # define GLEW_CONTEXT_ARG_DEF_INIT void # define GLEW_CONTEXT_ARG_VAR_INIT # define glxewGetContext() ctx # define GLXEW_CONTEXT_ARG_DEF_INIT void # define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx # endif /* _WIN32 */ # define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx #else /* GLEW_MX */ # define GLEW_CONTEXT_ARG_DEF_INIT void # define GLEW_CONTEXT_ARG_VAR_INIT # define GLEW_CONTEXT_ARG_DEF_LIST void # define WGLEW_CONTEXT_ARG_DEF_INIT void # define WGLEW_CONTEXT_ARG_DEF_LIST void # define GLXEW_CONTEXT_ARG_DEF_INIT void # define GLXEW_CONTEXT_ARG_DEF_LIST void #endif /* GLEW_MX */ #if defined(GLEW_REGAL) /* In GLEW_REGAL mode we call direcly into the linked libRegal.so glGetProcAddressREGAL for looking up the GL function pointers. */ # undef glGetProcAddressREGAL # ifdef WIN32 extern void * __stdcall glGetProcAddressREGAL(const GLchar *name); static void * (__stdcall * regalGetProcAddress) (const GLchar *) = glGetProcAddressREGAL; # else extern void * glGetProcAddressREGAL(const GLchar *name); static void * (*regalGetProcAddress) (const GLchar *) = glGetProcAddressREGAL; # endif # define glGetProcAddressREGAL GLEW_GET_FUN(__glewGetProcAddressREGAL) #elif defined(__sgi) || defined (__sun) || defined(__HAIKU__) || defined(GLEW_APPLE_GLX) #include #include #include void* dlGetProcAddress (const GLubyte* name) { static void* h = NULL; static void* gpa; if (h == NULL) { if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL; gpa = dlsym(h, "glXGetProcAddress"); } if (gpa != NULL) return ((void*(*)(const GLubyte*))gpa)(name); else return dlsym(h, (const char*)name); } #endif /* __sgi || __sun || GLEW_APPLE_GLX */ #if defined(__APPLE__) #include #include #include #ifdef MAC_OS_X_VERSION_10_3 #include void* NSGLGetProcAddress (const GLubyte *name) { static void* image = NULL; void* addr; if (NULL == image) { image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY); } if( !image ) return NULL; addr = dlsym(image, (const char*)name); if( addr ) return addr; #ifdef GLEW_APPLE_GLX return dlGetProcAddress( name ); // try next for glx symbols #else return NULL; #endif } #else #include void* NSGLGetProcAddress (const GLubyte *name) { static const struct mach_header* image = NULL; NSSymbol symbol; char* symbolName; if (NULL == image) { image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); } /* prepend a '_' for the Unix C symbol mangling convention */ symbolName = malloc(strlen((const char*)name) + 2); strcpy(symbolName+1, (const char*)name); symbolName[0] = '_'; symbol = NULL; /* if (NSIsSymbolNameDefined(symbolName)) symbol = NSLookupAndBindSymbol(symbolName); */ symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL; free(symbolName); if( symbol ) return NSAddressOfSymbol(symbol); #ifdef GLEW_APPLE_GLX return dlGetProcAddress( name ); // try next for glx symbols #else return NULL; #endif } #endif /* MAC_OS_X_VERSION_10_3 */ #endif /* __APPLE__ */ /* * Define glewGetProcAddress. */ #if defined(GLEW_REGAL) # define glewGetProcAddress(name) regalGetProcAddress((const GLchar *) name) #elif defined(_WIN32) # define glewGetProcAddress(name) ((LPCSTR)name) #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX) # define glewGetProcAddress(name) NSGLGetProcAddress(name) #elif defined(__sgi) || defined(__sun) || defined(__HAIKU__) # define glewGetProcAddress(name) dlGetProcAddress(name) #elif defined(__ANDROID__) # define glewGetProcAddress(name) NULL /* TODO */ #elif defined(__native_client__) # define glewGetProcAddress(name) NULL /* TODO */ #else /* __linux */ # define glewGetProcAddress(name) (*glXGetProcAddressARB)(name) #endif /* * Redefine GLEW_GET_VAR etc without const cast */ #undef GLEW_GET_VAR #ifdef GLEW_MX # define GLEW_GET_VAR(x) (glewGetContext()->x) #else /* GLEW_MX */ # define GLEW_GET_VAR(x) (x) #endif /* GLEW_MX */ #ifdef WGLEW_GET_VAR # undef WGLEW_GET_VAR # ifdef GLEW_MX # define WGLEW_GET_VAR(x) (wglewGetContext()->x) # else /* GLEW_MX */ # define WGLEW_GET_VAR(x) (x) # endif /* GLEW_MX */ #endif /* WGLEW_GET_VAR */ #ifdef GLXEW_GET_VAR # undef GLXEW_GET_VAR # ifdef GLEW_MX # define GLXEW_GET_VAR(x) (glxewGetContext()->x) # else /* GLEW_MX */ # define GLXEW_GET_VAR(x) (x) # endif /* GLEW_MX */ #endif /* GLXEW_GET_VAR */ /* * GLEW, just like OpenGL or GLU, does not rely on the standard C library. * These functions implement the functionality required in this file. */ static GLuint _glewStrLen (const GLubyte* s) { GLuint i=0; if (s == NULL) return 0; while (s[i] != '\0') i++; return i; } static GLuint _glewStrCLen (const GLubyte* s, GLubyte c) { GLuint i=0; if (s == NULL) return 0; while (s[i] != '\0' && s[i] != c) i++; return (s[i] == '\0' || s[i] == c) ? i : 0; } static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n) { GLuint i=0; if(a == NULL || b == NULL) return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE; while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++; return i == n ? GL_TRUE : GL_FALSE; } static GLboolean _glewStrSame1 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) { while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t')) { (*a)++; (*na)--; } if(*na >= nb) { GLuint i=0; while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; if(i == nb) { *a = *a + nb; *na = *na - nb; return GL_TRUE; } } return GL_FALSE; } static GLboolean _glewStrSame2 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) { if(*na >= nb) { GLuint i=0; while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; if(i == nb) { *a = *a + nb; *na = *na - nb; return GL_TRUE; } } return GL_FALSE; } static GLboolean _glewStrSame3 (const GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) { if(*na >= nb) { GLuint i=0; while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t')) { *a = *a + nb; *na = *na - nb; return GL_TRUE; } } return GL_FALSE; } /* * Search for name in the extensions string. Use of strstr() * is not sufficient because extension names can be prefixes of * other extension names. Could use strtok() but the constant * string returned by glGetString might be in read-only memory. */ static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end) { const GLubyte* p; GLuint len = _glewStrLen((const GLubyte*)name); p = start; while (p < end) { GLuint n = _glewStrCLen(p, ' '); if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE; p += n+1; } return GL_FALSE; } #if !defined(_WIN32) || !defined(GLEW_MX) PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL; PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL; PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL; PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL; PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL; PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL; PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL; PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL; PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL; PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL; PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL; PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL; PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL; PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL; PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL; PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL; PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL; PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL; PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL; PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL; PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL; PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL; PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL; PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL; PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL; PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL; PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL; PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL; PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL; PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL; PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL; PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL; PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL; PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL; PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL; PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL; PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL; PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL; PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL; PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL; PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL; PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL; PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL; PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL; PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL; PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL; PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL; PFNGLBLENDCOLORPROC __glewBlendColor = NULL; PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL; PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL; PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL; PFNGLFOGCOORDDPROC __glewFogCoordd = NULL; PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL; PFNGLFOGCOORDFPROC __glewFogCoordf = NULL; PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL; PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL; PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL; PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL; PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL; PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL; PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL; PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL; PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL; PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL; PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL; PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL; PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL; PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL; PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL; PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL; PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL; PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL; PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL; PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL; PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL; PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL; PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL; PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL; PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL; PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL; PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL; PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL; PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL; PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL; PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL; PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL; PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL; PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL; PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL; PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL; PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL; PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL; PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL; PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL; PFNGLBEGINQUERYPROC __glewBeginQuery = NULL; PFNGLBINDBUFFERPROC __glewBindBuffer = NULL; PFNGLBUFFERDATAPROC __glewBufferData = NULL; PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL; PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL; PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL; PFNGLENDQUERYPROC __glewEndQuery = NULL; PFNGLGENBUFFERSPROC __glewGenBuffers = NULL; PFNGLGENQUERIESPROC __glewGenQueries = NULL; PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL; PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL; PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL; PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL; PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL; PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL; PFNGLISBUFFERPROC __glewIsBuffer = NULL; PFNGLISQUERYPROC __glewIsQuery = NULL; PFNGLMAPBUFFERPROC __glewMapBuffer = NULL; PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL; PFNGLATTACHSHADERPROC __glewAttachShader = NULL; PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL; PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL; PFNGLCOMPILESHADERPROC __glewCompileShader = NULL; PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL; PFNGLCREATESHADERPROC __glewCreateShader = NULL; PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL; PFNGLDELETESHADERPROC __glewDeleteShader = NULL; PFNGLDETACHSHADERPROC __glewDetachShader = NULL; PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL; PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL; PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL; PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL; PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL; PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL; PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL; PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL; PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL; PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL; PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL; PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL; PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL; PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL; PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL; PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL; PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL; PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL; PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL; PFNGLISPROGRAMPROC __glewIsProgram = NULL; PFNGLISSHADERPROC __glewIsShader = NULL; PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL; PFNGLSHADERSOURCEPROC __glewShaderSource = NULL; PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL; PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL; PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL; PFNGLUNIFORM1FPROC __glewUniform1f = NULL; PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL; PFNGLUNIFORM1IPROC __glewUniform1i = NULL; PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL; PFNGLUNIFORM2FPROC __glewUniform2f = NULL; PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL; PFNGLUNIFORM2IPROC __glewUniform2i = NULL; PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL; PFNGLUNIFORM3FPROC __glewUniform3f = NULL; PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL; PFNGLUNIFORM3IPROC __glewUniform3i = NULL; PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL; PFNGLUNIFORM4FPROC __glewUniform4f = NULL; PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL; PFNGLUNIFORM4IPROC __glewUniform4i = NULL; PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL; PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL; PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL; PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL; PFNGLUSEPROGRAMPROC __glewUseProgram = NULL; PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL; PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL; PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL; PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL; PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL; PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL; PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL; PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL; PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL; PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL; PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL; PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL; PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL; PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL; PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL; PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL; PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL; PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL; PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL; PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL; PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL; PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL; PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL; PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL; PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL; PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL; PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL; PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL; PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL; PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL; PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL; PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL; PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL; PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL; PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL; PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL; PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL; PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL; PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL; PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL; PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL; PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL; PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL; PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL; PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL; PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL; PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL; PFNGLCLAMPCOLORPROC __glewClampColor = NULL; PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL; PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL; PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL; PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL; PFNGLCOLORMASKIPROC __glewColorMaski = NULL; PFNGLDISABLEIPROC __glewDisablei = NULL; PFNGLENABLEIPROC __glewEnablei = NULL; PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL; PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL; PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL; PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL; PFNGLGETSTRINGIPROC __glewGetStringi = NULL; PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL; PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL; PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL; PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL; PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL; PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL; PFNGLISENABLEDIPROC __glewIsEnabledi = NULL; PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL; PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL; PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL; PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL; PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL; PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL; PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL; PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL; PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL; PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL; PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL; PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL; PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL; PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL; PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL; PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL; PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL; PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL; PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL; PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL; PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL; PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL; PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL; PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL; PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL; PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL; PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL; PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL; PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL; PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL; PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL; PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL; PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL; PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL; PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL; PFNGLTEXBUFFERPROC __glewTexBuffer = NULL; PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL; PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL; PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL; PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL; PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL; PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL; PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL; PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL; PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL; PFNGLGETGRAPHICSRESETSTATUSPROC __glewGetGraphicsResetStatus = NULL; PFNGLGETNCOMPRESSEDTEXIMAGEPROC __glewGetnCompressedTexImage = NULL; PFNGLGETNTEXIMAGEPROC __glewGetnTexImage = NULL; PFNGLGETNUNIFORMDVPROC __glewGetnUniformdv = NULL; PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL; PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL; PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD = NULL; PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD = NULL; PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD = NULL; PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL; PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL; PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL; PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL; PFNGLVERTEXATTRIBPARAMETERIAMDPROC __glewVertexAttribParameteriAMD = NULL; PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL; PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD = NULL; PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD = NULL; PFNGLGENNAMESAMDPROC __glewGenNamesAMD = NULL; PFNGLISNAMEAMDPROC __glewIsNameAMD = NULL; PFNGLQUERYOBJECTPARAMETERUIAMDPROC __glewQueryObjectParameteruiAMD = NULL; PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL; PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL; PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL; PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL; PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL; PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL; PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL; PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL; PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL; PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL; PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL; PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD = NULL; PFNGLTEXSTORAGESPARSEAMDPROC __glewTexStorageSparseAMD = NULL; PFNGLTEXTURESTORAGESPARSEAMDPROC __glewTextureStorageSparseAMD = NULL; PFNGLSTENCILOPVALUEAMDPROC __glewStencilOpValueAMD = NULL; PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL; PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL; PFNGLBLITFRAMEBUFFERANGLEPROC __glewBlitFramebufferANGLE = NULL; PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC __glewRenderbufferStorageMultisampleANGLE = NULL; PFNGLDRAWARRAYSINSTANCEDANGLEPROC __glewDrawArraysInstancedANGLE = NULL; PFNGLDRAWELEMENTSINSTANCEDANGLEPROC __glewDrawElementsInstancedANGLE = NULL; PFNGLVERTEXATTRIBDIVISORANGLEPROC __glewVertexAttribDivisorANGLE = NULL; PFNGLBEGINQUERYANGLEPROC __glewBeginQueryANGLE = NULL; PFNGLDELETEQUERIESANGLEPROC __glewDeleteQueriesANGLE = NULL; PFNGLENDQUERYANGLEPROC __glewEndQueryANGLE = NULL; PFNGLGENQUERIESANGLEPROC __glewGenQueriesANGLE = NULL; PFNGLGETQUERYOBJECTI64VANGLEPROC __glewGetQueryObjecti64vANGLE = NULL; PFNGLGETQUERYOBJECTIVANGLEPROC __glewGetQueryObjectivANGLE = NULL; PFNGLGETQUERYOBJECTUI64VANGLEPROC __glewGetQueryObjectui64vANGLE = NULL; PFNGLGETQUERYOBJECTUIVANGLEPROC __glewGetQueryObjectuivANGLE = NULL; PFNGLGETQUERYIVANGLEPROC __glewGetQueryivANGLE = NULL; PFNGLISQUERYANGLEPROC __glewIsQueryANGLE = NULL; PFNGLQUERYCOUNTERANGLEPROC __glewQueryCounterANGLE = NULL; PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC __glewGetTranslatedShaderSourceANGLE = NULL; PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL; PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL; PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL; PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL; PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL; PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL; PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL; PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL; PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL; PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL; PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL; PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL; PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL; PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL; PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL; PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL; PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL; PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL; PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL; PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL; PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL; PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL; PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL; PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL; PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL; PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL; PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL; PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL; PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL; PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL; PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL; PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL; PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL; PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL; PFNGLCLEARDEPTHFPROC __glewClearDepthf = NULL; PFNGLDEPTHRANGEFPROC __glewDepthRangef = NULL; PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat = NULL; PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler = NULL; PFNGLSHADERBINARYPROC __glewShaderBinary = NULL; PFNGLMEMORYBARRIERBYREGIONPROC __glewMemoryBarrierByRegion = NULL; PFNGLPRIMITIVEBOUNDINGBOXARBPROC __glewPrimitiveBoundingBoxARB = NULL; PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance = NULL; PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance = NULL; PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance = NULL; PFNGLGETIMAGEHANDLEARBPROC __glewGetImageHandleARB = NULL; PFNGLGETTEXTUREHANDLEARBPROC __glewGetTextureHandleARB = NULL; PFNGLGETTEXTURESAMPLERHANDLEARBPROC __glewGetTextureSamplerHandleARB = NULL; PFNGLGETVERTEXATTRIBLUI64VARBPROC __glewGetVertexAttribLui64vARB = NULL; PFNGLISIMAGEHANDLERESIDENTARBPROC __glewIsImageHandleResidentARB = NULL; PFNGLISTEXTUREHANDLERESIDENTARBPROC __glewIsTextureHandleResidentARB = NULL; PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC __glewMakeImageHandleNonResidentARB = NULL; PFNGLMAKEIMAGEHANDLERESIDENTARBPROC __glewMakeImageHandleResidentARB = NULL; PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC __glewMakeTextureHandleNonResidentARB = NULL; PFNGLMAKETEXTUREHANDLERESIDENTARBPROC __glewMakeTextureHandleResidentARB = NULL; PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC __glewProgramUniformHandleui64ARB = NULL; PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC __glewProgramUniformHandleui64vARB = NULL; PFNGLUNIFORMHANDLEUI64ARBPROC __glewUniformHandleui64ARB = NULL; PFNGLUNIFORMHANDLEUI64VARBPROC __glewUniformHandleui64vARB = NULL; PFNGLVERTEXATTRIBL1UI64ARBPROC __glewVertexAttribL1ui64ARB = NULL; PFNGLVERTEXATTRIBL1UI64VARBPROC __glewVertexAttribL1ui64vARB = NULL; PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL; PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL; PFNGLBUFFERSTORAGEPROC __glewBufferStorage = NULL; PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL; PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL; PFNGLCLEARBUFFERDATAPROC __glewClearBufferData = NULL; PFNGLCLEARBUFFERSUBDATAPROC __glewClearBufferSubData = NULL; PFNGLCLEARNAMEDBUFFERDATAEXTPROC __glewClearNamedBufferDataEXT = NULL; PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC __glewClearNamedBufferSubDataEXT = NULL; PFNGLCLEARTEXIMAGEPROC __glewClearTexImage = NULL; PFNGLCLEARTEXSUBIMAGEPROC __glewClearTexSubImage = NULL; PFNGLCLIPCONTROLPROC __glewClipControl = NULL; PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL; PFNGLDISPATCHCOMPUTEPROC __glewDispatchCompute = NULL; PFNGLDISPATCHCOMPUTEINDIRECTPROC __glewDispatchComputeIndirect = NULL; PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC __glewDispatchComputeGroupSizeARB = NULL; PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL; PFNGLCOPYIMAGESUBDATAPROC __glewCopyImageSubData = NULL; PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB = NULL; PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB = NULL; PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB = NULL; PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB = NULL; PFNGLBINDTEXTUREUNITPROC __glewBindTextureUnit = NULL; PFNGLBLITNAMEDFRAMEBUFFERPROC __glewBlitNamedFramebuffer = NULL; PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC __glewCheckNamedFramebufferStatus = NULL; PFNGLCLEARNAMEDBUFFERDATAPROC __glewClearNamedBufferData = NULL; PFNGLCLEARNAMEDBUFFERSUBDATAPROC __glewClearNamedBufferSubData = NULL; PFNGLCLEARNAMEDFRAMEBUFFERFIPROC __glewClearNamedFramebufferfi = NULL; PFNGLCLEARNAMEDFRAMEBUFFERFVPROC __glewClearNamedFramebufferfv = NULL; PFNGLCLEARNAMEDFRAMEBUFFERIVPROC __glewClearNamedFramebufferiv = NULL; PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC __glewClearNamedFramebufferuiv = NULL; PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC __glewCompressedTextureSubImage1D = NULL; PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC __glewCompressedTextureSubImage2D = NULL; PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC __glewCompressedTextureSubImage3D = NULL; PFNGLCOPYNAMEDBUFFERSUBDATAPROC __glewCopyNamedBufferSubData = NULL; PFNGLCOPYTEXTURESUBIMAGE1DPROC __glewCopyTextureSubImage1D = NULL; PFNGLCOPYTEXTURESUBIMAGE2DPROC __glewCopyTextureSubImage2D = NULL; PFNGLCOPYTEXTURESUBIMAGE3DPROC __glewCopyTextureSubImage3D = NULL; PFNGLCREATEBUFFERSPROC __glewCreateBuffers = NULL; PFNGLCREATEFRAMEBUFFERSPROC __glewCreateFramebuffers = NULL; PFNGLCREATEPROGRAMPIPELINESPROC __glewCreateProgramPipelines = NULL; PFNGLCREATEQUERIESPROC __glewCreateQueries = NULL; PFNGLCREATERENDERBUFFERSPROC __glewCreateRenderbuffers = NULL; PFNGLCREATESAMPLERSPROC __glewCreateSamplers = NULL; PFNGLCREATETEXTURESPROC __glewCreateTextures = NULL; PFNGLCREATETRANSFORMFEEDBACKSPROC __glewCreateTransformFeedbacks = NULL; PFNGLCREATEVERTEXARRAYSPROC __glewCreateVertexArrays = NULL; PFNGLDISABLEVERTEXARRAYATTRIBPROC __glewDisableVertexArrayAttrib = NULL; PFNGLENABLEVERTEXARRAYATTRIBPROC __glewEnableVertexArrayAttrib = NULL; PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC __glewFlushMappedNamedBufferRange = NULL; PFNGLGENERATETEXTUREMIPMAPPROC __glewGenerateTextureMipmap = NULL; PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC __glewGetCompressedTextureImage = NULL; PFNGLGETNAMEDBUFFERPARAMETERI64VPROC __glewGetNamedBufferParameteri64v = NULL; PFNGLGETNAMEDBUFFERPARAMETERIVPROC __glewGetNamedBufferParameteriv = NULL; PFNGLGETNAMEDBUFFERPOINTERVPROC __glewGetNamedBufferPointerv = NULL; PFNGLGETNAMEDBUFFERSUBDATAPROC __glewGetNamedBufferSubData = NULL; PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetNamedFramebufferAttachmentParameteriv = NULL; PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC __glewGetNamedFramebufferParameteriv = NULL; PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC __glewGetNamedRenderbufferParameteriv = NULL; PFNGLGETQUERYBUFFEROBJECTI64VPROC __glewGetQueryBufferObjecti64v = NULL; PFNGLGETQUERYBUFFEROBJECTIVPROC __glewGetQueryBufferObjectiv = NULL; PFNGLGETQUERYBUFFEROBJECTUI64VPROC __glewGetQueryBufferObjectui64v = NULL; PFNGLGETQUERYBUFFEROBJECTUIVPROC __glewGetQueryBufferObjectuiv = NULL; PFNGLGETTEXTUREIMAGEPROC __glewGetTextureImage = NULL; PFNGLGETTEXTURELEVELPARAMETERFVPROC __glewGetTextureLevelParameterfv = NULL; PFNGLGETTEXTURELEVELPARAMETERIVPROC __glewGetTextureLevelParameteriv = NULL; PFNGLGETTEXTUREPARAMETERIIVPROC __glewGetTextureParameterIiv = NULL; PFNGLGETTEXTUREPARAMETERIUIVPROC __glewGetTextureParameterIuiv = NULL; PFNGLGETTEXTUREPARAMETERFVPROC __glewGetTextureParameterfv = NULL; PFNGLGETTEXTUREPARAMETERIVPROC __glewGetTextureParameteriv = NULL; PFNGLGETTRANSFORMFEEDBACKI64_VPROC __glewGetTransformFeedbacki64_v = NULL; PFNGLGETTRANSFORMFEEDBACKI_VPROC __glewGetTransformFeedbacki_v = NULL; PFNGLGETTRANSFORMFEEDBACKIVPROC __glewGetTransformFeedbackiv = NULL; PFNGLGETVERTEXARRAYINDEXED64IVPROC __glewGetVertexArrayIndexed64iv = NULL; PFNGLGETVERTEXARRAYINDEXEDIVPROC __glewGetVertexArrayIndexediv = NULL; PFNGLGETVERTEXARRAYIVPROC __glewGetVertexArrayiv = NULL; PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC __glewInvalidateNamedFramebufferData = NULL; PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC __glewInvalidateNamedFramebufferSubData = NULL; PFNGLMAPNAMEDBUFFERPROC __glewMapNamedBuffer = NULL; PFNGLMAPNAMEDBUFFERRANGEPROC __glewMapNamedBufferRange = NULL; PFNGLNAMEDBUFFERDATAPROC __glewNamedBufferData = NULL; PFNGLNAMEDBUFFERSTORAGEPROC __glewNamedBufferStorage = NULL; PFNGLNAMEDBUFFERSUBDATAPROC __glewNamedBufferSubData = NULL; PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC __glewNamedFramebufferDrawBuffer = NULL; PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC __glewNamedFramebufferDrawBuffers = NULL; PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC __glewNamedFramebufferParameteri = NULL; PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC __glewNamedFramebufferReadBuffer = NULL; PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC __glewNamedFramebufferRenderbuffer = NULL; PFNGLNAMEDFRAMEBUFFERTEXTUREPROC __glewNamedFramebufferTexture = NULL; PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC __glewNamedFramebufferTextureLayer = NULL; PFNGLNAMEDRENDERBUFFERSTORAGEPROC __glewNamedRenderbufferStorage = NULL; PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewNamedRenderbufferStorageMultisample = NULL; PFNGLTEXTUREBUFFERPROC __glewTextureBuffer = NULL; PFNGLTEXTUREBUFFERRANGEPROC __glewTextureBufferRange = NULL; PFNGLTEXTUREPARAMETERIIVPROC __glewTextureParameterIiv = NULL; PFNGLTEXTUREPARAMETERIUIVPROC __glewTextureParameterIuiv = NULL; PFNGLTEXTUREPARAMETERFPROC __glewTextureParameterf = NULL; PFNGLTEXTUREPARAMETERFVPROC __glewTextureParameterfv = NULL; PFNGLTEXTUREPARAMETERIPROC __glewTextureParameteri = NULL; PFNGLTEXTUREPARAMETERIVPROC __glewTextureParameteriv = NULL; PFNGLTEXTURESTORAGE1DPROC __glewTextureStorage1D = NULL; PFNGLTEXTURESTORAGE2DPROC __glewTextureStorage2D = NULL; PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC __glewTextureStorage2DMultisample = NULL; PFNGLTEXTURESTORAGE3DPROC __glewTextureStorage3D = NULL; PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC __glewTextureStorage3DMultisample = NULL; PFNGLTEXTURESUBIMAGE1DPROC __glewTextureSubImage1D = NULL; PFNGLTEXTURESUBIMAGE2DPROC __glewTextureSubImage2D = NULL; PFNGLTEXTURESUBIMAGE3DPROC __glewTextureSubImage3D = NULL; PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC __glewTransformFeedbackBufferBase = NULL; PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC __glewTransformFeedbackBufferRange = NULL; PFNGLUNMAPNAMEDBUFFERPROC __glewUnmapNamedBuffer = NULL; PFNGLVERTEXARRAYATTRIBBINDINGPROC __glewVertexArrayAttribBinding = NULL; PFNGLVERTEXARRAYATTRIBFORMATPROC __glewVertexArrayAttribFormat = NULL; PFNGLVERTEXARRAYATTRIBIFORMATPROC __glewVertexArrayAttribIFormat = NULL; PFNGLVERTEXARRAYATTRIBLFORMATPROC __glewVertexArrayAttribLFormat = NULL; PFNGLVERTEXARRAYBINDINGDIVISORPROC __glewVertexArrayBindingDivisor = NULL; PFNGLVERTEXARRAYELEMENTBUFFERPROC __glewVertexArrayElementBuffer = NULL; PFNGLVERTEXARRAYVERTEXBUFFERPROC __glewVertexArrayVertexBuffer = NULL; PFNGLVERTEXARRAYVERTEXBUFFERSPROC __glewVertexArrayVertexBuffers = NULL; PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL; PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL; PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL; PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL; PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL; PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL; PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL; PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL; PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL; PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL; PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL; PFNGLFRAMEBUFFERPARAMETERIPROC __glewFramebufferParameteri = NULL; PFNGLGETFRAMEBUFFERPARAMETERIVPROC __glewGetFramebufferParameteriv = NULL; PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC __glewGetNamedFramebufferParameterivEXT = NULL; PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC __glewNamedFramebufferParameteriEXT = NULL; PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL; PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL; PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL; PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL; PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL; PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL; PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL; PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL; PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL; PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL; PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL; PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL; PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL; PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL; PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL; PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL; PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL; PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL; PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL; PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL; PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL; PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL; PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL; PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL; PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary = NULL; PFNGLPROGRAMBINARYPROC __glewProgramBinary = NULL; PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri = NULL; PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC __glewGetCompressedTextureSubImage = NULL; PFNGLGETTEXTURESUBIMAGEPROC __glewGetTextureSubImage = NULL; PFNGLGETUNIFORMDVPROC __glewGetUniformdv = NULL; PFNGLUNIFORM1DPROC __glewUniform1d = NULL; PFNGLUNIFORM1DVPROC __glewUniform1dv = NULL; PFNGLUNIFORM2DPROC __glewUniform2d = NULL; PFNGLUNIFORM2DVPROC __glewUniform2dv = NULL; PFNGLUNIFORM3DPROC __glewUniform3d = NULL; PFNGLUNIFORM3DVPROC __glewUniform3dv = NULL; PFNGLUNIFORM4DPROC __glewUniform4d = NULL; PFNGLUNIFORM4DVPROC __glewUniform4dv = NULL; PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv = NULL; PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv = NULL; PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv = NULL; PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv = NULL; PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv = NULL; PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv = NULL; PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv = NULL; PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv = NULL; PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv = NULL; PFNGLGETUNIFORMI64VARBPROC __glewGetUniformi64vARB = NULL; PFNGLGETUNIFORMUI64VARBPROC __glewGetUniformui64vARB = NULL; PFNGLGETNUNIFORMI64VARBPROC __glewGetnUniformi64vARB = NULL; PFNGLGETNUNIFORMUI64VARBPROC __glewGetnUniformui64vARB = NULL; PFNGLPROGRAMUNIFORM1I64ARBPROC __glewProgramUniform1i64ARB = NULL; PFNGLPROGRAMUNIFORM1I64VARBPROC __glewProgramUniform1i64vARB = NULL; PFNGLPROGRAMUNIFORM1UI64ARBPROC __glewProgramUniform1ui64ARB = NULL; PFNGLPROGRAMUNIFORM1UI64VARBPROC __glewProgramUniform1ui64vARB = NULL; PFNGLPROGRAMUNIFORM2I64ARBPROC __glewProgramUniform2i64ARB = NULL; PFNGLPROGRAMUNIFORM2I64VARBPROC __glewProgramUniform2i64vARB = NULL; PFNGLPROGRAMUNIFORM2UI64ARBPROC __glewProgramUniform2ui64ARB = NULL; PFNGLPROGRAMUNIFORM2UI64VARBPROC __glewProgramUniform2ui64vARB = NULL; PFNGLPROGRAMUNIFORM3I64ARBPROC __glewProgramUniform3i64ARB = NULL; PFNGLPROGRAMUNIFORM3I64VARBPROC __glewProgramUniform3i64vARB = NULL; PFNGLPROGRAMUNIFORM3UI64ARBPROC __glewProgramUniform3ui64ARB = NULL; PFNGLPROGRAMUNIFORM3UI64VARBPROC __glewProgramUniform3ui64vARB = NULL; PFNGLPROGRAMUNIFORM4I64ARBPROC __glewProgramUniform4i64ARB = NULL; PFNGLPROGRAMUNIFORM4I64VARBPROC __glewProgramUniform4i64vARB = NULL; PFNGLPROGRAMUNIFORM4UI64ARBPROC __glewProgramUniform4ui64ARB = NULL; PFNGLPROGRAMUNIFORM4UI64VARBPROC __glewProgramUniform4ui64vARB = NULL; PFNGLUNIFORM1I64ARBPROC __glewUniform1i64ARB = NULL; PFNGLUNIFORM1I64VARBPROC __glewUniform1i64vARB = NULL; PFNGLUNIFORM1UI64ARBPROC __glewUniform1ui64ARB = NULL; PFNGLUNIFORM1UI64VARBPROC __glewUniform1ui64vARB = NULL; PFNGLUNIFORM2I64ARBPROC __glewUniform2i64ARB = NULL; PFNGLUNIFORM2I64VARBPROC __glewUniform2i64vARB = NULL; PFNGLUNIFORM2UI64ARBPROC __glewUniform2ui64ARB = NULL; PFNGLUNIFORM2UI64VARBPROC __glewUniform2ui64vARB = NULL; PFNGLUNIFORM3I64ARBPROC __glewUniform3i64ARB = NULL; PFNGLUNIFORM3I64VARBPROC __glewUniform3i64vARB = NULL; PFNGLUNIFORM3UI64ARBPROC __glewUniform3ui64ARB = NULL; PFNGLUNIFORM3UI64VARBPROC __glewUniform3ui64vARB = NULL; PFNGLUNIFORM4I64ARBPROC __glewUniform4i64ARB = NULL; PFNGLUNIFORM4I64VARBPROC __glewUniform4i64vARB = NULL; PFNGLUNIFORM4UI64ARBPROC __glewUniform4ui64ARB = NULL; PFNGLUNIFORM4UI64VARBPROC __glewUniform4ui64vARB = NULL; PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL; PFNGLCOLORTABLEPROC __glewColorTable = NULL; PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL; PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL; PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL; PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL; PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL; PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL; PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL; PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL; PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL; PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL; PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL; PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL; PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL; PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL; PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL; PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL; PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL; PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL; PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL; PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL; PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL; PFNGLGETMINMAXPROC __glewGetMinmax = NULL; PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL; PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL; PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL; PFNGLHISTOGRAMPROC __glewHistogram = NULL; PFNGLMINMAXPROC __glewMinmax = NULL; PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL; PFNGLRESETMINMAXPROC __glewResetMinmax = NULL; PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL; PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC __glewMultiDrawArraysIndirectCountARB = NULL; PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC __glewMultiDrawElementsIndirectCountARB = NULL; PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL; PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL; PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL; PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ = NULL; PFNGLGETINTERNALFORMATI64VPROC __glewGetInternalformati64v = NULL; PFNGLINVALIDATEBUFFERDATAPROC __glewInvalidateBufferData = NULL; PFNGLINVALIDATEBUFFERSUBDATAPROC __glewInvalidateBufferSubData = NULL; PFNGLINVALIDATEFRAMEBUFFERPROC __glewInvalidateFramebuffer = NULL; PFNGLINVALIDATESUBFRAMEBUFFERPROC __glewInvalidateSubFramebuffer = NULL; PFNGLINVALIDATETEXIMAGEPROC __glewInvalidateTexImage = NULL; PFNGLINVALIDATETEXSUBIMAGEPROC __glewInvalidateTexSubImage = NULL; PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL; PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL; PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL; PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL; PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL; PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL; PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL; PFNGLBINDBUFFERSBASEPROC __glewBindBuffersBase = NULL; PFNGLBINDBUFFERSRANGEPROC __glewBindBuffersRange = NULL; PFNGLBINDIMAGETEXTURESPROC __glewBindImageTextures = NULL; PFNGLBINDSAMPLERSPROC __glewBindSamplers = NULL; PFNGLBINDTEXTURESPROC __glewBindTextures = NULL; PFNGLBINDVERTEXBUFFERSPROC __glewBindVertexBuffers = NULL; PFNGLMULTIDRAWARRAYSINDIRECTPROC __glewMultiDrawArraysIndirect = NULL; PFNGLMULTIDRAWELEMENTSINDIRECTPROC __glewMultiDrawElementsIndirect = NULL; PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL; PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL; PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL; PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL; PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL; PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL; PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL; PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL; PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL; PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL; PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL; PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL; PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL; PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL; PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL; PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL; PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL; PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL; PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL; PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL; PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL; PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL; PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL; PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL; PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL; PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL; PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL; PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL; PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL; PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL; PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL; PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL; PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL; PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL; PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL; PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL; PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL; PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL; PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL; PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL; PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL; PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL; PFNGLISQUERYARBPROC __glewIsQueryARB = NULL; PFNGLMAXSHADERCOMPILERTHREADSARBPROC __glewMaxShaderCompilerThreadsARB = NULL; PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL; PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL; PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv = NULL; PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex = NULL; PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation = NULL; PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC __glewGetProgramResourceLocationIndex = NULL; PFNGLGETPROGRAMRESOURCENAMEPROC __glewGetProgramResourceName = NULL; PFNGLGETPROGRAMRESOURCEIVPROC __glewGetProgramResourceiv = NULL; PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL; PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB = NULL; PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB = NULL; PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB = NULL; PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB = NULL; PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB = NULL; PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB = NULL; PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB = NULL; PFNGLGETNMAPIVARBPROC __glewGetnMapivARB = NULL; PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB = NULL; PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB = NULL; PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB = NULL; PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB = NULL; PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB = NULL; PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB = NULL; PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB = NULL; PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB = NULL; PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB = NULL; PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL; PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL; PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL; PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewFramebufferSampleLocationsfvARB = NULL; PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC __glewNamedFramebufferSampleLocationsfvARB = NULL; PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL; PFNGLBINDSAMPLERPROC __glewBindSampler = NULL; PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL; PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL; PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL; PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL; PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL; PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL; PFNGLISSAMPLERPROC __glewIsSampler = NULL; PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL; PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL; PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL; PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL; PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL; PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL; PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram = NULL; PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline = NULL; PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv = NULL; PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines = NULL; PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines = NULL; PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog = NULL; PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv = NULL; PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline = NULL; PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d = NULL; PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv = NULL; PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f = NULL; PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv = NULL; PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i = NULL; PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv = NULL; PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui = NULL; PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv = NULL; PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d = NULL; PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv = NULL; PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f = NULL; PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv = NULL; PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i = NULL; PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv = NULL; PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui = NULL; PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv = NULL; PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d = NULL; PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv = NULL; PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f = NULL; PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv = NULL; PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i = NULL; PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv = NULL; PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui = NULL; PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv = NULL; PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d = NULL; PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv = NULL; PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f = NULL; PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv = NULL; PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i = NULL; PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv = NULL; PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui = NULL; PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv = NULL; PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv = NULL; PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv = NULL; PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv = NULL; PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv = NULL; PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv = NULL; PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv = NULL; PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv = NULL; PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv = NULL; PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv = NULL; PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv = NULL; PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv = NULL; PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv = NULL; PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv = NULL; PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv = NULL; PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv = NULL; PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv = NULL; PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv = NULL; PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv = NULL; PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages = NULL; PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline = NULL; PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv = NULL; PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture = NULL; PFNGLMEMORYBARRIERPROC __glewMemoryBarrier = NULL; PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL; PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL; PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL; PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL; PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL; PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL; PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL; PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL; PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL; PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL; PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL; PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL; PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL; PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL; PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL; PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL; PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL; PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL; PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL; PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL; PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL; PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL; PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL; PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL; PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL; PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL; PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL; PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL; PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL; PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL; PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL; PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL; PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL; PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL; PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL; PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL; PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL; PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL; PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL; PFNGLSHADERSTORAGEBLOCKBINDINGPROC __glewShaderStorageBlockBinding = NULL; PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL; PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL; PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL; PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL; PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL; PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL; PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL; PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL; PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL; PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL; PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL; PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL; PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL; PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL; PFNGLBUFFERPAGECOMMITMENTARBPROC __glewBufferPageCommitmentARB = NULL; PFNGLTEXPAGECOMMITMENTARBPROC __glewTexPageCommitmentARB = NULL; PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL; PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL; PFNGLDELETESYNCPROC __glewDeleteSync = NULL; PFNGLFENCESYNCPROC __glewFenceSync = NULL; PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL; PFNGLGETSYNCIVPROC __glewGetSynciv = NULL; PFNGLISSYNCPROC __glewIsSync = NULL; PFNGLWAITSYNCPROC __glewWaitSync = NULL; PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL; PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL; PFNGLTEXTUREBARRIERPROC __glewTextureBarrier = NULL; PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL; PFNGLTEXBUFFERRANGEPROC __glewTexBufferRange = NULL; PFNGLTEXTUREBUFFERRANGEEXTPROC __glewTextureBufferRangeEXT = NULL; PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL; PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL; PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL; PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL; PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL; PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL; PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL; PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL; PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL; PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL; PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL; PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL; PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL; PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL; PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample = NULL; PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample = NULL; PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC __glewTextureStorage2DMultisampleEXT = NULL; PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC __glewTextureStorage3DMultisampleEXT = NULL; PFNGLTEXTUREVIEWPROC __glewTextureView = NULL; PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL; PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL; PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL; PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL; PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL; PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL; PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL; PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL; PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL; PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL; PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL; PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL; PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL; PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL; PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced = NULL; PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced = NULL; PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL; PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL; PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL; PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL; PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL; PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL; PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL; PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL; PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL; PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL; PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL; PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL; PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL; PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL; PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL; PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL; PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL; PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL; PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv = NULL; PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d = NULL; PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv = NULL; PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d = NULL; PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv = NULL; PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d = NULL; PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv = NULL; PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d = NULL; PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv = NULL; PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer = NULL; PFNGLBINDVERTEXBUFFERPROC __glewBindVertexBuffer = NULL; PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC __glewVertexArrayBindVertexBufferEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC __glewVertexArrayVertexAttribBindingEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC __glewVertexArrayVertexAttribFormatEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC __glewVertexArrayVertexAttribIFormatEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC __glewVertexArrayVertexAttribLFormatEXT = NULL; PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC __glewVertexArrayVertexBindingDivisorEXT = NULL; PFNGLVERTEXATTRIBBINDINGPROC __glewVertexAttribBinding = NULL; PFNGLVERTEXATTRIBFORMATPROC __glewVertexAttribFormat = NULL; PFNGLVERTEXATTRIBIFORMATPROC __glewVertexAttribIFormat = NULL; PFNGLVERTEXATTRIBLFORMATPROC __glewVertexAttribLFormat = NULL; PFNGLVERTEXBINDINGDIVISORPROC __glewVertexBindingDivisor = NULL; PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL; PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL; PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL; PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL; PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL; PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL; PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL; PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL; PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL; PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL; PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL; PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL; PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL; PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL; PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL; PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL; PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL; PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL; PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL; PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL; PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL; PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL; PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL; PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL; PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL; PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL; PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL; PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL; PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL; PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL; PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL; PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL; PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL; PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL; PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL; PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL; PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL; PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL; PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL; PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL; PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL; PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL; PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL; PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL; PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL; PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL; PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL; PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL; PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL; PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL; PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL; PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL; PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL; PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL; PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL; PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL; PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL; PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL; PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL; PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL; PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL; PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL; PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL; PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL; PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL; PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL; PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL; PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL; PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL; PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL; PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL; PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL; PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL; PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL; PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL; PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL; PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL; PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL; PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL; PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL; PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL; PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL; PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL; PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL; PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL; PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL; PFNGLCOLORP3UIPROC __glewColorP3ui = NULL; PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL; PFNGLCOLORP4UIPROC __glewColorP4ui = NULL; PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL; PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL; PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL; PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL; PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL; PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL; PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL; PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL; PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL; PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL; PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL; PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL; PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL; PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL; PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL; PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL; PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL; PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL; PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL; PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL; PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL; PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL; PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL; PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL; PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL; PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL; PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL; PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL; PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL; PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL; PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL; PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL; PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL; PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL; PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL; PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv = NULL; PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed = NULL; PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v = NULL; PFNGLGETFLOATI_VPROC __glewGetFloati_v = NULL; PFNGLSCISSORARRAYVPROC __glewScissorArrayv = NULL; PFNGLSCISSORINDEXEDPROC __glewScissorIndexed = NULL; PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv = NULL; PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv = NULL; PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf = NULL; PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv = NULL; PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL; PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL; PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL; PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL; PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL; PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL; PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL; PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL; PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL; PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL; PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL; PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL; PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL; PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL; PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL; PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL; PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL; PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL; PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL; PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL; PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL; PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL; PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL; PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL; PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL; PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL; PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL; PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL; PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL; PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL; PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL; PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL; PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL; PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL; PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL; PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL; PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL; PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL; PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL; PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL; PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI = NULL; PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI = NULL; PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL; PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL; PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL; PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL; PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL; PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL; PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL; PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL; PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL; PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL; PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL; PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL; PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL; PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL; PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL; PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL; PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL; PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL; PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL; PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL; PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL; PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL; PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL; PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL; PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL; PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL; PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL; PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL; PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL; PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL; PFNGLVERTEXSTREAM1DATIPROC __glewVertexStream1dATI = NULL; PFNGLVERTEXSTREAM1DVATIPROC __glewVertexStream1dvATI = NULL; PFNGLVERTEXSTREAM1FATIPROC __glewVertexStream1fATI = NULL; PFNGLVERTEXSTREAM1FVATIPROC __glewVertexStream1fvATI = NULL; PFNGLVERTEXSTREAM1IATIPROC __glewVertexStream1iATI = NULL; PFNGLVERTEXSTREAM1IVATIPROC __glewVertexStream1ivATI = NULL; PFNGLVERTEXSTREAM1SATIPROC __glewVertexStream1sATI = NULL; PFNGLVERTEXSTREAM1SVATIPROC __glewVertexStream1svATI = NULL; PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL; PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL; PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL; PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL; PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL; PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL; PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL; PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL; PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL; PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL; PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL; PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL; PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL; PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL; PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL; PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL; PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL; PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL; PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL; PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL; PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL; PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL; PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL; PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL; PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL; PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL; PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL; PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL; PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL; PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL; PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL; PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL; PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL; PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL; PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL; PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL; PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL; PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL; PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL; PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL; PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL; PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL; PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL; PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL; PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL; PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL; PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL; PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL; PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL; PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL; PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL; PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL; PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL; PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL; PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL; PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL; PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL; PFNGLGETOBJECTLABELEXTPROC __glewGetObjectLabelEXT = NULL; PFNGLLABELOBJECTEXTPROC __glewLabelObjectEXT = NULL; PFNGLINSERTEVENTMARKEREXTPROC __glewInsertEventMarkerEXT = NULL; PFNGLPOPGROUPMARKEREXTPROC __glewPopGroupMarkerEXT = NULL; PFNGLPUSHGROUPMARKEREXTPROC __glewPushGroupMarkerEXT = NULL; PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL; PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL; PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL; PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL; PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL; PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL; PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL; PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL; PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL; PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL; PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL; PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL; PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL; PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL; PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL; PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL; PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL; PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL; PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL; PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL; PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL; PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL; PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL; PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL; PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL; PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL; PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL; PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL; PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL; PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL; PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL; PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL; PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL; PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL; PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL; PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL; PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL; PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL; PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL; PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL; PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL; PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL; PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL; PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL; PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL; PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL; PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL; PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL; PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL; PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL; PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL; PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL; PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL; PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL; PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL; PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL; PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL; PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL; PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL; PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL; PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL; PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL; PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL; PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL; PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL; PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL; PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL; PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL; PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL; PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL; PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL; PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL; PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL; PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL; PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL; PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL; PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL; PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL; PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL; PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL; PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL; PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL; PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL; PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL; PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL; PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL; PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL; PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL; PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL; PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL; PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL; PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL; PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL; PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL; PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL; PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL; PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL; PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL; PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL; PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL; PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL; PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL; PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL; PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL; PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL; PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL; PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL; PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL; PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL; PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL; PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL; PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL; PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL; PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL; PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL; PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL; PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL; PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL; PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL; PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL; PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL; PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL; PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL; PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL; PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL; PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL; PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL; PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL; PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL; PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL; PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL; PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL; PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL; PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL; PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL; PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL; PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL; PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL; PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL; PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL; PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL; PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL; PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL; PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL; PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL; PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL; PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL; PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL; PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL; PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL; PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL; PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL; PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL; PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL; PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL; PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL; PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL; PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL; PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL; PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL; PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL; PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL; PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL; PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL; PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL; PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL; PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL; PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL; PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL; PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL; PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL; PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL; PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL; PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL; PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL; PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL; PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL; PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL; PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL; PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL; PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL; PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL; PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL; PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL; PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL; PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL; PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL; PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL; PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL; PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL; PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL; PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL; PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC __glewVertexArrayVertexAttribDivisorEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL; PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL; PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL; PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL; PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL; PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL; PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL; PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL; PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL; PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL; PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL; PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL; PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL; PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL; PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL; PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL; PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL; PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL; PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL; PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL; PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL; PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL; PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL; PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL; PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL; PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL; PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL; PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL; PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL; PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL; PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL; PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL; PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL; PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL; PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL; PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL; PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL; PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL; PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL; PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL; PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL; PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL; PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL; PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL; PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL; PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL; PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL; PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL; PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL; PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL; PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL; PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL; PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL; PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL; PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL; PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL; PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL; PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL; PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL; PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL; PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL; PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL; PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL; PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL; PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL; PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL; PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL; PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL; PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL; PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL; PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL; PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL; PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL; PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL; PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL; PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL; PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL; PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL; PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL; PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL; PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL; PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL; PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL; PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL; PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL; PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL; PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL; PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL; PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL; PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL; PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL; PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL; PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL; PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL; PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL; PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL; PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL; PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL; PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL; PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL; PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL; PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL; PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL; PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL; PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL; PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL; PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL; PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL; PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL; PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL; PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL; PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL; PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL; PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL; PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL; PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL; PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL; PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL; PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL; PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL; PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL; PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL; PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL; PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL; PFNGLPOLYGONOFFSETCLAMPEXTPROC __glewPolygonOffsetClampEXT = NULL; PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL; PFNGLCOVERAGEMODULATIONNVPROC __glewCoverageModulationNV = NULL; PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTableNV = NULL; PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV = NULL; PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT = NULL; PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL; PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL; PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL; PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL; PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL; PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL; PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL; PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL; PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL; PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL; PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL; PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL; PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL; PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL; PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL; PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL; PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL; PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL; PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL; PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL; PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL; PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL; PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL; PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL; PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL; PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL; PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL; PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL; PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL; PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL; PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL; PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL; PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL; PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL; PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL; PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL; PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL; PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL; PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL; PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL; PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL; PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL; PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL; PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL; PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL; PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL; PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL; PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL; PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL; PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL; PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL; PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL; PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL; PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL; PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL; PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL; PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL; PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL; PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL; PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL; PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL; PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL; PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL; PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL; PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL; PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL; PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL; PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL; PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL; PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL; PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL; PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL; PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL; PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL; PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL; PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL; PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL; PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL; PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL; PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL; PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL; PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL; PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL; PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL; PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL; PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL; PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL; PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL; PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL; PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL; PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL; PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL; PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL; PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL; PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL; PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL; PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL; PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL; PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL; PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL; PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL; PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL; PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL; PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL; PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL; PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL; PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL; PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL; PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL; PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL; PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL; PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL; PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL; PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL; PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL; PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL; PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL; PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL; PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL; PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL; PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL; PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL; PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL; PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL; PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL; PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL; PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL; PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL; PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL; PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL; PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL; PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL; PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL; PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL; PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL; PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL = NULL; PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL = NULL; PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL = NULL; PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL; PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL; PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL; PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL; PFNGLBEGINPERFQUERYINTELPROC __glewBeginPerfQueryINTEL = NULL; PFNGLCREATEPERFQUERYINTELPROC __glewCreatePerfQueryINTEL = NULL; PFNGLDELETEPERFQUERYINTELPROC __glewDeletePerfQueryINTEL = NULL; PFNGLENDPERFQUERYINTELPROC __glewEndPerfQueryINTEL = NULL; PFNGLGETFIRSTPERFQUERYIDINTELPROC __glewGetFirstPerfQueryIdINTEL = NULL; PFNGLGETNEXTPERFQUERYIDINTELPROC __glewGetNextPerfQueryIdINTEL = NULL; PFNGLGETPERFCOUNTERINFOINTELPROC __glewGetPerfCounterInfoINTEL = NULL; PFNGLGETPERFQUERYDATAINTELPROC __glewGetPerfQueryDataINTEL = NULL; PFNGLGETPERFQUERYIDBYNAMEINTELPROC __glewGetPerfQueryIdByNameINTEL = NULL; PFNGLGETPERFQUERYINFOINTELPROC __glewGetPerfQueryInfoINTEL = NULL; PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL; PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL; PFNGLBLENDBARRIERKHRPROC __glewBlendBarrierKHR = NULL; PFNGLDEBUGMESSAGECALLBACKPROC __glewDebugMessageCallback = NULL; PFNGLDEBUGMESSAGECONTROLPROC __glewDebugMessageControl = NULL; PFNGLDEBUGMESSAGEINSERTPROC __glewDebugMessageInsert = NULL; PFNGLGETDEBUGMESSAGELOGPROC __glewGetDebugMessageLog = NULL; PFNGLGETOBJECTLABELPROC __glewGetObjectLabel = NULL; PFNGLGETOBJECTPTRLABELPROC __glewGetObjectPtrLabel = NULL; PFNGLOBJECTLABELPROC __glewObjectLabel = NULL; PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel = NULL; PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup = NULL; PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup = NULL; PFNGLGETNUNIFORMFVPROC __glewGetnUniformfv = NULL; PFNGLGETNUNIFORMIVPROC __glewGetnUniformiv = NULL; PFNGLGETNUNIFORMUIVPROC __glewGetnUniformuiv = NULL; PFNGLREADNPIXELSPROC __glewReadnPixels = NULL; PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled = NULL; PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion = NULL; PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion = NULL; PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion = NULL; PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion = NULL; PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL; PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL; PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL; PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL; PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL; PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL; PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL; PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL; PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL; PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL; PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL; PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL; PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL; PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL; PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL; PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL; PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL; PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL; PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL; PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL; PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL; PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL; PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL; PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL; PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL; PFNGLBEGINCONDITIONALRENDERNVXPROC __glewBeginConditionalRenderNVX = NULL; PFNGLENDCONDITIONALRENDERNVXPROC __glewEndConditionalRenderNVX = NULL; PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC __glewMultiDrawArraysIndirectBindlessNV = NULL; PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC __glewMultiDrawElementsIndirectBindlessNV = NULL; PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC __glewMultiDrawArraysIndirectBindlessCountNV = NULL; PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC __glewMultiDrawElementsIndirectBindlessCountNV = NULL; PFNGLGETIMAGEHANDLENVPROC __glewGetImageHandleNV = NULL; PFNGLGETTEXTUREHANDLENVPROC __glewGetTextureHandleNV = NULL; PFNGLGETTEXTURESAMPLERHANDLENVPROC __glewGetTextureSamplerHandleNV = NULL; PFNGLISIMAGEHANDLERESIDENTNVPROC __glewIsImageHandleResidentNV = NULL; PFNGLISTEXTUREHANDLERESIDENTNVPROC __glewIsTextureHandleResidentNV = NULL; PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC __glewMakeImageHandleNonResidentNV = NULL; PFNGLMAKEIMAGEHANDLERESIDENTNVPROC __glewMakeImageHandleResidentNV = NULL; PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC __glewMakeTextureHandleNonResidentNV = NULL; PFNGLMAKETEXTUREHANDLERESIDENTNVPROC __glewMakeTextureHandleResidentNV = NULL; PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC __glewProgramUniformHandleui64NV = NULL; PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC __glewProgramUniformHandleui64vNV = NULL; PFNGLUNIFORMHANDLEUI64NVPROC __glewUniformHandleui64NV = NULL; PFNGLUNIFORMHANDLEUI64VNVPROC __glewUniformHandleui64vNV = NULL; PFNGLBLENDBARRIERNVPROC __glewBlendBarrierNV = NULL; PFNGLBLENDPARAMETERINVPROC __glewBlendParameteriNV = NULL; PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL; PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL; PFNGLSUBPIXELPRECISIONBIASNVPROC __glewSubpixelPrecisionBiasNV = NULL; PFNGLCONSERVATIVERASTERPARAMETERFNVPROC __glewConservativeRasterParameterfNV = NULL; PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL; PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL; PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL; PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL; PFNGLDRAWTEXTURENVPROC __glewDrawTextureNV = NULL; PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL; PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL; PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL; PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL; PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL; PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL; PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL; PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL; PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL; PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL; PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL; PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL; PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL; PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL; PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL; PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL; PFNGLISFENCENVPROC __glewIsFenceNV = NULL; PFNGLSETFENCENVPROC __glewSetFenceNV = NULL; PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL; PFNGLFRAGMENTCOVERAGECOLORNVPROC __glewFragmentCoverageColorNV = NULL; PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL; PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL; PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL; PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL; PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL; PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL; PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL; PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL; PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL; PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL; PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL; PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL; PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL; PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL; PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL; PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL; PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL; PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL; PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL; PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL; PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL; PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL; PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL; PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL; PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL; PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL; PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL; PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL; PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL; PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL; PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL; PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL; PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL; PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL; PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL; PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL; PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL; PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL; PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL; PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL; PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL; PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL; PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL; PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL; PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL; PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL; PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL; PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL; PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL; PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL; PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL; PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL; PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL; PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL; PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL; PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL; PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL; PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL; PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL; PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL; PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL; PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL; PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL; PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL; PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL; PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL; PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL; PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL; PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL; PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL; PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL; PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL; PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL; PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL; PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL; PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL; PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL; PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL; PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL; PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL; PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL; PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL; PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL; PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL; PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL; PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL; PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL; PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL; PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL; PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL; PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL; PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL; PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL; PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL; PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL; PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL; PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL; PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL; PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL; PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL; PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV = NULL; PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL; PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL; PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL; PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL; PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL; PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL; PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL; PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL; PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL; PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL; PFNGLCOPYPATHNVPROC __glewCopyPathNV = NULL; PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV = NULL; PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV = NULL; PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV = NULL; PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV = NULL; PFNGLDELETEPATHSNVPROC __glewDeletePathsNV = NULL; PFNGLGENPATHSNVPROC __glewGenPathsNV = NULL; PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV = NULL; PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV = NULL; PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV = NULL; PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV = NULL; PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV = NULL; PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV = NULL; PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV = NULL; PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV = NULL; PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV = NULL; PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV = NULL; PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV = NULL; PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV = NULL; PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV = NULL; PFNGLGETPROGRAMRESOURCEFVNVPROC __glewGetProgramResourcefvNV = NULL; PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV = NULL; PFNGLISPATHNVPROC __glewIsPathNV = NULL; PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV = NULL; PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV = NULL; PFNGLMATRIXLOAD3X2FNVPROC __glewMatrixLoad3x2fNV = NULL; PFNGLMATRIXLOAD3X3FNVPROC __glewMatrixLoad3x3fNV = NULL; PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC __glewMatrixLoadTranspose3x3fNV = NULL; PFNGLMATRIXMULT3X2FNVPROC __glewMatrixMult3x2fNV = NULL; PFNGLMATRIXMULT3X3FNVPROC __glewMatrixMult3x3fNV = NULL; PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC __glewMatrixMultTranspose3x3fNV = NULL; PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV = NULL; PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV = NULL; PFNGLPATHCOORDSNVPROC __glewPathCoordsNV = NULL; PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV = NULL; PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV = NULL; PFNGLPATHFOGGENNVPROC __glewPathFogGenNV = NULL; PFNGLPATHGLYPHINDEXARRAYNVPROC __glewPathGlyphIndexArrayNV = NULL; PFNGLPATHGLYPHINDEXRANGENVPROC __glewPathGlyphIndexRangeNV = NULL; PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV = NULL; PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV = NULL; PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC __glewPathMemoryGlyphIndexArrayNV = NULL; PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV = NULL; PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV = NULL; PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV = NULL; PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV = NULL; PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV = NULL; PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV = NULL; PFNGLPATHSTRINGNVPROC __glewPathStringNV = NULL; PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV = NULL; PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV = NULL; PFNGLPATHTEXGENNVPROC __glewPathTexGenNV = NULL; PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV = NULL; PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC __glewProgramPathFragmentInputGenNV = NULL; PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV = NULL; PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV = NULL; PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV = NULL; PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV = NULL; PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC __glewStencilThenCoverFillPathInstancedNV = NULL; PFNGLSTENCILTHENCOVERFILLPATHNVPROC __glewStencilThenCoverFillPathNV = NULL; PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC __glewStencilThenCoverStrokePathInstancedNV = NULL; PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC __glewStencilThenCoverStrokePathNV = NULL; PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV = NULL; PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV = NULL; PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL; PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL; PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL; PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL; PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL; PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL; PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL; PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL; PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL; PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL; PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL; PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL; PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL; PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL; PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL; PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL; PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL; PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL; PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL; PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL; PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL; PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL; PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL; PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL; PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL; PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL; PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL; PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewFramebufferSampleLocationsfvNV = NULL; PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewNamedFramebufferSampleLocationsfvNV = NULL; PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL; PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL; PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL; PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL; PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL; PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL; PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL; PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL; PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL; PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL; PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL; PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL; PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL; PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL; PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL; PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV = NULL; PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV = NULL; PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL; PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL; PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL; PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL; PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL; PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL; PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL; PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL; PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL; PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL; PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL; PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL; PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL; PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL; PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL; PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL; PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL; PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL; PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL; PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL; PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL; PFNGLVDPAUFININVPROC __glewVDPAUFiniNV = NULL; PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV = NULL; PFNGLVDPAUINITNVPROC __glewVDPAUInitNV = NULL; PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV = NULL; PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV = NULL; PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV = NULL; PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV = NULL; PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV = NULL; PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV = NULL; PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV = NULL; PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL; PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL; PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL; PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL; PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL; PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL; PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL; PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL; PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL; PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL; PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL; PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL; PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL; PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL; PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL; PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL; PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL; PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL; PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL; PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL; PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL; PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL; PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL; PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL; PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL; PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL; PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL; PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL; PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL; PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL; PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL; PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL; PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL; PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL; PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL; PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL; PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL; PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL; PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL; PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL; PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL; PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL; PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL; PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL; PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL; PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL; PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL; PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL; PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL; PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL; PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL; PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL; PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL; PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL; PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL; PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL; PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL; PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL; PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL; PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL; PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL; PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL; PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL; PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL; PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL; PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL; PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL; PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL; PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL; PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL; PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL; PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL; PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL; PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL; PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL; PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL; PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL; PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL; PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL; PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL; PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL; PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL; PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL; PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL; PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL; PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL; PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL; PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL; PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL; PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL; PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL; PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL; PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL; PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL; PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL; PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL; PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL; PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV = NULL; PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV = NULL; PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV = NULL; PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV = NULL; PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV = NULL; PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV = NULL; PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV = NULL; PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV = NULL; PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV = NULL; PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = NULL; PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL; PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL; PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL; PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL; PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL; PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL; PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL; PFNGLORTHOFOESPROC __glewOrthofOES = NULL; PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR = NULL; PFNGLALPHAFUNCXPROC __glewAlphaFuncx = NULL; PFNGLCLEARCOLORXPROC __glewClearColorx = NULL; PFNGLCLEARDEPTHXPROC __glewClearDepthx = NULL; PFNGLCOLOR4XPROC __glewColor4x = NULL; PFNGLDEPTHRANGEXPROC __glewDepthRangex = NULL; PFNGLFOGXPROC __glewFogx = NULL; PFNGLFOGXVPROC __glewFogxv = NULL; PFNGLFRUSTUMFPROC __glewFrustumf = NULL; PFNGLFRUSTUMXPROC __glewFrustumx = NULL; PFNGLLIGHTMODELXPROC __glewLightModelx = NULL; PFNGLLIGHTMODELXVPROC __glewLightModelxv = NULL; PFNGLLIGHTXPROC __glewLightx = NULL; PFNGLLIGHTXVPROC __glewLightxv = NULL; PFNGLLINEWIDTHXPROC __glewLineWidthx = NULL; PFNGLLOADMATRIXXPROC __glewLoadMatrixx = NULL; PFNGLMATERIALXPROC __glewMaterialx = NULL; PFNGLMATERIALXVPROC __glewMaterialxv = NULL; PFNGLMULTMATRIXXPROC __glewMultMatrixx = NULL; PFNGLMULTITEXCOORD4XPROC __glewMultiTexCoord4x = NULL; PFNGLNORMAL3XPROC __glewNormal3x = NULL; PFNGLORTHOFPROC __glewOrthof = NULL; PFNGLORTHOXPROC __glewOrthox = NULL; PFNGLPOINTSIZEXPROC __glewPointSizex = NULL; PFNGLPOLYGONOFFSETXPROC __glewPolygonOffsetx = NULL; PFNGLROTATEXPROC __glewRotatex = NULL; PFNGLSAMPLECOVERAGEXPROC __glewSampleCoveragex = NULL; PFNGLSCALEXPROC __glewScalex = NULL; PFNGLTEXENVXPROC __glewTexEnvx = NULL; PFNGLTEXENVXVPROC __glewTexEnvxv = NULL; PFNGLTEXPARAMETERXPROC __glewTexParameterx = NULL; PFNGLTRANSLATEXPROC __glewTranslatex = NULL; PFNGLCLIPPLANEFPROC __glewClipPlanef = NULL; PFNGLCLIPPLANEXPROC __glewClipPlanex = NULL; PFNGLGETCLIPPLANEFPROC __glewGetClipPlanef = NULL; PFNGLGETCLIPPLANEXPROC __glewGetClipPlanex = NULL; PFNGLGETFIXEDVPROC __glewGetFixedv = NULL; PFNGLGETLIGHTXVPROC __glewGetLightxv = NULL; PFNGLGETMATERIALXVPROC __glewGetMaterialxv = NULL; PFNGLGETTEXENVXVPROC __glewGetTexEnvxv = NULL; PFNGLGETTEXPARAMETERXVPROC __glewGetTexParameterxv = NULL; PFNGLPOINTPARAMETERXPROC __glewPointParameterx = NULL; PFNGLPOINTPARAMETERXVPROC __glewPointParameterxv = NULL; PFNGLPOINTSIZEPOINTEROESPROC __glewPointSizePointerOES = NULL; PFNGLTEXPARAMETERXVPROC __glewTexParameterxv = NULL; PFNGLERRORSTRINGREGALPROC __glewErrorStringREGAL = NULL; PFNGLGETEXTENSIONREGALPROC __glewGetExtensionREGAL = NULL; PFNGLISSUPPORTEDREGALPROC __glewIsSupportedREGAL = NULL; PFNGLLOGMESSAGECALLBACKREGALPROC __glewLogMessageCallbackREGAL = NULL; PFNGLGETPROCADDRESSREGALPROC __glewGetProcAddressREGAL = NULL; PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL; PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL; PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL; PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL; PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL; PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL; PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL; PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL; PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL; PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL; PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL; PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL; PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL; PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL; PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL; PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL; PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL; PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL; PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL; PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL; PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL; PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL; PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL; PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL; PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL; PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL; PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL; PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL; PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL; PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL; PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL; PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL; PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL; PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL; PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL; PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL; PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL; PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL; PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL; PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL; PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL; PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL; PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL; PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL; PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL; PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL; PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL; PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL; PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL; PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL; PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL; PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL; PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL; PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL; PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL; PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL; PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL; PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL; PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL; PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL; PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL; PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL; PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL; PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL; PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL; PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL; PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL; PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL; PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL; PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL; PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL; PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL; PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL; PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL; PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL; PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL; PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL; PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL; PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL; PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL; PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL; PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL; PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL; PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL; PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL; PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL; PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL; PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL; PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL; PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL; PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL; PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL; PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL; PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL; PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL; PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL; #endif /* !WIN32 || !GLEW_MX */ #if !defined(GLEW_MX) GLboolean __GLEW_VERSION_1_1 = GL_FALSE; GLboolean __GLEW_VERSION_1_2 = GL_FALSE; GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE; GLboolean __GLEW_VERSION_1_3 = GL_FALSE; GLboolean __GLEW_VERSION_1_4 = GL_FALSE; GLboolean __GLEW_VERSION_1_5 = GL_FALSE; GLboolean __GLEW_VERSION_2_0 = GL_FALSE; GLboolean __GLEW_VERSION_2_1 = GL_FALSE; GLboolean __GLEW_VERSION_3_0 = GL_FALSE; GLboolean __GLEW_VERSION_3_1 = GL_FALSE; GLboolean __GLEW_VERSION_3_2 = GL_FALSE; GLboolean __GLEW_VERSION_3_3 = GL_FALSE; GLboolean __GLEW_VERSION_4_0 = GL_FALSE; GLboolean __GLEW_VERSION_4_1 = GL_FALSE; GLboolean __GLEW_VERSION_4_2 = GL_FALSE; GLboolean __GLEW_VERSION_4_3 = GL_FALSE; GLboolean __GLEW_VERSION_4_4 = GL_FALSE; GLboolean __GLEW_VERSION_4_5 = GL_FALSE; GLboolean __GLEW_3DFX_multisample = GL_FALSE; GLboolean __GLEW_3DFX_tbuffer = GL_FALSE; GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE; GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE; GLboolean __GLEW_AMD_conservative_depth = GL_FALSE; GLboolean __GLEW_AMD_debug_output = GL_FALSE; GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE; GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE; GLboolean __GLEW_AMD_gcn_shader = GL_FALSE; GLboolean __GLEW_AMD_gpu_shader_int64 = GL_FALSE; GLboolean __GLEW_AMD_interleaved_elements = GL_FALSE; GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE; GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE; GLboolean __GLEW_AMD_occlusion_query_event = GL_FALSE; GLboolean __GLEW_AMD_performance_monitor = GL_FALSE; GLboolean __GLEW_AMD_pinned_memory = GL_FALSE; GLboolean __GLEW_AMD_query_buffer_object = GL_FALSE; GLboolean __GLEW_AMD_sample_positions = GL_FALSE; GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE; GLboolean __GLEW_AMD_shader_atomic_counter_ops = GL_FALSE; GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE; GLboolean __GLEW_AMD_shader_stencil_value_export = GL_FALSE; GLboolean __GLEW_AMD_shader_trinary_minmax = GL_FALSE; GLboolean __GLEW_AMD_sparse_texture = GL_FALSE; GLboolean __GLEW_AMD_stencil_operation_extended = GL_FALSE; GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE; GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE; GLboolean __GLEW_AMD_transform_feedback4 = GL_FALSE; GLboolean __GLEW_AMD_vertex_shader_layer = GL_FALSE; GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE; GLboolean __GLEW_AMD_vertex_shader_viewport_index = GL_FALSE; GLboolean __GLEW_ANGLE_depth_texture = GL_FALSE; GLboolean __GLEW_ANGLE_framebuffer_blit = GL_FALSE; GLboolean __GLEW_ANGLE_framebuffer_multisample = GL_FALSE; GLboolean __GLEW_ANGLE_instanced_arrays = GL_FALSE; GLboolean __GLEW_ANGLE_pack_reverse_row_order = GL_FALSE; GLboolean __GLEW_ANGLE_program_binary = GL_FALSE; GLboolean __GLEW_ANGLE_texture_compression_dxt1 = GL_FALSE; GLboolean __GLEW_ANGLE_texture_compression_dxt3 = GL_FALSE; GLboolean __GLEW_ANGLE_texture_compression_dxt5 = GL_FALSE; GLboolean __GLEW_ANGLE_texture_usage = GL_FALSE; GLboolean __GLEW_ANGLE_timer_query = GL_FALSE; GLboolean __GLEW_ANGLE_translated_shader_source = GL_FALSE; GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE; GLboolean __GLEW_APPLE_client_storage = GL_FALSE; GLboolean __GLEW_APPLE_element_array = GL_FALSE; GLboolean __GLEW_APPLE_fence = GL_FALSE; GLboolean __GLEW_APPLE_float_pixels = GL_FALSE; GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE; GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE; GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE; GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE; GLboolean __GLEW_APPLE_row_bytes = GL_FALSE; GLboolean __GLEW_APPLE_specular_vector = GL_FALSE; GLboolean __GLEW_APPLE_texture_range = GL_FALSE; GLboolean __GLEW_APPLE_transform_hint = GL_FALSE; GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE; GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE; GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE; GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE; GLboolean __GLEW_ARB_ES2_compatibility = GL_FALSE; GLboolean __GLEW_ARB_ES3_1_compatibility = GL_FALSE; GLboolean __GLEW_ARB_ES3_2_compatibility = GL_FALSE; GLboolean __GLEW_ARB_ES3_compatibility = GL_FALSE; GLboolean __GLEW_ARB_arrays_of_arrays = GL_FALSE; GLboolean __GLEW_ARB_base_instance = GL_FALSE; GLboolean __GLEW_ARB_bindless_texture = GL_FALSE; GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE; GLboolean __GLEW_ARB_buffer_storage = GL_FALSE; GLboolean __GLEW_ARB_cl_event = GL_FALSE; GLboolean __GLEW_ARB_clear_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_clear_texture = GL_FALSE; GLboolean __GLEW_ARB_clip_control = GL_FALSE; GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE; GLboolean __GLEW_ARB_compatibility = GL_FALSE; GLboolean __GLEW_ARB_compressed_texture_pixel_storage = GL_FALSE; GLboolean __GLEW_ARB_compute_shader = GL_FALSE; GLboolean __GLEW_ARB_compute_variable_group_size = GL_FALSE; GLboolean __GLEW_ARB_conditional_render_inverted = GL_FALSE; GLboolean __GLEW_ARB_conservative_depth = GL_FALSE; GLboolean __GLEW_ARB_copy_buffer = GL_FALSE; GLboolean __GLEW_ARB_copy_image = GL_FALSE; GLboolean __GLEW_ARB_cull_distance = GL_FALSE; GLboolean __GLEW_ARB_debug_output = GL_FALSE; GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE; GLboolean __GLEW_ARB_depth_clamp = GL_FALSE; GLboolean __GLEW_ARB_depth_texture = GL_FALSE; GLboolean __GLEW_ARB_derivative_control = GL_FALSE; GLboolean __GLEW_ARB_direct_state_access = GL_FALSE; GLboolean __GLEW_ARB_draw_buffers = GL_FALSE; GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE; GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE; GLboolean __GLEW_ARB_draw_indirect = GL_FALSE; GLboolean __GLEW_ARB_draw_instanced = GL_FALSE; GLboolean __GLEW_ARB_enhanced_layouts = GL_FALSE; GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE; GLboolean __GLEW_ARB_explicit_uniform_location = GL_FALSE; GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE; GLboolean __GLEW_ARB_fragment_layer_viewport = GL_FALSE; GLboolean __GLEW_ARB_fragment_program = GL_FALSE; GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE; GLboolean __GLEW_ARB_fragment_shader = GL_FALSE; GLboolean __GLEW_ARB_fragment_shader_interlock = GL_FALSE; GLboolean __GLEW_ARB_framebuffer_no_attachments = GL_FALSE; GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE; GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE; GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE; GLboolean __GLEW_ARB_get_program_binary = GL_FALSE; GLboolean __GLEW_ARB_get_texture_sub_image = GL_FALSE; GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE; GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE; GLboolean __GLEW_ARB_gpu_shader_int64 = GL_FALSE; GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE; GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE; GLboolean __GLEW_ARB_imaging = GL_FALSE; GLboolean __GLEW_ARB_indirect_parameters = GL_FALSE; GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE; GLboolean __GLEW_ARB_internalformat_query = GL_FALSE; GLboolean __GLEW_ARB_internalformat_query2 = GL_FALSE; GLboolean __GLEW_ARB_invalidate_subdata = GL_FALSE; GLboolean __GLEW_ARB_map_buffer_alignment = GL_FALSE; GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE; GLboolean __GLEW_ARB_matrix_palette = GL_FALSE; GLboolean __GLEW_ARB_multi_bind = GL_FALSE; GLboolean __GLEW_ARB_multi_draw_indirect = GL_FALSE; GLboolean __GLEW_ARB_multisample = GL_FALSE; GLboolean __GLEW_ARB_multitexture = GL_FALSE; GLboolean __GLEW_ARB_occlusion_query = GL_FALSE; GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE; GLboolean __GLEW_ARB_parallel_shader_compile = GL_FALSE; GLboolean __GLEW_ARB_pipeline_statistics_query = GL_FALSE; GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_point_parameters = GL_FALSE; GLboolean __GLEW_ARB_point_sprite = GL_FALSE; GLboolean __GLEW_ARB_post_depth_coverage = GL_FALSE; GLboolean __GLEW_ARB_program_interface_query = GL_FALSE; GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE; GLboolean __GLEW_ARB_query_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_robust_buffer_access_behavior = GL_FALSE; GLboolean __GLEW_ARB_robustness = GL_FALSE; GLboolean __GLEW_ARB_robustness_application_isolation = GL_FALSE; GLboolean __GLEW_ARB_robustness_share_group_isolation = GL_FALSE; GLboolean __GLEW_ARB_sample_locations = GL_FALSE; GLboolean __GLEW_ARB_sample_shading = GL_FALSE; GLboolean __GLEW_ARB_sampler_objects = GL_FALSE; GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE; GLboolean __GLEW_ARB_seamless_cubemap_per_texture = GL_FALSE; GLboolean __GLEW_ARB_separate_shader_objects = GL_FALSE; GLboolean __GLEW_ARB_shader_atomic_counter_ops = GL_FALSE; GLboolean __GLEW_ARB_shader_atomic_counters = GL_FALSE; GLboolean __GLEW_ARB_shader_ballot = GL_FALSE; GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE; GLboolean __GLEW_ARB_shader_clock = GL_FALSE; GLboolean __GLEW_ARB_shader_draw_parameters = GL_FALSE; GLboolean __GLEW_ARB_shader_group_vote = GL_FALSE; GLboolean __GLEW_ARB_shader_image_load_store = GL_FALSE; GLboolean __GLEW_ARB_shader_image_size = GL_FALSE; GLboolean __GLEW_ARB_shader_objects = GL_FALSE; GLboolean __GLEW_ARB_shader_precision = GL_FALSE; GLboolean __GLEW_ARB_shader_stencil_export = GL_FALSE; GLboolean __GLEW_ARB_shader_storage_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE; GLboolean __GLEW_ARB_shader_texture_image_samples = GL_FALSE; GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE; GLboolean __GLEW_ARB_shader_viewport_layer_array = GL_FALSE; GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE; GLboolean __GLEW_ARB_shading_language_420pack = GL_FALSE; GLboolean __GLEW_ARB_shading_language_include = GL_FALSE; GLboolean __GLEW_ARB_shading_language_packing = GL_FALSE; GLboolean __GLEW_ARB_shadow = GL_FALSE; GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE; GLboolean __GLEW_ARB_sparse_buffer = GL_FALSE; GLboolean __GLEW_ARB_sparse_texture = GL_FALSE; GLboolean __GLEW_ARB_sparse_texture2 = GL_FALSE; GLboolean __GLEW_ARB_sparse_texture_clamp = GL_FALSE; GLboolean __GLEW_ARB_stencil_texturing = GL_FALSE; GLboolean __GLEW_ARB_sync = GL_FALSE; GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE; GLboolean __GLEW_ARB_texture_barrier = GL_FALSE; GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE; GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE; GLboolean __GLEW_ARB_texture_buffer_range = GL_FALSE; GLboolean __GLEW_ARB_texture_compression = GL_FALSE; GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE; GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE; GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE; GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE; GLboolean __GLEW_ARB_texture_env_add = GL_FALSE; GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE; GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE; GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE; GLboolean __GLEW_ARB_texture_filter_minmax = GL_FALSE; GLboolean __GLEW_ARB_texture_float = GL_FALSE; GLboolean __GLEW_ARB_texture_gather = GL_FALSE; GLboolean __GLEW_ARB_texture_mirror_clamp_to_edge = GL_FALSE; GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE; GLboolean __GLEW_ARB_texture_multisample = GL_FALSE; GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE; GLboolean __GLEW_ARB_texture_query_levels = GL_FALSE; GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE; GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE; GLboolean __GLEW_ARB_texture_rg = GL_FALSE; GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE; GLboolean __GLEW_ARB_texture_stencil8 = GL_FALSE; GLboolean __GLEW_ARB_texture_storage = GL_FALSE; GLboolean __GLEW_ARB_texture_storage_multisample = GL_FALSE; GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE; GLboolean __GLEW_ARB_texture_view = GL_FALSE; GLboolean __GLEW_ARB_timer_query = GL_FALSE; GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE; GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE; GLboolean __GLEW_ARB_transform_feedback_instanced = GL_FALSE; GLboolean __GLEW_ARB_transform_feedback_overflow_query = GL_FALSE; GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE; GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE; GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE; GLboolean __GLEW_ARB_vertex_attrib_64bit = GL_FALSE; GLboolean __GLEW_ARB_vertex_attrib_binding = GL_FALSE; GLboolean __GLEW_ARB_vertex_blend = GL_FALSE; GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_vertex_program = GL_FALSE; GLboolean __GLEW_ARB_vertex_shader = GL_FALSE; GLboolean __GLEW_ARB_vertex_type_10f_11f_11f_rev = GL_FALSE; GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE; GLboolean __GLEW_ARB_viewport_array = GL_FALSE; GLboolean __GLEW_ARB_window_pos = GL_FALSE; GLboolean __GLEW_ATIX_point_sprites = GL_FALSE; GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE; GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE; GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE; GLboolean __GLEW_ATI_draw_buffers = GL_FALSE; GLboolean __GLEW_ATI_element_array = GL_FALSE; GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE; GLboolean __GLEW_ATI_fragment_shader = GL_FALSE; GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE; GLboolean __GLEW_ATI_meminfo = GL_FALSE; GLboolean __GLEW_ATI_pn_triangles = GL_FALSE; GLboolean __GLEW_ATI_separate_stencil = GL_FALSE; GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE; GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE; GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE; GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE; GLboolean __GLEW_ATI_texture_float = GL_FALSE; GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE; GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE; GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE; GLboolean __GLEW_ATI_vertex_streams = GL_FALSE; GLboolean __GLEW_EXT_422_pixels = GL_FALSE; GLboolean __GLEW_EXT_Cg_shader = GL_FALSE; GLboolean __GLEW_EXT_abgr = GL_FALSE; GLboolean __GLEW_EXT_bgra = GL_FALSE; GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE; GLboolean __GLEW_EXT_blend_color = GL_FALSE; GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE; GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE; GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE; GLboolean __GLEW_EXT_blend_minmax = GL_FALSE; GLboolean __GLEW_EXT_blend_subtract = GL_FALSE; GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE; GLboolean __GLEW_EXT_cmyka = GL_FALSE; GLboolean __GLEW_EXT_color_subtable = GL_FALSE; GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE; GLboolean __GLEW_EXT_convolution = GL_FALSE; GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE; GLboolean __GLEW_EXT_copy_texture = GL_FALSE; GLboolean __GLEW_EXT_cull_vertex = GL_FALSE; GLboolean __GLEW_EXT_debug_label = GL_FALSE; GLboolean __GLEW_EXT_debug_marker = GL_FALSE; GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE; GLboolean __GLEW_EXT_direct_state_access = GL_FALSE; GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE; GLboolean __GLEW_EXT_draw_instanced = GL_FALSE; GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE; GLboolean __GLEW_EXT_fog_coord = GL_FALSE; GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE; GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE; GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE; GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE; GLboolean __GLEW_EXT_histogram = GL_FALSE; GLboolean __GLEW_EXT_index_array_formats = GL_FALSE; GLboolean __GLEW_EXT_index_func = GL_FALSE; GLboolean __GLEW_EXT_index_material = GL_FALSE; GLboolean __GLEW_EXT_index_texture = GL_FALSE; GLboolean __GLEW_EXT_light_texture = GL_FALSE; GLboolean __GLEW_EXT_misc_attribute = GL_FALSE; GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE; GLboolean __GLEW_EXT_multisample = GL_FALSE; GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE; GLboolean __GLEW_EXT_packed_float = GL_FALSE; GLboolean __GLEW_EXT_packed_pixels = GL_FALSE; GLboolean __GLEW_EXT_paletted_texture = GL_FALSE; GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE; GLboolean __GLEW_EXT_pixel_transform = GL_FALSE; GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE; GLboolean __GLEW_EXT_point_parameters = GL_FALSE; GLboolean __GLEW_EXT_polygon_offset = GL_FALSE; GLboolean __GLEW_EXT_polygon_offset_clamp = GL_FALSE; GLboolean __GLEW_EXT_post_depth_coverage = GL_FALSE; GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE; GLboolean __GLEW_EXT_raster_multisample = GL_FALSE; GLboolean __GLEW_EXT_rescale_normal = GL_FALSE; GLboolean __GLEW_EXT_scene_marker = GL_FALSE; GLboolean __GLEW_EXT_secondary_color = GL_FALSE; GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE; GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE; GLboolean __GLEW_EXT_shader_image_load_formatted = GL_FALSE; GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE; GLboolean __GLEW_EXT_shader_integer_mix = GL_FALSE; GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE; GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE; GLboolean __GLEW_EXT_sparse_texture2 = GL_FALSE; GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE; GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE; GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE; GLboolean __GLEW_EXT_subtexture = GL_FALSE; GLboolean __GLEW_EXT_texture = GL_FALSE; GLboolean __GLEW_EXT_texture3D = GL_FALSE; GLboolean __GLEW_EXT_texture_array = GL_FALSE; GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE; GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE; GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE; GLboolean __GLEW_EXT_texture_env = GL_FALSE; GLboolean __GLEW_EXT_texture_env_add = GL_FALSE; GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE; GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE; GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE; GLboolean __GLEW_EXT_texture_filter_minmax = GL_FALSE; GLboolean __GLEW_EXT_texture_integer = GL_FALSE; GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE; GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE; GLboolean __GLEW_EXT_texture_object = GL_FALSE; GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE; GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE; GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE; GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE; GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE; GLboolean __GLEW_EXT_texture_snorm = GL_FALSE; GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE; GLboolean __GLEW_EXT_timer_query = GL_FALSE; GLboolean __GLEW_EXT_transform_feedback = GL_FALSE; GLboolean __GLEW_EXT_vertex_array = GL_FALSE; GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE; GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE; GLboolean __GLEW_EXT_vertex_shader = GL_FALSE; GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE; GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE; GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE; GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE; GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE; GLboolean __GLEW_HP_image_transform = GL_FALSE; GLboolean __GLEW_HP_occlusion_test = GL_FALSE; GLboolean __GLEW_HP_texture_lighting = GL_FALSE; GLboolean __GLEW_IBM_cull_vertex = GL_FALSE; GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE; GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE; GLboolean __GLEW_IBM_static_data = GL_FALSE; GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE; GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE; GLboolean __GLEW_INGR_color_clamp = GL_FALSE; GLboolean __GLEW_INGR_interlace_read = GL_FALSE; GLboolean __GLEW_INTEL_fragment_shader_ordering = GL_FALSE; GLboolean __GLEW_INTEL_framebuffer_CMAA = GL_FALSE; GLboolean __GLEW_INTEL_map_texture = GL_FALSE; GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE; GLboolean __GLEW_INTEL_performance_query = GL_FALSE; GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE; GLboolean __GLEW_KHR_blend_equation_advanced = GL_FALSE; GLboolean __GLEW_KHR_blend_equation_advanced_coherent = GL_FALSE; GLboolean __GLEW_KHR_context_flush_control = GL_FALSE; GLboolean __GLEW_KHR_debug = GL_FALSE; GLboolean __GLEW_KHR_no_error = GL_FALSE; GLboolean __GLEW_KHR_robust_buffer_access_behavior = GL_FALSE; GLboolean __GLEW_KHR_robustness = GL_FALSE; GLboolean __GLEW_KHR_texture_compression_astc_hdr = GL_FALSE; GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE; GLboolean __GLEW_KTX_buffer_region = GL_FALSE; GLboolean __GLEW_MESAX_texture_stack = GL_FALSE; GLboolean __GLEW_MESA_pack_invert = GL_FALSE; GLboolean __GLEW_MESA_resize_buffers = GL_FALSE; GLboolean __GLEW_MESA_window_pos = GL_FALSE; GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE; GLboolean __GLEW_NVX_conditional_render = GL_FALSE; GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE; GLboolean __GLEW_NV_bindless_multi_draw_indirect = GL_FALSE; GLboolean __GLEW_NV_bindless_multi_draw_indirect_count = GL_FALSE; GLboolean __GLEW_NV_bindless_texture = GL_FALSE; GLboolean __GLEW_NV_blend_equation_advanced = GL_FALSE; GLboolean __GLEW_NV_blend_equation_advanced_coherent = GL_FALSE; GLboolean __GLEW_NV_blend_square = GL_FALSE; GLboolean __GLEW_NV_compute_program5 = GL_FALSE; GLboolean __GLEW_NV_conditional_render = GL_FALSE; GLboolean __GLEW_NV_conservative_raster = GL_FALSE; GLboolean __GLEW_NV_conservative_raster_dilate = GL_FALSE; GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE; GLboolean __GLEW_NV_copy_image = GL_FALSE; GLboolean __GLEW_NV_deep_texture3D = GL_FALSE; GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE; GLboolean __GLEW_NV_depth_clamp = GL_FALSE; GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE; GLboolean __GLEW_NV_draw_texture = GL_FALSE; GLboolean __GLEW_NV_evaluators = GL_FALSE; GLboolean __GLEW_NV_explicit_multisample = GL_FALSE; GLboolean __GLEW_NV_fence = GL_FALSE; GLboolean __GLEW_NV_fill_rectangle = GL_FALSE; GLboolean __GLEW_NV_float_buffer = GL_FALSE; GLboolean __GLEW_NV_fog_distance = GL_FALSE; GLboolean __GLEW_NV_fragment_coverage_to_color = GL_FALSE; GLboolean __GLEW_NV_fragment_program = GL_FALSE; GLboolean __GLEW_NV_fragment_program2 = GL_FALSE; GLboolean __GLEW_NV_fragment_program4 = GL_FALSE; GLboolean __GLEW_NV_fragment_program_option = GL_FALSE; GLboolean __GLEW_NV_fragment_shader_interlock = GL_FALSE; GLboolean __GLEW_NV_framebuffer_mixed_samples = GL_FALSE; GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE; GLboolean __GLEW_NV_geometry_program4 = GL_FALSE; GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE; GLboolean __GLEW_NV_geometry_shader_passthrough = GL_FALSE; GLboolean __GLEW_NV_gpu_program4 = GL_FALSE; GLboolean __GLEW_NV_gpu_program5 = GL_FALSE; GLboolean __GLEW_NV_gpu_program5_mem_extended = GL_FALSE; GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE; GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE; GLboolean __GLEW_NV_half_float = GL_FALSE; GLboolean __GLEW_NV_internalformat_sample_query = GL_FALSE; GLboolean __GLEW_NV_light_max_exponent = GL_FALSE; GLboolean __GLEW_NV_multisample_coverage = GL_FALSE; GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE; GLboolean __GLEW_NV_occlusion_query = GL_FALSE; GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE; GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE; GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE; GLboolean __GLEW_NV_path_rendering = GL_FALSE; GLboolean __GLEW_NV_path_rendering_shared_edge = GL_FALSE; GLboolean __GLEW_NV_pixel_data_range = GL_FALSE; GLboolean __GLEW_NV_point_sprite = GL_FALSE; GLboolean __GLEW_NV_present_video = GL_FALSE; GLboolean __GLEW_NV_primitive_restart = GL_FALSE; GLboolean __GLEW_NV_register_combiners = GL_FALSE; GLboolean __GLEW_NV_register_combiners2 = GL_FALSE; GLboolean __GLEW_NV_sample_locations = GL_FALSE; GLboolean __GLEW_NV_sample_mask_override_coverage = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_counters = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_float = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_fp16_vector = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_int64 = GL_FALSE; GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE; GLboolean __GLEW_NV_shader_storage_buffer_object = GL_FALSE; GLboolean __GLEW_NV_shader_thread_group = GL_FALSE; GLboolean __GLEW_NV_shader_thread_shuffle = GL_FALSE; GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE; GLboolean __GLEW_NV_texgen_emboss = GL_FALSE; GLboolean __GLEW_NV_texgen_reflection = GL_FALSE; GLboolean __GLEW_NV_texture_barrier = GL_FALSE; GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE; GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE; GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE; GLboolean __GLEW_NV_texture_multisample = GL_FALSE; GLboolean __GLEW_NV_texture_rectangle = GL_FALSE; GLboolean __GLEW_NV_texture_shader = GL_FALSE; GLboolean __GLEW_NV_texture_shader2 = GL_FALSE; GLboolean __GLEW_NV_texture_shader3 = GL_FALSE; GLboolean __GLEW_NV_transform_feedback = GL_FALSE; GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE; GLboolean __GLEW_NV_uniform_buffer_unified_memory = GL_FALSE; GLboolean __GLEW_NV_vdpau_interop = GL_FALSE; GLboolean __GLEW_NV_vertex_array_range = GL_FALSE; GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE; GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE; GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE; GLboolean __GLEW_NV_vertex_program = GL_FALSE; GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE; GLboolean __GLEW_NV_vertex_program2 = GL_FALSE; GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE; GLboolean __GLEW_NV_vertex_program3 = GL_FALSE; GLboolean __GLEW_NV_vertex_program4 = GL_FALSE; GLboolean __GLEW_NV_video_capture = GL_FALSE; GLboolean __GLEW_NV_viewport_array2 = GL_FALSE; GLboolean __GLEW_OES_byte_coordinates = GL_FALSE; GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE; GLboolean __GLEW_OES_read_format = GL_FALSE; GLboolean __GLEW_OES_single_precision = GL_FALSE; GLboolean __GLEW_OML_interlace = GL_FALSE; GLboolean __GLEW_OML_resample = GL_FALSE; GLboolean __GLEW_OML_subsample = GL_FALSE; GLboolean __GLEW_OVR_multiview = GL_FALSE; GLboolean __GLEW_OVR_multiview2 = GL_FALSE; GLboolean __GLEW_PGI_misc_hints = GL_FALSE; GLboolean __GLEW_PGI_vertex_hints = GL_FALSE; GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE; GLboolean __GLEW_REGAL_ES1_1_compatibility = GL_FALSE; GLboolean __GLEW_REGAL_enable = GL_FALSE; GLboolean __GLEW_REGAL_error_string = GL_FALSE; GLboolean __GLEW_REGAL_extension_query = GL_FALSE; GLboolean __GLEW_REGAL_log = GL_FALSE; GLboolean __GLEW_REGAL_proc_address = GL_FALSE; GLboolean __GLEW_REND_screen_coordinates = GL_FALSE; GLboolean __GLEW_S3_s3tc = GL_FALSE; GLboolean __GLEW_SGIS_color_range = GL_FALSE; GLboolean __GLEW_SGIS_detail_texture = GL_FALSE; GLboolean __GLEW_SGIS_fog_function = GL_FALSE; GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE; GLboolean __GLEW_SGIS_multisample = GL_FALSE; GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE; GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE; GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE; GLboolean __GLEW_SGIS_texture4D = GL_FALSE; GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE; GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE; GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE; GLboolean __GLEW_SGIS_texture_lod = GL_FALSE; GLboolean __GLEW_SGIS_texture_select = GL_FALSE; GLboolean __GLEW_SGIX_async = GL_FALSE; GLboolean __GLEW_SGIX_async_histogram = GL_FALSE; GLboolean __GLEW_SGIX_async_pixel = GL_FALSE; GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE; GLboolean __GLEW_SGIX_clipmap = GL_FALSE; GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE; GLboolean __GLEW_SGIX_depth_texture = GL_FALSE; GLboolean __GLEW_SGIX_flush_raster = GL_FALSE; GLboolean __GLEW_SGIX_fog_offset = GL_FALSE; GLboolean __GLEW_SGIX_fog_texture = GL_FALSE; GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE; GLboolean __GLEW_SGIX_framezoom = GL_FALSE; GLboolean __GLEW_SGIX_interlace = GL_FALSE; GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE; GLboolean __GLEW_SGIX_list_priority = GL_FALSE; GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE; GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE; GLboolean __GLEW_SGIX_reference_plane = GL_FALSE; GLboolean __GLEW_SGIX_resample = GL_FALSE; GLboolean __GLEW_SGIX_shadow = GL_FALSE; GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE; GLboolean __GLEW_SGIX_sprite = GL_FALSE; GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE; GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE; GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE; GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE; GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE; GLboolean __GLEW_SGIX_texture_range = GL_FALSE; GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE; GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE; GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE; GLboolean __GLEW_SGIX_ycrcb = GL_FALSE; GLboolean __GLEW_SGI_color_matrix = GL_FALSE; GLboolean __GLEW_SGI_color_table = GL_FALSE; GLboolean __GLEW_SGI_texture_color_table = GL_FALSE; GLboolean __GLEW_SUNX_constant_data = GL_FALSE; GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE; GLboolean __GLEW_SUN_global_alpha = GL_FALSE; GLboolean __GLEW_SUN_mesh_array = GL_FALSE; GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE; GLboolean __GLEW_SUN_slice_accum = GL_FALSE; GLboolean __GLEW_SUN_triangle_list = GL_FALSE; GLboolean __GLEW_SUN_vertex = GL_FALSE; GLboolean __GLEW_WIN_phong_shading = GL_FALSE; GLboolean __GLEW_WIN_specular_fog = GL_FALSE; GLboolean __GLEW_WIN_swap_hint = GL_FALSE; #endif /* !GLEW_MX */ #ifdef GL_VERSION_1_2 static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r; r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r; r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r; r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r; return r; } #endif /* GL_VERSION_1_2 */ #ifdef GL_VERSION_1_3 static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r; r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r; r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r; r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r; r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r; r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r; r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r; r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r; r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r; r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r; r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r; r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r; r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r; r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r; r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r; r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r; r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r; r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r; r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r; r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r; r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r; r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r; r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r; r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r; r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r; r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r; r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r; r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r; r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r; r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r; r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r; r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r; r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r; r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r; r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r; r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r; r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r; r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r; r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r; r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r; r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r; r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r; r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r; r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r; r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r; r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r; return r; } #endif /* GL_VERSION_1_3 */ #ifdef GL_VERSION_1_4 static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r; r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r; r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r; r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r; r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r; r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r; r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r; r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r; r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r; r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r; r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r; r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r; r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r; r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r; r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r; r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r; r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r; r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r; r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r; r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r; r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r; r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r; r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r; r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r; r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r; r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r; r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r; r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r; r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r; r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r; r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r; r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r; r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r; r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r; r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r; r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r; r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r; r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r; r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r; r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r; r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r; r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r; r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r; r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r; r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r; r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r; return r; } #endif /* GL_VERSION_1_4 */ #ifdef GL_VERSION_1_5 static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r; r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r; r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r; r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r; r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r; r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r; r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r; r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r; r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r; r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r; r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r; r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r; r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r; r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r; r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r; r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r; r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r; r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r; r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r; return r; } #endif /* GL_VERSION_1_5 */ #ifdef GL_VERSION_2_0 static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r; r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r; r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r; r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r; r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r; r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r; r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r; r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r; r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r; r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r; r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r; r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r; r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r; r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r; r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r; r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r; r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r; r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r; r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r; r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r; r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r; r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r; r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r; r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r; r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r; r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r; r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r; r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r; r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r; r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r; r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r; r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r; r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r; r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r; r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r; r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r; r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r; r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r; r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r; r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r; r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r; r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r; r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r; r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r; r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r; r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r; r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r; r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r; r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r; r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r; r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r; r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r; r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r; r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r; r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r; r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r; r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r; r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r; r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r; r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r; r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r; r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r; r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r; r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r; r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r; r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r; r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r; r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r; r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r; r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r; r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r; r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r; r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r; r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r; r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r; r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r; r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r; r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r; r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r; r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r; r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r; r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r; r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r; r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r; r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r; r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r; r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r; r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r; r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r; r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r; r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r; r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r; r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r; return r; } #endif /* GL_VERSION_2_0 */ #ifdef GL_VERSION_2_1 static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r; r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r; r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r; r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r; r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r; r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r; return r; } #endif /* GL_VERSION_2_1 */ #ifdef GL_VERSION_3_0 static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r; r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r; r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r; r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r; r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r; r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r; r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r; r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r; r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r; r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r; r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r; r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r; r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r; r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r; r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r; r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r; r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r; r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r; r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r; r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r; r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r; r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r; r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r; r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r; r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r; r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r; r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r; r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r; r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r; r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r; r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r; r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r; r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r; r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r; r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r; r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r; r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r; r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r; r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r; r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r; r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r; r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r; r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r; r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r; r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r; r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r; r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r; r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r; r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r; r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r; r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r; r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r; r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r; r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r; r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r; return r; } #endif /* GL_VERSION_3_0 */ #ifdef GL_VERSION_3_1 static GLboolean _glewInit_GL_VERSION_3_1 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r; r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r; r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r; r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r; return r; } #endif /* GL_VERSION_3_1 */ #ifdef GL_VERSION_3_2 static GLboolean _glewInit_GL_VERSION_3_2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r; r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r; r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r; return r; } #endif /* GL_VERSION_3_2 */ #ifdef GL_VERSION_3_3 static GLboolean _glewInit_GL_VERSION_3_3 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r; return r; } #endif /* GL_VERSION_3_3 */ #ifdef GL_VERSION_4_0 static GLboolean _glewInit_GL_VERSION_4_0 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r; r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r; r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r; r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r; r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r; return r; } #endif /* GL_VERSION_4_0 */ #ifdef GL_VERSION_4_5 static GLboolean _glewInit_GL_VERSION_4_5 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatus")) == NULL) || r; r = ((glGetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImage")) == NULL) || r; r = ((glGetnTexImage = (PFNGLGETNTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImage")) == NULL) || r; r = ((glGetnUniformdv = (PFNGLGETNUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdv")) == NULL) || r; return r; } #endif /* GL_VERSION_4_5 */ #ifdef GL_3DFX_tbuffer static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r; return r; } #endif /* GL_3DFX_tbuffer */ #ifdef GL_AMD_debug_output static GLboolean _glewInit_GL_AMD_debug_output (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackAMD")) == NULL) || r; r = ((glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageEnableAMD")) == NULL) || r; r = ((glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertAMD")) == NULL) || r; r = ((glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogAMD")) == NULL) || r; return r; } #endif /* GL_AMD_debug_output */ #ifdef GL_AMD_draw_buffers_blend static GLboolean _glewInit_GL_AMD_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r; r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r; r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r; r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r; return r; } #endif /* GL_AMD_draw_buffers_blend */ #ifdef GL_AMD_interleaved_elements static GLboolean _glewInit_GL_AMD_interleaved_elements (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glVertexAttribParameteriAMD = (PFNGLVERTEXATTRIBPARAMETERIAMDPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribParameteriAMD")) == NULL) || r; return r; } #endif /* GL_AMD_interleaved_elements */ #ifdef GL_AMD_multi_draw_indirect static GLboolean _glewInit_GL_AMD_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectAMD")) == NULL) || r; r = ((glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectAMD")) == NULL) || r; return r; } #endif /* GL_AMD_multi_draw_indirect */ #ifdef GL_AMD_name_gen_delete static GLboolean _glewInit_GL_AMD_name_gen_delete (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamesAMD")) == NULL) || r; r = ((glGenNamesAMD = (PFNGLGENNAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glGenNamesAMD")) == NULL) || r; r = ((glIsNameAMD = (PFNGLISNAMEAMDPROC)glewGetProcAddress((const GLubyte*)"glIsNameAMD")) == NULL) || r; return r; } #endif /* GL_AMD_name_gen_delete */ #ifdef GL_AMD_occlusion_query_event static GLboolean _glewInit_GL_AMD_occlusion_query_event (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glQueryObjectParameteruiAMD = (PFNGLQUERYOBJECTPARAMETERUIAMDPROC)glewGetProcAddress((const GLubyte*)"glQueryObjectParameteruiAMD")) == NULL) || r; return r; } #endif /* GL_AMD_occlusion_query_event */ #ifdef GL_AMD_performance_monitor static GLboolean _glewInit_GL_AMD_performance_monitor (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r; r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r; r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r; r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r; r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r; r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r; r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r; r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r; r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r; r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r; r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r; return r; } #endif /* GL_AMD_performance_monitor */ #ifdef GL_AMD_sample_positions static GLboolean _glewInit_GL_AMD_sample_positions (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC)glewGetProcAddress((const GLubyte*)"glSetMultisamplefvAMD")) == NULL) || r; return r; } #endif /* GL_AMD_sample_positions */ #ifdef GL_AMD_sparse_texture static GLboolean _glewInit_GL_AMD_sparse_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexStorageSparseAMD = (PFNGLTEXSTORAGESPARSEAMDPROC)glewGetProcAddress((const GLubyte*)"glTexStorageSparseAMD")) == NULL) || r; r = ((glTextureStorageSparseAMD = (PFNGLTEXTURESTORAGESPARSEAMDPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageSparseAMD")) == NULL) || r; return r; } #endif /* GL_AMD_sparse_texture */ #ifdef GL_AMD_stencil_operation_extended static GLboolean _glewInit_GL_AMD_stencil_operation_extended (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glStencilOpValueAMD = (PFNGLSTENCILOPVALUEAMDPROC)glewGetProcAddress((const GLubyte*)"glStencilOpValueAMD")) == NULL) || r; return r; } #endif /* GL_AMD_stencil_operation_extended */ #ifdef GL_AMD_vertex_shader_tessellator static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r; r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r; return r; } #endif /* GL_AMD_vertex_shader_tessellator */ #ifdef GL_ANGLE_framebuffer_blit static GLboolean _glewInit_GL_ANGLE_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlitFramebufferANGLE = (PFNGLBLITFRAMEBUFFERANGLEPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferANGLE")) == NULL) || r; return r; } #endif /* GL_ANGLE_framebuffer_blit */ #ifdef GL_ANGLE_framebuffer_multisample static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glRenderbufferStorageMultisampleANGLE = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleANGLE")) == NULL) || r; return r; } #endif /* GL_ANGLE_framebuffer_multisample */ #ifdef GL_ANGLE_instanced_arrays static GLboolean _glewInit_GL_ANGLE_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawArraysInstancedANGLE = (PFNGLDRAWARRAYSINSTANCEDANGLEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedANGLE")) == NULL) || r; r = ((glDrawElementsInstancedANGLE = (PFNGLDRAWELEMENTSINSTANCEDANGLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedANGLE")) == NULL) || r; r = ((glVertexAttribDivisorANGLE = (PFNGLVERTEXATTRIBDIVISORANGLEPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorANGLE")) == NULL) || r; return r; } #endif /* GL_ANGLE_instanced_arrays */ #ifdef GL_ANGLE_timer_query static GLboolean _glewInit_GL_ANGLE_timer_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginQueryANGLE = (PFNGLBEGINQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryANGLE")) == NULL) || r; r = ((glDeleteQueriesANGLE = (PFNGLDELETEQUERIESANGLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesANGLE")) == NULL) || r; r = ((glEndQueryANGLE = (PFNGLENDQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glEndQueryANGLE")) == NULL) || r; r = ((glGenQueriesANGLE = (PFNGLGENQUERIESANGLEPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesANGLE")) == NULL) || r; r = ((glGetQueryObjecti64vANGLE = (PFNGLGETQUERYOBJECTI64VANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vANGLE")) == NULL) || r; r = ((glGetQueryObjectivANGLE = (PFNGLGETQUERYOBJECTIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivANGLE")) == NULL) || r; r = ((glGetQueryObjectui64vANGLE = (PFNGLGETQUERYOBJECTUI64VANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vANGLE")) == NULL) || r; r = ((glGetQueryObjectuivANGLE = (PFNGLGETQUERYOBJECTUIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivANGLE")) == NULL) || r; r = ((glGetQueryivANGLE = (PFNGLGETQUERYIVANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivANGLE")) == NULL) || r; r = ((glIsQueryANGLE = (PFNGLISQUERYANGLEPROC)glewGetProcAddress((const GLubyte*)"glIsQueryANGLE")) == NULL) || r; r = ((glQueryCounterANGLE = (PFNGLQUERYCOUNTERANGLEPROC)glewGetProcAddress((const GLubyte*)"glQueryCounterANGLE")) == NULL) || r; return r; } #endif /* GL_ANGLE_timer_query */ #ifdef GL_ANGLE_translated_shader_source static GLboolean _glewInit_GL_ANGLE_translated_shader_source (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetTranslatedShaderSourceANGLE = (PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC)glewGetProcAddress((const GLubyte*)"glGetTranslatedShaderSourceANGLE")) == NULL) || r; return r; } #endif /* GL_ANGLE_translated_shader_source */ #ifdef GL_APPLE_element_array static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r; r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r; r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r; r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r; r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_element_array */ #ifdef GL_APPLE_fence static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r; r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r; r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r; r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r; r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r; r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r; r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r; r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_fence */ #ifdef GL_APPLE_flush_buffer_range static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r; r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_flush_buffer_range */ #ifdef GL_APPLE_object_purgeable static GLboolean _glewInit_GL_APPLE_object_purgeable (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r; r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r; r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_object_purgeable */ #ifdef GL_APPLE_texture_range static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r; r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_texture_range */ #ifdef GL_APPLE_vertex_array_object static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r; r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r; r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r; r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_vertex_array_object */ #ifdef GL_APPLE_vertex_array_range static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r; r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r; r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_vertex_array_range */ #ifdef GL_APPLE_vertex_program_evaluators static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r; r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r; r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r; r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r; r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r; r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r; r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r; return r; } #endif /* GL_APPLE_vertex_program_evaluators */ #ifdef GL_ARB_ES2_compatibility static GLboolean _glewInit_GL_ARB_ES2_compatibility (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClearDepthf = (PFNGLCLEARDEPTHFPROC)glewGetProcAddress((const GLubyte*)"glClearDepthf")) == NULL) || r; r = ((glDepthRangef = (PFNGLDEPTHRANGEFPROC)glewGetProcAddress((const GLubyte*)"glDepthRangef")) == NULL) || r; r = ((glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glewGetProcAddress((const GLubyte*)"glGetShaderPrecisionFormat")) == NULL) || r; r = ((glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glewGetProcAddress((const GLubyte*)"glReleaseShaderCompiler")) == NULL) || r; r = ((glShaderBinary = (PFNGLSHADERBINARYPROC)glewGetProcAddress((const GLubyte*)"glShaderBinary")) == NULL) || r; return r; } #endif /* GL_ARB_ES2_compatibility */ #ifdef GL_ARB_ES3_1_compatibility static GLboolean _glewInit_GL_ARB_ES3_1_compatibility (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMemoryBarrierByRegion = (PFNGLMEMORYBARRIERBYREGIONPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierByRegion")) == NULL) || r; return r; } #endif /* GL_ARB_ES3_1_compatibility */ #ifdef GL_ARB_ES3_2_compatibility static GLboolean _glewInit_GL_ARB_ES3_2_compatibility (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPrimitiveBoundingBoxARB = (PFNGLPRIMITIVEBOUNDINGBOXARBPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveBoundingBoxARB")) == NULL) || r; return r; } #endif /* GL_ARB_ES3_2_compatibility */ #ifdef GL_ARB_base_instance static GLboolean _glewInit_GL_ARB_base_instance (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstance")) == NULL) || r; r = ((glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstance")) == NULL) || r; r = ((glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstance")) == NULL) || r; return r; } #endif /* GL_ARB_base_instance */ #ifdef GL_ARB_bindless_texture static GLboolean _glewInit_GL_ARB_bindless_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetImageHandleARB = (PFNGLGETIMAGEHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleARB")) == NULL) || r; r = ((glGetTextureHandleARB = (PFNGLGETTEXTUREHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleARB")) == NULL) || r; r = ((glGetTextureSamplerHandleARB = (PFNGLGETTEXTURESAMPLERHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleARB")) == NULL) || r; r = ((glGetVertexAttribLui64vARB = (PFNGLGETVERTEXATTRIBLUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vARB")) == NULL) || r; r = ((glIsImageHandleResidentARB = (PFNGLISIMAGEHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentARB")) == NULL) || r; r = ((glIsTextureHandleResidentARB = (PFNGLISTEXTUREHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentARB")) == NULL) || r; r = ((glMakeImageHandleNonResidentARB = (PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentARB")) == NULL) || r; r = ((glMakeImageHandleResidentARB = (PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentARB")) == NULL) || r; r = ((glMakeTextureHandleNonResidentARB = (PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentARB")) == NULL) || r; r = ((glMakeTextureHandleResidentARB = (PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentARB")) == NULL) || r; r = ((glProgramUniformHandleui64ARB = (PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64ARB")) == NULL) || r; r = ((glProgramUniformHandleui64vARB = (PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vARB")) == NULL) || r; r = ((glUniformHandleui64ARB = (PFNGLUNIFORMHANDLEUI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64ARB")) == NULL) || r; r = ((glUniformHandleui64vARB = (PFNGLUNIFORMHANDLEUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vARB")) == NULL) || r; r = ((glVertexAttribL1ui64ARB = (PFNGLVERTEXATTRIBL1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64ARB")) == NULL) || r; r = ((glVertexAttribL1ui64vARB = (PFNGLVERTEXATTRIBL1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vARB")) == NULL) || r; return r; } #endif /* GL_ARB_bindless_texture */ #ifdef GL_ARB_blend_func_extended static GLboolean _glewInit_GL_ARB_blend_func_extended (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r; r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r; return r; } #endif /* GL_ARB_blend_func_extended */ #ifdef GL_ARB_buffer_storage static GLboolean _glewInit_GL_ARB_buffer_storage (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBufferStorage = (PFNGLBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glBufferStorage")) == NULL) || r; r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r; return r; } #endif /* GL_ARB_buffer_storage */ #ifdef GL_ARB_cl_event static GLboolean _glewInit_GL_ARB_cl_event (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateSyncFromCLeventARB")) == NULL) || r; return r; } #endif /* GL_ARB_cl_event */ #ifdef GL_ARB_clear_buffer_object static GLboolean _glewInit_GL_ARB_clear_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferData")) == NULL) || r; r = ((glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glClearBufferSubData")) == NULL) || r; r = ((glClearNamedBufferDataEXT = (PFNGLCLEARNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferDataEXT")) == NULL) || r; r = ((glClearNamedBufferSubDataEXT = (PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferSubDataEXT")) == NULL) || r; return r; } #endif /* GL_ARB_clear_buffer_object */ #ifdef GL_ARB_clear_texture static GLboolean _glewInit_GL_ARB_clear_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClearTexImage = (PFNGLCLEARTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glClearTexImage")) == NULL) || r; r = ((glClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glClearTexSubImage")) == NULL) || r; return r; } #endif /* GL_ARB_clear_texture */ #ifdef GL_ARB_clip_control static GLboolean _glewInit_GL_ARB_clip_control (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClipControl = (PFNGLCLIPCONTROLPROC)glewGetProcAddress((const GLubyte*)"glClipControl")) == NULL) || r; return r; } #endif /* GL_ARB_clip_control */ #ifdef GL_ARB_color_buffer_float static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r; return r; } #endif /* GL_ARB_color_buffer_float */ #ifdef GL_ARB_compute_shader static GLboolean _glewInit_GL_ARB_compute_shader (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)glewGetProcAddress((const GLubyte*)"glDispatchCompute")) == NULL) || r; r = ((glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeIndirect")) == NULL) || r; return r; } #endif /* GL_ARB_compute_shader */ #ifdef GL_ARB_compute_variable_group_size static GLboolean _glewInit_GL_ARB_compute_variable_group_size (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDispatchComputeGroupSizeARB = (PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC)glewGetProcAddress((const GLubyte*)"glDispatchComputeGroupSizeARB")) == NULL) || r; return r; } #endif /* GL_ARB_compute_variable_group_size */ #ifdef GL_ARB_copy_buffer static GLboolean _glewInit_GL_ARB_copy_buffer (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r; return r; } #endif /* GL_ARB_copy_buffer */ #ifdef GL_ARB_copy_image static GLboolean _glewInit_GL_ARB_copy_image (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubData")) == NULL) || r; return r; } #endif /* GL_ARB_copy_image */ #ifdef GL_ARB_debug_output static GLboolean _glewInit_GL_ARB_debug_output (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackARB")) == NULL) || r; r = ((glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControlARB")) == NULL) || r; r = ((glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertARB")) == NULL) || r; r = ((glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogARB")) == NULL) || r; return r; } #endif /* GL_ARB_debug_output */ #ifdef GL_ARB_direct_state_access static GLboolean _glewInit_GL_ARB_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindTextureUnit = (PFNGLBINDTEXTUREUNITPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnit")) == NULL) || r; r = ((glBlitNamedFramebuffer = (PFNGLBLITNAMEDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitNamedFramebuffer")) == NULL) || r; r = ((glCheckNamedFramebufferStatus = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatus")) == NULL) || r; r = ((glClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferData")) == NULL) || r; r = ((glClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glClearNamedBufferSubData")) == NULL) || r; r = ((glClearNamedFramebufferfi = (PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferfi")) == NULL) || r; r = ((glClearNamedFramebufferfv = (PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferfv")) == NULL) || r; r = ((glClearNamedFramebufferiv = (PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferiv")) == NULL) || r; r = ((glClearNamedFramebufferuiv = (PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearNamedFramebufferuiv")) == NULL) || r; r = ((glCompressedTextureSubImage1D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1D")) == NULL) || r; r = ((glCompressedTextureSubImage2D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2D")) == NULL) || r; r = ((glCompressedTextureSubImage3D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3D")) == NULL) || r; r = ((glCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyNamedBufferSubData")) == NULL) || r; r = ((glCopyTextureSubImage1D = (PFNGLCOPYTEXTURESUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1D")) == NULL) || r; r = ((glCopyTextureSubImage2D = (PFNGLCOPYTEXTURESUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2D")) == NULL) || r; r = ((glCopyTextureSubImage3D = (PFNGLCOPYTEXTURESUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3D")) == NULL) || r; r = ((glCreateBuffers = (PFNGLCREATEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glCreateBuffers")) == NULL) || r; r = ((glCreateFramebuffers = (PFNGLCREATEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glCreateFramebuffers")) == NULL) || r; r = ((glCreateProgramPipelines = (PFNGLCREATEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramPipelines")) == NULL) || r; r = ((glCreateQueries = (PFNGLCREATEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glCreateQueries")) == NULL) || r; r = ((glCreateRenderbuffers = (PFNGLCREATERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glCreateRenderbuffers")) == NULL) || r; r = ((glCreateSamplers = (PFNGLCREATESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glCreateSamplers")) == NULL) || r; r = ((glCreateTextures = (PFNGLCREATETEXTURESPROC)glewGetProcAddress((const GLubyte*)"glCreateTextures")) == NULL) || r; r = ((glCreateTransformFeedbacks = (PFNGLCREATETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glCreateTransformFeedbacks")) == NULL) || r; r = ((glCreateVertexArrays = (PFNGLCREATEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glCreateVertexArrays")) == NULL) || r; r = ((glDisableVertexArrayAttrib = (PFNGLDISABLEVERTEXARRAYATTRIBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttrib")) == NULL) || r; r = ((glEnableVertexArrayAttrib = (PFNGLENABLEVERTEXARRAYATTRIBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttrib")) == NULL) || r; r = ((glFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRange")) == NULL) || r; r = ((glGenerateTextureMipmap = (PFNGLGENERATETEXTUREMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmap")) == NULL) || r; r = ((glGetCompressedTextureImage = (PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImage")) == NULL) || r; r = ((glGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameteri64v")) == NULL) || r; r = ((glGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameteriv")) == NULL) || r; r = ((glGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointerv")) == NULL) || r; r = ((glGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubData")) == NULL) || r; r = ((glGetNamedFramebufferAttachmentParameteriv = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameteriv")) == NULL) || r; r = ((glGetNamedFramebufferParameteriv = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameteriv")) == NULL) || r; r = ((glGetNamedRenderbufferParameteriv = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameteriv")) == NULL) || r; r = ((glGetQueryBufferObjecti64v = (PFNGLGETQUERYBUFFEROBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjecti64v")) == NULL) || r; r = ((glGetQueryBufferObjectiv = (PFNGLGETQUERYBUFFEROBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjectiv")) == NULL) || r; r = ((glGetQueryBufferObjectui64v = (PFNGLGETQUERYBUFFEROBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjectui64v")) == NULL) || r; r = ((glGetQueryBufferObjectuiv = (PFNGLGETQUERYBUFFEROBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryBufferObjectuiv")) == NULL) || r; r = ((glGetTextureImage = (PFNGLGETTEXTUREIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImage")) == NULL) || r; r = ((glGetTextureLevelParameterfv = (PFNGLGETTEXTURELEVELPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfv")) == NULL) || r; r = ((glGetTextureLevelParameteriv = (PFNGLGETTEXTURELEVELPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameteriv")) == NULL) || r; r = ((glGetTextureParameterIiv = (PFNGLGETTEXTUREPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIiv")) == NULL) || r; r = ((glGetTextureParameterIuiv = (PFNGLGETTEXTUREPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuiv")) == NULL) || r; r = ((glGetTextureParameterfv = (PFNGLGETTEXTUREPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfv")) == NULL) || r; r = ((glGetTextureParameteriv = (PFNGLGETTEXTUREPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameteriv")) == NULL) || r; r = ((glGetTransformFeedbacki64_v = (PFNGLGETTRANSFORMFEEDBACKI64_VPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbacki64_v")) == NULL) || r; r = ((glGetTransformFeedbacki_v = (PFNGLGETTRANSFORMFEEDBACKI_VPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbacki_v")) == NULL) || r; r = ((glGetTransformFeedbackiv = (PFNGLGETTRANSFORMFEEDBACKIVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackiv")) == NULL) || r; r = ((glGetVertexArrayIndexed64iv = (PFNGLGETVERTEXARRAYINDEXED64IVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIndexed64iv")) == NULL) || r; r = ((glGetVertexArrayIndexediv = (PFNGLGETVERTEXARRAYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIndexediv")) == NULL) || r; r = ((glGetVertexArrayiv = (PFNGLGETVERTEXARRAYIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayiv")) == NULL) || r; r = ((glInvalidateNamedFramebufferData = (PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateNamedFramebufferData")) == NULL) || r; r = ((glInvalidateNamedFramebufferSubData = (PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateNamedFramebufferSubData")) == NULL) || r; r = ((glMapNamedBuffer = (PFNGLMAPNAMEDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBuffer")) == NULL) || r; r = ((glMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRange")) == NULL) || r; r = ((glNamedBufferData = (PFNGLNAMEDBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferData")) == NULL) || r; r = ((glNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorage")) == NULL) || r; r = ((glNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubData")) == NULL) || r; r = ((glNamedFramebufferDrawBuffer = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferDrawBuffer")) == NULL) || r; r = ((glNamedFramebufferDrawBuffers = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferDrawBuffers")) == NULL) || r; r = ((glNamedFramebufferParameteri = (PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferParameteri")) == NULL) || r; r = ((glNamedFramebufferReadBuffer = (PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferReadBuffer")) == NULL) || r; r = ((glNamedFramebufferRenderbuffer = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbuffer")) == NULL) || r; r = ((glNamedFramebufferTexture = (PFNGLNAMEDFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture")) == NULL) || r; r = ((glNamedFramebufferTextureLayer = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayer")) == NULL) || r; r = ((glNamedRenderbufferStorage = (PFNGLNAMEDRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorage")) == NULL) || r; r = ((glNamedRenderbufferStorageMultisample = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisample")) == NULL) || r; r = ((glTextureBuffer = (PFNGLTEXTUREBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTextureBuffer")) == NULL) || r; r = ((glTextureBufferRange = (PFNGLTEXTUREBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferRange")) == NULL) || r; r = ((glTextureParameterIiv = (PFNGLTEXTUREPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIiv")) == NULL) || r; r = ((glTextureParameterIuiv = (PFNGLTEXTUREPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuiv")) == NULL) || r; r = ((glTextureParameterf = (PFNGLTEXTUREPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterf")) == NULL) || r; r = ((glTextureParameterfv = (PFNGLTEXTUREPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfv")) == NULL) || r; r = ((glTextureParameteri = (PFNGLTEXTUREPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteri")) == NULL) || r; r = ((glTextureParameteriv = (PFNGLTEXTUREPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriv")) == NULL) || r; r = ((glTextureStorage1D = (PFNGLTEXTURESTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1D")) == NULL) || r; r = ((glTextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2D")) == NULL) || r; r = ((glTextureStorage2DMultisample = (PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DMultisample")) == NULL) || r; r = ((glTextureStorage3D = (PFNGLTEXTURESTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3D")) == NULL) || r; r = ((glTextureStorage3DMultisample = (PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DMultisample")) == NULL) || r; r = ((glTextureSubImage1D = (PFNGLTEXTURESUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1D")) == NULL) || r; r = ((glTextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2D")) == NULL) || r; r = ((glTextureSubImage3D = (PFNGLTEXTURESUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3D")) == NULL) || r; r = ((glTransformFeedbackBufferBase = (PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackBufferBase")) == NULL) || r; r = ((glTransformFeedbackBufferRange = (PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackBufferRange")) == NULL) || r; r = ((glUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBuffer")) == NULL) || r; r = ((glVertexArrayAttribBinding = (PFNGLVERTEXARRAYATTRIBBINDINGPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribBinding")) == NULL) || r; r = ((glVertexArrayAttribFormat = (PFNGLVERTEXARRAYATTRIBFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribFormat")) == NULL) || r; r = ((glVertexArrayAttribIFormat = (PFNGLVERTEXARRAYATTRIBIFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribIFormat")) == NULL) || r; r = ((glVertexArrayAttribLFormat = (PFNGLVERTEXARRAYATTRIBLFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayAttribLFormat")) == NULL) || r; r = ((glVertexArrayBindingDivisor = (PFNGLVERTEXARRAYBINDINGDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayBindingDivisor")) == NULL) || r; r = ((glVertexArrayElementBuffer = (PFNGLVERTEXARRAYELEMENTBUFFERPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayElementBuffer")) == NULL) || r; r = ((glVertexArrayVertexBuffer = (PFNGLVERTEXARRAYVERTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexBuffer")) == NULL) || r; r = ((glVertexArrayVertexBuffers = (PFNGLVERTEXARRAYVERTEXBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexBuffers")) == NULL) || r; return r; } #endif /* GL_ARB_direct_state_access */ #ifdef GL_ARB_draw_buffers static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r; return r; } #endif /* GL_ARB_draw_buffers */ #ifdef GL_ARB_draw_buffers_blend static GLboolean _glewInit_GL_ARB_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r; r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r; r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r; r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r; return r; } #endif /* GL_ARB_draw_buffers_blend */ #ifdef GL_ARB_draw_elements_base_vertex static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r; r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r; r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r; r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r; return r; } #endif /* GL_ARB_draw_elements_base_vertex */ #ifdef GL_ARB_draw_indirect static GLboolean _glewInit_GL_ARB_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r; r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r; return r; } #endif /* GL_ARB_draw_indirect */ #ifdef GL_ARB_framebuffer_no_attachments static GLboolean _glewInit_GL_ARB_framebuffer_no_attachments (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glFramebufferParameteri")) == NULL) || r; r = ((glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameteriv")) == NULL) || r; r = ((glGetNamedFramebufferParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameterivEXT")) == NULL) || r; r = ((glNamedFramebufferParameteriEXT = (PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferParameteriEXT")) == NULL) || r; return r; } #endif /* GL_ARB_framebuffer_no_attachments */ #ifdef GL_ARB_framebuffer_object static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r; r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r; r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r; r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r; r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r; r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r; r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r; r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r; r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r; r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r; r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r; r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r; r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r; r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r; r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r; r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r; r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r; r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r; r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r; r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r; return r; } #endif /* GL_ARB_framebuffer_object */ #ifdef GL_ARB_geometry_shader4 static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r; r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r; r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r; r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r; return r; } #endif /* GL_ARB_geometry_shader4 */ #ifdef GL_ARB_get_program_binary static GLboolean _glewInit_GL_ARB_get_program_binary (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinary")) == NULL) || r; r = ((glProgramBinary = (PFNGLPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glProgramBinary")) == NULL) || r; r = ((glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteri")) == NULL) || r; return r; } #endif /* GL_ARB_get_program_binary */ #ifdef GL_ARB_get_texture_sub_image static GLboolean _glewInit_GL_ARB_get_texture_sub_image (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetCompressedTextureSubImage = (PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureSubImage")) == NULL) || r; r = ((glGetTextureSubImage = (PFNGLGETTEXTURESUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSubImage")) == NULL) || r; return r; } #endif /* GL_ARB_get_texture_sub_image */ #ifdef GL_ARB_gpu_shader_fp64 static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetUniformdv = (PFNGLGETUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformdv")) == NULL) || r; r = ((glUniform1d = (PFNGLUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glUniform1d")) == NULL) || r; r = ((glUniform1dv = (PFNGLUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glUniform1dv")) == NULL) || r; r = ((glUniform2d = (PFNGLUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glUniform2d")) == NULL) || r; r = ((glUniform2dv = (PFNGLUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glUniform2dv")) == NULL) || r; r = ((glUniform3d = (PFNGLUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glUniform3d")) == NULL) || r; r = ((glUniform3dv = (PFNGLUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glUniform3dv")) == NULL) || r; r = ((glUniform4d = (PFNGLUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glUniform4d")) == NULL) || r; r = ((glUniform4dv = (PFNGLUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glUniform4dv")) == NULL) || r; r = ((glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2dv")) == NULL) || r; r = ((glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3dv")) == NULL) || r; r = ((glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4dv")) == NULL) || r; r = ((glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3dv")) == NULL) || r; r = ((glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2dv")) == NULL) || r; r = ((glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4dv")) == NULL) || r; r = ((glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4dv")) == NULL) || r; r = ((glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2dv")) == NULL) || r; r = ((glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3dv")) == NULL) || r; return r; } #endif /* GL_ARB_gpu_shader_fp64 */ #ifdef GL_ARB_gpu_shader_int64 static GLboolean _glewInit_GL_ARB_gpu_shader_int64 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetUniformi64vARB = (PFNGLGETUNIFORMI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vARB")) == NULL) || r; r = ((glGetUniformui64vARB = (PFNGLGETUNIFORMUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vARB")) == NULL) || r; r = ((glGetnUniformi64vARB = (PFNGLGETNUNIFORMI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformi64vARB")) == NULL) || r; r = ((glGetnUniformui64vARB = (PFNGLGETNUNIFORMUI64VARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformui64vARB")) == NULL) || r; r = ((glProgramUniform1i64ARB = (PFNGLPROGRAMUNIFORM1I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64ARB")) == NULL) || r; r = ((glProgramUniform1i64vARB = (PFNGLPROGRAMUNIFORM1I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vARB")) == NULL) || r; r = ((glProgramUniform1ui64ARB = (PFNGLPROGRAMUNIFORM1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64ARB")) == NULL) || r; r = ((glProgramUniform1ui64vARB = (PFNGLPROGRAMUNIFORM1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vARB")) == NULL) || r; r = ((glProgramUniform2i64ARB = (PFNGLPROGRAMUNIFORM2I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64ARB")) == NULL) || r; r = ((glProgramUniform2i64vARB = (PFNGLPROGRAMUNIFORM2I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vARB")) == NULL) || r; r = ((glProgramUniform2ui64ARB = (PFNGLPROGRAMUNIFORM2UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64ARB")) == NULL) || r; r = ((glProgramUniform2ui64vARB = (PFNGLPROGRAMUNIFORM2UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vARB")) == NULL) || r; r = ((glProgramUniform3i64ARB = (PFNGLPROGRAMUNIFORM3I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64ARB")) == NULL) || r; r = ((glProgramUniform3i64vARB = (PFNGLPROGRAMUNIFORM3I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vARB")) == NULL) || r; r = ((glProgramUniform3ui64ARB = (PFNGLPROGRAMUNIFORM3UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64ARB")) == NULL) || r; r = ((glProgramUniform3ui64vARB = (PFNGLPROGRAMUNIFORM3UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vARB")) == NULL) || r; r = ((glProgramUniform4i64ARB = (PFNGLPROGRAMUNIFORM4I64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64ARB")) == NULL) || r; r = ((glProgramUniform4i64vARB = (PFNGLPROGRAMUNIFORM4I64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vARB")) == NULL) || r; r = ((glProgramUniform4ui64ARB = (PFNGLPROGRAMUNIFORM4UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64ARB")) == NULL) || r; r = ((glProgramUniform4ui64vARB = (PFNGLPROGRAMUNIFORM4UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vARB")) == NULL) || r; r = ((glUniform1i64ARB = (PFNGLUNIFORM1I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64ARB")) == NULL) || r; r = ((glUniform1i64vARB = (PFNGLUNIFORM1I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vARB")) == NULL) || r; r = ((glUniform1ui64ARB = (PFNGLUNIFORM1UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64ARB")) == NULL) || r; r = ((glUniform1ui64vARB = (PFNGLUNIFORM1UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vARB")) == NULL) || r; r = ((glUniform2i64ARB = (PFNGLUNIFORM2I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64ARB")) == NULL) || r; r = ((glUniform2i64vARB = (PFNGLUNIFORM2I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vARB")) == NULL) || r; r = ((glUniform2ui64ARB = (PFNGLUNIFORM2UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64ARB")) == NULL) || r; r = ((glUniform2ui64vARB = (PFNGLUNIFORM2UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vARB")) == NULL) || r; r = ((glUniform3i64ARB = (PFNGLUNIFORM3I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64ARB")) == NULL) || r; r = ((glUniform3i64vARB = (PFNGLUNIFORM3I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vARB")) == NULL) || r; r = ((glUniform3ui64ARB = (PFNGLUNIFORM3UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64ARB")) == NULL) || r; r = ((glUniform3ui64vARB = (PFNGLUNIFORM3UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vARB")) == NULL) || r; r = ((glUniform4i64ARB = (PFNGLUNIFORM4I64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64ARB")) == NULL) || r; r = ((glUniform4i64vARB = (PFNGLUNIFORM4I64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vARB")) == NULL) || r; r = ((glUniform4ui64ARB = (PFNGLUNIFORM4UI64ARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64ARB")) == NULL) || r; r = ((glUniform4ui64vARB = (PFNGLUNIFORM4UI64VARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vARB")) == NULL) || r; return r; } #endif /* GL_ARB_gpu_shader_int64 */ #ifdef GL_ARB_imaging static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r; r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r; r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r; r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r; r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r; r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r; r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r; r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r; r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r; r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r; r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r; r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r; r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r; r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r; r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r; r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r; r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r; r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r; r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r; r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r; r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r; r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r; r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r; r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r; r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r; r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r; r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r; r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r; r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r; r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r; r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r; r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r; return r; } #endif /* GL_ARB_imaging */ #ifdef GL_ARB_indirect_parameters static GLboolean _glewInit_GL_ARB_indirect_parameters (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiDrawArraysIndirectCountARB = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectCountARB")) == NULL) || r; r = ((glMultiDrawElementsIndirectCountARB = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectCountARB")) == NULL) || r; return r; } #endif /* GL_ARB_indirect_parameters */ #ifdef GL_ARB_instanced_arrays static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r; r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r; r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r; return r; } #endif /* GL_ARB_instanced_arrays */ #ifdef GL_ARB_internalformat_query static GLboolean _glewInit_GL_ARB_internalformat_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformativ")) == NULL) || r; return r; } #endif /* GL_ARB_internalformat_query */ #ifdef GL_ARB_internalformat_query2 static GLboolean _glewInit_GL_ARB_internalformat_query2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformati64v")) == NULL) || r; return r; } #endif /* GL_ARB_internalformat_query2 */ #ifdef GL_ARB_invalidate_subdata static GLboolean _glewInit_GL_ARB_invalidate_subdata (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferData")) == NULL) || r; r = ((glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glInvalidateBufferSubData")) == NULL) || r; r = ((glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateFramebuffer")) == NULL) || r; r = ((glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glInvalidateSubFramebuffer")) == NULL) || r; r = ((glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexImage")) == NULL) || r; r = ((glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)glewGetProcAddress((const GLubyte*)"glInvalidateTexSubImage")) == NULL) || r; return r; } #endif /* GL_ARB_invalidate_subdata */ #ifdef GL_ARB_map_buffer_range static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r; r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r; return r; } #endif /* GL_ARB_map_buffer_range */ #ifdef GL_ARB_matrix_palette static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r; r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r; r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r; r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r; r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r; return r; } #endif /* GL_ARB_matrix_palette */ #ifdef GL_ARB_multi_bind static GLboolean _glewInit_GL_ARB_multi_bind (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBuffersBase")) == NULL) || r; r = ((glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBuffersRange")) == NULL) || r; r = ((glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextures")) == NULL) || r; r = ((glBindSamplers = (PFNGLBINDSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glBindSamplers")) == NULL) || r; r = ((glBindTextures = (PFNGLBINDTEXTURESPROC)glewGetProcAddress((const GLubyte*)"glBindTextures")) == NULL) || r; r = ((glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffers")) == NULL) || r; return r; } #endif /* GL_ARB_multi_bind */ #ifdef GL_ARB_multi_draw_indirect static GLboolean _glewInit_GL_ARB_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirect")) == NULL) || r; r = ((glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirect")) == NULL) || r; return r; } #endif /* GL_ARB_multi_draw_indirect */ #ifdef GL_ARB_multisample static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r; return r; } #endif /* GL_ARB_multisample */ #ifdef GL_ARB_multitexture static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r; r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r; r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r; r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r; r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r; r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r; r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r; r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r; r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r; r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r; r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r; r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r; r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r; r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r; r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r; r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r; r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r; r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r; r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r; r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r; r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r; r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r; r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r; r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r; r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r; r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r; r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r; r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r; r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r; r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r; r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r; r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r; r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r; r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r; return r; } #endif /* GL_ARB_multitexture */ #ifdef GL_ARB_occlusion_query static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r; r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r; r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r; r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r; r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r; r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r; r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r; r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r; return r; } #endif /* GL_ARB_occlusion_query */ #ifdef GL_ARB_parallel_shader_compile static GLboolean _glewInit_GL_ARB_parallel_shader_compile (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMaxShaderCompilerThreadsARB = (PFNGLMAXSHADERCOMPILERTHREADSARBPROC)glewGetProcAddress((const GLubyte*)"glMaxShaderCompilerThreadsARB")) == NULL) || r; return r; } #endif /* GL_ARB_parallel_shader_compile */ #ifdef GL_ARB_point_parameters static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r; r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r; return r; } #endif /* GL_ARB_point_parameters */ #ifdef GL_ARB_program_interface_query static GLboolean _glewInit_GL_ARB_program_interface_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInterfaceiv")) == NULL) || r; r = ((glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceIndex")) == NULL) || r; r = ((glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocation")) == NULL) || r; r = ((glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocationIndex")) == NULL) || r; r = ((glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceName")) == NULL) || r; r = ((glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceiv")) == NULL) || r; return r; } #endif /* GL_ARB_program_interface_query */ #ifdef GL_ARB_provoking_vertex static GLboolean _glewInit_GL_ARB_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r; return r; } #endif /* GL_ARB_provoking_vertex */ #ifdef GL_ARB_robustness static GLboolean _glewInit_GL_ARB_robustness (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusARB")) == NULL) || r; r = ((glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnColorTableARB")) == NULL) || r; r = ((glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImageARB")) == NULL) || r; r = ((glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnConvolutionFilterARB")) == NULL) || r; r = ((glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glGetnHistogramARB")) == NULL) || r; r = ((glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapdvARB")) == NULL) || r; r = ((glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapfvARB")) == NULL) || r; r = ((glGetnMapivARB = (PFNGLGETNMAPIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapivARB")) == NULL) || r; r = ((glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMinmaxARB")) == NULL) || r; r = ((glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapfvARB")) == NULL) || r; r = ((glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapuivARB")) == NULL) || r; r = ((glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapusvARB")) == NULL) || r; r = ((glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPolygonStippleARB")) == NULL) || r; r = ((glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnSeparableFilterARB")) == NULL) || r; r = ((glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImageARB")) == NULL) || r; r = ((glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdvARB")) == NULL) || r; r = ((glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvARB")) == NULL) || r; r = ((glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivARB")) == NULL) || r; r = ((glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuivARB")) == NULL) || r; r = ((glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsARB")) == NULL) || r; return r; } #endif /* GL_ARB_robustness */ #ifdef GL_ARB_sample_locations static GLboolean _glewInit_GL_ARB_sample_locations (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferSampleLocationsfvARB = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvARB")) == NULL) || r; r = ((glNamedFramebufferSampleLocationsfvARB = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvARB")) == NULL) || r; return r; } #endif /* GL_ARB_sample_locations */ #ifdef GL_ARB_sample_shading static GLboolean _glewInit_GL_ARB_sample_shading (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r; return r; } #endif /* GL_ARB_sample_shading */ #ifdef GL_ARB_sampler_objects static GLboolean _glewInit_GL_ARB_sampler_objects (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r; r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r; r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r; r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r; r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r; r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r; r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r; r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r; r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r; r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r; r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r; r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r; r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r; r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r; return r; } #endif /* GL_ARB_sampler_objects */ #ifdef GL_ARB_separate_shader_objects static GLboolean _glewInit_GL_ARB_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glActiveShaderProgram")) == NULL) || r; r = ((glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glBindProgramPipeline")) == NULL) || r; r = ((glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramv")) == NULL) || r; r = ((glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramPipelines")) == NULL) || r; r = ((glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glGenProgramPipelines")) == NULL) || r; r = ((glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineInfoLog")) == NULL) || r; r = ((glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineiv")) == NULL) || r; r = ((glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glIsProgramPipeline")) == NULL) || r; r = ((glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1d")) == NULL) || r; r = ((glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dv")) == NULL) || r; r = ((glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1f")) == NULL) || r; r = ((glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fv")) == NULL) || r; r = ((glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i")) == NULL) || r; r = ((glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iv")) == NULL) || r; r = ((glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui")) == NULL) || r; r = ((glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiv")) == NULL) || r; r = ((glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2d")) == NULL) || r; r = ((glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dv")) == NULL) || r; r = ((glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2f")) == NULL) || r; r = ((glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fv")) == NULL) || r; r = ((glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i")) == NULL) || r; r = ((glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iv")) == NULL) || r; r = ((glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui")) == NULL) || r; r = ((glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiv")) == NULL) || r; r = ((glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3d")) == NULL) || r; r = ((glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dv")) == NULL) || r; r = ((glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3f")) == NULL) || r; r = ((glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fv")) == NULL) || r; r = ((glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i")) == NULL) || r; r = ((glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iv")) == NULL) || r; r = ((glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui")) == NULL) || r; r = ((glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiv")) == NULL) || r; r = ((glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4d")) == NULL) || r; r = ((glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dv")) == NULL) || r; r = ((glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4f")) == NULL) || r; r = ((glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fv")) == NULL) || r; r = ((glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i")) == NULL) || r; r = ((glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iv")) == NULL) || r; r = ((glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui")) == NULL) || r; r = ((glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiv")) == NULL) || r; r = ((glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dv")) == NULL) || r; r = ((glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fv")) == NULL) || r; r = ((glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dv")) == NULL) || r; r = ((glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fv")) == NULL) || r; r = ((glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dv")) == NULL) || r; r = ((glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fv")) == NULL) || r; r = ((glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dv")) == NULL) || r; r = ((glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fv")) == NULL) || r; r = ((glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dv")) == NULL) || r; r = ((glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fv")) == NULL) || r; r = ((glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dv")) == NULL) || r; r = ((glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fv")) == NULL) || r; r = ((glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dv")) == NULL) || r; r = ((glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fv")) == NULL) || r; r = ((glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dv")) == NULL) || r; r = ((glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fv")) == NULL) || r; r = ((glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dv")) == NULL) || r; r = ((glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fv")) == NULL) || r; r = ((glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glewGetProcAddress((const GLubyte*)"glUseProgramStages")) == NULL) || r; r = ((glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramPipeline")) == NULL) || r; return r; } #endif /* GL_ARB_separate_shader_objects */ #ifdef GL_ARB_shader_atomic_counters static GLboolean _glewInit_GL_ARB_shader_atomic_counters (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAtomicCounterBufferiv")) == NULL) || r; return r; } #endif /* GL_ARB_shader_atomic_counters */ #ifdef GL_ARB_shader_image_load_store static GLboolean _glewInit_GL_ARB_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glBindImageTexture")) == NULL) || r; r = ((glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrier")) == NULL) || r; return r; } #endif /* GL_ARB_shader_image_load_store */ #ifdef GL_ARB_shader_objects static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r; r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r; r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r; r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r; r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r; r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r; r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r; r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r; r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r; r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r; r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r; r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r; r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r; r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r; r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r; r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r; r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r; r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r; r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r; r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r; r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r; r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r; r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r; r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r; r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r; r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r; r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r; r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r; r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r; r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r; r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r; r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r; r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r; r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r; r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r; r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r; r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r; r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r; r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r; return r; } #endif /* GL_ARB_shader_objects */ #ifdef GL_ARB_shader_storage_buffer_object static GLboolean _glewInit_GL_ARB_shader_storage_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glShaderStorageBlockBinding")) == NULL) || r; return r; } #endif /* GL_ARB_shader_storage_buffer_object */ #ifdef GL_ARB_shader_subroutine static GLboolean _glewInit_GL_ARB_shader_subroutine (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r; r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r; r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r; r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r; r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r; r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r; r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r; r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r; return r; } #endif /* GL_ARB_shader_subroutine */ #ifdef GL_ARB_shading_language_include static GLboolean _glewInit_GL_ARB_shading_language_include (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r; r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r; r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r; r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r; r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r; r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r; return r; } #endif /* GL_ARB_shading_language_include */ #ifdef GL_ARB_sparse_buffer static GLboolean _glewInit_GL_ARB_sparse_buffer (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBufferPageCommitmentARB = (PFNGLBUFFERPAGECOMMITMENTARBPROC)glewGetProcAddress((const GLubyte*)"glBufferPageCommitmentARB")) == NULL) || r; return r; } #endif /* GL_ARB_sparse_buffer */ #ifdef GL_ARB_sparse_texture static GLboolean _glewInit_GL_ARB_sparse_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexPageCommitmentARB = (PFNGLTEXPAGECOMMITMENTARBPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentARB")) == NULL) || r; r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r; return r; } #endif /* GL_ARB_sparse_texture */ #ifdef GL_ARB_sync static GLboolean _glewInit_GL_ARB_sync (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r; r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r; r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r; r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r; r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r; r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r; r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r; return r; } #endif /* GL_ARB_sync */ #ifdef GL_ARB_tessellation_shader static GLboolean _glewInit_GL_ARB_tessellation_shader (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r; r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r; return r; } #endif /* GL_ARB_tessellation_shader */ #ifdef GL_ARB_texture_barrier static GLboolean _glewInit_GL_ARB_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTextureBarrier = (PFNGLTEXTUREBARRIERPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrier")) == NULL) || r; return r; } #endif /* GL_ARB_texture_barrier */ #ifdef GL_ARB_texture_buffer_object static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r; return r; } #endif /* GL_ARB_texture_buffer_object */ #ifdef GL_ARB_texture_buffer_range static GLboolean _glewInit_GL_ARB_texture_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glTexBufferRange")) == NULL) || r; r = ((glTextureBufferRangeEXT = (PFNGLTEXTUREBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferRangeEXT")) == NULL) || r; return r; } #endif /* GL_ARB_texture_buffer_range */ #ifdef GL_ARB_texture_compression static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r; r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r; r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r; r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r; r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r; r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r; r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r; return r; } #endif /* GL_ARB_texture_compression */ #ifdef GL_ARB_texture_multisample static GLboolean _glewInit_GL_ARB_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r; r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r; r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r; r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r; return r; } #endif /* GL_ARB_texture_multisample */ #ifdef GL_ARB_texture_storage static GLboolean _glewInit_GL_ARB_texture_storage (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r; r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r; r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r; r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r; r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r; r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r; return r; } #endif /* GL_ARB_texture_storage */ #ifdef GL_ARB_texture_storage_multisample static GLboolean _glewInit_GL_ARB_texture_storage_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2DMultisample")) == NULL) || r; r = ((glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DMultisample")) == NULL) || r; r = ((glTextureStorage2DMultisampleEXT = (PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DMultisampleEXT")) == NULL) || r; r = ((glTextureStorage3DMultisampleEXT = (PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DMultisampleEXT")) == NULL) || r; return r; } #endif /* GL_ARB_texture_storage_multisample */ #ifdef GL_ARB_texture_view static GLboolean _glewInit_GL_ARB_texture_view (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTextureView = (PFNGLTEXTUREVIEWPROC)glewGetProcAddress((const GLubyte*)"glTextureView")) == NULL) || r; return r; } #endif /* GL_ARB_texture_view */ #ifdef GL_ARB_timer_query static GLboolean _glewInit_GL_ARB_timer_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r; r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r; r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r; return r; } #endif /* GL_ARB_timer_query */ #ifdef GL_ARB_transform_feedback2 static GLboolean _glewInit_GL_ARB_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r; r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r; r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r; r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r; r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r; r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r; r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r; return r; } #endif /* GL_ARB_transform_feedback2 */ #ifdef GL_ARB_transform_feedback3 static GLboolean _glewInit_GL_ARB_transform_feedback3 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r; r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r; r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r; r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r; return r; } #endif /* GL_ARB_transform_feedback3 */ #ifdef GL_ARB_transform_feedback_instanced static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstanced")) == NULL) || r; r = ((glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStreamInstanced")) == NULL) || r; return r; } #endif /* GL_ARB_transform_feedback_instanced */ #ifdef GL_ARB_transpose_matrix static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r; r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r; r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r; r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r; return r; } #endif /* GL_ARB_transpose_matrix */ #ifdef GL_ARB_uniform_buffer_object static GLboolean _glewInit_GL_ARB_uniform_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r; r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r; r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r; r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r; r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r; r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r; r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r; r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r; r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r; r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r; return r; } #endif /* GL_ARB_uniform_buffer_object */ #ifdef GL_ARB_vertex_array_object static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r; r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r; r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r; r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_array_object */ #ifdef GL_ARB_vertex_attrib_64bit static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdv")) == NULL) || r; r = ((glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1d")) == NULL) || r; r = ((glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dv")) == NULL) || r; r = ((glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2d")) == NULL) || r; r = ((glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dv")) == NULL) || r; r = ((glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3d")) == NULL) || r; r = ((glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dv")) == NULL) || r; r = ((glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4d")) == NULL) || r; r = ((glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dv")) == NULL) || r; r = ((glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointer")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_attrib_64bit */ #ifdef GL_ARB_vertex_attrib_binding static GLboolean _glewInit_GL_ARB_vertex_attrib_binding (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindVertexBuffer")) == NULL) || r; r = ((glVertexArrayBindVertexBufferEXT = (PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayBindVertexBufferEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribBindingEXT = (PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribBindingEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribFormatEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribIFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIFormatEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribLFormatEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLFormatEXT")) == NULL) || r; r = ((glVertexArrayVertexBindingDivisorEXT = (PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexBindingDivisorEXT")) == NULL) || r; r = ((glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribBinding")) == NULL) || r; r = ((glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormat")) == NULL) || r; r = ((glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormat")) == NULL) || r; r = ((glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormat")) == NULL) || r; r = ((glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexBindingDivisor")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_attrib_binding */ #ifdef GL_ARB_vertex_blend static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r; r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r; r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r; r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r; r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r; r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r; r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r; r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r; r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r; r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_blend */ #ifdef GL_ARB_vertex_buffer_object static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r; r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r; r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r; r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r; r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r; r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r; r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r; r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r; r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r; r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r; r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_buffer_object */ #ifdef GL_ARB_vertex_program static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r; r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r; r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r; r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r; r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r; r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r; r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r; r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r; r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r; r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r; r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r; r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r; r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r; r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r; r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r; r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r; r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r; r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r; r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r; r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r; r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r; r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r; r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r; r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r; r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r; r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r; r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r; r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r; r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r; r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r; r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r; r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r; r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r; r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r; r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r; r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r; r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r; r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r; r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r; r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r; r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r; r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r; r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r; r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r; r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r; r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r; r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r; r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r; r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r; r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r; r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r; r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r; r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r; r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r; r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r; r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r; r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r; r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r; r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r; r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r; r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r; r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_program */ #ifdef GL_ARB_vertex_shader static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r; r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r; r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_shader */ #ifdef GL_ARB_vertex_type_2_10_10_10_rev static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r; r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r; r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r; r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r; r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r; r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r; r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r; r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r; r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r; r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r; r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r; r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r; r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r; r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r; r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r; r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r; r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r; r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r; r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r; r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r; r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r; r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r; r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r; r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r; r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r; r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r; r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r; r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r; r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r; r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r; r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r; r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r; r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r; r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r; r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r; r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r; r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r; r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r; return r; } #endif /* GL_ARB_vertex_type_2_10_10_10_rev */ #ifdef GL_ARB_viewport_array static GLboolean _glewInit_GL_ARB_viewport_array (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayv")) == NULL) || r; r = ((glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexed")) == NULL) || r; r = ((glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_v")) == NULL) || r; r = ((glGetFloati_v = (PFNGLGETFLOATI_VPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_v")) == NULL) || r; r = ((glScissorArrayv = (PFNGLSCISSORARRAYVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayv")) == NULL) || r; r = ((glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexed")) == NULL) || r; r = ((glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedv")) == NULL) || r; r = ((glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayv")) == NULL) || r; r = ((glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedf")) == NULL) || r; r = ((glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfv")) == NULL) || r; return r; } #endif /* GL_ARB_viewport_array */ #ifdef GL_ARB_window_pos static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r; r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r; r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r; r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r; r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r; r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r; r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r; r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r; r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r; r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r; r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r; r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r; r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r; r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r; r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r; r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r; return r; } #endif /* GL_ARB_window_pos */ #ifdef GL_ATI_draw_buffers static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r; return r; } #endif /* GL_ATI_draw_buffers */ #ifdef GL_ATI_element_array static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r; r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r; r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r; return r; } #endif /* GL_ATI_element_array */ #ifdef GL_ATI_envmap_bumpmap static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r; r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r; r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r; r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r; return r; } #endif /* GL_ATI_envmap_bumpmap */ #ifdef GL_ATI_fragment_shader static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r; r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r; r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r; r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r; r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r; r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r; r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r; r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r; r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r; r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r; r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r; r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r; r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r; r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r; return r; } #endif /* GL_ATI_fragment_shader */ #ifdef GL_ATI_map_object_buffer static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r; r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r; return r; } #endif /* GL_ATI_map_object_buffer */ #ifdef GL_ATI_pn_triangles static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r; r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r; return r; } #endif /* GL_ATI_pn_triangles */ #ifdef GL_ATI_separate_stencil static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r; r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r; return r; } #endif /* GL_ATI_separate_stencil */ #ifdef GL_ATI_vertex_array_object static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r; r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r; r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r; r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r; r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r; r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r; r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r; r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r; r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r; r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r; r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r; r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r; return r; } #endif /* GL_ATI_vertex_array_object */ #ifdef GL_ATI_vertex_attrib_array_object static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r; r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r; r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r; return r; } #endif /* GL_ATI_vertex_attrib_array_object */ #ifdef GL_ATI_vertex_streams static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r; r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r; r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r; r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r; r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r; r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r; r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r; r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r; r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r; r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r; r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r; r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r; r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r; r = ((glVertexStream1dATI = (PFNGLVERTEXSTREAM1DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dATI")) == NULL) || r; r = ((glVertexStream1dvATI = (PFNGLVERTEXSTREAM1DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1dvATI")) == NULL) || r; r = ((glVertexStream1fATI = (PFNGLVERTEXSTREAM1FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fATI")) == NULL) || r; r = ((glVertexStream1fvATI = (PFNGLVERTEXSTREAM1FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1fvATI")) == NULL) || r; r = ((glVertexStream1iATI = (PFNGLVERTEXSTREAM1IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1iATI")) == NULL) || r; r = ((glVertexStream1ivATI = (PFNGLVERTEXSTREAM1IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1ivATI")) == NULL) || r; r = ((glVertexStream1sATI = (PFNGLVERTEXSTREAM1SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1sATI")) == NULL) || r; r = ((glVertexStream1svATI = (PFNGLVERTEXSTREAM1SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream1svATI")) == NULL) || r; r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r; r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r; r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r; r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r; r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r; r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r; r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r; r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r; r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r; r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r; r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r; r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r; r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r; r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r; r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r; r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r; r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r; r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r; r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r; r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r; r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r; r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r; r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r; r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r; return r; } #endif /* GL_ATI_vertex_streams */ #ifdef GL_EXT_bindable_uniform static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r; r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r; r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r; return r; } #endif /* GL_EXT_bindable_uniform */ #ifdef GL_EXT_blend_color static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r; return r; } #endif /* GL_EXT_blend_color */ #ifdef GL_EXT_blend_equation_separate static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r; return r; } #endif /* GL_EXT_blend_equation_separate */ #ifdef GL_EXT_blend_func_separate static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r; return r; } #endif /* GL_EXT_blend_func_separate */ #ifdef GL_EXT_blend_minmax static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r; return r; } #endif /* GL_EXT_blend_minmax */ #ifdef GL_EXT_color_subtable static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r; r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r; return r; } #endif /* GL_EXT_color_subtable */ #ifdef GL_EXT_compiled_vertex_array static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r; r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r; return r; } #endif /* GL_EXT_compiled_vertex_array */ #ifdef GL_EXT_convolution static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r; r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r; r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r; r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r; r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r; r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r; r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r; r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r; r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r; r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r; r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r; r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r; r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r; return r; } #endif /* GL_EXT_convolution */ #ifdef GL_EXT_coordinate_frame static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r; r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_coordinate_frame */ #ifdef GL_EXT_copy_texture static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r; r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r; r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r; r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r; r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r; return r; } #endif /* GL_EXT_copy_texture */ #ifdef GL_EXT_cull_vertex static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r; r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r; return r; } #endif /* GL_EXT_cull_vertex */ #ifdef GL_EXT_debug_label static GLboolean _glewInit_GL_EXT_debug_label (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetObjectLabelEXT = (PFNGLGETOBJECTLABELEXTPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabelEXT")) == NULL) || r; r = ((glLabelObjectEXT = (PFNGLLABELOBJECTEXTPROC)glewGetProcAddress((const GLubyte*)"glLabelObjectEXT")) == NULL) || r; return r; } #endif /* GL_EXT_debug_label */ #ifdef GL_EXT_debug_marker static GLboolean _glewInit_GL_EXT_debug_marker (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glInsertEventMarkerEXT = (PFNGLINSERTEVENTMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glInsertEventMarkerEXT")) == NULL) || r; r = ((glPopGroupMarkerEXT = (PFNGLPOPGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPopGroupMarkerEXT")) == NULL) || r; r = ((glPushGroupMarkerEXT = (PFNGLPUSHGROUPMARKEREXTPROC)glewGetProcAddress((const GLubyte*)"glPushGroupMarkerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_debug_marker */ #ifdef GL_EXT_depth_bounds_test static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r; return r; } #endif /* GL_EXT_depth_bounds_test */ #ifdef GL_EXT_direct_state_access static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r; r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r; r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r; r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r; r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r; r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r; r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r; r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r; r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r; r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r; r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r; r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r; r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r; r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r; r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r; r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r; r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r; r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r; r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r; r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r; r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r; r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r; r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r; r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r; r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r; r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r; r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r; r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r; r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r; r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r; r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r; r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r; r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r; r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r; r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r; r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r; r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r; r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r; r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r; r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r; r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r; r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r; r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r; r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r; r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r; r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r; r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r; r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r; r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r; r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r; r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r; r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r; r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r; r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r; r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r; r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r; r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r; r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r; r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r; r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r; r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r; r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r; r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r; r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r; r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r; r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r; r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r; r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r; r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r; r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r; r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r; r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r; r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r; r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r; r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r; r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r; r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r; r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r; r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r; r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r; r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r; r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r; r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r; r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r; r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r; r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r; r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r; r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r; r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r; r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r; r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r; r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r; r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r; r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r; r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r; r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r; r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r; r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r; r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r; r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r; r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r; r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r; r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r; r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r; r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r; r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r; r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r; r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r; r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r; r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r; r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r; r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r; r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r; r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r; r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r; r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r; r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r; r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r; r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r; r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r; r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r; r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r; r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r; r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r; r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r; r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r; r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r; r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r; r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r; r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r; r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r; r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r; r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r; r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r; r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r; r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r; r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r; r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r; r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r; r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r; r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r; r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r; r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r; r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r; r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r; r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r; r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r; r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r; r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r; r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r; r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r; r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r; r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r; r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r; r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r; r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r; r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r; r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r; r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r; r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r; r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r; r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r; r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r; r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r; r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r; r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r; r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r; r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r; r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r; r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r; r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r; r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r; r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r; r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r; r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r; r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r; r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r; r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r; r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r; r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r; r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r; r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r; r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r; r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r; r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r; r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r; r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r; r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r; r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r; r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r; r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r; r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r; r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r; r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r; r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r; r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r; r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r; r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r; r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r; r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r; r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r; r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r; r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribDivisorEXT = (PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribDivisorEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r; r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r; return r; } #endif /* GL_EXT_direct_state_access */ #ifdef GL_EXT_draw_buffers2 static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r; r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r; r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r; r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r; r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r; r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r; return r; } #endif /* GL_EXT_draw_buffers2 */ #ifdef GL_EXT_draw_instanced static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r; r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r; return r; } #endif /* GL_EXT_draw_instanced */ #ifdef GL_EXT_draw_range_elements static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r; return r; } #endif /* GL_EXT_draw_range_elements */ #ifdef GL_EXT_fog_coord static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r; r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r; r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r; r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r; r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r; return r; } #endif /* GL_EXT_fog_coord */ #ifdef GL_EXT_fragment_lighting static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r; r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r; r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r; r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r; r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r; r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r; r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r; r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r; r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r; r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r; r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r; r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r; r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r; r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r; r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r; r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r; r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r; r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r; return r; } #endif /* GL_EXT_fragment_lighting */ #ifdef GL_EXT_framebuffer_blit static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r; return r; } #endif /* GL_EXT_framebuffer_blit */ #ifdef GL_EXT_framebuffer_multisample static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r; return r; } #endif /* GL_EXT_framebuffer_multisample */ #ifdef GL_EXT_framebuffer_object static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r; r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r; r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r; r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r; r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r; r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r; r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r; r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r; r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r; r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r; r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r; r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r; r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r; r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r; r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r; r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r; r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r; return r; } #endif /* GL_EXT_framebuffer_object */ #ifdef GL_EXT_geometry_shader4 static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r; r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r; r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r; return r; } #endif /* GL_EXT_geometry_shader4 */ #ifdef GL_EXT_gpu_program_parameters static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r; r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r; return r; } #endif /* GL_EXT_gpu_program_parameters */ #ifdef GL_EXT_gpu_shader4 static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r; r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r; r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r; r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r; r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r; r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r; r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r; r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r; r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r; r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r; r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r; r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r; r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r; r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r; r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r; r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r; r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r; r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r; r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r; r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r; r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r; r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r; r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r; r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r; r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r; r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r; r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r; r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r; r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r; r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r; r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r; r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r; r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r; r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_gpu_shader4 */ #ifdef GL_EXT_histogram static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r; r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r; r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r; r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r; r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r; r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r; r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r; r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r; r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r; r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r; return r; } #endif /* GL_EXT_histogram */ #ifdef GL_EXT_index_func static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r; return r; } #endif /* GL_EXT_index_func */ #ifdef GL_EXT_index_material static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r; return r; } #endif /* GL_EXT_index_material */ #ifdef GL_EXT_light_texture static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r; r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r; r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r; return r; } #endif /* GL_EXT_light_texture */ #ifdef GL_EXT_multi_draw_arrays static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r; r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r; return r; } #endif /* GL_EXT_multi_draw_arrays */ #ifdef GL_EXT_multisample static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r; r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r; return r; } #endif /* GL_EXT_multisample */ #ifdef GL_EXT_paletted_texture static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r; r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r; r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r; r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r; return r; } #endif /* GL_EXT_paletted_texture */ #ifdef GL_EXT_pixel_transform static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r; r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r; r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r; r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r; r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r; r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r; return r; } #endif /* GL_EXT_pixel_transform */ #ifdef GL_EXT_point_parameters static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r; r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r; return r; } #endif /* GL_EXT_point_parameters */ #ifdef GL_EXT_polygon_offset static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r; return r; } #endif /* GL_EXT_polygon_offset */ #ifdef GL_EXT_polygon_offset_clamp static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPolygonOffsetClampEXT = (PFNGLPOLYGONOFFSETCLAMPEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetClampEXT")) == NULL) || r; return r; } #endif /* GL_EXT_polygon_offset_clamp */ #ifdef GL_EXT_provoking_vertex static GLboolean _glewInit_GL_EXT_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r; return r; } #endif /* GL_EXT_provoking_vertex */ #ifdef GL_EXT_raster_multisample static GLboolean _glewInit_GL_EXT_raster_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCoverageModulationNV = (PFNGLCOVERAGEMODULATIONNVPROC)glewGetProcAddress((const GLubyte*)"glCoverageModulationNV")) == NULL) || r; r = ((glCoverageModulationTableNV = (PFNGLCOVERAGEMODULATIONTABLENVPROC)glewGetProcAddress((const GLubyte*)"glCoverageModulationTableNV")) == NULL) || r; r = ((glGetCoverageModulationTableNV = (PFNGLGETCOVERAGEMODULATIONTABLENVPROC)glewGetProcAddress((const GLubyte*)"glGetCoverageModulationTableNV")) == NULL) || r; r = ((glRasterSamplesEXT = (PFNGLRASTERSAMPLESEXTPROC)glewGetProcAddress((const GLubyte*)"glRasterSamplesEXT")) == NULL) || r; return r; } #endif /* GL_EXT_raster_multisample */ #ifdef GL_EXT_scene_marker static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r; r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r; return r; } #endif /* GL_EXT_scene_marker */ #ifdef GL_EXT_secondary_color static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r; r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r; r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r; r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r; r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r; r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r; r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r; r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r; r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r; r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r; r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r; r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r; r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r; r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r; r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r; r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r; r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_secondary_color */ #ifdef GL_EXT_separate_shader_objects static GLboolean _glewInit_GL_EXT_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r; r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r; r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r; return r; } #endif /* GL_EXT_separate_shader_objects */ #ifdef GL_EXT_shader_image_load_store static GLboolean _glewInit_GL_EXT_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r; r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r; return r; } #endif /* GL_EXT_shader_image_load_store */ #ifdef GL_EXT_stencil_two_side static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r; return r; } #endif /* GL_EXT_stencil_two_side */ #ifdef GL_EXT_subtexture static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r; r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r; r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r; return r; } #endif /* GL_EXT_subtexture */ #ifdef GL_EXT_texture3D static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r; return r; } #endif /* GL_EXT_texture3D */ #ifdef GL_EXT_texture_array static GLboolean _glewInit_GL_EXT_texture_array (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_texture_array */ #ifdef GL_EXT_texture_buffer_object static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r; return r; } #endif /* GL_EXT_texture_buffer_object */ #ifdef GL_EXT_texture_integer static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r; r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r; r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r; r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r; r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r; r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r; return r; } #endif /* GL_EXT_texture_integer */ #ifdef GL_EXT_texture_object static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r; r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r; r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r; r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r; r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r; r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r; return r; } #endif /* GL_EXT_texture_object */ #ifdef GL_EXT_texture_perturb_normal static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r; return r; } #endif /* GL_EXT_texture_perturb_normal */ #ifdef GL_EXT_timer_query static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r; r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r; return r; } #endif /* GL_EXT_timer_query */ #ifdef GL_EXT_transform_feedback static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r; r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r; r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r; r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r; r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r; r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r; r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r; return r; } #endif /* GL_EXT_transform_feedback */ #ifdef GL_EXT_vertex_array static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r; r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r; r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r; r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r; r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r; r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r; r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r; r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_vertex_array */ #ifdef GL_EXT_vertex_attrib_64bit static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r; r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r; r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r; r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r; r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r; r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r; r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r; r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r; r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r; r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r; r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r; return r; } #endif /* GL_EXT_vertex_attrib_64bit */ #ifdef GL_EXT_vertex_shader static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r; r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r; r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r; r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r; r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r; r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r; r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r; r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r; r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r; r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r; r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r; r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r; r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r; r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r; r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r; r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r; r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r; r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r; r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r; r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r; r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r; r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r; r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r; r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r; r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r; r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r; r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r; r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r; r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r; r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r; r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r; r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r; r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r; r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r; r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r; r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r; r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r; r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r; r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r; r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r; r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r; r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r; return r; } #endif /* GL_EXT_vertex_shader */ #ifdef GL_EXT_vertex_weighting static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r; r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r; r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r; return r; } #endif /* GL_EXT_vertex_weighting */ #ifdef GL_EXT_x11_sync_object static GLboolean _glewInit_GL_EXT_x11_sync_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSyncEXT")) == NULL) || r; return r; } #endif /* GL_EXT_x11_sync_object */ #ifdef GL_GREMEDY_frame_terminator static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r; return r; } #endif /* GL_GREMEDY_frame_terminator */ #ifdef GL_GREMEDY_string_marker static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r; return r; } #endif /* GL_GREMEDY_string_marker */ #ifdef GL_HP_image_transform static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r; r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r; r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r; r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r; r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r; r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r; return r; } #endif /* GL_HP_image_transform */ #ifdef GL_IBM_multimode_draw_arrays static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r; r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r; return r; } #endif /* GL_IBM_multimode_draw_arrays */ #ifdef GL_IBM_vertex_array_lists static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r; r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r; r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r; r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r; r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r; r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r; r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r; r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r; return r; } #endif /* GL_IBM_vertex_array_lists */ #ifdef GL_INTEL_map_texture static GLboolean _glewInit_GL_INTEL_map_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMapTexture2DINTEL = (PFNGLMAPTEXTURE2DINTELPROC)glewGetProcAddress((const GLubyte*)"glMapTexture2DINTEL")) == NULL) || r; r = ((glSyncTextureINTEL = (PFNGLSYNCTEXTUREINTELPROC)glewGetProcAddress((const GLubyte*)"glSyncTextureINTEL")) == NULL) || r; r = ((glUnmapTexture2DINTEL = (PFNGLUNMAPTEXTURE2DINTELPROC)glewGetProcAddress((const GLubyte*)"glUnmapTexture2DINTEL")) == NULL) || r; return r; } #endif /* GL_INTEL_map_texture */ #ifdef GL_INTEL_parallel_arrays static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r; r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r; r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r; r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r; return r; } #endif /* GL_INTEL_parallel_arrays */ #ifdef GL_INTEL_performance_query static GLboolean _glewInit_GL_INTEL_performance_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginPerfQueryINTEL = (PFNGLBEGINPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfQueryINTEL")) == NULL) || r; r = ((glCreatePerfQueryINTEL = (PFNGLCREATEPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glCreatePerfQueryINTEL")) == NULL) || r; r = ((glDeletePerfQueryINTEL = (PFNGLDELETEPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfQueryINTEL")) == NULL) || r; r = ((glEndPerfQueryINTEL = (PFNGLENDPERFQUERYINTELPROC)glewGetProcAddress((const GLubyte*)"glEndPerfQueryINTEL")) == NULL) || r; r = ((glGetFirstPerfQueryIdINTEL = (PFNGLGETFIRSTPERFQUERYIDINTELPROC)glewGetProcAddress((const GLubyte*)"glGetFirstPerfQueryIdINTEL")) == NULL) || r; r = ((glGetNextPerfQueryIdINTEL = (PFNGLGETNEXTPERFQUERYIDINTELPROC)glewGetProcAddress((const GLubyte*)"glGetNextPerfQueryIdINTEL")) == NULL) || r; r = ((glGetPerfCounterInfoINTEL = (PFNGLGETPERFCOUNTERINFOINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfCounterInfoINTEL")) == NULL) || r; r = ((glGetPerfQueryDataINTEL = (PFNGLGETPERFQUERYDATAINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfQueryDataINTEL")) == NULL) || r; r = ((glGetPerfQueryIdByNameINTEL = (PFNGLGETPERFQUERYIDBYNAMEINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfQueryIdByNameINTEL")) == NULL) || r; r = ((glGetPerfQueryInfoINTEL = (PFNGLGETPERFQUERYINFOINTELPROC)glewGetProcAddress((const GLubyte*)"glGetPerfQueryInfoINTEL")) == NULL) || r; return r; } #endif /* GL_INTEL_performance_query */ #ifdef GL_INTEL_texture_scissor static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r; r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r; return r; } #endif /* GL_INTEL_texture_scissor */ #ifdef GL_KHR_blend_equation_advanced static GLboolean _glewInit_GL_KHR_blend_equation_advanced (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendBarrierKHR = (PFNGLBLENDBARRIERKHRPROC)glewGetProcAddress((const GLubyte*)"glBlendBarrierKHR")) == NULL) || r; return r; } #endif /* GL_KHR_blend_equation_advanced */ #ifdef GL_KHR_debug static GLboolean _glewInit_GL_KHR_debug (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallback")) == NULL) || r; r = ((glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControl")) == NULL) || r; r = ((glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsert")) == NULL) || r; r = ((glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLog")) == NULL) || r; r = ((glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectLabel")) == NULL) || r; r = ((glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glGetObjectPtrLabel")) == NULL) || r; r = ((glObjectLabel = (PFNGLOBJECTLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectLabel")) == NULL) || r; r = ((glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)glewGetProcAddress((const GLubyte*)"glObjectPtrLabel")) == NULL) || r; r = ((glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPopDebugGroup")) == NULL) || r; r = ((glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)glewGetProcAddress((const GLubyte*)"glPushDebugGroup")) == NULL) || r; return r; } #endif /* GL_KHR_debug */ #ifdef GL_KHR_robustness static GLboolean _glewInit_GL_KHR_robustness (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetnUniformfv = (PFNGLGETNUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfv")) == NULL) || r; r = ((glGetnUniformiv = (PFNGLGETNUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformiv")) == NULL) || r; r = ((glGetnUniformuiv = (PFNGLGETNUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuiv")) == NULL) || r; r = ((glReadnPixels = (PFNGLREADNPIXELSPROC)glewGetProcAddress((const GLubyte*)"glReadnPixels")) == NULL) || r; return r; } #endif /* GL_KHR_robustness */ #ifdef GL_KTX_buffer_region static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBufferRegionEnabled = (PFNGLBUFFERREGIONENABLEDPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabled")) == NULL) || r; r = ((glDeleteBufferRegion = (PFNGLDELETEBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegion")) == NULL) || r; r = ((glDrawBufferRegion = (PFNGLDRAWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegion")) == NULL) || r; r = ((glNewBufferRegion = (PFNGLNEWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegion")) == NULL) || r; r = ((glReadBufferRegion = (PFNGLREADBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegion")) == NULL) || r; return r; } #endif /* GL_KTX_buffer_region */ #ifdef GL_MESA_resize_buffers static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r; return r; } #endif /* GL_MESA_resize_buffers */ #ifdef GL_MESA_window_pos static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r; r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r; r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r; r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r; r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r; r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r; r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r; r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r; r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r; r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r; r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r; r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r; r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r; r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r; r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r; r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r; r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r; r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r; r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r; r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r; r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r; r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r; r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r; r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r; return r; } #endif /* GL_MESA_window_pos */ #ifdef GL_NVX_conditional_render static GLboolean _glewInit_GL_NVX_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginConditionalRenderNVX = (PFNGLBEGINCONDITIONALRENDERNVXPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNVX")) == NULL) || r; r = ((glEndConditionalRenderNVX = (PFNGLENDCONDITIONALRENDERNVXPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNVX")) == NULL) || r; return r; } #endif /* GL_NVX_conditional_render */ #ifdef GL_NV_bindless_multi_draw_indirect static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiDrawArraysIndirectBindlessNV = (PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectBindlessNV")) == NULL) || r; r = ((glMultiDrawElementsIndirectBindlessNV = (PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectBindlessNV")) == NULL) || r; return r; } #endif /* GL_NV_bindless_multi_draw_indirect */ #ifdef GL_NV_bindless_multi_draw_indirect_count static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glMultiDrawArraysIndirectBindlessCountNV = (PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectBindlessCountNV")) == NULL) || r; r = ((glMultiDrawElementsIndirectBindlessCountNV = (PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectBindlessCountNV")) == NULL) || r; return r; } #endif /* GL_NV_bindless_multi_draw_indirect_count */ #ifdef GL_NV_bindless_texture static GLboolean _glewInit_GL_NV_bindless_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetImageHandleNV = (PFNGLGETIMAGEHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetImageHandleNV")) == NULL) || r; r = ((glGetTextureHandleNV = (PFNGLGETTEXTUREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleNV")) == NULL) || r; r = ((glGetTextureSamplerHandleNV = (PFNGLGETTEXTURESAMPLERHANDLENVPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleNV")) == NULL) || r; r = ((glIsImageHandleResidentNV = (PFNGLISIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsImageHandleResidentNV")) == NULL) || r; r = ((glIsTextureHandleResidentNV = (PFNGLISTEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsTextureHandleResidentNV")) == NULL) || r; r = ((glMakeImageHandleNonResidentNV = (PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleNonResidentNV")) == NULL) || r; r = ((glMakeImageHandleResidentNV = (PFNGLMAKEIMAGEHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeImageHandleResidentNV")) == NULL) || r; r = ((glMakeTextureHandleNonResidentNV = (PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleNonResidentNV")) == NULL) || r; r = ((glMakeTextureHandleResidentNV = (PFNGLMAKETEXTUREHANDLERESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeTextureHandleResidentNV")) == NULL) || r; r = ((glProgramUniformHandleui64NV = (PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64NV")) == NULL) || r; r = ((glProgramUniformHandleui64vNV = (PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vNV")) == NULL) || r; r = ((glUniformHandleui64NV = (PFNGLUNIFORMHANDLEUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64NV")) == NULL) || r; r = ((glUniformHandleui64vNV = (PFNGLUNIFORMHANDLEUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vNV")) == NULL) || r; return r; } #endif /* GL_NV_bindless_texture */ #ifdef GL_NV_blend_equation_advanced static GLboolean _glewInit_GL_NV_blend_equation_advanced (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBlendBarrierNV = (PFNGLBLENDBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glBlendBarrierNV")) == NULL) || r; r = ((glBlendParameteriNV = (PFNGLBLENDPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glBlendParameteriNV")) == NULL) || r; return r; } #endif /* GL_NV_blend_equation_advanced */ #ifdef GL_NV_conditional_render static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r; r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r; return r; } #endif /* GL_NV_conditional_render */ #ifdef GL_NV_conservative_raster static GLboolean _glewInit_GL_NV_conservative_raster (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSubpixelPrecisionBiasNV = (PFNGLSUBPIXELPRECISIONBIASNVPROC)glewGetProcAddress((const GLubyte*)"glSubpixelPrecisionBiasNV")) == NULL) || r; return r; } #endif /* GL_NV_conservative_raster */ #ifdef GL_NV_conservative_raster_dilate static GLboolean _glewInit_GL_NV_conservative_raster_dilate (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glConservativeRasterParameterfNV = (PFNGLCONSERVATIVERASTERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glConservativeRasterParameterfNV")) == NULL) || r; return r; } #endif /* GL_NV_conservative_raster_dilate */ #ifdef GL_NV_copy_image static GLboolean _glewInit_GL_NV_copy_image (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r; return r; } #endif /* GL_NV_copy_image */ #ifdef GL_NV_depth_buffer_float static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r; r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r; r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r; return r; } #endif /* GL_NV_depth_buffer_float */ #ifdef GL_NV_draw_texture static GLboolean _glewInit_GL_NV_draw_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDrawTextureNV = (PFNGLDRAWTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glDrawTextureNV")) == NULL) || r; return r; } #endif /* GL_NV_draw_texture */ #ifdef GL_NV_evaluators static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r; r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r; r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r; r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r; r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r; r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r; r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r; r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r; r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r; return r; } #endif /* GL_NV_evaluators */ #ifdef GL_NV_explicit_multisample static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r; r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r; r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r; return r; } #endif /* GL_NV_explicit_multisample */ #ifdef GL_NV_fence static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r; r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r; r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r; r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r; r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r; r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r; r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r; return r; } #endif /* GL_NV_fence */ #ifdef GL_NV_fragment_coverage_to_color static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFragmentCoverageColorNV = (PFNGLFRAGMENTCOVERAGECOLORNVPROC)glewGetProcAddress((const GLubyte*)"glFragmentCoverageColorNV")) == NULL) || r; return r; } #endif /* GL_NV_fragment_coverage_to_color */ #ifdef GL_NV_fragment_program static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r; r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r; r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r; r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r; r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r; r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r; return r; } #endif /* GL_NV_fragment_program */ #ifdef GL_NV_framebuffer_multisample_coverage static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r; return r; } #endif /* GL_NV_framebuffer_multisample_coverage */ #ifdef GL_NV_geometry_program4 static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r; return r; } #endif /* GL_NV_geometry_program4 */ #ifdef GL_NV_gpu_program4 static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r; r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r; r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r; r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r; r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r; r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r; r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r; r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r; r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r; r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r; r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r; r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r; return r; } #endif /* GL_NV_gpu_program4 */ #ifdef GL_NV_gpu_shader5 static GLboolean _glewInit_GL_NV_gpu_shader5 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r; r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r; r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r; r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r; r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r; r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r; r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r; r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r; r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r; r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r; r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r; r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r; r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r; r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r; r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r; r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r; r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r; r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r; r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r; r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r; r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r; r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r; r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r; r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r; r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r; r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r; r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r; r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r; r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r; r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r; r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r; r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r; r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r; r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r; return r; } #endif /* GL_NV_gpu_shader5 */ #ifdef GL_NV_half_float static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r; r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r; r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r; r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r; r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r; r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r; r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r; r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r; r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r; r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r; r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r; r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r; r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r; r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r; r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r; r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r; r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r; r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r; r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r; r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r; r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r; r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r; r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r; r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r; r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r; r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r; r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r; r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r; r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r; r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r; r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r; r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r; r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r; r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r; r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r; r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r; r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r; r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r; r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r; r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r; r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r; r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r; r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r; r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r; r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r; r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r; return r; } #endif /* GL_NV_half_float */ #ifdef GL_NV_internalformat_sample_query static GLboolean _glewInit_GL_NV_internalformat_sample_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetInternalformatSampleivNV = (PFNGLGETINTERNALFORMATSAMPLEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformatSampleivNV")) == NULL) || r; return r; } #endif /* GL_NV_internalformat_sample_query */ #ifdef GL_NV_occlusion_query static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r; r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r; r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r; r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r; r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r; r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r; r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r; return r; } #endif /* GL_NV_occlusion_query */ #ifdef GL_NV_parameter_buffer_object static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r; r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r; r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r; return r; } #endif /* GL_NV_parameter_buffer_object */ #ifdef GL_NV_path_rendering static GLboolean _glewInit_GL_NV_path_rendering (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCopyPathNV = (PFNGLCOPYPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCopyPathNV")) == NULL) || r; r = ((glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathInstancedNV")) == NULL) || r; r = ((glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathNV")) == NULL) || r; r = ((glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathInstancedNV")) == NULL) || r; r = ((glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathNV")) == NULL) || r; r = ((glDeletePathsNV = (PFNGLDELETEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glDeletePathsNV")) == NULL) || r; r = ((glGenPathsNV = (PFNGLGENPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glGenPathsNV")) == NULL) || r; r = ((glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenfvNV")) == NULL) || r; r = ((glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenivNV")) == NULL) || r; r = ((glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCommandsNV")) == NULL) || r; r = ((glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCoordsNV")) == NULL) || r; r = ((glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathDashArrayNV")) == NULL) || r; r = ((glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathLengthNV")) == NULL) || r; r = ((glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricRangeNV")) == NULL) || r; r = ((glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricsNV")) == NULL) || r; r = ((glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterfvNV")) == NULL) || r; r = ((glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterivNV")) == NULL) || r; r = ((glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathSpacingNV")) == NULL) || r; r = ((glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenfvNV")) == NULL) || r; r = ((glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenivNV")) == NULL) || r; r = ((glGetProgramResourcefvNV = (PFNGLGETPROGRAMRESOURCEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourcefvNV")) == NULL) || r; r = ((glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glInterpolatePathsNV")) == NULL) || r; r = ((glIsPathNV = (PFNGLISPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPathNV")) == NULL) || r; r = ((glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInFillPathNV")) == NULL) || r; r = ((glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInStrokePathNV")) == NULL) || r; r = ((glMatrixLoad3x2fNV = (PFNGLMATRIXLOAD3X2FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoad3x2fNV")) == NULL) || r; r = ((glMatrixLoad3x3fNV = (PFNGLMATRIXLOAD3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoad3x3fNV")) == NULL) || r; r = ((glMatrixLoadTranspose3x3fNV = (PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTranspose3x3fNV")) == NULL) || r; r = ((glMatrixMult3x2fNV = (PFNGLMATRIXMULT3X2FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixMult3x2fNV")) == NULL) || r; r = ((glMatrixMult3x3fNV = (PFNGLMATRIXMULT3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixMult3x3fNV")) == NULL) || r; r = ((glMatrixMultTranspose3x3fNV = (PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTranspose3x3fNV")) == NULL) || r; r = ((glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathColorGenNV")) == NULL) || r; r = ((glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCommandsNV")) == NULL) || r; r = ((glPathCoordsNV = (PFNGLPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoordsNV")) == NULL) || r; r = ((glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoverDepthFuncNV")) == NULL) || r; r = ((glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathDashArrayNV")) == NULL) || r; r = ((glPathFogGenNV = (PFNGLPATHFOGGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathFogGenNV")) == NULL) || r; r = ((glPathGlyphIndexArrayNV = (PFNGLPATHGLYPHINDEXARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphIndexArrayNV")) == NULL) || r; r = ((glPathGlyphIndexRangeNV = (PFNGLPATHGLYPHINDEXRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphIndexRangeNV")) == NULL) || r; r = ((glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphRangeNV")) == NULL) || r; r = ((glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphsNV")) == NULL) || r; r = ((glPathMemoryGlyphIndexArrayNV = (PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathMemoryGlyphIndexArrayNV")) == NULL) || r; r = ((glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfNV")) == NULL) || r; r = ((glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfvNV")) == NULL) || r; r = ((glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPathParameteriNV")) == NULL) || r; r = ((glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterivNV")) == NULL) || r; r = ((glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilDepthOffsetNV")) == NULL) || r; r = ((glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilFuncNV")) == NULL) || r; r = ((glPathStringNV = (PFNGLPATHSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glPathStringNV")) == NULL) || r; r = ((glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCommandsNV")) == NULL) || r; r = ((glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCoordsNV")) == NULL) || r; r = ((glPathTexGenNV = (PFNGLPATHTEXGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathTexGenNV")) == NULL) || r; r = ((glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC)glewGetProcAddress((const GLubyte*)"glPointAlongPathNV")) == NULL) || r; r = ((glProgramPathFragmentInputGenNV = (PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC)glewGetProcAddress((const GLubyte*)"glProgramPathFragmentInputGenNV")) == NULL) || r; r = ((glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathInstancedNV")) == NULL) || r; r = ((glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathNV")) == NULL) || r; r = ((glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathInstancedNV")) == NULL) || r; r = ((glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathNV")) == NULL) || r; r = ((glStencilThenCoverFillPathInstancedNV = (PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverFillPathInstancedNV")) == NULL) || r; r = ((glStencilThenCoverFillPathNV = (PFNGLSTENCILTHENCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverFillPathNV")) == NULL) || r; r = ((glStencilThenCoverStrokePathInstancedNV = (PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverStrokePathInstancedNV")) == NULL) || r; r = ((glStencilThenCoverStrokePathNV = (PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilThenCoverStrokePathNV")) == NULL) || r; r = ((glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC)glewGetProcAddress((const GLubyte*)"glTransformPathNV")) == NULL) || r; r = ((glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glWeightPathsNV")) == NULL) || r; return r; } #endif /* GL_NV_path_rendering */ #ifdef GL_NV_pixel_data_range static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r; r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r; return r; } #endif /* GL_NV_pixel_data_range */ #ifdef GL_NV_point_sprite static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r; r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r; return r; } #endif /* GL_NV_point_sprite */ #ifdef GL_NV_present_video static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r; r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r; r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r; r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r; r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r; r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r; return r; } #endif /* GL_NV_present_video */ #ifdef GL_NV_primitive_restart static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r; r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r; return r; } #endif /* GL_NV_primitive_restart */ #ifdef GL_NV_register_combiners static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r; r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r; r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r; r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r; r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r; r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r; r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r; r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r; r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r; r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r; r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r; r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r; r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r; return r; } #endif /* GL_NV_register_combiners */ #ifdef GL_NV_register_combiners2 static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r; r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r; return r; } #endif /* GL_NV_register_combiners2 */ #ifdef GL_NV_sample_locations static GLboolean _glewInit_GL_NV_sample_locations (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferSampleLocationsfvNV = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvNV")) == NULL) || r; r = ((glNamedFramebufferSampleLocationsfvNV = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvNV")) == NULL) || r; return r; } #endif /* GL_NV_sample_locations */ #ifdef GL_NV_shader_buffer_load static GLboolean _glewInit_GL_NV_shader_buffer_load (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r; r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r; r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r; r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r; r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r; r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r; r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r; r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r; r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r; r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r; r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r; r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r; r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r; return r; } #endif /* GL_NV_shader_buffer_load */ #ifdef GL_NV_texture_barrier static GLboolean _glewInit_GL_NV_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r; return r; } #endif /* GL_NV_texture_barrier */ #ifdef GL_NV_texture_multisample static GLboolean _glewInit_GL_NV_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisampleCoverageNV")) == NULL) || r; r = ((glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisampleCoverageNV")) == NULL) || r; r = ((glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleCoverageNV")) == NULL) || r; r = ((glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleNV")) == NULL) || r; r = ((glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleCoverageNV")) == NULL) || r; r = ((glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleNV")) == NULL) || r; return r; } #endif /* GL_NV_texture_multisample */ #ifdef GL_NV_transform_feedback static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r; r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r; r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r; r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r; r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r; r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r; r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r; r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r; r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r; r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r; r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r; return r; } #endif /* GL_NV_transform_feedback */ #ifdef GL_NV_transform_feedback2 static GLboolean _glewInit_GL_NV_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r; r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r; r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r; r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r; r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r; r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r; r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r; return r; } #endif /* GL_NV_transform_feedback2 */ #ifdef GL_NV_vdpau_interop static GLboolean _glewInit_GL_NV_vdpau_interop (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glVDPAUFiniNV = (PFNGLVDPAUFININVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUFiniNV")) == NULL) || r; r = ((glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUGetSurfaceivNV")) == NULL) || r; r = ((glVDPAUInitNV = (PFNGLVDPAUINITNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUInitNV")) == NULL) || r; r = ((glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUIsSurfaceNV")) == NULL) || r; r = ((glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUMapSurfacesNV")) == NULL) || r; r = ((glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterOutputSurfaceNV")) == NULL) || r; r = ((glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterVideoSurfaceNV")) == NULL) || r; r = ((glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUSurfaceAccessNV")) == NULL) || r; r = ((glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnmapSurfacesNV")) == NULL) || r; r = ((glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnregisterSurfaceNV")) == NULL) || r; return r; } #endif /* GL_NV_vdpau_interop */ #ifdef GL_NV_vertex_array_range static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r; r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r; return r; } #endif /* GL_NV_vertex_array_range */ #ifdef GL_NV_vertex_attrib_integer_64bit static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r; r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r; r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r; r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r; r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r; r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r; r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r; r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r; r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r; r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r; r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r; r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r; r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r; r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r; r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r; r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r; r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r; r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r; r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r; return r; } #endif /* GL_NV_vertex_attrib_integer_64bit */ #ifdef GL_NV_vertex_buffer_unified_memory static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r; r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r; r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r; r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r; r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r; r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r; r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r; r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r; r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r; r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r; r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r; r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r; return r; } #endif /* GL_NV_vertex_buffer_unified_memory */ #ifdef GL_NV_vertex_program static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r; r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r; r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r; r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r; r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r; r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r; r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r; r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r; r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r; r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r; r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r; r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r; r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r; r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r; r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r; r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r; r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r; r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r; r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r; r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r; r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r; r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r; r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r; r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r; r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r; r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r; r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r; r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r; r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r; r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r; r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r; r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r; r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r; r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r; r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r; r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r; r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r; r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r; r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r; r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r; r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r; r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r; r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r; r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r; r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r; r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r; r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r; r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r; r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r; r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r; r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r; r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r; r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r; r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r; r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r; r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r; r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r; r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r; r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r; r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r; r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r; r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r; r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r; r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r; return r; } #endif /* GL_NV_vertex_program */ #ifdef GL_NV_video_capture static GLboolean _glewInit_GL_NV_video_capture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glBeginVideoCaptureNV")) == NULL) || r; r = ((glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamBufferNV")) == NULL) || r; r = ((glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamTextureNV")) == NULL) || r; r = ((glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glEndVideoCaptureNV")) == NULL) || r; r = ((glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamdvNV")) == NULL) || r; r = ((glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamfvNV")) == NULL) || r; r = ((glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamivNV")) == NULL) || r; r = ((glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureivNV")) == NULL) || r; r = ((glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureNV")) == NULL) || r; r = ((glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterdvNV")) == NULL) || r; r = ((glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterfvNV")) == NULL) || r; r = ((glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterivNV")) == NULL) || r; return r; } #endif /* GL_NV_video_capture */ #ifdef GL_OES_single_precision static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r; r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r; r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r; r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r; r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r; r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r; return r; } #endif /* GL_OES_single_precision */ #ifdef GL_OVR_multiview static GLboolean _glewInit_GL_OVR_multiview (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFramebufferTextureMultiviewOVR = (PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureMultiviewOVR")) == NULL) || r; return r; } #endif /* GL_OVR_multiview */ #ifdef GL_REGAL_ES1_0_compatibility static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAlphaFuncx = (PFNGLALPHAFUNCXPROC)glewGetProcAddress((const GLubyte*)"glAlphaFuncx")) == NULL) || r; r = ((glClearColorx = (PFNGLCLEARCOLORXPROC)glewGetProcAddress((const GLubyte*)"glClearColorx")) == NULL) || r; r = ((glClearDepthx = (PFNGLCLEARDEPTHXPROC)glewGetProcAddress((const GLubyte*)"glClearDepthx")) == NULL) || r; r = ((glColor4x = (PFNGLCOLOR4XPROC)glewGetProcAddress((const GLubyte*)"glColor4x")) == NULL) || r; r = ((glDepthRangex = (PFNGLDEPTHRANGEXPROC)glewGetProcAddress((const GLubyte*)"glDepthRangex")) == NULL) || r; r = ((glFogx = (PFNGLFOGXPROC)glewGetProcAddress((const GLubyte*)"glFogx")) == NULL) || r; r = ((glFogxv = (PFNGLFOGXVPROC)glewGetProcAddress((const GLubyte*)"glFogxv")) == NULL) || r; r = ((glFrustumf = (PFNGLFRUSTUMFPROC)glewGetProcAddress((const GLubyte*)"glFrustumf")) == NULL) || r; r = ((glFrustumx = (PFNGLFRUSTUMXPROC)glewGetProcAddress((const GLubyte*)"glFrustumx")) == NULL) || r; r = ((glLightModelx = (PFNGLLIGHTMODELXPROC)glewGetProcAddress((const GLubyte*)"glLightModelx")) == NULL) || r; r = ((glLightModelxv = (PFNGLLIGHTMODELXVPROC)glewGetProcAddress((const GLubyte*)"glLightModelxv")) == NULL) || r; r = ((glLightx = (PFNGLLIGHTXPROC)glewGetProcAddress((const GLubyte*)"glLightx")) == NULL) || r; r = ((glLightxv = (PFNGLLIGHTXVPROC)glewGetProcAddress((const GLubyte*)"glLightxv")) == NULL) || r; r = ((glLineWidthx = (PFNGLLINEWIDTHXPROC)glewGetProcAddress((const GLubyte*)"glLineWidthx")) == NULL) || r; r = ((glLoadMatrixx = (PFNGLLOADMATRIXXPROC)glewGetProcAddress((const GLubyte*)"glLoadMatrixx")) == NULL) || r; r = ((glMaterialx = (PFNGLMATERIALXPROC)glewGetProcAddress((const GLubyte*)"glMaterialx")) == NULL) || r; r = ((glMaterialxv = (PFNGLMATERIALXVPROC)glewGetProcAddress((const GLubyte*)"glMaterialxv")) == NULL) || r; r = ((glMultMatrixx = (PFNGLMULTMATRIXXPROC)glewGetProcAddress((const GLubyte*)"glMultMatrixx")) == NULL) || r; r = ((glMultiTexCoord4x = (PFNGLMULTITEXCOORD4XPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4x")) == NULL) || r; r = ((glNormal3x = (PFNGLNORMAL3XPROC)glewGetProcAddress((const GLubyte*)"glNormal3x")) == NULL) || r; r = ((glOrthof = (PFNGLORTHOFPROC)glewGetProcAddress((const GLubyte*)"glOrthof")) == NULL) || r; r = ((glOrthox = (PFNGLORTHOXPROC)glewGetProcAddress((const GLubyte*)"glOrthox")) == NULL) || r; r = ((glPointSizex = (PFNGLPOINTSIZEXPROC)glewGetProcAddress((const GLubyte*)"glPointSizex")) == NULL) || r; r = ((glPolygonOffsetx = (PFNGLPOLYGONOFFSETXPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetx")) == NULL) || r; r = ((glRotatex = (PFNGLROTATEXPROC)glewGetProcAddress((const GLubyte*)"glRotatex")) == NULL) || r; r = ((glSampleCoveragex = (PFNGLSAMPLECOVERAGEXPROC)glewGetProcAddress((const GLubyte*)"glSampleCoveragex")) == NULL) || r; r = ((glScalex = (PFNGLSCALEXPROC)glewGetProcAddress((const GLubyte*)"glScalex")) == NULL) || r; r = ((glTexEnvx = (PFNGLTEXENVXPROC)glewGetProcAddress((const GLubyte*)"glTexEnvx")) == NULL) || r; r = ((glTexEnvxv = (PFNGLTEXENVXVPROC)glewGetProcAddress((const GLubyte*)"glTexEnvxv")) == NULL) || r; r = ((glTexParameterx = (PFNGLTEXPARAMETERXPROC)glewGetProcAddress((const GLubyte*)"glTexParameterx")) == NULL) || r; r = ((glTranslatex = (PFNGLTRANSLATEXPROC)glewGetProcAddress((const GLubyte*)"glTranslatex")) == NULL) || r; return r; } #endif /* GL_REGAL_ES1_0_compatibility */ #ifdef GL_REGAL_ES1_1_compatibility static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glClipPlanef = (PFNGLCLIPPLANEFPROC)glewGetProcAddress((const GLubyte*)"glClipPlanef")) == NULL) || r; r = ((glClipPlanex = (PFNGLCLIPPLANEXPROC)glewGetProcAddress((const GLubyte*)"glClipPlanex")) == NULL) || r; r = ((glGetClipPlanef = (PFNGLGETCLIPPLANEFPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanef")) == NULL) || r; r = ((glGetClipPlanex = (PFNGLGETCLIPPLANEXPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanex")) == NULL) || r; r = ((glGetFixedv = (PFNGLGETFIXEDVPROC)glewGetProcAddress((const GLubyte*)"glGetFixedv")) == NULL) || r; r = ((glGetLightxv = (PFNGLGETLIGHTXVPROC)glewGetProcAddress((const GLubyte*)"glGetLightxv")) == NULL) || r; r = ((glGetMaterialxv = (PFNGLGETMATERIALXVPROC)glewGetProcAddress((const GLubyte*)"glGetMaterialxv")) == NULL) || r; r = ((glGetTexEnvxv = (PFNGLGETTEXENVXVPROC)glewGetProcAddress((const GLubyte*)"glGetTexEnvxv")) == NULL) || r; r = ((glGetTexParameterxv = (PFNGLGETTEXPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterxv")) == NULL) || r; r = ((glPointParameterx = (PFNGLPOINTPARAMETERXPROC)glewGetProcAddress((const GLubyte*)"glPointParameterx")) == NULL) || r; r = ((glPointParameterxv = (PFNGLPOINTPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterxv")) == NULL) || r; r = ((glPointSizePointerOES = (PFNGLPOINTSIZEPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glPointSizePointerOES")) == NULL) || r; r = ((glTexParameterxv = (PFNGLTEXPARAMETERXVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterxv")) == NULL) || r; return r; } #endif /* GL_REGAL_ES1_1_compatibility */ #ifdef GL_REGAL_error_string static GLboolean _glewInit_GL_REGAL_error_string (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glErrorStringREGAL = (PFNGLERRORSTRINGREGALPROC)glewGetProcAddress((const GLubyte*)"glErrorStringREGAL")) == NULL) || r; return r; } #endif /* GL_REGAL_error_string */ #ifdef GL_REGAL_extension_query static GLboolean _glewInit_GL_REGAL_extension_query (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetExtensionREGAL = (PFNGLGETEXTENSIONREGALPROC)glewGetProcAddress((const GLubyte*)"glGetExtensionREGAL")) == NULL) || r; r = ((glIsSupportedREGAL = (PFNGLISSUPPORTEDREGALPROC)glewGetProcAddress((const GLubyte*)"glIsSupportedREGAL")) == NULL) || r; return r; } #endif /* GL_REGAL_extension_query */ #ifdef GL_REGAL_log static GLboolean _glewInit_GL_REGAL_log (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glLogMessageCallbackREGAL = (PFNGLLOGMESSAGECALLBACKREGALPROC)glewGetProcAddress((const GLubyte*)"glLogMessageCallbackREGAL")) == NULL) || r; return r; } #endif /* GL_REGAL_log */ #ifdef GL_REGAL_proc_address static GLboolean _glewInit_GL_REGAL_proc_address (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetProcAddressREGAL = (PFNGLGETPROCADDRESSREGALPROC)glewGetProcAddress((const GLubyte*)"glGetProcAddressREGAL")) == NULL) || r; return r; } #endif /* GL_REGAL_proc_address */ #ifdef GL_SGIS_detail_texture static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r; r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r; return r; } #endif /* GL_SGIS_detail_texture */ #ifdef GL_SGIS_fog_function static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r; r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r; return r; } #endif /* GL_SGIS_fog_function */ #ifdef GL_SGIS_multisample static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r; r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r; return r; } #endif /* GL_SGIS_multisample */ #ifdef GL_SGIS_sharpen_texture static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r; r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r; return r; } #endif /* GL_SGIS_sharpen_texture */ #ifdef GL_SGIS_texture4D static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r; r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r; return r; } #endif /* GL_SGIS_texture4D */ #ifdef GL_SGIS_texture_filter4 static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r; r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r; return r; } #endif /* GL_SGIS_texture_filter4 */ #ifdef GL_SGIX_async static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r; r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r; r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r; r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r; r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r; r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_async */ #ifdef GL_SGIX_flush_raster static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_flush_raster */ #ifdef GL_SGIX_fog_texture static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_fog_texture */ #ifdef GL_SGIX_fragment_specular_lighting static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r; r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r; r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r; r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r; r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r; r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r; r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r; r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r; r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r; r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r; r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r; r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r; r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r; r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r; r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r; r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r; r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_fragment_specular_lighting */ #ifdef GL_SGIX_framezoom static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_framezoom */ #ifdef GL_SGIX_pixel_texture static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_pixel_texture */ #ifdef GL_SGIX_reference_plane static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_reference_plane */ #ifdef GL_SGIX_sprite static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r; r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r; r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r; r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_sprite */ #ifdef GL_SGIX_tag_sample_buffer static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r; return r; } #endif /* GL_SGIX_tag_sample_buffer */ #ifdef GL_SGI_color_table static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r; r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r; r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r; r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r; r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r; r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r; r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r; return r; } #endif /* GL_SGI_color_table */ #ifdef GL_SUNX_constant_data static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r; return r; } #endif /* GL_SUNX_constant_data */ #ifdef GL_SUN_global_alpha static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r; r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r; r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r; r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r; r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r; r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r; r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r; r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r; return r; } #endif /* GL_SUN_global_alpha */ #ifdef GL_SUN_read_video_pixels static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r; return r; } #endif /* GL_SUN_read_video_pixels */ #ifdef GL_SUN_triangle_list static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r; r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r; r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r; r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r; r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r; r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r; r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r; return r; } #endif /* GL_SUN_triangle_list */ #ifdef GL_SUN_vertex static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r; r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r; r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r; r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r; r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r; r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r; r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r; r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r; r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r; r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r; r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r; r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r; r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r; r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r; r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r; r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r; r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r; r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r; r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r; r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r; r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r; r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r; r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r; r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r; r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r; r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r; return r; } #endif /* GL_SUN_vertex */ #ifdef GL_WIN_swap_hint static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r; return r; } #endif /* GL_WIN_swap_hint */ /* ------------------------------------------------------------------------- */ GLboolean GLEWAPIENTRY glewGetExtension (const char* name) { const GLubyte* start; const GLubyte* end; start = (const GLubyte*)glGetString(GL_EXTENSIONS); if (start == 0) return GL_FALSE; end = start + _glewStrLen(start); return _glewSearchExtension(name, start, end); } /* ------------------------------------------------------------------------- */ #ifndef GLEW_MX static #endif GLenum GLEWAPIENTRY glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST) { const GLubyte* s; GLuint dot; GLint major, minor; const GLubyte* extStart; const GLubyte* extEnd; /* query opengl version */ s = glGetString(GL_VERSION); dot = _glewStrCLen(s, '.'); if (dot == 0) return GLEW_ERROR_NO_GL_VERSION; major = s[dot-1]-'0'; minor = s[dot+1]-'0'; if (minor < 0 || minor > 9) minor = 0; if (major<0 || major>9) return GLEW_ERROR_NO_GL_VERSION; if (major == 1 && minor == 0) { return GLEW_ERROR_GL_VERSION_10_ONLY; } else { GLEW_VERSION_4_5 = ( major > 4 ) || ( major == 4 && minor >= 5 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_4 = GLEW_VERSION_4_5 == GL_TRUE || ( major == 4 && minor >= 4 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_3 = GLEW_VERSION_4_4 == GL_TRUE || ( major == 4 && minor >= 3 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_2 = GLEW_VERSION_4_3 == GL_TRUE || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_1 = GLEW_VERSION_4_2 == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_0 = GLEW_VERSION_4_1 == GL_TRUE || ( major == 4 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_3_3 = GLEW_VERSION_4_0 == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_3_2 = GLEW_VERSION_3_3 == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_3_1 = GLEW_VERSION_3_2 == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_3_0 = GLEW_VERSION_3_1 == GL_TRUE || ( major == 3 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_2_1 = GLEW_VERSION_3_0 == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_2_0 = GLEW_VERSION_2_1 == GL_TRUE || ( major == 2 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_1_5 = GLEW_VERSION_2_0 == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_1_4 = GLEW_VERSION_1_5 == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_1_3 = GLEW_VERSION_1_4 == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_1_2_1 = GLEW_VERSION_1_3 == GL_TRUE ? GL_TRUE : GL_FALSE; GLEW_VERSION_1_2 = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_1_1 = GLEW_VERSION_1_2 == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE; } /* query opengl extensions string */ extStart = glGetString(GL_EXTENSIONS); if (extStart == 0) extStart = (const GLubyte*)""; extEnd = extStart + _glewStrLen(extStart); /* initialize extensions */ #ifdef GL_VERSION_1_2 if (glewExperimental || GLEW_VERSION_1_2) GLEW_VERSION_1_2 = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_1_2 */ #ifdef GL_VERSION_1_2_1 #endif /* GL_VERSION_1_2_1 */ #ifdef GL_VERSION_1_3 if (glewExperimental || GLEW_VERSION_1_3) GLEW_VERSION_1_3 = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_1_3 */ #ifdef GL_VERSION_1_4 if (glewExperimental || GLEW_VERSION_1_4) GLEW_VERSION_1_4 = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_1_4 */ #ifdef GL_VERSION_1_5 if (glewExperimental || GLEW_VERSION_1_5) GLEW_VERSION_1_5 = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_1_5 */ #ifdef GL_VERSION_2_0 if (glewExperimental || GLEW_VERSION_2_0) GLEW_VERSION_2_0 = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_2_0 */ #ifdef GL_VERSION_2_1 if (glewExperimental || GLEW_VERSION_2_1) GLEW_VERSION_2_1 = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_2_1 */ #ifdef GL_VERSION_3_0 if (glewExperimental || GLEW_VERSION_3_0) GLEW_VERSION_3_0 = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_3_0 */ #ifdef GL_VERSION_3_1 if (glewExperimental || GLEW_VERSION_3_1) GLEW_VERSION_3_1 = !_glewInit_GL_VERSION_3_1(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_3_1 */ #ifdef GL_VERSION_3_2 if (glewExperimental || GLEW_VERSION_3_2) GLEW_VERSION_3_2 = !_glewInit_GL_VERSION_3_2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_3_2 */ #ifdef GL_VERSION_3_3 if (glewExperimental || GLEW_VERSION_3_3) GLEW_VERSION_3_3 = !_glewInit_GL_VERSION_3_3(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_3_3 */ #ifdef GL_VERSION_4_0 if (glewExperimental || GLEW_VERSION_4_0) GLEW_VERSION_4_0 = !_glewInit_GL_VERSION_4_0(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_4_0 */ #ifdef GL_VERSION_4_1 #endif /* GL_VERSION_4_1 */ #ifdef GL_VERSION_4_2 #endif /* GL_VERSION_4_2 */ #ifdef GL_VERSION_4_3 #endif /* GL_VERSION_4_3 */ #ifdef GL_VERSION_4_4 #endif /* GL_VERSION_4_4 */ #ifdef GL_VERSION_4_5 if (glewExperimental || GLEW_VERSION_4_5) GLEW_VERSION_4_5 = !_glewInit_GL_VERSION_4_5(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_VERSION_4_5 */ #ifdef GL_3DFX_multisample GLEW_3DFX_multisample = _glewSearchExtension("GL_3DFX_multisample", extStart, extEnd); #endif /* GL_3DFX_multisample */ #ifdef GL_3DFX_tbuffer GLEW_3DFX_tbuffer = _glewSearchExtension("GL_3DFX_tbuffer", extStart, extEnd); if (glewExperimental || GLEW_3DFX_tbuffer) GLEW_3DFX_tbuffer = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_3DFX_tbuffer */ #ifdef GL_3DFX_texture_compression_FXT1 GLEW_3DFX_texture_compression_FXT1 = _glewSearchExtension("GL_3DFX_texture_compression_FXT1", extStart, extEnd); #endif /* GL_3DFX_texture_compression_FXT1 */ #ifdef GL_AMD_blend_minmax_factor GLEW_AMD_blend_minmax_factor = _glewSearchExtension("GL_AMD_blend_minmax_factor", extStart, extEnd); #endif /* GL_AMD_blend_minmax_factor */ #ifdef GL_AMD_conservative_depth GLEW_AMD_conservative_depth = _glewSearchExtension("GL_AMD_conservative_depth", extStart, extEnd); #endif /* GL_AMD_conservative_depth */ #ifdef GL_AMD_debug_output GLEW_AMD_debug_output = _glewSearchExtension("GL_AMD_debug_output", extStart, extEnd); if (glewExperimental || GLEW_AMD_debug_output) GLEW_AMD_debug_output = !_glewInit_GL_AMD_debug_output(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_debug_output */ #ifdef GL_AMD_depth_clamp_separate GLEW_AMD_depth_clamp_separate = _glewSearchExtension("GL_AMD_depth_clamp_separate", extStart, extEnd); #endif /* GL_AMD_depth_clamp_separate */ #ifdef GL_AMD_draw_buffers_blend GLEW_AMD_draw_buffers_blend = _glewSearchExtension("GL_AMD_draw_buffers_blend", extStart, extEnd); if (glewExperimental || GLEW_AMD_draw_buffers_blend) GLEW_AMD_draw_buffers_blend = !_glewInit_GL_AMD_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_draw_buffers_blend */ #ifdef GL_AMD_gcn_shader GLEW_AMD_gcn_shader = _glewSearchExtension("GL_AMD_gcn_shader", extStart, extEnd); #endif /* GL_AMD_gcn_shader */ #ifdef GL_AMD_gpu_shader_int64 GLEW_AMD_gpu_shader_int64 = _glewSearchExtension("GL_AMD_gpu_shader_int64", extStart, extEnd); #endif /* GL_AMD_gpu_shader_int64 */ #ifdef GL_AMD_interleaved_elements GLEW_AMD_interleaved_elements = _glewSearchExtension("GL_AMD_interleaved_elements", extStart, extEnd); if (glewExperimental || GLEW_AMD_interleaved_elements) GLEW_AMD_interleaved_elements = !_glewInit_GL_AMD_interleaved_elements(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_interleaved_elements */ #ifdef GL_AMD_multi_draw_indirect GLEW_AMD_multi_draw_indirect = _glewSearchExtension("GL_AMD_multi_draw_indirect", extStart, extEnd); if (glewExperimental || GLEW_AMD_multi_draw_indirect) GLEW_AMD_multi_draw_indirect = !_glewInit_GL_AMD_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_multi_draw_indirect */ #ifdef GL_AMD_name_gen_delete GLEW_AMD_name_gen_delete = _glewSearchExtension("GL_AMD_name_gen_delete", extStart, extEnd); if (glewExperimental || GLEW_AMD_name_gen_delete) GLEW_AMD_name_gen_delete = !_glewInit_GL_AMD_name_gen_delete(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_name_gen_delete */ #ifdef GL_AMD_occlusion_query_event GLEW_AMD_occlusion_query_event = _glewSearchExtension("GL_AMD_occlusion_query_event", extStart, extEnd); if (glewExperimental || GLEW_AMD_occlusion_query_event) GLEW_AMD_occlusion_query_event = !_glewInit_GL_AMD_occlusion_query_event(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_occlusion_query_event */ #ifdef GL_AMD_performance_monitor GLEW_AMD_performance_monitor = _glewSearchExtension("GL_AMD_performance_monitor", extStart, extEnd); if (glewExperimental || GLEW_AMD_performance_monitor) GLEW_AMD_performance_monitor = !_glewInit_GL_AMD_performance_monitor(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_performance_monitor */ #ifdef GL_AMD_pinned_memory GLEW_AMD_pinned_memory = _glewSearchExtension("GL_AMD_pinned_memory", extStart, extEnd); #endif /* GL_AMD_pinned_memory */ #ifdef GL_AMD_query_buffer_object GLEW_AMD_query_buffer_object = _glewSearchExtension("GL_AMD_query_buffer_object", extStart, extEnd); #endif /* GL_AMD_query_buffer_object */ #ifdef GL_AMD_sample_positions GLEW_AMD_sample_positions = _glewSearchExtension("GL_AMD_sample_positions", extStart, extEnd); if (glewExperimental || GLEW_AMD_sample_positions) GLEW_AMD_sample_positions = !_glewInit_GL_AMD_sample_positions(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_sample_positions */ #ifdef GL_AMD_seamless_cubemap_per_texture GLEW_AMD_seamless_cubemap_per_texture = _glewSearchExtension("GL_AMD_seamless_cubemap_per_texture", extStart, extEnd); #endif /* GL_AMD_seamless_cubemap_per_texture */ #ifdef GL_AMD_shader_atomic_counter_ops GLEW_AMD_shader_atomic_counter_ops = _glewSearchExtension("GL_AMD_shader_atomic_counter_ops", extStart, extEnd); #endif /* GL_AMD_shader_atomic_counter_ops */ #ifdef GL_AMD_shader_stencil_export GLEW_AMD_shader_stencil_export = _glewSearchExtension("GL_AMD_shader_stencil_export", extStart, extEnd); #endif /* GL_AMD_shader_stencil_export */ #ifdef GL_AMD_shader_stencil_value_export GLEW_AMD_shader_stencil_value_export = _glewSearchExtension("GL_AMD_shader_stencil_value_export", extStart, extEnd); #endif /* GL_AMD_shader_stencil_value_export */ #ifdef GL_AMD_shader_trinary_minmax GLEW_AMD_shader_trinary_minmax = _glewSearchExtension("GL_AMD_shader_trinary_minmax", extStart, extEnd); #endif /* GL_AMD_shader_trinary_minmax */ #ifdef GL_AMD_sparse_texture GLEW_AMD_sparse_texture = _glewSearchExtension("GL_AMD_sparse_texture", extStart, extEnd); if (glewExperimental || GLEW_AMD_sparse_texture) GLEW_AMD_sparse_texture = !_glewInit_GL_AMD_sparse_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_sparse_texture */ #ifdef GL_AMD_stencil_operation_extended GLEW_AMD_stencil_operation_extended = _glewSearchExtension("GL_AMD_stencil_operation_extended", extStart, extEnd); if (glewExperimental || GLEW_AMD_stencil_operation_extended) GLEW_AMD_stencil_operation_extended = !_glewInit_GL_AMD_stencil_operation_extended(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_stencil_operation_extended */ #ifdef GL_AMD_texture_texture4 GLEW_AMD_texture_texture4 = _glewSearchExtension("GL_AMD_texture_texture4", extStart, extEnd); #endif /* GL_AMD_texture_texture4 */ #ifdef GL_AMD_transform_feedback3_lines_triangles GLEW_AMD_transform_feedback3_lines_triangles = _glewSearchExtension("GL_AMD_transform_feedback3_lines_triangles", extStart, extEnd); #endif /* GL_AMD_transform_feedback3_lines_triangles */ #ifdef GL_AMD_transform_feedback4 GLEW_AMD_transform_feedback4 = _glewSearchExtension("GL_AMD_transform_feedback4", extStart, extEnd); #endif /* GL_AMD_transform_feedback4 */ #ifdef GL_AMD_vertex_shader_layer GLEW_AMD_vertex_shader_layer = _glewSearchExtension("GL_AMD_vertex_shader_layer", extStart, extEnd); #endif /* GL_AMD_vertex_shader_layer */ #ifdef GL_AMD_vertex_shader_tessellator GLEW_AMD_vertex_shader_tessellator = _glewSearchExtension("GL_AMD_vertex_shader_tessellator", extStart, extEnd); if (glewExperimental || GLEW_AMD_vertex_shader_tessellator) GLEW_AMD_vertex_shader_tessellator = !_glewInit_GL_AMD_vertex_shader_tessellator(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_AMD_vertex_shader_tessellator */ #ifdef GL_AMD_vertex_shader_viewport_index GLEW_AMD_vertex_shader_viewport_index = _glewSearchExtension("GL_AMD_vertex_shader_viewport_index", extStart, extEnd); #endif /* GL_AMD_vertex_shader_viewport_index */ #ifdef GL_ANGLE_depth_texture GLEW_ANGLE_depth_texture = _glewSearchExtension("GL_ANGLE_depth_texture", extStart, extEnd); #endif /* GL_ANGLE_depth_texture */ #ifdef GL_ANGLE_framebuffer_blit GLEW_ANGLE_framebuffer_blit = _glewSearchExtension("GL_ANGLE_framebuffer_blit", extStart, extEnd); if (glewExperimental || GLEW_ANGLE_framebuffer_blit) GLEW_ANGLE_framebuffer_blit = !_glewInit_GL_ANGLE_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ANGLE_framebuffer_blit */ #ifdef GL_ANGLE_framebuffer_multisample GLEW_ANGLE_framebuffer_multisample = _glewSearchExtension("GL_ANGLE_framebuffer_multisample", extStart, extEnd); if (glewExperimental || GLEW_ANGLE_framebuffer_multisample) GLEW_ANGLE_framebuffer_multisample = !_glewInit_GL_ANGLE_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ANGLE_framebuffer_multisample */ #ifdef GL_ANGLE_instanced_arrays GLEW_ANGLE_instanced_arrays = _glewSearchExtension("GL_ANGLE_instanced_arrays", extStart, extEnd); if (glewExperimental || GLEW_ANGLE_instanced_arrays) GLEW_ANGLE_instanced_arrays = !_glewInit_GL_ANGLE_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ANGLE_instanced_arrays */ #ifdef GL_ANGLE_pack_reverse_row_order GLEW_ANGLE_pack_reverse_row_order = _glewSearchExtension("GL_ANGLE_pack_reverse_row_order", extStart, extEnd); #endif /* GL_ANGLE_pack_reverse_row_order */ #ifdef GL_ANGLE_program_binary GLEW_ANGLE_program_binary = _glewSearchExtension("GL_ANGLE_program_binary", extStart, extEnd); #endif /* GL_ANGLE_program_binary */ #ifdef GL_ANGLE_texture_compression_dxt1 GLEW_ANGLE_texture_compression_dxt1 = _glewSearchExtension("GL_ANGLE_texture_compression_dxt1", extStart, extEnd); #endif /* GL_ANGLE_texture_compression_dxt1 */ #ifdef GL_ANGLE_texture_compression_dxt3 GLEW_ANGLE_texture_compression_dxt3 = _glewSearchExtension("GL_ANGLE_texture_compression_dxt3", extStart, extEnd); #endif /* GL_ANGLE_texture_compression_dxt3 */ #ifdef GL_ANGLE_texture_compression_dxt5 GLEW_ANGLE_texture_compression_dxt5 = _glewSearchExtension("GL_ANGLE_texture_compression_dxt5", extStart, extEnd); #endif /* GL_ANGLE_texture_compression_dxt5 */ #ifdef GL_ANGLE_texture_usage GLEW_ANGLE_texture_usage = _glewSearchExtension("GL_ANGLE_texture_usage", extStart, extEnd); #endif /* GL_ANGLE_texture_usage */ #ifdef GL_ANGLE_timer_query GLEW_ANGLE_timer_query = _glewSearchExtension("GL_ANGLE_timer_query", extStart, extEnd); if (glewExperimental || GLEW_ANGLE_timer_query) GLEW_ANGLE_timer_query = !_glewInit_GL_ANGLE_timer_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ANGLE_timer_query */ #ifdef GL_ANGLE_translated_shader_source GLEW_ANGLE_translated_shader_source = _glewSearchExtension("GL_ANGLE_translated_shader_source", extStart, extEnd); if (glewExperimental || GLEW_ANGLE_translated_shader_source) GLEW_ANGLE_translated_shader_source = !_glewInit_GL_ANGLE_translated_shader_source(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ANGLE_translated_shader_source */ #ifdef GL_APPLE_aux_depth_stencil GLEW_APPLE_aux_depth_stencil = _glewSearchExtension("GL_APPLE_aux_depth_stencil", extStart, extEnd); #endif /* GL_APPLE_aux_depth_stencil */ #ifdef GL_APPLE_client_storage GLEW_APPLE_client_storage = _glewSearchExtension("GL_APPLE_client_storage", extStart, extEnd); #endif /* GL_APPLE_client_storage */ #ifdef GL_APPLE_element_array GLEW_APPLE_element_array = _glewSearchExtension("GL_APPLE_element_array", extStart, extEnd); if (glewExperimental || GLEW_APPLE_element_array) GLEW_APPLE_element_array = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_element_array */ #ifdef GL_APPLE_fence GLEW_APPLE_fence = _glewSearchExtension("GL_APPLE_fence", extStart, extEnd); if (glewExperimental || GLEW_APPLE_fence) GLEW_APPLE_fence = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_fence */ #ifdef GL_APPLE_float_pixels GLEW_APPLE_float_pixels = _glewSearchExtension("GL_APPLE_float_pixels", extStart, extEnd); #endif /* GL_APPLE_float_pixels */ #ifdef GL_APPLE_flush_buffer_range GLEW_APPLE_flush_buffer_range = _glewSearchExtension("GL_APPLE_flush_buffer_range", extStart, extEnd); if (glewExperimental || GLEW_APPLE_flush_buffer_range) GLEW_APPLE_flush_buffer_range = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_flush_buffer_range */ #ifdef GL_APPLE_object_purgeable GLEW_APPLE_object_purgeable = _glewSearchExtension("GL_APPLE_object_purgeable", extStart, extEnd); if (glewExperimental || GLEW_APPLE_object_purgeable) GLEW_APPLE_object_purgeable = !_glewInit_GL_APPLE_object_purgeable(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_object_purgeable */ #ifdef GL_APPLE_pixel_buffer GLEW_APPLE_pixel_buffer = _glewSearchExtension("GL_APPLE_pixel_buffer", extStart, extEnd); #endif /* GL_APPLE_pixel_buffer */ #ifdef GL_APPLE_rgb_422 GLEW_APPLE_rgb_422 = _glewSearchExtension("GL_APPLE_rgb_422", extStart, extEnd); #endif /* GL_APPLE_rgb_422 */ #ifdef GL_APPLE_row_bytes GLEW_APPLE_row_bytes = _glewSearchExtension("GL_APPLE_row_bytes", extStart, extEnd); #endif /* GL_APPLE_row_bytes */ #ifdef GL_APPLE_specular_vector GLEW_APPLE_specular_vector = _glewSearchExtension("GL_APPLE_specular_vector", extStart, extEnd); #endif /* GL_APPLE_specular_vector */ #ifdef GL_APPLE_texture_range GLEW_APPLE_texture_range = _glewSearchExtension("GL_APPLE_texture_range", extStart, extEnd); if (glewExperimental || GLEW_APPLE_texture_range) GLEW_APPLE_texture_range = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_texture_range */ #ifdef GL_APPLE_transform_hint GLEW_APPLE_transform_hint = _glewSearchExtension("GL_APPLE_transform_hint", extStart, extEnd); #endif /* GL_APPLE_transform_hint */ #ifdef GL_APPLE_vertex_array_object GLEW_APPLE_vertex_array_object = _glewSearchExtension("GL_APPLE_vertex_array_object", extStart, extEnd); if (glewExperimental || GLEW_APPLE_vertex_array_object) GLEW_APPLE_vertex_array_object = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_vertex_array_object */ #ifdef GL_APPLE_vertex_array_range GLEW_APPLE_vertex_array_range = _glewSearchExtension("GL_APPLE_vertex_array_range", extStart, extEnd); if (glewExperimental || GLEW_APPLE_vertex_array_range) GLEW_APPLE_vertex_array_range = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_vertex_array_range */ #ifdef GL_APPLE_vertex_program_evaluators GLEW_APPLE_vertex_program_evaluators = _glewSearchExtension("GL_APPLE_vertex_program_evaluators", extStart, extEnd); if (glewExperimental || GLEW_APPLE_vertex_program_evaluators) GLEW_APPLE_vertex_program_evaluators = !_glewInit_GL_APPLE_vertex_program_evaluators(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_APPLE_vertex_program_evaluators */ #ifdef GL_APPLE_ycbcr_422 GLEW_APPLE_ycbcr_422 = _glewSearchExtension("GL_APPLE_ycbcr_422", extStart, extEnd); #endif /* GL_APPLE_ycbcr_422 */ #ifdef GL_ARB_ES2_compatibility GLEW_ARB_ES2_compatibility = _glewSearchExtension("GL_ARB_ES2_compatibility", extStart, extEnd); if (glewExperimental || GLEW_ARB_ES2_compatibility) GLEW_ARB_ES2_compatibility = !_glewInit_GL_ARB_ES2_compatibility(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_ES2_compatibility */ #ifdef GL_ARB_ES3_1_compatibility GLEW_ARB_ES3_1_compatibility = _glewSearchExtension("GL_ARB_ES3_1_compatibility", extStart, extEnd); if (glewExperimental || GLEW_ARB_ES3_1_compatibility) GLEW_ARB_ES3_1_compatibility = !_glewInit_GL_ARB_ES3_1_compatibility(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_ES3_1_compatibility */ #ifdef GL_ARB_ES3_2_compatibility GLEW_ARB_ES3_2_compatibility = _glewSearchExtension("GL_ARB_ES3_2_compatibility", extStart, extEnd); if (glewExperimental || GLEW_ARB_ES3_2_compatibility) GLEW_ARB_ES3_2_compatibility = !_glewInit_GL_ARB_ES3_2_compatibility(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_ES3_2_compatibility */ #ifdef GL_ARB_ES3_compatibility GLEW_ARB_ES3_compatibility = _glewSearchExtension("GL_ARB_ES3_compatibility", extStart, extEnd); #endif /* GL_ARB_ES3_compatibility */ #ifdef GL_ARB_arrays_of_arrays GLEW_ARB_arrays_of_arrays = _glewSearchExtension("GL_ARB_arrays_of_arrays", extStart, extEnd); #endif /* GL_ARB_arrays_of_arrays */ #ifdef GL_ARB_base_instance GLEW_ARB_base_instance = _glewSearchExtension("GL_ARB_base_instance", extStart, extEnd); if (glewExperimental || GLEW_ARB_base_instance) GLEW_ARB_base_instance = !_glewInit_GL_ARB_base_instance(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_base_instance */ #ifdef GL_ARB_bindless_texture GLEW_ARB_bindless_texture = _glewSearchExtension("GL_ARB_bindless_texture", extStart, extEnd); if (glewExperimental || GLEW_ARB_bindless_texture) GLEW_ARB_bindless_texture = !_glewInit_GL_ARB_bindless_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_bindless_texture */ #ifdef GL_ARB_blend_func_extended GLEW_ARB_blend_func_extended = _glewSearchExtension("GL_ARB_blend_func_extended", extStart, extEnd); if (glewExperimental || GLEW_ARB_blend_func_extended) GLEW_ARB_blend_func_extended = !_glewInit_GL_ARB_blend_func_extended(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_blend_func_extended */ #ifdef GL_ARB_buffer_storage GLEW_ARB_buffer_storage = _glewSearchExtension("GL_ARB_buffer_storage", extStart, extEnd); if (glewExperimental || GLEW_ARB_buffer_storage) GLEW_ARB_buffer_storage = !_glewInit_GL_ARB_buffer_storage(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_buffer_storage */ #ifdef GL_ARB_cl_event GLEW_ARB_cl_event = _glewSearchExtension("GL_ARB_cl_event", extStart, extEnd); if (glewExperimental || GLEW_ARB_cl_event) GLEW_ARB_cl_event = !_glewInit_GL_ARB_cl_event(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_cl_event */ #ifdef GL_ARB_clear_buffer_object GLEW_ARB_clear_buffer_object = _glewSearchExtension("GL_ARB_clear_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_clear_buffer_object) GLEW_ARB_clear_buffer_object = !_glewInit_GL_ARB_clear_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_clear_buffer_object */ #ifdef GL_ARB_clear_texture GLEW_ARB_clear_texture = _glewSearchExtension("GL_ARB_clear_texture", extStart, extEnd); if (glewExperimental || GLEW_ARB_clear_texture) GLEW_ARB_clear_texture = !_glewInit_GL_ARB_clear_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_clear_texture */ #ifdef GL_ARB_clip_control GLEW_ARB_clip_control = _glewSearchExtension("GL_ARB_clip_control", extStart, extEnd); if (glewExperimental || GLEW_ARB_clip_control) GLEW_ARB_clip_control = !_glewInit_GL_ARB_clip_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_clip_control */ #ifdef GL_ARB_color_buffer_float GLEW_ARB_color_buffer_float = _glewSearchExtension("GL_ARB_color_buffer_float", extStart, extEnd); if (glewExperimental || GLEW_ARB_color_buffer_float) GLEW_ARB_color_buffer_float = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_color_buffer_float */ #ifdef GL_ARB_compatibility GLEW_ARB_compatibility = _glewSearchExtension("GL_ARB_compatibility", extStart, extEnd); #endif /* GL_ARB_compatibility */ #ifdef GL_ARB_compressed_texture_pixel_storage GLEW_ARB_compressed_texture_pixel_storage = _glewSearchExtension("GL_ARB_compressed_texture_pixel_storage", extStart, extEnd); #endif /* GL_ARB_compressed_texture_pixel_storage */ #ifdef GL_ARB_compute_shader GLEW_ARB_compute_shader = _glewSearchExtension("GL_ARB_compute_shader", extStart, extEnd); if (glewExperimental || GLEW_ARB_compute_shader) GLEW_ARB_compute_shader = !_glewInit_GL_ARB_compute_shader(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_compute_shader */ #ifdef GL_ARB_compute_variable_group_size GLEW_ARB_compute_variable_group_size = _glewSearchExtension("GL_ARB_compute_variable_group_size", extStart, extEnd); if (glewExperimental || GLEW_ARB_compute_variable_group_size) GLEW_ARB_compute_variable_group_size = !_glewInit_GL_ARB_compute_variable_group_size(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_compute_variable_group_size */ #ifdef GL_ARB_conditional_render_inverted GLEW_ARB_conditional_render_inverted = _glewSearchExtension("GL_ARB_conditional_render_inverted", extStart, extEnd); #endif /* GL_ARB_conditional_render_inverted */ #ifdef GL_ARB_conservative_depth GLEW_ARB_conservative_depth = _glewSearchExtension("GL_ARB_conservative_depth", extStart, extEnd); #endif /* GL_ARB_conservative_depth */ #ifdef GL_ARB_copy_buffer GLEW_ARB_copy_buffer = _glewSearchExtension("GL_ARB_copy_buffer", extStart, extEnd); if (glewExperimental || GLEW_ARB_copy_buffer) GLEW_ARB_copy_buffer = !_glewInit_GL_ARB_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_copy_buffer */ #ifdef GL_ARB_copy_image GLEW_ARB_copy_image = _glewSearchExtension("GL_ARB_copy_image", extStart, extEnd); if (glewExperimental || GLEW_ARB_copy_image) GLEW_ARB_copy_image = !_glewInit_GL_ARB_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_copy_image */ #ifdef GL_ARB_cull_distance GLEW_ARB_cull_distance = _glewSearchExtension("GL_ARB_cull_distance", extStart, extEnd); #endif /* GL_ARB_cull_distance */ #ifdef GL_ARB_debug_output GLEW_ARB_debug_output = _glewSearchExtension("GL_ARB_debug_output", extStart, extEnd); if (glewExperimental || GLEW_ARB_debug_output) GLEW_ARB_debug_output = !_glewInit_GL_ARB_debug_output(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_debug_output */ #ifdef GL_ARB_depth_buffer_float GLEW_ARB_depth_buffer_float = _glewSearchExtension("GL_ARB_depth_buffer_float", extStart, extEnd); #endif /* GL_ARB_depth_buffer_float */ #ifdef GL_ARB_depth_clamp GLEW_ARB_depth_clamp = _glewSearchExtension("GL_ARB_depth_clamp", extStart, extEnd); #endif /* GL_ARB_depth_clamp */ #ifdef GL_ARB_depth_texture GLEW_ARB_depth_texture = _glewSearchExtension("GL_ARB_depth_texture", extStart, extEnd); #endif /* GL_ARB_depth_texture */ #ifdef GL_ARB_derivative_control GLEW_ARB_derivative_control = _glewSearchExtension("GL_ARB_derivative_control", extStart, extEnd); #endif /* GL_ARB_derivative_control */ #ifdef GL_ARB_direct_state_access GLEW_ARB_direct_state_access = _glewSearchExtension("GL_ARB_direct_state_access", extStart, extEnd); if (glewExperimental || GLEW_ARB_direct_state_access) GLEW_ARB_direct_state_access = !_glewInit_GL_ARB_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_direct_state_access */ #ifdef GL_ARB_draw_buffers GLEW_ARB_draw_buffers = _glewSearchExtension("GL_ARB_draw_buffers", extStart, extEnd); if (glewExperimental || GLEW_ARB_draw_buffers) GLEW_ARB_draw_buffers = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_draw_buffers */ #ifdef GL_ARB_draw_buffers_blend GLEW_ARB_draw_buffers_blend = _glewSearchExtension("GL_ARB_draw_buffers_blend", extStart, extEnd); if (glewExperimental || GLEW_ARB_draw_buffers_blend) GLEW_ARB_draw_buffers_blend = !_glewInit_GL_ARB_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_draw_buffers_blend */ #ifdef GL_ARB_draw_elements_base_vertex GLEW_ARB_draw_elements_base_vertex = _glewSearchExtension("GL_ARB_draw_elements_base_vertex", extStart, extEnd); if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) GLEW_ARB_draw_elements_base_vertex = !_glewInit_GL_ARB_draw_elements_base_vertex(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_draw_elements_base_vertex */ #ifdef GL_ARB_draw_indirect GLEW_ARB_draw_indirect = _glewSearchExtension("GL_ARB_draw_indirect", extStart, extEnd); if (glewExperimental || GLEW_ARB_draw_indirect) GLEW_ARB_draw_indirect = !_glewInit_GL_ARB_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_draw_indirect */ #ifdef GL_ARB_draw_instanced GLEW_ARB_draw_instanced = _glewSearchExtension("GL_ARB_draw_instanced", extStart, extEnd); #endif /* GL_ARB_draw_instanced */ #ifdef GL_ARB_enhanced_layouts GLEW_ARB_enhanced_layouts = _glewSearchExtension("GL_ARB_enhanced_layouts", extStart, extEnd); #endif /* GL_ARB_enhanced_layouts */ #ifdef GL_ARB_explicit_attrib_location GLEW_ARB_explicit_attrib_location = _glewSearchExtension("GL_ARB_explicit_attrib_location", extStart, extEnd); #endif /* GL_ARB_explicit_attrib_location */ #ifdef GL_ARB_explicit_uniform_location GLEW_ARB_explicit_uniform_location = _glewSearchExtension("GL_ARB_explicit_uniform_location", extStart, extEnd); #endif /* GL_ARB_explicit_uniform_location */ #ifdef GL_ARB_fragment_coord_conventions GLEW_ARB_fragment_coord_conventions = _glewSearchExtension("GL_ARB_fragment_coord_conventions", extStart, extEnd); #endif /* GL_ARB_fragment_coord_conventions */ #ifdef GL_ARB_fragment_layer_viewport GLEW_ARB_fragment_layer_viewport = _glewSearchExtension("GL_ARB_fragment_layer_viewport", extStart, extEnd); #endif /* GL_ARB_fragment_layer_viewport */ #ifdef GL_ARB_fragment_program GLEW_ARB_fragment_program = _glewSearchExtension("GL_ARB_fragment_program", extStart, extEnd); #endif /* GL_ARB_fragment_program */ #ifdef GL_ARB_fragment_program_shadow GLEW_ARB_fragment_program_shadow = _glewSearchExtension("GL_ARB_fragment_program_shadow", extStart, extEnd); #endif /* GL_ARB_fragment_program_shadow */ #ifdef GL_ARB_fragment_shader GLEW_ARB_fragment_shader = _glewSearchExtension("GL_ARB_fragment_shader", extStart, extEnd); #endif /* GL_ARB_fragment_shader */ #ifdef GL_ARB_fragment_shader_interlock GLEW_ARB_fragment_shader_interlock = _glewSearchExtension("GL_ARB_fragment_shader_interlock", extStart, extEnd); #endif /* GL_ARB_fragment_shader_interlock */ #ifdef GL_ARB_framebuffer_no_attachments GLEW_ARB_framebuffer_no_attachments = _glewSearchExtension("GL_ARB_framebuffer_no_attachments", extStart, extEnd); if (glewExperimental || GLEW_ARB_framebuffer_no_attachments) GLEW_ARB_framebuffer_no_attachments = !_glewInit_GL_ARB_framebuffer_no_attachments(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_framebuffer_no_attachments */ #ifdef GL_ARB_framebuffer_object GLEW_ARB_framebuffer_object = _glewSearchExtension("GL_ARB_framebuffer_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_framebuffer_object) GLEW_ARB_framebuffer_object = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_framebuffer_object */ #ifdef GL_ARB_framebuffer_sRGB GLEW_ARB_framebuffer_sRGB = _glewSearchExtension("GL_ARB_framebuffer_sRGB", extStart, extEnd); #endif /* GL_ARB_framebuffer_sRGB */ #ifdef GL_ARB_geometry_shader4 GLEW_ARB_geometry_shader4 = _glewSearchExtension("GL_ARB_geometry_shader4", extStart, extEnd); if (glewExperimental || GLEW_ARB_geometry_shader4) GLEW_ARB_geometry_shader4 = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_geometry_shader4 */ #ifdef GL_ARB_get_program_binary GLEW_ARB_get_program_binary = _glewSearchExtension("GL_ARB_get_program_binary", extStart, extEnd); if (glewExperimental || GLEW_ARB_get_program_binary) GLEW_ARB_get_program_binary = !_glewInit_GL_ARB_get_program_binary(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_get_program_binary */ #ifdef GL_ARB_get_texture_sub_image GLEW_ARB_get_texture_sub_image = _glewSearchExtension("GL_ARB_get_texture_sub_image", extStart, extEnd); if (glewExperimental || GLEW_ARB_get_texture_sub_image) GLEW_ARB_get_texture_sub_image = !_glewInit_GL_ARB_get_texture_sub_image(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_get_texture_sub_image */ #ifdef GL_ARB_gpu_shader5 GLEW_ARB_gpu_shader5 = _glewSearchExtension("GL_ARB_gpu_shader5", extStart, extEnd); #endif /* GL_ARB_gpu_shader5 */ #ifdef GL_ARB_gpu_shader_fp64 GLEW_ARB_gpu_shader_fp64 = _glewSearchExtension("GL_ARB_gpu_shader_fp64", extStart, extEnd); if (glewExperimental || GLEW_ARB_gpu_shader_fp64) GLEW_ARB_gpu_shader_fp64 = !_glewInit_GL_ARB_gpu_shader_fp64(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_gpu_shader_fp64 */ #ifdef GL_ARB_gpu_shader_int64 GLEW_ARB_gpu_shader_int64 = _glewSearchExtension("GL_ARB_gpu_shader_int64", extStart, extEnd); if (glewExperimental || GLEW_ARB_gpu_shader_int64) GLEW_ARB_gpu_shader_int64 = !_glewInit_GL_ARB_gpu_shader_int64(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_gpu_shader_int64 */ #ifdef GL_ARB_half_float_pixel GLEW_ARB_half_float_pixel = _glewSearchExtension("GL_ARB_half_float_pixel", extStart, extEnd); #endif /* GL_ARB_half_float_pixel */ #ifdef GL_ARB_half_float_vertex GLEW_ARB_half_float_vertex = _glewSearchExtension("GL_ARB_half_float_vertex", extStart, extEnd); #endif /* GL_ARB_half_float_vertex */ #ifdef GL_ARB_imaging GLEW_ARB_imaging = _glewSearchExtension("GL_ARB_imaging", extStart, extEnd); if (glewExperimental || GLEW_ARB_imaging) GLEW_ARB_imaging = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_imaging */ #ifdef GL_ARB_indirect_parameters GLEW_ARB_indirect_parameters = _glewSearchExtension("GL_ARB_indirect_parameters", extStart, extEnd); if (glewExperimental || GLEW_ARB_indirect_parameters) GLEW_ARB_indirect_parameters = !_glewInit_GL_ARB_indirect_parameters(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_indirect_parameters */ #ifdef GL_ARB_instanced_arrays GLEW_ARB_instanced_arrays = _glewSearchExtension("GL_ARB_instanced_arrays", extStart, extEnd); if (glewExperimental || GLEW_ARB_instanced_arrays) GLEW_ARB_instanced_arrays = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_instanced_arrays */ #ifdef GL_ARB_internalformat_query GLEW_ARB_internalformat_query = _glewSearchExtension("GL_ARB_internalformat_query", extStart, extEnd); if (glewExperimental || GLEW_ARB_internalformat_query) GLEW_ARB_internalformat_query = !_glewInit_GL_ARB_internalformat_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_internalformat_query */ #ifdef GL_ARB_internalformat_query2 GLEW_ARB_internalformat_query2 = _glewSearchExtension("GL_ARB_internalformat_query2", extStart, extEnd); if (glewExperimental || GLEW_ARB_internalformat_query2) GLEW_ARB_internalformat_query2 = !_glewInit_GL_ARB_internalformat_query2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_internalformat_query2 */ #ifdef GL_ARB_invalidate_subdata GLEW_ARB_invalidate_subdata = _glewSearchExtension("GL_ARB_invalidate_subdata", extStart, extEnd); if (glewExperimental || GLEW_ARB_invalidate_subdata) GLEW_ARB_invalidate_subdata = !_glewInit_GL_ARB_invalidate_subdata(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_invalidate_subdata */ #ifdef GL_ARB_map_buffer_alignment GLEW_ARB_map_buffer_alignment = _glewSearchExtension("GL_ARB_map_buffer_alignment", extStart, extEnd); #endif /* GL_ARB_map_buffer_alignment */ #ifdef GL_ARB_map_buffer_range GLEW_ARB_map_buffer_range = _glewSearchExtension("GL_ARB_map_buffer_range", extStart, extEnd); if (glewExperimental || GLEW_ARB_map_buffer_range) GLEW_ARB_map_buffer_range = !_glewInit_GL_ARB_map_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_map_buffer_range */ #ifdef GL_ARB_matrix_palette GLEW_ARB_matrix_palette = _glewSearchExtension("GL_ARB_matrix_palette", extStart, extEnd); if (glewExperimental || GLEW_ARB_matrix_palette) GLEW_ARB_matrix_palette = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_matrix_palette */ #ifdef GL_ARB_multi_bind GLEW_ARB_multi_bind = _glewSearchExtension("GL_ARB_multi_bind", extStart, extEnd); if (glewExperimental || GLEW_ARB_multi_bind) GLEW_ARB_multi_bind = !_glewInit_GL_ARB_multi_bind(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_multi_bind */ #ifdef GL_ARB_multi_draw_indirect GLEW_ARB_multi_draw_indirect = _glewSearchExtension("GL_ARB_multi_draw_indirect", extStart, extEnd); if (glewExperimental || GLEW_ARB_multi_draw_indirect) GLEW_ARB_multi_draw_indirect = !_glewInit_GL_ARB_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_multi_draw_indirect */ #ifdef GL_ARB_multisample GLEW_ARB_multisample = _glewSearchExtension("GL_ARB_multisample", extStart, extEnd); if (glewExperimental || GLEW_ARB_multisample) GLEW_ARB_multisample = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_multisample */ #ifdef GL_ARB_multitexture GLEW_ARB_multitexture = _glewSearchExtension("GL_ARB_multitexture", extStart, extEnd); if (glewExperimental || GLEW_ARB_multitexture) GLEW_ARB_multitexture = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_multitexture */ #ifdef GL_ARB_occlusion_query GLEW_ARB_occlusion_query = _glewSearchExtension("GL_ARB_occlusion_query", extStart, extEnd); if (glewExperimental || GLEW_ARB_occlusion_query) GLEW_ARB_occlusion_query = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_occlusion_query */ #ifdef GL_ARB_occlusion_query2 GLEW_ARB_occlusion_query2 = _glewSearchExtension("GL_ARB_occlusion_query2", extStart, extEnd); #endif /* GL_ARB_occlusion_query2 */ #ifdef GL_ARB_parallel_shader_compile GLEW_ARB_parallel_shader_compile = _glewSearchExtension("GL_ARB_parallel_shader_compile", extStart, extEnd); if (glewExperimental || GLEW_ARB_parallel_shader_compile) GLEW_ARB_parallel_shader_compile = !_glewInit_GL_ARB_parallel_shader_compile(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_parallel_shader_compile */ #ifdef GL_ARB_pipeline_statistics_query GLEW_ARB_pipeline_statistics_query = _glewSearchExtension("GL_ARB_pipeline_statistics_query", extStart, extEnd); #endif /* GL_ARB_pipeline_statistics_query */ #ifdef GL_ARB_pixel_buffer_object GLEW_ARB_pixel_buffer_object = _glewSearchExtension("GL_ARB_pixel_buffer_object", extStart, extEnd); #endif /* GL_ARB_pixel_buffer_object */ #ifdef GL_ARB_point_parameters GLEW_ARB_point_parameters = _glewSearchExtension("GL_ARB_point_parameters", extStart, extEnd); if (glewExperimental || GLEW_ARB_point_parameters) GLEW_ARB_point_parameters = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_point_parameters */ #ifdef GL_ARB_point_sprite GLEW_ARB_point_sprite = _glewSearchExtension("GL_ARB_point_sprite", extStart, extEnd); #endif /* GL_ARB_point_sprite */ #ifdef GL_ARB_post_depth_coverage GLEW_ARB_post_depth_coverage = _glewSearchExtension("GL_ARB_post_depth_coverage", extStart, extEnd); #endif /* GL_ARB_post_depth_coverage */ #ifdef GL_ARB_program_interface_query GLEW_ARB_program_interface_query = _glewSearchExtension("GL_ARB_program_interface_query", extStart, extEnd); if (glewExperimental || GLEW_ARB_program_interface_query) GLEW_ARB_program_interface_query = !_glewInit_GL_ARB_program_interface_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_program_interface_query */ #ifdef GL_ARB_provoking_vertex GLEW_ARB_provoking_vertex = _glewSearchExtension("GL_ARB_provoking_vertex", extStart, extEnd); if (glewExperimental || GLEW_ARB_provoking_vertex) GLEW_ARB_provoking_vertex = !_glewInit_GL_ARB_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_provoking_vertex */ #ifdef GL_ARB_query_buffer_object GLEW_ARB_query_buffer_object = _glewSearchExtension("GL_ARB_query_buffer_object", extStart, extEnd); #endif /* GL_ARB_query_buffer_object */ #ifdef GL_ARB_robust_buffer_access_behavior GLEW_ARB_robust_buffer_access_behavior = _glewSearchExtension("GL_ARB_robust_buffer_access_behavior", extStart, extEnd); #endif /* GL_ARB_robust_buffer_access_behavior */ #ifdef GL_ARB_robustness GLEW_ARB_robustness = _glewSearchExtension("GL_ARB_robustness", extStart, extEnd); if (glewExperimental || GLEW_ARB_robustness) GLEW_ARB_robustness = !_glewInit_GL_ARB_robustness(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_robustness */ #ifdef GL_ARB_robustness_application_isolation GLEW_ARB_robustness_application_isolation = _glewSearchExtension("GL_ARB_robustness_application_isolation", extStart, extEnd); #endif /* GL_ARB_robustness_application_isolation */ #ifdef GL_ARB_robustness_share_group_isolation GLEW_ARB_robustness_share_group_isolation = _glewSearchExtension("GL_ARB_robustness_share_group_isolation", extStart, extEnd); #endif /* GL_ARB_robustness_share_group_isolation */ #ifdef GL_ARB_sample_locations GLEW_ARB_sample_locations = _glewSearchExtension("GL_ARB_sample_locations", extStart, extEnd); if (glewExperimental || GLEW_ARB_sample_locations) GLEW_ARB_sample_locations = !_glewInit_GL_ARB_sample_locations(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_sample_locations */ #ifdef GL_ARB_sample_shading GLEW_ARB_sample_shading = _glewSearchExtension("GL_ARB_sample_shading", extStart, extEnd); if (glewExperimental || GLEW_ARB_sample_shading) GLEW_ARB_sample_shading = !_glewInit_GL_ARB_sample_shading(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_sample_shading */ #ifdef GL_ARB_sampler_objects GLEW_ARB_sampler_objects = _glewSearchExtension("GL_ARB_sampler_objects", extStart, extEnd); if (glewExperimental || GLEW_ARB_sampler_objects) GLEW_ARB_sampler_objects = !_glewInit_GL_ARB_sampler_objects(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_sampler_objects */ #ifdef GL_ARB_seamless_cube_map GLEW_ARB_seamless_cube_map = _glewSearchExtension("GL_ARB_seamless_cube_map", extStart, extEnd); #endif /* GL_ARB_seamless_cube_map */ #ifdef GL_ARB_seamless_cubemap_per_texture GLEW_ARB_seamless_cubemap_per_texture = _glewSearchExtension("GL_ARB_seamless_cubemap_per_texture", extStart, extEnd); #endif /* GL_ARB_seamless_cubemap_per_texture */ #ifdef GL_ARB_separate_shader_objects GLEW_ARB_separate_shader_objects = _glewSearchExtension("GL_ARB_separate_shader_objects", extStart, extEnd); if (glewExperimental || GLEW_ARB_separate_shader_objects) GLEW_ARB_separate_shader_objects = !_glewInit_GL_ARB_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_separate_shader_objects */ #ifdef GL_ARB_shader_atomic_counter_ops GLEW_ARB_shader_atomic_counter_ops = _glewSearchExtension("GL_ARB_shader_atomic_counter_ops", extStart, extEnd); #endif /* GL_ARB_shader_atomic_counter_ops */ #ifdef GL_ARB_shader_atomic_counters GLEW_ARB_shader_atomic_counters = _glewSearchExtension("GL_ARB_shader_atomic_counters", extStart, extEnd); if (glewExperimental || GLEW_ARB_shader_atomic_counters) GLEW_ARB_shader_atomic_counters = !_glewInit_GL_ARB_shader_atomic_counters(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_shader_atomic_counters */ #ifdef GL_ARB_shader_ballot GLEW_ARB_shader_ballot = _glewSearchExtension("GL_ARB_shader_ballot", extStart, extEnd); #endif /* GL_ARB_shader_ballot */ #ifdef GL_ARB_shader_bit_encoding GLEW_ARB_shader_bit_encoding = _glewSearchExtension("GL_ARB_shader_bit_encoding", extStart, extEnd); #endif /* GL_ARB_shader_bit_encoding */ #ifdef GL_ARB_shader_clock GLEW_ARB_shader_clock = _glewSearchExtension("GL_ARB_shader_clock", extStart, extEnd); #endif /* GL_ARB_shader_clock */ #ifdef GL_ARB_shader_draw_parameters GLEW_ARB_shader_draw_parameters = _glewSearchExtension("GL_ARB_shader_draw_parameters", extStart, extEnd); #endif /* GL_ARB_shader_draw_parameters */ #ifdef GL_ARB_shader_group_vote GLEW_ARB_shader_group_vote = _glewSearchExtension("GL_ARB_shader_group_vote", extStart, extEnd); #endif /* GL_ARB_shader_group_vote */ #ifdef GL_ARB_shader_image_load_store GLEW_ARB_shader_image_load_store = _glewSearchExtension("GL_ARB_shader_image_load_store", extStart, extEnd); if (glewExperimental || GLEW_ARB_shader_image_load_store) GLEW_ARB_shader_image_load_store = !_glewInit_GL_ARB_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_shader_image_load_store */ #ifdef GL_ARB_shader_image_size GLEW_ARB_shader_image_size = _glewSearchExtension("GL_ARB_shader_image_size", extStart, extEnd); #endif /* GL_ARB_shader_image_size */ #ifdef GL_ARB_shader_objects GLEW_ARB_shader_objects = _glewSearchExtension("GL_ARB_shader_objects", extStart, extEnd); if (glewExperimental || GLEW_ARB_shader_objects) GLEW_ARB_shader_objects = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_shader_objects */ #ifdef GL_ARB_shader_precision GLEW_ARB_shader_precision = _glewSearchExtension("GL_ARB_shader_precision", extStart, extEnd); #endif /* GL_ARB_shader_precision */ #ifdef GL_ARB_shader_stencil_export GLEW_ARB_shader_stencil_export = _glewSearchExtension("GL_ARB_shader_stencil_export", extStart, extEnd); #endif /* GL_ARB_shader_stencil_export */ #ifdef GL_ARB_shader_storage_buffer_object GLEW_ARB_shader_storage_buffer_object = _glewSearchExtension("GL_ARB_shader_storage_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_shader_storage_buffer_object) GLEW_ARB_shader_storage_buffer_object = !_glewInit_GL_ARB_shader_storage_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_shader_storage_buffer_object */ #ifdef GL_ARB_shader_subroutine GLEW_ARB_shader_subroutine = _glewSearchExtension("GL_ARB_shader_subroutine", extStart, extEnd); if (glewExperimental || GLEW_ARB_shader_subroutine) GLEW_ARB_shader_subroutine = !_glewInit_GL_ARB_shader_subroutine(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_shader_subroutine */ #ifdef GL_ARB_shader_texture_image_samples GLEW_ARB_shader_texture_image_samples = _glewSearchExtension("GL_ARB_shader_texture_image_samples", extStart, extEnd); #endif /* GL_ARB_shader_texture_image_samples */ #ifdef GL_ARB_shader_texture_lod GLEW_ARB_shader_texture_lod = _glewSearchExtension("GL_ARB_shader_texture_lod", extStart, extEnd); #endif /* GL_ARB_shader_texture_lod */ #ifdef GL_ARB_shader_viewport_layer_array GLEW_ARB_shader_viewport_layer_array = _glewSearchExtension("GL_ARB_shader_viewport_layer_array", extStart, extEnd); #endif /* GL_ARB_shader_viewport_layer_array */ #ifdef GL_ARB_shading_language_100 GLEW_ARB_shading_language_100 = _glewSearchExtension("GL_ARB_shading_language_100", extStart, extEnd); #endif /* GL_ARB_shading_language_100 */ #ifdef GL_ARB_shading_language_420pack GLEW_ARB_shading_language_420pack = _glewSearchExtension("GL_ARB_shading_language_420pack", extStart, extEnd); #endif /* GL_ARB_shading_language_420pack */ #ifdef GL_ARB_shading_language_include GLEW_ARB_shading_language_include = _glewSearchExtension("GL_ARB_shading_language_include", extStart, extEnd); if (glewExperimental || GLEW_ARB_shading_language_include) GLEW_ARB_shading_language_include = !_glewInit_GL_ARB_shading_language_include(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_shading_language_include */ #ifdef GL_ARB_shading_language_packing GLEW_ARB_shading_language_packing = _glewSearchExtension("GL_ARB_shading_language_packing", extStart, extEnd); #endif /* GL_ARB_shading_language_packing */ #ifdef GL_ARB_shadow GLEW_ARB_shadow = _glewSearchExtension("GL_ARB_shadow", extStart, extEnd); #endif /* GL_ARB_shadow */ #ifdef GL_ARB_shadow_ambient GLEW_ARB_shadow_ambient = _glewSearchExtension("GL_ARB_shadow_ambient", extStart, extEnd); #endif /* GL_ARB_shadow_ambient */ #ifdef GL_ARB_sparse_buffer GLEW_ARB_sparse_buffer = _glewSearchExtension("GL_ARB_sparse_buffer", extStart, extEnd); if (glewExperimental || GLEW_ARB_sparse_buffer) GLEW_ARB_sparse_buffer = !_glewInit_GL_ARB_sparse_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_sparse_buffer */ #ifdef GL_ARB_sparse_texture GLEW_ARB_sparse_texture = _glewSearchExtension("GL_ARB_sparse_texture", extStart, extEnd); if (glewExperimental || GLEW_ARB_sparse_texture) GLEW_ARB_sparse_texture = !_glewInit_GL_ARB_sparse_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_sparse_texture */ #ifdef GL_ARB_sparse_texture2 GLEW_ARB_sparse_texture2 = _glewSearchExtension("GL_ARB_sparse_texture2", extStart, extEnd); #endif /* GL_ARB_sparse_texture2 */ #ifdef GL_ARB_sparse_texture_clamp GLEW_ARB_sparse_texture_clamp = _glewSearchExtension("GL_ARB_sparse_texture_clamp", extStart, extEnd); #endif /* GL_ARB_sparse_texture_clamp */ #ifdef GL_ARB_stencil_texturing GLEW_ARB_stencil_texturing = _glewSearchExtension("GL_ARB_stencil_texturing", extStart, extEnd); #endif /* GL_ARB_stencil_texturing */ #ifdef GL_ARB_sync GLEW_ARB_sync = _glewSearchExtension("GL_ARB_sync", extStart, extEnd); if (glewExperimental || GLEW_ARB_sync) GLEW_ARB_sync = !_glewInit_GL_ARB_sync(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_sync */ #ifdef GL_ARB_tessellation_shader GLEW_ARB_tessellation_shader = _glewSearchExtension("GL_ARB_tessellation_shader", extStart, extEnd); if (glewExperimental || GLEW_ARB_tessellation_shader) GLEW_ARB_tessellation_shader = !_glewInit_GL_ARB_tessellation_shader(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_tessellation_shader */ #ifdef GL_ARB_texture_barrier GLEW_ARB_texture_barrier = _glewSearchExtension("GL_ARB_texture_barrier", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_barrier) GLEW_ARB_texture_barrier = !_glewInit_GL_ARB_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_barrier */ #ifdef GL_ARB_texture_border_clamp GLEW_ARB_texture_border_clamp = _glewSearchExtension("GL_ARB_texture_border_clamp", extStart, extEnd); #endif /* GL_ARB_texture_border_clamp */ #ifdef GL_ARB_texture_buffer_object GLEW_ARB_texture_buffer_object = _glewSearchExtension("GL_ARB_texture_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_buffer_object) GLEW_ARB_texture_buffer_object = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_buffer_object */ #ifdef GL_ARB_texture_buffer_object_rgb32 GLEW_ARB_texture_buffer_object_rgb32 = _glewSearchExtension("GL_ARB_texture_buffer_object_rgb32", extStart, extEnd); #endif /* GL_ARB_texture_buffer_object_rgb32 */ #ifdef GL_ARB_texture_buffer_range GLEW_ARB_texture_buffer_range = _glewSearchExtension("GL_ARB_texture_buffer_range", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_buffer_range) GLEW_ARB_texture_buffer_range = !_glewInit_GL_ARB_texture_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_buffer_range */ #ifdef GL_ARB_texture_compression GLEW_ARB_texture_compression = _glewSearchExtension("GL_ARB_texture_compression", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_compression) GLEW_ARB_texture_compression = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_compression */ #ifdef GL_ARB_texture_compression_bptc GLEW_ARB_texture_compression_bptc = _glewSearchExtension("GL_ARB_texture_compression_bptc", extStart, extEnd); #endif /* GL_ARB_texture_compression_bptc */ #ifdef GL_ARB_texture_compression_rgtc GLEW_ARB_texture_compression_rgtc = _glewSearchExtension("GL_ARB_texture_compression_rgtc", extStart, extEnd); #endif /* GL_ARB_texture_compression_rgtc */ #ifdef GL_ARB_texture_cube_map GLEW_ARB_texture_cube_map = _glewSearchExtension("GL_ARB_texture_cube_map", extStart, extEnd); #endif /* GL_ARB_texture_cube_map */ #ifdef GL_ARB_texture_cube_map_array GLEW_ARB_texture_cube_map_array = _glewSearchExtension("GL_ARB_texture_cube_map_array", extStart, extEnd); #endif /* GL_ARB_texture_cube_map_array */ #ifdef GL_ARB_texture_env_add GLEW_ARB_texture_env_add = _glewSearchExtension("GL_ARB_texture_env_add", extStart, extEnd); #endif /* GL_ARB_texture_env_add */ #ifdef GL_ARB_texture_env_combine GLEW_ARB_texture_env_combine = _glewSearchExtension("GL_ARB_texture_env_combine", extStart, extEnd); #endif /* GL_ARB_texture_env_combine */ #ifdef GL_ARB_texture_env_crossbar GLEW_ARB_texture_env_crossbar = _glewSearchExtension("GL_ARB_texture_env_crossbar", extStart, extEnd); #endif /* GL_ARB_texture_env_crossbar */ #ifdef GL_ARB_texture_env_dot3 GLEW_ARB_texture_env_dot3 = _glewSearchExtension("GL_ARB_texture_env_dot3", extStart, extEnd); #endif /* GL_ARB_texture_env_dot3 */ #ifdef GL_ARB_texture_filter_minmax GLEW_ARB_texture_filter_minmax = _glewSearchExtension("GL_ARB_texture_filter_minmax", extStart, extEnd); #endif /* GL_ARB_texture_filter_minmax */ #ifdef GL_ARB_texture_float GLEW_ARB_texture_float = _glewSearchExtension("GL_ARB_texture_float", extStart, extEnd); #endif /* GL_ARB_texture_float */ #ifdef GL_ARB_texture_gather GLEW_ARB_texture_gather = _glewSearchExtension("GL_ARB_texture_gather", extStart, extEnd); #endif /* GL_ARB_texture_gather */ #ifdef GL_ARB_texture_mirror_clamp_to_edge GLEW_ARB_texture_mirror_clamp_to_edge = _glewSearchExtension("GL_ARB_texture_mirror_clamp_to_edge", extStart, extEnd); #endif /* GL_ARB_texture_mirror_clamp_to_edge */ #ifdef GL_ARB_texture_mirrored_repeat GLEW_ARB_texture_mirrored_repeat = _glewSearchExtension("GL_ARB_texture_mirrored_repeat", extStart, extEnd); #endif /* GL_ARB_texture_mirrored_repeat */ #ifdef GL_ARB_texture_multisample GLEW_ARB_texture_multisample = _glewSearchExtension("GL_ARB_texture_multisample", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_multisample) GLEW_ARB_texture_multisample = !_glewInit_GL_ARB_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_multisample */ #ifdef GL_ARB_texture_non_power_of_two GLEW_ARB_texture_non_power_of_two = _glewSearchExtension("GL_ARB_texture_non_power_of_two", extStart, extEnd); #endif /* GL_ARB_texture_non_power_of_two */ #ifdef GL_ARB_texture_query_levels GLEW_ARB_texture_query_levels = _glewSearchExtension("GL_ARB_texture_query_levels", extStart, extEnd); #endif /* GL_ARB_texture_query_levels */ #ifdef GL_ARB_texture_query_lod GLEW_ARB_texture_query_lod = _glewSearchExtension("GL_ARB_texture_query_lod", extStart, extEnd); #endif /* GL_ARB_texture_query_lod */ #ifdef GL_ARB_texture_rectangle GLEW_ARB_texture_rectangle = _glewSearchExtension("GL_ARB_texture_rectangle", extStart, extEnd); #endif /* GL_ARB_texture_rectangle */ #ifdef GL_ARB_texture_rg GLEW_ARB_texture_rg = _glewSearchExtension("GL_ARB_texture_rg", extStart, extEnd); #endif /* GL_ARB_texture_rg */ #ifdef GL_ARB_texture_rgb10_a2ui GLEW_ARB_texture_rgb10_a2ui = _glewSearchExtension("GL_ARB_texture_rgb10_a2ui", extStart, extEnd); #endif /* GL_ARB_texture_rgb10_a2ui */ #ifdef GL_ARB_texture_stencil8 GLEW_ARB_texture_stencil8 = _glewSearchExtension("GL_ARB_texture_stencil8", extStart, extEnd); #endif /* GL_ARB_texture_stencil8 */ #ifdef GL_ARB_texture_storage GLEW_ARB_texture_storage = _glewSearchExtension("GL_ARB_texture_storage", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_storage) GLEW_ARB_texture_storage = !_glewInit_GL_ARB_texture_storage(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_storage */ #ifdef GL_ARB_texture_storage_multisample GLEW_ARB_texture_storage_multisample = _glewSearchExtension("GL_ARB_texture_storage_multisample", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_storage_multisample) GLEW_ARB_texture_storage_multisample = !_glewInit_GL_ARB_texture_storage_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_storage_multisample */ #ifdef GL_ARB_texture_swizzle GLEW_ARB_texture_swizzle = _glewSearchExtension("GL_ARB_texture_swizzle", extStart, extEnd); #endif /* GL_ARB_texture_swizzle */ #ifdef GL_ARB_texture_view GLEW_ARB_texture_view = _glewSearchExtension("GL_ARB_texture_view", extStart, extEnd); if (glewExperimental || GLEW_ARB_texture_view) GLEW_ARB_texture_view = !_glewInit_GL_ARB_texture_view(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_texture_view */ #ifdef GL_ARB_timer_query GLEW_ARB_timer_query = _glewSearchExtension("GL_ARB_timer_query", extStart, extEnd); if (glewExperimental || GLEW_ARB_timer_query) GLEW_ARB_timer_query = !_glewInit_GL_ARB_timer_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_timer_query */ #ifdef GL_ARB_transform_feedback2 GLEW_ARB_transform_feedback2 = _glewSearchExtension("GL_ARB_transform_feedback2", extStart, extEnd); if (glewExperimental || GLEW_ARB_transform_feedback2) GLEW_ARB_transform_feedback2 = !_glewInit_GL_ARB_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_transform_feedback2 */ #ifdef GL_ARB_transform_feedback3 GLEW_ARB_transform_feedback3 = _glewSearchExtension("GL_ARB_transform_feedback3", extStart, extEnd); if (glewExperimental || GLEW_ARB_transform_feedback3) GLEW_ARB_transform_feedback3 = !_glewInit_GL_ARB_transform_feedback3(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_transform_feedback3 */ #ifdef GL_ARB_transform_feedback_instanced GLEW_ARB_transform_feedback_instanced = _glewSearchExtension("GL_ARB_transform_feedback_instanced", extStart, extEnd); if (glewExperimental || GLEW_ARB_transform_feedback_instanced) GLEW_ARB_transform_feedback_instanced = !_glewInit_GL_ARB_transform_feedback_instanced(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_transform_feedback_instanced */ #ifdef GL_ARB_transform_feedback_overflow_query GLEW_ARB_transform_feedback_overflow_query = _glewSearchExtension("GL_ARB_transform_feedback_overflow_query", extStart, extEnd); #endif /* GL_ARB_transform_feedback_overflow_query */ #ifdef GL_ARB_transpose_matrix GLEW_ARB_transpose_matrix = _glewSearchExtension("GL_ARB_transpose_matrix", extStart, extEnd); if (glewExperimental || GLEW_ARB_transpose_matrix) GLEW_ARB_transpose_matrix = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_transpose_matrix */ #ifdef GL_ARB_uniform_buffer_object GLEW_ARB_uniform_buffer_object = _glewSearchExtension("GL_ARB_uniform_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_uniform_buffer_object) GLEW_ARB_uniform_buffer_object = !_glewInit_GL_ARB_uniform_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_uniform_buffer_object */ #ifdef GL_ARB_vertex_array_bgra GLEW_ARB_vertex_array_bgra = _glewSearchExtension("GL_ARB_vertex_array_bgra", extStart, extEnd); #endif /* GL_ARB_vertex_array_bgra */ #ifdef GL_ARB_vertex_array_object GLEW_ARB_vertex_array_object = _glewSearchExtension("GL_ARB_vertex_array_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_array_object) GLEW_ARB_vertex_array_object = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_array_object */ #ifdef GL_ARB_vertex_attrib_64bit GLEW_ARB_vertex_attrib_64bit = _glewSearchExtension("GL_ARB_vertex_attrib_64bit", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_attrib_64bit) GLEW_ARB_vertex_attrib_64bit = !_glewInit_GL_ARB_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_attrib_64bit */ #ifdef GL_ARB_vertex_attrib_binding GLEW_ARB_vertex_attrib_binding = _glewSearchExtension("GL_ARB_vertex_attrib_binding", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_attrib_binding) GLEW_ARB_vertex_attrib_binding = !_glewInit_GL_ARB_vertex_attrib_binding(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_attrib_binding */ #ifdef GL_ARB_vertex_blend GLEW_ARB_vertex_blend = _glewSearchExtension("GL_ARB_vertex_blend", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_blend) GLEW_ARB_vertex_blend = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_blend */ #ifdef GL_ARB_vertex_buffer_object GLEW_ARB_vertex_buffer_object = _glewSearchExtension("GL_ARB_vertex_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_buffer_object) GLEW_ARB_vertex_buffer_object = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_buffer_object */ #ifdef GL_ARB_vertex_program GLEW_ARB_vertex_program = _glewSearchExtension("GL_ARB_vertex_program", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_program) GLEW_ARB_vertex_program = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_program */ #ifdef GL_ARB_vertex_shader GLEW_ARB_vertex_shader = _glewSearchExtension("GL_ARB_vertex_shader", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_shader) { GLEW_ARB_vertex_shader = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); _glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); } #endif /* GL_ARB_vertex_shader */ #ifdef GL_ARB_vertex_type_10f_11f_11f_rev GLEW_ARB_vertex_type_10f_11f_11f_rev = _glewSearchExtension("GL_ARB_vertex_type_10f_11f_11f_rev", extStart, extEnd); #endif /* GL_ARB_vertex_type_10f_11f_11f_rev */ #ifdef GL_ARB_vertex_type_2_10_10_10_rev GLEW_ARB_vertex_type_2_10_10_10_rev = _glewSearchExtension("GL_ARB_vertex_type_2_10_10_10_rev", extStart, extEnd); if (glewExperimental || GLEW_ARB_vertex_type_2_10_10_10_rev) GLEW_ARB_vertex_type_2_10_10_10_rev = !_glewInit_GL_ARB_vertex_type_2_10_10_10_rev(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_vertex_type_2_10_10_10_rev */ #ifdef GL_ARB_viewport_array GLEW_ARB_viewport_array = _glewSearchExtension("GL_ARB_viewport_array", extStart, extEnd); if (glewExperimental || GLEW_ARB_viewport_array) GLEW_ARB_viewport_array = !_glewInit_GL_ARB_viewport_array(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_viewport_array */ #ifdef GL_ARB_window_pos GLEW_ARB_window_pos = _glewSearchExtension("GL_ARB_window_pos", extStart, extEnd); if (glewExperimental || GLEW_ARB_window_pos) GLEW_ARB_window_pos = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ARB_window_pos */ #ifdef GL_ATIX_point_sprites GLEW_ATIX_point_sprites = _glewSearchExtension("GL_ATIX_point_sprites", extStart, extEnd); #endif /* GL_ATIX_point_sprites */ #ifdef GL_ATIX_texture_env_combine3 GLEW_ATIX_texture_env_combine3 = _glewSearchExtension("GL_ATIX_texture_env_combine3", extStart, extEnd); #endif /* GL_ATIX_texture_env_combine3 */ #ifdef GL_ATIX_texture_env_route GLEW_ATIX_texture_env_route = _glewSearchExtension("GL_ATIX_texture_env_route", extStart, extEnd); #endif /* GL_ATIX_texture_env_route */ #ifdef GL_ATIX_vertex_shader_output_point_size GLEW_ATIX_vertex_shader_output_point_size = _glewSearchExtension("GL_ATIX_vertex_shader_output_point_size", extStart, extEnd); #endif /* GL_ATIX_vertex_shader_output_point_size */ #ifdef GL_ATI_draw_buffers GLEW_ATI_draw_buffers = _glewSearchExtension("GL_ATI_draw_buffers", extStart, extEnd); if (glewExperimental || GLEW_ATI_draw_buffers) GLEW_ATI_draw_buffers = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_draw_buffers */ #ifdef GL_ATI_element_array GLEW_ATI_element_array = _glewSearchExtension("GL_ATI_element_array", extStart, extEnd); if (glewExperimental || GLEW_ATI_element_array) GLEW_ATI_element_array = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_element_array */ #ifdef GL_ATI_envmap_bumpmap GLEW_ATI_envmap_bumpmap = _glewSearchExtension("GL_ATI_envmap_bumpmap", extStart, extEnd); if (glewExperimental || GLEW_ATI_envmap_bumpmap) GLEW_ATI_envmap_bumpmap = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_envmap_bumpmap */ #ifdef GL_ATI_fragment_shader GLEW_ATI_fragment_shader = _glewSearchExtension("GL_ATI_fragment_shader", extStart, extEnd); if (glewExperimental || GLEW_ATI_fragment_shader) GLEW_ATI_fragment_shader = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_fragment_shader */ #ifdef GL_ATI_map_object_buffer GLEW_ATI_map_object_buffer = _glewSearchExtension("GL_ATI_map_object_buffer", extStart, extEnd); if (glewExperimental || GLEW_ATI_map_object_buffer) GLEW_ATI_map_object_buffer = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_map_object_buffer */ #ifdef GL_ATI_meminfo GLEW_ATI_meminfo = _glewSearchExtension("GL_ATI_meminfo", extStart, extEnd); #endif /* GL_ATI_meminfo */ #ifdef GL_ATI_pn_triangles GLEW_ATI_pn_triangles = _glewSearchExtension("GL_ATI_pn_triangles", extStart, extEnd); if (glewExperimental || GLEW_ATI_pn_triangles) GLEW_ATI_pn_triangles = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_pn_triangles */ #ifdef GL_ATI_separate_stencil GLEW_ATI_separate_stencil = _glewSearchExtension("GL_ATI_separate_stencil", extStart, extEnd); if (glewExperimental || GLEW_ATI_separate_stencil) GLEW_ATI_separate_stencil = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_separate_stencil */ #ifdef GL_ATI_shader_texture_lod GLEW_ATI_shader_texture_lod = _glewSearchExtension("GL_ATI_shader_texture_lod", extStart, extEnd); #endif /* GL_ATI_shader_texture_lod */ #ifdef GL_ATI_text_fragment_shader GLEW_ATI_text_fragment_shader = _glewSearchExtension("GL_ATI_text_fragment_shader", extStart, extEnd); #endif /* GL_ATI_text_fragment_shader */ #ifdef GL_ATI_texture_compression_3dc GLEW_ATI_texture_compression_3dc = _glewSearchExtension("GL_ATI_texture_compression_3dc", extStart, extEnd); #endif /* GL_ATI_texture_compression_3dc */ #ifdef GL_ATI_texture_env_combine3 GLEW_ATI_texture_env_combine3 = _glewSearchExtension("GL_ATI_texture_env_combine3", extStart, extEnd); #endif /* GL_ATI_texture_env_combine3 */ #ifdef GL_ATI_texture_float GLEW_ATI_texture_float = _glewSearchExtension("GL_ATI_texture_float", extStart, extEnd); #endif /* GL_ATI_texture_float */ #ifdef GL_ATI_texture_mirror_once GLEW_ATI_texture_mirror_once = _glewSearchExtension("GL_ATI_texture_mirror_once", extStart, extEnd); #endif /* GL_ATI_texture_mirror_once */ #ifdef GL_ATI_vertex_array_object GLEW_ATI_vertex_array_object = _glewSearchExtension("GL_ATI_vertex_array_object", extStart, extEnd); if (glewExperimental || GLEW_ATI_vertex_array_object) GLEW_ATI_vertex_array_object = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_vertex_array_object */ #ifdef GL_ATI_vertex_attrib_array_object GLEW_ATI_vertex_attrib_array_object = _glewSearchExtension("GL_ATI_vertex_attrib_array_object", extStart, extEnd); if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) GLEW_ATI_vertex_attrib_array_object = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_vertex_attrib_array_object */ #ifdef GL_ATI_vertex_streams GLEW_ATI_vertex_streams = _glewSearchExtension("GL_ATI_vertex_streams", extStart, extEnd); if (glewExperimental || GLEW_ATI_vertex_streams) GLEW_ATI_vertex_streams = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_ATI_vertex_streams */ #ifdef GL_EXT_422_pixels GLEW_EXT_422_pixels = _glewSearchExtension("GL_EXT_422_pixels", extStart, extEnd); #endif /* GL_EXT_422_pixels */ #ifdef GL_EXT_Cg_shader GLEW_EXT_Cg_shader = _glewSearchExtension("GL_EXT_Cg_shader", extStart, extEnd); #endif /* GL_EXT_Cg_shader */ #ifdef GL_EXT_abgr GLEW_EXT_abgr = _glewSearchExtension("GL_EXT_abgr", extStart, extEnd); #endif /* GL_EXT_abgr */ #ifdef GL_EXT_bgra GLEW_EXT_bgra = _glewSearchExtension("GL_EXT_bgra", extStart, extEnd); #endif /* GL_EXT_bgra */ #ifdef GL_EXT_bindable_uniform GLEW_EXT_bindable_uniform = _glewSearchExtension("GL_EXT_bindable_uniform", extStart, extEnd); if (glewExperimental || GLEW_EXT_bindable_uniform) GLEW_EXT_bindable_uniform = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_bindable_uniform */ #ifdef GL_EXT_blend_color GLEW_EXT_blend_color = _glewSearchExtension("GL_EXT_blend_color", extStart, extEnd); if (glewExperimental || GLEW_EXT_blend_color) GLEW_EXT_blend_color = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_blend_color */ #ifdef GL_EXT_blend_equation_separate GLEW_EXT_blend_equation_separate = _glewSearchExtension("GL_EXT_blend_equation_separate", extStart, extEnd); if (glewExperimental || GLEW_EXT_blend_equation_separate) GLEW_EXT_blend_equation_separate = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_blend_equation_separate */ #ifdef GL_EXT_blend_func_separate GLEW_EXT_blend_func_separate = _glewSearchExtension("GL_EXT_blend_func_separate", extStart, extEnd); if (glewExperimental || GLEW_EXT_blend_func_separate) GLEW_EXT_blend_func_separate = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_blend_func_separate */ #ifdef GL_EXT_blend_logic_op GLEW_EXT_blend_logic_op = _glewSearchExtension("GL_EXT_blend_logic_op", extStart, extEnd); #endif /* GL_EXT_blend_logic_op */ #ifdef GL_EXT_blend_minmax GLEW_EXT_blend_minmax = _glewSearchExtension("GL_EXT_blend_minmax", extStart, extEnd); if (glewExperimental || GLEW_EXT_blend_minmax) GLEW_EXT_blend_minmax = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_blend_minmax */ #ifdef GL_EXT_blend_subtract GLEW_EXT_blend_subtract = _glewSearchExtension("GL_EXT_blend_subtract", extStart, extEnd); #endif /* GL_EXT_blend_subtract */ #ifdef GL_EXT_clip_volume_hint GLEW_EXT_clip_volume_hint = _glewSearchExtension("GL_EXT_clip_volume_hint", extStart, extEnd); #endif /* GL_EXT_clip_volume_hint */ #ifdef GL_EXT_cmyka GLEW_EXT_cmyka = _glewSearchExtension("GL_EXT_cmyka", extStart, extEnd); #endif /* GL_EXT_cmyka */ #ifdef GL_EXT_color_subtable GLEW_EXT_color_subtable = _glewSearchExtension("GL_EXT_color_subtable", extStart, extEnd); if (glewExperimental || GLEW_EXT_color_subtable) GLEW_EXT_color_subtable = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_color_subtable */ #ifdef GL_EXT_compiled_vertex_array GLEW_EXT_compiled_vertex_array = _glewSearchExtension("GL_EXT_compiled_vertex_array", extStart, extEnd); if (glewExperimental || GLEW_EXT_compiled_vertex_array) GLEW_EXT_compiled_vertex_array = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_compiled_vertex_array */ #ifdef GL_EXT_convolution GLEW_EXT_convolution = _glewSearchExtension("GL_EXT_convolution", extStart, extEnd); if (glewExperimental || GLEW_EXT_convolution) GLEW_EXT_convolution = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_convolution */ #ifdef GL_EXT_coordinate_frame GLEW_EXT_coordinate_frame = _glewSearchExtension("GL_EXT_coordinate_frame", extStart, extEnd); if (glewExperimental || GLEW_EXT_coordinate_frame) GLEW_EXT_coordinate_frame = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_coordinate_frame */ #ifdef GL_EXT_copy_texture GLEW_EXT_copy_texture = _glewSearchExtension("GL_EXT_copy_texture", extStart, extEnd); if (glewExperimental || GLEW_EXT_copy_texture) GLEW_EXT_copy_texture = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_copy_texture */ #ifdef GL_EXT_cull_vertex GLEW_EXT_cull_vertex = _glewSearchExtension("GL_EXT_cull_vertex", extStart, extEnd); if (glewExperimental || GLEW_EXT_cull_vertex) GLEW_EXT_cull_vertex = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_cull_vertex */ #ifdef GL_EXT_debug_label GLEW_EXT_debug_label = _glewSearchExtension("GL_EXT_debug_label", extStart, extEnd); if (glewExperimental || GLEW_EXT_debug_label) GLEW_EXT_debug_label = !_glewInit_GL_EXT_debug_label(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_debug_label */ #ifdef GL_EXT_debug_marker GLEW_EXT_debug_marker = _glewSearchExtension("GL_EXT_debug_marker", extStart, extEnd); if (glewExperimental || GLEW_EXT_debug_marker) GLEW_EXT_debug_marker = !_glewInit_GL_EXT_debug_marker(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_debug_marker */ #ifdef GL_EXT_depth_bounds_test GLEW_EXT_depth_bounds_test = _glewSearchExtension("GL_EXT_depth_bounds_test", extStart, extEnd); if (glewExperimental || GLEW_EXT_depth_bounds_test) GLEW_EXT_depth_bounds_test = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_depth_bounds_test */ #ifdef GL_EXT_direct_state_access GLEW_EXT_direct_state_access = _glewSearchExtension("GL_EXT_direct_state_access", extStart, extEnd); if (glewExperimental || GLEW_EXT_direct_state_access) GLEW_EXT_direct_state_access = !_glewInit_GL_EXT_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_direct_state_access */ #ifdef GL_EXT_draw_buffers2 GLEW_EXT_draw_buffers2 = _glewSearchExtension("GL_EXT_draw_buffers2", extStart, extEnd); if (glewExperimental || GLEW_EXT_draw_buffers2) GLEW_EXT_draw_buffers2 = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_draw_buffers2 */ #ifdef GL_EXT_draw_instanced GLEW_EXT_draw_instanced = _glewSearchExtension("GL_EXT_draw_instanced", extStart, extEnd); if (glewExperimental || GLEW_EXT_draw_instanced) GLEW_EXT_draw_instanced = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_draw_instanced */ #ifdef GL_EXT_draw_range_elements GLEW_EXT_draw_range_elements = _glewSearchExtension("GL_EXT_draw_range_elements", extStart, extEnd); if (glewExperimental || GLEW_EXT_draw_range_elements) GLEW_EXT_draw_range_elements = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_draw_range_elements */ #ifdef GL_EXT_fog_coord GLEW_EXT_fog_coord = _glewSearchExtension("GL_EXT_fog_coord", extStart, extEnd); if (glewExperimental || GLEW_EXT_fog_coord) GLEW_EXT_fog_coord = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_fog_coord */ #ifdef GL_EXT_fragment_lighting GLEW_EXT_fragment_lighting = _glewSearchExtension("GL_EXT_fragment_lighting", extStart, extEnd); if (glewExperimental || GLEW_EXT_fragment_lighting) GLEW_EXT_fragment_lighting = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_fragment_lighting */ #ifdef GL_EXT_framebuffer_blit GLEW_EXT_framebuffer_blit = _glewSearchExtension("GL_EXT_framebuffer_blit", extStart, extEnd); if (glewExperimental || GLEW_EXT_framebuffer_blit) GLEW_EXT_framebuffer_blit = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_framebuffer_blit */ #ifdef GL_EXT_framebuffer_multisample GLEW_EXT_framebuffer_multisample = _glewSearchExtension("GL_EXT_framebuffer_multisample", extStart, extEnd); if (glewExperimental || GLEW_EXT_framebuffer_multisample) GLEW_EXT_framebuffer_multisample = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_framebuffer_multisample */ #ifdef GL_EXT_framebuffer_multisample_blit_scaled GLEW_EXT_framebuffer_multisample_blit_scaled = _glewSearchExtension("GL_EXT_framebuffer_multisample_blit_scaled", extStart, extEnd); #endif /* GL_EXT_framebuffer_multisample_blit_scaled */ #ifdef GL_EXT_framebuffer_object GLEW_EXT_framebuffer_object = _glewSearchExtension("GL_EXT_framebuffer_object", extStart, extEnd); if (glewExperimental || GLEW_EXT_framebuffer_object) GLEW_EXT_framebuffer_object = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_framebuffer_object */ #ifdef GL_EXT_framebuffer_sRGB GLEW_EXT_framebuffer_sRGB = _glewSearchExtension("GL_EXT_framebuffer_sRGB", extStart, extEnd); #endif /* GL_EXT_framebuffer_sRGB */ #ifdef GL_EXT_geometry_shader4 GLEW_EXT_geometry_shader4 = _glewSearchExtension("GL_EXT_geometry_shader4", extStart, extEnd); if (glewExperimental || GLEW_EXT_geometry_shader4) GLEW_EXT_geometry_shader4 = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_geometry_shader4 */ #ifdef GL_EXT_gpu_program_parameters GLEW_EXT_gpu_program_parameters = _glewSearchExtension("GL_EXT_gpu_program_parameters", extStart, extEnd); if (glewExperimental || GLEW_EXT_gpu_program_parameters) GLEW_EXT_gpu_program_parameters = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_gpu_program_parameters */ #ifdef GL_EXT_gpu_shader4 GLEW_EXT_gpu_shader4 = _glewSearchExtension("GL_EXT_gpu_shader4", extStart, extEnd); if (glewExperimental || GLEW_EXT_gpu_shader4) GLEW_EXT_gpu_shader4 = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_gpu_shader4 */ #ifdef GL_EXT_histogram GLEW_EXT_histogram = _glewSearchExtension("GL_EXT_histogram", extStart, extEnd); if (glewExperimental || GLEW_EXT_histogram) GLEW_EXT_histogram = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_histogram */ #ifdef GL_EXT_index_array_formats GLEW_EXT_index_array_formats = _glewSearchExtension("GL_EXT_index_array_formats", extStart, extEnd); #endif /* GL_EXT_index_array_formats */ #ifdef GL_EXT_index_func GLEW_EXT_index_func = _glewSearchExtension("GL_EXT_index_func", extStart, extEnd); if (glewExperimental || GLEW_EXT_index_func) GLEW_EXT_index_func = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_index_func */ #ifdef GL_EXT_index_material GLEW_EXT_index_material = _glewSearchExtension("GL_EXT_index_material", extStart, extEnd); if (glewExperimental || GLEW_EXT_index_material) GLEW_EXT_index_material = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_index_material */ #ifdef GL_EXT_index_texture GLEW_EXT_index_texture = _glewSearchExtension("GL_EXT_index_texture", extStart, extEnd); #endif /* GL_EXT_index_texture */ #ifdef GL_EXT_light_texture GLEW_EXT_light_texture = _glewSearchExtension("GL_EXT_light_texture", extStart, extEnd); if (glewExperimental || GLEW_EXT_light_texture) GLEW_EXT_light_texture = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_light_texture */ #ifdef GL_EXT_misc_attribute GLEW_EXT_misc_attribute = _glewSearchExtension("GL_EXT_misc_attribute", extStart, extEnd); #endif /* GL_EXT_misc_attribute */ #ifdef GL_EXT_multi_draw_arrays GLEW_EXT_multi_draw_arrays = _glewSearchExtension("GL_EXT_multi_draw_arrays", extStart, extEnd); if (glewExperimental || GLEW_EXT_multi_draw_arrays) GLEW_EXT_multi_draw_arrays = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_multi_draw_arrays */ #ifdef GL_EXT_multisample GLEW_EXT_multisample = _glewSearchExtension("GL_EXT_multisample", extStart, extEnd); if (glewExperimental || GLEW_EXT_multisample) GLEW_EXT_multisample = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_multisample */ #ifdef GL_EXT_packed_depth_stencil GLEW_EXT_packed_depth_stencil = _glewSearchExtension("GL_EXT_packed_depth_stencil", extStart, extEnd); #endif /* GL_EXT_packed_depth_stencil */ #ifdef GL_EXT_packed_float GLEW_EXT_packed_float = _glewSearchExtension("GL_EXT_packed_float", extStart, extEnd); #endif /* GL_EXT_packed_float */ #ifdef GL_EXT_packed_pixels GLEW_EXT_packed_pixels = _glewSearchExtension("GL_EXT_packed_pixels", extStart, extEnd); #endif /* GL_EXT_packed_pixels */ #ifdef GL_EXT_paletted_texture GLEW_EXT_paletted_texture = _glewSearchExtension("GL_EXT_paletted_texture", extStart, extEnd); if (glewExperimental || GLEW_EXT_paletted_texture) GLEW_EXT_paletted_texture = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_paletted_texture */ #ifdef GL_EXT_pixel_buffer_object GLEW_EXT_pixel_buffer_object = _glewSearchExtension("GL_EXT_pixel_buffer_object", extStart, extEnd); #endif /* GL_EXT_pixel_buffer_object */ #ifdef GL_EXT_pixel_transform GLEW_EXT_pixel_transform = _glewSearchExtension("GL_EXT_pixel_transform", extStart, extEnd); if (glewExperimental || GLEW_EXT_pixel_transform) GLEW_EXT_pixel_transform = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_pixel_transform */ #ifdef GL_EXT_pixel_transform_color_table GLEW_EXT_pixel_transform_color_table = _glewSearchExtension("GL_EXT_pixel_transform_color_table", extStart, extEnd); #endif /* GL_EXT_pixel_transform_color_table */ #ifdef GL_EXT_point_parameters GLEW_EXT_point_parameters = _glewSearchExtension("GL_EXT_point_parameters", extStart, extEnd); if (glewExperimental || GLEW_EXT_point_parameters) GLEW_EXT_point_parameters = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_point_parameters */ #ifdef GL_EXT_polygon_offset GLEW_EXT_polygon_offset = _glewSearchExtension("GL_EXT_polygon_offset", extStart, extEnd); if (glewExperimental || GLEW_EXT_polygon_offset) GLEW_EXT_polygon_offset = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_polygon_offset */ #ifdef GL_EXT_polygon_offset_clamp GLEW_EXT_polygon_offset_clamp = _glewSearchExtension("GL_EXT_polygon_offset_clamp", extStart, extEnd); if (glewExperimental || GLEW_EXT_polygon_offset_clamp) GLEW_EXT_polygon_offset_clamp = !_glewInit_GL_EXT_polygon_offset_clamp(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_polygon_offset_clamp */ #ifdef GL_EXT_post_depth_coverage GLEW_EXT_post_depth_coverage = _glewSearchExtension("GL_EXT_post_depth_coverage", extStart, extEnd); #endif /* GL_EXT_post_depth_coverage */ #ifdef GL_EXT_provoking_vertex GLEW_EXT_provoking_vertex = _glewSearchExtension("GL_EXT_provoking_vertex", extStart, extEnd); if (glewExperimental || GLEW_EXT_provoking_vertex) GLEW_EXT_provoking_vertex = !_glewInit_GL_EXT_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_provoking_vertex */ #ifdef GL_EXT_raster_multisample GLEW_EXT_raster_multisample = _glewSearchExtension("GL_EXT_raster_multisample", extStart, extEnd); if (glewExperimental || GLEW_EXT_raster_multisample) GLEW_EXT_raster_multisample = !_glewInit_GL_EXT_raster_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_raster_multisample */ #ifdef GL_EXT_rescale_normal GLEW_EXT_rescale_normal = _glewSearchExtension("GL_EXT_rescale_normal", extStart, extEnd); #endif /* GL_EXT_rescale_normal */ #ifdef GL_EXT_scene_marker GLEW_EXT_scene_marker = _glewSearchExtension("GL_EXT_scene_marker", extStart, extEnd); if (glewExperimental || GLEW_EXT_scene_marker) GLEW_EXT_scene_marker = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_scene_marker */ #ifdef GL_EXT_secondary_color GLEW_EXT_secondary_color = _glewSearchExtension("GL_EXT_secondary_color", extStart, extEnd); if (glewExperimental || GLEW_EXT_secondary_color) GLEW_EXT_secondary_color = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_secondary_color */ #ifdef GL_EXT_separate_shader_objects GLEW_EXT_separate_shader_objects = _glewSearchExtension("GL_EXT_separate_shader_objects", extStart, extEnd); if (glewExperimental || GLEW_EXT_separate_shader_objects) GLEW_EXT_separate_shader_objects = !_glewInit_GL_EXT_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_separate_shader_objects */ #ifdef GL_EXT_separate_specular_color GLEW_EXT_separate_specular_color = _glewSearchExtension("GL_EXT_separate_specular_color", extStart, extEnd); #endif /* GL_EXT_separate_specular_color */ #ifdef GL_EXT_shader_image_load_formatted GLEW_EXT_shader_image_load_formatted = _glewSearchExtension("GL_EXT_shader_image_load_formatted", extStart, extEnd); #endif /* GL_EXT_shader_image_load_formatted */ #ifdef GL_EXT_shader_image_load_store GLEW_EXT_shader_image_load_store = _glewSearchExtension("GL_EXT_shader_image_load_store", extStart, extEnd); if (glewExperimental || GLEW_EXT_shader_image_load_store) GLEW_EXT_shader_image_load_store = !_glewInit_GL_EXT_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_shader_image_load_store */ #ifdef GL_EXT_shader_integer_mix GLEW_EXT_shader_integer_mix = _glewSearchExtension("GL_EXT_shader_integer_mix", extStart, extEnd); #endif /* GL_EXT_shader_integer_mix */ #ifdef GL_EXT_shadow_funcs GLEW_EXT_shadow_funcs = _glewSearchExtension("GL_EXT_shadow_funcs", extStart, extEnd); #endif /* GL_EXT_shadow_funcs */ #ifdef GL_EXT_shared_texture_palette GLEW_EXT_shared_texture_palette = _glewSearchExtension("GL_EXT_shared_texture_palette", extStart, extEnd); #endif /* GL_EXT_shared_texture_palette */ #ifdef GL_EXT_sparse_texture2 GLEW_EXT_sparse_texture2 = _glewSearchExtension("GL_EXT_sparse_texture2", extStart, extEnd); #endif /* GL_EXT_sparse_texture2 */ #ifdef GL_EXT_stencil_clear_tag GLEW_EXT_stencil_clear_tag = _glewSearchExtension("GL_EXT_stencil_clear_tag", extStart, extEnd); #endif /* GL_EXT_stencil_clear_tag */ #ifdef GL_EXT_stencil_two_side GLEW_EXT_stencil_two_side = _glewSearchExtension("GL_EXT_stencil_two_side", extStart, extEnd); if (glewExperimental || GLEW_EXT_stencil_two_side) GLEW_EXT_stencil_two_side = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_stencil_two_side */ #ifdef GL_EXT_stencil_wrap GLEW_EXT_stencil_wrap = _glewSearchExtension("GL_EXT_stencil_wrap", extStart, extEnd); #endif /* GL_EXT_stencil_wrap */ #ifdef GL_EXT_subtexture GLEW_EXT_subtexture = _glewSearchExtension("GL_EXT_subtexture", extStart, extEnd); if (glewExperimental || GLEW_EXT_subtexture) GLEW_EXT_subtexture = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_subtexture */ #ifdef GL_EXT_texture GLEW_EXT_texture = _glewSearchExtension("GL_EXT_texture", extStart, extEnd); #endif /* GL_EXT_texture */ #ifdef GL_EXT_texture3D GLEW_EXT_texture3D = _glewSearchExtension("GL_EXT_texture3D", extStart, extEnd); if (glewExperimental || GLEW_EXT_texture3D) GLEW_EXT_texture3D = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_texture3D */ #ifdef GL_EXT_texture_array GLEW_EXT_texture_array = _glewSearchExtension("GL_EXT_texture_array", extStart, extEnd); if (glewExperimental || GLEW_EXT_texture_array) GLEW_EXT_texture_array = !_glewInit_GL_EXT_texture_array(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_texture_array */ #ifdef GL_EXT_texture_buffer_object GLEW_EXT_texture_buffer_object = _glewSearchExtension("GL_EXT_texture_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_EXT_texture_buffer_object) GLEW_EXT_texture_buffer_object = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_texture_buffer_object */ #ifdef GL_EXT_texture_compression_dxt1 GLEW_EXT_texture_compression_dxt1 = _glewSearchExtension("GL_EXT_texture_compression_dxt1", extStart, extEnd); #endif /* GL_EXT_texture_compression_dxt1 */ #ifdef GL_EXT_texture_compression_latc GLEW_EXT_texture_compression_latc = _glewSearchExtension("GL_EXT_texture_compression_latc", extStart, extEnd); #endif /* GL_EXT_texture_compression_latc */ #ifdef GL_EXT_texture_compression_rgtc GLEW_EXT_texture_compression_rgtc = _glewSearchExtension("GL_EXT_texture_compression_rgtc", extStart, extEnd); #endif /* GL_EXT_texture_compression_rgtc */ #ifdef GL_EXT_texture_compression_s3tc GLEW_EXT_texture_compression_s3tc = _glewSearchExtension("GL_EXT_texture_compression_s3tc", extStart, extEnd); #endif /* GL_EXT_texture_compression_s3tc */ #ifdef GL_EXT_texture_cube_map GLEW_EXT_texture_cube_map = _glewSearchExtension("GL_EXT_texture_cube_map", extStart, extEnd); #endif /* GL_EXT_texture_cube_map */ #ifdef GL_EXT_texture_edge_clamp GLEW_EXT_texture_edge_clamp = _glewSearchExtension("GL_EXT_texture_edge_clamp", extStart, extEnd); #endif /* GL_EXT_texture_edge_clamp */ #ifdef GL_EXT_texture_env GLEW_EXT_texture_env = _glewSearchExtension("GL_EXT_texture_env", extStart, extEnd); #endif /* GL_EXT_texture_env */ #ifdef GL_EXT_texture_env_add GLEW_EXT_texture_env_add = _glewSearchExtension("GL_EXT_texture_env_add", extStart, extEnd); #endif /* GL_EXT_texture_env_add */ #ifdef GL_EXT_texture_env_combine GLEW_EXT_texture_env_combine = _glewSearchExtension("GL_EXT_texture_env_combine", extStart, extEnd); #endif /* GL_EXT_texture_env_combine */ #ifdef GL_EXT_texture_env_dot3 GLEW_EXT_texture_env_dot3 = _glewSearchExtension("GL_EXT_texture_env_dot3", extStart, extEnd); #endif /* GL_EXT_texture_env_dot3 */ #ifdef GL_EXT_texture_filter_anisotropic GLEW_EXT_texture_filter_anisotropic = _glewSearchExtension("GL_EXT_texture_filter_anisotropic", extStart, extEnd); #endif /* GL_EXT_texture_filter_anisotropic */ #ifdef GL_EXT_texture_filter_minmax GLEW_EXT_texture_filter_minmax = _glewSearchExtension("GL_EXT_texture_filter_minmax", extStart, extEnd); #endif /* GL_EXT_texture_filter_minmax */ #ifdef GL_EXT_texture_integer GLEW_EXT_texture_integer = _glewSearchExtension("GL_EXT_texture_integer", extStart, extEnd); if (glewExperimental || GLEW_EXT_texture_integer) GLEW_EXT_texture_integer = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_texture_integer */ #ifdef GL_EXT_texture_lod_bias GLEW_EXT_texture_lod_bias = _glewSearchExtension("GL_EXT_texture_lod_bias", extStart, extEnd); #endif /* GL_EXT_texture_lod_bias */ #ifdef GL_EXT_texture_mirror_clamp GLEW_EXT_texture_mirror_clamp = _glewSearchExtension("GL_EXT_texture_mirror_clamp", extStart, extEnd); #endif /* GL_EXT_texture_mirror_clamp */ #ifdef GL_EXT_texture_object GLEW_EXT_texture_object = _glewSearchExtension("GL_EXT_texture_object", extStart, extEnd); if (glewExperimental || GLEW_EXT_texture_object) GLEW_EXT_texture_object = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_texture_object */ #ifdef GL_EXT_texture_perturb_normal GLEW_EXT_texture_perturb_normal = _glewSearchExtension("GL_EXT_texture_perturb_normal", extStart, extEnd); if (glewExperimental || GLEW_EXT_texture_perturb_normal) GLEW_EXT_texture_perturb_normal = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_texture_perturb_normal */ #ifdef GL_EXT_texture_rectangle GLEW_EXT_texture_rectangle = _glewSearchExtension("GL_EXT_texture_rectangle", extStart, extEnd); #endif /* GL_EXT_texture_rectangle */ #ifdef GL_EXT_texture_sRGB GLEW_EXT_texture_sRGB = _glewSearchExtension("GL_EXT_texture_sRGB", extStart, extEnd); #endif /* GL_EXT_texture_sRGB */ #ifdef GL_EXT_texture_sRGB_decode GLEW_EXT_texture_sRGB_decode = _glewSearchExtension("GL_EXT_texture_sRGB_decode", extStart, extEnd); #endif /* GL_EXT_texture_sRGB_decode */ #ifdef GL_EXT_texture_shared_exponent GLEW_EXT_texture_shared_exponent = _glewSearchExtension("GL_EXT_texture_shared_exponent", extStart, extEnd); #endif /* GL_EXT_texture_shared_exponent */ #ifdef GL_EXT_texture_snorm GLEW_EXT_texture_snorm = _glewSearchExtension("GL_EXT_texture_snorm", extStart, extEnd); #endif /* GL_EXT_texture_snorm */ #ifdef GL_EXT_texture_swizzle GLEW_EXT_texture_swizzle = _glewSearchExtension("GL_EXT_texture_swizzle", extStart, extEnd); #endif /* GL_EXT_texture_swizzle */ #ifdef GL_EXT_timer_query GLEW_EXT_timer_query = _glewSearchExtension("GL_EXT_timer_query", extStart, extEnd); if (glewExperimental || GLEW_EXT_timer_query) GLEW_EXT_timer_query = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_timer_query */ #ifdef GL_EXT_transform_feedback GLEW_EXT_transform_feedback = _glewSearchExtension("GL_EXT_transform_feedback", extStart, extEnd); if (glewExperimental || GLEW_EXT_transform_feedback) GLEW_EXT_transform_feedback = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_transform_feedback */ #ifdef GL_EXT_vertex_array GLEW_EXT_vertex_array = _glewSearchExtension("GL_EXT_vertex_array", extStart, extEnd); if (glewExperimental || GLEW_EXT_vertex_array) GLEW_EXT_vertex_array = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_vertex_array */ #ifdef GL_EXT_vertex_array_bgra GLEW_EXT_vertex_array_bgra = _glewSearchExtension("GL_EXT_vertex_array_bgra", extStart, extEnd); #endif /* GL_EXT_vertex_array_bgra */ #ifdef GL_EXT_vertex_attrib_64bit GLEW_EXT_vertex_attrib_64bit = _glewSearchExtension("GL_EXT_vertex_attrib_64bit", extStart, extEnd); if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) GLEW_EXT_vertex_attrib_64bit = !_glewInit_GL_EXT_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_vertex_attrib_64bit */ #ifdef GL_EXT_vertex_shader GLEW_EXT_vertex_shader = _glewSearchExtension("GL_EXT_vertex_shader", extStart, extEnd); if (glewExperimental || GLEW_EXT_vertex_shader) GLEW_EXT_vertex_shader = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_vertex_shader */ #ifdef GL_EXT_vertex_weighting GLEW_EXT_vertex_weighting = _glewSearchExtension("GL_EXT_vertex_weighting", extStart, extEnd); if (glewExperimental || GLEW_EXT_vertex_weighting) GLEW_EXT_vertex_weighting = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_vertex_weighting */ #ifdef GL_EXT_x11_sync_object GLEW_EXT_x11_sync_object = _glewSearchExtension("GL_EXT_x11_sync_object", extStart, extEnd); if (glewExperimental || GLEW_EXT_x11_sync_object) GLEW_EXT_x11_sync_object = !_glewInit_GL_EXT_x11_sync_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_EXT_x11_sync_object */ #ifdef GL_GREMEDY_frame_terminator GLEW_GREMEDY_frame_terminator = _glewSearchExtension("GL_GREMEDY_frame_terminator", extStart, extEnd); if (glewExperimental || GLEW_GREMEDY_frame_terminator) GLEW_GREMEDY_frame_terminator = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_GREMEDY_frame_terminator */ #ifdef GL_GREMEDY_string_marker GLEW_GREMEDY_string_marker = _glewSearchExtension("GL_GREMEDY_string_marker", extStart, extEnd); if (glewExperimental || GLEW_GREMEDY_string_marker) GLEW_GREMEDY_string_marker = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_GREMEDY_string_marker */ #ifdef GL_HP_convolution_border_modes GLEW_HP_convolution_border_modes = _glewSearchExtension("GL_HP_convolution_border_modes", extStart, extEnd); #endif /* GL_HP_convolution_border_modes */ #ifdef GL_HP_image_transform GLEW_HP_image_transform = _glewSearchExtension("GL_HP_image_transform", extStart, extEnd); if (glewExperimental || GLEW_HP_image_transform) GLEW_HP_image_transform = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_HP_image_transform */ #ifdef GL_HP_occlusion_test GLEW_HP_occlusion_test = _glewSearchExtension("GL_HP_occlusion_test", extStart, extEnd); #endif /* GL_HP_occlusion_test */ #ifdef GL_HP_texture_lighting GLEW_HP_texture_lighting = _glewSearchExtension("GL_HP_texture_lighting", extStart, extEnd); #endif /* GL_HP_texture_lighting */ #ifdef GL_IBM_cull_vertex GLEW_IBM_cull_vertex = _glewSearchExtension("GL_IBM_cull_vertex", extStart, extEnd); #endif /* GL_IBM_cull_vertex */ #ifdef GL_IBM_multimode_draw_arrays GLEW_IBM_multimode_draw_arrays = _glewSearchExtension("GL_IBM_multimode_draw_arrays", extStart, extEnd); if (glewExperimental || GLEW_IBM_multimode_draw_arrays) GLEW_IBM_multimode_draw_arrays = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_IBM_multimode_draw_arrays */ #ifdef GL_IBM_rasterpos_clip GLEW_IBM_rasterpos_clip = _glewSearchExtension("GL_IBM_rasterpos_clip", extStart, extEnd); #endif /* GL_IBM_rasterpos_clip */ #ifdef GL_IBM_static_data GLEW_IBM_static_data = _glewSearchExtension("GL_IBM_static_data", extStart, extEnd); #endif /* GL_IBM_static_data */ #ifdef GL_IBM_texture_mirrored_repeat GLEW_IBM_texture_mirrored_repeat = _glewSearchExtension("GL_IBM_texture_mirrored_repeat", extStart, extEnd); #endif /* GL_IBM_texture_mirrored_repeat */ #ifdef GL_IBM_vertex_array_lists GLEW_IBM_vertex_array_lists = _glewSearchExtension("GL_IBM_vertex_array_lists", extStart, extEnd); if (glewExperimental || GLEW_IBM_vertex_array_lists) GLEW_IBM_vertex_array_lists = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_IBM_vertex_array_lists */ #ifdef GL_INGR_color_clamp GLEW_INGR_color_clamp = _glewSearchExtension("GL_INGR_color_clamp", extStart, extEnd); #endif /* GL_INGR_color_clamp */ #ifdef GL_INGR_interlace_read GLEW_INGR_interlace_read = _glewSearchExtension("GL_INGR_interlace_read", extStart, extEnd); #endif /* GL_INGR_interlace_read */ #ifdef GL_INTEL_fragment_shader_ordering GLEW_INTEL_fragment_shader_ordering = _glewSearchExtension("GL_INTEL_fragment_shader_ordering", extStart, extEnd); #endif /* GL_INTEL_fragment_shader_ordering */ #ifdef GL_INTEL_framebuffer_CMAA GLEW_INTEL_framebuffer_CMAA = _glewSearchExtension("GL_INTEL_framebuffer_CMAA", extStart, extEnd); #endif /* GL_INTEL_framebuffer_CMAA */ #ifdef GL_INTEL_map_texture GLEW_INTEL_map_texture = _glewSearchExtension("GL_INTEL_map_texture", extStart, extEnd); if (glewExperimental || GLEW_INTEL_map_texture) GLEW_INTEL_map_texture = !_glewInit_GL_INTEL_map_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_INTEL_map_texture */ #ifdef GL_INTEL_parallel_arrays GLEW_INTEL_parallel_arrays = _glewSearchExtension("GL_INTEL_parallel_arrays", extStart, extEnd); if (glewExperimental || GLEW_INTEL_parallel_arrays) GLEW_INTEL_parallel_arrays = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_INTEL_parallel_arrays */ #ifdef GL_INTEL_performance_query GLEW_INTEL_performance_query = _glewSearchExtension("GL_INTEL_performance_query", extStart, extEnd); if (glewExperimental || GLEW_INTEL_performance_query) GLEW_INTEL_performance_query = !_glewInit_GL_INTEL_performance_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_INTEL_performance_query */ #ifdef GL_INTEL_texture_scissor GLEW_INTEL_texture_scissor = _glewSearchExtension("GL_INTEL_texture_scissor", extStart, extEnd); if (glewExperimental || GLEW_INTEL_texture_scissor) GLEW_INTEL_texture_scissor = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_INTEL_texture_scissor */ #ifdef GL_KHR_blend_equation_advanced GLEW_KHR_blend_equation_advanced = _glewSearchExtension("GL_KHR_blend_equation_advanced", extStart, extEnd); if (glewExperimental || GLEW_KHR_blend_equation_advanced) GLEW_KHR_blend_equation_advanced = !_glewInit_GL_KHR_blend_equation_advanced(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_KHR_blend_equation_advanced */ #ifdef GL_KHR_blend_equation_advanced_coherent GLEW_KHR_blend_equation_advanced_coherent = _glewSearchExtension("GL_KHR_blend_equation_advanced_coherent", extStart, extEnd); #endif /* GL_KHR_blend_equation_advanced_coherent */ #ifdef GL_KHR_context_flush_control GLEW_KHR_context_flush_control = _glewSearchExtension("GL_KHR_context_flush_control", extStart, extEnd); #endif /* GL_KHR_context_flush_control */ #ifdef GL_KHR_debug GLEW_KHR_debug = _glewSearchExtension("GL_KHR_debug", extStart, extEnd); if (glewExperimental || GLEW_KHR_debug) GLEW_KHR_debug = !_glewInit_GL_KHR_debug(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_KHR_debug */ #ifdef GL_KHR_no_error GLEW_KHR_no_error = _glewSearchExtension("GL_KHR_no_error", extStart, extEnd); #endif /* GL_KHR_no_error */ #ifdef GL_KHR_robust_buffer_access_behavior GLEW_KHR_robust_buffer_access_behavior = _glewSearchExtension("GL_KHR_robust_buffer_access_behavior", extStart, extEnd); #endif /* GL_KHR_robust_buffer_access_behavior */ #ifdef GL_KHR_robustness GLEW_KHR_robustness = _glewSearchExtension("GL_KHR_robustness", extStart, extEnd); if (glewExperimental || GLEW_KHR_robustness) GLEW_KHR_robustness = !_glewInit_GL_KHR_robustness(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_KHR_robustness */ #ifdef GL_KHR_texture_compression_astc_hdr GLEW_KHR_texture_compression_astc_hdr = _glewSearchExtension("GL_KHR_texture_compression_astc_hdr", extStart, extEnd); #endif /* GL_KHR_texture_compression_astc_hdr */ #ifdef GL_KHR_texture_compression_astc_ldr GLEW_KHR_texture_compression_astc_ldr = _glewSearchExtension("GL_KHR_texture_compression_astc_ldr", extStart, extEnd); #endif /* GL_KHR_texture_compression_astc_ldr */ #ifdef GL_KTX_buffer_region GLEW_KTX_buffer_region = _glewSearchExtension("GL_KTX_buffer_region", extStart, extEnd); if (glewExperimental || GLEW_KTX_buffer_region) GLEW_KTX_buffer_region = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_KTX_buffer_region */ #ifdef GL_MESAX_texture_stack GLEW_MESAX_texture_stack = _glewSearchExtension("GL_MESAX_texture_stack", extStart, extEnd); #endif /* GL_MESAX_texture_stack */ #ifdef GL_MESA_pack_invert GLEW_MESA_pack_invert = _glewSearchExtension("GL_MESA_pack_invert", extStart, extEnd); #endif /* GL_MESA_pack_invert */ #ifdef GL_MESA_resize_buffers GLEW_MESA_resize_buffers = _glewSearchExtension("GL_MESA_resize_buffers", extStart, extEnd); if (glewExperimental || GLEW_MESA_resize_buffers) GLEW_MESA_resize_buffers = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_MESA_resize_buffers */ #ifdef GL_MESA_window_pos GLEW_MESA_window_pos = _glewSearchExtension("GL_MESA_window_pos", extStart, extEnd); if (glewExperimental || GLEW_MESA_window_pos) GLEW_MESA_window_pos = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_MESA_window_pos */ #ifdef GL_MESA_ycbcr_texture GLEW_MESA_ycbcr_texture = _glewSearchExtension("GL_MESA_ycbcr_texture", extStart, extEnd); #endif /* GL_MESA_ycbcr_texture */ #ifdef GL_NVX_conditional_render GLEW_NVX_conditional_render = _glewSearchExtension("GL_NVX_conditional_render", extStart, extEnd); if (glewExperimental || GLEW_NVX_conditional_render) GLEW_NVX_conditional_render = !_glewInit_GL_NVX_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NVX_conditional_render */ #ifdef GL_NVX_gpu_memory_info GLEW_NVX_gpu_memory_info = _glewSearchExtension("GL_NVX_gpu_memory_info", extStart, extEnd); #endif /* GL_NVX_gpu_memory_info */ #ifdef GL_NV_bindless_multi_draw_indirect GLEW_NV_bindless_multi_draw_indirect = _glewSearchExtension("GL_NV_bindless_multi_draw_indirect", extStart, extEnd); if (glewExperimental || GLEW_NV_bindless_multi_draw_indirect) GLEW_NV_bindless_multi_draw_indirect = !_glewInit_GL_NV_bindless_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_bindless_multi_draw_indirect */ #ifdef GL_NV_bindless_multi_draw_indirect_count GLEW_NV_bindless_multi_draw_indirect_count = _glewSearchExtension("GL_NV_bindless_multi_draw_indirect_count", extStart, extEnd); if (glewExperimental || GLEW_NV_bindless_multi_draw_indirect_count) GLEW_NV_bindless_multi_draw_indirect_count = !_glewInit_GL_NV_bindless_multi_draw_indirect_count(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_bindless_multi_draw_indirect_count */ #ifdef GL_NV_bindless_texture GLEW_NV_bindless_texture = _glewSearchExtension("GL_NV_bindless_texture", extStart, extEnd); if (glewExperimental || GLEW_NV_bindless_texture) GLEW_NV_bindless_texture = !_glewInit_GL_NV_bindless_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_bindless_texture */ #ifdef GL_NV_blend_equation_advanced GLEW_NV_blend_equation_advanced = _glewSearchExtension("GL_NV_blend_equation_advanced", extStart, extEnd); if (glewExperimental || GLEW_NV_blend_equation_advanced) GLEW_NV_blend_equation_advanced = !_glewInit_GL_NV_blend_equation_advanced(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_blend_equation_advanced */ #ifdef GL_NV_blend_equation_advanced_coherent GLEW_NV_blend_equation_advanced_coherent = _glewSearchExtension("GL_NV_blend_equation_advanced_coherent", extStart, extEnd); #endif /* GL_NV_blend_equation_advanced_coherent */ #ifdef GL_NV_blend_square GLEW_NV_blend_square = _glewSearchExtension("GL_NV_blend_square", extStart, extEnd); #endif /* GL_NV_blend_square */ #ifdef GL_NV_compute_program5 GLEW_NV_compute_program5 = _glewSearchExtension("GL_NV_compute_program5", extStart, extEnd); #endif /* GL_NV_compute_program5 */ #ifdef GL_NV_conditional_render GLEW_NV_conditional_render = _glewSearchExtension("GL_NV_conditional_render", extStart, extEnd); if (glewExperimental || GLEW_NV_conditional_render) GLEW_NV_conditional_render = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_conditional_render */ #ifdef GL_NV_conservative_raster GLEW_NV_conservative_raster = _glewSearchExtension("GL_NV_conservative_raster", extStart, extEnd); if (glewExperimental || GLEW_NV_conservative_raster) GLEW_NV_conservative_raster = !_glewInit_GL_NV_conservative_raster(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_conservative_raster */ #ifdef GL_NV_conservative_raster_dilate GLEW_NV_conservative_raster_dilate = _glewSearchExtension("GL_NV_conservative_raster_dilate", extStart, extEnd); if (glewExperimental || GLEW_NV_conservative_raster_dilate) GLEW_NV_conservative_raster_dilate = !_glewInit_GL_NV_conservative_raster_dilate(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_conservative_raster_dilate */ #ifdef GL_NV_copy_depth_to_color GLEW_NV_copy_depth_to_color = _glewSearchExtension("GL_NV_copy_depth_to_color", extStart, extEnd); #endif /* GL_NV_copy_depth_to_color */ #ifdef GL_NV_copy_image GLEW_NV_copy_image = _glewSearchExtension("GL_NV_copy_image", extStart, extEnd); if (glewExperimental || GLEW_NV_copy_image) GLEW_NV_copy_image = !_glewInit_GL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_copy_image */ #ifdef GL_NV_deep_texture3D GLEW_NV_deep_texture3D = _glewSearchExtension("GL_NV_deep_texture3D", extStart, extEnd); #endif /* GL_NV_deep_texture3D */ #ifdef GL_NV_depth_buffer_float GLEW_NV_depth_buffer_float = _glewSearchExtension("GL_NV_depth_buffer_float", extStart, extEnd); if (glewExperimental || GLEW_NV_depth_buffer_float) GLEW_NV_depth_buffer_float = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_depth_buffer_float */ #ifdef GL_NV_depth_clamp GLEW_NV_depth_clamp = _glewSearchExtension("GL_NV_depth_clamp", extStart, extEnd); #endif /* GL_NV_depth_clamp */ #ifdef GL_NV_depth_range_unclamped GLEW_NV_depth_range_unclamped = _glewSearchExtension("GL_NV_depth_range_unclamped", extStart, extEnd); #endif /* GL_NV_depth_range_unclamped */ #ifdef GL_NV_draw_texture GLEW_NV_draw_texture = _glewSearchExtension("GL_NV_draw_texture", extStart, extEnd); if (glewExperimental || GLEW_NV_draw_texture) GLEW_NV_draw_texture = !_glewInit_GL_NV_draw_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_draw_texture */ #ifdef GL_NV_evaluators GLEW_NV_evaluators = _glewSearchExtension("GL_NV_evaluators", extStart, extEnd); if (glewExperimental || GLEW_NV_evaluators) GLEW_NV_evaluators = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_evaluators */ #ifdef GL_NV_explicit_multisample GLEW_NV_explicit_multisample = _glewSearchExtension("GL_NV_explicit_multisample", extStart, extEnd); if (glewExperimental || GLEW_NV_explicit_multisample) GLEW_NV_explicit_multisample = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_explicit_multisample */ #ifdef GL_NV_fence GLEW_NV_fence = _glewSearchExtension("GL_NV_fence", extStart, extEnd); if (glewExperimental || GLEW_NV_fence) GLEW_NV_fence = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_fence */ #ifdef GL_NV_fill_rectangle GLEW_NV_fill_rectangle = _glewSearchExtension("GL_NV_fill_rectangle", extStart, extEnd); #endif /* GL_NV_fill_rectangle */ #ifdef GL_NV_float_buffer GLEW_NV_float_buffer = _glewSearchExtension("GL_NV_float_buffer", extStart, extEnd); #endif /* GL_NV_float_buffer */ #ifdef GL_NV_fog_distance GLEW_NV_fog_distance = _glewSearchExtension("GL_NV_fog_distance", extStart, extEnd); #endif /* GL_NV_fog_distance */ #ifdef GL_NV_fragment_coverage_to_color GLEW_NV_fragment_coverage_to_color = _glewSearchExtension("GL_NV_fragment_coverage_to_color", extStart, extEnd); if (glewExperimental || GLEW_NV_fragment_coverage_to_color) GLEW_NV_fragment_coverage_to_color = !_glewInit_GL_NV_fragment_coverage_to_color(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_fragment_coverage_to_color */ #ifdef GL_NV_fragment_program GLEW_NV_fragment_program = _glewSearchExtension("GL_NV_fragment_program", extStart, extEnd); if (glewExperimental || GLEW_NV_fragment_program) GLEW_NV_fragment_program = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_fragment_program */ #ifdef GL_NV_fragment_program2 GLEW_NV_fragment_program2 = _glewSearchExtension("GL_NV_fragment_program2", extStart, extEnd); #endif /* GL_NV_fragment_program2 */ #ifdef GL_NV_fragment_program4 GLEW_NV_fragment_program4 = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); #endif /* GL_NV_fragment_program4 */ #ifdef GL_NV_fragment_program_option GLEW_NV_fragment_program_option = _glewSearchExtension("GL_NV_fragment_program_option", extStart, extEnd); #endif /* GL_NV_fragment_program_option */ #ifdef GL_NV_fragment_shader_interlock GLEW_NV_fragment_shader_interlock = _glewSearchExtension("GL_NV_fragment_shader_interlock", extStart, extEnd); #endif /* GL_NV_fragment_shader_interlock */ #ifdef GL_NV_framebuffer_mixed_samples GLEW_NV_framebuffer_mixed_samples = _glewSearchExtension("GL_NV_framebuffer_mixed_samples", extStart, extEnd); #endif /* GL_NV_framebuffer_mixed_samples */ #ifdef GL_NV_framebuffer_multisample_coverage GLEW_NV_framebuffer_multisample_coverage = _glewSearchExtension("GL_NV_framebuffer_multisample_coverage", extStart, extEnd); if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) GLEW_NV_framebuffer_multisample_coverage = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_framebuffer_multisample_coverage */ #ifdef GL_NV_geometry_program4 GLEW_NV_geometry_program4 = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); if (glewExperimental || GLEW_NV_geometry_program4) GLEW_NV_geometry_program4 = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_geometry_program4 */ #ifdef GL_NV_geometry_shader4 GLEW_NV_geometry_shader4 = _glewSearchExtension("GL_NV_geometry_shader4", extStart, extEnd); #endif /* GL_NV_geometry_shader4 */ #ifdef GL_NV_geometry_shader_passthrough GLEW_NV_geometry_shader_passthrough = _glewSearchExtension("GL_NV_geometry_shader_passthrough", extStart, extEnd); #endif /* GL_NV_geometry_shader_passthrough */ #ifdef GL_NV_gpu_program4 GLEW_NV_gpu_program4 = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); if (glewExperimental || GLEW_NV_gpu_program4) GLEW_NV_gpu_program4 = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_gpu_program4 */ #ifdef GL_NV_gpu_program5 GLEW_NV_gpu_program5 = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd); #endif /* GL_NV_gpu_program5 */ #ifdef GL_NV_gpu_program5_mem_extended GLEW_NV_gpu_program5_mem_extended = _glewSearchExtension("GL_NV_gpu_program5_mem_extended", extStart, extEnd); #endif /* GL_NV_gpu_program5_mem_extended */ #ifdef GL_NV_gpu_program_fp64 GLEW_NV_gpu_program_fp64 = _glewSearchExtension("GL_NV_gpu_program_fp64", extStart, extEnd); #endif /* GL_NV_gpu_program_fp64 */ #ifdef GL_NV_gpu_shader5 GLEW_NV_gpu_shader5 = _glewSearchExtension("GL_NV_gpu_shader5", extStart, extEnd); if (glewExperimental || GLEW_NV_gpu_shader5) GLEW_NV_gpu_shader5 = !_glewInit_GL_NV_gpu_shader5(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_gpu_shader5 */ #ifdef GL_NV_half_float GLEW_NV_half_float = _glewSearchExtension("GL_NV_half_float", extStart, extEnd); if (glewExperimental || GLEW_NV_half_float) GLEW_NV_half_float = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_half_float */ #ifdef GL_NV_internalformat_sample_query GLEW_NV_internalformat_sample_query = _glewSearchExtension("GL_NV_internalformat_sample_query", extStart, extEnd); if (glewExperimental || GLEW_NV_internalformat_sample_query) GLEW_NV_internalformat_sample_query = !_glewInit_GL_NV_internalformat_sample_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_internalformat_sample_query */ #ifdef GL_NV_light_max_exponent GLEW_NV_light_max_exponent = _glewSearchExtension("GL_NV_light_max_exponent", extStart, extEnd); #endif /* GL_NV_light_max_exponent */ #ifdef GL_NV_multisample_coverage GLEW_NV_multisample_coverage = _glewSearchExtension("GL_NV_multisample_coverage", extStart, extEnd); #endif /* GL_NV_multisample_coverage */ #ifdef GL_NV_multisample_filter_hint GLEW_NV_multisample_filter_hint = _glewSearchExtension("GL_NV_multisample_filter_hint", extStart, extEnd); #endif /* GL_NV_multisample_filter_hint */ #ifdef GL_NV_occlusion_query GLEW_NV_occlusion_query = _glewSearchExtension("GL_NV_occlusion_query", extStart, extEnd); if (glewExperimental || GLEW_NV_occlusion_query) GLEW_NV_occlusion_query = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_occlusion_query */ #ifdef GL_NV_packed_depth_stencil GLEW_NV_packed_depth_stencil = _glewSearchExtension("GL_NV_packed_depth_stencil", extStart, extEnd); #endif /* GL_NV_packed_depth_stencil */ #ifdef GL_NV_parameter_buffer_object GLEW_NV_parameter_buffer_object = _glewSearchExtension("GL_NV_parameter_buffer_object", extStart, extEnd); if (glewExperimental || GLEW_NV_parameter_buffer_object) GLEW_NV_parameter_buffer_object = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_parameter_buffer_object */ #ifdef GL_NV_parameter_buffer_object2 GLEW_NV_parameter_buffer_object2 = _glewSearchExtension("GL_NV_parameter_buffer_object2", extStart, extEnd); #endif /* GL_NV_parameter_buffer_object2 */ #ifdef GL_NV_path_rendering GLEW_NV_path_rendering = _glewSearchExtension("GL_NV_path_rendering", extStart, extEnd); if (glewExperimental || GLEW_NV_path_rendering) GLEW_NV_path_rendering = !_glewInit_GL_NV_path_rendering(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_path_rendering */ #ifdef GL_NV_path_rendering_shared_edge GLEW_NV_path_rendering_shared_edge = _glewSearchExtension("GL_NV_path_rendering_shared_edge", extStart, extEnd); #endif /* GL_NV_path_rendering_shared_edge */ #ifdef GL_NV_pixel_data_range GLEW_NV_pixel_data_range = _glewSearchExtension("GL_NV_pixel_data_range", extStart, extEnd); if (glewExperimental || GLEW_NV_pixel_data_range) GLEW_NV_pixel_data_range = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_pixel_data_range */ #ifdef GL_NV_point_sprite GLEW_NV_point_sprite = _glewSearchExtension("GL_NV_point_sprite", extStart, extEnd); if (glewExperimental || GLEW_NV_point_sprite) GLEW_NV_point_sprite = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_point_sprite */ #ifdef GL_NV_present_video GLEW_NV_present_video = _glewSearchExtension("GL_NV_present_video", extStart, extEnd); if (glewExperimental || GLEW_NV_present_video) GLEW_NV_present_video = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_present_video */ #ifdef GL_NV_primitive_restart GLEW_NV_primitive_restart = _glewSearchExtension("GL_NV_primitive_restart", extStart, extEnd); if (glewExperimental || GLEW_NV_primitive_restart) GLEW_NV_primitive_restart = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_primitive_restart */ #ifdef GL_NV_register_combiners GLEW_NV_register_combiners = _glewSearchExtension("GL_NV_register_combiners", extStart, extEnd); if (glewExperimental || GLEW_NV_register_combiners) GLEW_NV_register_combiners = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_register_combiners */ #ifdef GL_NV_register_combiners2 GLEW_NV_register_combiners2 = _glewSearchExtension("GL_NV_register_combiners2", extStart, extEnd); if (glewExperimental || GLEW_NV_register_combiners2) GLEW_NV_register_combiners2 = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_register_combiners2 */ #ifdef GL_NV_sample_locations GLEW_NV_sample_locations = _glewSearchExtension("GL_NV_sample_locations", extStart, extEnd); if (glewExperimental || GLEW_NV_sample_locations) GLEW_NV_sample_locations = !_glewInit_GL_NV_sample_locations(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_sample_locations */ #ifdef GL_NV_sample_mask_override_coverage GLEW_NV_sample_mask_override_coverage = _glewSearchExtension("GL_NV_sample_mask_override_coverage", extStart, extEnd); #endif /* GL_NV_sample_mask_override_coverage */ #ifdef GL_NV_shader_atomic_counters GLEW_NV_shader_atomic_counters = _glewSearchExtension("GL_NV_shader_atomic_counters", extStart, extEnd); #endif /* GL_NV_shader_atomic_counters */ #ifdef GL_NV_shader_atomic_float GLEW_NV_shader_atomic_float = _glewSearchExtension("GL_NV_shader_atomic_float", extStart, extEnd); #endif /* GL_NV_shader_atomic_float */ #ifdef GL_NV_shader_atomic_fp16_vector GLEW_NV_shader_atomic_fp16_vector = _glewSearchExtension("GL_NV_shader_atomic_fp16_vector", extStart, extEnd); #endif /* GL_NV_shader_atomic_fp16_vector */ #ifdef GL_NV_shader_atomic_int64 GLEW_NV_shader_atomic_int64 = _glewSearchExtension("GL_NV_shader_atomic_int64", extStart, extEnd); #endif /* GL_NV_shader_atomic_int64 */ #ifdef GL_NV_shader_buffer_load GLEW_NV_shader_buffer_load = _glewSearchExtension("GL_NV_shader_buffer_load", extStart, extEnd); if (glewExperimental || GLEW_NV_shader_buffer_load) GLEW_NV_shader_buffer_load = !_glewInit_GL_NV_shader_buffer_load(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_shader_buffer_load */ #ifdef GL_NV_shader_storage_buffer_object GLEW_NV_shader_storage_buffer_object = _glewSearchExtension("GL_NV_shader_storage_buffer_object", extStart, extEnd); #endif /* GL_NV_shader_storage_buffer_object */ #ifdef GL_NV_shader_thread_group GLEW_NV_shader_thread_group = _glewSearchExtension("GL_NV_shader_thread_group", extStart, extEnd); #endif /* GL_NV_shader_thread_group */ #ifdef GL_NV_shader_thread_shuffle GLEW_NV_shader_thread_shuffle = _glewSearchExtension("GL_NV_shader_thread_shuffle", extStart, extEnd); #endif /* GL_NV_shader_thread_shuffle */ #ifdef GL_NV_tessellation_program5 GLEW_NV_tessellation_program5 = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd); #endif /* GL_NV_tessellation_program5 */ #ifdef GL_NV_texgen_emboss GLEW_NV_texgen_emboss = _glewSearchExtension("GL_NV_texgen_emboss", extStart, extEnd); #endif /* GL_NV_texgen_emboss */ #ifdef GL_NV_texgen_reflection GLEW_NV_texgen_reflection = _glewSearchExtension("GL_NV_texgen_reflection", extStart, extEnd); #endif /* GL_NV_texgen_reflection */ #ifdef GL_NV_texture_barrier GLEW_NV_texture_barrier = _glewSearchExtension("GL_NV_texture_barrier", extStart, extEnd); if (glewExperimental || GLEW_NV_texture_barrier) GLEW_NV_texture_barrier = !_glewInit_GL_NV_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_texture_barrier */ #ifdef GL_NV_texture_compression_vtc GLEW_NV_texture_compression_vtc = _glewSearchExtension("GL_NV_texture_compression_vtc", extStart, extEnd); #endif /* GL_NV_texture_compression_vtc */ #ifdef GL_NV_texture_env_combine4 GLEW_NV_texture_env_combine4 = _glewSearchExtension("GL_NV_texture_env_combine4", extStart, extEnd); #endif /* GL_NV_texture_env_combine4 */ #ifdef GL_NV_texture_expand_normal GLEW_NV_texture_expand_normal = _glewSearchExtension("GL_NV_texture_expand_normal", extStart, extEnd); #endif /* GL_NV_texture_expand_normal */ #ifdef GL_NV_texture_multisample GLEW_NV_texture_multisample = _glewSearchExtension("GL_NV_texture_multisample", extStart, extEnd); if (glewExperimental || GLEW_NV_texture_multisample) GLEW_NV_texture_multisample = !_glewInit_GL_NV_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_texture_multisample */ #ifdef GL_NV_texture_rectangle GLEW_NV_texture_rectangle = _glewSearchExtension("GL_NV_texture_rectangle", extStart, extEnd); #endif /* GL_NV_texture_rectangle */ #ifdef GL_NV_texture_shader GLEW_NV_texture_shader = _glewSearchExtension("GL_NV_texture_shader", extStart, extEnd); #endif /* GL_NV_texture_shader */ #ifdef GL_NV_texture_shader2 GLEW_NV_texture_shader2 = _glewSearchExtension("GL_NV_texture_shader2", extStart, extEnd); #endif /* GL_NV_texture_shader2 */ #ifdef GL_NV_texture_shader3 GLEW_NV_texture_shader3 = _glewSearchExtension("GL_NV_texture_shader3", extStart, extEnd); #endif /* GL_NV_texture_shader3 */ #ifdef GL_NV_transform_feedback GLEW_NV_transform_feedback = _glewSearchExtension("GL_NV_transform_feedback", extStart, extEnd); if (glewExperimental || GLEW_NV_transform_feedback) GLEW_NV_transform_feedback = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_transform_feedback */ #ifdef GL_NV_transform_feedback2 GLEW_NV_transform_feedback2 = _glewSearchExtension("GL_NV_transform_feedback2", extStart, extEnd); if (glewExperimental || GLEW_NV_transform_feedback2) GLEW_NV_transform_feedback2 = !_glewInit_GL_NV_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_transform_feedback2 */ #ifdef GL_NV_uniform_buffer_unified_memory GLEW_NV_uniform_buffer_unified_memory = _glewSearchExtension("GL_NV_uniform_buffer_unified_memory", extStart, extEnd); #endif /* GL_NV_uniform_buffer_unified_memory */ #ifdef GL_NV_vdpau_interop GLEW_NV_vdpau_interop = _glewSearchExtension("GL_NV_vdpau_interop", extStart, extEnd); if (glewExperimental || GLEW_NV_vdpau_interop) GLEW_NV_vdpau_interop = !_glewInit_GL_NV_vdpau_interop(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_vdpau_interop */ #ifdef GL_NV_vertex_array_range GLEW_NV_vertex_array_range = _glewSearchExtension("GL_NV_vertex_array_range", extStart, extEnd); if (glewExperimental || GLEW_NV_vertex_array_range) GLEW_NV_vertex_array_range = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_vertex_array_range */ #ifdef GL_NV_vertex_array_range2 GLEW_NV_vertex_array_range2 = _glewSearchExtension("GL_NV_vertex_array_range2", extStart, extEnd); #endif /* GL_NV_vertex_array_range2 */ #ifdef GL_NV_vertex_attrib_integer_64bit GLEW_NV_vertex_attrib_integer_64bit = _glewSearchExtension("GL_NV_vertex_attrib_integer_64bit", extStart, extEnd); if (glewExperimental || GLEW_NV_vertex_attrib_integer_64bit) GLEW_NV_vertex_attrib_integer_64bit = !_glewInit_GL_NV_vertex_attrib_integer_64bit(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_vertex_attrib_integer_64bit */ #ifdef GL_NV_vertex_buffer_unified_memory GLEW_NV_vertex_buffer_unified_memory = _glewSearchExtension("GL_NV_vertex_buffer_unified_memory", extStart, extEnd); if (glewExperimental || GLEW_NV_vertex_buffer_unified_memory) GLEW_NV_vertex_buffer_unified_memory = !_glewInit_GL_NV_vertex_buffer_unified_memory(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_vertex_buffer_unified_memory */ #ifdef GL_NV_vertex_program GLEW_NV_vertex_program = _glewSearchExtension("GL_NV_vertex_program", extStart, extEnd); if (glewExperimental || GLEW_NV_vertex_program) GLEW_NV_vertex_program = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_vertex_program */ #ifdef GL_NV_vertex_program1_1 GLEW_NV_vertex_program1_1 = _glewSearchExtension("GL_NV_vertex_program1_1", extStart, extEnd); #endif /* GL_NV_vertex_program1_1 */ #ifdef GL_NV_vertex_program2 GLEW_NV_vertex_program2 = _glewSearchExtension("GL_NV_vertex_program2", extStart, extEnd); #endif /* GL_NV_vertex_program2 */ #ifdef GL_NV_vertex_program2_option GLEW_NV_vertex_program2_option = _glewSearchExtension("GL_NV_vertex_program2_option", extStart, extEnd); #endif /* GL_NV_vertex_program2_option */ #ifdef GL_NV_vertex_program3 GLEW_NV_vertex_program3 = _glewSearchExtension("GL_NV_vertex_program3", extStart, extEnd); #endif /* GL_NV_vertex_program3 */ #ifdef GL_NV_vertex_program4 GLEW_NV_vertex_program4 = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd); #endif /* GL_NV_vertex_program4 */ #ifdef GL_NV_video_capture GLEW_NV_video_capture = _glewSearchExtension("GL_NV_video_capture", extStart, extEnd); if (glewExperimental || GLEW_NV_video_capture) GLEW_NV_video_capture = !_glewInit_GL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_NV_video_capture */ #ifdef GL_NV_viewport_array2 GLEW_NV_viewport_array2 = _glewSearchExtension("GL_NV_viewport_array2", extStart, extEnd); #endif /* GL_NV_viewport_array2 */ #ifdef GL_OES_byte_coordinates GLEW_OES_byte_coordinates = _glewSearchExtension("GL_OES_byte_coordinates", extStart, extEnd); #endif /* GL_OES_byte_coordinates */ #ifdef GL_OES_compressed_paletted_texture GLEW_OES_compressed_paletted_texture = _glewSearchExtension("GL_OES_compressed_paletted_texture", extStart, extEnd); #endif /* GL_OES_compressed_paletted_texture */ #ifdef GL_OES_read_format GLEW_OES_read_format = _glewSearchExtension("GL_OES_read_format", extStart, extEnd); #endif /* GL_OES_read_format */ #ifdef GL_OES_single_precision GLEW_OES_single_precision = _glewSearchExtension("GL_OES_single_precision", extStart, extEnd); if (glewExperimental || GLEW_OES_single_precision) GLEW_OES_single_precision = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_OES_single_precision */ #ifdef GL_OML_interlace GLEW_OML_interlace = _glewSearchExtension("GL_OML_interlace", extStart, extEnd); #endif /* GL_OML_interlace */ #ifdef GL_OML_resample GLEW_OML_resample = _glewSearchExtension("GL_OML_resample", extStart, extEnd); #endif /* GL_OML_resample */ #ifdef GL_OML_subsample GLEW_OML_subsample = _glewSearchExtension("GL_OML_subsample", extStart, extEnd); #endif /* GL_OML_subsample */ #ifdef GL_OVR_multiview GLEW_OVR_multiview = _glewSearchExtension("GL_OVR_multiview", extStart, extEnd); if (glewExperimental || GLEW_OVR_multiview) GLEW_OVR_multiview = !_glewInit_GL_OVR_multiview(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_OVR_multiview */ #ifdef GL_OVR_multiview2 GLEW_OVR_multiview2 = _glewSearchExtension("GL_OVR_multiview2", extStart, extEnd); #endif /* GL_OVR_multiview2 */ #ifdef GL_PGI_misc_hints GLEW_PGI_misc_hints = _glewSearchExtension("GL_PGI_misc_hints", extStart, extEnd); #endif /* GL_PGI_misc_hints */ #ifdef GL_PGI_vertex_hints GLEW_PGI_vertex_hints = _glewSearchExtension("GL_PGI_vertex_hints", extStart, extEnd); #endif /* GL_PGI_vertex_hints */ #ifdef GL_REGAL_ES1_0_compatibility GLEW_REGAL_ES1_0_compatibility = _glewSearchExtension("GL_REGAL_ES1_0_compatibility", extStart, extEnd); if (glewExperimental || GLEW_REGAL_ES1_0_compatibility) GLEW_REGAL_ES1_0_compatibility = !_glewInit_GL_REGAL_ES1_0_compatibility(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_REGAL_ES1_0_compatibility */ #ifdef GL_REGAL_ES1_1_compatibility GLEW_REGAL_ES1_1_compatibility = _glewSearchExtension("GL_REGAL_ES1_1_compatibility", extStart, extEnd); if (glewExperimental || GLEW_REGAL_ES1_1_compatibility) GLEW_REGAL_ES1_1_compatibility = !_glewInit_GL_REGAL_ES1_1_compatibility(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_REGAL_ES1_1_compatibility */ #ifdef GL_REGAL_enable GLEW_REGAL_enable = _glewSearchExtension("GL_REGAL_enable", extStart, extEnd); #endif /* GL_REGAL_enable */ #ifdef GL_REGAL_error_string GLEW_REGAL_error_string = _glewSearchExtension("GL_REGAL_error_string", extStart, extEnd); if (glewExperimental || GLEW_REGAL_error_string) GLEW_REGAL_error_string = !_glewInit_GL_REGAL_error_string(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_REGAL_error_string */ #ifdef GL_REGAL_extension_query GLEW_REGAL_extension_query = _glewSearchExtension("GL_REGAL_extension_query", extStart, extEnd); if (glewExperimental || GLEW_REGAL_extension_query) GLEW_REGAL_extension_query = !_glewInit_GL_REGAL_extension_query(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_REGAL_extension_query */ #ifdef GL_REGAL_log GLEW_REGAL_log = _glewSearchExtension("GL_REGAL_log", extStart, extEnd); if (glewExperimental || GLEW_REGAL_log) GLEW_REGAL_log = !_glewInit_GL_REGAL_log(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_REGAL_log */ #ifdef GL_REGAL_proc_address GLEW_REGAL_proc_address = _glewSearchExtension("GL_REGAL_proc_address", extStart, extEnd); if (glewExperimental || GLEW_REGAL_proc_address) GLEW_REGAL_proc_address = !_glewInit_GL_REGAL_proc_address(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_REGAL_proc_address */ #ifdef GL_REND_screen_coordinates GLEW_REND_screen_coordinates = _glewSearchExtension("GL_REND_screen_coordinates", extStart, extEnd); #endif /* GL_REND_screen_coordinates */ #ifdef GL_S3_s3tc GLEW_S3_s3tc = _glewSearchExtension("GL_S3_s3tc", extStart, extEnd); #endif /* GL_S3_s3tc */ #ifdef GL_SGIS_color_range GLEW_SGIS_color_range = _glewSearchExtension("GL_SGIS_color_range", extStart, extEnd); #endif /* GL_SGIS_color_range */ #ifdef GL_SGIS_detail_texture GLEW_SGIS_detail_texture = _glewSearchExtension("GL_SGIS_detail_texture", extStart, extEnd); if (glewExperimental || GLEW_SGIS_detail_texture) GLEW_SGIS_detail_texture = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIS_detail_texture */ #ifdef GL_SGIS_fog_function GLEW_SGIS_fog_function = _glewSearchExtension("GL_SGIS_fog_function", extStart, extEnd); if (glewExperimental || GLEW_SGIS_fog_function) GLEW_SGIS_fog_function = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIS_fog_function */ #ifdef GL_SGIS_generate_mipmap GLEW_SGIS_generate_mipmap = _glewSearchExtension("GL_SGIS_generate_mipmap", extStart, extEnd); #endif /* GL_SGIS_generate_mipmap */ #ifdef GL_SGIS_multisample GLEW_SGIS_multisample = _glewSearchExtension("GL_SGIS_multisample", extStart, extEnd); if (glewExperimental || GLEW_SGIS_multisample) GLEW_SGIS_multisample = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIS_multisample */ #ifdef GL_SGIS_pixel_texture GLEW_SGIS_pixel_texture = _glewSearchExtension("GL_SGIS_pixel_texture", extStart, extEnd); #endif /* GL_SGIS_pixel_texture */ #ifdef GL_SGIS_point_line_texgen GLEW_SGIS_point_line_texgen = _glewSearchExtension("GL_SGIS_point_line_texgen", extStart, extEnd); #endif /* GL_SGIS_point_line_texgen */ #ifdef GL_SGIS_sharpen_texture GLEW_SGIS_sharpen_texture = _glewSearchExtension("GL_SGIS_sharpen_texture", extStart, extEnd); if (glewExperimental || GLEW_SGIS_sharpen_texture) GLEW_SGIS_sharpen_texture = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIS_sharpen_texture */ #ifdef GL_SGIS_texture4D GLEW_SGIS_texture4D = _glewSearchExtension("GL_SGIS_texture4D", extStart, extEnd); if (glewExperimental || GLEW_SGIS_texture4D) GLEW_SGIS_texture4D = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIS_texture4D */ #ifdef GL_SGIS_texture_border_clamp GLEW_SGIS_texture_border_clamp = _glewSearchExtension("GL_SGIS_texture_border_clamp", extStart, extEnd); #endif /* GL_SGIS_texture_border_clamp */ #ifdef GL_SGIS_texture_edge_clamp GLEW_SGIS_texture_edge_clamp = _glewSearchExtension("GL_SGIS_texture_edge_clamp", extStart, extEnd); #endif /* GL_SGIS_texture_edge_clamp */ #ifdef GL_SGIS_texture_filter4 GLEW_SGIS_texture_filter4 = _glewSearchExtension("GL_SGIS_texture_filter4", extStart, extEnd); if (glewExperimental || GLEW_SGIS_texture_filter4) GLEW_SGIS_texture_filter4 = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIS_texture_filter4 */ #ifdef GL_SGIS_texture_lod GLEW_SGIS_texture_lod = _glewSearchExtension("GL_SGIS_texture_lod", extStart, extEnd); #endif /* GL_SGIS_texture_lod */ #ifdef GL_SGIS_texture_select GLEW_SGIS_texture_select = _glewSearchExtension("GL_SGIS_texture_select", extStart, extEnd); #endif /* GL_SGIS_texture_select */ #ifdef GL_SGIX_async GLEW_SGIX_async = _glewSearchExtension("GL_SGIX_async", extStart, extEnd); if (glewExperimental || GLEW_SGIX_async) GLEW_SGIX_async = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_async */ #ifdef GL_SGIX_async_histogram GLEW_SGIX_async_histogram = _glewSearchExtension("GL_SGIX_async_histogram", extStart, extEnd); #endif /* GL_SGIX_async_histogram */ #ifdef GL_SGIX_async_pixel GLEW_SGIX_async_pixel = _glewSearchExtension("GL_SGIX_async_pixel", extStart, extEnd); #endif /* GL_SGIX_async_pixel */ #ifdef GL_SGIX_blend_alpha_minmax GLEW_SGIX_blend_alpha_minmax = _glewSearchExtension("GL_SGIX_blend_alpha_minmax", extStart, extEnd); #endif /* GL_SGIX_blend_alpha_minmax */ #ifdef GL_SGIX_clipmap GLEW_SGIX_clipmap = _glewSearchExtension("GL_SGIX_clipmap", extStart, extEnd); #endif /* GL_SGIX_clipmap */ #ifdef GL_SGIX_convolution_accuracy GLEW_SGIX_convolution_accuracy = _glewSearchExtension("GL_SGIX_convolution_accuracy", extStart, extEnd); #endif /* GL_SGIX_convolution_accuracy */ #ifdef GL_SGIX_depth_texture GLEW_SGIX_depth_texture = _glewSearchExtension("GL_SGIX_depth_texture", extStart, extEnd); #endif /* GL_SGIX_depth_texture */ #ifdef GL_SGIX_flush_raster GLEW_SGIX_flush_raster = _glewSearchExtension("GL_SGIX_flush_raster", extStart, extEnd); if (glewExperimental || GLEW_SGIX_flush_raster) GLEW_SGIX_flush_raster = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_flush_raster */ #ifdef GL_SGIX_fog_offset GLEW_SGIX_fog_offset = _glewSearchExtension("GL_SGIX_fog_offset", extStart, extEnd); #endif /* GL_SGIX_fog_offset */ #ifdef GL_SGIX_fog_texture GLEW_SGIX_fog_texture = _glewSearchExtension("GL_SGIX_fog_texture", extStart, extEnd); if (glewExperimental || GLEW_SGIX_fog_texture) GLEW_SGIX_fog_texture = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_fog_texture */ #ifdef GL_SGIX_fragment_specular_lighting GLEW_SGIX_fragment_specular_lighting = _glewSearchExtension("GL_SGIX_fragment_specular_lighting", extStart, extEnd); if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) GLEW_SGIX_fragment_specular_lighting = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_fragment_specular_lighting */ #ifdef GL_SGIX_framezoom GLEW_SGIX_framezoom = _glewSearchExtension("GL_SGIX_framezoom", extStart, extEnd); if (glewExperimental || GLEW_SGIX_framezoom) GLEW_SGIX_framezoom = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_framezoom */ #ifdef GL_SGIX_interlace GLEW_SGIX_interlace = _glewSearchExtension("GL_SGIX_interlace", extStart, extEnd); #endif /* GL_SGIX_interlace */ #ifdef GL_SGIX_ir_instrument1 GLEW_SGIX_ir_instrument1 = _glewSearchExtension("GL_SGIX_ir_instrument1", extStart, extEnd); #endif /* GL_SGIX_ir_instrument1 */ #ifdef GL_SGIX_list_priority GLEW_SGIX_list_priority = _glewSearchExtension("GL_SGIX_list_priority", extStart, extEnd); #endif /* GL_SGIX_list_priority */ #ifdef GL_SGIX_pixel_texture GLEW_SGIX_pixel_texture = _glewSearchExtension("GL_SGIX_pixel_texture", extStart, extEnd); if (glewExperimental || GLEW_SGIX_pixel_texture) GLEW_SGIX_pixel_texture = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_pixel_texture */ #ifdef GL_SGIX_pixel_texture_bits GLEW_SGIX_pixel_texture_bits = _glewSearchExtension("GL_SGIX_pixel_texture_bits", extStart, extEnd); #endif /* GL_SGIX_pixel_texture_bits */ #ifdef GL_SGIX_reference_plane GLEW_SGIX_reference_plane = _glewSearchExtension("GL_SGIX_reference_plane", extStart, extEnd); if (glewExperimental || GLEW_SGIX_reference_plane) GLEW_SGIX_reference_plane = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_reference_plane */ #ifdef GL_SGIX_resample GLEW_SGIX_resample = _glewSearchExtension("GL_SGIX_resample", extStart, extEnd); #endif /* GL_SGIX_resample */ #ifdef GL_SGIX_shadow GLEW_SGIX_shadow = _glewSearchExtension("GL_SGIX_shadow", extStart, extEnd); #endif /* GL_SGIX_shadow */ #ifdef GL_SGIX_shadow_ambient GLEW_SGIX_shadow_ambient = _glewSearchExtension("GL_SGIX_shadow_ambient", extStart, extEnd); #endif /* GL_SGIX_shadow_ambient */ #ifdef GL_SGIX_sprite GLEW_SGIX_sprite = _glewSearchExtension("GL_SGIX_sprite", extStart, extEnd); if (glewExperimental || GLEW_SGIX_sprite) GLEW_SGIX_sprite = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_sprite */ #ifdef GL_SGIX_tag_sample_buffer GLEW_SGIX_tag_sample_buffer = _glewSearchExtension("GL_SGIX_tag_sample_buffer", extStart, extEnd); if (glewExperimental || GLEW_SGIX_tag_sample_buffer) GLEW_SGIX_tag_sample_buffer = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGIX_tag_sample_buffer */ #ifdef GL_SGIX_texture_add_env GLEW_SGIX_texture_add_env = _glewSearchExtension("GL_SGIX_texture_add_env", extStart, extEnd); #endif /* GL_SGIX_texture_add_env */ #ifdef GL_SGIX_texture_coordinate_clamp GLEW_SGIX_texture_coordinate_clamp = _glewSearchExtension("GL_SGIX_texture_coordinate_clamp", extStart, extEnd); #endif /* GL_SGIX_texture_coordinate_clamp */ #ifdef GL_SGIX_texture_lod_bias GLEW_SGIX_texture_lod_bias = _glewSearchExtension("GL_SGIX_texture_lod_bias", extStart, extEnd); #endif /* GL_SGIX_texture_lod_bias */ #ifdef GL_SGIX_texture_multi_buffer GLEW_SGIX_texture_multi_buffer = _glewSearchExtension("GL_SGIX_texture_multi_buffer", extStart, extEnd); #endif /* GL_SGIX_texture_multi_buffer */ #ifdef GL_SGIX_texture_range GLEW_SGIX_texture_range = _glewSearchExtension("GL_SGIX_texture_range", extStart, extEnd); #endif /* GL_SGIX_texture_range */ #ifdef GL_SGIX_texture_scale_bias GLEW_SGIX_texture_scale_bias = _glewSearchExtension("GL_SGIX_texture_scale_bias", extStart, extEnd); #endif /* GL_SGIX_texture_scale_bias */ #ifdef GL_SGIX_vertex_preclip GLEW_SGIX_vertex_preclip = _glewSearchExtension("GL_SGIX_vertex_preclip", extStart, extEnd); #endif /* GL_SGIX_vertex_preclip */ #ifdef GL_SGIX_vertex_preclip_hint GLEW_SGIX_vertex_preclip_hint = _glewSearchExtension("GL_SGIX_vertex_preclip_hint", extStart, extEnd); #endif /* GL_SGIX_vertex_preclip_hint */ #ifdef GL_SGIX_ycrcb GLEW_SGIX_ycrcb = _glewSearchExtension("GL_SGIX_ycrcb", extStart, extEnd); #endif /* GL_SGIX_ycrcb */ #ifdef GL_SGI_color_matrix GLEW_SGI_color_matrix = _glewSearchExtension("GL_SGI_color_matrix", extStart, extEnd); #endif /* GL_SGI_color_matrix */ #ifdef GL_SGI_color_table GLEW_SGI_color_table = _glewSearchExtension("GL_SGI_color_table", extStart, extEnd); if (glewExperimental || GLEW_SGI_color_table) GLEW_SGI_color_table = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SGI_color_table */ #ifdef GL_SGI_texture_color_table GLEW_SGI_texture_color_table = _glewSearchExtension("GL_SGI_texture_color_table", extStart, extEnd); #endif /* GL_SGI_texture_color_table */ #ifdef GL_SUNX_constant_data GLEW_SUNX_constant_data = _glewSearchExtension("GL_SUNX_constant_data", extStart, extEnd); if (glewExperimental || GLEW_SUNX_constant_data) GLEW_SUNX_constant_data = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SUNX_constant_data */ #ifdef GL_SUN_convolution_border_modes GLEW_SUN_convolution_border_modes = _glewSearchExtension("GL_SUN_convolution_border_modes", extStart, extEnd); #endif /* GL_SUN_convolution_border_modes */ #ifdef GL_SUN_global_alpha GLEW_SUN_global_alpha = _glewSearchExtension("GL_SUN_global_alpha", extStart, extEnd); if (glewExperimental || GLEW_SUN_global_alpha) GLEW_SUN_global_alpha = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SUN_global_alpha */ #ifdef GL_SUN_mesh_array GLEW_SUN_mesh_array = _glewSearchExtension("GL_SUN_mesh_array", extStart, extEnd); #endif /* GL_SUN_mesh_array */ #ifdef GL_SUN_read_video_pixels GLEW_SUN_read_video_pixels = _glewSearchExtension("GL_SUN_read_video_pixels", extStart, extEnd); if (glewExperimental || GLEW_SUN_read_video_pixels) GLEW_SUN_read_video_pixels = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SUN_read_video_pixels */ #ifdef GL_SUN_slice_accum GLEW_SUN_slice_accum = _glewSearchExtension("GL_SUN_slice_accum", extStart, extEnd); #endif /* GL_SUN_slice_accum */ #ifdef GL_SUN_triangle_list GLEW_SUN_triangle_list = _glewSearchExtension("GL_SUN_triangle_list", extStart, extEnd); if (glewExperimental || GLEW_SUN_triangle_list) GLEW_SUN_triangle_list = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SUN_triangle_list */ #ifdef GL_SUN_vertex GLEW_SUN_vertex = _glewSearchExtension("GL_SUN_vertex", extStart, extEnd); if (glewExperimental || GLEW_SUN_vertex) GLEW_SUN_vertex = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_SUN_vertex */ #ifdef GL_WIN_phong_shading GLEW_WIN_phong_shading = _glewSearchExtension("GL_WIN_phong_shading", extStart, extEnd); #endif /* GL_WIN_phong_shading */ #ifdef GL_WIN_specular_fog GLEW_WIN_specular_fog = _glewSearchExtension("GL_WIN_specular_fog", extStart, extEnd); #endif /* GL_WIN_specular_fog */ #ifdef GL_WIN_swap_hint GLEW_WIN_swap_hint = _glewSearchExtension("GL_WIN_swap_hint", extStart, extEnd); if (glewExperimental || GLEW_WIN_swap_hint) GLEW_WIN_swap_hint = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GL_WIN_swap_hint */ return GLEW_OK; } #if defined(_WIN32) #if !defined(GLEW_MX) PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL; PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL; PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL; PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL; PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL; PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL; PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL; PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL; PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL; PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL; PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL; PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL; PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL; PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL; PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL; PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL; PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL; PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL; PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL; PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL; PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL; PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL; PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL; PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL; PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL; PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL; PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL; PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL; PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL; PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL; PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL; PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL; PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL; PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL; PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL; PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL; PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL; PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL; PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL; PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL; PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL; PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL; PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL; PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL; PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL; PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL; PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL; PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL; PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL; PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL; PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL; PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL; PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL; PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL; PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL; PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL; PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL; PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL; PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL; PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL; PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL; PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL; PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL; PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL; PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL; PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL; PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL; PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL; PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL; PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL; PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL; PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL; PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL; PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL; PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL; PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL; PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV = NULL; PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV = NULL; PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV = NULL; PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV = NULL; PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV = NULL; PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV = NULL; PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV = NULL; PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV = NULL; PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL; PFNWGLDELAYBEFORESWAPNVPROC __wglewDelayBeforeSwapNV = NULL; PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL; PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL; PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL; PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL; PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL; PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL; PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL; PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL; PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL; PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL; PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL; PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL; PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL; PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL; PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL; PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL; PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV = NULL; PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV = NULL; PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV = NULL; PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV = NULL; PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV = NULL; PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL; PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL; PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL; PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL; PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL; PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL; PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL; PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL; PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL; PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL; PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL; PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL; GLboolean __WGLEW_3DFX_multisample = GL_FALSE; GLboolean __WGLEW_3DL_stereo_control = GL_FALSE; GLboolean __WGLEW_AMD_gpu_association = GL_FALSE; GLboolean __WGLEW_ARB_buffer_region = GL_FALSE; GLboolean __WGLEW_ARB_context_flush_control = GL_FALSE; GLboolean __WGLEW_ARB_create_context = GL_FALSE; GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE; GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE; GLboolean __WGLEW_ARB_extensions_string = GL_FALSE; GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE; GLboolean __WGLEW_ARB_make_current_read = GL_FALSE; GLboolean __WGLEW_ARB_multisample = GL_FALSE; GLboolean __WGLEW_ARB_pbuffer = GL_FALSE; GLboolean __WGLEW_ARB_pixel_format = GL_FALSE; GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE; GLboolean __WGLEW_ARB_render_texture = GL_FALSE; GLboolean __WGLEW_ARB_robustness_application_isolation = GL_FALSE; GLboolean __WGLEW_ARB_robustness_share_group_isolation = GL_FALSE; GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE; GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE; GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE; GLboolean __WGLEW_EXT_create_context_es_profile = GL_FALSE; GLboolean __WGLEW_EXT_depth_float = GL_FALSE; GLboolean __WGLEW_EXT_display_color_table = GL_FALSE; GLboolean __WGLEW_EXT_extensions_string = GL_FALSE; GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE; GLboolean __WGLEW_EXT_make_current_read = GL_FALSE; GLboolean __WGLEW_EXT_multisample = GL_FALSE; GLboolean __WGLEW_EXT_pbuffer = GL_FALSE; GLboolean __WGLEW_EXT_pixel_format = GL_FALSE; GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE; GLboolean __WGLEW_EXT_swap_control = GL_FALSE; GLboolean __WGLEW_EXT_swap_control_tear = GL_FALSE; GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE; GLboolean __WGLEW_I3D_gamma = GL_FALSE; GLboolean __WGLEW_I3D_genlock = GL_FALSE; GLboolean __WGLEW_I3D_image_buffer = GL_FALSE; GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE; GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE; GLboolean __WGLEW_NV_DX_interop = GL_FALSE; GLboolean __WGLEW_NV_DX_interop2 = GL_FALSE; GLboolean __WGLEW_NV_copy_image = GL_FALSE; GLboolean __WGLEW_NV_delay_before_swap = GL_FALSE; GLboolean __WGLEW_NV_float_buffer = GL_FALSE; GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE; GLboolean __WGLEW_NV_multisample_coverage = GL_FALSE; GLboolean __WGLEW_NV_present_video = GL_FALSE; GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE; GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE; GLboolean __WGLEW_NV_swap_group = GL_FALSE; GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE; GLboolean __WGLEW_NV_video_capture = GL_FALSE; GLboolean __WGLEW_NV_video_output = GL_FALSE; GLboolean __WGLEW_OML_sync_control = GL_FALSE; #endif /* !GLEW_MX */ #ifdef WGL_3DL_stereo_control static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r; return r; } #endif /* WGL_3DL_stereo_control */ #ifdef WGL_AMD_gpu_association static GLboolean _glewInit_WGL_AMD_gpu_association (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r; r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r; r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r; r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r; r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r; r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r; r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r; r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r; r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r; return r; } #endif /* WGL_AMD_gpu_association */ #ifdef WGL_ARB_buffer_region static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r; r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r; r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r; r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r; return r; } #endif /* WGL_ARB_buffer_region */ #ifdef WGL_ARB_create_context static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r; return r; } #endif /* WGL_ARB_create_context */ #ifdef WGL_ARB_extensions_string static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r; return r; } #endif /* WGL_ARB_extensions_string */ #ifdef WGL_ARB_make_current_read static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r; r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r; return r; } #endif /* WGL_ARB_make_current_read */ #ifdef WGL_ARB_pbuffer static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r; r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r; r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r; r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r; r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r; return r; } #endif /* WGL_ARB_pbuffer */ #ifdef WGL_ARB_pixel_format static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r; r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r; r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r; return r; } #endif /* WGL_ARB_pixel_format */ #ifdef WGL_ARB_render_texture static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r; r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r; r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r; return r; } #endif /* WGL_ARB_render_texture */ #ifdef WGL_EXT_display_color_table static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r; r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r; r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r; r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r; return r; } #endif /* WGL_EXT_display_color_table */ #ifdef WGL_EXT_extensions_string static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r; return r; } #endif /* WGL_EXT_extensions_string */ #ifdef WGL_EXT_make_current_read static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r; r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r; return r; } #endif /* WGL_EXT_make_current_read */ #ifdef WGL_EXT_pbuffer static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r; r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r; r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r; r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r; r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r; return r; } #endif /* WGL_EXT_pbuffer */ #ifdef WGL_EXT_pixel_format static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r; r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r; r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r; return r; } #endif /* WGL_EXT_pixel_format */ #ifdef WGL_EXT_swap_control static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r; r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r; return r; } #endif /* WGL_EXT_swap_control */ #ifdef WGL_I3D_digital_video_control static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r; r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r; return r; } #endif /* WGL_I3D_digital_video_control */ #ifdef WGL_I3D_gamma static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r; r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r; r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r; r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r; return r; } #endif /* WGL_I3D_gamma */ #ifdef WGL_I3D_genlock static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r; r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r; r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r; r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r; r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r; r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r; r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r; r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r; r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r; r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r; r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r; r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r; return r; } #endif /* WGL_I3D_genlock */ #ifdef WGL_I3D_image_buffer static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r; r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r; r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r; r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r; return r; } #endif /* WGL_I3D_image_buffer */ #ifdef WGL_I3D_swap_frame_lock static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r; r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r; r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r; r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r; return r; } #endif /* WGL_I3D_swap_frame_lock */ #ifdef WGL_I3D_swap_frame_usage static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r; r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r; r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r; r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r; return r; } #endif /* WGL_I3D_swap_frame_usage */ #ifdef WGL_NV_DX_interop static GLboolean _glewInit_WGL_NV_DX_interop (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXCloseDeviceNV")) == NULL) || r; r = ((wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXLockObjectsNV")) == NULL) || r; r = ((wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXObjectAccessNV")) == NULL) || r; r = ((wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXOpenDeviceNV")) == NULL) || r; r = ((wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXRegisterObjectNV")) == NULL) || r; r = ((wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"wglDXSetResourceShareHandleNV")) == NULL) || r; r = ((wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnlockObjectsNV")) == NULL) || r; r = ((wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnregisterObjectNV")) == NULL) || r; return r; } #endif /* WGL_NV_DX_interop */ #ifdef WGL_NV_copy_image static GLboolean _glewInit_WGL_NV_copy_image (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r; return r; } #endif /* WGL_NV_copy_image */ #ifdef WGL_NV_delay_before_swap static GLboolean _glewInit_WGL_NV_delay_before_swap (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglDelayBeforeSwapNV = (PFNWGLDELAYBEFORESWAPNVPROC)glewGetProcAddress((const GLubyte*)"wglDelayBeforeSwapNV")) == NULL) || r; return r; } #endif /* WGL_NV_delay_before_swap */ #ifdef WGL_NV_gpu_affinity static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r; r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r; r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r; r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r; r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r; return r; } #endif /* WGL_NV_gpu_affinity */ #ifdef WGL_NV_present_video static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r; r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r; r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r; return r; } #endif /* WGL_NV_present_video */ #ifdef WGL_NV_swap_group static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r; r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r; r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r; r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r; r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r; r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r; return r; } #endif /* WGL_NV_swap_group */ #ifdef WGL_NV_vertex_array_range static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r; r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r; return r; } #endif /* WGL_NV_vertex_array_range */ #ifdef WGL_NV_video_capture static GLboolean _glewInit_WGL_NV_video_capture (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoCaptureDeviceNV")) == NULL) || r; r = ((wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoCaptureDevicesNV")) == NULL) || r; r = ((wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglLockVideoCaptureDeviceNV")) == NULL) || r; r = ((wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglQueryVideoCaptureDeviceNV")) == NULL) || r; r = ((wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoCaptureDeviceNV")) == NULL) || r; return r; } #endif /* WGL_NV_video_capture */ #ifdef WGL_NV_video_output static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r; r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r; r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r; r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r; r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r; r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r; return r; } #endif /* WGL_NV_video_output */ #ifdef WGL_OML_sync_control static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r; r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r; r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r; r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r; r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r; r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r; return r; } #endif /* WGL_OML_sync_control */ /* ------------------------------------------------------------------------- */ static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL; static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL; GLboolean GLEWAPIENTRY wglewGetExtension (const char* name) { const GLubyte* start; const GLubyte* end; if (_wglewGetExtensionsStringARB == NULL) if (_wglewGetExtensionsStringEXT == NULL) return GL_FALSE; else start = (const GLubyte*)_wglewGetExtensionsStringEXT(); else start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); if (start == 0) return GL_FALSE; end = start + _glewStrLen(start); return _glewSearchExtension(name, start, end); } #ifdef GLEW_MX GLenum GLEWAPIENTRY wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST) #else GLenum GLEWAPIENTRY wglewInit (WGLEW_CONTEXT_ARG_DEF_LIST) #endif { GLboolean crippled; const GLubyte* extStart; const GLubyte* extEnd; /* find wgl extension string query functions */ _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB"); _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT"); /* query wgl extension string */ if (_wglewGetExtensionsStringARB == NULL) if (_wglewGetExtensionsStringEXT == NULL) extStart = (const GLubyte*)""; else extStart = (const GLubyte*)_wglewGetExtensionsStringEXT(); else extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); extEnd = extStart + _glewStrLen(extStart); /* initialize extensions */ crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL; #ifdef WGL_3DFX_multisample WGLEW_3DFX_multisample = _glewSearchExtension("WGL_3DFX_multisample", extStart, extEnd); #endif /* WGL_3DFX_multisample */ #ifdef WGL_3DL_stereo_control WGLEW_3DL_stereo_control = _glewSearchExtension("WGL_3DL_stereo_control", extStart, extEnd); if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) WGLEW_3DL_stereo_control= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_3DL_stereo_control */ #ifdef WGL_AMD_gpu_association WGLEW_AMD_gpu_association = _glewSearchExtension("WGL_AMD_gpu_association", extStart, extEnd); if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) WGLEW_AMD_gpu_association= !_glewInit_WGL_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_AMD_gpu_association */ #ifdef WGL_ARB_buffer_region WGLEW_ARB_buffer_region = _glewSearchExtension("WGL_ARB_buffer_region", extStart, extEnd); if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) WGLEW_ARB_buffer_region= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_buffer_region */ #ifdef WGL_ARB_context_flush_control WGLEW_ARB_context_flush_control = _glewSearchExtension("WGL_ARB_context_flush_control", extStart, extEnd); #endif /* WGL_ARB_context_flush_control */ #ifdef WGL_ARB_create_context WGLEW_ARB_create_context = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd); if (glewExperimental || WGLEW_ARB_create_context|| crippled) WGLEW_ARB_create_context= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_create_context */ #ifdef WGL_ARB_create_context_profile WGLEW_ARB_create_context_profile = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd); #endif /* WGL_ARB_create_context_profile */ #ifdef WGL_ARB_create_context_robustness WGLEW_ARB_create_context_robustness = _glewSearchExtension("WGL_ARB_create_context_robustness", extStart, extEnd); #endif /* WGL_ARB_create_context_robustness */ #ifdef WGL_ARB_extensions_string WGLEW_ARB_extensions_string = _glewSearchExtension("WGL_ARB_extensions_string", extStart, extEnd); if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) WGLEW_ARB_extensions_string= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_extensions_string */ #ifdef WGL_ARB_framebuffer_sRGB WGLEW_ARB_framebuffer_sRGB = _glewSearchExtension("WGL_ARB_framebuffer_sRGB", extStart, extEnd); #endif /* WGL_ARB_framebuffer_sRGB */ #ifdef WGL_ARB_make_current_read WGLEW_ARB_make_current_read = _glewSearchExtension("WGL_ARB_make_current_read", extStart, extEnd); if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) WGLEW_ARB_make_current_read= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_make_current_read */ #ifdef WGL_ARB_multisample WGLEW_ARB_multisample = _glewSearchExtension("WGL_ARB_multisample", extStart, extEnd); #endif /* WGL_ARB_multisample */ #ifdef WGL_ARB_pbuffer WGLEW_ARB_pbuffer = _glewSearchExtension("WGL_ARB_pbuffer", extStart, extEnd); if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) WGLEW_ARB_pbuffer= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_pbuffer */ #ifdef WGL_ARB_pixel_format WGLEW_ARB_pixel_format = _glewSearchExtension("WGL_ARB_pixel_format", extStart, extEnd); if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) WGLEW_ARB_pixel_format= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_pixel_format */ #ifdef WGL_ARB_pixel_format_float WGLEW_ARB_pixel_format_float = _glewSearchExtension("WGL_ARB_pixel_format_float", extStart, extEnd); #endif /* WGL_ARB_pixel_format_float */ #ifdef WGL_ARB_render_texture WGLEW_ARB_render_texture = _glewSearchExtension("WGL_ARB_render_texture", extStart, extEnd); if (glewExperimental || WGLEW_ARB_render_texture|| crippled) WGLEW_ARB_render_texture= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_ARB_render_texture */ #ifdef WGL_ARB_robustness_application_isolation WGLEW_ARB_robustness_application_isolation = _glewSearchExtension("WGL_ARB_robustness_application_isolation", extStart, extEnd); #endif /* WGL_ARB_robustness_application_isolation */ #ifdef WGL_ARB_robustness_share_group_isolation WGLEW_ARB_robustness_share_group_isolation = _glewSearchExtension("WGL_ARB_robustness_share_group_isolation", extStart, extEnd); #endif /* WGL_ARB_robustness_share_group_isolation */ #ifdef WGL_ATI_pixel_format_float WGLEW_ATI_pixel_format_float = _glewSearchExtension("WGL_ATI_pixel_format_float", extStart, extEnd); #endif /* WGL_ATI_pixel_format_float */ #ifdef WGL_ATI_render_texture_rectangle WGLEW_ATI_render_texture_rectangle = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd); #endif /* WGL_ATI_render_texture_rectangle */ #ifdef WGL_EXT_create_context_es2_profile WGLEW_EXT_create_context_es2_profile = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd); #endif /* WGL_EXT_create_context_es2_profile */ #ifdef WGL_EXT_create_context_es_profile WGLEW_EXT_create_context_es_profile = _glewSearchExtension("WGL_EXT_create_context_es_profile", extStart, extEnd); #endif /* WGL_EXT_create_context_es_profile */ #ifdef WGL_EXT_depth_float WGLEW_EXT_depth_float = _glewSearchExtension("WGL_EXT_depth_float", extStart, extEnd); #endif /* WGL_EXT_depth_float */ #ifdef WGL_EXT_display_color_table WGLEW_EXT_display_color_table = _glewSearchExtension("WGL_EXT_display_color_table", extStart, extEnd); if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) WGLEW_EXT_display_color_table= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_EXT_display_color_table */ #ifdef WGL_EXT_extensions_string WGLEW_EXT_extensions_string = _glewSearchExtension("WGL_EXT_extensions_string", extStart, extEnd); if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) WGLEW_EXT_extensions_string= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_EXT_extensions_string */ #ifdef WGL_EXT_framebuffer_sRGB WGLEW_EXT_framebuffer_sRGB = _glewSearchExtension("WGL_EXT_framebuffer_sRGB", extStart, extEnd); #endif /* WGL_EXT_framebuffer_sRGB */ #ifdef WGL_EXT_make_current_read WGLEW_EXT_make_current_read = _glewSearchExtension("WGL_EXT_make_current_read", extStart, extEnd); if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) WGLEW_EXT_make_current_read= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_EXT_make_current_read */ #ifdef WGL_EXT_multisample WGLEW_EXT_multisample = _glewSearchExtension("WGL_EXT_multisample", extStart, extEnd); #endif /* WGL_EXT_multisample */ #ifdef WGL_EXT_pbuffer WGLEW_EXT_pbuffer = _glewSearchExtension("WGL_EXT_pbuffer", extStart, extEnd); if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) WGLEW_EXT_pbuffer= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_EXT_pbuffer */ #ifdef WGL_EXT_pixel_format WGLEW_EXT_pixel_format = _glewSearchExtension("WGL_EXT_pixel_format", extStart, extEnd); if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) WGLEW_EXT_pixel_format= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_EXT_pixel_format */ #ifdef WGL_EXT_pixel_format_packed_float WGLEW_EXT_pixel_format_packed_float = _glewSearchExtension("WGL_EXT_pixel_format_packed_float", extStart, extEnd); #endif /* WGL_EXT_pixel_format_packed_float */ #ifdef WGL_EXT_swap_control WGLEW_EXT_swap_control = _glewSearchExtension("WGL_EXT_swap_control", extStart, extEnd); if (glewExperimental || WGLEW_EXT_swap_control|| crippled) WGLEW_EXT_swap_control= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_EXT_swap_control */ #ifdef WGL_EXT_swap_control_tear WGLEW_EXT_swap_control_tear = _glewSearchExtension("WGL_EXT_swap_control_tear", extStart, extEnd); #endif /* WGL_EXT_swap_control_tear */ #ifdef WGL_I3D_digital_video_control WGLEW_I3D_digital_video_control = _glewSearchExtension("WGL_I3D_digital_video_control", extStart, extEnd); if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) WGLEW_I3D_digital_video_control= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_I3D_digital_video_control */ #ifdef WGL_I3D_gamma WGLEW_I3D_gamma = _glewSearchExtension("WGL_I3D_gamma", extStart, extEnd); if (glewExperimental || WGLEW_I3D_gamma|| crippled) WGLEW_I3D_gamma= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_I3D_gamma */ #ifdef WGL_I3D_genlock WGLEW_I3D_genlock = _glewSearchExtension("WGL_I3D_genlock", extStart, extEnd); if (glewExperimental || WGLEW_I3D_genlock|| crippled) WGLEW_I3D_genlock= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_I3D_genlock */ #ifdef WGL_I3D_image_buffer WGLEW_I3D_image_buffer = _glewSearchExtension("WGL_I3D_image_buffer", extStart, extEnd); if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) WGLEW_I3D_image_buffer= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_I3D_image_buffer */ #ifdef WGL_I3D_swap_frame_lock WGLEW_I3D_swap_frame_lock = _glewSearchExtension("WGL_I3D_swap_frame_lock", extStart, extEnd); if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) WGLEW_I3D_swap_frame_lock= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_I3D_swap_frame_lock */ #ifdef WGL_I3D_swap_frame_usage WGLEW_I3D_swap_frame_usage = _glewSearchExtension("WGL_I3D_swap_frame_usage", extStart, extEnd); if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) WGLEW_I3D_swap_frame_usage= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_I3D_swap_frame_usage */ #ifdef WGL_NV_DX_interop WGLEW_NV_DX_interop = _glewSearchExtension("WGL_NV_DX_interop", extStart, extEnd); if (glewExperimental || WGLEW_NV_DX_interop|| crippled) WGLEW_NV_DX_interop= !_glewInit_WGL_NV_DX_interop(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_DX_interop */ #ifdef WGL_NV_DX_interop2 WGLEW_NV_DX_interop2 = _glewSearchExtension("WGL_NV_DX_interop2", extStart, extEnd); #endif /* WGL_NV_DX_interop2 */ #ifdef WGL_NV_copy_image WGLEW_NV_copy_image = _glewSearchExtension("WGL_NV_copy_image", extStart, extEnd); if (glewExperimental || WGLEW_NV_copy_image|| crippled) WGLEW_NV_copy_image= !_glewInit_WGL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_copy_image */ #ifdef WGL_NV_delay_before_swap WGLEW_NV_delay_before_swap = _glewSearchExtension("WGL_NV_delay_before_swap", extStart, extEnd); if (glewExperimental || WGLEW_NV_delay_before_swap|| crippled) WGLEW_NV_delay_before_swap= !_glewInit_WGL_NV_delay_before_swap(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_delay_before_swap */ #ifdef WGL_NV_float_buffer WGLEW_NV_float_buffer = _glewSearchExtension("WGL_NV_float_buffer", extStart, extEnd); #endif /* WGL_NV_float_buffer */ #ifdef WGL_NV_gpu_affinity WGLEW_NV_gpu_affinity = _glewSearchExtension("WGL_NV_gpu_affinity", extStart, extEnd); if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) WGLEW_NV_gpu_affinity= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_gpu_affinity */ #ifdef WGL_NV_multisample_coverage WGLEW_NV_multisample_coverage = _glewSearchExtension("WGL_NV_multisample_coverage", extStart, extEnd); #endif /* WGL_NV_multisample_coverage */ #ifdef WGL_NV_present_video WGLEW_NV_present_video = _glewSearchExtension("WGL_NV_present_video", extStart, extEnd); if (glewExperimental || WGLEW_NV_present_video|| crippled) WGLEW_NV_present_video= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_present_video */ #ifdef WGL_NV_render_depth_texture WGLEW_NV_render_depth_texture = _glewSearchExtension("WGL_NV_render_depth_texture", extStart, extEnd); #endif /* WGL_NV_render_depth_texture */ #ifdef WGL_NV_render_texture_rectangle WGLEW_NV_render_texture_rectangle = _glewSearchExtension("WGL_NV_render_texture_rectangle", extStart, extEnd); #endif /* WGL_NV_render_texture_rectangle */ #ifdef WGL_NV_swap_group WGLEW_NV_swap_group = _glewSearchExtension("WGL_NV_swap_group", extStart, extEnd); if (glewExperimental || WGLEW_NV_swap_group|| crippled) WGLEW_NV_swap_group= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_swap_group */ #ifdef WGL_NV_vertex_array_range WGLEW_NV_vertex_array_range = _glewSearchExtension("WGL_NV_vertex_array_range", extStart, extEnd); if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) WGLEW_NV_vertex_array_range= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_vertex_array_range */ #ifdef WGL_NV_video_capture WGLEW_NV_video_capture = _glewSearchExtension("WGL_NV_video_capture", extStart, extEnd); if (glewExperimental || WGLEW_NV_video_capture|| crippled) WGLEW_NV_video_capture= !_glewInit_WGL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_video_capture */ #ifdef WGL_NV_video_output WGLEW_NV_video_output = _glewSearchExtension("WGL_NV_video_output", extStart, extEnd); if (glewExperimental || WGLEW_NV_video_output|| crippled) WGLEW_NV_video_output= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_NV_video_output */ #ifdef WGL_OML_sync_control WGLEW_OML_sync_control = _glewSearchExtension("WGL_OML_sync_control", extStart, extEnd); if (glewExperimental || WGLEW_OML_sync_control|| crippled) WGLEW_OML_sync_control= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* WGL_OML_sync_control */ return GLEW_OK; } #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL; PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL; PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL; PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL; PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL; PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL; PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL; PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL; PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL; PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL; PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL; PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL; PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL; PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL; PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL; PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL; PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL; PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL; PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC __glewXBlitContextFramebufferAMD = NULL; PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC __glewXCreateAssociatedContextAMD = NULL; PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __glewXCreateAssociatedContextAttribsAMD = NULL; PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC __glewXDeleteAssociatedContextAMD = NULL; PFNGLXGETCONTEXTGPUIDAMDPROC __glewXGetContextGPUIDAMD = NULL; PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC __glewXGetCurrentAssociatedContextAMD = NULL; PFNGLXGETGPUIDSAMDPROC __glewXGetGPUIDsAMD = NULL; PFNGLXGETGPUINFOAMDPROC __glewXGetGPUInfoAMD = NULL; PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __glewXMakeAssociatedContextCurrentAMD = NULL; PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL; PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL; PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL; PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL; PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL; PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL; PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL; PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL; PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL; PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL; PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL; PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL; PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL; PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL; PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC __glewXQueryCurrentRendererIntegerMESA = NULL; PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC __glewXQueryCurrentRendererStringMESA = NULL; PFNGLXQUERYRENDERERINTEGERMESAPROC __glewXQueryRendererIntegerMESA = NULL; PFNGLXQUERYRENDERERSTRINGMESAPROC __glewXQueryRendererStringMESA = NULL; PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL; PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL; PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA = NULL; PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA = NULL; PFNGLXCOPYBUFFERSUBDATANVPROC __glewXCopyBufferSubDataNV = NULL; PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC __glewXNamedCopyBufferSubDataNV = NULL; PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL; PFNGLXDELAYBEFORESWAPNVPROC __glewXDelayBeforeSwapNV = NULL; PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL; PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL; PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL; PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL; PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL; PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL; PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL; PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL; PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL; PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL; PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV = NULL; PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV = NULL; PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV = NULL; PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV = NULL; PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV = NULL; PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL; PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL; PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL; PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL; PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL; PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL; PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL; PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL; PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL; PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL; PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL; PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL; PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL; PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL; PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL; PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL; PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL; PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL; PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL; PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL; PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL; PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL; PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL; PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL; PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL; PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL; PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL; PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL; PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL; PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL; PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL; PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL; PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL; PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL; PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL; PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL; PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL; PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL; PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL; PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL; PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL; PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL; PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL; PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL; PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL; PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL; PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL; #if !defined(GLEW_MX) GLboolean __GLXEW_VERSION_1_0 = GL_FALSE; GLboolean __GLXEW_VERSION_1_1 = GL_FALSE; GLboolean __GLXEW_VERSION_1_2 = GL_FALSE; GLboolean __GLXEW_VERSION_1_3 = GL_FALSE; GLboolean __GLXEW_VERSION_1_4 = GL_FALSE; GLboolean __GLXEW_3DFX_multisample = GL_FALSE; GLboolean __GLXEW_AMD_gpu_association = GL_FALSE; GLboolean __GLXEW_ARB_context_flush_control = GL_FALSE; GLboolean __GLXEW_ARB_create_context = GL_FALSE; GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE; GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE; GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE; GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE; GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE; GLboolean __GLXEW_ARB_multisample = GL_FALSE; GLboolean __GLXEW_ARB_robustness_application_isolation = GL_FALSE; GLboolean __GLXEW_ARB_robustness_share_group_isolation = GL_FALSE; GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE; GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE; GLboolean __GLXEW_ATI_render_texture = GL_FALSE; GLboolean __GLXEW_EXT_buffer_age = GL_FALSE; GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE; GLboolean __GLXEW_EXT_create_context_es_profile = GL_FALSE; GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE; GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE; GLboolean __GLXEW_EXT_import_context = GL_FALSE; GLboolean __GLXEW_EXT_scene_marker = GL_FALSE; GLboolean __GLXEW_EXT_stereo_tree = GL_FALSE; GLboolean __GLXEW_EXT_swap_control = GL_FALSE; GLboolean __GLXEW_EXT_swap_control_tear = GL_FALSE; GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE; GLboolean __GLXEW_EXT_visual_info = GL_FALSE; GLboolean __GLXEW_EXT_visual_rating = GL_FALSE; GLboolean __GLXEW_INTEL_swap_event = GL_FALSE; GLboolean __GLXEW_MESA_agp_offset = GL_FALSE; GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE; GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE; GLboolean __GLXEW_MESA_query_renderer = GL_FALSE; GLboolean __GLXEW_MESA_release_buffers = GL_FALSE; GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE; GLboolean __GLXEW_MESA_swap_control = GL_FALSE; GLboolean __GLXEW_NV_copy_buffer = GL_FALSE; GLboolean __GLXEW_NV_copy_image = GL_FALSE; GLboolean __GLXEW_NV_delay_before_swap = GL_FALSE; GLboolean __GLXEW_NV_float_buffer = GL_FALSE; GLboolean __GLXEW_NV_multisample_coverage = GL_FALSE; GLboolean __GLXEW_NV_present_video = GL_FALSE; GLboolean __GLXEW_NV_swap_group = GL_FALSE; GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE; GLboolean __GLXEW_NV_video_capture = GL_FALSE; GLboolean __GLXEW_NV_video_out = GL_FALSE; GLboolean __GLXEW_OML_swap_method = GL_FALSE; GLboolean __GLXEW_OML_sync_control = GL_FALSE; GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE; GLboolean __GLXEW_SGIS_color_range = GL_FALSE; GLboolean __GLXEW_SGIS_multisample = GL_FALSE; GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE; GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE; GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE; GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE; GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE; GLboolean __GLXEW_SGIX_swap_group = GL_FALSE; GLboolean __GLXEW_SGIX_video_resize = GL_FALSE; GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE; GLboolean __GLXEW_SGI_cushion = GL_FALSE; GLboolean __GLXEW_SGI_make_current_read = GL_FALSE; GLboolean __GLXEW_SGI_swap_control = GL_FALSE; GLboolean __GLXEW_SGI_video_sync = GL_FALSE; GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE; GLboolean __GLXEW_SUN_video_resize = GL_FALSE; #endif /* !GLEW_MX */ #ifdef GLX_VERSION_1_2 static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r; return r; } #endif /* GLX_VERSION_1_2 */ #ifdef GLX_VERSION_1_3 static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r; r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r; r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r; r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r; r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r; r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r; r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r; r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r; r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r; r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r; r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r; r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r; r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r; r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r; r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r; r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r; r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r; return r; } #endif /* GLX_VERSION_1_3 */ #ifdef GLX_AMD_gpu_association static GLboolean _glewInit_GLX_AMD_gpu_association (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBlitContextFramebufferAMD = (PFNGLXBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"glXBlitContextFramebufferAMD")) == NULL) || r; r = ((glXCreateAssociatedContextAMD = (PFNGLXCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXCreateAssociatedContextAMD")) == NULL) || r; r = ((glXCreateAssociatedContextAttribsAMD = (PFNGLXCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"glXCreateAssociatedContextAttribsAMD")) == NULL) || r; r = ((glXDeleteAssociatedContextAMD = (PFNGLXDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXDeleteAssociatedContextAMD")) == NULL) || r; r = ((glXGetContextGPUIDAMD = (PFNGLXGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetContextGPUIDAMD")) == NULL) || r; r = ((glXGetCurrentAssociatedContextAMD = (PFNGLXGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentAssociatedContextAMD")) == NULL) || r; r = ((glXGetGPUIDsAMD = (PFNGLXGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetGPUIDsAMD")) == NULL) || r; r = ((glXGetGPUInfoAMD = (PFNGLXGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glXGetGPUInfoAMD")) == NULL) || r; r = ((glXMakeAssociatedContextCurrentAMD = (PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"glXMakeAssociatedContextCurrentAMD")) == NULL) || r; return r; } #endif /* GLX_AMD_gpu_association */ #ifdef GLX_ARB_create_context static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r; return r; } #endif /* GLX_ARB_create_context */ #ifdef GLX_ATI_render_texture static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r; r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r; r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r; return r; } #endif /* GLX_ATI_render_texture */ #ifdef GLX_EXT_import_context static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r; r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r; r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r; r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r; return r; } #endif /* GLX_EXT_import_context */ #ifdef GLX_EXT_swap_control static GLboolean _glewInit_GLX_EXT_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r; return r; } #endif /* GLX_EXT_swap_control */ #ifdef GLX_EXT_texture_from_pixmap static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r; r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r; return r; } #endif /* GLX_EXT_texture_from_pixmap */ #ifdef GLX_MESA_agp_offset static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_agp_offset */ #ifdef GLX_MESA_copy_sub_buffer static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_copy_sub_buffer */ #ifdef GLX_MESA_pixmap_colormap static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_pixmap_colormap */ #ifdef GLX_MESA_query_renderer static GLboolean _glewInit_GLX_MESA_query_renderer (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXQueryCurrentRendererIntegerMESA = (PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryCurrentRendererIntegerMESA")) == NULL) || r; r = ((glXQueryCurrentRendererStringMESA = (PFNGLXQUERYCURRENTRENDERERSTRINGMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryCurrentRendererStringMESA")) == NULL) || r; r = ((glXQueryRendererIntegerMESA = (PFNGLXQUERYRENDERERINTEGERMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryRendererIntegerMESA")) == NULL) || r; r = ((glXQueryRendererStringMESA = (PFNGLXQUERYRENDERERSTRINGMESAPROC)glewGetProcAddress((const GLubyte*)"glXQueryRendererStringMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_query_renderer */ #ifdef GLX_MESA_release_buffers static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_release_buffers */ #ifdef GLX_MESA_set_3dfx_mode static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_set_3dfx_mode */ #ifdef GLX_MESA_swap_control static GLboolean _glewInit_GLX_MESA_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetSwapIntervalMESA")) == NULL) || r; r = ((glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalMESA")) == NULL) || r; return r; } #endif /* GLX_MESA_swap_control */ #ifdef GLX_NV_copy_buffer static GLboolean _glewInit_GLX_NV_copy_buffer (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCopyBufferSubDataNV = (PFNGLXCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyBufferSubDataNV")) == NULL) || r; r = ((glXNamedCopyBufferSubDataNV = (PFNGLXNAMEDCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXNamedCopyBufferSubDataNV")) == NULL) || r; return r; } #endif /* GLX_NV_copy_buffer */ #ifdef GLX_NV_copy_image static GLboolean _glewInit_GLX_NV_copy_image (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r; return r; } #endif /* GLX_NV_copy_image */ #ifdef GLX_NV_delay_before_swap static GLboolean _glewInit_GLX_NV_delay_before_swap (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXDelayBeforeSwapNV = (PFNGLXDELAYBEFORESWAPNVPROC)glewGetProcAddress((const GLubyte*)"glXDelayBeforeSwapNV")) == NULL) || r; return r; } #endif /* GLX_NV_delay_before_swap */ #ifdef GLX_NV_present_video static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r; r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r; return r; } #endif /* GLX_NV_present_video */ #ifdef GLX_NV_swap_group static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r; r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r; r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r; r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r; r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r; r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r; return r; } #endif /* GLX_NV_swap_group */ #ifdef GLX_NV_vertex_array_range static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r; r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r; return r; } #endif /* GLX_NV_vertex_array_range */ #ifdef GLX_NV_video_capture static GLboolean _glewInit_GLX_NV_video_capture (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoCaptureDeviceNV")) == NULL) || r; r = ((glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoCaptureDevicesNV")) == NULL) || r; r = ((glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXLockVideoCaptureDeviceNV")) == NULL) || r; r = ((glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXQueryVideoCaptureDeviceNV")) == NULL) || r; r = ((glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoCaptureDeviceNV")) == NULL) || r; return r; } #endif /* GLX_NV_video_capture */ #ifdef GLX_NV_video_out static GLboolean _glewInit_GLX_NV_video_out (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r; r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r; r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r; r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r; r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r; r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r; return r; } #endif /* GLX_NV_video_out */ #ifdef GLX_OML_sync_control static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r; r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r; r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r; r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r; r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r; return r; } #endif /* GLX_OML_sync_control */ #ifdef GLX_SGIX_fbconfig static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r; r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r; r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r; r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r; r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r; r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r; return r; } #endif /* GLX_SGIX_fbconfig */ #ifdef GLX_SGIX_hyperpipe static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r; r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r; r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r; r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r; r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r; r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r; r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r; r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r; return r; } #endif /* GLX_SGIX_hyperpipe */ #ifdef GLX_SGIX_pbuffer static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r; r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r; r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r; r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r; r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r; return r; } #endif /* GLX_SGIX_pbuffer */ #ifdef GLX_SGIX_swap_barrier static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r; r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r; return r; } #endif /* GLX_SGIX_swap_barrier */ #ifdef GLX_SGIX_swap_group static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r; return r; } #endif /* GLX_SGIX_swap_group */ #ifdef GLX_SGIX_video_resize static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r; r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r; r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r; r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r; r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r; return r; } #endif /* GLX_SGIX_video_resize */ #ifdef GLX_SGI_cushion static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r; return r; } #endif /* GLX_SGI_cushion */ #ifdef GLX_SGI_make_current_read static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r; r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r; return r; } #endif /* GLX_SGI_make_current_read */ #ifdef GLX_SGI_swap_control static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r; return r; } #endif /* GLX_SGI_swap_control */ #ifdef GLX_SGI_video_sync static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r; r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r; return r; } #endif /* GLX_SGI_video_sync */ #ifdef GLX_SUN_get_transparent_index static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r; return r; } #endif /* GLX_SUN_get_transparent_index */ #ifdef GLX_SUN_video_resize static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT) { GLboolean r = GL_FALSE; r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r; r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r; return r; } #endif /* GLX_SUN_video_resize */ /* ------------------------------------------------------------------------ */ GLboolean glxewGetExtension (const char* name) { const GLubyte* start; const GLubyte* end; if (glXGetCurrentDisplay == NULL) return GL_FALSE; start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); if (0 == start) return GL_FALSE; end = start + _glewStrLen(start); return _glewSearchExtension(name, start, end); } #ifdef GLEW_MX GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST) #else GLenum glxewInit (GLXEW_CONTEXT_ARG_DEF_LIST) #endif { int major, minor; const GLubyte* extStart; const GLubyte* extEnd; /* initialize core GLX 1.2 */ if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY; /* initialize flags */ GLXEW_VERSION_1_0 = GL_TRUE; GLXEW_VERSION_1_1 = GL_TRUE; GLXEW_VERSION_1_2 = GL_TRUE; GLXEW_VERSION_1_3 = GL_TRUE; GLXEW_VERSION_1_4 = GL_TRUE; /* query GLX version */ glXQueryVersion(glXGetCurrentDisplay(), &major, &minor); if (major == 1 && minor <= 3) { switch (minor) { case 3: GLXEW_VERSION_1_4 = GL_FALSE; break; case 2: GLXEW_VERSION_1_4 = GL_FALSE; GLXEW_VERSION_1_3 = GL_FALSE; break; default: return GLEW_ERROR_GLX_VERSION_11_ONLY; break; } } /* query GLX extension string */ extStart = 0; if (glXGetCurrentDisplay != NULL) extStart = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); if (extStart == 0) extStart = (const GLubyte *)""; extEnd = extStart + _glewStrLen(extStart); /* initialize extensions */ #ifdef GLX_VERSION_1_3 if (glewExperimental || GLXEW_VERSION_1_3) GLXEW_VERSION_1_3 = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_VERSION_1_3 */ #ifdef GLX_3DFX_multisample GLXEW_3DFX_multisample = _glewSearchExtension("GLX_3DFX_multisample", extStart, extEnd); #endif /* GLX_3DFX_multisample */ #ifdef GLX_AMD_gpu_association GLXEW_AMD_gpu_association = _glewSearchExtension("GLX_AMD_gpu_association", extStart, extEnd); if (glewExperimental || GLXEW_AMD_gpu_association) GLXEW_AMD_gpu_association = !_glewInit_GLX_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_AMD_gpu_association */ #ifdef GLX_ARB_context_flush_control GLXEW_ARB_context_flush_control = _glewSearchExtension("GLX_ARB_context_flush_control", extStart, extEnd); #endif /* GLX_ARB_context_flush_control */ #ifdef GLX_ARB_create_context GLXEW_ARB_create_context = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd); if (glewExperimental || GLXEW_ARB_create_context) GLXEW_ARB_create_context = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_ARB_create_context */ #ifdef GLX_ARB_create_context_profile GLXEW_ARB_create_context_profile = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd); #endif /* GLX_ARB_create_context_profile */ #ifdef GLX_ARB_create_context_robustness GLXEW_ARB_create_context_robustness = _glewSearchExtension("GLX_ARB_create_context_robustness", extStart, extEnd); #endif /* GLX_ARB_create_context_robustness */ #ifdef GLX_ARB_fbconfig_float GLXEW_ARB_fbconfig_float = _glewSearchExtension("GLX_ARB_fbconfig_float", extStart, extEnd); #endif /* GLX_ARB_fbconfig_float */ #ifdef GLX_ARB_framebuffer_sRGB GLXEW_ARB_framebuffer_sRGB = _glewSearchExtension("GLX_ARB_framebuffer_sRGB", extStart, extEnd); #endif /* GLX_ARB_framebuffer_sRGB */ #ifdef GLX_ARB_get_proc_address GLXEW_ARB_get_proc_address = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd); #endif /* GLX_ARB_get_proc_address */ #ifdef GLX_ARB_multisample GLXEW_ARB_multisample = _glewSearchExtension("GLX_ARB_multisample", extStart, extEnd); #endif /* GLX_ARB_multisample */ #ifdef GLX_ARB_robustness_application_isolation GLXEW_ARB_robustness_application_isolation = _glewSearchExtension("GLX_ARB_robustness_application_isolation", extStart, extEnd); #endif /* GLX_ARB_robustness_application_isolation */ #ifdef GLX_ARB_robustness_share_group_isolation GLXEW_ARB_robustness_share_group_isolation = _glewSearchExtension("GLX_ARB_robustness_share_group_isolation", extStart, extEnd); #endif /* GLX_ARB_robustness_share_group_isolation */ #ifdef GLX_ARB_vertex_buffer_object GLXEW_ARB_vertex_buffer_object = _glewSearchExtension("GLX_ARB_vertex_buffer_object", extStart, extEnd); #endif /* GLX_ARB_vertex_buffer_object */ #ifdef GLX_ATI_pixel_format_float GLXEW_ATI_pixel_format_float = _glewSearchExtension("GLX_ATI_pixel_format_float", extStart, extEnd); #endif /* GLX_ATI_pixel_format_float */ #ifdef GLX_ATI_render_texture GLXEW_ATI_render_texture = _glewSearchExtension("GLX_ATI_render_texture", extStart, extEnd); if (glewExperimental || GLXEW_ATI_render_texture) GLXEW_ATI_render_texture = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_ATI_render_texture */ #ifdef GLX_EXT_buffer_age GLXEW_EXT_buffer_age = _glewSearchExtension("GLX_EXT_buffer_age", extStart, extEnd); #endif /* GLX_EXT_buffer_age */ #ifdef GLX_EXT_create_context_es2_profile GLXEW_EXT_create_context_es2_profile = _glewSearchExtension("GLX_EXT_create_context_es2_profile", extStart, extEnd); #endif /* GLX_EXT_create_context_es2_profile */ #ifdef GLX_EXT_create_context_es_profile GLXEW_EXT_create_context_es_profile = _glewSearchExtension("GLX_EXT_create_context_es_profile", extStart, extEnd); #endif /* GLX_EXT_create_context_es_profile */ #ifdef GLX_EXT_fbconfig_packed_float GLXEW_EXT_fbconfig_packed_float = _glewSearchExtension("GLX_EXT_fbconfig_packed_float", extStart, extEnd); #endif /* GLX_EXT_fbconfig_packed_float */ #ifdef GLX_EXT_framebuffer_sRGB GLXEW_EXT_framebuffer_sRGB = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd); #endif /* GLX_EXT_framebuffer_sRGB */ #ifdef GLX_EXT_import_context GLXEW_EXT_import_context = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd); if (glewExperimental || GLXEW_EXT_import_context) GLXEW_EXT_import_context = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_EXT_import_context */ #ifdef GLX_EXT_scene_marker GLXEW_EXT_scene_marker = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd); #endif /* GLX_EXT_scene_marker */ #ifdef GLX_EXT_stereo_tree GLXEW_EXT_stereo_tree = _glewSearchExtension("GLX_EXT_stereo_tree", extStart, extEnd); #endif /* GLX_EXT_stereo_tree */ #ifdef GLX_EXT_swap_control GLXEW_EXT_swap_control = _glewSearchExtension("GLX_EXT_swap_control", extStart, extEnd); if (glewExperimental || GLXEW_EXT_swap_control) GLXEW_EXT_swap_control = !_glewInit_GLX_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_EXT_swap_control */ #ifdef GLX_EXT_swap_control_tear GLXEW_EXT_swap_control_tear = _glewSearchExtension("GLX_EXT_swap_control_tear", extStart, extEnd); #endif /* GLX_EXT_swap_control_tear */ #ifdef GLX_EXT_texture_from_pixmap GLXEW_EXT_texture_from_pixmap = _glewSearchExtension("GLX_EXT_texture_from_pixmap", extStart, extEnd); if (glewExperimental || GLXEW_EXT_texture_from_pixmap) GLXEW_EXT_texture_from_pixmap = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_EXT_texture_from_pixmap */ #ifdef GLX_EXT_visual_info GLXEW_EXT_visual_info = _glewSearchExtension("GLX_EXT_visual_info", extStart, extEnd); #endif /* GLX_EXT_visual_info */ #ifdef GLX_EXT_visual_rating GLXEW_EXT_visual_rating = _glewSearchExtension("GLX_EXT_visual_rating", extStart, extEnd); #endif /* GLX_EXT_visual_rating */ #ifdef GLX_INTEL_swap_event GLXEW_INTEL_swap_event = _glewSearchExtension("GLX_INTEL_swap_event", extStart, extEnd); #endif /* GLX_INTEL_swap_event */ #ifdef GLX_MESA_agp_offset GLXEW_MESA_agp_offset = _glewSearchExtension("GLX_MESA_agp_offset", extStart, extEnd); if (glewExperimental || GLXEW_MESA_agp_offset) GLXEW_MESA_agp_offset = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_agp_offset */ #ifdef GLX_MESA_copy_sub_buffer GLXEW_MESA_copy_sub_buffer = _glewSearchExtension("GLX_MESA_copy_sub_buffer", extStart, extEnd); if (glewExperimental || GLXEW_MESA_copy_sub_buffer) GLXEW_MESA_copy_sub_buffer = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_copy_sub_buffer */ #ifdef GLX_MESA_pixmap_colormap GLXEW_MESA_pixmap_colormap = _glewSearchExtension("GLX_MESA_pixmap_colormap", extStart, extEnd); if (glewExperimental || GLXEW_MESA_pixmap_colormap) GLXEW_MESA_pixmap_colormap = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_pixmap_colormap */ #ifdef GLX_MESA_query_renderer GLXEW_MESA_query_renderer = _glewSearchExtension("GLX_MESA_query_renderer", extStart, extEnd); if (glewExperimental || GLXEW_MESA_query_renderer) GLXEW_MESA_query_renderer = !_glewInit_GLX_MESA_query_renderer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_query_renderer */ #ifdef GLX_MESA_release_buffers GLXEW_MESA_release_buffers = _glewSearchExtension("GLX_MESA_release_buffers", extStart, extEnd); if (glewExperimental || GLXEW_MESA_release_buffers) GLXEW_MESA_release_buffers = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_release_buffers */ #ifdef GLX_MESA_set_3dfx_mode GLXEW_MESA_set_3dfx_mode = _glewSearchExtension("GLX_MESA_set_3dfx_mode", extStart, extEnd); if (glewExperimental || GLXEW_MESA_set_3dfx_mode) GLXEW_MESA_set_3dfx_mode = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_set_3dfx_mode */ #ifdef GLX_MESA_swap_control GLXEW_MESA_swap_control = _glewSearchExtension("GLX_MESA_swap_control", extStart, extEnd); if (glewExperimental || GLXEW_MESA_swap_control) GLXEW_MESA_swap_control = !_glewInit_GLX_MESA_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_MESA_swap_control */ #ifdef GLX_NV_copy_buffer GLXEW_NV_copy_buffer = _glewSearchExtension("GLX_NV_copy_buffer", extStart, extEnd); if (glewExperimental || GLXEW_NV_copy_buffer) GLXEW_NV_copy_buffer = !_glewInit_GLX_NV_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_copy_buffer */ #ifdef GLX_NV_copy_image GLXEW_NV_copy_image = _glewSearchExtension("GLX_NV_copy_image", extStart, extEnd); if (glewExperimental || GLXEW_NV_copy_image) GLXEW_NV_copy_image = !_glewInit_GLX_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_copy_image */ #ifdef GLX_NV_delay_before_swap GLXEW_NV_delay_before_swap = _glewSearchExtension("GLX_NV_delay_before_swap", extStart, extEnd); if (glewExperimental || GLXEW_NV_delay_before_swap) GLXEW_NV_delay_before_swap = !_glewInit_GLX_NV_delay_before_swap(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_delay_before_swap */ #ifdef GLX_NV_float_buffer GLXEW_NV_float_buffer = _glewSearchExtension("GLX_NV_float_buffer", extStart, extEnd); #endif /* GLX_NV_float_buffer */ #ifdef GLX_NV_multisample_coverage GLXEW_NV_multisample_coverage = _glewSearchExtension("GLX_NV_multisample_coverage", extStart, extEnd); #endif /* GLX_NV_multisample_coverage */ #ifdef GLX_NV_present_video GLXEW_NV_present_video = _glewSearchExtension("GLX_NV_present_video", extStart, extEnd); if (glewExperimental || GLXEW_NV_present_video) GLXEW_NV_present_video = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_present_video */ #ifdef GLX_NV_swap_group GLXEW_NV_swap_group = _glewSearchExtension("GLX_NV_swap_group", extStart, extEnd); if (glewExperimental || GLXEW_NV_swap_group) GLXEW_NV_swap_group = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_swap_group */ #ifdef GLX_NV_vertex_array_range GLXEW_NV_vertex_array_range = _glewSearchExtension("GLX_NV_vertex_array_range", extStart, extEnd); if (glewExperimental || GLXEW_NV_vertex_array_range) GLXEW_NV_vertex_array_range = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_vertex_array_range */ #ifdef GLX_NV_video_capture GLXEW_NV_video_capture = _glewSearchExtension("GLX_NV_video_capture", extStart, extEnd); if (glewExperimental || GLXEW_NV_video_capture) GLXEW_NV_video_capture = !_glewInit_GLX_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_video_capture */ #ifdef GLX_NV_video_out GLXEW_NV_video_out = _glewSearchExtension("GLX_NV_video_out", extStart, extEnd); if (glewExperimental || GLXEW_NV_video_out) GLXEW_NV_video_out = !_glewInit_GLX_NV_video_out(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_NV_video_out */ #ifdef GLX_OML_swap_method GLXEW_OML_swap_method = _glewSearchExtension("GLX_OML_swap_method", extStart, extEnd); #endif /* GLX_OML_swap_method */ #ifdef GLX_OML_sync_control GLXEW_OML_sync_control = _glewSearchExtension("GLX_OML_sync_control", extStart, extEnd); if (glewExperimental || GLXEW_OML_sync_control) GLXEW_OML_sync_control = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_OML_sync_control */ #ifdef GLX_SGIS_blended_overlay GLXEW_SGIS_blended_overlay = _glewSearchExtension("GLX_SGIS_blended_overlay", extStart, extEnd); #endif /* GLX_SGIS_blended_overlay */ #ifdef GLX_SGIS_color_range GLXEW_SGIS_color_range = _glewSearchExtension("GLX_SGIS_color_range", extStart, extEnd); #endif /* GLX_SGIS_color_range */ #ifdef GLX_SGIS_multisample GLXEW_SGIS_multisample = _glewSearchExtension("GLX_SGIS_multisample", extStart, extEnd); #endif /* GLX_SGIS_multisample */ #ifdef GLX_SGIS_shared_multisample GLXEW_SGIS_shared_multisample = _glewSearchExtension("GLX_SGIS_shared_multisample", extStart, extEnd); #endif /* GLX_SGIS_shared_multisample */ #ifdef GLX_SGIX_fbconfig GLXEW_SGIX_fbconfig = _glewSearchExtension("GLX_SGIX_fbconfig", extStart, extEnd); if (glewExperimental || GLXEW_SGIX_fbconfig) GLXEW_SGIX_fbconfig = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGIX_fbconfig */ #ifdef GLX_SGIX_hyperpipe GLXEW_SGIX_hyperpipe = _glewSearchExtension("GLX_SGIX_hyperpipe", extStart, extEnd); if (glewExperimental || GLXEW_SGIX_hyperpipe) GLXEW_SGIX_hyperpipe = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGIX_hyperpipe */ #ifdef GLX_SGIX_pbuffer GLXEW_SGIX_pbuffer = _glewSearchExtension("GLX_SGIX_pbuffer", extStart, extEnd); if (glewExperimental || GLXEW_SGIX_pbuffer) GLXEW_SGIX_pbuffer = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGIX_pbuffer */ #ifdef GLX_SGIX_swap_barrier GLXEW_SGIX_swap_barrier = _glewSearchExtension("GLX_SGIX_swap_barrier", extStart, extEnd); if (glewExperimental || GLXEW_SGIX_swap_barrier) GLXEW_SGIX_swap_barrier = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGIX_swap_barrier */ #ifdef GLX_SGIX_swap_group GLXEW_SGIX_swap_group = _glewSearchExtension("GLX_SGIX_swap_group", extStart, extEnd); if (glewExperimental || GLXEW_SGIX_swap_group) GLXEW_SGIX_swap_group = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGIX_swap_group */ #ifdef GLX_SGIX_video_resize GLXEW_SGIX_video_resize = _glewSearchExtension("GLX_SGIX_video_resize", extStart, extEnd); if (glewExperimental || GLXEW_SGIX_video_resize) GLXEW_SGIX_video_resize = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGIX_video_resize */ #ifdef GLX_SGIX_visual_select_group GLXEW_SGIX_visual_select_group = _glewSearchExtension("GLX_SGIX_visual_select_group", extStart, extEnd); #endif /* GLX_SGIX_visual_select_group */ #ifdef GLX_SGI_cushion GLXEW_SGI_cushion = _glewSearchExtension("GLX_SGI_cushion", extStart, extEnd); if (glewExperimental || GLXEW_SGI_cushion) GLXEW_SGI_cushion = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGI_cushion */ #ifdef GLX_SGI_make_current_read GLXEW_SGI_make_current_read = _glewSearchExtension("GLX_SGI_make_current_read", extStart, extEnd); if (glewExperimental || GLXEW_SGI_make_current_read) GLXEW_SGI_make_current_read = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGI_make_current_read */ #ifdef GLX_SGI_swap_control GLXEW_SGI_swap_control = _glewSearchExtension("GLX_SGI_swap_control", extStart, extEnd); if (glewExperimental || GLXEW_SGI_swap_control) GLXEW_SGI_swap_control = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGI_swap_control */ #ifdef GLX_SGI_video_sync GLXEW_SGI_video_sync = _glewSearchExtension("GLX_SGI_video_sync", extStart, extEnd); if (glewExperimental || GLXEW_SGI_video_sync) GLXEW_SGI_video_sync = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SGI_video_sync */ #ifdef GLX_SUN_get_transparent_index GLXEW_SUN_get_transparent_index = _glewSearchExtension("GLX_SUN_get_transparent_index", extStart, extEnd); if (glewExperimental || GLXEW_SUN_get_transparent_index) GLXEW_SUN_get_transparent_index = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SUN_get_transparent_index */ #ifdef GLX_SUN_video_resize GLXEW_SUN_video_resize = _glewSearchExtension("GLX_SUN_video_resize", extStart, extEnd); if (glewExperimental || GLXEW_SUN_video_resize) GLXEW_SUN_video_resize = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT); #endif /* GLX_SUN_video_resize */ return GLEW_OK; } #endif /* !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) */ /* ------------------------------------------------------------------------ */ const GLubyte * GLEWAPIENTRY glewGetErrorString (GLenum error) { static const GLubyte* _glewErrorString[] = { (const GLubyte*)"No error", (const GLubyte*)"Missing GL version", (const GLubyte*)"GL 1.1 and up are not supported", (const GLubyte*)"GLX 1.2 and up are not supported", (const GLubyte*)"Unknown error" }; const size_t max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1; return _glewErrorString[(size_t)error > max_error ? max_error : (size_t)error]; } const GLubyte * GLEWAPIENTRY glewGetString (GLenum name) { static const GLubyte* _glewString[] = { (const GLubyte*)NULL, (const GLubyte*)"1.13.0", (const GLubyte*)"1", (const GLubyte*)"13", (const GLubyte*)"0" }; const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; return _glewString[(size_t)name > max_string ? 0 : (size_t)name]; } /* ------------------------------------------------------------------------ */ GLboolean glewExperimental = GL_FALSE; #if !defined(GLEW_MX) GLenum GLEWAPIENTRY glewInit (void) { GLenum r; r = glewContextInit(); if ( r != 0 ) return r; #if defined(_WIN32) return wglewInit(); #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) /* _UNIX */ return glxewInit(); #else return r; #endif /* _WIN32 */ } #endif /* !GLEW_MX */ #ifdef GLEW_MX GLboolean GLEWAPIENTRY glewContextIsSupported (const GLEWContext* ctx, const char* name) #else GLboolean GLEWAPIENTRY glewIsSupported (const char* name) #endif { const GLubyte* pos = (const GLubyte*)name; GLuint len = _glewStrLen(pos); GLboolean ret = GL_TRUE; while (ret && len > 0) { if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3)) { if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) { #ifdef GL_VERSION_1_2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) { ret = GLEW_VERSION_1_2; continue; } #endif #ifdef GL_VERSION_1_2_1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5)) { ret = GLEW_VERSION_1_2_1; continue; } #endif #ifdef GL_VERSION_1_3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) { ret = GLEW_VERSION_1_3; continue; } #endif #ifdef GL_VERSION_1_4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) { ret = GLEW_VERSION_1_4; continue; } #endif #ifdef GL_VERSION_1_5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3)) { ret = GLEW_VERSION_1_5; continue; } #endif #ifdef GL_VERSION_2_0 if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3)) { ret = GLEW_VERSION_2_0; continue; } #endif #ifdef GL_VERSION_2_1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3)) { ret = GLEW_VERSION_2_1; continue; } #endif #ifdef GL_VERSION_3_0 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3)) { ret = GLEW_VERSION_3_0; continue; } #endif #ifdef GL_VERSION_3_1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3)) { ret = GLEW_VERSION_3_1; continue; } #endif #ifdef GL_VERSION_3_2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3)) { ret = GLEW_VERSION_3_2; continue; } #endif #ifdef GL_VERSION_3_3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3)) { ret = GLEW_VERSION_3_3; continue; } #endif #ifdef GL_VERSION_4_0 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3)) { ret = GLEW_VERSION_4_0; continue; } #endif #ifdef GL_VERSION_4_1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3)) { ret = GLEW_VERSION_4_1; continue; } #endif #ifdef GL_VERSION_4_2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3)) { ret = GLEW_VERSION_4_2; continue; } #endif #ifdef GL_VERSION_4_3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_3", 3)) { ret = GLEW_VERSION_4_3; continue; } #endif #ifdef GL_VERSION_4_4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_4", 3)) { ret = GLEW_VERSION_4_4; continue; } #endif #ifdef GL_VERSION_4_5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_5", 3)) { ret = GLEW_VERSION_4_5; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) { #ifdef GL_3DFX_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLEW_3DFX_multisample; continue; } #endif #ifdef GL_3DFX_tbuffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7)) { ret = GLEW_3DFX_tbuffer; continue; } #endif #ifdef GL_3DFX_texture_compression_FXT1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24)) { ret = GLEW_3DFX_texture_compression_FXT1; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4)) { #ifdef GL_AMD_blend_minmax_factor if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19)) { ret = GLEW_AMD_blend_minmax_factor; continue; } #endif #ifdef GL_AMD_conservative_depth if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18)) { ret = GLEW_AMD_conservative_depth; continue; } #endif #ifdef GL_AMD_debug_output if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12)) { ret = GLEW_AMD_debug_output; continue; } #endif #ifdef GL_AMD_depth_clamp_separate if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp_separate", 20)) { ret = GLEW_AMD_depth_clamp_separate; continue; } #endif #ifdef GL_AMD_draw_buffers_blend if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18)) { ret = GLEW_AMD_draw_buffers_blend; continue; } #endif #ifdef GL_AMD_gcn_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"gcn_shader", 10)) { ret = GLEW_AMD_gcn_shader; continue; } #endif #ifdef GL_AMD_gpu_shader_int64 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int64", 16)) { ret = GLEW_AMD_gpu_shader_int64; continue; } #endif #ifdef GL_AMD_interleaved_elements if (_glewStrSame3(&pos, &len, (const GLubyte*)"interleaved_elements", 20)) { ret = GLEW_AMD_interleaved_elements; continue; } #endif #ifdef GL_AMD_multi_draw_indirect if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19)) { ret = GLEW_AMD_multi_draw_indirect; continue; } #endif #ifdef GL_AMD_name_gen_delete if (_glewStrSame3(&pos, &len, (const GLubyte*)"name_gen_delete", 15)) { ret = GLEW_AMD_name_gen_delete; continue; } #endif #ifdef GL_AMD_occlusion_query_event if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query_event", 21)) { ret = GLEW_AMD_occlusion_query_event; continue; } #endif #ifdef GL_AMD_performance_monitor if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19)) { ret = GLEW_AMD_performance_monitor; continue; } #endif #ifdef GL_AMD_pinned_memory if (_glewStrSame3(&pos, &len, (const GLubyte*)"pinned_memory", 13)) { ret = GLEW_AMD_pinned_memory; continue; } #endif #ifdef GL_AMD_query_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19)) { ret = GLEW_AMD_query_buffer_object; continue; } #endif #ifdef GL_AMD_sample_positions if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_positions", 16)) { ret = GLEW_AMD_sample_positions; continue; } #endif #ifdef GL_AMD_seamless_cubemap_per_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28)) { ret = GLEW_AMD_seamless_cubemap_per_texture; continue; } #endif #ifdef GL_AMD_shader_atomic_counter_ops if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counter_ops", 25)) { ret = GLEW_AMD_shader_atomic_counter_ops; continue; } #endif #ifdef GL_AMD_shader_stencil_export if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21)) { ret = GLEW_AMD_shader_stencil_export; continue; } #endif #ifdef GL_AMD_shader_stencil_value_export if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_value_export", 27)) { ret = GLEW_AMD_shader_stencil_value_export; continue; } #endif #ifdef GL_AMD_shader_trinary_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_trinary_minmax", 21)) { ret = GLEW_AMD_shader_trinary_minmax; continue; } #endif #ifdef GL_AMD_sparse_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14)) { ret = GLEW_AMD_sparse_texture; continue; } #endif #ifdef GL_AMD_stencil_operation_extended if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_operation_extended", 26)) { ret = GLEW_AMD_stencil_operation_extended; continue; } #endif #ifdef GL_AMD_texture_texture4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16)) { ret = GLEW_AMD_texture_texture4; continue; } #endif #ifdef GL_AMD_transform_feedback3_lines_triangles if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3_lines_triangles", 35)) { ret = GLEW_AMD_transform_feedback3_lines_triangles; continue; } #endif #ifdef GL_AMD_transform_feedback4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback4", 19)) { ret = GLEW_AMD_transform_feedback4; continue; } #endif #ifdef GL_AMD_vertex_shader_layer if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_layer", 19)) { ret = GLEW_AMD_vertex_shader_layer; continue; } #endif #ifdef GL_AMD_vertex_shader_tessellator if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25)) { ret = GLEW_AMD_vertex_shader_tessellator; continue; } #endif #ifdef GL_AMD_vertex_shader_viewport_index if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_viewport_index", 28)) { ret = GLEW_AMD_vertex_shader_viewport_index; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6)) { #ifdef GL_ANGLE_depth_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) { ret = GLEW_ANGLE_depth_texture; continue; } #endif #ifdef GL_ANGLE_framebuffer_blit if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16)) { ret = GLEW_ANGLE_framebuffer_blit; continue; } #endif #ifdef GL_ANGLE_framebuffer_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) { ret = GLEW_ANGLE_framebuffer_multisample; continue; } #endif #ifdef GL_ANGLE_instanced_arrays if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16)) { ret = GLEW_ANGLE_instanced_arrays; continue; } #endif #ifdef GL_ANGLE_pack_reverse_row_order if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_reverse_row_order", 22)) { ret = GLEW_ANGLE_pack_reverse_row_order; continue; } #endif #ifdef GL_ANGLE_program_binary if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14)) { ret = GLEW_ANGLE_program_binary; continue; } #endif #ifdef GL_ANGLE_texture_compression_dxt1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24)) { ret = GLEW_ANGLE_texture_compression_dxt1; continue; } #endif #ifdef GL_ANGLE_texture_compression_dxt3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt3", 24)) { ret = GLEW_ANGLE_texture_compression_dxt3; continue; } #endif #ifdef GL_ANGLE_texture_compression_dxt5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt5", 24)) { ret = GLEW_ANGLE_texture_compression_dxt5; continue; } #endif #ifdef GL_ANGLE_texture_usage if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_usage", 13)) { ret = GLEW_ANGLE_texture_usage; continue; } #endif #ifdef GL_ANGLE_timer_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) { ret = GLEW_ANGLE_timer_query; continue; } #endif #ifdef GL_ANGLE_translated_shader_source if (_glewStrSame3(&pos, &len, (const GLubyte*)"translated_shader_source", 24)) { ret = GLEW_ANGLE_translated_shader_source; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6)) { #ifdef GL_APPLE_aux_depth_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17)) { ret = GLEW_APPLE_aux_depth_stencil; continue; } #endif #ifdef GL_APPLE_client_storage if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14)) { ret = GLEW_APPLE_client_storage; continue; } #endif #ifdef GL_APPLE_element_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) { ret = GLEW_APPLE_element_array; continue; } #endif #ifdef GL_APPLE_fence if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) { ret = GLEW_APPLE_fence; continue; } #endif #ifdef GL_APPLE_float_pixels if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12)) { ret = GLEW_APPLE_float_pixels; continue; } #endif #ifdef GL_APPLE_flush_buffer_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18)) { ret = GLEW_APPLE_flush_buffer_range; continue; } #endif #ifdef GL_APPLE_object_purgeable if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16)) { ret = GLEW_APPLE_object_purgeable; continue; } #endif #ifdef GL_APPLE_pixel_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12)) { ret = GLEW_APPLE_pixel_buffer; continue; } #endif #ifdef GL_APPLE_rgb_422 if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7)) { ret = GLEW_APPLE_rgb_422; continue; } #endif #ifdef GL_APPLE_row_bytes if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9)) { ret = GLEW_APPLE_row_bytes; continue; } #endif #ifdef GL_APPLE_specular_vector if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15)) { ret = GLEW_APPLE_specular_vector; continue; } #endif #ifdef GL_APPLE_texture_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) { ret = GLEW_APPLE_texture_range; continue; } #endif #ifdef GL_APPLE_transform_hint if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14)) { ret = GLEW_APPLE_transform_hint; continue; } #endif #ifdef GL_APPLE_vertex_array_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) { ret = GLEW_APPLE_vertex_array_object; continue; } #endif #ifdef GL_APPLE_vertex_array_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) { ret = GLEW_APPLE_vertex_array_range; continue; } #endif #ifdef GL_APPLE_vertex_program_evaluators if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25)) { ret = GLEW_APPLE_vertex_program_evaluators; continue; } #endif #ifdef GL_APPLE_ycbcr_422 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9)) { ret = GLEW_APPLE_ycbcr_422; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) { #ifdef GL_ARB_ES2_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES2_compatibility", 17)) { ret = GLEW_ARB_ES2_compatibility; continue; } #endif #ifdef GL_ARB_ES3_1_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_1_compatibility", 19)) { ret = GLEW_ARB_ES3_1_compatibility; continue; } #endif #ifdef GL_ARB_ES3_2_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_2_compatibility", 19)) { ret = GLEW_ARB_ES3_2_compatibility; continue; } #endif #ifdef GL_ARB_ES3_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES3_compatibility", 17)) { ret = GLEW_ARB_ES3_compatibility; continue; } #endif #ifdef GL_ARB_arrays_of_arrays if (_glewStrSame3(&pos, &len, (const GLubyte*)"arrays_of_arrays", 16)) { ret = GLEW_ARB_arrays_of_arrays; continue; } #endif #ifdef GL_ARB_base_instance if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13)) { ret = GLEW_ARB_base_instance; continue; } #endif #ifdef GL_ARB_bindless_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16)) { ret = GLEW_ARB_bindless_texture; continue; } #endif #ifdef GL_ARB_blend_func_extended if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19)) { ret = GLEW_ARB_blend_func_extended; continue; } #endif #ifdef GL_ARB_buffer_storage if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_storage", 14)) { ret = GLEW_ARB_buffer_storage; continue; } #endif #ifdef GL_ARB_cl_event if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8)) { ret = GLEW_ARB_cl_event; continue; } #endif #ifdef GL_ARB_clear_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_buffer_object", 19)) { ret = GLEW_ARB_clear_buffer_object; continue; } #endif #ifdef GL_ARB_clear_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_texture", 13)) { ret = GLEW_ARB_clear_texture; continue; } #endif #ifdef GL_ARB_clip_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_control", 12)) { ret = GLEW_ARB_clip_control; continue; } #endif #ifdef GL_ARB_color_buffer_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18)) { ret = GLEW_ARB_color_buffer_float; continue; } #endif #ifdef GL_ARB_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13)) { ret = GLEW_ARB_compatibility; continue; } #endif #ifdef GL_ARB_compressed_texture_pixel_storage if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_texture_pixel_storage", 32)) { ret = GLEW_ARB_compressed_texture_pixel_storage; continue; } #endif #ifdef GL_ARB_compute_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_shader", 14)) { ret = GLEW_ARB_compute_shader; continue; } #endif #ifdef GL_ARB_compute_variable_group_size if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_variable_group_size", 27)) { ret = GLEW_ARB_compute_variable_group_size; continue; } #endif #ifdef GL_ARB_conditional_render_inverted if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render_inverted", 27)) { ret = GLEW_ARB_conditional_render_inverted; continue; } #endif #ifdef GL_ARB_conservative_depth if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18)) { ret = GLEW_ARB_conservative_depth; continue; } #endif #ifdef GL_ARB_copy_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11)) { ret = GLEW_ARB_copy_buffer; continue; } #endif #ifdef GL_ARB_copy_image if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) { ret = GLEW_ARB_copy_image; continue; } #endif #ifdef GL_ARB_cull_distance if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_distance", 13)) { ret = GLEW_ARB_cull_distance; continue; } #endif #ifdef GL_ARB_debug_output if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12)) { ret = GLEW_ARB_debug_output; continue; } #endif #ifdef GL_ARB_depth_buffer_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18)) { ret = GLEW_ARB_depth_buffer_float; continue; } #endif #ifdef GL_ARB_depth_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11)) { ret = GLEW_ARB_depth_clamp; continue; } #endif #ifdef GL_ARB_depth_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) { ret = GLEW_ARB_depth_texture; continue; } #endif #ifdef GL_ARB_derivative_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"derivative_control", 18)) { ret = GLEW_ARB_derivative_control; continue; } #endif #ifdef GL_ARB_direct_state_access if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19)) { ret = GLEW_ARB_direct_state_access; continue; } #endif #ifdef GL_ARB_draw_buffers if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) { ret = GLEW_ARB_draw_buffers; continue; } #endif #ifdef GL_ARB_draw_buffers_blend if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18)) { ret = GLEW_ARB_draw_buffers_blend; continue; } #endif #ifdef GL_ARB_draw_elements_base_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25)) { ret = GLEW_ARB_draw_elements_base_vertex; continue; } #endif #ifdef GL_ARB_draw_indirect if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13)) { ret = GLEW_ARB_draw_indirect; continue; } #endif #ifdef GL_ARB_draw_instanced if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) { ret = GLEW_ARB_draw_instanced; continue; } #endif #ifdef GL_ARB_enhanced_layouts if (_glewStrSame3(&pos, &len, (const GLubyte*)"enhanced_layouts", 16)) { ret = GLEW_ARB_enhanced_layouts; continue; } #endif #ifdef GL_ARB_explicit_attrib_location if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24)) { ret = GLEW_ARB_explicit_attrib_location; continue; } #endif #ifdef GL_ARB_explicit_uniform_location if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_uniform_location", 25)) { ret = GLEW_ARB_explicit_uniform_location; continue; } #endif #ifdef GL_ARB_fragment_coord_conventions if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26)) { ret = GLEW_ARB_fragment_coord_conventions; continue; } #endif #ifdef GL_ARB_fragment_layer_viewport if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_layer_viewport", 23)) { ret = GLEW_ARB_fragment_layer_viewport; continue; } #endif #ifdef GL_ARB_fragment_program if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16)) { ret = GLEW_ARB_fragment_program; continue; } #endif #ifdef GL_ARB_fragment_program_shadow if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23)) { ret = GLEW_ARB_fragment_program_shadow; continue; } #endif #ifdef GL_ARB_fragment_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15)) { ret = GLEW_ARB_fragment_shader; continue; } #endif #ifdef GL_ARB_fragment_shader_interlock if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_interlock", 25)) { ret = GLEW_ARB_fragment_shader_interlock; continue; } #endif #ifdef GL_ARB_framebuffer_no_attachments if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_no_attachments", 26)) { ret = GLEW_ARB_framebuffer_no_attachments; continue; } #endif #ifdef GL_ARB_framebuffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) { ret = GLEW_ARB_framebuffer_object; continue; } #endif #ifdef GL_ARB_framebuffer_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) { ret = GLEW_ARB_framebuffer_sRGB; continue; } #endif #ifdef GL_ARB_geometry_shader4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) { ret = GLEW_ARB_geometry_shader4; continue; } #endif #ifdef GL_ARB_get_program_binary if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18)) { ret = GLEW_ARB_get_program_binary; continue; } #endif #ifdef GL_ARB_get_texture_sub_image if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_texture_sub_image", 21)) { ret = GLEW_ARB_get_texture_sub_image; continue; } #endif #ifdef GL_ARB_gpu_shader5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11)) { ret = GLEW_ARB_gpu_shader5; continue; } #endif #ifdef GL_ARB_gpu_shader_fp64 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15)) { ret = GLEW_ARB_gpu_shader_fp64; continue; } #endif #ifdef GL_ARB_gpu_shader_int64 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int64", 16)) { ret = GLEW_ARB_gpu_shader_int64; continue; } #endif #ifdef GL_ARB_half_float_pixel if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16)) { ret = GLEW_ARB_half_float_pixel; continue; } #endif #ifdef GL_ARB_half_float_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17)) { ret = GLEW_ARB_half_float_vertex; continue; } #endif #ifdef GL_ARB_imaging if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7)) { ret = GLEW_ARB_imaging; continue; } #endif #ifdef GL_ARB_indirect_parameters if (_glewStrSame3(&pos, &len, (const GLubyte*)"indirect_parameters", 19)) { ret = GLEW_ARB_indirect_parameters; continue; } #endif #ifdef GL_ARB_instanced_arrays if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16)) { ret = GLEW_ARB_instanced_arrays; continue; } #endif #ifdef GL_ARB_internalformat_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query", 20)) { ret = GLEW_ARB_internalformat_query; continue; } #endif #ifdef GL_ARB_internalformat_query2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query2", 21)) { ret = GLEW_ARB_internalformat_query2; continue; } #endif #ifdef GL_ARB_invalidate_subdata if (_glewStrSame3(&pos, &len, (const GLubyte*)"invalidate_subdata", 18)) { ret = GLEW_ARB_invalidate_subdata; continue; } #endif #ifdef GL_ARB_map_buffer_alignment if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_alignment", 20)) { ret = GLEW_ARB_map_buffer_alignment; continue; } #endif #ifdef GL_ARB_map_buffer_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16)) { ret = GLEW_ARB_map_buffer_range; continue; } #endif #ifdef GL_ARB_matrix_palette if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14)) { ret = GLEW_ARB_matrix_palette; continue; } #endif #ifdef GL_ARB_multi_bind if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_bind", 10)) { ret = GLEW_ARB_multi_bind; continue; } #endif #ifdef GL_ARB_multi_draw_indirect if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19)) { ret = GLEW_ARB_multi_draw_indirect; continue; } #endif #ifdef GL_ARB_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLEW_ARB_multisample; continue; } #endif #ifdef GL_ARB_multitexture if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12)) { ret = GLEW_ARB_multitexture; continue; } #endif #ifdef GL_ARB_occlusion_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) { ret = GLEW_ARB_occlusion_query; continue; } #endif #ifdef GL_ARB_occlusion_query2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16)) { ret = GLEW_ARB_occlusion_query2; continue; } #endif #ifdef GL_ARB_parallel_shader_compile if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_shader_compile", 23)) { ret = GLEW_ARB_parallel_shader_compile; continue; } #endif #ifdef GL_ARB_pipeline_statistics_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"pipeline_statistics_query", 25)) { ret = GLEW_ARB_pipeline_statistics_query; continue; } #endif #ifdef GL_ARB_pixel_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) { ret = GLEW_ARB_pixel_buffer_object; continue; } #endif #ifdef GL_ARB_point_parameters if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16)) { ret = GLEW_ARB_point_parameters; continue; } #endif #ifdef GL_ARB_point_sprite if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) { ret = GLEW_ARB_point_sprite; continue; } #endif #ifdef GL_ARB_post_depth_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_depth_coverage", 19)) { ret = GLEW_ARB_post_depth_coverage; continue; } #endif #ifdef GL_ARB_program_interface_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_interface_query", 23)) { ret = GLEW_ARB_program_interface_query; continue; } #endif #ifdef GL_ARB_provoking_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16)) { ret = GLEW_ARB_provoking_vertex; continue; } #endif #ifdef GL_ARB_query_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19)) { ret = GLEW_ARB_query_buffer_object; continue; } #endif #ifdef GL_ARB_robust_buffer_access_behavior if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29)) { ret = GLEW_ARB_robust_buffer_access_behavior; continue; } #endif #ifdef GL_ARB_robustness if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10)) { ret = GLEW_ARB_robustness; continue; } #endif #ifdef GL_ARB_robustness_application_isolation if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32)) { ret = GLEW_ARB_robustness_application_isolation; continue; } #endif #ifdef GL_ARB_robustness_share_group_isolation if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32)) { ret = GLEW_ARB_robustness_share_group_isolation; continue; } #endif #ifdef GL_ARB_sample_locations if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_locations", 16)) { ret = GLEW_ARB_sample_locations; continue; } #endif #ifdef GL_ARB_sample_shading if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14)) { ret = GLEW_ARB_sample_shading; continue; } #endif #ifdef GL_ARB_sampler_objects if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15)) { ret = GLEW_ARB_sampler_objects; continue; } #endif #ifdef GL_ARB_seamless_cube_map if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17)) { ret = GLEW_ARB_seamless_cube_map; continue; } #endif #ifdef GL_ARB_seamless_cubemap_per_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28)) { ret = GLEW_ARB_seamless_cubemap_per_texture; continue; } #endif #ifdef GL_ARB_separate_shader_objects if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23)) { ret = GLEW_ARB_separate_shader_objects; continue; } #endif #ifdef GL_ARB_shader_atomic_counter_ops if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counter_ops", 25)) { ret = GLEW_ARB_shader_atomic_counter_ops; continue; } #endif #ifdef GL_ARB_shader_atomic_counters if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22)) { ret = GLEW_ARB_shader_atomic_counters; continue; } #endif #ifdef GL_ARB_shader_ballot if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_ballot", 13)) { ret = GLEW_ARB_shader_ballot; continue; } #endif #ifdef GL_ARB_shader_bit_encoding if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19)) { ret = GLEW_ARB_shader_bit_encoding; continue; } #endif #ifdef GL_ARB_shader_clock if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_clock", 12)) { ret = GLEW_ARB_shader_clock; continue; } #endif #ifdef GL_ARB_shader_draw_parameters if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_draw_parameters", 22)) { ret = GLEW_ARB_shader_draw_parameters; continue; } #endif #ifdef GL_ARB_shader_group_vote if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_group_vote", 17)) { ret = GLEW_ARB_shader_group_vote; continue; } #endif #ifdef GL_ARB_shader_image_load_store if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23)) { ret = GLEW_ARB_shader_image_load_store; continue; } #endif #ifdef GL_ARB_shader_image_size if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_size", 17)) { ret = GLEW_ARB_shader_image_size; continue; } #endif #ifdef GL_ARB_shader_objects if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14)) { ret = GLEW_ARB_shader_objects; continue; } #endif #ifdef GL_ARB_shader_precision if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_precision", 16)) { ret = GLEW_ARB_shader_precision; continue; } #endif #ifdef GL_ARB_shader_stencil_export if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21)) { ret = GLEW_ARB_shader_stencil_export; continue; } #endif #ifdef GL_ARB_shader_storage_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28)) { ret = GLEW_ARB_shader_storage_buffer_object; continue; } #endif #ifdef GL_ARB_shader_subroutine if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17)) { ret = GLEW_ARB_shader_subroutine; continue; } #endif #ifdef GL_ARB_shader_texture_image_samples if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_image_samples", 28)) { ret = GLEW_ARB_shader_texture_image_samples; continue; } #endif #ifdef GL_ARB_shader_texture_lod if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) { ret = GLEW_ARB_shader_texture_lod; continue; } #endif #ifdef GL_ARB_shader_viewport_layer_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_viewport_layer_array", 27)) { ret = GLEW_ARB_shader_viewport_layer_array; continue; } #endif #ifdef GL_ARB_shading_language_100 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20)) { ret = GLEW_ARB_shading_language_100; continue; } #endif #ifdef GL_ARB_shading_language_420pack if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_420pack", 24)) { ret = GLEW_ARB_shading_language_420pack; continue; } #endif #ifdef GL_ARB_shading_language_include if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24)) { ret = GLEW_ARB_shading_language_include; continue; } #endif #ifdef GL_ARB_shading_language_packing if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_packing", 24)) { ret = GLEW_ARB_shading_language_packing; continue; } #endif #ifdef GL_ARB_shadow if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) { ret = GLEW_ARB_shadow; continue; } #endif #ifdef GL_ARB_shadow_ambient if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14)) { ret = GLEW_ARB_shadow_ambient; continue; } #endif #ifdef GL_ARB_sparse_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_buffer", 13)) { ret = GLEW_ARB_sparse_buffer; continue; } #endif #ifdef GL_ARB_sparse_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14)) { ret = GLEW_ARB_sparse_texture; continue; } #endif #ifdef GL_ARB_sparse_texture2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture2", 15)) { ret = GLEW_ARB_sparse_texture2; continue; } #endif #ifdef GL_ARB_sparse_texture_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture_clamp", 20)) { ret = GLEW_ARB_sparse_texture_clamp; continue; } #endif #ifdef GL_ARB_stencil_texturing if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_texturing", 17)) { ret = GLEW_ARB_stencil_texturing; continue; } #endif #ifdef GL_ARB_sync if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4)) { ret = GLEW_ARB_sync; continue; } #endif #ifdef GL_ARB_tessellation_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19)) { ret = GLEW_ARB_tessellation_shader; continue; } #endif #ifdef GL_ARB_texture_barrier if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15)) { ret = GLEW_ARB_texture_barrier; continue; } #endif #ifdef GL_ARB_texture_border_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) { ret = GLEW_ARB_texture_border_clamp; continue; } #endif #ifdef GL_ARB_texture_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) { ret = GLEW_ARB_texture_buffer_object; continue; } #endif #ifdef GL_ARB_texture_buffer_object_rgb32 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27)) { ret = GLEW_ARB_texture_buffer_object_rgb32; continue; } #endif #ifdef GL_ARB_texture_buffer_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_range", 20)) { ret = GLEW_ARB_texture_buffer_range; continue; } #endif #ifdef GL_ARB_texture_compression if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19)) { ret = GLEW_ARB_texture_compression; continue; } #endif #ifdef GL_ARB_texture_compression_bptc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24)) { ret = GLEW_ARB_texture_compression_bptc; continue; } #endif #ifdef GL_ARB_texture_compression_rgtc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24)) { ret = GLEW_ARB_texture_compression_rgtc; continue; } #endif #ifdef GL_ARB_texture_cube_map if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) { ret = GLEW_ARB_texture_cube_map; continue; } #endif #ifdef GL_ARB_texture_cube_map_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22)) { ret = GLEW_ARB_texture_cube_map_array; continue; } #endif #ifdef GL_ARB_texture_env_add if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15)) { ret = GLEW_ARB_texture_env_add; continue; } #endif #ifdef GL_ARB_texture_env_combine if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19)) { ret = GLEW_ARB_texture_env_combine; continue; } #endif #ifdef GL_ARB_texture_env_crossbar if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20)) { ret = GLEW_ARB_texture_env_crossbar; continue; } #endif #ifdef GL_ARB_texture_env_dot3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16)) { ret = GLEW_ARB_texture_env_dot3; continue; } #endif #ifdef GL_ARB_texture_filter_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_minmax", 21)) { ret = GLEW_ARB_texture_filter_minmax; continue; } #endif #ifdef GL_ARB_texture_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13)) { ret = GLEW_ARB_texture_float; continue; } #endif #ifdef GL_ARB_texture_gather if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14)) { ret = GLEW_ARB_texture_gather; continue; } #endif #ifdef GL_ARB_texture_mirror_clamp_to_edge if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp_to_edge", 28)) { ret = GLEW_ARB_texture_mirror_clamp_to_edge; continue; } #endif #ifdef GL_ARB_texture_mirrored_repeat if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) { ret = GLEW_ARB_texture_mirrored_repeat; continue; } #endif #ifdef GL_ARB_texture_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19)) { ret = GLEW_ARB_texture_multisample; continue; } #endif #ifdef GL_ARB_texture_non_power_of_two if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24)) { ret = GLEW_ARB_texture_non_power_of_two; continue; } #endif #ifdef GL_ARB_texture_query_levels if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_levels", 20)) { ret = GLEW_ARB_texture_query_levels; continue; } #endif #ifdef GL_ARB_texture_query_lod if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17)) { ret = GLEW_ARB_texture_query_lod; continue; } #endif #ifdef GL_ARB_texture_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) { ret = GLEW_ARB_texture_rectangle; continue; } #endif #ifdef GL_ARB_texture_rg if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10)) { ret = GLEW_ARB_texture_rg; continue; } #endif #ifdef GL_ARB_texture_rgb10_a2ui if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18)) { ret = GLEW_ARB_texture_rgb10_a2ui; continue; } #endif #ifdef GL_ARB_texture_stencil8 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stencil8", 16)) { ret = GLEW_ARB_texture_stencil8; continue; } #endif #ifdef GL_ARB_texture_storage if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15)) { ret = GLEW_ARB_texture_storage; continue; } #endif #ifdef GL_ARB_texture_storage_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_multisample", 27)) { ret = GLEW_ARB_texture_storage_multisample; continue; } #endif #ifdef GL_ARB_texture_swizzle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) { ret = GLEW_ARB_texture_swizzle; continue; } #endif #ifdef GL_ARB_texture_view if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12)) { ret = GLEW_ARB_texture_view; continue; } #endif #ifdef GL_ARB_timer_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) { ret = GLEW_ARB_timer_query; continue; } #endif #ifdef GL_ARB_transform_feedback2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19)) { ret = GLEW_ARB_transform_feedback2; continue; } #endif #ifdef GL_ARB_transform_feedback3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19)) { ret = GLEW_ARB_transform_feedback3; continue; } #endif #ifdef GL_ARB_transform_feedback_instanced if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_instanced", 28)) { ret = GLEW_ARB_transform_feedback_instanced; continue; } #endif #ifdef GL_ARB_transform_feedback_overflow_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_overflow_query", 33)) { ret = GLEW_ARB_transform_feedback_overflow_query; continue; } #endif #ifdef GL_ARB_transpose_matrix if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16)) { ret = GLEW_ARB_transpose_matrix; continue; } #endif #ifdef GL_ARB_uniform_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21)) { ret = GLEW_ARB_uniform_buffer_object; continue; } #endif #ifdef GL_ARB_vertex_array_bgra if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17)) { ret = GLEW_ARB_vertex_array_bgra; continue; } #endif #ifdef GL_ARB_vertex_array_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) { ret = GLEW_ARB_vertex_array_object; continue; } #endif #ifdef GL_ARB_vertex_attrib_64bit if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19)) { ret = GLEW_ARB_vertex_attrib_64bit; continue; } #endif #ifdef GL_ARB_vertex_attrib_binding if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_binding", 21)) { ret = GLEW_ARB_vertex_attrib_binding; continue; } #endif #ifdef GL_ARB_vertex_blend if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12)) { ret = GLEW_ARB_vertex_blend; continue; } #endif #ifdef GL_ARB_vertex_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20)) { ret = GLEW_ARB_vertex_buffer_object; continue; } #endif #ifdef GL_ARB_vertex_program if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14)) { ret = GLEW_ARB_vertex_program; continue; } #endif #ifdef GL_ARB_vertex_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13)) { ret = GLEW_ARB_vertex_shader; continue; } #endif #ifdef GL_ARB_vertex_type_10f_11f_11f_rev if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_10f_11f_11f_rev", 27)) { ret = GLEW_ARB_vertex_type_10f_11f_11f_rev; continue; } #endif #ifdef GL_ARB_vertex_type_2_10_10_10_rev if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26)) { ret = GLEW_ARB_vertex_type_2_10_10_10_rev; continue; } #endif #ifdef GL_ARB_viewport_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14)) { ret = GLEW_ARB_viewport_array; continue; } #endif #ifdef GL_ARB_window_pos if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) { ret = GLEW_ARB_window_pos; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5)) { #ifdef GL_ATIX_point_sprites if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13)) { ret = GLEW_ATIX_point_sprites; continue; } #endif #ifdef GL_ATIX_texture_env_combine3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20)) { ret = GLEW_ATIX_texture_env_combine3; continue; } #endif #ifdef GL_ATIX_texture_env_route if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17)) { ret = GLEW_ATIX_texture_env_route; continue; } #endif #ifdef GL_ATIX_vertex_shader_output_point_size if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31)) { ret = GLEW_ATIX_vertex_shader_output_point_size; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) { #ifdef GL_ATI_draw_buffers if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) { ret = GLEW_ATI_draw_buffers; continue; } #endif #ifdef GL_ATI_element_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) { ret = GLEW_ATI_element_array; continue; } #endif #ifdef GL_ATI_envmap_bumpmap if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14)) { ret = GLEW_ATI_envmap_bumpmap; continue; } #endif #ifdef GL_ATI_fragment_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15)) { ret = GLEW_ATI_fragment_shader; continue; } #endif #ifdef GL_ATI_map_object_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17)) { ret = GLEW_ATI_map_object_buffer; continue; } #endif #ifdef GL_ATI_meminfo if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7)) { ret = GLEW_ATI_meminfo; continue; } #endif #ifdef GL_ATI_pn_triangles if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12)) { ret = GLEW_ATI_pn_triangles; continue; } #endif #ifdef GL_ATI_separate_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16)) { ret = GLEW_ATI_separate_stencil; continue; } #endif #ifdef GL_ATI_shader_texture_lod if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) { ret = GLEW_ATI_shader_texture_lod; continue; } #endif #ifdef GL_ATI_text_fragment_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20)) { ret = GLEW_ATI_text_fragment_shader; continue; } #endif #ifdef GL_ATI_texture_compression_3dc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23)) { ret = GLEW_ATI_texture_compression_3dc; continue; } #endif #ifdef GL_ATI_texture_env_combine3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20)) { ret = GLEW_ATI_texture_env_combine3; continue; } #endif #ifdef GL_ATI_texture_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13)) { ret = GLEW_ATI_texture_float; continue; } #endif #ifdef GL_ATI_texture_mirror_once if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19)) { ret = GLEW_ATI_texture_mirror_once; continue; } #endif #ifdef GL_ATI_vertex_array_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) { ret = GLEW_ATI_vertex_array_object; continue; } #endif #ifdef GL_ATI_vertex_attrib_array_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26)) { ret = GLEW_ATI_vertex_attrib_array_object; continue; } #endif #ifdef GL_ATI_vertex_streams if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14)) { ret = GLEW_ATI_vertex_streams; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) { #ifdef GL_EXT_422_pixels if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10)) { ret = GLEW_EXT_422_pixels; continue; } #endif #ifdef GL_EXT_Cg_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9)) { ret = GLEW_EXT_Cg_shader; continue; } #endif #ifdef GL_EXT_abgr if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4)) { ret = GLEW_EXT_abgr; continue; } #endif #ifdef GL_EXT_bgra if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4)) { ret = GLEW_EXT_bgra; continue; } #endif #ifdef GL_EXT_bindable_uniform if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16)) { ret = GLEW_EXT_bindable_uniform; continue; } #endif #ifdef GL_EXT_blend_color if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11)) { ret = GLEW_EXT_blend_color; continue; } #endif #ifdef GL_EXT_blend_equation_separate if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23)) { ret = GLEW_EXT_blend_equation_separate; continue; } #endif #ifdef GL_EXT_blend_func_separate if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19)) { ret = GLEW_EXT_blend_func_separate; continue; } #endif #ifdef GL_EXT_blend_logic_op if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14)) { ret = GLEW_EXT_blend_logic_op; continue; } #endif #ifdef GL_EXT_blend_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12)) { ret = GLEW_EXT_blend_minmax; continue; } #endif #ifdef GL_EXT_blend_subtract if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14)) { ret = GLEW_EXT_blend_subtract; continue; } #endif #ifdef GL_EXT_clip_volume_hint if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16)) { ret = GLEW_EXT_clip_volume_hint; continue; } #endif #ifdef GL_EXT_cmyka if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5)) { ret = GLEW_EXT_cmyka; continue; } #endif #ifdef GL_EXT_color_subtable if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14)) { ret = GLEW_EXT_color_subtable; continue; } #endif #ifdef GL_EXT_compiled_vertex_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21)) { ret = GLEW_EXT_compiled_vertex_array; continue; } #endif #ifdef GL_EXT_convolution if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11)) { ret = GLEW_EXT_convolution; continue; } #endif #ifdef GL_EXT_coordinate_frame if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16)) { ret = GLEW_EXT_coordinate_frame; continue; } #endif #ifdef GL_EXT_copy_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12)) { ret = GLEW_EXT_copy_texture; continue; } #endif #ifdef GL_EXT_cull_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11)) { ret = GLEW_EXT_cull_vertex; continue; } #endif #ifdef GL_EXT_debug_label if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_label", 11)) { ret = GLEW_EXT_debug_label; continue; } #endif #ifdef GL_EXT_debug_marker if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_marker", 12)) { ret = GLEW_EXT_debug_marker; continue; } #endif #ifdef GL_EXT_depth_bounds_test if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17)) { ret = GLEW_EXT_depth_bounds_test; continue; } #endif #ifdef GL_EXT_direct_state_access if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19)) { ret = GLEW_EXT_direct_state_access; continue; } #endif #ifdef GL_EXT_draw_buffers2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13)) { ret = GLEW_EXT_draw_buffers2; continue; } #endif #ifdef GL_EXT_draw_instanced if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) { ret = GLEW_EXT_draw_instanced; continue; } #endif #ifdef GL_EXT_draw_range_elements if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19)) { ret = GLEW_EXT_draw_range_elements; continue; } #endif #ifdef GL_EXT_fog_coord if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9)) { ret = GLEW_EXT_fog_coord; continue; } #endif #ifdef GL_EXT_fragment_lighting if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17)) { ret = GLEW_EXT_fragment_lighting; continue; } #endif #ifdef GL_EXT_framebuffer_blit if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16)) { ret = GLEW_EXT_framebuffer_blit; continue; } #endif #ifdef GL_EXT_framebuffer_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) { ret = GLEW_EXT_framebuffer_multisample; continue; } #endif #ifdef GL_EXT_framebuffer_multisample_blit_scaled if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_blit_scaled", 35)) { ret = GLEW_EXT_framebuffer_multisample_blit_scaled; continue; } #endif #ifdef GL_EXT_framebuffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) { ret = GLEW_EXT_framebuffer_object; continue; } #endif #ifdef GL_EXT_framebuffer_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) { ret = GLEW_EXT_framebuffer_sRGB; continue; } #endif #ifdef GL_EXT_geometry_shader4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) { ret = GLEW_EXT_geometry_shader4; continue; } #endif #ifdef GL_EXT_gpu_program_parameters if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22)) { ret = GLEW_EXT_gpu_program_parameters; continue; } #endif #ifdef GL_EXT_gpu_shader4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11)) { ret = GLEW_EXT_gpu_shader4; continue; } #endif #ifdef GL_EXT_histogram if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9)) { ret = GLEW_EXT_histogram; continue; } #endif #ifdef GL_EXT_index_array_formats if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19)) { ret = GLEW_EXT_index_array_formats; continue; } #endif #ifdef GL_EXT_index_func if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10)) { ret = GLEW_EXT_index_func; continue; } #endif #ifdef GL_EXT_index_material if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14)) { ret = GLEW_EXT_index_material; continue; } #endif #ifdef GL_EXT_index_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13)) { ret = GLEW_EXT_index_texture; continue; } #endif #ifdef GL_EXT_light_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13)) { ret = GLEW_EXT_light_texture; continue; } #endif #ifdef GL_EXT_misc_attribute if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14)) { ret = GLEW_EXT_misc_attribute; continue; } #endif #ifdef GL_EXT_multi_draw_arrays if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17)) { ret = GLEW_EXT_multi_draw_arrays; continue; } #endif #ifdef GL_EXT_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLEW_EXT_multisample; continue; } #endif #ifdef GL_EXT_packed_depth_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) { ret = GLEW_EXT_packed_depth_stencil; continue; } #endif #ifdef GL_EXT_packed_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12)) { ret = GLEW_EXT_packed_float; continue; } #endif #ifdef GL_EXT_packed_pixels if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13)) { ret = GLEW_EXT_packed_pixels; continue; } #endif #ifdef GL_EXT_paletted_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16)) { ret = GLEW_EXT_paletted_texture; continue; } #endif #ifdef GL_EXT_pixel_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) { ret = GLEW_EXT_pixel_buffer_object; continue; } #endif #ifdef GL_EXT_pixel_transform if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15)) { ret = GLEW_EXT_pixel_transform; continue; } #endif #ifdef GL_EXT_pixel_transform_color_table if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27)) { ret = GLEW_EXT_pixel_transform_color_table; continue; } #endif #ifdef GL_EXT_point_parameters if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16)) { ret = GLEW_EXT_point_parameters; continue; } #endif #ifdef GL_EXT_polygon_offset if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14)) { ret = GLEW_EXT_polygon_offset; continue; } #endif #ifdef GL_EXT_polygon_offset_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset_clamp", 20)) { ret = GLEW_EXT_polygon_offset_clamp; continue; } #endif #ifdef GL_EXT_post_depth_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_depth_coverage", 19)) { ret = GLEW_EXT_post_depth_coverage; continue; } #endif #ifdef GL_EXT_provoking_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16)) { ret = GLEW_EXT_provoking_vertex; continue; } #endif #ifdef GL_EXT_raster_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"raster_multisample", 18)) { ret = GLEW_EXT_raster_multisample; continue; } #endif #ifdef GL_EXT_rescale_normal if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14)) { ret = GLEW_EXT_rescale_normal; continue; } #endif #ifdef GL_EXT_scene_marker if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) { ret = GLEW_EXT_scene_marker; continue; } #endif #ifdef GL_EXT_secondary_color if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15)) { ret = GLEW_EXT_secondary_color; continue; } #endif #ifdef GL_EXT_separate_shader_objects if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23)) { ret = GLEW_EXT_separate_shader_objects; continue; } #endif #ifdef GL_EXT_separate_specular_color if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23)) { ret = GLEW_EXT_separate_specular_color; continue; } #endif #ifdef GL_EXT_shader_image_load_formatted if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_formatted", 27)) { ret = GLEW_EXT_shader_image_load_formatted; continue; } #endif #ifdef GL_EXT_shader_image_load_store if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23)) { ret = GLEW_EXT_shader_image_load_store; continue; } #endif #ifdef GL_EXT_shader_integer_mix if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_integer_mix", 18)) { ret = GLEW_EXT_shader_integer_mix; continue; } #endif #ifdef GL_EXT_shadow_funcs if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12)) { ret = GLEW_EXT_shadow_funcs; continue; } #endif #ifdef GL_EXT_shared_texture_palette if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22)) { ret = GLEW_EXT_shared_texture_palette; continue; } #endif #ifdef GL_EXT_sparse_texture2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture2", 15)) { ret = GLEW_EXT_sparse_texture2; continue; } #endif #ifdef GL_EXT_stencil_clear_tag if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17)) { ret = GLEW_EXT_stencil_clear_tag; continue; } #endif #ifdef GL_EXT_stencil_two_side if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16)) { ret = GLEW_EXT_stencil_two_side; continue; } #endif #ifdef GL_EXT_stencil_wrap if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12)) { ret = GLEW_EXT_stencil_wrap; continue; } #endif #ifdef GL_EXT_subtexture if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10)) { ret = GLEW_EXT_subtexture; continue; } #endif #ifdef GL_EXT_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7)) { ret = GLEW_EXT_texture; continue; } #endif #ifdef GL_EXT_texture3D if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9)) { ret = GLEW_EXT_texture3D; continue; } #endif #ifdef GL_EXT_texture_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13)) { ret = GLEW_EXT_texture_array; continue; } #endif #ifdef GL_EXT_texture_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) { ret = GLEW_EXT_texture_buffer_object; continue; } #endif #ifdef GL_EXT_texture_compression_dxt1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24)) { ret = GLEW_EXT_texture_compression_dxt1; continue; } #endif #ifdef GL_EXT_texture_compression_latc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24)) { ret = GLEW_EXT_texture_compression_latc; continue; } #endif #ifdef GL_EXT_texture_compression_rgtc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24)) { ret = GLEW_EXT_texture_compression_rgtc; continue; } #endif #ifdef GL_EXT_texture_compression_s3tc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24)) { ret = GLEW_EXT_texture_compression_s3tc; continue; } #endif #ifdef GL_EXT_texture_cube_map if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) { ret = GLEW_EXT_texture_cube_map; continue; } #endif #ifdef GL_EXT_texture_edge_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) { ret = GLEW_EXT_texture_edge_clamp; continue; } #endif #ifdef GL_EXT_texture_env if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11)) { ret = GLEW_EXT_texture_env; continue; } #endif #ifdef GL_EXT_texture_env_add if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15)) { ret = GLEW_EXT_texture_env_add; continue; } #endif #ifdef GL_EXT_texture_env_combine if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19)) { ret = GLEW_EXT_texture_env_combine; continue; } #endif #ifdef GL_EXT_texture_env_dot3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16)) { ret = GLEW_EXT_texture_env_dot3; continue; } #endif #ifdef GL_EXT_texture_filter_anisotropic if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26)) { ret = GLEW_EXT_texture_filter_anisotropic; continue; } #endif #ifdef GL_EXT_texture_filter_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_minmax", 21)) { ret = GLEW_EXT_texture_filter_minmax; continue; } #endif #ifdef GL_EXT_texture_integer if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15)) { ret = GLEW_EXT_texture_integer; continue; } #endif #ifdef GL_EXT_texture_lod_bias if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) { ret = GLEW_EXT_texture_lod_bias; continue; } #endif #ifdef GL_EXT_texture_mirror_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20)) { ret = GLEW_EXT_texture_mirror_clamp; continue; } #endif #ifdef GL_EXT_texture_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14)) { ret = GLEW_EXT_texture_object; continue; } #endif #ifdef GL_EXT_texture_perturb_normal if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22)) { ret = GLEW_EXT_texture_perturb_normal; continue; } #endif #ifdef GL_EXT_texture_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) { ret = GLEW_EXT_texture_rectangle; continue; } #endif #ifdef GL_EXT_texture_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12)) { ret = GLEW_EXT_texture_sRGB; continue; } #endif #ifdef GL_EXT_texture_sRGB_decode if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19)) { ret = GLEW_EXT_texture_sRGB_decode; continue; } #endif #ifdef GL_EXT_texture_shared_exponent if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23)) { ret = GLEW_EXT_texture_shared_exponent; continue; } #endif #ifdef GL_EXT_texture_snorm if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13)) { ret = GLEW_EXT_texture_snorm; continue; } #endif #ifdef GL_EXT_texture_swizzle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) { ret = GLEW_EXT_texture_swizzle; continue; } #endif #ifdef GL_EXT_timer_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) { ret = GLEW_EXT_timer_query; continue; } #endif #ifdef GL_EXT_transform_feedback if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) { ret = GLEW_EXT_transform_feedback; continue; } #endif #ifdef GL_EXT_vertex_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12)) { ret = GLEW_EXT_vertex_array; continue; } #endif #ifdef GL_EXT_vertex_array_bgra if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17)) { ret = GLEW_EXT_vertex_array_bgra; continue; } #endif #ifdef GL_EXT_vertex_attrib_64bit if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19)) { ret = GLEW_EXT_vertex_attrib_64bit; continue; } #endif #ifdef GL_EXT_vertex_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13)) { ret = GLEW_EXT_vertex_shader; continue; } #endif #ifdef GL_EXT_vertex_weighting if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16)) { ret = GLEW_EXT_vertex_weighting; continue; } #endif #ifdef GL_EXT_x11_sync_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"x11_sync_object", 15)) { ret = GLEW_EXT_x11_sync_object; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8)) { #ifdef GL_GREMEDY_frame_terminator if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16)) { ret = GLEW_GREMEDY_frame_terminator; continue; } #endif #ifdef GL_GREMEDY_string_marker if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13)) { ret = GLEW_GREMEDY_string_marker; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3)) { #ifdef GL_HP_convolution_border_modes if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24)) { ret = GLEW_HP_convolution_border_modes; continue; } #endif #ifdef GL_HP_image_transform if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15)) { ret = GLEW_HP_image_transform; continue; } #endif #ifdef GL_HP_occlusion_test if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14)) { ret = GLEW_HP_occlusion_test; continue; } #endif #ifdef GL_HP_texture_lighting if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16)) { ret = GLEW_HP_texture_lighting; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4)) { #ifdef GL_IBM_cull_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11)) { ret = GLEW_IBM_cull_vertex; continue; } #endif #ifdef GL_IBM_multimode_draw_arrays if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21)) { ret = GLEW_IBM_multimode_draw_arrays; continue; } #endif #ifdef GL_IBM_rasterpos_clip if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14)) { ret = GLEW_IBM_rasterpos_clip; continue; } #endif #ifdef GL_IBM_static_data if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11)) { ret = GLEW_IBM_static_data; continue; } #endif #ifdef GL_IBM_texture_mirrored_repeat if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) { ret = GLEW_IBM_texture_mirrored_repeat; continue; } #endif #ifdef GL_IBM_vertex_array_lists if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18)) { ret = GLEW_IBM_vertex_array_lists; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5)) { #ifdef GL_INGR_color_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11)) { ret = GLEW_INGR_color_clamp; continue; } #endif #ifdef GL_INGR_interlace_read if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14)) { ret = GLEW_INGR_interlace_read; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6)) { #ifdef GL_INTEL_fragment_shader_ordering if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_ordering", 24)) { ret = GLEW_INTEL_fragment_shader_ordering; continue; } #endif #ifdef GL_INTEL_framebuffer_CMAA if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_CMAA", 16)) { ret = GLEW_INTEL_framebuffer_CMAA; continue; } #endif #ifdef GL_INTEL_map_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_texture", 11)) { ret = GLEW_INTEL_map_texture; continue; } #endif #ifdef GL_INTEL_parallel_arrays if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15)) { ret = GLEW_INTEL_parallel_arrays; continue; } #endif #ifdef GL_INTEL_performance_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_query", 17)) { ret = GLEW_INTEL_performance_query; continue; } #endif #ifdef GL_INTEL_texture_scissor if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15)) { ret = GLEW_INTEL_texture_scissor; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"KHR_", 4)) { #ifdef GL_KHR_blend_equation_advanced if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced", 23)) { ret = GLEW_KHR_blend_equation_advanced; continue; } #endif #ifdef GL_KHR_blend_equation_advanced_coherent if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced_coherent", 32)) { ret = GLEW_KHR_blend_equation_advanced_coherent; continue; } #endif #ifdef GL_KHR_context_flush_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21)) { ret = GLEW_KHR_context_flush_control; continue; } #endif #ifdef GL_KHR_debug if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug", 5)) { ret = GLEW_KHR_debug; continue; } #endif #ifdef GL_KHR_no_error if (_glewStrSame3(&pos, &len, (const GLubyte*)"no_error", 8)) { ret = GLEW_KHR_no_error; continue; } #endif #ifdef GL_KHR_robust_buffer_access_behavior if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29)) { ret = GLEW_KHR_robust_buffer_access_behavior; continue; } #endif #ifdef GL_KHR_robustness if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10)) { ret = GLEW_KHR_robustness; continue; } #endif #ifdef GL_KHR_texture_compression_astc_hdr if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_hdr", 28)) { ret = GLEW_KHR_texture_compression_astc_hdr; continue; } #endif #ifdef GL_KHR_texture_compression_astc_ldr if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_ldr", 28)) { ret = GLEW_KHR_texture_compression_astc_ldr; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4)) { #ifdef GL_KTX_buffer_region if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13)) { ret = GLEW_KTX_buffer_region; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6)) { #ifdef GL_MESAX_texture_stack if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13)) { ret = GLEW_MESAX_texture_stack; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) { #ifdef GL_MESA_pack_invert if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11)) { ret = GLEW_MESA_pack_invert; continue; } #endif #ifdef GL_MESA_resize_buffers if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14)) { ret = GLEW_MESA_resize_buffers; continue; } #endif #ifdef GL_MESA_window_pos if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) { ret = GLEW_MESA_window_pos; continue; } #endif #ifdef GL_MESA_ycbcr_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13)) { ret = GLEW_MESA_ycbcr_texture; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"NVX_", 4)) { #ifdef GL_NVX_conditional_render if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18)) { ret = GLEW_NVX_conditional_render; continue; } #endif #ifdef GL_NVX_gpu_memory_info if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_memory_info", 15)) { ret = GLEW_NVX_gpu_memory_info; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) { #ifdef GL_NV_bindless_multi_draw_indirect if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_multi_draw_indirect", 28)) { ret = GLEW_NV_bindless_multi_draw_indirect; continue; } #endif #ifdef GL_NV_bindless_multi_draw_indirect_count if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_multi_draw_indirect_count", 34)) { ret = GLEW_NV_bindless_multi_draw_indirect_count; continue; } #endif #ifdef GL_NV_bindless_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16)) { ret = GLEW_NV_bindless_texture; continue; } #endif #ifdef GL_NV_blend_equation_advanced if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced", 23)) { ret = GLEW_NV_blend_equation_advanced; continue; } #endif #ifdef GL_NV_blend_equation_advanced_coherent if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_advanced_coherent", 32)) { ret = GLEW_NV_blend_equation_advanced_coherent; continue; } #endif #ifdef GL_NV_blend_square if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12)) { ret = GLEW_NV_blend_square; continue; } #endif #ifdef GL_NV_compute_program5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_program5", 16)) { ret = GLEW_NV_compute_program5; continue; } #endif #ifdef GL_NV_conditional_render if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18)) { ret = GLEW_NV_conditional_render; continue; } #endif #ifdef GL_NV_conservative_raster if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster", 19)) { ret = GLEW_NV_conservative_raster; continue; } #endif #ifdef GL_NV_conservative_raster_dilate if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster_dilate", 26)) { ret = GLEW_NV_conservative_raster_dilate; continue; } #endif #ifdef GL_NV_copy_depth_to_color if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19)) { ret = GLEW_NV_copy_depth_to_color; continue; } #endif #ifdef GL_NV_copy_image if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) { ret = GLEW_NV_copy_image; continue; } #endif #ifdef GL_NV_deep_texture3D if (_glewStrSame3(&pos, &len, (const GLubyte*)"deep_texture3D", 14)) { ret = GLEW_NV_deep_texture3D; continue; } #endif #ifdef GL_NV_depth_buffer_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18)) { ret = GLEW_NV_depth_buffer_float; continue; } #endif #ifdef GL_NV_depth_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11)) { ret = GLEW_NV_depth_clamp; continue; } #endif #ifdef GL_NV_depth_range_unclamped if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21)) { ret = GLEW_NV_depth_range_unclamped; continue; } #endif #ifdef GL_NV_draw_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_texture", 12)) { ret = GLEW_NV_draw_texture; continue; } #endif #ifdef GL_NV_evaluators if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10)) { ret = GLEW_NV_evaluators; continue; } #endif #ifdef GL_NV_explicit_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20)) { ret = GLEW_NV_explicit_multisample; continue; } #endif #ifdef GL_NV_fence if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) { ret = GLEW_NV_fence; continue; } #endif #ifdef GL_NV_fill_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"fill_rectangle", 14)) { ret = GLEW_NV_fill_rectangle; continue; } #endif #ifdef GL_NV_float_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) { ret = GLEW_NV_float_buffer; continue; } #endif #ifdef GL_NV_fog_distance if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12)) { ret = GLEW_NV_fog_distance; continue; } #endif #ifdef GL_NV_fragment_coverage_to_color if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coverage_to_color", 26)) { ret = GLEW_NV_fragment_coverage_to_color; continue; } #endif #ifdef GL_NV_fragment_program if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16)) { ret = GLEW_NV_fragment_program; continue; } #endif #ifdef GL_NV_fragment_program2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17)) { ret = GLEW_NV_fragment_program2; continue; } #endif #ifdef GL_NV_fragment_program4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17)) { ret = GLEW_NV_fragment_program4; continue; } #endif #ifdef GL_NV_fragment_program_option if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23)) { ret = GLEW_NV_fragment_program_option; continue; } #endif #ifdef GL_NV_fragment_shader_interlock if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_interlock", 25)) { ret = GLEW_NV_fragment_shader_interlock; continue; } #endif #ifdef GL_NV_framebuffer_mixed_samples if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_mixed_samples", 25)) { ret = GLEW_NV_framebuffer_mixed_samples; continue; } #endif #ifdef GL_NV_framebuffer_multisample_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32)) { ret = GLEW_NV_framebuffer_multisample_coverage; continue; } #endif #ifdef GL_NV_geometry_program4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17)) { ret = GLEW_NV_geometry_program4; continue; } #endif #ifdef GL_NV_geometry_shader4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) { ret = GLEW_NV_geometry_shader4; continue; } #endif #ifdef GL_NV_geometry_shader_passthrough if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader_passthrough", 27)) { ret = GLEW_NV_geometry_shader_passthrough; continue; } #endif #ifdef GL_NV_gpu_program4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12)) { ret = GLEW_NV_gpu_program4; continue; } #endif #ifdef GL_NV_gpu_program5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12)) { ret = GLEW_NV_gpu_program5; continue; } #endif #ifdef GL_NV_gpu_program5_mem_extended if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5_mem_extended", 25)) { ret = GLEW_NV_gpu_program5_mem_extended; continue; } #endif #ifdef GL_NV_gpu_program_fp64 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16)) { ret = GLEW_NV_gpu_program_fp64; continue; } #endif #ifdef GL_NV_gpu_shader5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11)) { ret = GLEW_NV_gpu_shader5; continue; } #endif #ifdef GL_NV_half_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10)) { ret = GLEW_NV_half_float; continue; } #endif #ifdef GL_NV_internalformat_sample_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_sample_query", 27)) { ret = GLEW_NV_internalformat_sample_query; continue; } #endif #ifdef GL_NV_light_max_exponent if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18)) { ret = GLEW_NV_light_max_exponent; continue; } #endif #ifdef GL_NV_multisample_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) { ret = GLEW_NV_multisample_coverage; continue; } #endif #ifdef GL_NV_multisample_filter_hint if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23)) { ret = GLEW_NV_multisample_filter_hint; continue; } #endif #ifdef GL_NV_occlusion_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) { ret = GLEW_NV_occlusion_query; continue; } #endif #ifdef GL_NV_packed_depth_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) { ret = GLEW_NV_packed_depth_stencil; continue; } #endif #ifdef GL_NV_parameter_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23)) { ret = GLEW_NV_parameter_buffer_object; continue; } #endif #ifdef GL_NV_parameter_buffer_object2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24)) { ret = GLEW_NV_parameter_buffer_object2; continue; } #endif #ifdef GL_NV_path_rendering if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering", 14)) { ret = GLEW_NV_path_rendering; continue; } #endif #ifdef GL_NV_path_rendering_shared_edge if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering_shared_edge", 26)) { ret = GLEW_NV_path_rendering_shared_edge; continue; } #endif #ifdef GL_NV_pixel_data_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16)) { ret = GLEW_NV_pixel_data_range; continue; } #endif #ifdef GL_NV_point_sprite if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) { ret = GLEW_NV_point_sprite; continue; } #endif #ifdef GL_NV_present_video if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) { ret = GLEW_NV_present_video; continue; } #endif #ifdef GL_NV_primitive_restart if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17)) { ret = GLEW_NV_primitive_restart; continue; } #endif #ifdef GL_NV_register_combiners if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18)) { ret = GLEW_NV_register_combiners; continue; } #endif #ifdef GL_NV_register_combiners2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19)) { ret = GLEW_NV_register_combiners2; continue; } #endif #ifdef GL_NV_sample_locations if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_locations", 16)) { ret = GLEW_NV_sample_locations; continue; } #endif #ifdef GL_NV_sample_mask_override_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_mask_override_coverage", 29)) { ret = GLEW_NV_sample_mask_override_coverage; continue; } #endif #ifdef GL_NV_shader_atomic_counters if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22)) { ret = GLEW_NV_shader_atomic_counters; continue; } #endif #ifdef GL_NV_shader_atomic_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_float", 19)) { ret = GLEW_NV_shader_atomic_float; continue; } #endif #ifdef GL_NV_shader_atomic_fp16_vector if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_fp16_vector", 25)) { ret = GLEW_NV_shader_atomic_fp16_vector; continue; } #endif #ifdef GL_NV_shader_atomic_int64 if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_int64", 19)) { ret = GLEW_NV_shader_atomic_int64; continue; } #endif #ifdef GL_NV_shader_buffer_load if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18)) { ret = GLEW_NV_shader_buffer_load; continue; } #endif #ifdef GL_NV_shader_storage_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28)) { ret = GLEW_NV_shader_storage_buffer_object; continue; } #endif #ifdef GL_NV_shader_thread_group if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_thread_group", 19)) { ret = GLEW_NV_shader_thread_group; continue; } #endif #ifdef GL_NV_shader_thread_shuffle if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_thread_shuffle", 21)) { ret = GLEW_NV_shader_thread_shuffle; continue; } #endif #ifdef GL_NV_tessellation_program5 if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21)) { ret = GLEW_NV_tessellation_program5; continue; } #endif #ifdef GL_NV_texgen_emboss if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13)) { ret = GLEW_NV_texgen_emboss; continue; } #endif #ifdef GL_NV_texgen_reflection if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17)) { ret = GLEW_NV_texgen_reflection; continue; } #endif #ifdef GL_NV_texture_barrier if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15)) { ret = GLEW_NV_texture_barrier; continue; } #endif #ifdef GL_NV_texture_compression_vtc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23)) { ret = GLEW_NV_texture_compression_vtc; continue; } #endif #ifdef GL_NV_texture_env_combine4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20)) { ret = GLEW_NV_texture_env_combine4; continue; } #endif #ifdef GL_NV_texture_expand_normal if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21)) { ret = GLEW_NV_texture_expand_normal; continue; } #endif #ifdef GL_NV_texture_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19)) { ret = GLEW_NV_texture_multisample; continue; } #endif #ifdef GL_NV_texture_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) { ret = GLEW_NV_texture_rectangle; continue; } #endif #ifdef GL_NV_texture_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14)) { ret = GLEW_NV_texture_shader; continue; } #endif #ifdef GL_NV_texture_shader2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15)) { ret = GLEW_NV_texture_shader2; continue; } #endif #ifdef GL_NV_texture_shader3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15)) { ret = GLEW_NV_texture_shader3; continue; } #endif #ifdef GL_NV_transform_feedback if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) { ret = GLEW_NV_transform_feedback; continue; } #endif #ifdef GL_NV_transform_feedback2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19)) { ret = GLEW_NV_transform_feedback2; continue; } #endif #ifdef GL_NV_uniform_buffer_unified_memory if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_unified_memory", 29)) { ret = GLEW_NV_uniform_buffer_unified_memory; continue; } #endif #ifdef GL_NV_vdpau_interop if (_glewStrSame3(&pos, &len, (const GLubyte*)"vdpau_interop", 13)) { ret = GLEW_NV_vdpau_interop; continue; } #endif #ifdef GL_NV_vertex_array_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) { ret = GLEW_NV_vertex_array_range; continue; } #endif #ifdef GL_NV_vertex_array_range2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19)) { ret = GLEW_NV_vertex_array_range2; continue; } #endif #ifdef GL_NV_vertex_attrib_integer_64bit if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27)) { ret = GLEW_NV_vertex_attrib_integer_64bit; continue; } #endif #ifdef GL_NV_vertex_buffer_unified_memory if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28)) { ret = GLEW_NV_vertex_buffer_unified_memory; continue; } #endif #ifdef GL_NV_vertex_program if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14)) { ret = GLEW_NV_vertex_program; continue; } #endif #ifdef GL_NV_vertex_program1_1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17)) { ret = GLEW_NV_vertex_program1_1; continue; } #endif #ifdef GL_NV_vertex_program2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15)) { ret = GLEW_NV_vertex_program2; continue; } #endif #ifdef GL_NV_vertex_program2_option if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22)) { ret = GLEW_NV_vertex_program2_option; continue; } #endif #ifdef GL_NV_vertex_program3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15)) { ret = GLEW_NV_vertex_program3; continue; } #endif #ifdef GL_NV_vertex_program4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15)) { ret = GLEW_NV_vertex_program4; continue; } #endif #ifdef GL_NV_video_capture if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13)) { ret = GLEW_NV_video_capture; continue; } #endif #ifdef GL_NV_viewport_array2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array2", 15)) { ret = GLEW_NV_viewport_array2; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4)) { #ifdef GL_OES_byte_coordinates if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16)) { ret = GLEW_OES_byte_coordinates; continue; } #endif #ifdef GL_OES_compressed_paletted_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27)) { ret = GLEW_OES_compressed_paletted_texture; continue; } #endif #ifdef GL_OES_read_format if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) { ret = GLEW_OES_read_format; continue; } #endif #ifdef GL_OES_single_precision if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16)) { ret = GLEW_OES_single_precision; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) { #ifdef GL_OML_interlace if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) { ret = GLEW_OML_interlace; continue; } #endif #ifdef GL_OML_resample if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8)) { ret = GLEW_OML_resample; continue; } #endif #ifdef GL_OML_subsample if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9)) { ret = GLEW_OML_subsample; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OVR_", 4)) { #ifdef GL_OVR_multiview if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview", 9)) { ret = GLEW_OVR_multiview; continue; } #endif #ifdef GL_OVR_multiview2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview2", 10)) { ret = GLEW_OVR_multiview2; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4)) { #ifdef GL_PGI_misc_hints if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10)) { ret = GLEW_PGI_misc_hints; continue; } #endif #ifdef GL_PGI_vertex_hints if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12)) { ret = GLEW_PGI_vertex_hints; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6)) { #ifdef GL_REGAL_ES1_0_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES1_0_compatibility", 19)) { ret = GLEW_REGAL_ES1_0_compatibility; continue; } #endif #ifdef GL_REGAL_ES1_1_compatibility if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES1_1_compatibility", 19)) { ret = GLEW_REGAL_ES1_1_compatibility; continue; } #endif #ifdef GL_REGAL_enable if (_glewStrSame3(&pos, &len, (const GLubyte*)"enable", 6)) { ret = GLEW_REGAL_enable; continue; } #endif #ifdef GL_REGAL_error_string if (_glewStrSame3(&pos, &len, (const GLubyte*)"error_string", 12)) { ret = GLEW_REGAL_error_string; continue; } #endif #ifdef GL_REGAL_extension_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"extension_query", 15)) { ret = GLEW_REGAL_extension_query; continue; } #endif #ifdef GL_REGAL_log if (_glewStrSame3(&pos, &len, (const GLubyte*)"log", 3)) { ret = GLEW_REGAL_log; continue; } #endif #ifdef GL_REGAL_proc_address if (_glewStrSame3(&pos, &len, (const GLubyte*)"proc_address", 12)) { ret = GLEW_REGAL_proc_address; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5)) { #ifdef GL_REND_screen_coordinates if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18)) { ret = GLEW_REND_screen_coordinates; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3)) { #ifdef GL_S3_s3tc if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4)) { ret = GLEW_S3_s3tc; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) { #ifdef GL_SGIS_color_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) { ret = GLEW_SGIS_color_range; continue; } #endif #ifdef GL_SGIS_detail_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14)) { ret = GLEW_SGIS_detail_texture; continue; } #endif #ifdef GL_SGIS_fog_function if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12)) { ret = GLEW_SGIS_fog_function; continue; } #endif #ifdef GL_SGIS_generate_mipmap if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15)) { ret = GLEW_SGIS_generate_mipmap; continue; } #endif #ifdef GL_SGIS_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLEW_SGIS_multisample; continue; } #endif #ifdef GL_SGIS_pixel_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) { ret = GLEW_SGIS_pixel_texture; continue; } #endif #ifdef GL_SGIS_point_line_texgen if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17)) { ret = GLEW_SGIS_point_line_texgen; continue; } #endif #ifdef GL_SGIS_sharpen_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15)) { ret = GLEW_SGIS_sharpen_texture; continue; } #endif #ifdef GL_SGIS_texture4D if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9)) { ret = GLEW_SGIS_texture4D; continue; } #endif #ifdef GL_SGIS_texture_border_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) { ret = GLEW_SGIS_texture_border_clamp; continue; } #endif #ifdef GL_SGIS_texture_edge_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) { ret = GLEW_SGIS_texture_edge_clamp; continue; } #endif #ifdef GL_SGIS_texture_filter4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15)) { ret = GLEW_SGIS_texture_filter4; continue; } #endif #ifdef GL_SGIS_texture_lod if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11)) { ret = GLEW_SGIS_texture_lod; continue; } #endif #ifdef GL_SGIS_texture_select if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14)) { ret = GLEW_SGIS_texture_select; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5)) { #ifdef GL_SGIX_async if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5)) { ret = GLEW_SGIX_async; continue; } #endif #ifdef GL_SGIX_async_histogram if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15)) { ret = GLEW_SGIX_async_histogram; continue; } #endif #ifdef GL_SGIX_async_pixel if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11)) { ret = GLEW_SGIX_async_pixel; continue; } #endif #ifdef GL_SGIX_blend_alpha_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18)) { ret = GLEW_SGIX_blend_alpha_minmax; continue; } #endif #ifdef GL_SGIX_clipmap if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7)) { ret = GLEW_SGIX_clipmap; continue; } #endif #ifdef GL_SGIX_convolution_accuracy if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20)) { ret = GLEW_SGIX_convolution_accuracy; continue; } #endif #ifdef GL_SGIX_depth_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) { ret = GLEW_SGIX_depth_texture; continue; } #endif #ifdef GL_SGIX_flush_raster if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12)) { ret = GLEW_SGIX_flush_raster; continue; } #endif #ifdef GL_SGIX_fog_offset if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10)) { ret = GLEW_SGIX_fog_offset; continue; } #endif #ifdef GL_SGIX_fog_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11)) { ret = GLEW_SGIX_fog_texture; continue; } #endif #ifdef GL_SGIX_fragment_specular_lighting if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26)) { ret = GLEW_SGIX_fragment_specular_lighting; continue; } #endif #ifdef GL_SGIX_framezoom if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9)) { ret = GLEW_SGIX_framezoom; continue; } #endif #ifdef GL_SGIX_interlace if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) { ret = GLEW_SGIX_interlace; continue; } #endif #ifdef GL_SGIX_ir_instrument1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14)) { ret = GLEW_SGIX_ir_instrument1; continue; } #endif #ifdef GL_SGIX_list_priority if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13)) { ret = GLEW_SGIX_list_priority; continue; } #endif #ifdef GL_SGIX_pixel_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) { ret = GLEW_SGIX_pixel_texture; continue; } #endif #ifdef GL_SGIX_pixel_texture_bits if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18)) { ret = GLEW_SGIX_pixel_texture_bits; continue; } #endif #ifdef GL_SGIX_reference_plane if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15)) { ret = GLEW_SGIX_reference_plane; continue; } #endif #ifdef GL_SGIX_resample if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8)) { ret = GLEW_SGIX_resample; continue; } #endif #ifdef GL_SGIX_shadow if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) { ret = GLEW_SGIX_shadow; continue; } #endif #ifdef GL_SGIX_shadow_ambient if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14)) { ret = GLEW_SGIX_shadow_ambient; continue; } #endif #ifdef GL_SGIX_sprite if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6)) { ret = GLEW_SGIX_sprite; continue; } #endif #ifdef GL_SGIX_tag_sample_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17)) { ret = GLEW_SGIX_tag_sample_buffer; continue; } #endif #ifdef GL_SGIX_texture_add_env if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15)) { ret = GLEW_SGIX_texture_add_env; continue; } #endif #ifdef GL_SGIX_texture_coordinate_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24)) { ret = GLEW_SGIX_texture_coordinate_clamp; continue; } #endif #ifdef GL_SGIX_texture_lod_bias if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) { ret = GLEW_SGIX_texture_lod_bias; continue; } #endif #ifdef GL_SGIX_texture_multi_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20)) { ret = GLEW_SGIX_texture_multi_buffer; continue; } #endif #ifdef GL_SGIX_texture_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) { ret = GLEW_SGIX_texture_range; continue; } #endif #ifdef GL_SGIX_texture_scale_bias if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18)) { ret = GLEW_SGIX_texture_scale_bias; continue; } #endif #ifdef GL_SGIX_vertex_preclip if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14)) { ret = GLEW_SGIX_vertex_preclip; continue; } #endif #ifdef GL_SGIX_vertex_preclip_hint if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19)) { ret = GLEW_SGIX_vertex_preclip_hint; continue; } #endif #ifdef GL_SGIX_ycrcb if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5)) { ret = GLEW_SGIX_ycrcb; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) { #ifdef GL_SGI_color_matrix if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12)) { ret = GLEW_SGI_color_matrix; continue; } #endif #ifdef GL_SGI_color_table if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11)) { ret = GLEW_SGI_color_table; continue; } #endif #ifdef GL_SGI_texture_color_table if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19)) { ret = GLEW_SGI_texture_color_table; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5)) { #ifdef GL_SUNX_constant_data if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13)) { ret = GLEW_SUNX_constant_data; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4)) { #ifdef GL_SUN_convolution_border_modes if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24)) { ret = GLEW_SUN_convolution_border_modes; continue; } #endif #ifdef GL_SUN_global_alpha if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12)) { ret = GLEW_SUN_global_alpha; continue; } #endif #ifdef GL_SUN_mesh_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10)) { ret = GLEW_SUN_mesh_array; continue; } #endif #ifdef GL_SUN_read_video_pixels if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17)) { ret = GLEW_SUN_read_video_pixels; continue; } #endif #ifdef GL_SUN_slice_accum if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11)) { ret = GLEW_SUN_slice_accum; continue; } #endif #ifdef GL_SUN_triangle_list if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13)) { ret = GLEW_SUN_triangle_list; continue; } #endif #ifdef GL_SUN_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6)) { ret = GLEW_SUN_vertex; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4)) { #ifdef GL_WIN_phong_shading if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13)) { ret = GLEW_WIN_phong_shading; continue; } #endif #ifdef GL_WIN_specular_fog if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12)) { ret = GLEW_WIN_specular_fog; continue; } #endif #ifdef GL_WIN_swap_hint if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9)) { ret = GLEW_WIN_swap_hint; continue; } #endif } } ret = (len == 0); } return ret; } #if defined(_WIN32) #if defined(GLEW_MX) GLboolean GLEWAPIENTRY wglewContextIsSupported (const WGLEWContext* ctx, const char* name) #else GLboolean GLEWAPIENTRY wglewIsSupported (const char* name) #endif { const GLubyte* pos = (const GLubyte*)name; GLuint len = _glewStrLen(pos); GLboolean ret = GL_TRUE; while (ret && len > 0) { if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4)) { if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) { #ifdef WGL_3DFX_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = WGLEW_3DFX_multisample; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4)) { #ifdef WGL_3DL_stereo_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14)) { ret = WGLEW_3DL_stereo_control; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4)) { #ifdef WGL_AMD_gpu_association if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15)) { ret = WGLEW_AMD_gpu_association; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) { #ifdef WGL_ARB_buffer_region if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13)) { ret = WGLEW_ARB_buffer_region; continue; } #endif #ifdef WGL_ARB_context_flush_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21)) { ret = WGLEW_ARB_context_flush_control; continue; } #endif #ifdef WGL_ARB_create_context if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) { ret = WGLEW_ARB_create_context; continue; } #endif #ifdef WGL_ARB_create_context_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22)) { ret = WGLEW_ARB_create_context_profile; continue; } #endif #ifdef WGL_ARB_create_context_robustness if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25)) { ret = WGLEW_ARB_create_context_robustness; continue; } #endif #ifdef WGL_ARB_extensions_string if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17)) { ret = WGLEW_ARB_extensions_string; continue; } #endif #ifdef WGL_ARB_framebuffer_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) { ret = WGLEW_ARB_framebuffer_sRGB; continue; } #endif #ifdef WGL_ARB_make_current_read if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) { ret = WGLEW_ARB_make_current_read; continue; } #endif #ifdef WGL_ARB_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = WGLEW_ARB_multisample; continue; } #endif #ifdef WGL_ARB_pbuffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) { ret = WGLEW_ARB_pbuffer; continue; } #endif #ifdef WGL_ARB_pixel_format if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12)) { ret = WGLEW_ARB_pixel_format; continue; } #endif #ifdef WGL_ARB_pixel_format_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) { ret = WGLEW_ARB_pixel_format_float; continue; } #endif #ifdef WGL_ARB_render_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14)) { ret = WGLEW_ARB_render_texture; continue; } #endif #ifdef WGL_ARB_robustness_application_isolation if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32)) { ret = WGLEW_ARB_robustness_application_isolation; continue; } #endif #ifdef WGL_ARB_robustness_share_group_isolation if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32)) { ret = WGLEW_ARB_robustness_share_group_isolation; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) { #ifdef WGL_ATI_pixel_format_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) { ret = WGLEW_ATI_pixel_format_float; continue; } #endif #ifdef WGL_ATI_render_texture_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24)) { ret = WGLEW_ATI_render_texture_rectangle; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) { #ifdef WGL_EXT_create_context_es2_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26)) { ret = WGLEW_EXT_create_context_es2_profile; continue; } #endif #ifdef WGL_EXT_create_context_es_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25)) { ret = WGLEW_EXT_create_context_es_profile; continue; } #endif #ifdef WGL_EXT_depth_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11)) { ret = WGLEW_EXT_depth_float; continue; } #endif #ifdef WGL_EXT_display_color_table if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19)) { ret = WGLEW_EXT_display_color_table; continue; } #endif #ifdef WGL_EXT_extensions_string if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17)) { ret = WGLEW_EXT_extensions_string; continue; } #endif #ifdef WGL_EXT_framebuffer_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) { ret = WGLEW_EXT_framebuffer_sRGB; continue; } #endif #ifdef WGL_EXT_make_current_read if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) { ret = WGLEW_EXT_make_current_read; continue; } #endif #ifdef WGL_EXT_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = WGLEW_EXT_multisample; continue; } #endif #ifdef WGL_EXT_pbuffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) { ret = WGLEW_EXT_pbuffer; continue; } #endif #ifdef WGL_EXT_pixel_format if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12)) { ret = WGLEW_EXT_pixel_format; continue; } #endif #ifdef WGL_EXT_pixel_format_packed_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25)) { ret = WGLEW_EXT_pixel_format_packed_float; continue; } #endif #ifdef WGL_EXT_swap_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) { ret = WGLEW_EXT_swap_control; continue; } #endif #ifdef WGL_EXT_swap_control_tear if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17)) { ret = WGLEW_EXT_swap_control_tear; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4)) { #ifdef WGL_I3D_digital_video_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21)) { ret = WGLEW_I3D_digital_video_control; continue; } #endif #ifdef WGL_I3D_gamma if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5)) { ret = WGLEW_I3D_gamma; continue; } #endif #ifdef WGL_I3D_genlock if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7)) { ret = WGLEW_I3D_genlock; continue; } #endif #ifdef WGL_I3D_image_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12)) { ret = WGLEW_I3D_image_buffer; continue; } #endif #ifdef WGL_I3D_swap_frame_lock if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15)) { ret = WGLEW_I3D_swap_frame_lock; continue; } #endif #ifdef WGL_I3D_swap_frame_usage if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16)) { ret = WGLEW_I3D_swap_frame_usage; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) { #ifdef WGL_NV_DX_interop if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop", 10)) { ret = WGLEW_NV_DX_interop; continue; } #endif #ifdef WGL_NV_DX_interop2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop2", 11)) { ret = WGLEW_NV_DX_interop2; continue; } #endif #ifdef WGL_NV_copy_image if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) { ret = WGLEW_NV_copy_image; continue; } #endif #ifdef WGL_NV_delay_before_swap if (_glewStrSame3(&pos, &len, (const GLubyte*)"delay_before_swap", 17)) { ret = WGLEW_NV_delay_before_swap; continue; } #endif #ifdef WGL_NV_float_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) { ret = WGLEW_NV_float_buffer; continue; } #endif #ifdef WGL_NV_gpu_affinity if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12)) { ret = WGLEW_NV_gpu_affinity; continue; } #endif #ifdef WGL_NV_multisample_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) { ret = WGLEW_NV_multisample_coverage; continue; } #endif #ifdef WGL_NV_present_video if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) { ret = WGLEW_NV_present_video; continue; } #endif #ifdef WGL_NV_render_depth_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20)) { ret = WGLEW_NV_render_depth_texture; continue; } #endif #ifdef WGL_NV_render_texture_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24)) { ret = WGLEW_NV_render_texture_rectangle; continue; } #endif #ifdef WGL_NV_swap_group if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) { ret = WGLEW_NV_swap_group; continue; } #endif #ifdef WGL_NV_vertex_array_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) { ret = WGLEW_NV_vertex_array_range; continue; } #endif #ifdef WGL_NV_video_capture if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13)) { ret = WGLEW_NV_video_capture; continue; } #endif #ifdef WGL_NV_video_output if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12)) { ret = WGLEW_NV_video_output; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) { #ifdef WGL_OML_sync_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12)) { ret = WGLEW_OML_sync_control; continue; } #endif } } ret = (len == 0); } return ret; } #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && !defined(__APPLE__) || defined(GLEW_APPLE_GLX) #if defined(GLEW_MX) GLboolean glxewContextIsSupported (const GLXEWContext* ctx, const char* name) #else GLboolean glxewIsSupported (const char* name) #endif { const GLubyte* pos = (const GLubyte*)name; GLuint len = _glewStrLen(pos); GLboolean ret = GL_TRUE; while (ret && len > 0) { if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4)) { if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) { #ifdef GLX_VERSION_1_2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) { ret = GLXEW_VERSION_1_2; continue; } #endif #ifdef GLX_VERSION_1_3 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) { ret = GLXEW_VERSION_1_3; continue; } #endif #ifdef GLX_VERSION_1_4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) { ret = GLXEW_VERSION_1_4; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) { #ifdef GLX_3DFX_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLXEW_3DFX_multisample; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4)) { #ifdef GLX_AMD_gpu_association if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15)) { ret = GLXEW_AMD_gpu_association; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) { #ifdef GLX_ARB_context_flush_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21)) { ret = GLXEW_ARB_context_flush_control; continue; } #endif #ifdef GLX_ARB_create_context if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) { ret = GLXEW_ARB_create_context; continue; } #endif #ifdef GLX_ARB_create_context_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22)) { ret = GLXEW_ARB_create_context_profile; continue; } #endif #ifdef GLX_ARB_create_context_robustness if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25)) { ret = GLXEW_ARB_create_context_robustness; continue; } #endif #ifdef GLX_ARB_fbconfig_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14)) { ret = GLXEW_ARB_fbconfig_float; continue; } #endif #ifdef GLX_ARB_framebuffer_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) { ret = GLXEW_ARB_framebuffer_sRGB; continue; } #endif #ifdef GLX_ARB_get_proc_address if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16)) { ret = GLXEW_ARB_get_proc_address; continue; } #endif #ifdef GLX_ARB_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLXEW_ARB_multisample; continue; } #endif #ifdef GLX_ARB_robustness_application_isolation if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_application_isolation", 32)) { ret = GLXEW_ARB_robustness_application_isolation; continue; } #endif #ifdef GLX_ARB_robustness_share_group_isolation if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_share_group_isolation", 32)) { ret = GLXEW_ARB_robustness_share_group_isolation; continue; } #endif #ifdef GLX_ARB_vertex_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20)) { ret = GLXEW_ARB_vertex_buffer_object; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) { #ifdef GLX_ATI_pixel_format_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) { ret = GLXEW_ATI_pixel_format_float; continue; } #endif #ifdef GLX_ATI_render_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14)) { ret = GLXEW_ATI_render_texture; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) { #ifdef GLX_EXT_buffer_age if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_age", 10)) { ret = GLXEW_EXT_buffer_age; continue; } #endif #ifdef GLX_EXT_create_context_es2_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26)) { ret = GLXEW_EXT_create_context_es2_profile; continue; } #endif #ifdef GLX_EXT_create_context_es_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es_profile", 25)) { ret = GLXEW_EXT_create_context_es_profile; continue; } #endif #ifdef GLX_EXT_fbconfig_packed_float if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21)) { ret = GLXEW_EXT_fbconfig_packed_float; continue; } #endif #ifdef GLX_EXT_framebuffer_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) { ret = GLXEW_EXT_framebuffer_sRGB; continue; } #endif #ifdef GLX_EXT_import_context if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14)) { ret = GLXEW_EXT_import_context; continue; } #endif #ifdef GLX_EXT_scene_marker if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) { ret = GLXEW_EXT_scene_marker; continue; } #endif #ifdef GLX_EXT_stereo_tree if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_tree", 11)) { ret = GLXEW_EXT_stereo_tree; continue; } #endif #ifdef GLX_EXT_swap_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) { ret = GLXEW_EXT_swap_control; continue; } #endif #ifdef GLX_EXT_swap_control_tear if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control_tear", 17)) { ret = GLXEW_EXT_swap_control_tear; continue; } #endif #ifdef GLX_EXT_texture_from_pixmap if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19)) { ret = GLXEW_EXT_texture_from_pixmap; continue; } #endif #ifdef GLX_EXT_visual_info if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11)) { ret = GLXEW_EXT_visual_info; continue; } #endif #ifdef GLX_EXT_visual_rating if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13)) { ret = GLXEW_EXT_visual_rating; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6)) { #ifdef GLX_INTEL_swap_event if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10)) { ret = GLXEW_INTEL_swap_event; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) { #ifdef GLX_MESA_agp_offset if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10)) { ret = GLXEW_MESA_agp_offset; continue; } #endif #ifdef GLX_MESA_copy_sub_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15)) { ret = GLXEW_MESA_copy_sub_buffer; continue; } #endif #ifdef GLX_MESA_pixmap_colormap if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15)) { ret = GLXEW_MESA_pixmap_colormap; continue; } #endif #ifdef GLX_MESA_query_renderer if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_renderer", 14)) { ret = GLXEW_MESA_query_renderer; continue; } #endif #ifdef GLX_MESA_release_buffers if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15)) { ret = GLXEW_MESA_release_buffers; continue; } #endif #ifdef GLX_MESA_set_3dfx_mode if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13)) { ret = GLXEW_MESA_set_3dfx_mode; continue; } #endif #ifdef GLX_MESA_swap_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) { ret = GLXEW_MESA_swap_control; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) { #ifdef GLX_NV_copy_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11)) { ret = GLXEW_NV_copy_buffer; continue; } #endif #ifdef GLX_NV_copy_image if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) { ret = GLXEW_NV_copy_image; continue; } #endif #ifdef GLX_NV_delay_before_swap if (_glewStrSame3(&pos, &len, (const GLubyte*)"delay_before_swap", 17)) { ret = GLXEW_NV_delay_before_swap; continue; } #endif #ifdef GLX_NV_float_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) { ret = GLXEW_NV_float_buffer; continue; } #endif #ifdef GLX_NV_multisample_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) { ret = GLXEW_NV_multisample_coverage; continue; } #endif #ifdef GLX_NV_present_video if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) { ret = GLXEW_NV_present_video; continue; } #endif #ifdef GLX_NV_swap_group if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) { ret = GLXEW_NV_swap_group; continue; } #endif #ifdef GLX_NV_vertex_array_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) { ret = GLXEW_NV_vertex_array_range; continue; } #endif #ifdef GLX_NV_video_capture if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13)) { ret = GLXEW_NV_video_capture; continue; } #endif #ifdef GLX_NV_video_out if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_out", 9)) { ret = GLXEW_NV_video_out; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) { #ifdef GLX_OML_swap_method if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11)) { ret = GLXEW_OML_swap_method; continue; } #endif #ifdef GLX_OML_sync_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12)) { ret = GLXEW_OML_sync_control; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) { #ifdef GLX_SGIS_blended_overlay if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15)) { ret = GLXEW_SGIS_blended_overlay; continue; } #endif #ifdef GLX_SGIS_color_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) { ret = GLXEW_SGIS_color_range; continue; } #endif #ifdef GLX_SGIS_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { ret = GLXEW_SGIS_multisample; continue; } #endif #ifdef GLX_SGIS_shared_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18)) { ret = GLXEW_SGIS_shared_multisample; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5)) { #ifdef GLX_SGIX_fbconfig if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8)) { ret = GLXEW_SGIX_fbconfig; continue; } #endif #ifdef GLX_SGIX_hyperpipe if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9)) { ret = GLXEW_SGIX_hyperpipe; continue; } #endif #ifdef GLX_SGIX_pbuffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) { ret = GLXEW_SGIX_pbuffer; continue; } #endif #ifdef GLX_SGIX_swap_barrier if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12)) { ret = GLXEW_SGIX_swap_barrier; continue; } #endif #ifdef GLX_SGIX_swap_group if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) { ret = GLXEW_SGIX_swap_group; continue; } #endif #ifdef GLX_SGIX_video_resize if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12)) { ret = GLXEW_SGIX_video_resize; continue; } #endif #ifdef GLX_SGIX_visual_select_group if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19)) { ret = GLXEW_SGIX_visual_select_group; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) { #ifdef GLX_SGI_cushion if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7)) { ret = GLXEW_SGI_cushion; continue; } #endif #ifdef GLX_SGI_make_current_read if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) { ret = GLXEW_SGI_make_current_read; continue; } #endif #ifdef GLX_SGI_swap_control if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) { ret = GLXEW_SGI_swap_control; continue; } #endif #ifdef GLX_SGI_video_sync if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10)) { ret = GLXEW_SGI_video_sync; continue; } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4)) { #ifdef GLX_SUN_get_transparent_index if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21)) { ret = GLXEW_SUN_get_transparent_index; continue; } #endif #ifdef GLX_SUN_video_resize if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12)) { ret = GLXEW_SUN_video_resize; continue; } #endif } } ret = (len == 0); } return ret; } #endif /* _WIN32 */ #endif /* SLIC3R_GUI */ Slic3r-version_1.31.6/xs/src/libslic3r/000077500000000000000000000000001301441720000176055ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/libslic3r/BoundingBox.cpp000066400000000000000000000222751301441720000225370ustar00rootroot00000000000000#include "BoundingBox.hpp" #include namespace Slic3r { template BoundingBoxBase::BoundingBoxBase(const std::vector &points) { if (points.empty()) CONFESS("Empty point set supplied to BoundingBoxBase constructor"); typename std::vector::const_iterator it = points.begin(); this->min.x = this->max.x = it->x; this->min.y = this->max.y = it->y; for (++it; it != points.end(); ++it) { this->min.x = std::min(it->x, this->min.x); this->min.y = std::min(it->y, this->min.y); this->max.x = std::max(it->x, this->max.x); this->max.y = std::max(it->y, this->max.y); } this->defined = true; } template BoundingBoxBase::BoundingBoxBase(const std::vector &points); template BoundingBoxBase::BoundingBoxBase(const std::vector &points); template BoundingBox3Base::BoundingBox3Base(const std::vector &points) : BoundingBoxBase(points) { if (points.empty()) CONFESS("Empty point set supplied to BoundingBox3Base constructor"); typename std::vector::const_iterator it = points.begin(); this->min.z = this->max.z = it->z; for (++it; it != points.end(); ++it) { this->min.z = std::min(it->z, this->min.z); this->max.z = std::max(it->z, this->max.z); } } template BoundingBox3Base::BoundingBox3Base(const std::vector &points); BoundingBox::BoundingBox(const Lines &lines) { Points points; for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { points.push_back(line->a); points.push_back(line->b); } *this = BoundingBox(points); } void BoundingBox::polygon(Polygon* polygon) const { polygon->points.clear(); polygon->points.resize(4); polygon->points[0].x = this->min.x; polygon->points[0].y = this->min.y; polygon->points[1].x = this->max.x; polygon->points[1].y = this->min.y; polygon->points[2].x = this->max.x; polygon->points[2].y = this->max.y; polygon->points[3].x = this->min.x; polygon->points[3].y = this->max.y; } Polygon BoundingBox::polygon() const { Polygon p; this->polygon(&p); return p; } BoundingBox BoundingBox::rotated(double angle) const { BoundingBox out; out.merge(this->min.rotated(angle)); out.merge(this->max.rotated(angle)); out.merge(Point(this->min.x, this->max.y).rotated(angle)); out.merge(Point(this->max.x, this->min.y).rotated(angle)); return out; } BoundingBox BoundingBox::rotated(double angle, const Point ¢er) const { BoundingBox out; out.merge(this->min.rotated(angle, center)); out.merge(this->max.rotated(angle, center)); out.merge(Point(this->min.x, this->max.y).rotated(angle, center)); out.merge(Point(this->max.x, this->min.y).rotated(angle, center)); return out; } template void BoundingBoxBase::scale(double factor) { this->min.scale(factor); this->max.scale(factor); } template void BoundingBoxBase::scale(double factor); template void BoundingBoxBase::scale(double factor); template void BoundingBoxBase::scale(double factor); template void BoundingBoxBase::merge(const PointClass &point) { if (this->defined) { this->min.x = std::min(point.x, this->min.x); this->min.y = std::min(point.y, this->min.y); this->max.x = std::max(point.x, this->max.x); this->max.y = std::max(point.y, this->max.y); } else { this->min = this->max = point; this->defined = true; } } template void BoundingBoxBase::merge(const Point &point); template void BoundingBoxBase::merge(const Pointf &point); template void BoundingBoxBase::merge(const std::vector &points) { this->merge(BoundingBoxBase(points)); } template void BoundingBoxBase::merge(const Points &points); template void BoundingBoxBase::merge(const Pointfs &points); template void BoundingBoxBase::merge(const BoundingBoxBase &bb) { if (this->defined) { this->min.x = std::min(bb.min.x, this->min.x); this->min.y = std::min(bb.min.y, this->min.y); this->max.x = std::max(bb.max.x, this->max.x); this->max.y = std::max(bb.max.y, this->max.y); } else { this->min = bb.min; this->max = bb.max; this->defined = true; } } template void BoundingBoxBase::merge(const BoundingBoxBase &bb); template void BoundingBoxBase::merge(const BoundingBoxBase &bb); template void BoundingBox3Base::merge(const PointClass &point) { if (this->defined) { this->min.z = std::min(point.z, this->min.z); this->max.z = std::max(point.z, this->max.z); } BoundingBoxBase::merge(point); } template void BoundingBox3Base::merge(const Pointf3 &point); template void BoundingBox3Base::merge(const std::vector &points) { this->merge(BoundingBox3Base(points)); } template void BoundingBox3Base::merge(const Pointf3s &points); template void BoundingBox3Base::merge(const BoundingBox3Base &bb) { if (this->defined) { this->min.z = std::min(bb.min.z, this->min.z); this->max.z = std::max(bb.max.z, this->max.z); } BoundingBoxBase::merge(bb); } template void BoundingBox3Base::merge(const BoundingBox3Base &bb); template PointClass BoundingBoxBase::size() const { return PointClass(this->max.x - this->min.x, this->max.y - this->min.y); } template Point BoundingBoxBase::size() const; template Pointf BoundingBoxBase::size() const; template PointClass BoundingBox3Base::size() const { return PointClass(this->max.x - this->min.x, this->max.y - this->min.y, this->max.z - this->min.z); } template Pointf3 BoundingBox3Base::size() const; template double BoundingBoxBase::radius() const { double x = this->max.x - this->min.x; double y = this->max.y - this->min.y; return 0.5 * sqrt(x*x+y*y); } template double BoundingBoxBase::radius() const; template double BoundingBoxBase::radius() const; template double BoundingBox3Base::radius() const { double x = this->max.x - this->min.x; double y = this->max.y - this->min.y; double z = this->max.z - this->min.z; return 0.5 * sqrt(x*x+y*y+z*z); } template double BoundingBox3Base::radius() const; template void BoundingBoxBase::translate(coordf_t x, coordf_t y) { this->min.translate(x, y); this->max.translate(x, y); } template void BoundingBoxBase::translate(coordf_t x, coordf_t y); template void BoundingBoxBase::translate(coordf_t x, coordf_t y); template void BoundingBox3Base::translate(coordf_t x, coordf_t y, coordf_t z) { this->min.translate(x, y, z); this->max.translate(x, y, z); } template void BoundingBox3Base::translate(coordf_t x, coordf_t y, coordf_t z); template void BoundingBoxBase::offset(coordf_t delta) { this->min.translate(-delta, -delta); this->max.translate(delta, delta); } template void BoundingBoxBase::offset(coordf_t delta); template void BoundingBoxBase::offset(coordf_t delta); template void BoundingBox3Base::offset(coordf_t delta) { this->min.translate(-delta, -delta, -delta); this->max.translate(delta, delta, delta); } template void BoundingBox3Base::offset(coordf_t delta); template PointClass BoundingBoxBase::center() const { return PointClass( (this->max.x + this->min.x)/2, (this->max.y + this->min.y)/2 ); } template Point BoundingBoxBase::center() const; template Pointf BoundingBoxBase::center() const; template PointClass BoundingBox3Base::center() const { return PointClass( (this->max.x + this->min.x)/2, (this->max.y + this->min.y)/2, (this->max.z + this->min.z)/2 ); } template Pointf3 BoundingBox3Base::center() const; template bool BoundingBoxBase::contains(const PointClass &point) const { return point.x >= this->min.x && point.x <= this->max.x && point.y >= this->min.y && point.y <= this->max.y; } template bool BoundingBoxBase::contains(const Point &point) const; template bool BoundingBoxBase::contains(const Pointf &point) const; template bool BoundingBoxBase::overlap(const BoundingBoxBase &other) const { return ! (this->max.x < other.min.x || this->min.x > other.max.x || this->max.y < other.min.y || this->min.y > other.max.y); } template bool BoundingBoxBase::overlap(const BoundingBoxBase &point) const; template bool BoundingBoxBase::overlap(const BoundingBoxBase &point) const; } Slic3r-version_1.31.6/xs/src/libslic3r/BoundingBox.hpp000066400000000000000000000075661301441720000225520ustar00rootroot00000000000000#ifndef slic3r_BoundingBox_hpp_ #define slic3r_BoundingBox_hpp_ #include "libslic3r.h" #include "Point.hpp" #include "Polygon.hpp" namespace Slic3r { typedef Point Size; typedef Point3 Size3; typedef Pointf Sizef; typedef Pointf3 Sizef3; template class BoundingBoxBase { public: PointClass min; PointClass max; bool defined; BoundingBoxBase() : defined(false) {}; BoundingBoxBase(const PointClass &pmin, const PointClass &pmax) : min(pmin), max(pmax), defined(pmin.x < pmax.x && pmin.y < pmax.y) {} BoundingBoxBase(const std::vector &points); void merge(const PointClass &point); void merge(const std::vector &points); void merge(const BoundingBoxBase &bb); void scale(double factor); PointClass size() const; double radius() const; void translate(coordf_t x, coordf_t y); void offset(coordf_t delta); PointClass center() const; bool contains(const PointClass &point) const; bool overlap(const BoundingBoxBase &other) const; }; template class BoundingBox3Base : public BoundingBoxBase { public: BoundingBox3Base() : BoundingBoxBase() {}; BoundingBox3Base(const PointClass &pmin, const PointClass &pmax) : BoundingBoxBase(pmin, pmax) { if (pmin.z >= pmax.z) BoundingBoxBase::defined = false; } BoundingBox3Base(const std::vector &points); void merge(const PointClass &point); void merge(const std::vector &points); void merge(const BoundingBox3Base &bb); PointClass size() const; double radius() const; void translate(coordf_t x, coordf_t y, coordf_t z); void offset(coordf_t delta); PointClass center() const; }; class BoundingBox : public BoundingBoxBase { public: void polygon(Polygon* polygon) const; Polygon polygon() const; BoundingBox rotated(double angle) const; BoundingBox rotated(double angle, const Point ¢er) const; void rotate(double angle) { (*this) = this->rotated(angle); } void rotate(double angle, const Point ¢er) { (*this) = this->rotated(angle, center); } BoundingBox() : BoundingBoxBase() {}; BoundingBox(const Point &pmin, const Point &pmax) : BoundingBoxBase(pmin, pmax) {}; BoundingBox(const Points &points) : BoundingBoxBase(points) {}; BoundingBox(const Lines &lines); friend BoundingBox get_extents_rotated(const Points &points, double angle); }; /* class BoundingBox3 : public BoundingBox3Base {}; */ class BoundingBoxf : public BoundingBoxBase { public: BoundingBoxf() : BoundingBoxBase() {}; BoundingBoxf(const Pointf &pmin, const Pointf &pmax) : BoundingBoxBase(pmin, pmax) {}; BoundingBoxf(const std::vector &points) : BoundingBoxBase(points) {}; }; class BoundingBoxf3 : public BoundingBox3Base { public: BoundingBoxf3() : BoundingBox3Base() {}; BoundingBoxf3(const Pointf3 &pmin, const Pointf3 &pmax) : BoundingBox3Base(pmin, pmax) {}; BoundingBoxf3(const std::vector &points) : BoundingBox3Base(points) {}; }; template inline bool operator==(const BoundingBoxBase &bb1, const BoundingBoxBase &bb2) { return bb1.min == bb2.min && bb1.max == bb2.max; } template inline bool operator!=(const BoundingBoxBase &bb1, const BoundingBoxBase &bb2) { return !(bb1 == bb2); } template inline bool empty(const BoundingBoxBase &bb) { return ! bb.defined || bb.min.x >= bb.max.x || bb.min.y >= bb.max.y; } template inline bool empty(const BoundingBox3Base &bb) { return ! bb.defined || bb.min.x >= bb.max.x || bb.min.y >= bb.max.y || bb.min.z >= bb.max.z; } } // namespace Slic3r #endif Slic3r-version_1.31.6/xs/src/libslic3r/BridgeDetector.cpp000066400000000000000000000320121301441720000231750ustar00rootroot00000000000000#include "BridgeDetector.hpp" #include "ClipperUtils.hpp" #include "Geometry.hpp" #include namespace Slic3r { BridgeDetector::BridgeDetector( ExPolygon _expolygon, const ExPolygonCollection &_lower_slices, coord_t _spacing) : // The original infill polygon, not inflated. expolygons(expolygons_owned), // All surfaces of the object supporting this region. lower_slices(_lower_slices), spacing(_spacing) { this->expolygons_owned.push_back(STDMOVE(_expolygon)); initialize(); } BridgeDetector::BridgeDetector( const ExPolygons &_expolygons, const ExPolygonCollection &_lower_slices, coord_t _spacing) : // The original infill polygon, not inflated. expolygons(_expolygons), // All surfaces of the object supporting this region. lower_slices(_lower_slices), spacing(_spacing) { initialize(); } void BridgeDetector::initialize() { // 5 degrees stepping this->resolution = PI/36.0; // output angle not known this->angle = -1.; // Outset our bridge by an arbitrary amout; we'll use this outer margin for detecting anchors. Polygons grown = offset(this->expolygons, float(this->spacing)); // Detect possible anchoring edges of this bridging region. // Detect what edges lie on lower slices by turning bridge contour and holes // into polylines and then clipping them with each lower slice's contour. // Currently _edges are only used to set a candidate direction of the bridge (see bridge_direction_candidates()). intersection(to_polylines(grown), this->lower_slices.contours(), &this->_edges); #ifdef SLIC3R_DEBUG printf(" bridge has " PRINTF_ZU " support(s)\n", this->_edges.size()); #endif // detect anchors as intersection between our bridge expolygon and the lower slices // safety offset required to avoid Clipper from detecting empty intersection while Boost actually found some edges this->_anchor_regions = intersection_ex(grown, to_polygons(this->lower_slices.expolygons), true); /* if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("bridge.svg", expolygons => [ $self->expolygon ], red_expolygons => $self->lower_slices, polylines => $self->_edges, ); } */ } bool BridgeDetector::detect_angle() { if (this->_edges.empty() || this->_anchor_regions.empty()) // The bridging region is completely in the air, there are no anchors available at the layer below. return false; std::vector candidates; { std::vector angles = bridge_direction_candidates(); candidates.reserve(angles.size()); for (size_t i = 0; i < angles.size(); ++ i) candidates.push_back(BridgeDirection(angles[i])); } /* Outset the bridge expolygon by half the amount we used for detecting anchors; we'll use this one to clip our test lines and be sure that their endpoints are inside the anchors and not on their contours leading to false negatives. */ Polygons clip_area = offset(this->expolygons, 0.5f * float(this->spacing)); /* we'll now try several directions using a rudimentary visibility check: bridge in several directions and then sum the length of lines having both endpoints within anchors */ bool have_coverage = false; for (size_t i_angle = 0; i_angle < candidates.size(); ++ i_angle) { const double angle = candidates[i_angle].angle; Lines lines; { // Get an oriented bounding box around _anchor_regions. BoundingBox bbox = get_extents_rotated(this->_anchor_regions, - angle); // Cover the region with line segments. lines.reserve((bbox.max.y - bbox.min.y + this->spacing) / this->spacing); double s = sin(angle); double c = cos(angle); //FIXME Vojtech: The lines shall be spaced half the line width from the edge, but then // some of the test cases fail. Need to adjust the test cases then? // for (coord_t y = bbox.min.y + this->spacing / 2; y <= bbox.max.y; y += this->spacing) for (coord_t y = bbox.min.y; y <= bbox.max.y; y += this->spacing) lines.push_back(Line( Point((coord_t)round(c * bbox.min.x - s * y), (coord_t)round(c * y + s * bbox.min.x)), Point((coord_t)round(c * bbox.max.x - s * y), (coord_t)round(c * y + s * bbox.max.x)))); } double total_length = 0; double max_length = 0; { Lines clipped_lines = intersection(lines, clip_area); for (size_t i = 0; i < clipped_lines.size(); ++i) { const Line &line = clipped_lines[i]; if (expolygons_contain(this->_anchor_regions, line.a) && expolygons_contain(this->_anchor_regions, line.b)) { // This line could be anchored. double len = line.length(); total_length += len; max_length = std::max(max_length, len); } } } if (total_length == 0.) continue; have_coverage = true; // Sum length of bridged lines. candidates[i_angle].coverage = total_length; /* The following produces more correct results in some cases and more broken in others. TODO: investigate, as it looks more reliable than line clipping. */ // $directions_coverage{$angle} = sum(map $_->area, @{$self->coverage($angle)}) // 0; // max length of bridged lines candidates[i_angle].max_length = max_length; } // if no direction produced coverage, then there's no bridge direction if (! have_coverage) return false; // sort directions by coverage - most coverage first std::sort(candidates.begin(), candidates.end()); // if any other direction is within extrusion width of coverage, prefer it if shorter // TODO: There are two options here - within width of the angle with most coverage, or within width of the currently perferred? size_t i_best = 0; for (size_t i = 1; i < candidates.size() && candidates[i_best].coverage - candidates[i].coverage < this->spacing; ++ i) if (candidates[i].max_length < candidates[i_best].max_length) i_best = i; this->angle = candidates[i_best].angle; if (this->angle >= PI) this->angle -= PI; #ifdef SLIC3R_DEBUG printf(" Optimal infill angle is %d degrees\n", (int)Slic3r::Geometry::rad2deg(this->angle)); #endif return true; } std::vector BridgeDetector::bridge_direction_candidates() const { // we test angles according to configured resolution std::vector angles; for (int i = 0; i <= PI/this->resolution; ++i) angles.push_back(i * this->resolution); // we also test angles of each bridge contour { Lines lines = to_lines(this->expolygons); for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) angles.push_back(line->direction()); } /* we also test angles of each open supporting edge (this finds the optimal angle for C-shaped supports) */ for (Polylines::const_iterator edge = this->_edges.begin(); edge != this->_edges.end(); ++edge) if (! edge->first_point().coincides_with(edge->last_point())) angles.push_back(Line(edge->first_point(), edge->last_point()).direction()); // remove duplicates double min_resolution = PI/180.0; // 1 degree std::sort(angles.begin(), angles.end()); for (size_t i = 1; i < angles.size(); ++i) { if (Slic3r::Geometry::directions_parallel(angles[i], angles[i-1], min_resolution)) { angles.erase(angles.begin() + i); --i; } } /* compare first value with last one and remove the greatest one (PI) in case they are parallel (PI, 0) */ if (Slic3r::Geometry::directions_parallel(angles.front(), angles.back(), min_resolution)) angles.pop_back(); return angles; } void BridgeDetector::coverage(double angle, Polygons* coverage) const { if (angle == -1) angle = this->angle; if (angle == -1) return; // Get anchors, convert them to Polygons and rotate them. Polygons anchors = to_polygons(this->_anchor_regions); polygons_rotate(anchors, PI/2.0 - angle); Polygons covered; for (ExPolygons::const_iterator it_expoly = this->expolygons.begin(); it_expoly != this->expolygons.end(); ++ it_expoly) { // Clone our expolygon and rotate it so that we work with vertical lines. ExPolygon expolygon = *it_expoly; expolygon.rotate(PI/2.0 - angle); /* Outset the bridge expolygon by half the amount we used for detecting anchors; we'll use this one to generate our trapezoids and be sure that their vertices are inside the anchors and not on their contours leading to false negatives. */ ExPolygons grown = offset_ex(expolygon, 0.5f * float(this->spacing)); // Compute trapezoids according to a vertical orientation Polygons trapezoids; for (ExPolygons::const_iterator it = grown.begin(); it != grown.end(); ++it) it->get_trapezoids2(&trapezoids, PI/2.0); for (Polygons::iterator trapezoid = trapezoids.begin(); trapezoid != trapezoids.end(); ++trapezoid) { Lines supported = intersection(trapezoid->lines(), anchors); size_t n_supported = 0; // not nice, we need a more robust non-numeric check for (size_t i = 0; i < supported.size(); ++i) if (supported[i].length() >= this->spacing) ++ n_supported; if (n_supported >= 2) covered.push_back(STDMOVE(*trapezoid)); } } // Unite the trapezoids before rotation, as the rotation creates tiny gaps and intersections between the trapezoids // instead of exact overlaps. covered = union_(covered); // Intersect trapezoids with actual bridge area to remove extra margins and append it to result. polygons_rotate(covered, -(PI/2.0 - angle)); intersection(covered, to_polygons(this->expolygons), coverage); /* if (0) { my @lines = map @{$_->lines}, @$trapezoids; $_->rotate(-(PI/2 - $angle), [0,0]) for @lines; require "Slic3r/SVG.pm"; Slic3r::SVG::output( "coverage_" . rad2deg($angle) . ".svg", expolygons => [$self->expolygon], green_expolygons => $self->_anchor_regions, red_expolygons => $coverage, lines => \@lines, ); } */ } Polygons BridgeDetector::coverage(double angle) const { Polygons pp; this->coverage(angle, &pp); return pp; } /* This method returns the bridge edges (as polylines) that are not supported but would allow the entire bridge area to be bridged with detected angle if supported too */ void BridgeDetector::unsupported_edges(double angle, Polylines* unsupported) const { if (angle == -1) angle = this->angle; if (angle == -1) return; Polygons grown_lower = offset(this->lower_slices.expolygons, float(this->spacing)); for (ExPolygons::const_iterator it_expoly = this->expolygons.begin(); it_expoly != this->expolygons.end(); ++ it_expoly) { // get unsupported bridge edges (both contour and holes) Polylines unuspported_polylines; diff(to_polylines(*it_expoly), grown_lower, &unuspported_polylines); Lines unsupported_lines = to_lines(unuspported_polylines); /* Split into individual segments and filter out edges parallel to the bridging angle TODO: angle tolerance should probably be based on segment length and flow width, so that we build supports whenever there's a chance that at least one or two bridge extrusions would be anchored within such length (i.e. a slightly non-parallel bridging direction might still benefit from anchors if long enough) double angle_tolerance = PI / 180.0 * 5.0; */ for (Lines::const_iterator line = unsupported_lines.begin(); line != unsupported_lines.end(); ++line) { if (!Slic3r::Geometry::directions_parallel(line->direction(), angle)) unsupported->push_back(*line); } } /* if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output( "unsupported_" . rad2deg($angle) . ".svg", expolygons => [$self->expolygon], green_expolygons => $self->_anchor_regions, red_expolygons => union_ex($grown_lower), no_arrows => 1, polylines => \@bridge_edges, red_polylines => $unsupported, ); } */ } Polylines BridgeDetector::unsupported_edges(double angle) const { Polylines pp; this->unsupported_edges(angle, &pp); return pp; } } Slic3r-version_1.31.6/xs/src/libslic3r/BridgeDetector.hpp000066400000000000000000000050641301441720000232110ustar00rootroot00000000000000#ifndef slic3r_BridgeDetector_hpp_ #define slic3r_BridgeDetector_hpp_ #include "libslic3r.h" #include "ExPolygon.hpp" #include "ExPolygonCollection.hpp" #include namespace Slic3r { // The bridge detector optimizes a direction of bridges over a region or a set of regions. // A bridge direction is considered optimal, if the length of the lines strang over the region is maximal. // This is optimal if the bridge is supported in a single direction only, but // it may not likely be optimal, if the bridge region is supported from all sides. Then an optimal // solution would find a direction with shortest bridges. // The bridge orientation is measured CCW from the X axis. class BridgeDetector { public: // The non-grown holes. const ExPolygons &expolygons; // In case the caller gaves us the input polygons by a value, make a copy. ExPolygons expolygons_owned; // Lower slices, all regions. const ExPolygonCollection &lower_slices; // Scaled extrusion width of the infill. coord_t spacing; // Angle resolution for the brute force search of the best bridging angle. double resolution; // The final optimal angle. double angle; BridgeDetector(ExPolygon _expolygon, const ExPolygonCollection &_lower_slices, coord_t _extrusion_width); BridgeDetector(const ExPolygons &_expolygons, const ExPolygonCollection &_lower_slices, coord_t _extrusion_width); bool detect_angle(); void coverage(double angle, Polygons* coverage) const; Polygons coverage(double angle = -1) const; void unsupported_edges(double angle, Polylines* unsupported) const; Polylines unsupported_edges(double angle = -1) const; private: void initialize(); struct BridgeDirection { BridgeDirection(double a = -1.) : angle(a), coverage(0.), max_length(0.) {} // the best direction is the one causing most lines to be bridged (thus most coverage) bool operator<(const BridgeDirection &other) const { // Initial sort by coverage only - comparator must obey strict weak ordering return this->coverage > other.coverage; }; double angle; double coverage; double max_length; }; // Get possible briging direction candidates. std::vector bridge_direction_candidates() const; // Open lines representing the supporting edges. Polylines _edges; // Closed polygons representing the supporting areas. ExPolygons _anchor_regions; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/ClipperUtils.cpp000066400000000000000000001106731301441720000227400ustar00rootroot00000000000000#include "ClipperUtils.hpp" #include "Geometry.hpp" // #define CLIPPER_UTILS_DEBUG #ifdef CLIPPER_UTILS_DEBUG #include "SVG.hpp" #endif /* CLIPPER_UTILS_DEBUG */ #include namespace Slic3r { //----------------------------------------------------------- // legacy code from Clipper documentation void AddOuterPolyNodeToExPolygons(ClipperLib::PolyNode& polynode, Slic3r::ExPolygons* expolygons) { size_t cnt = expolygons->size(); expolygons->resize(cnt + 1); ClipperPath_to_Slic3rMultiPoint(polynode.Contour, &(*expolygons)[cnt].contour); (*expolygons)[cnt].holes.resize(polynode.ChildCount()); for (int i = 0; i < polynode.ChildCount(); ++i) { ClipperPath_to_Slic3rMultiPoint(polynode.Childs[i]->Contour, &(*expolygons)[cnt].holes[i]); //Add outer polygons contained by (nested within) holes ... for (int j = 0; j < polynode.Childs[i]->ChildCount(); ++j) AddOuterPolyNodeToExPolygons(*polynode.Childs[i]->Childs[j], expolygons); } } void PolyTreeToExPolygons(ClipperLib::PolyTree& polytree, Slic3r::ExPolygons* expolygons) { PROFILE_FUNC(); expolygons->clear(); for (int i = 0; i < polytree.ChildCount(); ++i) AddOuterPolyNodeToExPolygons(*polytree.Childs[i], expolygons); } //----------------------------------------------------------- template void ClipperPath_to_Slic3rMultiPoint(const ClipperLib::Path &input, T* output) { PROFILE_FUNC(); output->points.clear(); output->points.reserve(input.size()); for (ClipperLib::Path::const_iterator pit = input.begin(); pit != input.end(); ++pit) output->points.push_back(Slic3r::Point( (*pit).X, (*pit).Y )); } template void ClipperPath_to_Slic3rMultiPoint(const ClipperLib::Path &input, Slic3r::Polygon* output); template void ClipperPaths_to_Slic3rMultiPoints(const ClipperLib::Paths &input, T* output) { PROFILE_FUNC(); output->clear(); output->reserve(input.size()); for (ClipperLib::Paths::const_iterator it = input.begin(); it != input.end(); ++it) { typename T::value_type p; ClipperPath_to_Slic3rMultiPoint(*it, &p); output->push_back(p); } } void ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input, Slic3r::ExPolygons* output) { PROFILE_FUNC(); // init Clipper ClipperLib::Clipper clipper; clipper.Clear(); // perform union clipper.AddPaths(input, ClipperLib::ptSubject, true); ClipperLib::PolyTree polytree; clipper.Execute(ClipperLib::ctUnion, polytree, ClipperLib::pftEvenOdd, ClipperLib::pftEvenOdd); // offset results work with both EvenOdd and NonZero // write to ExPolygons object output->clear(); PolyTreeToExPolygons(polytree, output); } void Slic3rMultiPoint_to_ClipperPath(const Slic3r::MultiPoint &input, ClipperLib::Path* output) { PROFILE_FUNC(); output->clear(); output->reserve(input.points.size()); for (Slic3r::Points::const_iterator pit = input.points.begin(); pit != input.points.end(); ++pit) output->push_back(ClipperLib::IntPoint( (*pit).x, (*pit).y )); } void Slic3rMultiPoint_to_ClipperPath_reversed(const Slic3r::MultiPoint &input, ClipperLib::Path* output) { PROFILE_FUNC(); output->clear(); output->reserve(input.points.size()); for (Slic3r::Points::const_reverse_iterator pit = input.points.rbegin(); pit != input.points.rend(); ++pit) output->push_back(ClipperLib::IntPoint( (*pit).x, (*pit).y )); } template void Slic3rMultiPoints_to_ClipperPaths(const T &input, ClipperLib::Paths* output) { PROFILE_FUNC(); output->clear(); output->reserve(input.size()); for (typename T::const_iterator it = input.begin(); it != input.end(); ++it) { // std::vector< IntPoint >, IntPoint is a pair of int64_t ClipperLib::Path p; Slic3rMultiPoint_to_ClipperPath(*it, &p); output->push_back(p); } } void scaleClipperPolygon(ClipperLib::Path &polygon, const double scale) { PROFILE_FUNC(); for (ClipperLib::Path::iterator pit = polygon.begin(); pit != polygon.end(); ++pit) { //FIXME multiplication of int64_t by double! // Replace by bit shifts? (*pit).X *= scale; (*pit).Y *= scale; } } void scaleClipperPolygons(ClipperLib::Paths &polygons, const double scale) { PROFILE_FUNC(); for (ClipperLib::Paths::iterator it = polygons.begin(); it != polygons.end(); ++it) { for (ClipperLib::Path::iterator pit = (*it).begin(); pit != (*it).end(); ++pit) { //FIXME multiplication of int64_t by double! // Replace by bit shifts? (*pit).X *= scale; (*pit).Y *= scale; } } } void offset(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { PROFILE_FUNC(); // read input ClipperLib::Paths input; Slic3rMultiPoints_to_ClipperPaths(polygons, &input); // scale input scaleClipperPolygons(input, scale); // perform offset ClipperLib::ClipperOffset co; if (joinType == jtRound) { co.ArcTolerance = miterLimit; } else { co.MiterLimit = miterLimit; } { PROFILE_BLOCK(offset_AddPaths); co.AddPaths(input, joinType, ClipperLib::etClosedPolygon); } { PROFILE_BLOCK(offset_Execute); co.Execute(*retval, (delta*scale)); } // unscale output scaleClipperPolygons(*retval, 1/scale); } void offset(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(polygons, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons ClipperPaths_to_Slic3rMultiPoints(output, retval); } Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { Slic3r::Polygons pp; offset(polygons, &pp, delta, scale, joinType, miterLimit); return pp; } void offset(const Slic3r::Polylines &polylines, ClipperLib::Paths* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // read input ClipperLib::Paths input; Slic3rMultiPoints_to_ClipperPaths(polylines, &input); // scale input scaleClipperPolygons(input, scale); // perform offset ClipperLib::ClipperOffset co; if (joinType == jtRound) { co.ArcTolerance = miterLimit; } else { co.MiterLimit = miterLimit; } co.AddPaths(input, joinType, ClipperLib::etOpenButt); co.Execute(*retval, (delta*scale)); // unscale output scaleClipperPolygons(*retval, 1/scale); } void offset(const Slic3r::Polylines &polylines, Slic3r::Polygons* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(polylines, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons ClipperPaths_to_Slic3rMultiPoints(output, retval); } void offset(const Slic3r::Surface &surface, Slic3r::Surfaces* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset Slic3r::ExPolygons expp; offset(surface.expolygon, &expp, delta, scale, joinType, miterLimit); // clone the input surface for each expolygon we got retval->clear(); retval->reserve(expp.size()); for (ExPolygons::iterator it = expp.begin(); it != expp.end(); ++it) { Surface s = surface; // clone s.expolygon = *it; retval->push_back(s); } } void offset(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(polygons, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons ClipperPaths_to_Slic3rExPolygons(output, retval); } // This is a safe variant of the polygon offset, tailored for a single ExPolygon: // a single polygon with multiple non-overlapping holes. // Each contour and hole is offsetted separately, then the holes are subtracted from the outer contours. void offset(const Slic3r::ExPolygon &expolygon, ClipperLib::Paths* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // printf("new ExPolygon offset\n"); // 1) Offset the outer contour. const float delta_scaled = float(delta * scale); ClipperLib::Paths contours; { ClipperLib::Path input; Slic3rMultiPoint_to_ClipperPath(expolygon.contour, &input); scaleClipperPolygon(input, scale); ClipperLib::ClipperOffset co; if (joinType == jtRound) co.ArcTolerance = miterLimit; else co.MiterLimit = miterLimit; co.AddPath(input, joinType, ClipperLib::etClosedPolygon); co.Execute(contours, delta_scaled); } // 2) Offset the holes one by one, collect the results. ClipperLib::Paths holes; { holes.reserve(expolygon.holes.size()); for (Polygons::const_iterator it_hole = expolygon.holes.begin(); it_hole != expolygon.holes.end(); ++ it_hole) { ClipperLib::Path input; Slic3rMultiPoint_to_ClipperPath_reversed(*it_hole, &input); scaleClipperPolygon(input, scale); ClipperLib::ClipperOffset co; if (joinType == jtRound) co.ArcTolerance = miterLimit; else co.MiterLimit = miterLimit; co.AddPath(input, joinType, ClipperLib::etClosedPolygon); ClipperLib::Paths out; co.Execute(out, - delta_scaled); holes.insert(holes.end(), out.begin(), out.end()); } } // 3) Subtract holes from the contours. ClipperLib::Paths output; { ClipperLib::Clipper clipper; clipper.Clear(); clipper.AddPaths(contours, ClipperLib::ptSubject, true); clipper.AddPaths(holes, ClipperLib::ptClip, true); clipper.Execute(ClipperLib::ctDifference, *retval, ClipperLib::pftNonZero, ClipperLib::pftNonZero); } // 4) Unscale the output. scaleClipperPolygons(*retval, 1/scale); } Slic3r::Polygons offset(const Slic3r::ExPolygon &expolygon, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(expolygon, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons Slic3r::Polygons retval; ClipperPaths_to_Slic3rMultiPoints(output, &retval); return retval; } Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(expolygon, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons Slic3r::ExPolygons retval; ClipperPaths_to_Slic3rExPolygons(output, &retval); return retval; } // This is a safe variant of the polygon offset, tailored for a single ExPolygon: // a single polygon with multiple non-overlapping holes. // Each contour and hole is offsetted separately, then the holes are subtracted from the outer contours. void offset(const Slic3r::ExPolygons &expolygons, ClipperLib::Paths* retval, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // printf("new ExPolygon offset\n"); const float delta_scaled = float(delta * scale); ClipperLib::Paths contours; ClipperLib::Paths holes; contours.reserve(expolygons.size()); { size_t n_holes = 0; for (size_t i = 0; i < expolygons.size(); ++ i) n_holes += expolygons[i].holes.size(); holes.reserve(n_holes); } for (Slic3r::ExPolygons::const_iterator it_expoly = expolygons.begin(); it_expoly != expolygons.end(); ++ it_expoly) { // 1) Offset the outer contour. { ClipperLib::Path input; Slic3rMultiPoint_to_ClipperPath(it_expoly->contour, &input); scaleClipperPolygon(input, scale); ClipperLib::ClipperOffset co; if (joinType == jtRound) co.ArcTolerance = miterLimit; else co.MiterLimit = miterLimit; co.AddPath(input, joinType, ClipperLib::etClosedPolygon); ClipperLib::Paths out; co.Execute(out, delta_scaled); contours.insert(contours.end(), out.begin(), out.end()); } // 2) Offset the holes one by one, collect the results. { for (Polygons::const_iterator it_hole = it_expoly->holes.begin(); it_hole != it_expoly->holes.end(); ++ it_hole) { ClipperLib::Path input; Slic3rMultiPoint_to_ClipperPath_reversed(*it_hole, &input); scaleClipperPolygon(input, scale); ClipperLib::ClipperOffset co; if (joinType == jtRound) co.ArcTolerance = miterLimit; else co.MiterLimit = miterLimit; co.AddPath(input, joinType, ClipperLib::etClosedPolygon); ClipperLib::Paths out; co.Execute(out, - delta_scaled); holes.insert(holes.end(), out.begin(), out.end()); } } } // 3) Subtract holes from the contours. ClipperLib::Paths output; { ClipperLib::Clipper clipper; clipper.Clear(); clipper.AddPaths(contours, ClipperLib::ptSubject, true); clipper.AddPaths(holes, ClipperLib::ptClip, true); clipper.Execute(ClipperLib::ctDifference, *retval, ClipperLib::pftNonZero, ClipperLib::pftNonZero); } // 4) Unscale the output. scaleClipperPolygons(*retval, 1/scale); } Slic3r::Polygons offset(const Slic3r::ExPolygons &expolygons, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(expolygons, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons Slic3r::Polygons retval; ClipperPaths_to_Slic3rMultiPoints(output, &retval); return retval; } Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygons &expolygons, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { // perform offset ClipperLib::Paths output; offset(expolygons, &output, delta, scale, joinType, miterLimit); // convert into ExPolygons Slic3r::ExPolygons retval; ClipperPaths_to_Slic3rExPolygons(output, &retval); return retval; } Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit) { Slic3r::ExPolygons expp; offset(polygons, &expp, delta, scale, joinType, miterLimit); return expp; } void offset2(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta1, const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit) { if (delta1 * delta2 >= 0) { // Both deltas are the same signum offset(polygons, retval, delta1 + delta2, scale, joinType, miterLimit); return; } #ifdef CLIPPER_UTILS_DEBUG BoundingBox bbox = get_extents(polygons); coordf_t stroke_width = scale_(0.005); static int iRun = 0; ++ iRun; bool flipY = false; SVG svg(debug_out_path("offset2-%d.svg", iRun), bbox, scale_(1.), flipY); for (Slic3r::Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++ it) svg.draw(it->lines(), "gray", stroke_width); #endif /* CLIPPER_UTILS_DEBUG */ // read input ClipperLib::Paths input; Slic3rMultiPoints_to_ClipperPaths(polygons, &input); // scale input scaleClipperPolygons(input, scale); // prepare ClipperOffset object ClipperLib::ClipperOffset co; if (joinType == jtRound) { co.ArcTolerance = miterLimit; } else { co.MiterLimit = miterLimit; } // perform first offset ClipperLib::Paths output1; co.AddPaths(input, joinType, ClipperLib::etClosedPolygon); co.Execute(output1, (delta1*scale)); #ifdef CLIPPER_UTILS_DEBUG svg.draw(output1, 1./CLIPPER_OFFSET_SCALE, "red", stroke_width); #endif /* CLIPPER_UTILS_DEBUG */ // perform second offset co.Clear(); co.AddPaths(output1, joinType, ClipperLib::etClosedPolygon); co.Execute(*retval, (delta2*scale)); #ifdef CLIPPER_UTILS_DEBUG svg.draw(*retval, 1./CLIPPER_OFFSET_SCALE, "green", stroke_width); #endif /* CLIPPER_UTILS_DEBUG */ // unscale output scaleClipperPolygons(*retval, 1/scale); } void offset2(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta1, const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit) { // perform offset ClipperLib::Paths output; offset2(polygons, &output, delta1, delta2, scale, joinType, miterLimit); // convert into ExPolygons ClipperPaths_to_Slic3rMultiPoints(output, retval); } Slic3r::Polygons offset2(const Slic3r::Polygons &polygons, const float delta1, const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit) { Slic3r::Polygons pp; offset2(polygons, &pp, delta1, delta2, scale, joinType, miterLimit); return pp; } void offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta1, const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit) { // perform offset ClipperLib::Paths output; offset2(polygons, &output, delta1, delta2, scale, joinType, miterLimit); // convert into ExPolygons ClipperPaths_to_Slic3rExPolygons(output, retval); } Slic3r::ExPolygons offset2_ex(const Slic3r::Polygons &polygons, const float delta1, const float delta2, const double scale, const ClipperLib::JoinType joinType, const double miterLimit) { Slic3r::ExPolygons expp; offset2(polygons, &expp, delta1, delta2, scale, joinType, miterLimit); return expp; } template void _clipper_do(const ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, T* retval, const ClipperLib::PolyFillType fillType, const bool safety_offset_) { PROFILE_BLOCK(_clipper_do_polygons); // read input ClipperLib::Paths input_subject, input_clip; Slic3rMultiPoints_to_ClipperPaths(subject, &input_subject); Slic3rMultiPoints_to_ClipperPaths(clip, &input_clip); // perform safety offset if (safety_offset_) { if (clipType == ClipperLib::ctUnion) { safety_offset(&input_subject); } else { safety_offset(&input_clip); } } // init Clipper ClipperLib::Clipper clipper; clipper.Clear(); // add polygons { PROFILE_BLOCK(_clipper_do_polygons_AddPaths); clipper.AddPaths(input_subject, ClipperLib::ptSubject, true); clipper.AddPaths(input_clip, ClipperLib::ptClip, true); } // perform operation { PROFILE_BLOCK(_clipper_do_polygons_Execute); clipper.Execute(clipType, *retval, fillType, fillType); } } void _clipper_do(const ClipperLib::ClipType clipType, const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, ClipperLib::PolyTree* retval, const ClipperLib::PolyFillType fillType, const bool safety_offset_) { PROFILE_BLOCK(_clipper_do_polylines); // read input ClipperLib::Paths input_subject, input_clip; Slic3rMultiPoints_to_ClipperPaths(subject, &input_subject); Slic3rMultiPoints_to_ClipperPaths(clip, &input_clip); // perform safety offset if (safety_offset_) safety_offset(&input_clip); // init Clipper ClipperLib::Clipper clipper; clipper.Clear(); // add polygons { PROFILE_BLOCK(_clipper_do_polylines_AddPaths); clipper.AddPaths(input_subject, ClipperLib::ptSubject, false); clipper.AddPaths(input_clip, ClipperLib::ptClip, true); } // perform operation { PROFILE_BLOCK(_clipper_do_polylines_Execute); clipper.Execute(clipType, *retval, fillType, fillType); } } void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polygons* retval, bool safety_offset_) { PROFILE_FUNC(); // perform operation ClipperLib::Paths output; _clipper_do(clipType, subject, clip, &output, ClipperLib::pftNonZero, safety_offset_); // convert into Polygons ClipperPaths_to_Slic3rMultiPoints(output, retval); } void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_) { PROFILE_FUNC(); // perform operation ClipperLib::PolyTree polytree; _clipper_do(clipType, subject, clip, &polytree, ClipperLib::pftNonZero, safety_offset_); // convert into ExPolygons PolyTreeToExPolygons(polytree, retval); } void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_) { PROFILE_FUNC(); // perform operation ClipperLib::PolyTree polytree; _clipper_do(clipType, subject, clip, &polytree, ClipperLib::pftNonZero, safety_offset_); // convert into Polylines ClipperLib::Paths output; ClipperLib::PolyTreeToPaths(polytree, output); ClipperPaths_to_Slic3rMultiPoints(output, retval); } void _clipper(ClipperLib::ClipType clipType, const Slic3r::Lines &subject, const Slic3r::Polygons &clip, Slic3r::Lines* retval, bool safety_offset_) { // convert Lines to Polylines Slic3r::Polylines polylines; polylines.reserve(subject.size()); for (Slic3r::Lines::const_iterator line = subject.begin(); line != subject.end(); ++line) polylines.push_back(*line); // perform operation _clipper(clipType, polylines, clip, &polylines, safety_offset_); // convert Polylines to Lines for (Slic3r::Polylines::const_iterator polyline = polylines.begin(); polyline != polylines.end(); ++polyline) retval->push_back(*polyline); } void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_) { // transform input polygons into polylines Slic3r::Polylines polylines; polylines.reserve(subject.size()); for (Slic3r::Polygons::const_iterator polygon = subject.begin(); polygon != subject.end(); ++polygon) polylines.push_back(*polygon); // implicit call to split_at_first_point() // perform clipping _clipper(clipType, polylines, clip, retval, safety_offset_); /* If the split_at_first_point() call above happens to split the polygon inside the clipping area we would get two consecutive polylines instead of a single one, so we go through them in order to recombine continuous polylines. */ for (size_t i = 0; i < retval->size(); ++i) { for (size_t j = i+1; j < retval->size(); ++j) { if ((*retval)[i].points.back().coincides_with((*retval)[j].points.front())) { /* If last point of i coincides with first point of j, append points of j to i and delete j */ (*retval)[i].points.insert((*retval)[i].points.end(), (*retval)[j].points.begin()+1, (*retval)[j].points.end()); retval->erase(retval->begin() + j); --j; } else if ((*retval)[i].points.front().coincides_with((*retval)[j].points.back())) { /* If first point of i coincides with last point of j, prepend points of j to i and delete j */ (*retval)[i].points.insert((*retval)[i].points.begin(), (*retval)[j].points.begin(), (*retval)[j].points.end()-1); retval->erase(retval->begin() + j); --j; } else if ((*retval)[i].points.front().coincides_with((*retval)[j].points.front())) { /* Since Clipper does not preserve orientation of polylines, also check the case when first point of i coincides with first point of j. */ (*retval)[j].reverse(); (*retval)[i].points.insert((*retval)[i].points.begin(), (*retval)[j].points.begin(), (*retval)[j].points.end()-1); retval->erase(retval->begin() + j); --j; } else if ((*retval)[i].points.back().coincides_with((*retval)[j].points.back())) { /* Since Clipper does not preserve orientation of polylines, also check the case when last point of i coincides with last point of j. */ (*retval)[j].reverse(); (*retval)[i].points.insert((*retval)[i].points.end(), (*retval)[j].points.begin()+1, (*retval)[j].points.end()); retval->erase(retval->begin() + j); --j; } } } } template void diff(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_) { _clipper(ClipperLib::ctDifference, subject, clip, retval, safety_offset_); } template void diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_); template void diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polygons* retval, bool safety_offset_); template void diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_); template void diff(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_); template void diff(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, Slic3r::Lines* retval, bool safety_offset_); template void diff(const SubjectType &subject, const Slic3r::ExPolygons &clip, ResultType* retval, bool safety_offset_) { Slic3r::Polygons pp; for (Slic3r::ExPolygons::const_iterator ex = clip.begin(); ex != clip.end(); ++ex) { Slic3r::Polygons ppp = *ex; pp.insert(pp.end(), ppp.begin(), ppp.end()); } diff(subject, pp, retval, safety_offset_); } template void diff(const Slic3r::Polygons &subject, const Slic3r::ExPolygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_); template void diff(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, ResultType* retval, bool safety_offset_) { Slic3r::Polygons pp; for (Slic3r::ExPolygons::const_iterator ex = subject.begin(); ex != subject.end(); ++ex) { Slic3r::Polygons ppp = *ex; pp.insert(pp.end(), ppp.begin(), ppp.end()); } diff(pp, clip, retval, safety_offset_); } Slic3r::Polygons diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_) { Slic3r::Polygons pp; diff(subject, clip, &pp, safety_offset_); return pp; } template Slic3r::ExPolygons diff_ex(const SubjectType &subject, const ClipType &clip, bool safety_offset_) { Slic3r::ExPolygons expp; diff(subject, clip, &expp, safety_offset_); return expp; } template Slic3r::ExPolygons diff_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_); template Slic3r::ExPolygons diff_ex(const Slic3r::Polygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_); template Slic3r::ExPolygons diff_ex(const Slic3r::ExPolygons &subject, const Slic3r::ExPolygons &clip, bool safety_offset_); template void intersection(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_) { _clipper(ClipperLib::ctIntersection, subject, clip, retval, safety_offset_); } template void intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_); template void intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polygons* retval, bool safety_offset_); template void intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_); template void intersection(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval, bool safety_offset_); template void intersection(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, Slic3r::Lines* retval, bool safety_offset_); template SubjectType intersection(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_) { SubjectType pp; intersection(subject, clip, &pp, safety_offset_); return pp; } template Slic3r::Polygons intersection(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_); template Slic3r::Polylines intersection(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_); template Slic3r::Lines intersection(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_); Slic3r::ExPolygons intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_) { Slic3r::ExPolygons expp; intersection(subject, clip, &expp, safety_offset_); return expp; } template bool intersects(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_) { SubjectType retval; intersection(subject, clip, &retval, safety_offset_); return !retval.empty(); } template bool intersects(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_); template bool intersects(const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, bool safety_offset_); template bool intersects(const Slic3r::Lines &subject, const Slic3r::Polygons &clip, bool safety_offset_); void xor_(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_) { _clipper(ClipperLib::ctXor, subject, clip, retval, safety_offset_); } template void union_(const Slic3r::Polygons &subject, T* retval, bool safety_offset_) { Slic3r::Polygons p; _clipper(ClipperLib::ctUnion, subject, p, retval, safety_offset_); } template void union_(const Slic3r::Polygons &subject, Slic3r::ExPolygons* retval, bool safety_offset_); template void union_(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool safety_offset_); Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool safety_offset) { Polygons pp; union_(subject, &pp, safety_offset); return pp; } Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool safety_offset) { ExPolygons expp; union_(subject, &expp, safety_offset); return expp; } Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject, bool safety_offset) { Polygons pp; for (Slic3r::Surfaces::const_iterator s = subject.begin(); s != subject.end(); ++s) { Polygons spp = *s; pp.insert(pp.end(), spp.begin(), spp.end()); } return union_ex(pp, safety_offset); } void union_(const Slic3r::Polygons &subject1, const Slic3r::Polygons &subject2, Slic3r::Polygons* retval, bool safety_offset) { Polygons pp = subject1; pp.insert(pp.end(), subject2.begin(), subject2.end()); union_(pp, retval, safety_offset); } Slic3r::Polygons union_(const Slic3r::ExPolygons &subject1, const Slic3r::ExPolygons &subject2, bool safety_offset) { Polygons pp; for (Slic3r::ExPolygons::const_iterator it = subject1.begin(); it != subject1.end(); ++it) { Polygons spp = *it; pp.insert(pp.end(), spp.begin(), spp.end()); } for (Slic3r::ExPolygons::const_iterator it = subject2.begin(); it != subject2.end(); ++it) { Polygons spp = *it; pp.insert(pp.end(), spp.begin(), spp.end()); } Polygons retval; union_(pp, &retval, safety_offset); return retval; } void union_pt(const Slic3r::Polygons &subject, ClipperLib::PolyTree* retval, bool safety_offset_) { Slic3r::Polygons clip; _clipper_do(ClipperLib::ctUnion, subject, clip, retval, ClipperLib::pftEvenOdd, safety_offset_); } void union_pt_chained(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool safety_offset_) { ClipperLib::PolyTree pt; union_pt(subject, &pt, safety_offset_); if (&subject == retval) // It is safe to use the same variable for input and output, because this function makes // a temporary copy of the results. retval->clear(); traverse_pt(pt.Childs, retval); } static void traverse_pt(ClipperLib::PolyNodes &nodes, Slic3r::Polygons* retval) { /* use a nearest neighbor search to order these children TODO: supply start_near to chained_path() too? */ // collect ordering points Points ordering_points; ordering_points.reserve(nodes.size()); for (ClipperLib::PolyNodes::const_iterator it = nodes.begin(); it != nodes.end(); ++it) { Point p((*it)->Contour.front().X, (*it)->Contour.front().Y); ordering_points.push_back(p); } // perform the ordering ClipperLib::PolyNodes ordered_nodes; Slic3r::Geometry::chained_path_items(ordering_points, nodes, ordered_nodes); // push results recursively for (ClipperLib::PolyNodes::iterator it = ordered_nodes.begin(); it != ordered_nodes.end(); ++it) { // traverse the next depth traverse_pt((*it)->Childs, retval); Polygon p; ClipperPath_to_Slic3rMultiPoint((*it)->Contour, &p); retval->push_back(p); if ((*it)->IsHole()) retval->back().reverse(); // ccw } } void simplify_polygons(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool preserve_collinear) { PROFILE_FUNC(); // convert into Clipper polygons ClipperLib::Paths input_subject, output; Slic3rMultiPoints_to_ClipperPaths(subject, &input_subject); if (preserve_collinear) { ClipperLib::Clipper c; c.PreserveCollinear(true); c.StrictlySimple(true); c.AddPaths(input_subject, ClipperLib::ptSubject, true); c.Execute(ClipperLib::ctUnion, output, ClipperLib::pftNonZero, ClipperLib::pftNonZero); } else { ClipperLib::SimplifyPolygons(input_subject, output, ClipperLib::pftNonZero); } // convert into Slic3r polygons ClipperPaths_to_Slic3rMultiPoints(output, retval); } void simplify_polygons(const Slic3r::Polygons &subject, Slic3r::ExPolygons* retval, bool preserve_collinear) { PROFILE_FUNC(); if (!preserve_collinear) { Polygons polygons; simplify_polygons(subject, &polygons, preserve_collinear); union_(polygons, retval); return; } // convert into Clipper polygons ClipperLib::Paths input_subject; Slic3rMultiPoints_to_ClipperPaths(subject, &input_subject); ClipperLib::PolyTree polytree; ClipperLib::Clipper c; c.PreserveCollinear(true); c.StrictlySimple(true); c.AddPaths(input_subject, ClipperLib::ptSubject, true); c.Execute(ClipperLib::ctUnion, polytree, ClipperLib::pftNonZero, ClipperLib::pftNonZero); // convert into ExPolygons PolyTreeToExPolygons(polytree, retval); } void safety_offset(ClipperLib::Paths* paths) { PROFILE_FUNC(); // scale input scaleClipperPolygons(*paths, CLIPPER_OFFSET_SCALE); // perform offset (delta = scale 1e-05) ClipperLib::ClipperOffset co; co.MiterLimit = 2; { PROFILE_BLOCK(safety_offset_AddPaths); co.AddPaths(*paths, ClipperLib::jtMiter, ClipperLib::etClosedPolygon); } { PROFILE_BLOCK(safety_offset_Execute); co.Execute(*paths, 10.0 * CLIPPER_OFFSET_SCALE); } // unscale output scaleClipperPolygons(*paths, 1.0/CLIPPER_OFFSET_SCALE); } } Slic3r-version_1.31.6/xs/src/libslic3r/ClipperUtils.hpp000066400000000000000000000223761301441720000227470ustar00rootroot00000000000000#ifndef slic3r_ClipperUtils_hpp_ #define slic3r_ClipperUtils_hpp_ #include #include "clipper.hpp" #include "ExPolygon.hpp" #include "Polygon.hpp" #include "Surface.hpp" // import these wherever we're included using ClipperLib::jtMiter; using ClipperLib::jtRound; using ClipperLib::jtSquare; namespace Slic3r { // Factor to convert from coord_t (which is int32) to an int64 type used by the Clipper library. //FIXME Vojtech: Better to use a power of 2 coefficient and to use bit shifts for scaling. // How about 2^17=131072? // By the way, is the scalling needed at all? Cura runs all the computation with a fixed point precision of 1um, while Slic3r scales to 1nm, // further scaling by 10e5 brings us to #define CLIPPER_OFFSET_SCALE 100000.0 //----------------------------------------------------------- // legacy code from Clipper documentation void AddOuterPolyNodeToExPolygons(ClipperLib::PolyNode& polynode, Slic3r::ExPolygons& expolygons); void PolyTreeToExPolygons(ClipperLib::PolyTree& polytree, Slic3r::ExPolygons& expolygons); //----------------------------------------------------------- void Slic3rMultiPoint_to_ClipperPath(const Slic3r::MultiPoint &input, ClipperLib::Path* output); template void Slic3rMultiPoints_to_ClipperPaths(const T &input, ClipperLib::Paths* output); template void ClipperPath_to_Slic3rMultiPoint(const ClipperLib::Path &input, T* output); template void ClipperPaths_to_Slic3rMultiPoints(const ClipperLib::Paths &input, T* output); void ClipperPaths_to_Slic3rExPolygons(const ClipperLib::Paths &input, Slic3r::ExPolygons* output); void scaleClipperPolygons(ClipperLib::Paths &polygons, const double scale); // offset Polygons void offset(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); void offset(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::Polygons offset(const Slic3r::Polygons &polygons, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); // This is a safe variant of the polygon offset, tailored for a single ExPolygon: // a single polygon with multiple non-overlapping holes. // Each contour and hole is offsetted separately, then the holes are subtracted from the outer contours. void offset(const Slic3r::ExPolygon &expolygon, ClipperLib::Paths* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); void offset(const Slic3r::ExPolygons &expolygons, ClipperLib::Paths* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::Polygons offset(const Slic3r::ExPolygon &expolygon, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::Polygons offset(const Slic3r::ExPolygons &expolygons, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygon &expolygon, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit); Slic3r::ExPolygons offset_ex(const Slic3r::ExPolygons &expolygons, const float delta, double scale, ClipperLib::JoinType joinType, double miterLimit); // offset Polylines void offset(const Slic3r::Polylines &polylines, ClipperLib::Paths* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3); void offset(const Slic3r::Polylines &polylines, Slic3r::Polygons* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3); void offset(const Slic3r::Surface &surface, Slic3r::Surfaces* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtSquare, double miterLimit = 3); void offset(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::ExPolygons offset_ex(const Slic3r::Polygons &polygons, const float delta, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); void offset2(const Slic3r::Polygons &polygons, ClipperLib::Paths* retval, const float delta1, const float delta2, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); void offset2(const Slic3r::Polygons &polygons, Slic3r::Polygons* retval, const float delta1, const float delta2, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::Polygons offset2(const Slic3r::Polygons &polygons, const float delta1, const float delta2, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); void offset2(const Slic3r::Polygons &polygons, Slic3r::ExPolygons* retval, const float delta1, const float delta2, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); Slic3r::ExPolygons offset2_ex(const Slic3r::Polygons &polygons, const float delta1, const float delta2, double scale = CLIPPER_OFFSET_SCALE, ClipperLib::JoinType joinType = ClipperLib::jtMiter, double miterLimit = 3); template void _clipper_do(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, T* retval, bool safety_offset_); void _clipper_do(ClipperLib::ClipType clipType, const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, ClipperLib::Paths* retval, bool safety_offset_); void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::Polygons* retval, bool safety_offset_); void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_); void _clipper(ClipperLib::ClipType clipType, const Slic3r::Polylines &subject, const Slic3r::Polygons &clip, Slic3r::Polylines* retval); void _clipper(ClipperLib::ClipType clipType, const Slic3r::Lines &subject, const Slic3r::Polygons &clip, Slic3r::Lines* retval); template void diff(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_ = false); template void diff(const SubjectType &subject, const Slic3r::ExPolygons &clip, ResultType* retval, bool safety_offset_ = false); Slic3r::Polygons diff(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false); template Slic3r::ExPolygons diff_ex(const SubjectType &subject, const ClipType &clip, bool safety_offset_ = false); template void intersection(const SubjectType &subject, const Slic3r::Polygons &clip, ResultType* retval, bool safety_offset_ = false); template SubjectType intersection(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false); Slic3r::ExPolygons intersection_ex(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false); template bool intersects(const SubjectType &subject, const Slic3r::Polygons &clip, bool safety_offset_ = false); void xor_(const Slic3r::Polygons &subject, const Slic3r::Polygons &clip, Slic3r::ExPolygons* retval, bool safety_offset_ = false); template void union_(const Slic3r::Polygons &subject, T* retval, bool safety_offset_ = false); Slic3r::Polygons union_(const Slic3r::Polygons &subject, bool safety_offset = false); Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, bool safety_offset = false); Slic3r::ExPolygons union_ex(const Slic3r::Surfaces &subject, bool safety_offset = false); void union_(const Slic3r::Polygons &subject1, const Slic3r::Polygons &subject2, Slic3r::Polygons* retval, bool safety_offset = false); Slic3r::Polygons union_(const Slic3r::ExPolygons &subject1, const Slic3r::ExPolygons &subject2, bool safety_offset = false); void union_pt(const Slic3r::Polygons &subject, ClipperLib::PolyTree* retval, bool safety_offset_ = false); void union_pt_chained(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool safety_offset_ = false); static void traverse_pt(ClipperLib::PolyNodes &nodes, Slic3r::Polygons* retval); void simplify_polygons(const Slic3r::Polygons &subject, Slic3r::Polygons* retval, bool preserve_collinear = false); void simplify_polygons(const Slic3r::Polygons &subject, Slic3r::ExPolygons* retval, bool preserve_collinear = false); void safety_offset(ClipperLib::Paths* paths); } #endif Slic3r-version_1.31.6/xs/src/libslic3r/Config.cpp000066400000000000000000000352311301441720000215220ustar00rootroot00000000000000#include "Config.hpp" #include // for setenv() #include #include #if defined(_WIN32) && !defined(setenv) && defined(_putenv_s) #define setenv(k, v, o) _putenv_s(k, v) #endif namespace Slic3r { std::string escape_string_cstyle(const std::string &str) { // Allocate a buffer twice the input string length, // so the output will fit even if all input characters get escaped. std::vector out(str.size() * 2, 0); char *outptr = out.data(); for (size_t i = 0; i < str.size(); ++ i) { char c = str[i]; if (c == '\n' || c == '\r') { (*outptr ++) = '\\'; (*outptr ++) = 'n'; } else (*outptr ++) = c; } return std::string(out.data(), outptr - out.data()); } std::string escape_strings_cstyle(const std::vector &strs) { // 1) Estimate the output buffer size to avoid buffer reallocation. size_t outbuflen = 0; for (size_t i = 0; i < strs.size(); ++ i) // Reserve space for every character escaped + quotes + semicolon. outbuflen += strs[i].size() * 2 + 3; // 2) Fill in the buffer. std::vector out(outbuflen, 0); char *outptr = out.data(); for (size_t j = 0; j < strs.size(); ++ j) { if (j > 0) // Separate the strings. (*outptr ++) = ';'; const std::string &str = strs[j]; // Is the string simple or complex? Complex string contains spaces, tabs, new lines and other // escapable characters. Empty string shall be quoted as well, if it is the only string in strs. bool should_quote = strs.size() == 1 && str.empty(); for (size_t i = 0; i < str.size(); ++ i) { char c = str[i]; if (c == ' ' || c == '\t' || c == '\\' || c == '"' || c == '\r' || c == '\n') { should_quote = true; break; } } if (should_quote) { (*outptr ++) = '"'; for (size_t i = 0; i < str.size(); ++ i) { char c = str[i]; if (c == '\\' || c == '"') { (*outptr ++) = '\\'; (*outptr ++) = c; } else if (c == '\n' || c == '\r') { (*outptr ++) = '\\'; (*outptr ++) = 'n'; } else (*outptr ++) = c; } (*outptr ++) = '"'; } else { memcpy(outptr, str.data(), str.size()); outptr += str.size(); } } return std::string(out.data(), outptr - out.data()); } bool unescape_string_cstyle(const std::string &str, std::string &str_out) { std::vector out(str.size(), 0); char *outptr = out.data(); for (size_t i = 0; i < str.size(); ++ i) { char c = str[i]; if (c == '\\') { if (++ i == str.size()) return false; c = str[i]; if (c == 'n') (*outptr ++) = '\n'; } else (*outptr ++) = c; } str_out.assign(out.data(), outptr - out.data()); return true; } bool unescape_strings_cstyle(const std::string &str, std::vector &out) { out.clear(); if (str.empty()) return true; size_t i = 0; for (;;) { // Skip white spaces. char c = str[i]; while (c == ' ' || c == '\t') { if (++ i == str.size()) return true; c = str[i]; } // Start of a word. std::vector buf; buf.reserve(16); // Is it enclosed in quotes? c = str[i]; if (c == '"') { // Complex case, string is enclosed in quotes. for (++ i; i < str.size(); ++ i) { c = str[i]; if (c == '"') { // End of string. break; } if (c == '\\') { if (++ i == str.size()) return false; c = str[i]; if (c == 'n') c = '\n'; } buf.push_back(c); } if (i == str.size()) return false; ++ i; } else { for (; i < str.size(); ++ i) { c = str[i]; if (c == ';') break; buf.push_back(c); } } // Store the string into the output vector. out.push_back(std::string(buf.data(), buf.size())); if (i == str.size()) return true; // Skip white spaces. c = str[i]; while (c == ' ' || c == '\t') { if (++ i == str.size()) // End of string. This is correct. return true; c = str[i]; } if (c != ';') return false; if (++ i == str.size()) { // Emit one additional empty string. out.push_back(std::string()); return true; } } } bool operator== (const ConfigOption &a, const ConfigOption &b) { return a.serialize().compare(b.serialize()) == 0; } bool operator!= (const ConfigOption &a, const ConfigOption &b) { return !(a == b); } ConfigDef::~ConfigDef() { for (t_optiondef_map::iterator it = this->options.begin(); it != this->options.end(); ++it) { if (it->second.default_value != NULL) delete it->second.default_value; } } ConfigOptionDef* ConfigDef::add(const t_config_option_key &opt_key, ConfigOptionType type) { ConfigOptionDef* opt = &this->options[opt_key]; opt->type = type; return opt; } const ConfigOptionDef* ConfigDef::get(const t_config_option_key &opt_key) const { t_optiondef_map::iterator it = const_cast(this)->options.find(opt_key); return (it == this->options.end()) ? NULL : &it->second; } bool ConfigBase::has(const t_config_option_key &opt_key) { return (this->option(opt_key, false) != NULL); } void ConfigBase::apply(const ConfigBase &other, bool ignore_nonexistent) { // get list of option keys to apply t_config_option_keys opt_keys = other.keys(); // loop through options and apply them for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) { ConfigOption* my_opt = this->option(*it, true); if (my_opt == NULL) { if (ignore_nonexistent == false) throw "Attempt to apply non-existent option"; continue; } // not the most efficient way, but easier than casting pointers to subclasses bool res = my_opt->deserialize( other.option(*it)->serialize() ); if (!res) { std::string error = "Unexpected failure when deserializing serialized value for " + *it; CONFESS(error.c_str()); } } } bool ConfigBase::equals(ConfigBase &other) { return this->diff(other).empty(); } // this will *ignore* options not present in both configs t_config_option_keys ConfigBase::diff(ConfigBase &other) { t_config_option_keys diff; t_config_option_keys my_keys = this->keys(); for (t_config_option_keys::const_iterator opt_key = my_keys.begin(); opt_key != my_keys.end(); ++opt_key) { if (other.has(*opt_key) && other.serialize(*opt_key) != this->serialize(*opt_key)) { diff.push_back(*opt_key); } } return diff; } std::string ConfigBase::serialize(const t_config_option_key &opt_key) const { const ConfigOption* opt = this->option(opt_key); assert(opt != NULL); return opt->serialize(); } bool ConfigBase::set_deserialize(const t_config_option_key &opt_key, std::string str) { const ConfigOptionDef* optdef = this->def->get(opt_key); if (optdef == NULL) throw "Calling set_deserialize() on unknown option"; if (!optdef->shortcut.empty()) { for (std::vector::const_iterator it = optdef->shortcut.begin(); it != optdef->shortcut.end(); ++it) { if (!this->set_deserialize(*it, str)) return false; } return true; } ConfigOption* opt = this->option(opt_key, true); assert(opt != NULL); return opt->deserialize(str); } // Return an absolute value of a possibly relative config variable. // For example, return absolute infill extrusion width, either from an absolute value, or relative to the layer height. double ConfigBase::get_abs_value(const t_config_option_key &opt_key) const { const ConfigOption* opt = this->option(opt_key); if (const ConfigOptionFloatOrPercent* optv = dynamic_cast(opt)) { // get option definition const ConfigOptionDef* def = this->def->get(opt_key); assert(def != NULL); // compute absolute value over the absolute value of the base option return optv->get_abs_value(this->get_abs_value(def->ratio_over)); } else if (const ConfigOptionFloat* optv = dynamic_cast(opt)) { return optv->value; } else { throw "Not a valid option type for get_abs_value()"; } } // Return an absolute value of a possibly relative config variable. // For example, return absolute infill extrusion width, either from an absolute value, or relative to a provided value. double ConfigBase::get_abs_value(const t_config_option_key &opt_key, double ratio_over) const { // get stored option value const ConfigOptionFloatOrPercent* opt = dynamic_cast(this->option(opt_key)); assert(opt != NULL); // compute absolute value return opt->get_abs_value(ratio_over); } void ConfigBase::setenv_() { #ifdef setenv t_config_option_keys opt_keys = this->keys(); for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) { // prepend the SLIC3R_ prefix std::ostringstream ss; ss << "SLIC3R_"; ss << *it; std::string envname = ss.str(); // capitalize environment variable name for (size_t i = 0; i < envname.size(); ++i) envname[i] = (envname[i] <= 'z' && envname[i] >= 'a') ? envname[i]-('a'-'A') : envname[i]; setenv(envname.c_str(), this->serialize(*it).c_str(), 1); } #endif } const ConfigOption* ConfigBase::option(const t_config_option_key &opt_key) const { return const_cast(this)->option(opt_key, false); } ConfigOption* ConfigBase::option(const t_config_option_key &opt_key, bool create) { return this->optptr(opt_key, create); } DynamicConfig& DynamicConfig::operator= (DynamicConfig other) { this->swap(other); return *this; } void DynamicConfig::swap(DynamicConfig &other) { std::swap(this->def, other.def); std::swap(this->options, other.options); } DynamicConfig::~DynamicConfig () { for (t_options_map::iterator it = this->options.begin(); it != this->options.end(); ++it) { ConfigOption* opt = it->second; if (opt != NULL) delete opt; } } DynamicConfig::DynamicConfig (const DynamicConfig& other) { this->def = other.def; this->apply(other, false); } ConfigOption* DynamicConfig::optptr(const t_config_option_key &opt_key, bool create) { t_options_map::iterator it = options.find(opt_key); if (it == options.end()) { if (create) { const ConfigOptionDef* optdef = this->def->get(opt_key); assert(optdef != NULL); ConfigOption* opt; if (optdef->type == coFloat) { opt = new ConfigOptionFloat (); } else if (optdef->type == coFloats) { opt = new ConfigOptionFloats (); } else if (optdef->type == coInt) { opt = new ConfigOptionInt (); } else if (optdef->type == coInts) { opt = new ConfigOptionInts (); } else if (optdef->type == coString) { opt = new ConfigOptionString (); } else if (optdef->type == coStrings) { opt = new ConfigOptionStrings (); } else if (optdef->type == coPercent) { opt = new ConfigOptionPercent (); } else if (optdef->type == coFloatOrPercent) { opt = new ConfigOptionFloatOrPercent (); } else if (optdef->type == coPoint) { opt = new ConfigOptionPoint (); } else if (optdef->type == coPoints) { opt = new ConfigOptionPoints (); } else if (optdef->type == coBool) { opt = new ConfigOptionBool (); } else if (optdef->type == coBools) { opt = new ConfigOptionBools (); } else if (optdef->type == coEnum) { ConfigOptionEnumGeneric* optv = new ConfigOptionEnumGeneric (); optv->keys_map = &optdef->enum_keys_map; opt = static_cast(optv); } else { throw "Unknown option type"; } this->options[opt_key] = opt; return opt; } else { return NULL; } } return it->second; } template T* DynamicConfig::opt(const t_config_option_key &opt_key, bool create) { return dynamic_cast(this->option(opt_key, create)); } template ConfigOptionInt* DynamicConfig::opt(const t_config_option_key &opt_key, bool create); template ConfigOptionBool* DynamicConfig::opt(const t_config_option_key &opt_key, bool create); template ConfigOptionBools* DynamicConfig::opt(const t_config_option_key &opt_key, bool create); template ConfigOptionPercent* DynamicConfig::opt(const t_config_option_key &opt_key, bool create); t_config_option_keys DynamicConfig::keys() const { t_config_option_keys keys; for (t_options_map::const_iterator it = this->options.begin(); it != this->options.end(); ++it) keys.push_back(it->first); return keys; } void DynamicConfig::erase(const t_config_option_key &opt_key) { this->options.erase(opt_key); } void StaticConfig::set_defaults() { // use defaults from definition if (this->def == NULL) return; t_config_option_keys keys = this->keys(); for (t_config_option_keys::const_iterator it = keys.begin(); it != keys.end(); ++it) { const ConfigOptionDef* def = this->def->get(*it); if (def->default_value != NULL) this->option(*it)->set(*def->default_value); } } t_config_option_keys StaticConfig::keys() const { t_config_option_keys keys; assert(this->def != NULL); for (t_optiondef_map::const_iterator it = this->def->options.begin(); it != this->def->options.end(); ++it) { const ConfigOption* opt = this->option(it->first); if (opt != NULL) keys.push_back(it->first); } return keys; } } Slic3r-version_1.31.6/xs/src/libslic3r/Config.hpp000066400000000000000000000542461301441720000215360ustar00rootroot00000000000000#ifndef slic3r_Config_hpp_ #define slic3r_Config_hpp_ #include #include #include #include #include #include #include #include #include "libslic3r.h" #include "Point.hpp" namespace Slic3r { // Name of the configuration option. typedef std::string t_config_option_key; typedef std::vector t_config_option_keys; extern std::string escape_string_cstyle(const std::string &str); extern std::string escape_strings_cstyle(const std::vector &strs); extern bool unescape_string_cstyle(const std::string &str, std::string &out); extern bool unescape_strings_cstyle(const std::string &str, std::vector &out); // A generic value of a configuration option. class ConfigOption { public: virtual ~ConfigOption() {}; virtual std::string serialize() const = 0; virtual bool deserialize(std::string str) = 0; virtual void set(const ConfigOption &option) = 0; virtual int getInt() const { return 0; }; virtual double getFloat() const { return 0; }; virtual bool getBool() const { return false; }; virtual void setInt(int val) {}; friend bool operator== (const ConfigOption &a, const ConfigOption &b); friend bool operator!= (const ConfigOption &a, const ConfigOption &b); }; // Value of a single valued option (bool, int, float, string, point, enum) template class ConfigOptionSingle : public ConfigOption { public: T value; ConfigOptionSingle(T _value) : value(_value) {}; operator T() const { return this->value; }; void set(const ConfigOption &option) { const ConfigOptionSingle* other = dynamic_cast< const ConfigOptionSingle* >(&option); if (other != NULL) this->value = other->value; }; }; // Value of a vector valued option (bools, ints, floats, strings, points) class ConfigOptionVectorBase : public ConfigOption { public: virtual ~ConfigOptionVectorBase() {}; virtual std::vector vserialize() const = 0; }; // Value of a vector valued option (bools, ints, floats, strings, points), template template class ConfigOptionVector : public ConfigOptionVectorBase { public: virtual ~ConfigOptionVector() {}; std::vector values; void set(const ConfigOption &option) { const ConfigOptionVector* other = dynamic_cast< const ConfigOptionVector* >(&option); if (other != NULL) this->values = other->values; }; T get_at(size_t i) const { try { return this->values.at(i); } catch (const std::out_of_range& oor) { return this->values.front(); } }; }; class ConfigOptionFloat : public ConfigOptionSingle { public: ConfigOptionFloat() : ConfigOptionSingle(0) {}; ConfigOptionFloat(double _value) : ConfigOptionSingle(_value) {}; double getFloat() const { return this->value; }; std::string serialize() const { std::ostringstream ss; ss << this->value; return ss.str(); }; bool deserialize(std::string str) { std::istringstream iss(str); iss >> this->value; return !iss.fail(); }; }; class ConfigOptionFloats : public ConfigOptionVector { public: std::string serialize() const { std::ostringstream ss; for (std::vector::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { if (it - this->values.begin() != 0) ss << ","; ss << *it; } return ss.str(); }; std::vector vserialize() const { std::vector vv; vv.reserve(this->values.size()); for (std::vector::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { std::ostringstream ss; ss << *it; vv.push_back(ss.str()); } return vv; }; bool deserialize(std::string str) { this->values.clear(); std::istringstream is(str); std::string item_str; while (std::getline(is, item_str, ',')) { std::istringstream iss(item_str); double value; iss >> value; this->values.push_back(value); } return true; }; }; class ConfigOptionInt : public ConfigOptionSingle { public: ConfigOptionInt() : ConfigOptionSingle(0) {}; ConfigOptionInt(double _value) : ConfigOptionSingle(_value) {}; int getInt() const { return this->value; }; void setInt(int val) { this->value = val; }; std::string serialize() const { std::ostringstream ss; ss << this->value; return ss.str(); }; bool deserialize(std::string str) { std::istringstream iss(str); iss >> this->value; return !iss.fail(); }; }; class ConfigOptionInts : public ConfigOptionVector { public: std::string serialize() const { std::ostringstream ss; for (std::vector::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { if (it - this->values.begin() != 0) ss << ","; ss << *it; } return ss.str(); }; std::vector vserialize() const { std::vector vv; vv.reserve(this->values.size()); for (std::vector::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { std::ostringstream ss; ss << *it; vv.push_back(ss.str()); } return vv; }; bool deserialize(std::string str) { this->values.clear(); std::istringstream is(str); std::string item_str; while (std::getline(is, item_str, ',')) { std::istringstream iss(item_str); int value; iss >> value; this->values.push_back(value); } return true; }; }; class ConfigOptionString : public ConfigOptionSingle { public: ConfigOptionString() : ConfigOptionSingle("") {}; ConfigOptionString(std::string _value) : ConfigOptionSingle(_value) {}; std::string serialize() const { return escape_string_cstyle(this->value); } bool deserialize(std::string str) { return unescape_string_cstyle(str, this->value); }; }; // semicolon-separated strings class ConfigOptionStrings : public ConfigOptionVector { public: std::string serialize() const { return escape_strings_cstyle(this->values); }; std::vector vserialize() const { return this->values; }; bool deserialize(std::string str) { return unescape_strings_cstyle(str, this->values); }; }; class ConfigOptionPercent : public ConfigOptionFloat { public: ConfigOptionPercent() : ConfigOptionFloat(0) {}; ConfigOptionPercent(double _value) : ConfigOptionFloat(_value) {}; double get_abs_value(double ratio_over) const { return ratio_over * this->value / 100; }; std::string serialize() const { std::ostringstream ss; ss << this->value; std::string s(ss.str()); s += "%"; return s; }; bool deserialize(std::string str) { // don't try to parse the trailing % since it's optional std::istringstream iss(str); iss >> this->value; return !iss.fail(); }; }; class ConfigOptionFloatOrPercent : public ConfigOptionPercent { public: bool percent; ConfigOptionFloatOrPercent() : ConfigOptionPercent(0), percent(false) {}; ConfigOptionFloatOrPercent(double _value, bool _percent) : ConfigOptionPercent(_value), percent(_percent) {}; void set(const ConfigOption &option) { const ConfigOptionFloatOrPercent* other = dynamic_cast< const ConfigOptionFloatOrPercent* >(&option); if (other != NULL) { this->value = other->value; this->percent = other->percent; } }; double get_abs_value(double ratio_over) const { if (this->percent) { return ratio_over * this->value / 100; } else { return this->value; } }; std::string serialize() const { std::ostringstream ss; ss << this->value; std::string s(ss.str()); if (this->percent) s += "%"; return s; }; bool deserialize(std::string str) { this->percent = str.find_first_of("%") != std::string::npos; std::istringstream iss(str); iss >> this->value; return !iss.fail(); }; }; class ConfigOptionPoint : public ConfigOptionSingle { public: ConfigOptionPoint() : ConfigOptionSingle(Pointf(0,0)) {}; ConfigOptionPoint(Pointf _value) : ConfigOptionSingle(_value) {}; std::string serialize() const { std::ostringstream ss; ss << this->value.x; ss << ","; ss << this->value.y; return ss.str(); }; bool deserialize(std::string str) { std::istringstream iss(str); iss >> this->value.x; iss.ignore(std::numeric_limits::max(), ','); iss.ignore(std::numeric_limits::max(), 'x'); iss >> this->value.y; return true; }; }; class ConfigOptionPoints : public ConfigOptionVector { public: std::string serialize() const { std::ostringstream ss; for (Pointfs::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { if (it - this->values.begin() != 0) ss << ","; ss << it->x; ss << "x"; ss << it->y; } return ss.str(); }; std::vector vserialize() const { std::vector vv; for (Pointfs::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { std::ostringstream ss; ss << *it; vv.push_back(ss.str()); } return vv; }; bool deserialize(std::string str) { this->values.clear(); std::istringstream is(str); std::string point_str; while (std::getline(is, point_str, ',')) { Pointf point; std::istringstream iss(point_str); std::string coord_str; if (std::getline(iss, coord_str, 'x')) { std::istringstream(coord_str) >> point.x; if (std::getline(iss, coord_str, 'x')) { std::istringstream(coord_str) >> point.y; } } this->values.push_back(point); } return true; }; }; class ConfigOptionBool : public ConfigOptionSingle { public: ConfigOptionBool() : ConfigOptionSingle(false) {}; ConfigOptionBool(bool _value) : ConfigOptionSingle(_value) {}; bool getBool() const { return this->value; }; std::string serialize() const { return std::string(this->value ? "1" : "0"); }; bool deserialize(std::string str) { this->value = (str.compare("1") == 0); return true; }; }; class ConfigOptionBools : public ConfigOptionVector { public: std::string serialize() const { std::ostringstream ss; for (std::vector::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { if (it - this->values.begin() != 0) ss << ","; ss << (*it ? "1" : "0"); } return ss.str(); }; std::vector vserialize() const { std::vector vv; for (std::vector::const_iterator it = this->values.begin(); it != this->values.end(); ++it) { std::ostringstream ss; ss << (*it ? "1" : "0"); vv.push_back(ss.str()); } return vv; }; bool deserialize(std::string str) { this->values.clear(); std::istringstream is(str); std::string item_str; while (std::getline(is, item_str, ',')) { this->values.push_back(item_str.compare("1") == 0); } return true; }; }; // Map from an enum name to an enum integer value. typedef std::map t_config_enum_values; template class ConfigOptionEnum : public ConfigOptionSingle { public: // by default, use the first value (0) of the T enum type ConfigOptionEnum() : ConfigOptionSingle(static_cast(0)) {}; ConfigOptionEnum(T _value) : ConfigOptionSingle(_value) {}; std::string serialize() const { t_config_enum_values enum_keys_map = ConfigOptionEnum::get_enum_values(); for (t_config_enum_values::iterator it = enum_keys_map.begin(); it != enum_keys_map.end(); ++it) { if (it->second == static_cast(this->value)) return it->first; } return ""; }; bool deserialize(std::string str) { t_config_enum_values enum_keys_map = ConfigOptionEnum::get_enum_values(); if (enum_keys_map.count(str) == 0) return false; this->value = static_cast(enum_keys_map[str]); return true; }; // Map from an enum name to an enum integer value. //FIXME The map is called often, it shall be initialized statically. static t_config_enum_values get_enum_values(); }; // Generic enum configuration value. // We use this one in DynamicConfig objects when creating a config value object for ConfigOptionType == coEnum. // In the StaticConfig, it is better to use the specialized ConfigOptionEnum containers. class ConfigOptionEnumGeneric : public ConfigOptionInt { public: const t_config_enum_values* keys_map; std::string serialize() const { for (t_config_enum_values::const_iterator it = this->keys_map->begin(); it != this->keys_map->end(); ++it) { if (it->second == this->value) return it->first; } return ""; }; bool deserialize(std::string str) { if (this->keys_map->count(str) == 0) return false; this->value = (*const_cast(this->keys_map))[str]; return true; }; }; // Type of a configuration value. enum ConfigOptionType { coNone, // single float coFloat, // vector of floats coFloats, // single int coInt, // vector of ints coInts, // single string coString, // vector of strings coStrings, // percent value. Currently only used for infill. coPercent, // a fraction or an absolute value coFloatOrPercent, // single 2d point. Currently not used. coPoint, // vector of 2d points. Currently used for the definition of the print bed and for the extruder offsets. coPoints, // single boolean value coBool, // vector of boolean values coBools, // a generic enum coEnum, }; // Definition of a configuration value for the purpose of GUI presentation, editing, value mapping and config file handling. class ConfigOptionDef { public: // What type? bool, int, string etc. ConfigOptionType type; // Default value of this option. The default value object is owned by ConfigDef, it is released in its destructor. ConfigOption* default_value; // Usually empty. // Special values - "i_enum_open", "f_enum_open" to provide combo box for int or float selection, // "select_open" - to open a selection dialog (currently only a serial port selection). std::string gui_type; // Usually empty. Otherwise "serialized" or "show_value" // The flags may be combined. // "serialized" - vector valued option is entered in a single edit field. Values are separated by a semicolon. // "show_value" - even if enum_values / enum_labels are set, still display the value, not the enum label. std::string gui_flags; // Label of the GUI input field. // In case the GUI input fields are grouped in some views, the label defines a short label of a grouped value, // while full_label contains a label of a stand-alone field. // The full label is shown, when adding an override parameter for an object or a modified object. std::string label; std::string full_label; // Category of a configuration field, from the GUI perspective. // One of: "Layers and Perimeters", "Infill", "Support material", "Speed", "Extruders", "Advanced", "Extrusion Width" std::string category; // A tooltip text shown in the GUI. std::string tooltip; // Text right from the input field, usually a unit of measurement. std::string sidetext; // Format of this parameter on a command line. std::string cli; // Set for type == coFloatOrPercent. // It provides a link to a configuration value, of which this option provides a ratio. // For example, // For example external_perimeter_speed may be defined as a fraction of perimeter_speed. t_config_option_key ratio_over; // True for multiline strings. bool multiline; // For text input: If true, the GUI text box spans the complete page width. bool full_width; // Not editable. Currently only used for the display of the number of threads. bool readonly; // Height of a multiline GUI text box. int height; // Optional width of an input field. int width; // limit of a numeric input. // If not set, the is set to // By setting min=0, only nonnegative input is allowed. int min; int max; // Legacy names for this configuration option. // Used when parsing legacy configuration file. std::vector aliases; // Sometimes a single value may well define multiple values in a "beginner" mode. // Currently used for aliasing "solid_layers" to "top_solid_layers", "bottom_solid_layers". std::vector shortcut; // Definition of values / labels for a combo box. // Mostly used for enums (when type == coEnum), but may be used for ints resp. floats, if gui_type is set to "i_enum_open" resp. "f_enum_open". std::vector enum_values; std::vector enum_labels; // For enums (when type == coEnum). Maps enum_values to enums. // Initialized by ConfigOptionEnum::get_enum_values() t_config_enum_values enum_keys_map; ConfigOptionDef() : type(coNone), default_value(NULL), multiline(false), full_width(false), readonly(false), height(-1), width(-1), min(INT_MIN), max(INT_MAX) {}; }; // Map from a config option name to its definition. // The definition does not carry an actual value of the config option, only its constant default value. // t_config_option_key is std::string typedef std::map t_optiondef_map; // Definition of configuration values for the purpose of GUI presentation, editing, value mapping and config file handling. // The configuration definition is static: It does not carry the actual configuration values, // but it carries the defaults of the configuration values. class ConfigDef { public: t_optiondef_map options; ~ConfigDef(); ConfigOptionDef* add(const t_config_option_key &opt_key, ConfigOptionType type); const ConfigOptionDef* get(const t_config_option_key &opt_key) const; }; // An abstract configuration store. class ConfigBase { public: // Definition of configuration values for the purpose of GUI presentation, editing, value mapping and config file handling. // The configuration definition is static: It does not carry the actual configuration values, // but it carries the defaults of the configuration values. // ConfigBase does not own ConfigDef, it only references it. const ConfigDef* def; ConfigBase() : def(NULL) {}; virtual ~ConfigBase() {}; bool has(const t_config_option_key &opt_key); const ConfigOption* option(const t_config_option_key &opt_key) const; ConfigOption* option(const t_config_option_key &opt_key, bool create = false); virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) = 0; virtual t_config_option_keys keys() const = 0; void apply(const ConfigBase &other, bool ignore_nonexistent = false); bool equals(ConfigBase &other); t_config_option_keys diff(ConfigBase &other); std::string serialize(const t_config_option_key &opt_key) const; bool set_deserialize(const t_config_option_key &opt_key, std::string str); double get_abs_value(const t_config_option_key &opt_key) const; double get_abs_value(const t_config_option_key &opt_key, double ratio_over) const; void setenv_(); }; // Configuration store with dynamic number of configuration values. // In Slic3r, the dynamic config is mostly used at the user interface layer. class DynamicConfig : public virtual ConfigBase { public: DynamicConfig() {}; DynamicConfig(const DynamicConfig& other); DynamicConfig& operator= (DynamicConfig other); void swap(DynamicConfig &other); virtual ~DynamicConfig(); template T* opt(const t_config_option_key &opt_key, bool create = false); virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false); t_config_option_keys keys() const; void erase(const t_config_option_key &opt_key); private: typedef std::map t_options_map; t_options_map options; }; // Configuration store with a static definition of configuration values. // In Slic3r, the static configuration stores are during the slicing / g-code generation for efficiency reasons, // because the configuration values could be accessed directly. class StaticConfig : public virtual ConfigBase { public: StaticConfig() : ConfigBase() {}; // Gets list of config option names for each config option of this->def, which has a static counter-part defined by the derived object // and which could be resolved by this->optptr(key) call. t_config_option_keys keys() const; // Set all statically defined config options to their defaults defined by this->def. void set_defaults(); // The derived class has to implement optptr to resolve a static configuration value. // virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) = 0; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/EdgeGrid.cpp000066400000000000000000001151521301441720000217700ustar00rootroot00000000000000#include #include #include #ifdef SLIC3R_GUI #include #endif /* SLIC3R_GUI */ #include "libslic3r.h" #include "EdgeGrid.hpp" #if 0 // Enable debugging and assert in this file. #define DEBUG #define _DEBUG #undef NDEBUG #endif #include namespace Slic3r { EdgeGrid::Grid::Grid() : m_rows(0), m_cols(0) { } EdgeGrid::Grid::~Grid() { m_contours.clear(); m_cell_data.clear(); m_cells.clear(); } void EdgeGrid::Grid::create(const Polygons &polygons, coord_t resolution) { // Count the contours. size_t ncontours = 0; for (size_t j = 0; j < polygons.size(); ++ j) if (! polygons[j].points.empty()) ++ ncontours; // Collect the contours. m_contours.assign(ncontours, NULL); ncontours = 0; for (size_t j = 0; j < polygons.size(); ++ j) if (! polygons[j].points.empty()) m_contours[ncontours++] = &polygons[j].points; create_from_m_contours(resolution); } void EdgeGrid::Grid::create(const ExPolygon &expoly, coord_t resolution) { // Count the contours. size_t ncontours = 0; if (! expoly.contour.points.empty()) ++ ncontours; for (size_t j = 0; j < expoly.holes.size(); ++ j) if (! expoly.holes[j].points.empty()) ++ ncontours; // Collect the contours. m_contours.assign(ncontours, NULL); ncontours = 0; if (! expoly.contour.points.empty()) m_contours[ncontours++] = &expoly.contour.points; for (size_t j = 0; j < expoly.holes.size(); ++ j) if (! expoly.holes[j].points.empty()) m_contours[ncontours++] = &expoly.holes[j].points; create_from_m_contours(resolution); } void EdgeGrid::Grid::create(const ExPolygons &expolygons, coord_t resolution) { // Count the contours. size_t ncontours = 0; for (size_t i = 0; i < expolygons.size(); ++ i) { const ExPolygon &expoly = expolygons[i]; if (! expoly.contour.points.empty()) ++ ncontours; for (size_t j = 0; j < expoly.holes.size(); ++ j) if (! expoly.holes[j].points.empty()) ++ ncontours; } // Collect the contours. m_contours.assign(ncontours, NULL); ncontours = 0; for (size_t i = 0; i < expolygons.size(); ++ i) { const ExPolygon &expoly = expolygons[i]; if (! expoly.contour.points.empty()) m_contours[ncontours++] = &expoly.contour.points; for (size_t j = 0; j < expoly.holes.size(); ++ j) if (! expoly.holes[j].points.empty()) m_contours[ncontours++] = &expoly.holes[j].points; } create_from_m_contours(resolution); } void EdgeGrid::Grid::create(const ExPolygonCollection &expolygons, coord_t resolution) { create(expolygons.expolygons, resolution); } // m_contours has been initialized. Now fill in the edge grid. void EdgeGrid::Grid::create_from_m_contours(coord_t resolution) { // 1) Measure the bounding box. m_bbox.defined = false; for (size_t i = 0; i < m_contours.size(); ++ i) { const Slic3r::Points &pts = *m_contours[i]; for (size_t j = 0; j < pts.size(); ++ j) m_bbox.merge(pts[j]); } coord_t eps = 16; m_bbox.min.x -= eps; m_bbox.min.y -= eps; m_bbox.max.x += eps; m_bbox.max.y += eps; // 2) Initialize the edge grid. m_resolution = resolution; m_cols = (m_bbox.max.x - m_bbox.min.x + m_resolution - 1) / m_resolution; m_rows = (m_bbox.max.y - m_bbox.min.y + m_resolution - 1) / m_resolution; m_cells.assign(m_rows * m_cols, Cell()); // 3) First round of contour rasterization, count the edges per grid cell. for (size_t i = 0; i < m_contours.size(); ++ i) { const Slic3r::Points &pts = *m_contours[i]; for (size_t j = 0; j < pts.size(); ++ j) { // End points of the line segment. Slic3r::Point p1(pts[j]); Slic3r::Point p2 = pts[(j + 1 == pts.size()) ? 0 : j + 1]; p1.x -= m_bbox.min.x; p1.y -= m_bbox.min.y; p2.x -= m_bbox.min.x; p2.y -= m_bbox.min.y; // Get the cells of the end points. coord_t ix = p1.x / m_resolution; coord_t iy = p1.y / m_resolution; coord_t ixb = p2.x / m_resolution; coord_t iyb = p2.y / m_resolution; assert(ix >= 0 && ix < m_cols); assert(iy >= 0 && iy < m_rows); assert(ixb >= 0 && ixb < m_cols); assert(iyb >= 0 && iyb < m_rows); // Account for the end points. ++ m_cells[iy*m_cols+ix].end; if (ix == ixb && iy == iyb) // Both ends fall into the same cell. continue; // Raster the centeral part of the line. coord_t dx = std::abs(p2.x - p1.x); coord_t dy = std::abs(p2.y - p1.y); if (p1.x < p2.x) { int64_t ex = int64_t((ix + 1)*m_resolution - p1.x) * int64_t(dy); if (p1.y < p2.y) { // x positive, y positive int64_t ey = int64_t((iy + 1)*m_resolution - p1.y) * int64_t(dx); do { assert(ix <= ixb && iy <= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix += 1; } else if (ex == ey) { ex = int64_t(dy) * m_resolution; ey = int64_t(dx) * m_resolution; ix += 1; iy += 1; } else { assert(ex > ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy += 1; } ++m_cells[iy*m_cols + ix].end; } while (ix != ixb || iy != iyb); } else { // x positive, y non positive int64_t ey = int64_t(p1.y - iy*m_resolution) * int64_t(dx); do { assert(ix <= ixb && iy >= iyb); if (ex <= ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix += 1; } else { ex -= ey; ey = int64_t(dx) * m_resolution; iy -= 1; } ++m_cells[iy*m_cols + ix].end; } while (ix != ixb || iy != iyb); } } else { int64_t ex = int64_t(p1.x - ix*m_resolution) * int64_t(dy); if (p1.y < p2.y) { // x non positive, y positive int64_t ey = int64_t((iy + 1)*m_resolution - p1.y) * int64_t(dx); do { assert(ix >= ixb && iy <= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix -= 1; } else { assert(ex >= ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy += 1; } ++m_cells[iy*m_cols + ix].end; } while (ix != ixb || iy != iyb); } else { // x non positive, y non positive int64_t ey = int64_t(p1.y - iy*m_resolution) * int64_t(dx); do { assert(ix >= ixb && iy >= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix -= 1; } else if (ex == ey) { // The lower edge of a grid cell belongs to the cell. // Handle the case where the ray may cross the lower left corner of a cell in a general case, // or a left or lower edge in a degenerate case (horizontal or vertical line). if (dx > 0) { ex = int64_t(dy) * m_resolution; ix -= 1; } if (dy > 0) { ey = int64_t(dx) * m_resolution; iy -= 1; } } else { assert(ex > ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy -= 1; } ++m_cells[iy*m_cols + ix].end; } while (ix != ixb || iy != iyb); } } } } // 4) Prefix sum the numbers of hits per cells to get an index into m_cell_data. size_t cnt = m_cells.front().end; for (size_t i = 1; i < m_cells.size(); ++ i) { m_cells[i].begin = cnt; cnt += m_cells[i].end; m_cells[i].end = cnt; } // 5) Allocate the cell data. m_cell_data.assign(cnt, std::pair(size_t(-1), size_t(-1))); // 6) Finally fill in m_cell_data by rasterizing the lines once again. for (size_t i = 0; i < m_cells.size(); ++i) m_cells[i].end = m_cells[i].begin; for (size_t i = 0; i < m_contours.size(); ++i) { const Slic3r::Points &pts = *m_contours[i]; for (size_t j = 0; j < pts.size(); ++j) { // End points of the line segment. Slic3r::Point p1(pts[j]); Slic3r::Point p2 = pts[(j + 1 == pts.size()) ? 0 : j + 1]; p1.x -= m_bbox.min.x; p1.y -= m_bbox.min.y; p2.x -= m_bbox.min.x; p2.y -= m_bbox.min.y; // Get the cells of the end points. coord_t ix = p1.x / m_resolution; coord_t iy = p1.y / m_resolution; coord_t ixb = p2.x / m_resolution; coord_t iyb = p2.y / m_resolution; assert(ix >= 0 && ix < m_cols); assert(iy >= 0 && iy < m_rows); assert(ixb >= 0 && ixb < m_cols); assert(iyb >= 0 && iyb < m_rows); // Account for the end points. m_cell_data[m_cells[iy*m_cols + ix].end++] = std::pair(i, j); if (ix == ixb && iy == iyb) // Both ends fall into the same cell. continue; // Raster the centeral part of the line. coord_t dx = std::abs(p2.x - p1.x); coord_t dy = std::abs(p2.y - p1.y); if (p1.x < p2.x) { int64_t ex = int64_t((ix + 1)*m_resolution - p1.x) * int64_t(dy); if (p1.y < p2.y) { // x positive, y positive int64_t ey = int64_t((iy + 1)*m_resolution - p1.y) * int64_t(dx); do { assert(ix <= ixb && iy <= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix += 1; } else if (ex == ey) { ex = int64_t(dy) * m_resolution; ey = int64_t(dx) * m_resolution; ix += 1; iy += 1; } else { assert(ex > ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy += 1; } m_cell_data[m_cells[iy*m_cols + ix].end++] = std::pair(i, j); } while (ix != ixb || iy != iyb); } else { // x positive, y non positive int64_t ey = int64_t(p1.y - iy*m_resolution) * int64_t(dx); do { assert(ix <= ixb && iy >= iyb); if (ex <= ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix += 1; } else { ex -= ey; ey = int64_t(dx) * m_resolution; iy -= 1; } m_cell_data[m_cells[iy*m_cols + ix].end++] = std::pair(i, j); } while (ix != ixb || iy != iyb); } } else { int64_t ex = int64_t(p1.x - ix*m_resolution) * int64_t(dy); if (p1.y < p2.y) { // x non positive, y positive int64_t ey = int64_t((iy + 1)*m_resolution - p1.y) * int64_t(dx); do { assert(ix >= ixb && iy <= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix -= 1; } else { assert(ex >= ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy += 1; } m_cell_data[m_cells[iy*m_cols + ix].end++] = std::pair(i, j); } while (ix != ixb || iy != iyb); } else { // x non positive, y non positive int64_t ey = int64_t(p1.y - iy*m_resolution) * int64_t(dx); do { assert(ix >= ixb && iy >= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix -= 1; } else if (ex == ey) { // The lower edge of a grid cell belongs to the cell. // Handle the case where the ray may cross the lower left corner of a cell in a general case, // or a left or lower edge in a degenerate case (horizontal or vertical line). if (dx > 0) { ex = int64_t(dy) * m_resolution; ix -= 1; } if (dy > 0) { ey = int64_t(dx) * m_resolution; iy -= 1; } } else { assert(ex > ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy -= 1; } m_cell_data[m_cells[iy*m_cols + ix].end++] = std::pair(i, j); } while (ix != ixb || iy != iyb); } } } } } #if 0 // Divide, round to a grid coordinate. // Divide x/y, round down. y is expected to be positive. static inline coord_t div_floor(coord_t x, coord_t y) { assert(y > 0); return ((x < 0) ? (x - y + 1) : x) / y; } // Walk the polyline, test whether any lines of this polyline does not intersect // any line stored into the grid. bool EdgeGrid::Grid::intersect(const MultiPoint &polyline, bool closed) { size_t n = polyline.points.size(); if (closed) ++ n; for (size_t i = 0; i < n; ++ i) { size_t j = i + 1; if (j == polyline.points.size()) j = 0; Point p1src = polyline.points[i]; Point p2src = polyline.points[j]; Point p1 = p1src; Point p2 = p2src; // Discretize the line segment p1, p2. p1.x -= m_bbox.min.x; p1.y -= m_bbox.min.y; p2.x -= m_bbox.min.x; p2.y -= m_bbox.min.y; // Get the cells of the end points. coord_t ix = div_floor(p1.x, m_resolution); coord_t iy = div_floor(p1.y, m_resolution); coord_t ixb = div_floor(p2.x, m_resolution); coord_t iyb = div_floor(p2.y, m_resolution); // assert(ix >= 0 && ix < m_cols); // assert(iy >= 0 && iy < m_rows); // assert(ixb >= 0 && ixb < m_cols); // assert(iyb >= 0 && iyb < m_rows); // Account for the end points. if (line_cell_intersect(p1src, p2src, m_cells[iy*m_cols + ix])) return true; if (ix == ixb && iy == iyb) // Both ends fall into the same cell. continue; // Raster the centeral part of the line. coord_t dx = std::abs(p2.x - p1.x); coord_t dy = std::abs(p2.y - p1.y); if (p1.x < p2.x) { int64_t ex = int64_t((ix + 1)*m_resolution - p1.x) * int64_t(dy); if (p1.y < p2.y) { int64_t ey = int64_t((iy + 1)*m_resolution - p1.y) * int64_t(dx); do { assert(ix <= ixb && iy <= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix += 1; } else if (ex == ey) { ex = int64_t(dy) * m_resolution; ey = int64_t(dx) * m_resolution; ix += 1; iy += 1; } else { assert(ex > ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy += 1; } if (line_cell_intersect(p1src, p2src, m_cells[iy*m_cols + ix])) return true; } while (ix != ixb || iy != iyb); } else { int64_t ey = int64_t(p1.y - iy*m_resolution) * int64_t(dx); do { assert(ix <= ixb && iy >= iyb); if (ex <= ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix += 1; } else { ex -= ey; ey = int64_t(dx) * m_resolution; iy -= 1; } if (line_cell_intersect(p1src, p2src, m_cells[iy*m_cols + ix])) return true; } while (ix != ixb || iy != iyb); } } else { int64_t ex = int64_t(p1.x - ix*m_resolution) * int64_t(dy); if (p1.y < p2.y) { int64_t ey = int64_t((iy + 1)*m_resolution - p1.y) * int64_t(dx); do { assert(ix >= ixb && iy <= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix -= 1; } else { assert(ex >= ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy += 1; } if (line_cell_intersect(p1src, p2src, m_cells[iy*m_cols + ix])) return true; } while (ix != ixb || iy != iyb); } else { int64_t ey = int64_t(p1.y - iy*m_resolution) * int64_t(dx); do { assert(ix >= ixb && iy >= iyb); if (ex < ey) { ey -= ex; ex = int64_t(dy) * m_resolution; ix -= 1; } else if (ex == ey) { if (dx > 0) { ex = int64_t(dy) * m_resolution; ix -= 1; } if (dy > 0) { ey = int64_t(dx) * m_resolution; iy -= 1; } } else { assert(ex > ey); ex -= ey; ey = int64_t(dx) * m_resolution; iy -= 1; } if (line_cell_intersect(p1src, p2src, m_cells[iy*m_cols + ix])) return true; } while (ix != ixb || iy != iyb); } } } return false; } bool EdgeGrid::Grid::line_cell_intersect(const Point &p1a, const Point &p2a, const Cell &cell) { BoundingBox bbox(p1a, p1a); bbox.merge(p2a); int64_t va_x = p2a.x - p1a.x; int64_t va_y = p2a.y - p1a.y; for (size_t i = cell.begin; i != cell.end; ++ i) { const std::pair &cell_data = m_cell_data[i]; // Contour indexed by the ith line of this cell. const Slic3r::Points &contour = *m_contours[cell_data.first]; // Point indices in contour indexed by the ith line of this cell. size_t idx1 = cell_data.second; size_t idx2 = idx1 + 1; if (idx2 == contour.size()) idx2 = 0; // The points of the ith line of this cell and its bounding box. const Point &p1b = contour[idx1]; const Point &p2b = contour[idx2]; BoundingBox bbox2(p1b, p1b); bbox2.merge(p2b); // Do the bounding boxes intersect? if (! bbox.overlap(bbox2)) continue; // Now intersect the two line segments using exact arithmetics. int64_t w1_x = p1b.x - p1a.x; int64_t w1_y = p1b.y - p1a.y; int64_t w2_x = p2b.x - p1a.x; int64_t w2_y = p2b.y - p1a.y; int64_t side1 = va_x * w1_y - va_y * w1_x; int64_t side2 = va_x * w2_y - va_y * w2_x; if (side1 == side2 && side1 != 0) // The line segments don't intersect. continue; w1_x = p1a.x - p1b.x; w1_y = p1a.y - p1b.y; w2_x = p2a.x - p1b.x; w2_y = p2a.y - p1b.y; int64_t vb_x = p2b.x - p1b.x; int64_t vb_y = p2b.y - p1b.y; side1 = vb_x * w1_y - vb_y * w1_x; side2 = vb_x * w2_y - vb_y * w2_x; if (side1 == side2 && side1 != 0) // The line segments don't intersect. continue; // The line segments intersect. return true; } // The line segment (p1a, p2a) does not intersect any of the line segments inside this cell. return false; } // Test, whether a point is inside a contour. bool EdgeGrid::Grid::inside(const Point &pt_src) { Point p = pt_src; p.x -= m_bbox.min.x; p.y -= m_bbox.min.y; // Get the cell of the point. if (p.x < 0 || p.y < 0) return false; coord_t ix = p.x / m_resolution; coord_t iy = p.y / m_resolution; if (ix >= this->m_cols || iy >= this->m_rows) return false; size_t i_closest = (size_t)-1; bool inside = false; { // Hit in the first cell? const Cell &cell = m_cells[iy * m_cols + ix]; for (size_t i = cell.begin; i != cell.end; ++ i) { const std::pair &cell_data = m_cell_data[i]; // Contour indexed by the ith line of this cell. const Slic3r::Points &contour = *m_contours[cell_data.first]; // Point indices in contour indexed by the ith line of this cell. size_t idx1 = cell_data.second; size_t idx2 = idx1 + 1; if (idx2 == contour.size()) idx2 = 0; const Point &p1 = contour[idx1]; const Point &p2 = contour[idx2]; if (p1.y < p2.y) { if (p.y < p1.y || p.y > p2.y) continue; //FIXME finish this! int64_t vx = 0;// pt_src //FIXME finish this! int64_t det = 0; } else if (p1.y != p2.y) { assert(p1.y > p2.y); if (p.y < p2.y || p.y > p1.y) continue; } else { assert(p1.y == p2.y); if (p1.y == p.y) { if (p.x >= p1.x && p.x <= p2.x) // On the segment. return true; // Before or after the segment. size_t idx0 = idx1 - 1; size_t idx2 = idx1 + 1; if (idx0 == (size_t)-1) idx0 = contour.size() - 1; if (idx2 == contour.size()) idx2 = 0; } } } } //FIXME This code follows only a single direction. Better to follow the direction closest to the bounding box. } #endif template struct PropagateDanielssonSingleStep { PropagateDanielssonSingleStep(float *aL, unsigned char *asigns, size_t astride, coord_t aresolution) : L(aL), signs(asigns), stride(astride), resolution(aresolution) {} inline void operator()(int r, int c, int addr_delta) { size_t addr = r * stride + c; if ((signs[addr] & 2) == 0) { float *v = &L[addr << 1]; float l = v[0] * v[0] + v[1] * v[1]; float *v2s = v + (addr_delta << 1); float v2[2] = { v2s[0] + INCX * resolution, v2s[1] + INCY * resolution }; float l2 = v2[0] * v2[0] + v2[1] * v2[1]; if (l2 < l) { v[0] = v2[0]; v[1] = v2[1]; } } } float *L; unsigned char *signs; size_t stride; coord_t resolution; }; struct PropagateDanielssonSingleVStep3 { PropagateDanielssonSingleVStep3(float *aL, unsigned char *asigns, size_t astride, coord_t aresolution) : L(aL), signs(asigns), stride(astride), resolution(aresolution) {} inline void operator()(int r, int c, int addr_delta, bool has_l, bool has_r) { size_t addr = r * stride + c; if ((signs[addr] & 2) == 0) { float *v = &L[addr<<1]; float l = v[0]*v[0]+v[1]*v[1]; float *v2s = v+(addr_delta<<1); float v2[2] = { v2s[0], v2s[1] + resolution }; float l2 = v2[0]*v2[0]+v2[1]*v2[1]; if (l2 < l) { v[0] = v2[0]; v[1] = v2[1]; } if (has_l) { float *v2sl = v2s - 1; v2[0] = v2sl[0] + resolution; v2[1] = v2sl[1] + resolution; l2 = v2[0]*v2[0]+v2[1]*v2[1]; if (l2 < l) { v[0] = v2[0]; v[1] = v2[1]; } } if (has_r) { float *v2sr = v2s + 1; v2[0] = v2sr[0] + resolution; v2[1] = v2sr[1] + resolution; l2 = v2[0]*v2[0]+v2[1]*v2[1]; if (l2 < l) { v[0] = v2[0]; v[1] = v2[1]; } } } } float *L; unsigned char *signs; size_t stride; coord_t resolution; }; void EdgeGrid::Grid::calculate_sdf() { // 1) Initialize a signum and an unsigned vector to a zero iso surface. size_t nrows = m_rows + 1; size_t ncols = m_cols + 1; // Unsigned vectors towards the closest point on the surface. std::vector L(nrows * ncols * 2, FLT_MAX); // Bit 0 set - negative. // Bit 1 set - original value, the distance value shall not be changed by the Danielsson propagation. // Bit 2 set - signum not propagated yet. std::vector signs(nrows * ncols, 4); // SDF will be initially filled with unsigned DF. // m_signed_distance_field.assign(nrows * ncols, FLT_MAX); float search_radius = float(m_resolution<<1); m_signed_distance_field.assign(nrows * ncols, search_radius); // For each cell: for (size_t r = 0; r < m_rows; ++ r) { for (size_t c = 0; c < m_cols; ++ c) { const Cell &cell = m_cells[r * m_cols + c]; // For each segment in the cell: for (size_t i = cell.begin; i != cell.end; ++ i) { const Slic3r::Points &pts = *m_contours[m_cell_data[i].first]; size_t ipt = m_cell_data[i].second; // End points of the line segment. const Slic3r::Point &p1 = pts[ipt]; const Slic3r::Point &p2 = pts[(ipt + 1 == pts.size()) ? 0 : ipt + 1]; // Segment vector const Slic3r::Point v_seg = p1.vector_to(p2); // l2 of v_seg const int64_t l2_seg = int64_t(v_seg.x) * int64_t(v_seg.x) + int64_t(v_seg.y) * int64_t(v_seg.y); // For each corner of this cell and its 1 ring neighbours: for (int corner_y = -1; corner_y < 3; ++ corner_y) { coord_t corner_r = r + corner_y; if (corner_r < 0 || corner_r >= nrows) continue; for (int corner_x = -1; corner_x < 3; ++ corner_x) { coord_t corner_c = c + corner_x; if (corner_c < 0 || corner_c >= ncols) continue; float &d_min = m_signed_distance_field[corner_r * ncols + corner_c]; Slic3r::Point pt(m_bbox.min.x + corner_c * m_resolution, m_bbox.min.y + corner_r * m_resolution); Slic3r::Point v_pt = p1.vector_to(pt); // dot(p2-p1, pt-p1) int64_t t_pt = int64_t(v_seg.x) * int64_t(v_pt.x) + int64_t(v_seg.y) * int64_t(v_pt.y); if (t_pt < 0) { // Closest to p1. double dabs = sqrt(int64_t(v_pt.x) * int64_t(v_pt.x) + int64_t(v_pt.y) * int64_t(v_pt.y)); if (dabs < d_min) { // Previous point. const Slic3r::Point &p0 = pts[(ipt == 0) ? (pts.size() - 1) : ipt - 1]; Slic3r::Point v_seg_prev = p0.vector_to(p1); int64_t t2_pt = int64_t(v_seg_prev.x) * int64_t(v_pt.x) + int64_t(v_seg_prev.y) * int64_t(v_pt.y); if (t2_pt > 0) { // Inside the wedge between the previous and the next segment. // Set the signum depending on whether the vertex is convex or reflex. int64_t det = int64_t(v_seg_prev.x) * int64_t(v_seg.y) - int64_t(v_seg_prev.y) * int64_t(v_seg.x); assert(det != 0); d_min = dabs; // Fill in an unsigned vector towards the zero iso surface. float *l = &L[(corner_r * ncols + corner_c) << 1]; l[0] = std::abs(v_pt.x); l[1] = std::abs(v_pt.y); #ifdef _DEBUG double dabs2 = sqrt(l[0]*l[0]+l[1]*l[1]); assert(std::abs(dabs-dabs2) < 1e-4 * std::max(dabs, dabs2)); #endif /* _DEBUG */ signs[corner_r * ncols + corner_c] = ((det < 0) ? 1 : 0) | 2; } } } else if (t_pt > l2_seg) { // Closest to p2. Then p2 is the starting point of another segment, which shall be discovered in the same cell. continue; } else { // Closest to the segment. assert(t_pt >= 0 && t_pt <= l2_seg); int64_t d_seg = int64_t(v_seg.y) * int64_t(v_pt.x) - int64_t(v_seg.x) * int64_t(v_pt.y); double d = double(d_seg) / sqrt(double(l2_seg)); double dabs = std::abs(d); if (dabs < d_min) { d_min = dabs; // Fill in an unsigned vector towards the zero iso surface. float *l = &L[(corner_r * ncols + corner_c) << 1]; float linv = float(d_seg) / float(l2_seg); l[0] = std::abs(float(v_seg.y) * linv); l[1] = std::abs(float(v_seg.x) * linv); #ifdef _DEBUG double dabs2 = sqrt(l[0]*l[0]+l[1]*l[1]); assert(std::abs(dabs-dabs2) <= 1e-4 * std::max(dabs, dabs2)); #endif /* _DEBUG */ signs[corner_r * ncols + corner_c] = ((d_seg < 0) ? 1 : 0) | 2; } } } } } } } #if 0 //#ifdef SLIC3R_GUI { wxImage img(ncols, nrows); unsigned char *data = img.GetData(); memset(data, 0, ncols * nrows * 3); for (coord_t r = 0; r < nrows; ++r) { for (coord_t c = 0; c < ncols; ++c) { unsigned char *pxl = data + (((nrows - r - 1) * ncols) + c) * 3; float d = m_signed_distance_field[r * ncols + c]; if (d != search_radius) { float s = 255 * d / search_radius; int is = std::max(0, std::min(255, int(floor(s + 0.5f)))); pxl[0] = 255; pxl[1] = 255 - is; pxl[2] = 255 - is; } else { pxl[0] = 0; pxl[1] = 255; pxl[2] = 0; } } } img.SaveFile(debug_out_path("unsigned_df.png"), wxBITMAP_TYPE_PNG); } { wxImage img(ncols, nrows); unsigned char *data = img.GetData(); memset(data, 0, ncols * nrows * 3); for (coord_t r = 0; r < nrows; ++r) { for (coord_t c = 0; c < ncols; ++c) { unsigned char *pxl = data + (((nrows - r - 1) * ncols) + c) * 3; float d = m_signed_distance_field[r * ncols + c]; if (d != search_radius) { float s = 255 * d / search_radius; int is = std::max(0, std::min(255, int(floor(s + 0.5f)))); if ((signs[r * ncols + c] & 1) == 0) { // Positive pxl[0] = 255; pxl[1] = 255 - is; pxl[2] = 255 - is; } else { // Negative pxl[0] = 255 - is; pxl[1] = 255 - is; pxl[2] = 255; } } else { pxl[0] = 0; pxl[1] = 255; pxl[2] = 0; } } } img.SaveFile(debug_out_path("signed_df.png"), wxBITMAP_TYPE_PNG); } #endif /* SLIC3R_GUI */ // 2) Propagate the signum. #define PROPAGATE_SIGNUM_SINGLE_STEP(DELTA) do { \ size_t addr = r * ncols + c; \ unsigned char &cur_val = signs[addr]; \ if (cur_val & 4) { \ unsigned char old_val = signs[addr + (DELTA)]; \ if ((old_val & 4) == 0) \ cur_val = old_val & 1; \ } \ } while (0); // Top to bottom propagation. for (size_t r = 0; r < nrows; ++ r) { if (r > 0) for (size_t c = 0; c < ncols; ++ c) PROPAGATE_SIGNUM_SINGLE_STEP(- int(ncols)); for (size_t c = 1; c < ncols; ++ c) PROPAGATE_SIGNUM_SINGLE_STEP(- 1); for (int c = int(ncols) - 2; c >= 0; -- c) PROPAGATE_SIGNUM_SINGLE_STEP(+ 1); } // Bottom to top propagation. for (int r = int(nrows) - 2; r >= 0; -- r) { for (size_t c = 0; c < ncols; ++ c) PROPAGATE_SIGNUM_SINGLE_STEP(+ ncols); for (size_t c = 1; c < ncols; ++ c) PROPAGATE_SIGNUM_SINGLE_STEP(- 1); for (int c = int(ncols) - 2; c >= 0; -- c) PROPAGATE_SIGNUM_SINGLE_STEP(+ 1); } #undef PROPAGATE_SIGNUM_SINGLE_STEP // 3) Propagate the distance by the Danielsson chamfer metric. // Top to bottom propagation. PropagateDanielssonSingleStep<1, 0> danielsson_hstep(L.data(), signs.data(), ncols, m_resolution); PropagateDanielssonSingleStep<0, 1> danielsson_vstep(L.data(), signs.data(), ncols, m_resolution); PropagateDanielssonSingleVStep3 danielsson_vstep3(L.data(), signs.data(), ncols, m_resolution); // Top to bottom propagation. for (size_t r = 0; r < nrows; ++ r) { if (r > 0) for (size_t c = 0; c < ncols; ++ c) danielsson_vstep(r, c, -int(ncols)); // PROPAGATE_DANIELSSON_SINGLE_VSTEP3(-int(ncols), c != 0, c + 1 != ncols); for (size_t c = 1; c < ncols; ++ c) danielsson_hstep(r, c, -1); for (int c = int(ncols) - 2; c >= 0; -- c) danielsson_hstep(r, c, +1); } // Bottom to top propagation. for (int r = int(nrows) - 2; r >= 0; -- r) { for (size_t c = 0; c < ncols; ++ c) danielsson_vstep(r, c, +ncols); // PROPAGATE_DANIELSSON_SINGLE_VSTEP3(+int(ncols), c != 0, c + 1 != ncols); for (size_t c = 1; c < ncols; ++ c) danielsson_hstep(r, c, -1); for (int c = int(ncols) - 2; c >= 0; -- c) danielsson_hstep(r, c, +1); } // Update signed distance field from absolte vectors to the iso-surface. for (size_t r = 0; r < nrows; ++ r) { for (size_t c = 0; c < ncols; ++ c) { size_t addr = r * ncols + c; float *v = &L[addr<<1]; float d = sqrt(v[0]*v[0]+v[1]*v[1]); if (signs[addr] & 1) d = -d; m_signed_distance_field[addr] = d; } } #if 0 //#ifdef SLIC3R_GUI { wxImage img(ncols, nrows); unsigned char *data = img.GetData(); memset(data, 0, ncols * nrows * 3); float search_radius = float(m_resolution * 5); for (coord_t r = 0; r < nrows; ++r) { for (coord_t c = 0; c < ncols; ++c) { unsigned char *pxl = data + (((nrows - r - 1) * ncols) + c) * 3; unsigned char sign = signs[r * ncols + c]; switch (sign) { case 0: // Positive, outside of a narrow band. pxl[0] = 0; pxl[1] = 0; pxl[2] = 255; break; case 1: // Negative, outside of a narrow band. pxl[0] = 255; pxl[1] = 0; pxl[2] = 0; break; case 2: // Positive, outside of a narrow band. pxl[0] = 100; pxl[1] = 100; pxl[2] = 255; break; case 3: // Negative, outside of a narrow band. pxl[0] = 255; pxl[1] = 100; pxl[2] = 100; break; case 4: // This shall not happen. Undefined signum. pxl[0] = 0; pxl[1] = 255; pxl[2] = 0; break; default: // This shall not happen. Invalid signum value. pxl[0] = 255; pxl[1] = 255; pxl[2] = 255; break; } } } img.SaveFile(debug_out_path("signed_df-signs.png"), wxBITMAP_TYPE_PNG); } #endif /* SLIC3R_GUI */ #if 0 //#ifdef SLIC3R_GUI { wxImage img(ncols, nrows); unsigned char *data = img.GetData(); memset(data, 0, ncols * nrows * 3); float search_radius = float(m_resolution * 5); for (coord_t r = 0; r < nrows; ++r) { for (coord_t c = 0; c < ncols; ++c) { unsigned char *pxl = data + (((nrows - r - 1) * ncols) + c) * 3; float d = m_signed_distance_field[r * ncols + c]; float s = 255.f * fabs(d) / search_radius; int is = std::max(0, std::min(255, int(floor(s + 0.5f)))); if (d < 0.f) { pxl[0] = 255; pxl[1] = 255 - is; pxl[2] = 255 - is; } else { pxl[0] = 255 - is; pxl[1] = 255 - is; pxl[2] = 255; } } } img.SaveFile(debug_out_path("signed_df2.png"), wxBITMAP_TYPE_PNG); } #endif /* SLIC3R_GUI */ } float EdgeGrid::Grid::signed_distance_bilinear(const Point &pt) const { coord_t x = pt.x - m_bbox.min.x; coord_t y = pt.y - m_bbox.min.y; coord_t w = m_resolution * m_cols; coord_t h = m_resolution * m_rows; bool clamped = false; coord_t xcl = x; coord_t ycl = y; if (x < 0) { xcl = 0; clamped = true; } else if (x >= w) { xcl = w - 1; clamped = true; } if (y < 0) { ycl = 0; clamped = true; } else if (y >= h) { ycl = h - 1; clamped = true; } coord_t cell_c = coord_t(floor(xcl / m_resolution)); coord_t cell_r = coord_t(floor(ycl / m_resolution)); float tx = float(xcl - cell_c * m_resolution) / float(m_resolution); assert(tx >= -1e-5 && tx < 1.f + 1e-5); float ty = float(ycl - cell_r * m_resolution) / float(m_resolution); assert(ty >= -1e-5 && ty < 1.f + 1e-5); size_t addr = cell_r * (m_cols + 1) + cell_c; float f00 = m_signed_distance_field[addr]; float f01 = m_signed_distance_field[addr+1]; addr += m_cols + 1; float f10 = m_signed_distance_field[addr]; float f11 = m_signed_distance_field[addr+1]; float f0 = (1.f - tx) * f00 + tx * f01; float f1 = (1.f - tx) * f10 + tx * f11; float f = (1.f - ty) * f0 + ty * f1; if (clamped) { if (f > 0) { if (x < 0) f += -x; else if (x >= w) f += x - w + 1; if (y < 0) f += -y; else if (y >= h) f += y - h + 1; } else { if (x < 0) f -= -x; else if (x >= w) f -= x - w + 1; if (y < 0) f -= -y; else if (y >= h) f -= y - h + 1; } } return f; } bool EdgeGrid::Grid::signed_distance_edges(const Point &pt, coord_t search_radius, coordf_t &result_min_dist, bool *pon_segment) const { BoundingBox bbox; bbox.min = bbox.max = Point(pt.x - m_bbox.min.x, pt.y - m_bbox.min.y); bbox.defined = true; // Upper boundary, round to grid and test validity. bbox.max.x += search_radius; bbox.max.y += search_radius; if (bbox.max.x < 0 || bbox.max.y < 0) return false; bbox.max.x /= m_resolution; bbox.max.y /= m_resolution; if (bbox.max.x >= m_cols) bbox.max.x = m_cols - 1; if (bbox.max.y >= m_rows) bbox.max.y = m_rows - 1; // Lower boundary, round to grid and test validity. bbox.min.x -= search_radius; bbox.min.y -= search_radius; if (bbox.min.x < 0) bbox.min.x = 0; if (bbox.min.y < 0) bbox.min.y = 0; bbox.min.x /= m_resolution; bbox.min.y /= m_resolution; // Is the interval empty? if (bbox.min.x > bbox.max.x || bbox.min.y > bbox.max.y) return false; // Traverse all cells in the bounding box. float d_min = search_radius; // Signum of the distance field at pt. int sign_min = 0; bool on_segment = false; for (int r = bbox.min.y; r <= bbox.max.y; ++ r) { for (int c = bbox.min.x; c <= bbox.max.x; ++ c) { const Cell &cell = m_cells[r * m_cols + c]; for (size_t i = cell.begin; i < cell.end; ++ i) { const Slic3r::Points &pts = *m_contours[m_cell_data[i].first]; size_t ipt = m_cell_data[i].second; // End points of the line segment. const Slic3r::Point &p1 = pts[ipt]; const Slic3r::Point &p2 = pts[(ipt + 1 == pts.size()) ? 0 : ipt + 1]; Slic3r::Point v_seg = p1.vector_to(p2); Slic3r::Point v_pt = p1.vector_to(pt); // dot(p2-p1, pt-p1) int64_t t_pt = int64_t(v_seg.x) * int64_t(v_pt.x) + int64_t(v_seg.y) * int64_t(v_pt.y); // l2 of seg int64_t l2_seg = int64_t(v_seg.x) * int64_t(v_seg.x) + int64_t(v_seg.y) * int64_t(v_seg.y); if (t_pt < 0) { // Closest to p1. double dabs = sqrt(int64_t(v_pt.x) * int64_t(v_pt.x) + int64_t(v_pt.y) * int64_t(v_pt.y)); if (dabs < d_min) { // Previous point. const Slic3r::Point &p0 = pts[(ipt == 0) ? (pts.size() - 1) : ipt - 1]; Slic3r::Point v_seg_prev = p0.vector_to(p1); int64_t t2_pt = int64_t(v_seg_prev.x) * int64_t(v_pt.x) + int64_t(v_seg_prev.y) * int64_t(v_pt.y); if (t2_pt > 0) { // Inside the wedge between the previous and the next segment. d_min = dabs; // Set the signum depending on whether the vertex is convex or reflex. int64_t det = int64_t(v_seg_prev.x) * int64_t(v_seg.y) - int64_t(v_seg_prev.y) * int64_t(v_seg.x); assert(det != 0); sign_min = (det > 0) ? 1 : -1; on_segment = false; } } } else if (t_pt > l2_seg) { // Closest to p2. Then p2 is the starting point of another segment, which shall be discovered in the same cell. continue; } else { // Closest to the segment. assert(t_pt >= 0 && t_pt <= l2_seg); int64_t d_seg = int64_t(v_seg.y) * int64_t(v_pt.x) - int64_t(v_seg.x) * int64_t(v_pt.y); double d = double(d_seg) / sqrt(double(l2_seg)); double dabs = std::abs(d); if (dabs < d_min) { d_min = dabs; sign_min = (d_seg < 0) ? -1 : ((d_seg == 0) ? 0 : 1); on_segment = true; } } } } } if (d_min >= search_radius) return false; result_min_dist = d_min * sign_min; if (pon_segment != NULL) *pon_segment = on_segment; return true; } bool EdgeGrid::Grid::signed_distance(const Point &pt, coord_t search_radius, coordf_t &result_min_dist) const { if (signed_distance_edges(pt, search_radius, result_min_dist)) return true; if (m_signed_distance_field.empty()) return false; result_min_dist = signed_distance_bilinear(pt); return true; } #ifdef SLIC3R_GUI void EdgeGrid::save_png(const EdgeGrid::Grid &grid, const BoundingBox &bbox, coord_t resolution, const char *path) { unsigned int w = (bbox.max.x - bbox.min.x + resolution - 1) / resolution; unsigned int h = (bbox.max.y - bbox.min.y + resolution - 1) / resolution; wxImage img(w, h); unsigned char *data = img.GetData(); memset(data, 0, w * h * 3); static int iRun = 0; ++iRun; const coord_t search_radius = grid.resolution() * 2; const coord_t display_blend_radius = grid.resolution() * 5; for (coord_t r = 0; r < h; ++r) { for (coord_t c = 0; c < w; ++ c) { unsigned char *pxl = data + (((h - r - 1) * w) + c) * 3; Point pt(c * resolution + bbox.min.x, r * resolution + bbox.min.y); coordf_t min_dist; bool on_segment; // if (grid.signed_distance_edges(pt, search_radius, min_dist, &on_segment)) { if (grid.signed_distance(pt, search_radius, min_dist)) { //FIXME on_segment = true; float s = 255 * std::abs(min_dist) / float(display_blend_radius); int is = std::max(0, std::min(255, int(floor(s + 0.5f)))); if (min_dist < 0) { if (on_segment) { pxl[0] = 255; pxl[1] = 255 - is; pxl[2] = 255 - is; } else { pxl[0] = 128; pxl[1] = 128; pxl[2] = 255 - is; } } else { if (on_segment) { pxl[0] = 255 - is; pxl[1] = 255 - is; pxl[2] = 255; } else { pxl[0] = 255 - is; pxl[1] = 0; pxl[2] = 255; } } } else { pxl[0] = 0; pxl[1] = 255; pxl[2] = 0; } float gridx = float(pt.x - grid.bbox().min.x) / float(grid.resolution()); float gridy = float(pt.y - grid.bbox().min.y) / float(grid.resolution()); if (gridx >= -0.4f && gridy >= -0.4f && gridx <= grid.cols() + 0.4f && gridy <= grid.rows() + 0.4f) { int ix = int(floor(gridx + 0.5f)); int iy = int(floor(gridy + 0.5f)); float dx = gridx - float(ix); float dy = gridy - float(iy); float d = sqrt(dx*dx + dy*dy) * float(grid.resolution()) / float(resolution); if (d < 1.f) { // Less than 1 pixel from the grid point. float t = 0.5f + 0.5f * d; pxl[0] = (unsigned char)(t * pxl[0]); pxl[1] = (unsigned char)(t * pxl[1]); pxl[2] = (unsigned char)(t * pxl[2]); } } float dgrid = fabs(min_dist) / float(grid.resolution()); float igrid = floor(dgrid + 0.5f); dgrid = std::abs(dgrid - igrid) * float(grid.resolution()) / float(resolution); if (dgrid < 1.f) { // Less than 1 pixel from the grid point. float t = 0.5f + 0.5f * dgrid; pxl[0] = (unsigned char)(t * pxl[0]); pxl[1] = (unsigned char)(t * pxl[1]); pxl[2] = (unsigned char)(t * pxl[2]); if (igrid > 0.f) { // Other than zero iso contour. int g = pxl[1] + 255.f * (1.f - t); pxl[1] = std::min(g, 255); } } } } img.SaveFile(path, wxBITMAP_TYPE_PNG); } #endif /* SLIC3R_GUI */ } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/EdgeGrid.hpp000066400000000000000000000072601301441720000217750ustar00rootroot00000000000000#ifndef slic3r_EdgeGrid_hpp_ #define slic3r_EdgeGrid_hpp_ #include #include #include "Point.hpp" #include "BoundingBox.hpp" #include "ExPolygon.hpp" #include "ExPolygonCollection.hpp" namespace Slic3r { namespace EdgeGrid { struct Grid { Grid(); ~Grid(); void create(const Polygons &polygons, coord_t resolution); void create(const ExPolygon &expoly, coord_t resolution); void create(const ExPolygons &expolygons, coord_t resolution); void create(const ExPolygonCollection &expolygons, coord_t resolution); #if 0 // Test, whether the edges inside the grid intersect with the polygons provided. bool intersect(const MultiPoint &polyline, bool closed); bool intersect(const Polygon &polygon) { return intersect(static_cast(polygon), true); } bool intersect(const Polygons &polygons) { for (size_t i = 0; i < polygons.size(); ++ i) if (intersect(polygons[i])) return true; return false; } bool intersect(const ExPolygon &expoly) { if (intersect(expoly.contour)) return true; for (size_t i = 0; i < expoly.holes.size(); ++ i) if (intersect(expoly.holes[i])) return true; return false; } bool intersect(const ExPolygons &expolygons) { for (size_t i = 0; i < expolygons.size(); ++ i) if (intersect(expolygons[i])) return true; return false; } bool intersect(const ExPolygonCollection &expolygons) { return intersect(expolygons.expolygons); } // Test, whether a point is inside a contour. bool inside(const Point &pt); #endif // Fill in a rough m_signed_distance_field from the edge grid. // The rough SDF is used by signed_distance() for distances outside of the search_radius. void calculate_sdf(); // Return an estimate of the signed distance based on m_signed_distance_field grid. float signed_distance_bilinear(const Point &pt) const; // Calculate a signed distance to the contours in search_radius from the point. bool signed_distance_edges(const Point &pt, coord_t search_radius, coordf_t &result_min_dist, bool *pon_segment = NULL) const; // Calculate a signed distance to the contours in search_radius from the point. If no edge is found in search_radius, // return an interpolated value from m_signed_distance_field, if it exists. bool signed_distance(const Point &pt, coord_t search_radius, coordf_t &result_min_dist) const; const BoundingBox& bbox() const { return m_bbox; } const coord_t resolution() const { return m_resolution; } const size_t rows() const { return m_rows; } const size_t cols() const { return m_cols; } protected: struct Cell { Cell() : begin(0), end(0) {} size_t begin; size_t end; }; void create_from_m_contours(coord_t resolution); #if 0 bool line_cell_intersect(const Point &p1, const Point &p2, const Cell &cell); #endif // Bounding box around the contours. BoundingBox m_bbox; // Grid dimensions. coord_t m_resolution; size_t m_rows; size_t m_cols; // Referencing the source contours. // This format allows one to work with any Slic3r fixed point contour format // (Polygon, ExPolygon, ExPolygonCollection etc). std::vector m_contours; // Referencing a contour and a line segment of m_contours. std::vector > m_cell_data; // Full grid of cells. std::vector m_cells; // Distance field derived from the edge grid, seed filled by the Danielsson chamfer metric. // May be empty. std::vector m_signed_distance_field; }; #ifdef SLIC3R_GUI // Debugging utility. Save the signed distance field. extern void save_png(const Grid &grid, const BoundingBox &bbox, coord_t resolution, const char *path); #endif /* SLIC3R_GUI */ } // namespace EdgeGrid } // namespace Slic3r #endif /* slic3r_EdgeGrid_hpp_ */ Slic3r-version_1.31.6/xs/src/libslic3r/ExPolygon.cpp000066400000000000000000000457011301441720000222440ustar00rootroot00000000000000#include "BoundingBox.hpp" #include "ExPolygon.hpp" #include "Geometry.hpp" #include "Polygon.hpp" #include "Line.hpp" #include "ClipperUtils.hpp" #include "SVG.hpp" #include "polypartition.h" #include "poly2tri/poly2tri.h" #include #include #include namespace Slic3r { ExPolygon::operator Points() const { Points points; Polygons pp = *this; for (Polygons::const_iterator poly = pp.begin(); poly != pp.end(); ++poly) { for (Points::const_iterator point = poly->points.begin(); point != poly->points.end(); ++point) points.push_back(*point); } return points; } ExPolygon::operator Polygons() const { return to_polygons(*this); } ExPolygon::operator Polylines() const { return to_polylines(*this); } void ExPolygon::scale(double factor) { contour.scale(factor); for (Polygons::iterator it = holes.begin(); it != holes.end(); ++it) { (*it).scale(factor); } } void ExPolygon::translate(double x, double y) { contour.translate(x, y); for (Polygons::iterator it = holes.begin(); it != holes.end(); ++it) { (*it).translate(x, y); } } void ExPolygon::rotate(double angle) { contour.rotate(angle); for (Polygons::iterator it = holes.begin(); it != holes.end(); ++it) { (*it).rotate(angle); } } void ExPolygon::rotate(double angle, const Point ¢er) { contour.rotate(angle, center); for (Polygons::iterator it = holes.begin(); it != holes.end(); ++it) { (*it).rotate(angle, center); } } double ExPolygon::area() const { double a = this->contour.area(); for (Polygons::const_iterator it = this->holes.begin(); it != this->holes.end(); ++it) { a -= -(*it).area(); // holes have negative area } return a; } bool ExPolygon::is_valid() const { if (!this->contour.is_valid() || !this->contour.is_counter_clockwise()) return false; for (Polygons::const_iterator it = this->holes.begin(); it != this->holes.end(); ++it) { if (!(*it).is_valid() || (*it).is_counter_clockwise()) return false; } return true; } bool ExPolygon::contains(const Line &line) const { return this->contains((Polyline)line); } bool ExPolygon::contains(const Polyline &polyline) const { Polylines pl_out; diff((Polylines)polyline, *this, &pl_out); return pl_out.empty(); } bool ExPolygon::contains(const Polylines &polylines) const { #if 0 BoundingBox bbox = get_extents(polylines); bbox.merge(get_extents(*this)); SVG svg(debug_out_path("ExPolygon_contains.svg"), bbox); svg.draw(*this); svg.draw_outline(*this); svg.draw(polylines, "blue"); #endif Polylines pl_out; diff(polylines, *this, &pl_out); #if 0 svg.draw(pl_out, "red"); #endif return pl_out.empty(); } bool ExPolygon::contains(const Point &point) const { if (!this->contour.contains(point)) return false; for (Polygons::const_iterator it = this->holes.begin(); it != this->holes.end(); ++it) { if (it->contains(point)) return false; } return true; } // inclusive version of contains() that also checks whether point is on boundaries bool ExPolygon::contains_b(const Point &point) const { return this->contains(point) || this->has_boundary_point(point); } bool ExPolygon::has_boundary_point(const Point &point) const { if (this->contour.has_boundary_point(point)) return true; for (Polygons::const_iterator h = this->holes.begin(); h != this->holes.end(); ++h) { if (h->has_boundary_point(point)) return true; } return false; } bool ExPolygon::overlaps(const ExPolygon &other) const { #if 0 BoundingBox bbox = get_extents(other); bbox.merge(get_extents(*this)); static int iRun = 0; SVG svg(debug_out_path("ExPolygon_overlaps-%d.svg", iRun ++), bbox); svg.draw(*this); svg.draw_outline(*this); svg.draw_outline(other, "blue"); #endif Polylines pl_out; intersection((Polylines)other, *this, &pl_out); #if 0 svg.draw(pl_out, "red"); #endif if (! pl_out.empty()) return true; return ! other.contour.points.empty() && this->contains_b(other.contour.points.front()); } void ExPolygon::simplify_p(double tolerance, Polygons* polygons) const { Polygons pp = this->simplify_p(tolerance); polygons->insert(polygons->end(), pp.begin(), pp.end()); } Polygons ExPolygon::simplify_p(double tolerance) const { Polygons pp; pp.reserve(this->holes.size() + 1); // contour { Polygon p = this->contour; p.points.push_back(p.points.front()); p.points = MultiPoint::_douglas_peucker(p.points, tolerance); p.points.pop_back(); pp.push_back(p); } // holes for (Polygons::const_iterator it = this->holes.begin(); it != this->holes.end(); ++it) { Polygon p = *it; p.points.push_back(p.points.front()); p.points = MultiPoint::_douglas_peucker(p.points, tolerance); p.points.pop_back(); pp.push_back(p); } simplify_polygons(pp, &pp); return pp; } ExPolygons ExPolygon::simplify(double tolerance) const { Polygons pp = this->simplify_p(tolerance); return union_ex(pp); } void ExPolygon::simplify(double tolerance, ExPolygons* expolygons) const { ExPolygons ep = this->simplify(tolerance); expolygons->insert(expolygons->end(), ep.begin(), ep.end()); } void ExPolygon::medial_axis(double max_width, double min_width, ThickPolylines* polylines) const { // init helper object Slic3r::Geometry::MedialAxis ma(max_width, min_width, this); ma.lines = this->lines(); // compute the Voronoi diagram and extract medial axis polylines ThickPolylines pp; ma.build(&pp); /* SVG svg("medial_axis.svg"); svg.draw(*this); svg.draw(pp); svg.Close(); */ /* Find the maximum width returned; we're going to use this for validating and filtering the output segments. */ double max_w = 0; for (ThickPolylines::const_iterator it = pp.begin(); it != pp.end(); ++it) max_w = fmaxf(max_w, *std::max_element(it->width.begin(), it->width.end())); /* Loop through all returned polylines in order to extend their endpoints to the expolygon boundaries */ bool removed = false; for (size_t i = 0; i < pp.size(); ++i) { ThickPolyline& polyline = pp[i]; // extend initial and final segments of each polyline if they're actual endpoints /* We assign new endpoints to temporary variables because in case of a single-line polyline, after we extend the start point it will be caught by the intersection() call, so we keep the inner point until we perform the second intersection() as well */ Point new_front = polyline.points.front(); Point new_back = polyline.points.back(); if (polyline.endpoints.first && !this->has_boundary_point(new_front)) { Line line(polyline.points.front(), polyline.points[1]); // prevent the line from touching on the other side, otherwise intersection() might return that solution if (polyline.points.size() == 2) line.b = line.midpoint(); line.extend_start(max_width); (void)this->contour.intersection(line, &new_front); } if (polyline.endpoints.second && !this->has_boundary_point(new_back)) { Line line( *(polyline.points.end() - 2), polyline.points.back() ); // prevent the line from touching on the other side, otherwise intersection() might return that solution if (polyline.points.size() == 2) line.a = line.midpoint(); line.extend_end(max_width); (void)this->contour.intersection(line, &new_back); } polyline.points.front() = new_front; polyline.points.back() = new_back; /* remove too short polylines (we can't do this check before endpoints extension and clipping because we don't know how long will the endpoints be extended since it depends on polygon thickness which is variable - extension will be <= max_width/2 on each side) */ if ((polyline.endpoints.first || polyline.endpoints.second) && polyline.length() < max_w*2) { pp.erase(pp.begin() + i); --i; removed = true; continue; } } /* If we removed any short polylines we now try to connect consecutive polylines in order to allow loop detection. Note that this algorithm is greedier than MedialAxis::process_edge_neighbors() as it will connect random pairs of polylines even when more than two start from the same point. This has no drawbacks since we optimize later using nearest-neighbor which would do the same, but should we use a more sophisticated optimization algorithm we should not connect polylines when more than two meet. */ if (removed) { for (size_t i = 0; i < pp.size(); ++i) { ThickPolyline& polyline = pp[i]; if (polyline.endpoints.first && polyline.endpoints.second) continue; // optimization // find another polyline starting here for (size_t j = i+1; j < pp.size(); ++j) { ThickPolyline& other = pp[j]; if (polyline.last_point().coincides_with(other.last_point())) { other.reverse(); } else if (polyline.first_point().coincides_with(other.last_point())) { polyline.reverse(); other.reverse(); } else if (polyline.first_point().coincides_with(other.first_point())) { polyline.reverse(); } else if (!polyline.last_point().coincides_with(other.first_point())) { continue; } polyline.points.insert(polyline.points.end(), other.points.begin() + 1, other.points.end()); polyline.width.insert(polyline.width.end(), other.width.begin(), other.width.end()); polyline.endpoints.second = other.endpoints.second; assert(polyline.width.size() == polyline.points.size()*2 - 2); pp.erase(pp.begin() + j); j = i; // restart search from i+1 } } } polylines->insert(polylines->end(), pp.begin(), pp.end()); } void ExPolygon::medial_axis(double max_width, double min_width, Polylines* polylines) const { ThickPolylines tp; this->medial_axis(max_width, min_width, &tp); polylines->insert(polylines->end(), tp.begin(), tp.end()); } void ExPolygon::get_trapezoids(Polygons* polygons) const { ExPolygons expp; expp.push_back(*this); boost::polygon::get_trapezoids(*polygons, expp); } void ExPolygon::get_trapezoids(Polygons* polygons, double angle) const { ExPolygon clone = *this; clone.rotate(PI/2 - angle, Point(0,0)); clone.get_trapezoids(polygons); for (Polygons::iterator polygon = polygons->begin(); polygon != polygons->end(); ++polygon) polygon->rotate(-(PI/2 - angle), Point(0,0)); } // This algorithm may return more trapezoids than necessary // (i.e. it may break a single trapezoid in several because // other parts of the object have x coordinates in the middle) void ExPolygon::get_trapezoids2(Polygons* polygons) const { // get all points of this ExPolygon Points pp = *this; // build our bounding box BoundingBox bb(pp); // get all x coordinates std::vector xx; xx.reserve(pp.size()); for (Points::const_iterator p = pp.begin(); p != pp.end(); ++p) xx.push_back(p->x); std::sort(xx.begin(), xx.end()); // find trapezoids by looping from first to next-to-last coordinate for (std::vector::const_iterator x = xx.begin(); x != xx.end()-1; ++x) { coord_t next_x = *(x + 1); if (*x == next_x) continue; // build rectangle Polygon poly; poly.points.resize(4); poly[0].x = *x; poly[0].y = bb.min.y; poly[1].x = next_x; poly[1].y = bb.min.y; poly[2].x = next_x; poly[2].y = bb.max.y; poly[3].x = *x; poly[3].y = bb.max.y; // intersect with this expolygon Polygons trapezoids; intersection(poly, *this, &trapezoids); // append results to return value polygons->insert(polygons->end(), trapezoids.begin(), trapezoids.end()); } } void ExPolygon::get_trapezoids2(Polygons* polygons, double angle) const { ExPolygon clone = *this; clone.rotate(PI/2 - angle, Point(0,0)); clone.get_trapezoids2(polygons); for (Polygons::iterator polygon = polygons->begin(); polygon != polygons->end(); ++polygon) polygon->rotate(-(PI/2 - angle), Point(0,0)); } // While this triangulates successfully, it's NOT a constrained triangulation // as it will create more vertices on the boundaries than the ones supplied. void ExPolygon::triangulate(Polygons* polygons) const { // first make trapezoids Polygons trapezoids; this->get_trapezoids2(&trapezoids); // then triangulate each trapezoid for (Polygons::iterator polygon = trapezoids.begin(); polygon != trapezoids.end(); ++polygon) polygon->triangulate_convex(polygons); } void ExPolygon::triangulate_pp(Polygons* polygons) const { // convert polygons std::list input; Polygons pp = *this; simplify_polygons(pp, &pp, true); ExPolygons expp; union_(pp, &expp); for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex) { // contour { TPPLPoly p; p.Init(ex->contour.points.size()); //printf(PRINTF_ZU "\n0\n", ex->contour.points.size()); for (Points::const_iterator point = ex->contour.points.begin(); point != ex->contour.points.end(); ++point) { p[ point-ex->contour.points.begin() ].x = point->x; p[ point-ex->contour.points.begin() ].y = point->y; //printf("%ld %ld\n", point->x, point->y); } p.SetHole(false); input.push_back(p); } // holes for (Polygons::const_iterator hole = ex->holes.begin(); hole != ex->holes.end(); ++hole) { TPPLPoly p; p.Init(hole->points.size()); //printf(PRINTF_ZU "\n1\n", hole->points.size()); for (Points::const_iterator point = hole->points.begin(); point != hole->points.end(); ++point) { p[ point-hole->points.begin() ].x = point->x; p[ point-hole->points.begin() ].y = point->y; //printf("%ld %ld\n", point->x, point->y); } p.SetHole(true); input.push_back(p); } } // perform triangulation std::list output; int res = TPPLPartition().Triangulate_MONO(&input, &output); if (res != 1) CONFESS("Triangulation failed"); // convert output polygons for (std::list::iterator poly = output.begin(); poly != output.end(); ++poly) { long num_points = poly->GetNumPoints(); Polygon p; p.points.resize(num_points); for (long i = 0; i < num_points; ++i) { p.points[i].x = (*poly)[i].x; p.points[i].y = (*poly)[i].y; } polygons->push_back(p); } } void ExPolygon::triangulate_p2t(Polygons* polygons) const { ExPolygons expp; simplify_polygons(*this, &expp, true); for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex) { // TODO: prevent duplicate points // contour std::vector ContourPoints; for (Points::const_iterator point = ex->contour.points.begin(); point != ex->contour.points.end(); ++point) { // We should delete each p2t::Point object ContourPoints.push_back(new p2t::Point(point->x, point->y)); } p2t::CDT cdt(ContourPoints); // holes for (Polygons::const_iterator hole = ex->holes.begin(); hole != ex->holes.end(); ++hole) { std::vector points; for (Points::const_iterator point = hole->points.begin(); point != hole->points.end(); ++point) { // will be destructed in SweepContext::~SweepContext points.push_back(new p2t::Point(point->x, point->y)); } cdt.AddHole(points); } // perform triangulation cdt.Triangulate(); std::vector triangles = cdt.GetTriangles(); for (std::vector::const_iterator triangle = triangles.begin(); triangle != triangles.end(); ++triangle) { Polygon p; for (int i = 0; i <= 2; ++i) { p2t::Point* point = (*triangle)->GetPoint(i); p.points.push_back(Point(point->x, point->y)); } polygons->push_back(p); } for(std::vector::iterator it = ContourPoints.begin(); it != ContourPoints.end(); ++it) { delete *it; } } } Lines ExPolygon::lines() const { Lines lines = this->contour.lines(); for (Polygons::const_iterator h = this->holes.begin(); h != this->holes.end(); ++h) { Lines hole_lines = h->lines(); lines.insert(lines.end(), hole_lines.begin(), hole_lines.end()); } return lines; } std::string ExPolygon::dump_perl() const { std::ostringstream ret; ret << "[" << this->contour.dump_perl(); for (Polygons::const_iterator h = this->holes.begin(); h != this->holes.end(); ++h) ret << "," << h->dump_perl(); ret << "]"; return ret.str(); } BoundingBox get_extents(const ExPolygon &expolygon) { return get_extents(expolygon.contour); } BoundingBox get_extents(const ExPolygons &expolygons) { BoundingBox bbox; if (! expolygons.empty()) { bbox = get_extents(expolygons.front()); for (size_t i = 1; i < expolygons.size(); ++ i) bbox.merge(get_extents(expolygons[i])); } return bbox; } BoundingBox get_extents_rotated(const ExPolygon &expolygon, double angle) { return get_extents_rotated(expolygon.contour, angle); } BoundingBox get_extents_rotated(const ExPolygons &expolygons, double angle) { BoundingBox bbox; if (! expolygons.empty()) { bbox = get_extents_rotated(expolygons.front().contour, angle); for (size_t i = 1; i < expolygons.size(); ++ i) bbox.merge(get_extents_rotated(expolygons[i].contour, angle)); } return bbox; } extern std::vector get_extents_vector(const ExPolygons &polygons) { std::vector out; out.reserve(polygons.size()); for (ExPolygons::const_iterator it = polygons.begin(); it != polygons.end(); ++ it) out.push_back(get_extents(*it)); return out; } bool remove_sticks(ExPolygon &poly) { return remove_sticks(poly.contour) || remove_sticks(poly.holes); } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/ExPolygon.hpp000066400000000000000000000321751301441720000222520ustar00rootroot00000000000000#ifndef slic3r_ExPolygon_hpp_ #define slic3r_ExPolygon_hpp_ #include "libslic3r.h" #include "Polygon.hpp" #include "Polyline.hpp" #include namespace Slic3r { class ExPolygon; typedef std::vector ExPolygons; class ExPolygon { public: Polygon contour; Polygons holes; operator Points() const; operator Polygons() const; operator Polylines() const; void clear() { contour.points.clear(); holes.clear(); } void scale(double factor); void translate(double x, double y); void rotate(double angle); void rotate(double angle, const Point ¢er); double area() const; bool empty() const { return contour.points.empty(); } bool is_valid() const; // Contains the line / polyline / polylines etc COMPLETELY. bool contains(const Line &line) const; bool contains(const Polyline &polyline) const; bool contains(const Polylines &polylines) const; bool contains(const Point &point) const; bool contains_b(const Point &point) const; bool has_boundary_point(const Point &point) const; // Does this expolygon overlap another expolygon? // Either the ExPolygons intersect, or one is fully inside the other, // and it is not inside a hole of the other expolygon. bool overlaps(const ExPolygon &other) const; void simplify_p(double tolerance, Polygons* polygons) const; Polygons simplify_p(double tolerance) const; ExPolygons simplify(double tolerance) const; void simplify(double tolerance, ExPolygons* expolygons) const; void medial_axis(double max_width, double min_width, ThickPolylines* polylines) const; void medial_axis(double max_width, double min_width, Polylines* polylines) const; void get_trapezoids(Polygons* polygons) const; void get_trapezoids(Polygons* polygons, double angle) const; void get_trapezoids2(Polygons* polygons) const; void get_trapezoids2(Polygons* polygons, double angle) const; void triangulate(Polygons* polygons) const; void triangulate_pp(Polygons* polygons) const; void triangulate_p2t(Polygons* polygons) const; Lines lines() const; std::string dump_perl() const; }; // Count a nuber of polygons stored inside the vector of expolygons. // Useful for allocating space for polygons when converting expolygons to polygons. inline size_t number_polygons(const ExPolygons &expolys) { size_t n_polygons = 0; for (ExPolygons::const_iterator it = expolys.begin(); it != expolys.end(); ++ it) n_polygons += it->holes.size() + 1; return n_polygons; } inline Lines to_lines(const ExPolygon &src) { size_t n_lines = src.contour.points.size(); for (size_t i = 0; i < src.holes.size(); ++ i) n_lines += src.holes[i].points.size(); Lines lines; lines.reserve(n_lines); for (size_t i = 0; i <= src.holes.size(); ++ i) { const Polygon &poly = (i == 0) ? src.contour : src.holes[i - 1]; for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it) lines.push_back(Line(*it, *(it + 1))); lines.push_back(Line(poly.points.back(), poly.points.front())); } return lines; } inline Lines to_lines(const ExPolygons &src) { size_t n_lines = 0; for (ExPolygons::const_iterator it_expoly = src.begin(); it_expoly != src.end(); ++ it_expoly) { n_lines += it_expoly->contour.points.size(); for (size_t i = 0; i < it_expoly->holes.size(); ++ i) n_lines += it_expoly->holes[i].points.size(); } Lines lines; lines.reserve(n_lines); for (ExPolygons::const_iterator it_expoly = src.begin(); it_expoly != src.end(); ++ it_expoly) { for (size_t i = 0; i <= it_expoly->holes.size(); ++ i) { const Points &points = ((i == 0) ? it_expoly->contour : it_expoly->holes[i - 1]).points; for (Points::const_iterator it = points.begin(); it != points.end()-1; ++it) lines.push_back(Line(*it, *(it + 1))); lines.push_back(Line(points.back(), points.front())); } } return lines; } inline Polylines to_polylines(const ExPolygon &src) { Polylines polylines; polylines.assign(src.holes.size() + 1, Polyline()); size_t idx = 0; Polyline &pl = polylines[idx ++]; pl.points = src.contour.points; pl.points.push_back(pl.points.front()); for (Polygons::const_iterator ith = src.holes.begin(); ith != src.holes.end(); ++ith) { Polyline &pl = polylines[idx ++]; pl.points = ith->points; pl.points.push_back(ith->points.front()); } assert(idx == polylines.size()); return polylines; } inline Polylines to_polylines(const ExPolygons &src) { Polylines polylines; polylines.assign(number_polygons(src), Polyline()); size_t idx = 0; for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++it) { Polyline &pl = polylines[idx ++]; pl.points = it->contour.points; pl.points.push_back(pl.points.front()); for (Polygons::const_iterator ith = it->holes.begin(); ith != it->holes.end(); ++ith) { Polyline &pl = polylines[idx ++]; pl.points = ith->points; pl.points.push_back(ith->points.front()); } } assert(idx == polylines.size()); return polylines; } #if SLIC3R_CPPVER >= 11 inline Polylines to_polylines(ExPolygon &&src) { Polylines polylines; polylines.assign(src.holes.size() + 1, Polyline()); size_t idx = 0; Polyline &pl = polylines[idx ++]; pl.points = std::move(src.contour.points); pl.points.push_back(pl.points.front()); for (Polygons::const_iterator ith = src.holes.begin(); ith != src.holes.end(); ++ith) { Polyline &pl = polylines[idx ++]; pl.points = std::move(ith->points); pl.points.push_back(ith->points.front()); } assert(idx == polylines.size()); return polylines; } inline Polylines to_polylines(ExPolygons &&src) { Polylines polylines; polylines.assign(number_polygons(src), Polyline()); size_t idx = 0; for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++it) { Polyline &pl = polylines[idx ++]; pl.points = std::move(it->contour.points); pl.points.push_back(pl.points.front()); for (Polygons::const_iterator ith = it->holes.begin(); ith != it->holes.end(); ++ith) { Polyline &pl = polylines[idx ++]; pl.points = std::move(ith->points); pl.points.push_back(ith->points.front()); } } assert(idx == polylines.size()); return polylines; } #endif inline Polygons to_polygons(const ExPolygon &src) { Polygons polygons; polygons.reserve(src.holes.size() + 1); polygons.push_back(src.contour); polygons.insert(polygons.end(), src.holes.begin(), src.holes.end()); return polygons; } inline Polygons to_polygons(const ExPolygons &src) { Polygons polygons; polygons.reserve(number_polygons(src)); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++it) { polygons.push_back(it->contour); polygons.insert(polygons.end(), it->holes.begin(), it->holes.end()); } return polygons; } #if SLIC3R_CPPVER >= 11 inline Polygons to_polygons(ExPolygon &&src) { Polygons polygons; polygons.reserve(src.holes.size() + 1); polygons.push_back(std::move(src.contour)); std::move(std::begin(src.holes), std::end(src.holes), std::back_inserter(polygons)); return polygons; } inline Polygons to_polygons(ExPolygons &&src) { Polygons polygons; polygons.reserve(number_polygons(src)); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++it) { polygons.push_back(std::move(it->contour)); std::move(std::begin(it->holes), std::end(it->holes), std::back_inserter(polygons)); } return polygons; } #endif inline void polygons_append(Polygons &dst, const ExPolygon &src) { dst.reserve(dst.size() + src.holes.size() + 1); dst.push_back(src.contour); dst.insert(dst.end(), src.holes.begin(), src.holes.end()); } inline void polygons_append(Polygons &dst, const ExPolygons &src) { dst.reserve(dst.size() + number_polygons(src)); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++ it) { dst.push_back(it->contour); dst.insert(dst.end(), it->holes.begin(), it->holes.end()); } } #if SLIC3R_CPPVER >= 11 inline void polygons_append(Polygons &dst, ExPolygon &&src) { dst.reserve(dst.size() + src.holes.size() + 1); dst.push_back(std::move(src.contour)); std::move(std::begin(src.holes), std::end(src.holes), std::back_inserter(dst)); } inline void polygons_append(Polygons &dst, ExPolygons &&src) { dst.reserve(dst.size() + number_polygons(src)); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++ it) { dst.push_back(std::move(it->contour)); std::move(std::begin(it->holes), std::end(it->holes), std::back_inserter(dst)); } } #endif inline void expolygons_rotate(ExPolygons &expolys, double angle) { for (ExPolygons::iterator p = expolys.begin(); p != expolys.end(); ++p) p->rotate(angle); } inline bool expolygons_contain(ExPolygons &expolys, const Point &pt) { for (ExPolygons::iterator p = expolys.begin(); p != expolys.end(); ++p) if (p->contains(pt)) return true; return false; } extern BoundingBox get_extents(const ExPolygon &expolygon); extern BoundingBox get_extents(const ExPolygons &expolygons); extern BoundingBox get_extents_rotated(const ExPolygon &poly, double angle); extern BoundingBox get_extents_rotated(const ExPolygons &polygons, double angle); extern std::vector get_extents_vector(const ExPolygons &polygons); extern bool remove_sticks(ExPolygon &poly); } // namespace Slic3r // start Boost #include namespace boost { namespace polygon { template <> struct polygon_traits { typedef coord_t coordinate_type; typedef Points::const_iterator iterator_type; typedef Point point_type; // Get the begin iterator static inline iterator_type begin_points(const ExPolygon& t) { return t.contour.points.begin(); } // Get the end iterator static inline iterator_type end_points(const ExPolygon& t) { return t.contour.points.end(); } // Get the number of sides of the polygon static inline std::size_t size(const ExPolygon& t) { return t.contour.points.size(); } // Get the winding direction of the polygon static inline winding_direction winding(const ExPolygon& t) { return unknown_winding; } }; template <> struct polygon_mutable_traits { //expects stl style iterators template static inline ExPolygon& set_points(ExPolygon& expolygon, iT input_begin, iT input_end) { expolygon.contour.points.assign(input_begin, input_end); // skip last point since Boost will set last point = first point expolygon.contour.points.pop_back(); return expolygon; } }; template <> struct geometry_concept { typedef polygon_with_holes_concept type; }; template <> struct polygon_with_holes_traits { typedef Polygons::const_iterator iterator_holes_type; typedef Polygon hole_type; static inline iterator_holes_type begin_holes(const ExPolygon& t) { return t.holes.begin(); } static inline iterator_holes_type end_holes(const ExPolygon& t) { return t.holes.end(); } static inline unsigned int size_holes(const ExPolygon& t) { return (int)t.holes.size(); } }; template <> struct polygon_with_holes_mutable_traits { template static inline ExPolygon& set_holes(ExPolygon& t, iT inputBegin, iT inputEnd) { t.holes.assign(inputBegin, inputEnd); return t; } }; //first we register CPolygonSet as a polygon set template <> struct geometry_concept { typedef polygon_set_concept type; }; //next we map to the concept through traits template <> struct polygon_set_traits { typedef coord_t coordinate_type; typedef ExPolygons::const_iterator iterator_type; typedef ExPolygons operator_arg_type; static inline iterator_type begin(const ExPolygons& polygon_set) { return polygon_set.begin(); } static inline iterator_type end(const ExPolygons& polygon_set) { return polygon_set.end(); } //don't worry about these, just return false from them static inline bool clean(const ExPolygons& polygon_set) { return false; } static inline bool sorted(const ExPolygons& polygon_set) { return false; } }; template <> struct polygon_set_mutable_traits { template static inline void set(ExPolygons& expolygons, input_iterator_type input_begin, input_iterator_type input_end) { expolygons.assign(input_begin, input_end); } }; } } // end Boost #endif Slic3r-version_1.31.6/xs/src/libslic3r/ExPolygonCollection.cpp000066400000000000000000000071721301441720000242600ustar00rootroot00000000000000#include "ExPolygonCollection.hpp" #include "Geometry.hpp" namespace Slic3r { ExPolygonCollection::ExPolygonCollection(const ExPolygon &expolygon) { this->expolygons.push_back(expolygon); } ExPolygonCollection::operator Points() const { Points points; Polygons pp = *this; for (Polygons::const_iterator poly = pp.begin(); poly != pp.end(); ++poly) { for (Points::const_iterator point = poly->points.begin(); point != poly->points.end(); ++point) points.push_back(*point); } return points; } ExPolygonCollection::operator Polygons() const { Polygons polygons; for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) { polygons.push_back(it->contour); for (Polygons::const_iterator ith = it->holes.begin(); ith != it->holes.end(); ++ith) { polygons.push_back(*ith); } } return polygons; } ExPolygonCollection::operator ExPolygons&() { return this->expolygons; } void ExPolygonCollection::scale(double factor) { for (ExPolygons::iterator it = expolygons.begin(); it != expolygons.end(); ++it) { (*it).scale(factor); } } void ExPolygonCollection::translate(double x, double y) { for (ExPolygons::iterator it = expolygons.begin(); it != expolygons.end(); ++it) { (*it).translate(x, y); } } void ExPolygonCollection::rotate(double angle, const Point ¢er) { for (ExPolygons::iterator it = expolygons.begin(); it != expolygons.end(); ++it) { (*it).rotate(angle, center); } } template bool ExPolygonCollection::contains(const T &item) const { for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) { if (it->contains(item)) return true; } return false; } template bool ExPolygonCollection::contains(const Point &item) const; template bool ExPolygonCollection::contains(const Line &item) const; template bool ExPolygonCollection::contains(const Polyline &item) const; bool ExPolygonCollection::contains_b(const Point &point) const { for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) { if (it->contains_b(point)) return true; } return false; } void ExPolygonCollection::simplify(double tolerance) { ExPolygons expp; for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) { it->simplify(tolerance, &expp); } this->expolygons = expp; } Polygon ExPolygonCollection::convex_hull() const { Points pp; for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) pp.insert(pp.end(), it->contour.points.begin(), it->contour.points.end()); return Slic3r::Geometry::convex_hull(pp); } Lines ExPolygonCollection::lines() const { Lines lines; for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) { Lines ex_lines = it->lines(); lines.insert(lines.end(), ex_lines.begin(), ex_lines.end()); } return lines; } Polygons ExPolygonCollection::contours() const { Polygons contours; contours.reserve(this->expolygons.size()); for (ExPolygons::const_iterator it = this->expolygons.begin(); it != this->expolygons.end(); ++it) contours.push_back(it->contour); return contours; } void ExPolygonCollection::append(const ExPolygons &expp) { this->expolygons.insert(this->expolygons.end(), expp.begin(), expp.end()); } BoundingBox get_extents(const ExPolygonCollection &expolygon) { return get_extents(expolygon.expolygons); } } Slic3r-version_1.31.6/xs/src/libslic3r/ExPolygonCollection.hpp000066400000000000000000000021121301441720000242520ustar00rootroot00000000000000#ifndef slic3r_ExPolygonCollection_hpp_ #define slic3r_ExPolygonCollection_hpp_ #include "libslic3r.h" #include "ExPolygon.hpp" #include "Line.hpp" #include "Polyline.hpp" namespace Slic3r { class ExPolygonCollection; typedef std::vector ExPolygonCollections; class ExPolygonCollection { public: ExPolygons expolygons; ExPolygonCollection() {}; ExPolygonCollection(const ExPolygon &expolygon); ExPolygonCollection(const ExPolygons &expolygons) : expolygons(expolygons) {}; operator Points() const; operator Polygons() const; operator ExPolygons&(); void scale(double factor); void translate(double x, double y); void rotate(double angle, const Point ¢er); template bool contains(const T &item) const; bool contains_b(const Point &point) const; void simplify(double tolerance); Polygon convex_hull() const; Lines lines() const; Polygons contours() const; void append(const ExPolygons &expolygons); }; extern BoundingBox get_extents(const ExPolygonCollection &expolygon); } #endif Slic3r-version_1.31.6/xs/src/libslic3r/Extruder.cpp000066400000000000000000000074041301441720000221200ustar00rootroot00000000000000#include "Extruder.hpp" namespace Slic3r { Extruder::Extruder(unsigned int id, GCodeConfig *config) : id(id), config(config) { reset(); // cache values that are going to be called often if (config->use_volumetric_e) { this->e_per_mm3 = this->extrusion_multiplier(); } else { this->e_per_mm3 = this->extrusion_multiplier() * (4 / ((this->filament_diameter() * this->filament_diameter()) * PI)); } this->retract_speed_mm_min = this->retract_speed() * 60; } void Extruder::reset() { this->E = 0; this->absolute_E = 0; this->retracted = 0; this->restart_extra = 0; } double Extruder::extrude(double dE) { // in case of relative E distances we always reset to 0 before any output if (this->config->use_relative_e_distances) this->E = 0; this->E += dE; this->absolute_E += dE; return dE; } /* This method makes sure the extruder is retracted by the specified amount of filament and returns the amount of filament retracted. If the extruder is already retracted by the same or a greater amount, this method is a no-op. The restart_extra argument sets the extra length to be used for unretraction. If we're actually performing a retraction, any restart_extra value supplied will overwrite the previous one if any. */ double Extruder::retract(double length, double restart_extra) { // in case of relative E distances we always reset to 0 before any output if (this->config->use_relative_e_distances) this->E = 0; double to_retract = length - this->retracted; if (to_retract > 0) { this->E -= to_retract; this->absolute_E -= to_retract; this->retracted += to_retract; this->restart_extra = restart_extra; return to_retract; } else { return 0; } } double Extruder::unretract() { double dE = this->retracted + this->restart_extra; this->extrude(dE); this->retracted = 0; this->restart_extra = 0; return dE; } double Extruder::e_per_mm(double mm3_per_mm) const { return mm3_per_mm * this->e_per_mm3; } double Extruder::extruded_volume() const { if (this->config->use_volumetric_e) { // Any current amount of retraction should not affect used filament, since // it represents empty volume in the nozzle. We add it back to E. return this->absolute_E + this->retracted; } return this->used_filament() * (this->filament_diameter() * this->filament_diameter()) * PI/4; } double Extruder::used_filament() const { if (this->config->use_volumetric_e) { return this->extruded_volume() / (this->filament_diameter() * this->filament_diameter() * PI/4); } // Any current amount of retraction should not affect used filament, since // it represents empty volume in the nozzle. We add it back to E. return this->absolute_E + this->retracted; } double Extruder::filament_diameter() const { return this->config->filament_diameter.get_at(this->id); } double Extruder::extrusion_multiplier() const { return this->config->extrusion_multiplier.get_at(this->id); } double Extruder::retract_length() const { return this->config->retract_length.get_at(this->id); } double Extruder::retract_lift() const { return this->config->retract_lift.get_at(this->id); } int Extruder::retract_speed() const { return this->config->retract_speed.get_at(this->id); } double Extruder::retract_restart_extra() const { return this->config->retract_restart_extra.get_at(this->id); } double Extruder::retract_length_toolchange() const { return this->config->retract_length_toolchange.get_at(this->id); } double Extruder::retract_restart_extra_toolchange() const { return this->config->retract_restart_extra_toolchange.get_at(this->id); } } Slic3r-version_1.31.6/xs/src/libslic3r/Extruder.hpp000066400000000000000000000020341301441720000221170ustar00rootroot00000000000000#ifndef slic3r_Extruder_hpp_ #define slic3r_Extruder_hpp_ #include "libslic3r.h" #include "Point.hpp" #include "PrintConfig.hpp" namespace Slic3r { class Extruder { public: unsigned int id; double E; double absolute_E; double retracted; double restart_extra; double e_per_mm3; double retract_speed_mm_min; Extruder(unsigned int id, GCodeConfig *config); virtual ~Extruder() {} void reset(); double extrude(double dE); double retract(double length, double restart_extra); double unretract(); double e_per_mm(double mm3_per_mm) const; double extruded_volume() const; double used_filament() const; double filament_diameter() const; double extrusion_multiplier() const; double retract_length() const; double retract_lift() const; int retract_speed() const; double retract_restart_extra() const; double retract_length_toolchange() const; double retract_restart_extra_toolchange() const; private: GCodeConfig *config; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/ExtrusionEntity.cpp000066400000000000000000000213761301441720000235170ustar00rootroot00000000000000#include "ExtrusionEntity.hpp" #include "ExtrusionEntityCollection.hpp" #include "ExPolygonCollection.hpp" #include "ClipperUtils.hpp" #include "Extruder.hpp" #include "Flow.hpp" #include #include #include namespace Slic3r { void ExtrusionPath::intersect_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const { // perform clipping Polylines clipped; intersection(this->polyline, collection, &clipped); return this->_inflate_collection(clipped, retval); } void ExtrusionPath::subtract_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const { // perform clipping Polylines clipped; diff(this->polyline, collection, &clipped); return this->_inflate_collection(clipped, retval); } void ExtrusionPath::clip_end(double distance) { this->polyline.clip_end(distance); } void ExtrusionPath::simplify(double tolerance) { this->polyline.simplify(tolerance); } double ExtrusionPath::length() const { return this->polyline.length(); } void ExtrusionPath::_inflate_collection(const Polylines &polylines, ExtrusionEntityCollection* collection) const { for (Polylines::const_iterator it = polylines.begin(); it != polylines.end(); ++it) { ExtrusionPath* path = this->clone(); path->polyline = *it; collection->entities.push_back(path); } } void ExtrusionPath::polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const { Polygons tmp; offset(this->polyline, &tmp, scale_(this->width/2) + scaled_epsilon); polygons_append(out, STDMOVE(tmp)); } void ExtrusionPath::polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const { // Instantiating the Flow class to get the line spacing. // Don't know the nozzle diameter, setting to zero. It shall not matter it shall be optimized out by the compiler. Flow flow(this->width, this->height, 0.f, this->is_bridge()); Polygons tmp; offset(this->polyline, &tmp, 0.5f * flow.scaled_spacing() + scaled_epsilon); polygons_append(out, STDMOVE(tmp)); } bool ExtrusionLoop::make_clockwise() { bool was_ccw = this->polygon().is_counter_clockwise(); if (was_ccw) this->reverse(); return was_ccw; } bool ExtrusionLoop::make_counter_clockwise() { bool was_cw = this->polygon().is_clockwise(); if (was_cw) this->reverse(); return was_cw; } void ExtrusionLoop::reverse() { for (ExtrusionPaths::iterator path = this->paths.begin(); path != this->paths.end(); ++path) path->reverse(); std::reverse(this->paths.begin(), this->paths.end()); } Polygon ExtrusionLoop::polygon() const { Polygon polygon; for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) { // for each polyline, append all points except the last one (because it coincides with the first one of the next polyline) polygon.points.insert(polygon.points.end(), path->polyline.points.begin(), path->polyline.points.end()-1); } return polygon; } double ExtrusionLoop::length() const { double len = 0; for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) len += path->polyline.length(); return len; } bool ExtrusionLoop::split_at_vertex(const Point &point) { for (ExtrusionPaths::iterator path = this->paths.begin(); path != this->paths.end(); ++path) { int idx = path->polyline.find_point(point); if (idx != -1) { if (this->paths.size() == 1) { // just change the order of points path->polyline.points.insert(path->polyline.points.end(), path->polyline.points.begin() + 1, path->polyline.points.begin() + idx + 1); path->polyline.points.erase(path->polyline.points.begin(), path->polyline.points.begin() + idx); } else { // new paths list starts with the second half of current path ExtrusionPaths new_paths; new_paths.reserve(this->paths.size() + 1); { ExtrusionPath p = *path; p.polyline.points.erase(p.polyline.points.begin(), p.polyline.points.begin() + idx); if (p.polyline.is_valid()) new_paths.push_back(p); } // then we add all paths until the end of current path list new_paths.insert(new_paths.end(), path+1, this->paths.end()); // not including this path // then we add all paths since the beginning of current list up to the previous one new_paths.insert(new_paths.end(), this->paths.begin(), path); // not including this path // finally we add the first half of current path { ExtrusionPath p = *path; p.polyline.points.erase(p.polyline.points.begin() + idx + 1, p.polyline.points.end()); if (p.polyline.is_valid()) new_paths.push_back(p); } // we can now override the old path list with the new one and stop looping std::swap(this->paths, new_paths); } return true; } } return false; } void ExtrusionLoop::split_at(const Point &point) { if (this->paths.empty()) return; // find the closest path and closest point belonging to that path size_t path_idx = 0; Point p = this->paths.front().first_point(); double min = point.distance_to(p); for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) { Point p_tmp = point.projection_onto(path->polyline); double dist = point.distance_to(p_tmp); if (dist < min) { p = p_tmp; min = dist; path_idx = path - this->paths.begin(); } } // now split path_idx in two parts const ExtrusionPath &path = this->paths[path_idx]; ExtrusionPath p1(path.role, path.mm3_per_mm, path.width, path.height); ExtrusionPath p2(path.role, path.mm3_per_mm, path.width, path.height); path.polyline.split_at(p, &p1.polyline, &p2.polyline); if (this->paths.size() == 1) { if (! p1.polyline.is_valid()) std::swap(this->paths.front().polyline.points, p2.polyline.points); else if (! p2.polyline.is_valid()) std::swap(this->paths.front().polyline.points, p1.polyline.points); else { p2.polyline.points.insert(p2.polyline.points.end(), p1.polyline.points.begin() + 1, p1.polyline.points.end()); std::swap(this->paths.front().polyline.points, p2.polyline.points); } } else { // install the two paths this->paths.erase(this->paths.begin() + path_idx); if (p2.polyline.is_valid()) this->paths.insert(this->paths.begin() + path_idx, p2); if (p1.polyline.is_valid()) this->paths.insert(this->paths.begin() + path_idx, p1); } // split at the new vertex this->split_at_vertex(p); } void ExtrusionLoop::clip_end(double distance, ExtrusionPaths* paths) const { *paths = this->paths; while (distance > 0 && !paths->empty()) { ExtrusionPath &last = paths->back(); double len = last.length(); if (len <= distance) { paths->pop_back(); distance -= len; } else { last.polyline.clip_end(distance); break; } } } bool ExtrusionLoop::has_overhang_point(const Point &point) const { for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) { int pos = path->polyline.find_point(point); if (pos != -1) { // point belongs to this path // we consider it overhang only if it's not an endpoint return (path->is_bridge() && pos > 0 && pos != (int)(path->polyline.points.size())-1); } } return false; } void ExtrusionLoop::polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const { for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) path->polygons_covered_by_width(out, scaled_epsilon); } void ExtrusionLoop::polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const { for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) path->polygons_covered_by_spacing(out, scaled_epsilon); } double ExtrusionLoop::min_mm3_per_mm() const { double min_mm3_per_mm = std::numeric_limits::max(); for (ExtrusionPaths::const_iterator path = this->paths.begin(); path != this->paths.end(); ++path) min_mm3_per_mm = std::min(min_mm3_per_mm, path->mm3_per_mm); return min_mm3_per_mm; } } Slic3r-version_1.31.6/xs/src/libslic3r/ExtrusionEntity.hpp000066400000000000000000000224251301441720000235200ustar00rootroot00000000000000#ifndef slic3r_ExtrusionEntity_hpp_ #define slic3r_ExtrusionEntity_hpp_ #include "libslic3r.h" #include "Polygon.hpp" #include "Polyline.hpp" namespace Slic3r { class ExPolygonCollection; class ExtrusionEntityCollection; class Extruder; /* Each ExtrusionRole value identifies a distinct set of { extruder, speed } */ enum ExtrusionRole { erNone, erPerimeter, erExternalPerimeter, erOverhangPerimeter, erInternalInfill, erSolidInfill, erTopSolidInfill, erBridgeInfill, erGapFill, erSkirt, erSupportMaterial, erSupportMaterialInterface, }; /* Special flags describing loop */ enum ExtrusionLoopRole { elrDefault, elrContourInternalPerimeter, elrSkirt, }; class ExtrusionEntity { public: virtual bool is_collection() const { return false; } virtual bool is_loop() const { return false; } virtual bool can_reverse() const { return true; } virtual ExtrusionEntity* clone() const = 0; virtual ~ExtrusionEntity() {}; virtual void reverse() = 0; virtual Point first_point() const = 0; virtual Point last_point() const = 0; // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. virtual void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const = 0; // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion spacing. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. virtual void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const = 0; Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm. virtual double min_mm3_per_mm() const = 0; virtual Polyline as_polyline() const = 0; virtual double length() const = 0; }; typedef std::vector ExtrusionEntitiesPtr; class ExtrusionPath : public ExtrusionEntity { public: Polyline polyline; ExtrusionRole role; // Volumetric velocity. mm^3 of plastic per mm of linear head motion double mm3_per_mm; // Width of the extrusion. float width; // Height of the extrusion. float height; ExtrusionPath(ExtrusionRole role) : role(role), mm3_per_mm(-1), width(-1), height(-1) {}; ExtrusionPath(ExtrusionRole role, double mm3_per_mm, float width, float height) : role(role), mm3_per_mm(mm3_per_mm), width(width), height(height) {}; // ExtrusionPath(ExtrusionRole role, const Flow &flow) : role(role), mm3_per_mm(flow.mm3_per_mm()), width(flow.width), height(flow.height) {}; ExtrusionPath* clone() const { return new ExtrusionPath (*this); } void reverse() { this->polyline.reverse(); } Point first_point() const { return this->polyline.points.front(); } Point last_point() const { return this->polyline.points.back(); } // Produce a list of extrusion paths into retval by clipping this path by ExPolygonCollection. // Currently not used. void intersect_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const; // Produce a list of extrusion paths into retval by removing parts of this path by ExPolygonCollection. // Currently not used. void subtract_expolygons(const ExPolygonCollection &collection, ExtrusionEntityCollection* retval) const; void clip_end(double distance); void simplify(double tolerance); virtual double length() const; bool is_perimeter() const { return this->role == erPerimeter || this->role == erExternalPerimeter || this->role == erOverhangPerimeter; } bool is_infill() const { return this->role == erBridgeInfill || this->role == erInternalInfill || this->role == erSolidInfill || this->role == erTopSolidInfill; } bool is_solid_infill() const { return this->role == erBridgeInfill || this->role == erSolidInfill || this->role == erTopSolidInfill; } bool is_bridge() const { return this->role == erBridgeInfill || this->role == erOverhangPerimeter; } // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const; // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion spacing. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const; Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm. double min_mm3_per_mm() const { return this->mm3_per_mm; } Polyline as_polyline() const { return this->polyline; } private: void _inflate_collection(const Polylines &polylines, ExtrusionEntityCollection* collection) const; }; typedef std::vector ExtrusionPaths; class ExtrusionLoop : public ExtrusionEntity { public: ExtrusionPaths paths; ExtrusionLoopRole role; ExtrusionLoop(ExtrusionLoopRole role = elrDefault) : role(role) {}; ExtrusionLoop(const ExtrusionPaths &paths, ExtrusionLoopRole role = elrDefault) : paths(paths), role(role) {}; ExtrusionLoop(const ExtrusionPath &path, ExtrusionLoopRole role = elrDefault) : role(role) { this->paths.push_back(path); }; bool is_loop() const { return true; } bool can_reverse() const { return false; } ExtrusionLoop* clone() const { return new ExtrusionLoop (*this); } bool make_clockwise(); bool make_counter_clockwise(); void reverse(); Point first_point() const { return this->paths.front().polyline.points.front(); } Point last_point() const { assert(first_point() == this->paths.back().polyline.points.back()); return first_point(); } Polygon polygon() const; virtual double length() const; bool split_at_vertex(const Point &point); void split_at(const Point &point); void clip_end(double distance, ExtrusionPaths* paths) const; // Test, whether the point is extruded by a bridging flow. // This used to be used to avoid placing seams on overhangs, but now the EdgeGrid is used instead. bool has_overhang_point(const Point &point) const; bool is_perimeter() const { return this->paths.front().role == erPerimeter || this->paths.front().role == erExternalPerimeter || this->paths.front().role == erOverhangPerimeter; } bool is_infill() const { return this->paths.front().role == erBridgeInfill || this->paths.front().role == erInternalInfill || this->paths.front().role == erSolidInfill || this->paths.front().role == erTopSolidInfill; } bool is_solid_infill() const { return this->paths.front().role == erBridgeInfill || this->paths.front().role == erSolidInfill || this->paths.front().role == erTopSolidInfill; } // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const; // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion spacing. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const; Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } // Minimum volumetric velocity of this extrusion entity. Used by the constant nozzle pressure algorithm. double min_mm3_per_mm() const; Polyline as_polyline() const { return this->polygon().split_at_first_point(); } }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/ExtrusionEntityCollection.cpp000066400000000000000000000166241301441720000255330ustar00rootroot00000000000000#include "ExtrusionEntityCollection.hpp" #include #include #include namespace Slic3r { ExtrusionEntityCollection::ExtrusionEntityCollection(const ExtrusionEntityCollection& collection) : orig_indices(collection.orig_indices), no_sort(collection.no_sort) { this->append(collection.entities); } ExtrusionEntityCollection::ExtrusionEntityCollection(const ExtrusionPaths &paths) : no_sort(false) { this->append(paths); } ExtrusionEntityCollection& ExtrusionEntityCollection::operator= (const ExtrusionEntityCollection &other) { this->entities = other.entities; for (size_t i = 0; i < this->entities.size(); ++i) this->entities[i] = this->entities[i]->clone(); this->orig_indices = other.orig_indices; this->no_sort = other.no_sort; return *this; } void ExtrusionEntityCollection::swap (ExtrusionEntityCollection &c) { std::swap(this->entities, c.entities); std::swap(this->orig_indices, c.orig_indices); std::swap(this->no_sort, c.no_sort); } void ExtrusionEntityCollection::clear() { for (size_t i = 0; i < this->entities.size(); ++i) delete this->entities[i]; this->entities.clear(); } ExtrusionEntityCollection::operator ExtrusionPaths() const { ExtrusionPaths paths; for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) { if (const ExtrusionPath* path = dynamic_cast(*it)) paths.push_back(*path); } return paths; } ExtrusionEntityCollection* ExtrusionEntityCollection::clone() const { ExtrusionEntityCollection* coll = new ExtrusionEntityCollection(*this); for (size_t i = 0; i < coll->entities.size(); ++i) coll->entities[i] = this->entities[i]->clone(); return coll; } void ExtrusionEntityCollection::reverse() { for (ExtrusionEntitiesPtr::iterator it = this->entities.begin(); it != this->entities.end(); ++it) { // Don't reverse it if it's a loop, as it doesn't change anything in terms of elements ordering // and caller might rely on winding order if (!(*it)->is_loop()) (*it)->reverse(); } std::reverse(this->entities.begin(), this->entities.end()); } void ExtrusionEntityCollection::append(const ExtrusionEntitiesPtr &entities) { for (ExtrusionEntitiesPtr::const_iterator ptr = entities.begin(); ptr != entities.end(); ++ptr) this->append(**ptr); } void ExtrusionEntityCollection::append(const ExtrusionPaths &paths) { for (ExtrusionPaths::const_iterator path = paths.begin(); path != paths.end(); ++path) this->append(*path); } void ExtrusionEntityCollection::replace(size_t i, const ExtrusionEntity &entity) { delete this->entities[i]; this->entities[i] = entity.clone(); } void ExtrusionEntityCollection::remove(size_t i) { delete this->entities[i]; this->entities.erase(this->entities.begin() + i); } ExtrusionEntityCollection ExtrusionEntityCollection::chained_path(bool no_reverse, std::vector* orig_indices) const { ExtrusionEntityCollection coll; this->chained_path(&coll, no_reverse, orig_indices); return coll; } void ExtrusionEntityCollection::chained_path(ExtrusionEntityCollection* retval, bool no_reverse, std::vector* orig_indices) const { if (this->entities.empty()) return; this->chained_path_from(this->entities.front()->first_point(), retval, no_reverse, orig_indices); } void ExtrusionEntityCollection::chained_path_from(Point start_near, ExtrusionEntityCollection* retval, bool no_reverse, std::vector* orig_indices) const { if (this->no_sort) { *retval = *this; return; } retval->entities.reserve(this->entities.size()); retval->orig_indices.reserve(this->entities.size()); // if we're asked to return the original indices, build a map std::map indices_map; ExtrusionEntitiesPtr my_paths; for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) { ExtrusionEntity* entity = (*it)->clone(); my_paths.push_back(entity); if (orig_indices != NULL) indices_map[entity] = it - this->entities.begin(); } Points endpoints; for (ExtrusionEntitiesPtr::iterator it = my_paths.begin(); it != my_paths.end(); ++it) { endpoints.push_back((*it)->first_point()); if (no_reverse || !(*it)->can_reverse()) { endpoints.push_back((*it)->first_point()); } else { endpoints.push_back((*it)->last_point()); } } while (!my_paths.empty()) { // find nearest point int start_index = start_near.nearest_point_index(endpoints); int path_index = start_index/2; ExtrusionEntity* entity = my_paths.at(path_index); // never reverse loops, since it's pointless for chained path and callers might depend on orientation if (start_index % 2 && !no_reverse && entity->can_reverse()) { entity->reverse(); } retval->entities.push_back(my_paths.at(path_index)); if (orig_indices != NULL) orig_indices->push_back(indices_map[entity]); my_paths.erase(my_paths.begin() + path_index); endpoints.erase(endpoints.begin() + 2*path_index, endpoints.begin() + 2*path_index + 2); start_near = retval->entities.back()->last_point(); } } void ExtrusionEntityCollection::polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const { for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) (*it)->polygons_covered_by_width(out, scaled_epsilon); } void ExtrusionEntityCollection::polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const { for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) (*it)->polygons_covered_by_spacing(out, scaled_epsilon); } /* Recursively count paths and loops contained in this collection */ size_t ExtrusionEntityCollection::items_count() const { size_t count = 0; for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) { if ((*it)->is_collection()) { ExtrusionEntityCollection* collection = dynamic_cast(*it); count += collection->items_count(); } else { ++count; } } return count; } /* Returns a single vector of pointers to all non-collection items contained in this one */ void ExtrusionEntityCollection::flatten(ExtrusionEntityCollection* retval) const { for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) { if ((*it)->is_collection()) { ExtrusionEntityCollection* collection = dynamic_cast(*it); retval->append(collection->flatten().entities); } else { retval->append(**it); } } } ExtrusionEntityCollection ExtrusionEntityCollection::flatten() const { ExtrusionEntityCollection coll; this->flatten(&coll); return coll; } double ExtrusionEntityCollection::min_mm3_per_mm() const { double min_mm3_per_mm = std::numeric_limits::max(); for (ExtrusionEntitiesPtr::const_iterator it = this->entities.begin(); it != this->entities.end(); ++it) min_mm3_per_mm = std::min(min_mm3_per_mm, (*it)->min_mm3_per_mm()); return min_mm3_per_mm; } } Slic3r-version_1.31.6/xs/src/libslic3r/ExtrusionEntityCollection.hpp000066400000000000000000000064651301441720000255420ustar00rootroot00000000000000#ifndef slic3r_ExtrusionEntityCollection_hpp_ #define slic3r_ExtrusionEntityCollection_hpp_ #include "libslic3r.h" #include "ExtrusionEntity.hpp" namespace Slic3r { class ExtrusionEntityCollection : public ExtrusionEntity { public: ExtrusionEntityCollection* clone() const; ExtrusionEntitiesPtr entities; // we own these entities std::vector orig_indices; // handy for XS bool no_sort; ExtrusionEntityCollection(): no_sort(false) {}; ExtrusionEntityCollection(const ExtrusionEntityCollection &collection); ExtrusionEntityCollection(const ExtrusionPaths &paths); ExtrusionEntityCollection& operator= (const ExtrusionEntityCollection &other); ~ExtrusionEntityCollection() { clear(); } operator ExtrusionPaths() const; bool is_collection() const { return true; }; bool can_reverse() const { return !this->no_sort; }; bool empty() const { return this->entities.empty(); }; void clear(); void swap (ExtrusionEntityCollection &c); void append(const ExtrusionEntity &entity) { this->entities.push_back(entity.clone()); } void append(const ExtrusionEntitiesPtr &entities); void append(const ExtrusionPaths &paths); void replace(size_t i, const ExtrusionEntity &entity); void remove(size_t i); ExtrusionEntityCollection chained_path(bool no_reverse = false, std::vector* orig_indices = NULL) const; void chained_path(ExtrusionEntityCollection* retval, bool no_reverse = false, std::vector* orig_indices = NULL) const; void chained_path_from(Point start_near, ExtrusionEntityCollection* retval, bool no_reverse = false, std::vector* orig_indices = NULL) const; void reverse(); Point first_point() const { return this->entities.front()->first_point(); } Point last_point() const { return this->entities.back()->last_point(); } // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion width. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. virtual void polygons_covered_by_width(Polygons &out, const float scaled_epsilon) const; // Produce a list of 2D polygons covered by the extruded paths, offsetted by the extrusion spacing. // Increase the offset by scaled_epsilon to achieve an overlap, so a union will produce no gaps. // Useful to calculate area of an infill, which has been really filled in by a 100% rectilinear infill. virtual void polygons_covered_by_spacing(Polygons &out, const float scaled_epsilon) const; Polygons polygons_covered_by_width(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_width(out, scaled_epsilon); return out; } Polygons polygons_covered_by_spacing(const float scaled_epsilon = 0.f) const { Polygons out; this->polygons_covered_by_spacing(out, scaled_epsilon); return out; } size_t items_count() const; void flatten(ExtrusionEntityCollection* retval) const; ExtrusionEntityCollection flatten() const; double min_mm3_per_mm() const; Polyline as_polyline() const { CONFESS("Calling as_polyline() on a ExtrusionEntityCollection"); return Polyline(); }; virtual double length() const { CONFESS("Calling length() on a ExtrusionEntityCollection"); return 0.; } }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/ExtrusionSimulator.cpp000066400000000000000000001001701301441720000242100ustar00rootroot00000000000000// Optimize the extrusion simulator to the bones. //#pragma GCC optimize ("O3") //#undef SLIC3R_DEBUG //#define NDEBUG #include #include #include #include #include #include #include #include "ExtrusionSimulator.hpp" #ifndef M_PI #define M_PI 3.1415926535897932384626433832795 #endif // Replacement for a template alias. // Shorthand for the point_xy. template struct V2 { typedef boost::geometry::model::d2::point_xy Type; }; // Replacement for a template alias. // Shorthand for the point with a cartesian coordinate system. template struct V3 { typedef boost::geometry::model::point Type; }; // Replacement for a template alias. // Shorthand for the point with a cartesian coordinate system. template struct V4 { typedef boost::geometry::model::point Type; }; typedef V2::Type V2i; typedef V2::Type V2f; typedef V2::Type V2d; // Used for an RGB color. typedef V3::Type V3uc; // Used for an RGBA color. typedef V4::Type V4uc; typedef boost::geometry::model::box B2i; typedef boost::geometry::model::box B2f; typedef boost::geometry::model::box B2d; typedef boost::multi_array A2uc; typedef boost::multi_array A2i; typedef boost::multi_array A2f; typedef boost::multi_array A2d; template inline void operator+=( boost::geometry::model::d2::point_xy &v1, const boost::geometry::model::d2::point_xy &v2) { boost::geometry::add_point(v1, v2); } template inline void operator-=( boost::geometry::model::d2::point_xy &v1, const boost::geometry::model::d2::point_xy &v2) { boost::geometry::subtract_point(v1, v2); } template inline void operator*=(boost::geometry::model::d2::point_xy &v, const T c) { boost::geometry::multiply_value(v, c); } template inline void operator/=(boost::geometry::model::d2::point_xy &v, const T c) { boost::geometry::divide_value(v, c); } template inline typename boost::geometry::model::d2::point_xy operator+( const boost::geometry::model::d2::point_xy &v1, const boost::geometry::model::d2::point_xy &v2) { boost::geometry::model::d2::point_xy out(v1); out += v2; return out; } template inline boost::geometry::model::d2::point_xy operator-( const boost::geometry::model::d2::point_xy &v1, const boost::geometry::model::d2::point_xy &v2) { boost::geometry::model::d2::point_xy out(v1); out -= v2; return out; } template inline boost::geometry::model::d2::point_xy operator*( const boost::geometry::model::d2::point_xy &v, const T c) { boost::geometry::model::d2::point_xy out(v); out *= c; return out; } template inline typename boost::geometry::model::d2::point_xy operator*( const T c, const boost::geometry::model::d2::point_xy &v) { boost::geometry::model::d2::point_xy out(v); out *= c; return out; } template inline typename boost::geometry::model::d2::point_xy operator/( const boost::geometry::model::d2::point_xy &v, const T c) { boost::geometry::model::d2::point_xy out(v); out /= c; return out; } template inline T dot( const boost::geometry::model::d2::point_xy &v1, const boost::geometry::model::d2::point_xy &v2) { return boost::geometry::dot_product(v1, v2); } template inline T dot(const boost::geometry::model::d2::point_xy &v) { return boost::geometry::dot_product(v, v); } template inline T cross( const boost::geometry::model::d2::point_xy &v1, const boost::geometry::model::d2::point_xy &v2) { return v1.x() * v2.y() - v2.x() * v1.y(); } // Euclidian measure template inline T l2(const boost::geometry::model::d2::point_xy &v) { return std::sqrt(dot(v)); } // Euclidian measure template inline T mag(const boost::geometry::model::d2::point_xy &v) { return l2(v); } template inline T lerp(T start, T end, T alpha) { return start * (T(1.) - alpha) + end * alpha; } template inline T clamp(T low, T high, T x) { return std::max(low, std::min(high, x)); } template inline T sqr(T x) { return x * x; } template inline T dist2_to_line( const boost::geometry::model::d2::point_xy &p0, const boost::geometry::model::d2::point_xy &p1, const boost::geometry::model::d2::point_xy &px) { boost::geometry::model::d2::point_xy v = p1 - p0; boost::geometry::model::d2::point_xy vx = px - p0; T l = dot(v); T t = dot(v, vx); if (l != T(0) && t > T(0.)) { t /= l; vx = px - ((t > T(1.)) ? p1 : (p0 + t * v)); } return dot(vx); } // Intersect a circle with a line segment. // Returns number of intersection points. template int line_circle_intersection( const boost::geometry::model::d2::point_xy &p0, const boost::geometry::model::d2::point_xy &p1, const boost::geometry::model::d2::point_xy ¢er, const T radius, boost::geometry::model::d2::point_xy intersection[2]) { typedef typename V2::Type V2T; V2T v = p1 - p0; V2T vc = p0 - center; T a = dot(v); T b = T(2.) * dot(vc, v); T c = dot(vc) - radius * radius; T d = b * b - T(4.) * a * c; if (d < T(0)) // The circle misses the ray. return 0; int n = 0; if (d == T(0)) { // The circle touches the ray at a single tangent point. T t = - b / (T(2.) * a); if (t >= T(0.) && t <= T(1.)) intersection[n ++] = p0 + t * v; } else { // The circle intersects the ray in two points. d = sqrt(d); T t = (- b - d) / (T(2.) * a); if (t >= T(0.) && t <= T(1.)) intersection[n ++] = p0 + t * v; t = (- b + d) / (T(2.) * a); if (t >= T(0.) && t <= T(1.)) intersection[n ++] = p0 + t * v; } return n; } // Sutherland–Hodgman clipping of a rectangle against an AABB. // Expects the first 4 points of rect to be filled at the beginning. // The clipping may produce up to 8 points. // Returns the number of resulting points. template int clip_rect_by_AABB( boost::geometry::model::d2::point_xy rect[8], const boost::geometry::model::box > &aabb) { typedef typename V2::Type V2T; V2T result[8]; int nin = 4; int nout = 0; V2T *in = rect; V2T *out = result; // Clip left { const V2T *S = in + nin - 1; T left = aabb.min_corner().x(); for (int i = 0; i < nin; ++i) { const V2T &E = in[i]; if (E.x() == left) { out[nout++] = E; } else if (E.x() > left) { // E is inside the AABB. if (S->x() < left) { // S is outside the AABB. Calculate an intersection point. T t = (left - S->x()) / (E.x() - S->x()); out[nout++] = V2T(left, S->y() + t * (E.y() - S->y())); } out[nout++] = E; } else if (S->x() > left) { // S is inside the AABB, E is outside the AABB. T t = (left - S->x()) / (E.x() - S->x()); out[nout++] = V2T(left, S->y() + t * (E.y() - S->y())); } S = &E; } assert(nout <= 8); } // Clip bottom { std::swap(in, out); nin = nout; nout = 0; const V2T *S = in + nin - 1; T bottom = aabb.min_corner().y(); for (int i = 0; i < nin; ++i) { const V2T &E = in[i]; if (E.y() == bottom) { out[nout++] = E; } else if (E.y() > bottom) { // E is inside the AABB. if (S->y() < bottom) { // S is outside the AABB. Calculate an intersection point. T t = (bottom - S->y()) / (E.y() - S->y()); out[nout++] = V2T(S->x() + t * (E.x() - S->x()), bottom); } out[nout++] = E; } else if (S->y() > bottom) { // S is inside the AABB, E is outside the AABB. T t = (bottom - S->y()) / (E.y() - S->y()); out[nout++] = V2T(S->x() + t * (E.x() - S->x()), bottom); } S = &E; } assert(nout <= 8); } // Clip right { std::swap(in, out); nin = nout; nout = 0; const V2T *S = in + nin - 1; T right = aabb.max_corner().x(); for (int i = 0; i < nin; ++i) { const V2T &E = in[i]; if (E.x() == right) { out[nout++] = E; } else if (E.x() < right) { // E is inside the AABB. if (S->x() > right) { // S is outside the AABB. Calculate an intersection point. T t = (right - S->x()) / (E.x() - S->x()); out[nout++] = V2T(right, S->y() + t * (E.y() - S->y())); } out[nout++] = E; } else if (S->x() < right) { // S is inside the AABB, E is outside the AABB. T t = (right - S->x()) / (E.x() - S->x()); out[nout++] = V2T(right, S->y() + t * (E.y() - S->y())); } S = &E; } assert(nout <= 8); } // Clip top { std::swap(in, out); nin = nout; nout = 0; const V2T *S = in + nin - 1; T top = aabb.max_corner().y(); for (int i = 0; i < nin; ++i) { const V2T &E = in[i]; if (E.y() == top) { out[nout++] = E; } else if (E.y() < top) { // E is inside the AABB. if (S->y() > top) { // S is outside the AABB. Calculate an intersection point. T t = (top - S->y()) / (E.y() - S->y()); out[nout++] = V2T(S->x() + t * (E.x() - S->x()), top); } out[nout++] = E; } else if (S->y() < top) { // S is inside the AABB, E is outside the AABB. T t = (top - S->y()) / (E.y() - S->y()); out[nout++] = V2T(S->x() + t * (E.x() - S->x()), top); } S = &E; } assert(nout <= 8); } assert(nout <= 8); return nout; } // Calculate area of the circle x AABB intersection. // The calculation is approximate in a way, that the circular segment // intersecting the cell is approximated by its chord (a linear segment). template int clip_circle_by_AABB( const boost::geometry::model::d2::point_xy ¢er, const T radius, const boost::geometry::model::box > &aabb, boost::geometry::model::d2::point_xy result[8], bool result_arc[8]) { typedef typename V2::Type V2T; V2T rect[4] = { aabb.min_corner(), V2T(aabb.max_corner().x(), aabb.min_corner().y()), aabb.max_corner(), V2T(aabb.min_corner().x(), aabb.max_corner().y()) }; int bits_corners = 0; T r2 = sqr(radius); for (int i = 0; i < 4; ++ i, bits_corners <<= 1) bits_corners |= dot(rect[i] - center) >= r2; bits_corners >>= 1; if (bits_corners == 0) { // all inside memcpy(result, rect, sizeof(rect)); memset(result_arc, true, 4); return 4; } if (bits_corners == 0x0f) // all outside return 0; // Some corners are outside, some are inside. Trim the rectangle. int n = 0; for (int i = 0; i < 4; ++ i) { bool inside = (bits_corners & 0x08) == 0; bits_corners <<= 1; V2T chordal_points[2]; int n_chordal_points = line_circle_intersection(rect[i], rect[(i + 1)%4], center, radius, chordal_points); if (n_chordal_points == 2) { result_arc[n] = true; result[n ++] = chordal_points[0]; result_arc[n] = true; result[n ++] = chordal_points[1]; } else { if (inside) { result_arc[n] = false; result[n ++] = rect[i]; } if (n_chordal_points == 1) { result_arc[n] = false; result[n ++] = chordal_points[0]; } } } return n; } /* // Calculate area of the circle x AABB intersection. // The calculation is approximate in a way, that the circular segment // intersecting the cell is approximated by its chord (a linear segment). template T circle_AABB_intersection_area( const boost::geometry::model::d2::point_xy ¢er, const T radius, const boost::geometry::model::box > &aabb) { typedef typename V2::Type V2T; typedef typename boost::geometry::model::box B2T; T radius2 = radius * radius; bool intersectionLeft = sqr(aabb.min_corner().x() - center.x()) < radius2; bool intersectionRight = sqr(aabb.max_corner().x() - center.x()) < radius2; bool intersectionBottom = sqr(aabb.min_corner().y() - center.y()) < radius2; bool intersectionTop = sqr(aabb.max_corner().y() - center.y()) < radius2; if (! (intersectionLeft || intersectionRight || intersectionTop || intersectionBottom)) // No intersection between the aabb and the center. return boost::geometry::point_in_box()::apply(center, aabb) ? 1.f : 0.f; V2T rect[4] = { aabb.min_corner(), V2T(aabb.max_corner().x(), aabb.min_corner().y()), aabb.max_corner(), V2T(aabb.min_corner().x(), aabb.max_corner().y()) }; int bits_corners = 0; T r2 = sqr(radius); for (int i = 0; i < 4; ++ i, bits_corners <<= 1) bits_corners |= dot(rect[i] - center) >= r2; bits_corners >>= 1; if (bits_corners == 0) { // all inside memcpy(result, rect, sizeof(rect)); memset(result_arc, true, 4); return 4; } if (bits_corners == 0x0f) // all outside return 0; // Some corners are outside, some are inside. Trim the rectangle. int n = 0; for (int i = 0; i < 4; ++ i) { bool inside = (bits_corners & 0x08) == 0; bits_corners <<= 1; V2T chordal_points[2]; int n_chordal_points = line_circle_intersection(rect[i], rect[(i + 1)%4], center, radius, chordal_points); if (n_chordal_points == 2) { result_arc[n] = true; result[n ++] = chordal_points[0]; result_arc[n] = true; result[n ++] = chordal_points[1]; } else { if (inside) { result_arc[n] = false; result[n ++] = rect[i]; } if (n_chordal_points == 1) { result_arc[n] = false; result[n ++] = chordal_points[0]; } } } return n; } */ template inline T polyArea(const boost::geometry::model::d2::point_xy *poly, int n) { T area = T(0); for (int i = 1; i + 1 < n; ++i) area += cross(poly[i] - poly[0], poly[i + 1] - poly[0]); return T(0.5) * area; } template boost::geometry::model::d2::point_xy polyCentroid(const boost::geometry::model::d2::point_xy *poly, int n) { boost::geometry::model::d2::point_xy centroid(T(0), T(0)); for (int i = 0; i < n; ++i) centroid += poly[i]; return (n == 0) ? centroid : (centroid / float(n)); } void gcode_paint_layer( const std::vector &polyline, float width, float thickness, A2f &acc) { int nc = acc.shape()[1]; int nr = acc.shape()[0]; // printf("gcode_paint_layer %d,%d\n", nc, nr); for (size_t iLine = 1; iLine != polyline.size(); ++iLine) { const V2f &p1 = polyline[iLine - 1]; const V2f &p2 = polyline[iLine]; // printf("p1, p2: %f,%f %f,%f\n", p1.x(), p1.y(), p2.x(), p2.y()); const V2f dir = p2 - p1; V2f vperp(- dir.y(), dir.x()); vperp = vperp * 0.5f * width / l2(vperp); // Rectangle of the extrusion. V2f rect[4] = { p1 + vperp, p1 - vperp, p2 - vperp, p2 + vperp }; // Bounding box of the extrusion. B2f bboxLine(rect[0], rect[0]); boost::geometry::expand(bboxLine, rect[1]); boost::geometry::expand(bboxLine, rect[2]); boost::geometry::expand(bboxLine, rect[3]); B2i bboxLinei( V2i(clamp(0, nc-1, int(floor(bboxLine.min_corner().x()))), clamp(0, nr-1, int(floor(bboxLine.min_corner().y())))), V2i(clamp(0, nc-1, int(ceil (bboxLine.max_corner().x()))), clamp(0, nr-1, int(ceil (bboxLine.max_corner().y()))))); // printf("bboxLinei %d,%d %d,%d\n", bboxLinei.min_corner().x(), bboxLinei.min_corner().y(), bboxLinei.max_corner().x(), bboxLinei.max_corner().y()); #ifdef _DEBUG float area = polyArea(rect, 4); assert(area > 0.f); #endif /* _DEBUG */ for (int j = bboxLinei.min_corner().y(); j + 1 < bboxLinei.max_corner().y(); ++ j) { for (int i = bboxLinei.min_corner().x(); i + 1 < bboxLinei.max_corner().x(); ++i) { V2f rect2[8]; memcpy(rect2, rect, sizeof(rect)); int n = clip_rect_by_AABB(rect2, B2f(V2f(float(i), float(j)), V2f(float(i + 1), float(j + 1)))); float area = polyArea(rect2, n); assert(area >= 0.f && area <= 1.000001f); acc[j][i] += area * thickness; } } } } void gcode_paint_bitmap( const std::vector &polyline, float width, A2uc &bitmap, float scale) { int nc = bitmap.shape()[1]; int nr = bitmap.shape()[0]; float r2 = width * width * 0.25f; // printf("gcode_paint_layer %d,%d\n", nc, nr); for (size_t iLine = 1; iLine != polyline.size(); ++iLine) { const V2f &p1 = polyline[iLine - 1]; const V2f &p2 = polyline[iLine]; // printf("p1, p2: %f,%f %f,%f\n", p1.x(), p1.y(), p2.x(), p2.y()); V2f dir = p2 - p1; dir = dir * 0.5f * width / l2(dir); V2f vperp(- dir.y(), dir.x()); // Rectangle of the extrusion. V2f rect[4] = { (p1 + vperp - dir) * scale, (p1 - vperp - dir) * scale, (p2 - vperp + dir) * scale, (p2 + vperp + dir) * scale }; // Bounding box of the extrusion. B2f bboxLine(rect[0], rect[0]); boost::geometry::expand(bboxLine, rect[1]); boost::geometry::expand(bboxLine, rect[2]); boost::geometry::expand(bboxLine, rect[3]); B2i bboxLinei( V2i(clamp(0, nc-1, int(floor(bboxLine.min_corner().x()))), clamp(0, nr-1, int(floor(bboxLine.min_corner().y())))), V2i(clamp(0, nc-1, int(ceil (bboxLine.max_corner().x()))), clamp(0, nr-1, int(ceil (bboxLine.max_corner().y()))))); // printf("bboxLinei %d,%d %d,%d\n", bboxLinei.min_corner().x(), bboxLinei.min_corner().y(), bboxLinei.max_corner().x(), bboxLinei.max_corner().y()); for (int j = bboxLinei.min_corner().y(); j + 1 < bboxLinei.max_corner().y(); ++ j) { for (int i = bboxLinei.min_corner().x(); i + 1 < bboxLinei.max_corner().x(); ++i) { float d2 = dist2_to_line(p1, p2, V2f(float(i) + 0.5f, float(j) + 0.5f) / scale); if (d2 < r2) bitmap[j][i] = 1; } } } } struct Cell { // Cell index in the grid. V2i idx; // Total volume of the material stored in this cell. float volume; // Area covered inside this cell, <0,1>. float area; // Fraction of the area covered by the print head. <0,1> float fraction_covered; // Height of the covered part in excess to the expected layer height. float excess_height; bool operator<(const Cell &c2) const { return this->excess_height < c2.excess_height; } }; struct ExtrusionPoint { V2f center; float radius; float height; }; typedef std::vector ExtrusionPoints; void gcode_spread_points( A2f &acc, const A2f &mask, const ExtrusionPoints &points, Slic3r::ExtrusionSimulationType simulationType) { int nc = acc.shape()[1]; int nr = acc.shape()[0]; // Maximum radius of the spreading points, to allocate a large enough cell array. float rmax = 0.f; for (ExtrusionPoints::const_iterator it = points.begin(); it != points.end(); ++ it) rmax = std::max(rmax, it->radius); size_t n_rows_max = size_t(ceil(rmax * 2.f + 2.f)); size_t n_cells_max = sqr(n_rows_max); std::vector > spans; std::vector cells(n_cells_max, Cell()); std::vector areas_sum(n_cells_max, 0.f); for (ExtrusionPoints::const_iterator it = points.begin(); it != points.end(); ++ it) { const V2f ¢er = it->center; const float radius = it->radius; const float radius2 = radius * radius; const float height_target = it->height; B2f bbox(center - V2f(radius, radius), center + V2f(radius, radius)); B2i bboxi( V2i(clamp(0, nc-1, int(floor(bbox.min_corner().x()))), clamp(0, nr-1, int(floor(bbox.min_corner().y())))), V2i(clamp(0, nc-1, int(ceil (bbox.max_corner().x()))), clamp(0, nr-1, int(ceil (bbox.max_corner().y()))))); /* // Fill in the spans, at which the circle intersects the rows. int row_first = bboxi.min_corner().y(); int row_last = bboxi.max_corner().y(); for (; row_first <= row_last; ++ row_first) { float y = float(j) - center.y(); float discr = radius2 - sqr(y); if (discr > 0) { // Circle intersects the row j at 2 points. float d = sqrt(discr); spans.push_back(std.pair(center.x() - d, center.x() + d))); break; } } for (int j = row_first + 1; j <= row_last; ++ j) { float y = float(j) - center.y(); float discr = radius2 - sqr(y); if (discr > 0) { // Circle intersects the row j at 2 points. float d = sqrt(discr); spans.push_back(std.pair(center.x() - d, center.x() + d))); } else { row_last = j - 1; break; } } */ float area_total = 0; float volume_total = 0; float volume_excess = 0; float volume_deficit = 0; size_t n_cells = 0; float area_circle_total = 0; #if 0 // The intermediate lines. for (int j = row_first; j < row_last; ++ j) { const std::pair &span1 = spans[j]; const std::pair &span2 = spans[j+1]; float l1 = span1.first; float l2 = span2.first; float r1 = span1.second; float r2 = span2.second; if (l2 < l1) std::swap(l1, l2); if (r1 > r2) std::swap(r1, r2); int il1 = int(floor(l1)); int il2 = int(ceil(l2)); int ir1 = int(floor(r1)); int ir2 = int(floor(r2)); assert(il2 <= ir1); for (int i = il1; i < il2; ++ i) { Cell &cell = cells[n_cells ++]; cell.idx.x(i); cell.idx.y(j); cell.area = area; } for (int i = il2; i < ir1; ++ i) { Cell &cell = cells[n_cells ++]; cell.idx.x(i); cell.idx.y(j); cell.area = 1.f; } for (int i = ir1; i < ir2; ++ i) { Cell &cell = cells[n_cells ++]; cell.idx.x(i); cell.idx.y(j); cell.area = area; } } #else for (int j = bboxi.min_corner().y(); j < bboxi.max_corner().y(); ++ j) { for (int i = bboxi.min_corner().x(); i < bboxi.max_corner().x(); ++i) { B2f bb(V2f(float(i), float(j)), V2f(float(i + 1), float(j + 1))); V2f poly[8]; bool poly_arc[8]; int n = clip_circle_by_AABB(center, radius, bb, poly, poly_arc); float area = polyArea(poly, n); assert(area >= 0.f && area <= 1.000001f); if (area == 0.f) continue; Cell &cell = cells[n_cells ++]; cell.idx.x(i); cell.idx.y(j); cell.volume = acc[j][i]; cell.area = mask[j][i]; assert(cell.area >= 0.f && cell.area <= 1.000001f); area_circle_total += area; if (cell.area < area) cell.area = area; cell.fraction_covered = clamp(0.f, 1.f, (cell.area > 0) ? (area / cell.area) : 0); if (cell.fraction_covered == 0) { -- n_cells; continue; } float cell_height = cell.volume / cell.area; cell.excess_height = cell_height - height_target; if (cell.excess_height > 0.f) volume_excess += cell.excess_height * cell.area * cell.fraction_covered; else volume_deficit -= cell.excess_height * cell.area * cell.fraction_covered; volume_total += cell.volume * cell.fraction_covered; area_total += cell.area * cell.fraction_covered; } } #endif float area_circle_total2 = float(M_PI) * sqr(radius); float area_err = fabs(area_circle_total2 - area_circle_total) / area_circle_total2; // printf("area_circle_total: %f, %f, %f\n", area_circle_total, area_circle_total2, area_err); float volume_full = float(M_PI) * sqr(radius) * height_target; // if (true) { // printf("volume_total: %f, volume_full: %f, fill factor: %f\n", volume_total, volume_full, 100.f - 100.f * volume_total / volume_full); // printf("volume_full: %f, volume_excess+deficit: %f, volume_excess: %f, volume_deficit: %f\n", volume_full, volume_excess+volume_deficit, volume_excess, volume_deficit); if (simulationType == Slic3r::ExtrusionSimulationSpreadFull || volume_total <= volume_full) { // The volume under the circle is spreaded fully. float height_avg = volume_total / area_total; for (size_t i = 0; i < n_cells; ++ i) { const Cell &cell = cells[i]; acc[cell.idx.y()][cell.idx.x()] = (1.f - cell.fraction_covered) * cell.volume + cell.fraction_covered * cell.area * height_avg; } } else if (simulationType == ExtrusionSimulationSpreadExcess) { // The volume under the circle does not fit. // 1) Fill the underfilled cells and remove them from the list. float volume_borrowed_total = 0.; for (size_t i = 0; i < n_cells;) { Cell &cell = cells[i]; if (cell.excess_height <= 0) { // Fill in the part of the cell below the circle. float volume_borrowed = - cell.excess_height * cell.area * cell.fraction_covered; assert(volume_borrowed >= 0.f); acc[cell.idx.y()][cell.idx.x()] = cell.volume + volume_borrowed; volume_borrowed_total += volume_borrowed; cell = cells[-- n_cells]; } else ++ i; } // 2) Sort the remaining cells by their excess height. std::sort(cells.begin(), cells.begin() + n_cells); // 3) Prefix sum the areas per excess height. // The excess height is discrete with the number of excess cells. areas_sum[n_cells-1] = cells[n_cells-1].area * cells[n_cells-1].fraction_covered; for (int i = n_cells - 2; i >= 0; -- i) { const Cell &cell = cells[i]; areas_sum[i] = areas_sum[i + 1] + cell.area * cell.fraction_covered; } // 4) Find the excess height, where the volume_excess is over the volume_borrowed_total. float volume_current = 0.f; float excess_height_prev = 0.f; size_t i_top = n_cells; for (size_t i = 0; i < n_cells; ++ i) { const Cell &cell = cells[i]; volume_current += (cell.excess_height - excess_height_prev) * areas_sum[i]; excess_height_prev = cell.excess_height; if (volume_current > volume_borrowed_total) { i_top = i; break; } } // 5) Remove material from the cells with deficit. // First remove all the excess material from the cells, where the deficit is low. for (size_t i = 0; i < i_top; ++ i) { const Cell &cell = cells[i]; float volume_removed = cell.excess_height * cell.area * cell.fraction_covered; acc[cell.idx.y()][cell.idx.x()] = cell.volume - volume_removed; volume_borrowed_total -= volume_removed; } // Second remove some excess material from the cells, where the deficit is high. if (i_top < n_cells) { float height_diff = volume_borrowed_total / areas_sum[i_top]; for (size_t i = i_top; i < n_cells; ++ i) { const Cell &cell = cells[i]; acc[cell.idx.y()][cell.idx.x()] = cell.volume - height_diff * cell.area * cell.fraction_covered; } } } } } inline std::vector CreatePowerColorGradient24bit() { int i; int iColor = 0; std::vector out(6 * 255 + 1, V3uc(0, 0, 0)); for (i = 0; i < 256; ++i) out[iColor++] = V3uc(0, 0, i); for (i = 1; i < 256; ++i) out[iColor++] = V3uc(0, i, 255); for (i = 1; i < 256; ++i) out[iColor++] = V3uc(0, 255, 256 - i); for (i = 1; i < 256; ++i) out[iColor++] = V3uc(i, 255, 0); for (i = 1; i < 256; ++i) out[iColor++] = V3uc(255, 256 - i, 0); for (i = 1; i < 256; ++i) out[iColor++] = V3uc(255, 0, i); return out; } namespace Slic3r { class ExtrusionSimulatorImpl { public: std::vector image_data; A2f accumulator; A2uc bitmap; unsigned int bitmap_oversampled; ExtrusionPoints extrusion_points; // RGB gradient to color map the fullness of an accumulator bucket into the output image. std::vector > color_gradient; }; ExtrusionSimulator::ExtrusionSimulator() : pimpl(new ExtrusionSimulatorImpl) { pimpl->color_gradient = CreatePowerColorGradient24bit(); pimpl->bitmap_oversampled = 4; } ExtrusionSimulator::~ExtrusionSimulator() { delete pimpl; pimpl = NULL; } void ExtrusionSimulator::set_image_size(const Point &image_size) { // printf("ExtrusionSimulator::set_image_size()\n"); if (this->image_size.x == image_size.x && this->image_size.y == image_size.y) return; // printf("Setting image size: %d, %d\n", image_size.x, image_size.y); this->image_size = image_size; // Allocate the image data in an RGBA format. // printf("Allocating image data, size %d\n", image_size.x * image_size.y * 4); pimpl->image_data.assign(image_size.x * image_size.y * 4, 0); // printf("Allocating image data, allocated\n"); //FIXME fill the image with red vertical lines. for (size_t r = 0; r < image_size.y; ++ r) { for (size_t c = 0; c < image_size.x; c += 2) { // Color red pimpl->image_data[r * image_size.x * 4 + c * 4] = 255; // Opacity full pimpl->image_data[r * image_size.x * 4 + c * 4 + 3] = 255; } } // printf("Allocating image data, set\n"); } void ExtrusionSimulator::set_viewport(const BoundingBox &viewport) { // printf("ExtrusionSimulator::set_viewport(%d, %d, %d, %d)\n", viewport.min.x, viewport.min.y, viewport.max.x, viewport.max.y); if (this->viewport != viewport) { this->viewport = viewport; Point sz = viewport.size(); pimpl->accumulator.resize(boost::extents[sz.y][sz.x]); pimpl->bitmap.resize(boost::extents[sz.y*pimpl->bitmap_oversampled][sz.x*pimpl->bitmap_oversampled]); // printf("Accumulator size: %d, %d\n", sz.y, sz.x); } } void ExtrusionSimulator::set_bounding_box(const BoundingBox &bbox) { this->bbox = bbox; } const void* ExtrusionSimulator::image_ptr() const { return (pimpl->image_data.empty()) ? NULL : (void*)&pimpl->image_data.front(); } void ExtrusionSimulator::reset_accumulator() { // printf("ExtrusionSimulator::reset_accumulator()\n"); Point sz = viewport.size(); // printf("Reset accumulator, Accumulator size: %d, %d\n", sz.y, sz.x); memset(&pimpl->accumulator[0][0], 0, sizeof(float) * sz.x * sz.y); memset(&pimpl->bitmap[0][0], 0, sz.x * sz.y * pimpl->bitmap_oversampled * pimpl->bitmap_oversampled); pimpl->extrusion_points.clear(); // printf("Reset accumulator, done.\n"); } void ExtrusionSimulator::extrude_to_accumulator(const ExtrusionPath &path, const Point &shift, ExtrusionSimulationType simulationType) { // printf("Extruding a path. Nr points: %d, width: %f, height: %f\r\n", path.polyline.points.size(), path.width, path.height); // Convert the path to V2f points, shift and scale them to the viewport. std::vector polyline; polyline.reserve(path.polyline.points.size()); float scalex = float(viewport.size().x) / float(bbox.size().x); float scaley = float(viewport.size().y) / float(bbox.size().y); float w = scale_(path.width) * scalex; float h = scale_(path.height) * scalex; w = scale_(path.mm3_per_mm / path.height) * scalex; // printf("scalex: %f, scaley: %f\n", scalex, scaley); // printf("bbox: %d,%d %d,%d\n", bbox.min.x, bbox.min.y, bbox.max.x, bbox.max.y); for (Points::const_iterator it = path.polyline.points.begin(); it != path.polyline.points.end(); ++ it) { // printf("point %d,%d\n", it->x+shift.x, it->y+shift.y); ExtrusionPoint ept; ept.center = V2f(float(it->x+shift.x-bbox.min.x) * scalex, float(it->y+shift.y-bbox.min.y) * scaley); ept.radius = w/2.f; ept.height = 0.5f; polyline.push_back(ept.center); pimpl->extrusion_points.push_back(ept); } // Extrude the polyline into an accumulator. // printf("width scaled: %f, height scaled: %f\n", w, h); gcode_paint_layer(polyline, w, 0.5f, pimpl->accumulator); if (simulationType > ExtrusionSimulationDontSpread) gcode_paint_bitmap(polyline, w, pimpl->bitmap, pimpl->bitmap_oversampled); // double path.mm3_per_mm; // mm^3 of plastic per mm of linear head motion // float path.width; // float path.height; } void ExtrusionSimulator::evaluate_accumulator(ExtrusionSimulationType simulationType) { // printf("ExtrusionSimulator::evaluate_accumulator()\n"); Point sz = viewport.size(); if (simulationType > ExtrusionSimulationDontSpread) { // Average the cells of a bitmap into a lower resolution floating point mask. A2f mask(boost::extents[sz.y][sz.x]); for (int r = 0; r < sz.y; ++r) { for (int c = 0; c < sz.x; ++c) { float p = 0; for (int j = 0; j < pimpl->bitmap_oversampled; ++ j) { for (int i = 0; i < pimpl->bitmap_oversampled; ++ i) { if (pimpl->bitmap[r * pimpl->bitmap_oversampled + j][c * pimpl->bitmap_oversampled + i]) p += 1.f; } } p /= float(pimpl->bitmap_oversampled * pimpl->bitmap_oversampled * 2); mask[r][c] = p; } } // Spread the excess of the material. gcode_spread_points(pimpl->accumulator, mask, pimpl->extrusion_points, simulationType); } // Color map the accumulator. for (int r = 0; r < sz.y; ++r) { unsigned char *ptr = &pimpl->image_data[(image_size.x * (viewport.min.y + r) + viewport.min.x) * 4]; for (int c = 0; c < sz.x; ++c) { #if 1 float p = pimpl->accumulator[r][c]; #else float p = mask[r][c]; #endif int idx = int(floor(p * float(pimpl->color_gradient.size()) + 0.5f)); V3uc clr = pimpl->color_gradient[clamp(0, int(pimpl->color_gradient.size()-1), idx)]; *ptr ++ = clr.get<0>(); *ptr ++ = clr.get<1>(); *ptr ++ = clr.get<2>(); *ptr ++ = (idx == 0) ? 0 : 255; } } } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/ExtrusionSimulator.hpp000066400000000000000000000037721301441720000242270ustar00rootroot00000000000000#ifndef slic3r_ExtrusionSimulator_hpp_ #define slic3r_ExtrusionSimulator_hpp_ #include "libslic3r.h" #include "ExtrusionEntity.hpp" #include "BoundingBox.hpp" namespace Slic3r { enum ExtrusionSimulationType { ExtrusionSimulationSimple, ExtrusionSimulationDontSpread, ExtrisopmSimulationSpreadNotOverfilled, ExtrusionSimulationSpreadFull, ExtrusionSimulationSpreadExcess, }; // An opaque class, to keep the boost stuff away from the header. class ExtrusionSimulatorImpl; class ExtrusionSimulator { public: ExtrusionSimulator(); ~ExtrusionSimulator(); // Size of the image, that will be returned by image_ptr(). // The image may be bigger than the viewport as many graphics drivers // expect the size of a texture to be rounded to a power of two. void set_image_size(const Point &image_size); // Which part of the image shall be rendered to? void set_viewport(const BoundingBox &viewport); // Shift and scale of the rendered extrusion paths into the viewport. void set_bounding_box(const BoundingBox &bbox); // Reset the extrusion accumulator to zero for all buckets. void reset_accumulator(); // Paint a thick path into an extrusion buffer. // A simple implementation is provided now, splatting a rectangular extrusion for each linear segment. // In the future, spreading and suqashing of a material will be simulated. void extrude_to_accumulator(const ExtrusionPath &path, const Point &shift, ExtrusionSimulationType simulationType); // Evaluate the content of the accumulator and paint it into the viewport. // After this call the image_ptr() call will return a valid image. void evaluate_accumulator(ExtrusionSimulationType simulationType); // An RGBA image of image_size, to be loaded into a GPU texture. const void* image_ptr() const; private: Point image_size; BoundingBox viewport; BoundingBox bbox; ExtrusionSimulatorImpl *pimpl; }; } #endif /* slic3r_ExtrusionSimulator_hpp_ */ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/000077500000000000000000000000001301441720000204735ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/libslic3r/Fill/Fill.cpp000066400000000000000000000320131301441720000220640ustar00rootroot00000000000000#include #include #include #include "../ClipperUtils.hpp" #include "../Geometry.hpp" #include "../Layer.hpp" #include "../Print.hpp" #include "../PrintConfig.hpp" #include "../Surface.hpp" #include "FillBase.hpp" namespace Slic3r { struct SurfaceGroupAttrib { SurfaceGroupAttrib() : is_solid(false), fw(0.f), pattern(-1) {} bool operator==(const SurfaceGroupAttrib &other) const { return is_solid == other.is_solid && fw == other.fw && pattern == other.pattern; } bool is_solid; float fw; // pattern is of type InfillPattern, -1 for an unset pattern. int pattern; }; // Generate infills for Slic3r::Layer::Region. // The Slic3r::Layer::Region at this point of time may contain // surfaces of various types (internal/bridge/top/bottom/solid). // The infills are generated on the groups of surfaces with a compatible type. // Returns an array of Slic3r::ExtrusionPath::Collection objects containing the infills generaed now // and the thin fills generated by generate_perimeters(). void make_fill(LayerRegion &layerm, ExtrusionEntityCollection &out) { // Slic3r::debugf "Filling layer %d:\n", $layerm->layer->id; double fill_density = layerm.region()->config.fill_density; Flow infill_flow = layerm.flow(frInfill); Flow solid_infill_flow = layerm.flow(frSolidInfill); Flow top_solid_infill_flow = layerm.flow(frTopSolidInfill); Surfaces surfaces; // merge adjacent surfaces // in case of bridge surfaces, the ones with defined angle will be attached to the ones // without any angle (shouldn't this logic be moved to process_external_surfaces()?) { Polygons polygons_bridged; polygons_bridged.reserve(layerm.fill_surfaces.surfaces.size()); for (Surfaces::iterator it = layerm.fill_surfaces.surfaces.begin(); it != layerm.fill_surfaces.surfaces.end(); ++ it) if (it->bridge_angle >= 0) polygons_append(polygons_bridged, *it); // group surfaces by distinct properties (equal surface_type, thickness, thickness_layers, bridge_angle) // group is of type Slic3r::SurfaceCollection //FIXME: Use some smart heuristics to merge similar surfaces to eliminate tiny regions. std::vector groups; layerm.fill_surfaces.group(&groups); // merge compatible groups (we can generate continuous infill for them) { // cache flow widths and patterns used for all solid groups // (we'll use them for comparing compatible groups) std::vector group_attrib(groups.size()); for (size_t i = 0; i < groups.size(); ++ i) { // we can only merge solid non-bridge surfaces, so discard // non-solid surfaces const Surface &surface = *groups[i].front(); if (surface.is_solid() && (!surface.is_bridge() || layerm.layer()->id() == 0)) { group_attrib[i].is_solid = true; group_attrib[i].fw = (surface.surface_type == stTop) ? top_solid_infill_flow.width : solid_infill_flow.width; group_attrib[i].pattern = surface.is_external() ? layerm.region()->config.external_fill_pattern.value : ipRectilinear; } } // Loop through solid groups, find compatible groups and append them to this one. for (size_t i = 0; i < groups.size(); ++ i) { if (! group_attrib[i].is_solid) continue; for (size_t j = i + 1; j < groups.size();) { if (group_attrib[i] == group_attrib[j]) { // groups are compatible, merge them groups[i].insert(groups[i].end(), groups[j].begin(), groups[j].end()); groups.erase(groups.begin() + j); group_attrib.erase(group_attrib.begin() + j); } else ++ j; } } } // Give priority to bridges. Process the bridges in the first round, the rest of the surfaces in the 2nd round. for (size_t round = 0; round < 2; ++ round) { for (std::vector::iterator it_group = groups.begin(); it_group != groups.end(); ++ it_group) { const SurfacesPtr &group = *it_group; bool is_bridge = group.front()->bridge_angle >= 0; if (is_bridge != (round == 0)) continue; // Make a union of polygons defining the infiill regions of a group, use a safety offset. Polygons union_p = union_(to_polygons(*it_group), true); // Subtract surfaces having a defined bridge_angle from any other, use a safety offset. if (! polygons_bridged.empty() && ! is_bridge) union_p = diff(union_p, polygons_bridged, true); // subtract any other surface already processed //FIXME Vojtech: Because the bridge surfaces came first, they are subtracted twice! // Using group.front() as a template. surfaces_append(surfaces, diff_ex(union_p, to_polygons(surfaces), true), *group.front()); } } } // we need to detect any narrow surfaces that might collapse // when adding spacing below // such narrow surfaces are often generated in sloping walls // by bridge_over_infill() and combine_infill() as a result of the // subtraction of the combinable area from the layer infill area, // which leaves small areas near the perimeters // we are going to grow such regions by overlapping them with the void (if any) // TODO: detect and investigate whether there could be narrow regions without // any void neighbors { coord_t distance_between_surfaces = std::max( std::max(infill_flow.scaled_spacing(), solid_infill_flow.scaled_spacing()), top_solid_infill_flow.scaled_spacing()); Polygons surfaces_polygons = to_polygons(surfaces); Polygons collapsed = diff( surfaces_polygons, offset2(surfaces_polygons, -distance_between_surfaces/2, +distance_between_surfaces/2), true); Polygons to_subtract; to_subtract.reserve(collapsed.size() + number_polygons(surfaces)); for (Surfaces::const_iterator it_surface = surfaces.begin(); it_surface != surfaces.end(); ++ it_surface) if (it_surface->surface_type == stInternalVoid) polygons_append(to_subtract, *it_surface); polygons_append(to_subtract, collapsed); surfaces_append( surfaces, intersection_ex( offset(collapsed, distance_between_surfaces), to_subtract, true), stInternalSolid); } if (0) { // require "Slic3r/SVG.pm"; // Slic3r::SVG::output("fill_" . $layerm->print_z . ".svg", // expolygons => [ map $_->expolygon, grep !$_->is_solid, @surfaces ], // red_expolygons => [ map $_->expolygon, grep $_->is_solid, @surfaces ], // ); } for (Surfaces::const_iterator surface_it = surfaces.begin(); surface_it != surfaces.end(); ++ surface_it) { const Surface &surface = *surface_it; if (surface.surface_type == stInternalVoid) continue; InfillPattern fill_pattern = layerm.region()->config.fill_pattern.value; double density = fill_density; FlowRole role = (surface.surface_type == stTop) ? frTopSolidInfill : (surface.is_solid() ? frSolidInfill : frInfill); bool is_bridge = layerm.layer()->id() > 0 && surface.is_bridge(); if (surface.is_solid()) { density = 100.; fill_pattern = (surface.is_external() && ! is_bridge) ? layerm.region()->config.external_fill_pattern.value : ipRectilinear; } else if (density <= 0) continue; // get filler object #if SLIC3R_CPPVER >= 11 std::unique_ptr f = std::unique_ptr(Fill::new_from_type(fill_pattern)); #else std::auto_ptr f = std::auto_ptr(Fill::new_from_type(fill_pattern)); #endif f->set_bounding_box(layerm.layer()->object()->bounding_box()); // calculate the actual flow we'll be using for this infill coordf_t h = (surface.thickness == -1) ? layerm.layer()->height : surface.thickness; Flow flow = layerm.region()->flow( role, h, is_bridge || f->use_bridge_flow(), // bridge flow? layerm.layer()->id() == 0, // first layer? -1, // auto width *layerm.layer()->object() ); // calculate flow spacing for infill pattern generation bool using_internal_flow = false; if (! surface.is_solid() && ! is_bridge) { // it's internal infill, so we can calculate a generic flow spacing // for all layers, for avoiding the ugly effect of // misaligned infill on first layer because of different extrusion width and // layer height Flow internal_flow = layerm.region()->flow( frInfill, layerm.layer()->object()->config.layer_height.value, // TODO: handle infill_every_layers? false, // no bridge false, // no first layer -1, // auto width *layerm.layer()->object() ); f->spacing = internal_flow.spacing(); using_internal_flow = true; } else { f->spacing = flow.spacing(); } double link_max_length = 0.; if (! is_bridge) { #if 0 link_max_length = layerm.region()->config.get_abs_value(surface.is_external() ? "external_fill_link_max_length" : "fill_link_max_length", flow.spacing()); // printf("flow spacing: %f, is_external: %d, link_max_length: %lf\n", flow.spacing(), int(surface.is_external()), link_max_length); #else if (density > 80.) // 80% link_max_length = 3. * f->spacing; #endif } f->layer_id = layerm.layer()->id(); f->z = layerm.layer()->print_z; f->angle = Geometry::deg2rad(layerm.region()->config.fill_angle.value); // Maximum length of the perimeter segment linking two infill lines. f->link_max_length = scale_(link_max_length); // Used by the concentric infill pattern to clip the loops to create extrusion paths. f->loop_clipping = scale_(flow.nozzle_diameter) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER; // f->layer_height = h; // apply half spacing using this flow's own spacing and generate infill FillParams params; params.density = 0.01 * density; // params.dont_adjust = true; params.dont_adjust = false; Polylines polylines = f->fill_surface(&surface, params); if (polylines.empty()) continue; // calculate actual flow from spacing (which might have been adjusted by the infill // pattern generator) if (using_internal_flow) { // if we used the internal flow we're not doing a solid infill // so we can safely ignore the slight variation that might have // been applied to $f->flow_spacing } else { flow = Flow::new_from_spacing(f->spacing, flow.nozzle_diameter, h, is_bridge || f->use_bridge_flow()); } // save into layer { ExtrusionRole role = is_bridge ? erBridgeInfill : (surface.is_solid() ? ((surface.surface_type == stTop) ? erTopSolidInfill : erSolidInfill) : erInternalInfill); ExtrusionEntityCollection &collection = *(new ExtrusionEntityCollection()); out.entities.push_back(&collection); // Only concentric fills are not sorted. collection.no_sort = f->no_sort(); for (Polylines::iterator it = polylines.begin(); it != polylines.end(); ++ it) { ExtrusionPath *path = new ExtrusionPath(role, flow.mm3_per_mm(), flow.width, flow.height); collection.entities.push_back(path); path->polyline.points.swap(it->points); } } } // add thin fill regions // thin_fills are of C++ Slic3r::ExtrusionEntityCollection, perl type Slic3r::ExtrusionPath::Collection // Unpacks the collection, creates multiple collections per path. // The path type could be ExtrusionPath, ExtrusionLoop or ExtrusionEntityCollection. // Why the paths are unpacked? for (ExtrusionEntitiesPtr::iterator thin_fill = layerm.thin_fills.entities.begin(); thin_fill != layerm.thin_fills.entities.end(); ++ thin_fill) { ExtrusionEntityCollection &collection = *(new ExtrusionEntityCollection()); out.entities.push_back(&collection); collection.entities.push_back((*thin_fill)->clone()); } } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/Fill.hpp000066400000000000000000000012331301441720000220710ustar00rootroot00000000000000#ifndef slic3r_Fill_hpp_ #define slic3r_Fill_hpp_ #include #include #include #include "../libslic3r.h" #include "../BoundingBox.hpp" #include "../PrintConfig.hpp" #include "FillBase.hpp" namespace Slic3r { class ExtrusionEntityCollection; class LayerRegion; // An interface class to Perl, aggregating an instance of a Fill and a FillData. class Filler { public: Filler() : fill(NULL) {} ~Filler() { delete fill; fill = NULL; } Fill *fill; FillParams params; }; void make_fill(LayerRegion &layerm, ExtrusionEntityCollection &out); } // namespace Slic3r #endif // slic3r_Fill_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/Fill3DHoneycomb.cpp000066400000000000000000000214371301441720000241270ustar00rootroot00000000000000#include "../ClipperUtils.hpp" #include "../PolylineCollection.hpp" #include "../Surface.hpp" #include "Fill3DHoneycomb.hpp" namespace Slic3r { /* Creates a contiguous sequence of points at a specified height that make up a horizontal slice of the edges of a space filling truncated octahedron tesselation. The octahedrons are oriented so that the square faces are in the horizontal plane with edges parallel to the X and Y axes. Credits: David Eccles (gringer). */ // Generate an array of points that are in the same direction as the // basic printing line (i.e. Y points for columns, X points for rows) // Note: a negative offset only causes a change in the perpendicular // direction static std::vector colinearPoints(const coordf_t offset, const size_t baseLocation, size_t gridLength) { const coordf_t offset2 = std::abs(offset / coordf_t(2.)); std::vector points; points.push_back(baseLocation - offset2); for (size_t i = 0; i < gridLength; ++i) { points.push_back(baseLocation + i + offset2); points.push_back(baseLocation + i + 1 - offset2); } points.push_back(baseLocation + gridLength + offset2); return points; } // Generate an array of points for the dimension that is perpendicular to // the basic printing line (i.e. X points for columns, Y points for rows) static std::vector perpendPoints(const coordf_t offset, const size_t baseLocation, size_t gridLength) { coordf_t offset2 = offset / coordf_t(2.); coord_t side = 2 * (baseLocation & 1) - 1; std::vector points; points.push_back(baseLocation - offset2 * side); for (size_t i = 0; i < gridLength; ++i) { side = 2*((i+baseLocation) & 1) - 1; points.push_back(baseLocation + offset2 * side); points.push_back(baseLocation + offset2 * side); } points.push_back(baseLocation - offset2 * side); return points; } template static inline T clamp(T low, T high, T x) { return std::max(low, std::min(high, x)); } // Trims an array of points to specified rectangular limits. Point // components that are outside these limits are set to the limits. static inline void trim(Pointfs &pts, coordf_t minX, coordf_t minY, coordf_t maxX, coordf_t maxY) { for (Pointfs::iterator it = pts.begin(); it != pts.end(); ++ it) { it->x = clamp(minX, maxX, it->x); it->y = clamp(minY, maxY, it->y); } } static inline Pointfs zip(const std::vector &x, const std::vector &y) { assert(x.size() == y.size()); Pointfs out; out.reserve(x.size()); for (size_t i = 0; i < x.size(); ++ i) out.push_back(Pointf(x[i], y[i])); return out; } // Generate a set of curves (array of array of 2d points) that describe a // horizontal slice of a truncated regular octahedron with edge length 1. // curveType specifies which lines to print, 1 for vertical lines // (columns), 2 for horizontal lines (rows), and 3 for both. static std::vector makeNormalisedGrid(coordf_t z, size_t gridWidth, size_t gridHeight, size_t curveType) { // offset required to create a regular octagram coordf_t octagramGap = coordf_t(0.5); // sawtooth wave function for range f($z) = [-$octagramGap .. $octagramGap] coordf_t a = std::sqrt(coordf_t(2.)); // period coordf_t wave = fabs(fmod(z, a) - a/2.)/a*4. - 1.; coordf_t offset = wave * octagramGap; std::vector points; if ((curveType & 1) != 0) { for (size_t x = 0; x <= gridWidth; ++x) { points.push_back(Pointfs()); Pointfs &newPoints = points.back(); newPoints = zip( perpendPoints(offset, x, gridHeight), colinearPoints(offset, 0, gridHeight)); // trim points to grid edges trim(newPoints, coordf_t(0.), coordf_t(0.), coordf_t(gridWidth), coordf_t(gridHeight)); if (x & 1) std::reverse(newPoints.begin(), newPoints.end()); } } if ((curveType & 2) != 0) { for (size_t y = 0; y <= gridHeight; ++y) { points.push_back(Pointfs()); Pointfs &newPoints = points.back(); newPoints = zip( colinearPoints(offset, 0, gridWidth), perpendPoints(offset, y, gridWidth)); // trim points to grid edges trim(newPoints, coordf_t(0.), coordf_t(0.), coordf_t(gridWidth), coordf_t(gridHeight)); if (y & 1) std::reverse(newPoints.begin(), newPoints.end()); } } return points; } // Generate a set of curves (array of array of 2d points) that describe a // horizontal slice of a truncated regular octahedron with a specified // grid square size. static Polylines makeGrid(coord_t z, coord_t gridSize, size_t gridWidth, size_t gridHeight, size_t curveType) { coord_t scaleFactor = gridSize; coordf_t normalisedZ = coordf_t(z) / coordf_t(scaleFactor); std::vector polylines = makeNormalisedGrid(normalisedZ, gridWidth, gridHeight, curveType); Polylines result; result.reserve(polylines.size()); for (std::vector::const_iterator it_polylines = polylines.begin(); it_polylines != polylines.end(); ++ it_polylines) { result.push_back(Polyline()); Polyline &polyline = result.back(); for (Pointfs::const_iterator it = it_polylines->begin(); it != it_polylines->end(); ++ it) polyline.points.push_back(Point(coord_t(it->x * scaleFactor), coord_t(it->y * scaleFactor))); } return result; } void Fill3DHoneycomb::_fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out) { // no rotation is supported for this infill pattern BoundingBox bb = expolygon.contour.bounding_box(); coord_t distance = coord_t(scale_(this->spacing) / params.density); // align bounding box to a multiple of our honeycomb grid module // (a module is 2*$distance since one $distance half-module is // growing while the other $distance half-module is shrinking) bb.merge(_align_to_grid(bb.min, Point(2*distance, 2*distance))); // generate pattern Polylines polylines = makeGrid( scale_(this->z), distance, ceil(bb.size().x / distance) + 1, ceil(bb.size().y / distance) + 1, ((this->layer_id/thickness_layers) % 2) + 1); // move pattern in place for (Polylines::iterator it = polylines.begin(); it != polylines.end(); ++ it) it->translate(bb.min.x, bb.min.y); // clip pattern to boundaries intersection(polylines, (Polygons)expolygon, &polylines); // connect lines if (! params.dont_connect && ! polylines.empty()) { // prevent calling leftmost_point() on empty collections ExPolygon expolygon_off; { ExPolygons expolygons_off = offset_ex(expolygon, SCALED_EPSILON); if (! expolygons_off.empty()) { // When expanding a polygon, the number of islands could only shrink. Therefore the offset_ex shall generate exactly one expanded island for one input island. assert(expolygons_off.size() == 1); std::swap(expolygon_off, expolygons_off.front()); } } Polylines chained = PolylineCollection::chained_path_from( #if SLIC3R_CPPVER >= 11 std::move(polylines), #else polylines, #endif PolylineCollection::leftmost_point(polylines), false); // reverse allowed bool first = true; for (Polylines::iterator it_polyline = chained.begin(); it_polyline != chained.end(); ++ it_polyline) { if (! first) { // Try to connect the lines. Points &pts_end = polylines_out.back().points; const Point &first_point = it_polyline->points.front(); const Point &last_point = pts_end.back(); // TODO: we should also check that both points are on a fill_boundary to avoid // connecting paths on the boundaries of internal regions if (first_point.distance_to(last_point) <= 1.5 * distance && expolygon_off.contains(Line(last_point, first_point))) { // Append the polyline. pts_end.insert(pts_end.end(), it_polyline->points.begin(), it_polyline->points.end()); continue; } } // The lines cannot be connected. #if SLIC3R_CPPVER >= 11 polylines_out.push_back(std::move(*it_polyline)); #else polylines_out.push_back(Polyline()); std::swap(polylines_out.back(), *it_polyline); #endif first = false; } } } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/Fill3DHoneycomb.hpp000066400000000000000000000013361301441720000241300ustar00rootroot00000000000000#ifndef slic3r_Fill3DHoneycomb_hpp_ #define slic3r_Fill3DHoneycomb_hpp_ #include #include "../libslic3r.h" #include "FillBase.hpp" namespace Slic3r { class Fill3DHoneycomb : public Fill { public: virtual ~Fill3DHoneycomb() {} // require bridge flow since most of this pattern hangs in air virtual bool use_bridge_flow() const { return true; } protected: virtual void _fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out); }; } // namespace Slic3r #endif // slic3r_Fill3DHoneycomb_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillBase.cpp000066400000000000000000000114361301441720000226650ustar00rootroot00000000000000#include #include "../ClipperUtils.hpp" #include "../Surface.hpp" #include "../PrintConfig.hpp" #include "FillBase.hpp" #include "FillConcentric.hpp" #include "FillHoneycomb.hpp" #include "Fill3DHoneycomb.hpp" #include "FillPlanePath.hpp" #include "FillRectilinear.hpp" #include "FillRectilinear2.hpp" namespace Slic3r { Fill* Fill::new_from_type(const InfillPattern type) { switch (type) { case ipConcentric: return new FillConcentric(); case ipHoneycomb: return new FillHoneycomb(); case ip3DHoneycomb: return new Fill3DHoneycomb(); case ipRectilinear: return new FillRectilinear2(); // case ipRectilinear: return new FillRectilinear(); case ipLine: return new FillLine(); case ipGrid: return new FillGrid2(); case ipTriangles: return new FillTriangles(); case ipStars: return new FillStars(); case ipCubic: return new FillCubic(); // case ipGrid: return new FillGrid(); case ipArchimedeanChords: return new FillArchimedeanChords(); case ipHilbertCurve: return new FillHilbertCurve(); case ipOctagramSpiral: return new FillOctagramSpiral(); default: CONFESS("unknown type"); return NULL; } } Fill* Fill::new_from_type(const std::string &type) { static t_config_enum_values enum_keys_map = ConfigOptionEnum::get_enum_values(); t_config_enum_values::const_iterator it = enum_keys_map.find(type); return (it == enum_keys_map.end()) ? NULL : new_from_type(InfillPattern(it->second)); } Polylines Fill::fill_surface(const Surface *surface, const FillParams ¶ms) { // Perform offset. Slic3r::ExPolygons expp; offset(surface->expolygon, &expp, -0.5*scale_(this->spacing)); // Create the infills for each of the regions. Polylines polylines_out; for (size_t i = 0; i < expp.size(); ++ i) _fill_surface_single( params, surface->thickness_layers, _infill_direction(surface), expp[i], polylines_out); return polylines_out; } // Calculate a new spacing to fill width with possibly integer number of lines, // the first and last line being centered at the interval ends. // This function possibly increases the spacing, never decreases, // and for a narrow width the increase in spacing may become severe, // therefore the adjustment is limited to 20% increase. coord_t Fill::_adjust_solid_spacing(const coord_t width, const coord_t distance) { assert(width >= 0); assert(distance > 0); // floor(width / distance) coord_t number_of_intervals = (width - EPSILON) / distance; coord_t distance_new = (number_of_intervals == 0) ? distance : ((width - EPSILON) / number_of_intervals); const coordf_t factor = coordf_t(distance_new) / coordf_t(distance); assert(factor > 1. - 1e-5); // How much could the extrusion width be increased? By 20%. const coordf_t factor_max = 1.2; if (factor > factor_max) distance_new = coord_t(floor((coordf_t(distance) * factor_max + 0.5))); return distance_new; } // Returns orientation of the infill and the reference point of the infill pattern. // For a normal print, the reference point is the center of a bounding box of the STL. std::pair Fill::_infill_direction(const Surface *surface) const { // set infill angle float out_angle = this->angle; if (out_angle == FLT_MAX) { //FIXME Vojtech: Add a warning? printf("Using undefined infill angle\n"); out_angle = 0.f; } // Bounding box is the bounding box of a perl object Slic3r::Print::Object (c++ object Slic3r::PrintObject) // The bounding box is only undefined in unit tests. Point out_shift = empty(this->bounding_box) ? surface->expolygon.contour.bounding_box().center() : this->bounding_box.center(); #if 0 if (empty(this->bounding_box)) { printf("Fill::_infill_direction: empty bounding box!"); } else { printf("Fill::_infill_direction: reference point %d, %d\n", out_shift.x, out_shift.y); } #endif if (surface->bridge_angle >= 0) { // use bridge angle //FIXME Vojtech: Add a debugf? // Slic3r::debugf "Filling bridge with angle %d\n", rad2deg($surface->bridge_angle); #ifdef SLIC3R_DEBUG printf("Filling bridge with angle %f\n", surface->bridge_angle); #endif /* SLIC3R_DEBUG */ out_angle = surface->bridge_angle; } else if (this->layer_id != size_t(-1)) { // alternate fill direction out_angle += this->_layer_angle(this->layer_id / surface->thickness_layers); } else { // printf("Layer_ID undefined!\n"); } out_angle += float(M_PI/2.); return std::pair(out_angle, out_shift); } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillBase.hpp000066400000000000000000000105061301441720000226670ustar00rootroot00000000000000#ifndef slic3r_FillBase_hpp_ #define slic3r_FillBase_hpp_ #include #include #include #include #include "../libslic3r.h" #include "../BoundingBox.hpp" #include "../PrintConfig.hpp" namespace Slic3r { class Surface; struct FillParams { FillParams() { memset(this, 0, sizeof(FillParams)); // Adjustment does not work. dont_adjust = true; } // Fill density, fraction in <0, 1> float density; // Don't connect the fill lines around the inner perimeter. bool dont_connect; // Don't adjust spacing to fill the space evenly. bool dont_adjust; // For Honeycomb. // we were requested to complete each loop; // in this case we don't try to make more continuous paths bool complete; }; class Fill { public: // Index of the layer. size_t layer_id; // Z coordinate of the top print surface, in unscaled coordinates coordf_t z; // in unscaled coordinates coordf_t spacing; // in radians, ccw, 0 = East float angle; // In scaled coordinates. Maximum lenght of a perimeter segment connecting two infill lines. // Used by the FillRectilinear2, FillGrid2, FillTriangles, FillStars and FillCubic. // If left to zero, the links will not be limited. coord_t link_max_length; // In scaled coordinates. Used by the concentric infill pattern to clip the loops to create extrusion paths. coord_t loop_clipping; // In scaled coordinates. Bounding box of the 2D projection of the object. BoundingBox bounding_box; public: virtual ~Fill() {} static Fill* new_from_type(const InfillPattern type); static Fill* new_from_type(const std::string &type); void set_bounding_box(const Slic3r::BoundingBox &bbox) { bounding_box = bbox; } // Use bridge flow for the fill? virtual bool use_bridge_flow() const { return false; } // Do not sort the fill lines to optimize the print head path? virtual bool no_sort() const { return false; } // Perform the fill. virtual Polylines fill_surface(const Surface *surface, const FillParams ¶ms); protected: Fill() : layer_id(size_t(-1)), z(0.f), spacing(0.f), // Initial angle is undefined. angle(FLT_MAX), link_max_length(0), loop_clipping(0), // The initial bounding box is empty, therefore undefined. bounding_box(Point(0, 0), Point(-1, -1)) {} // The expolygon may be modified by the method to avoid a copy. virtual void _fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out) {} static coord_t _adjust_solid_spacing(const coord_t width, const coord_t distance); virtual float _layer_angle(size_t idx) const { bool odd = idx & 1; return (idx & 1) ? float(M_PI/2.) : 0; } virtual std::pair _infill_direction(const Surface *surface) const; // Align a coordinate to a grid. The coordinate may be negative, // the aligned value will never be bigger than the original one. static coord_t _align_to_grid(const coord_t coord, const coord_t spacing) { // Current C++ standard defines the result of integer division to be rounded to zero, // for both positive and negative numbers. Here we want to round down for negative // numbers as well. coord_t aligned = (coord < 0) ? ((coord - spacing + 1) / spacing) * spacing : (coord / spacing) * spacing; assert(aligned <= coord); return aligned; } static Point _align_to_grid(Point coord, Point spacing) { return Point(_align_to_grid(coord.x, spacing.x), _align_to_grid(coord.y, spacing.y)); } static coord_t _align_to_grid(coord_t coord, coord_t spacing, coord_t base) { return base + _align_to_grid(coord - base, spacing); } static Point _align_to_grid(Point coord, Point spacing, Point base) { return Point(_align_to_grid(coord.x, spacing.x, base.x), _align_to_grid(coord.y, spacing.y, base.y)); } }; } // namespace Slic3r #endif // slic3r_FillBase_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillConcentric.cpp000066400000000000000000000044021301441720000240750ustar00rootroot00000000000000#include "../ClipperUtils.hpp" #include "../ExPolygon.hpp" #include "../Surface.hpp" #include "FillConcentric.hpp" namespace Slic3r { void FillConcentric::_fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out) { // no rotation is supported for this infill pattern BoundingBox bounding_box = expolygon.contour.bounding_box(); coord_t min_spacing = scale_(this->spacing); coord_t distance = coord_t(min_spacing / params.density); if (params.density > 0.9999f && !params.dont_adjust) { distance = this->_adjust_solid_spacing(bounding_box.size().x, distance); this->spacing = unscale(distance); } Polygons loops = (Polygons)expolygon; Polygons last = loops; while (! last.empty()) { last = offset2(last, -(distance + min_spacing/2), +min_spacing/2); loops.insert(loops.end(), last.begin(), last.end()); } // generate paths from the outermost to the innermost, to avoid // adhesion problems of the first central tiny loops union_pt_chained(loops, &loops, false); // split paths using a nearest neighbor search size_t iPathFirst = polylines_out.size(); Point last_pos(0, 0); for (Polygons::const_iterator it_loop = loops.begin(); it_loop != loops.end(); ++ it_loop) { polylines_out.push_back(it_loop->split_at_index(last_pos.nearest_point_index(*it_loop))); last_pos = polylines_out.back().last_point(); } // clip the paths to prevent the extruder from getting exactly on the first point of the loop // Keep valid paths only. size_t j = iPathFirst; for (size_t i = iPathFirst; i < polylines_out.size(); ++ i) { polylines_out[i].clip_end(this->loop_clipping); if (polylines_out[i].is_valid()) { if (j < i) std::swap(polylines_out[j], polylines_out[i]); ++ j; } } if (j < polylines_out.size()) polylines_out.erase(polylines_out.begin() + j, polylines_out.end()); // TODO: return ExtrusionLoop objects to get better chained paths } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillConcentric.hpp000066400000000000000000000011431301441720000241010ustar00rootroot00000000000000#ifndef slic3r_FillConcentric_hpp_ #define slic3r_FillConcentric_hpp_ #include "FillBase.hpp" namespace Slic3r { class FillConcentric : public Fill { public: virtual ~FillConcentric() {} protected: virtual void _fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out); virtual bool no_sort() const { return true; } }; } // namespace Slic3r #endif // slic3r_FillConcentric_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillHoneycomb.cpp000066400000000000000000000137041301441720000237360ustar00rootroot00000000000000#include "../ClipperUtils.hpp" #include "../PolylineCollection.hpp" #include "../Surface.hpp" #include "FillHoneycomb.hpp" namespace Slic3r { void FillHoneycomb::_fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out) { // cache hexagons math CacheID cache_id(params.density, this->spacing); Cache::iterator it_m = this->cache.find(cache_id); if (it_m == this->cache.end()) { #if 0 // #if SLIC3R_CPPVER > 11 it_m = this->cache.emplace_hint(it_m); #else it_m = this->cache.insert(it_m, std::pair(cache_id, CacheData())); #endif CacheData &m = it_m->second; coord_t min_spacing = scale_(this->spacing); m.distance = min_spacing / params.density; m.hex_side = m.distance / (sqrt(3)/2); m.hex_width = m.distance * 2; // $m->{hex_width} == $m->{hex_side} * sqrt(3); coord_t hex_height = m.hex_side * 2; m.pattern_height = hex_height + m.hex_side; m.y_short = m.distance * sqrt(3)/3; m.x_offset = min_spacing / 2; m.y_offset = m.x_offset * sqrt(3)/3; m.hex_center = Point(m.hex_width/2, m.hex_side); } CacheData &m = it_m->second; Polygons polygons; { // adjust actual bounding box to the nearest multiple of our hex pattern // and align it so that it matches across layers BoundingBox bounding_box = expolygon.contour.bounding_box(); { // rotate bounding box according to infill direction Polygon bb_polygon = bounding_box.polygon(); bb_polygon.rotate(direction.first, m.hex_center); bounding_box = bb_polygon.bounding_box(); // extend bounding box so that our pattern will be aligned with other layers // $bounding_box->[X1] and [Y1] represent the displacement between new bounding box offset and old one // The infill is not aligned to the object bounding box, but to a world coordinate system. Supposedly good enough. bounding_box.merge(_align_to_grid(bounding_box.min, Point(m.hex_width, m.pattern_height))); } coord_t x = bounding_box.min.x; while (x <= bounding_box.max.x) { Polygon p; coord_t ax[2] = { x + m.x_offset, x + m.distance - m.x_offset }; for (size_t i = 0; i < 2; ++ i) { std::reverse(p.points.begin(), p.points.end()); // turn first half upside down for (coord_t y = bounding_box.min.y; y <= bounding_box.max.y; y += m.y_short + m.hex_side + m.y_short + m.hex_side) { p.points.push_back(Point(ax[1], y + m.y_offset)); p.points.push_back(Point(ax[0], y + m.y_short - m.y_offset)); p.points.push_back(Point(ax[0], y + m.y_short + m.hex_side + m.y_offset)); p.points.push_back(Point(ax[1], y + m.y_short + m.hex_side + m.y_short - m.y_offset)); p.points.push_back(Point(ax[1], y + m.y_short + m.hex_side + m.y_short + m.hex_side + m.y_offset)); } ax[0] = ax[0] + m.distance; ax[1] = ax[1] + m.distance; std::swap(ax[0], ax[1]); // draw symmetrical pattern x += m.distance; } p.rotate(-direction.first, m.hex_center); polygons.push_back(p); } } if (params.complete || true) { // we were requested to complete each loop; // in this case we don't try to make more continuous paths Polygons polygons_trimmed = intersection((Polygons)expolygon, polygons); for (Polygons::iterator it = polygons_trimmed.begin(); it != polygons_trimmed.end(); ++ it) polylines_out.push_back(it->split_at_first_point()); } else { // consider polygons as polylines without re-appending the initial point: // this cuts the last segment on purpose, so that the jump to the next // path is more straight Polylines paths; { Polylines p; for (Polygons::iterator it = polygons.begin(); it != polygons.end(); ++ it) p.push_back((Polyline)(*it)); intersection(p, (Polygons)expolygon, &paths); } // connect paths if (! paths.empty()) { // prevent calling leftmost_point() on empty collections Polylines chained = PolylineCollection::chained_path_from( #if SLIC3R_CPPVER >= 11 std::move(paths), #else paths, #endif PolylineCollection::leftmost_point(paths), false); assert(paths.empty()); paths.clear(); for (Polylines::iterator it_path = chained.begin(); it_path != chained.end(); ++ it_path) { if (! paths.empty()) { // distance between first point of this path and last point of last path double distance = paths.back().last_point().distance_to(it_path->first_point()); if (distance <= m.hex_width) { paths.back().points.insert(paths.back().points.end(), it_path->points.begin(), it_path->points.end()); continue; } } // Don't connect the paths. paths.push_back(*it_path); } } // clip paths again to prevent connection segments from crossing the expolygon boundaries intersection(paths, to_polygons(offset_ex(expolygon, SCALED_EPSILON)), &paths); // Move the polylines to the output, avoid a deep copy. size_t j = polylines_out.size(); polylines_out.resize(j + paths.size(), Polyline()); for (size_t i = 0; i < paths.size(); ++ i) std::swap(polylines_out[j ++], paths[i]); } } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillHoneycomb.hpp000066400000000000000000000026121301441720000237370ustar00rootroot00000000000000#ifndef slic3r_FillHoneycomb_hpp_ #define slic3r_FillHoneycomb_hpp_ #include #include "../libslic3r.h" #include "FillBase.hpp" namespace Slic3r { class FillHoneycomb : public Fill { public: virtual ~FillHoneycomb() {} protected: virtual void _fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out); // Caching the struct CacheID { CacheID(float adensity, coordf_t aspacing) : density(adensity), spacing(aspacing) {} float density; coordf_t spacing; bool operator<(const CacheID &other) const { return (density < other.density) || (density == other.density && spacing < other.spacing); } bool operator==(const CacheID &other) const { return density == other.density && spacing == other.spacing; } }; struct CacheData { coord_t distance; coord_t hex_side; coord_t hex_width; coord_t pattern_height; coord_t y_short; coord_t x_offset; coord_t y_offset; Point hex_center; }; typedef std::map Cache; Cache cache; virtual float _layer_angle(size_t idx) const { return float(M_PI/3.) * (idx % 3); } }; } // namespace Slic3r #endif // slic3r_FillHoneycomb_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillPlanePath.cpp000066400000000000000000000150441301441720000236660ustar00rootroot00000000000000#include "../ClipperUtils.hpp" #include "../PolylineCollection.hpp" #include "../Surface.hpp" #include "FillPlanePath.hpp" namespace Slic3r { void FillPlanePath::_fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out) { expolygon.rotate(- direction.first); coord_t distance_between_lines = scale_(this->spacing) / params.density; // align infill across layers using the object's bounding box // Rotated bounding box of the whole object. BoundingBox bounding_box = this->bounding_box.rotated(- direction.first); Point shift = this->_centered() ? bounding_box.center() : bounding_box.min; expolygon.translate(-shift.x, -shift.y); bounding_box.translate(-shift.x, -shift.y); Pointfs pts = _generate( coord_t(ceil(coordf_t(bounding_box.min.x) / distance_between_lines)), coord_t(ceil(coordf_t(bounding_box.min.y) / distance_between_lines)), coord_t(ceil(coordf_t(bounding_box.max.x) / distance_between_lines)), coord_t(ceil(coordf_t(bounding_box.max.y) / distance_between_lines))); Polylines polylines; if (pts.size() >= 2) { // Convert points to a polyline, upscale. polylines.push_back(Polyline()); Polyline &polyline = polylines.back(); polyline.points.reserve(pts.size()); for (Pointfs::iterator it = pts.begin(); it != pts.end(); ++ it) polyline.points.push_back(Point( coord_t(floor(it->x * distance_between_lines + 0.5)), coord_t(floor(it->y * distance_between_lines + 0.5)))); // intersection(polylines_src, offset((Polygons)expolygon, scale_(0.02)), &polylines); intersection(polylines, (Polygons)expolygon, &polylines); /* if (1) { require "Slic3r/SVG.pm"; print "Writing fill.svg\n"; Slic3r::SVG::output("fill.svg", no_arrows => 1, polygons => \@$expolygon, green_polygons => [ $bounding_box->polygon ], polylines => [ $polyline ], red_polylines => \@paths, ); } */ // paths must be repositioned and rotated back for (Polylines::iterator it = polylines.begin(); it != polylines.end(); ++ it) { it->translate(shift.x, shift.y); it->rotate(direction.first); } } // Move the polylines to the output, avoid a deep copy. size_t j = polylines_out.size(); polylines_out.resize(j + polylines.size(), Polyline()); for (size_t i = 0; i < polylines.size(); ++ i) std::swap(polylines_out[j ++], polylines[i]); } // Follow an Archimedean spiral, in polar coordinates: r=a+b\theta Pointfs FillArchimedeanChords::_generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y) { // Radius to achieve. coordf_t rmax = std::sqrt(coordf_t(max_x)*coordf_t(max_x)+coordf_t(max_y)*coordf_t(max_y)) * std::sqrt(2.) + 1.5; // Now unwind the spiral. coordf_t a = 1.; coordf_t b = 1./(2.*M_PI); coordf_t theta = 0.; coordf_t r = 1; Pointfs out; //FIXME Vojtech: If used as a solid infill, there is a gap left at the center. out.push_back(Pointf(0, 0)); out.push_back(Pointf(1, 0)); while (r < rmax) { theta += 1. / r; r = a + b * theta; out.push_back(Pointf(r * cos(theta), r * sin(theta))); } return out; } // Adapted from // http://cpansearch.perl.org/src/KRYDE/Math-PlanePath-122/lib/Math/PlanePath/HilbertCurve.pm // // state=0 3--2 plain // | // 0--1 // // state=4 1--2 transpose // | | // 0 3 // // state=8 // // state=12 3 0 rot180 + transpose // | | // 2--1 // static inline Point hilbert_n_to_xy(const size_t n) { static const int next_state[16] = { 4,0,0,12, 0,4,4,8, 12,8,8,4, 8,12,12,0 }; static const int digit_to_x[16] = { 0,1,1,0, 0,0,1,1, 1,0,0,1, 1,1,0,0 }; static const int digit_to_y[16] = { 0,0,1,1, 0,1,1,0, 1,1,0,0, 1,0,0,1 }; // Number of 2 bit digits. size_t ndigits = 0; { size_t nc = n; while(nc > 0) { nc >>= 2; ++ ndigits; } } int state = (ndigits & 1) ? 4 : 0; int dirstate = (ndigits & 1) ? 0 : 4; coord_t x = 0; coord_t y = 0; for (int i = (int)ndigits - 1; i >= 0; -- i) { int digit = (n >> (i * 2)) & 3; state += digit; if (digit != 3) dirstate = state; // lowest non-3 digit x |= digit_to_x[state] << i; y |= digit_to_y[state] << i; state = next_state[state]; } return Point(x, y); } Pointfs FillHilbertCurve::_generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y) { // Minimum power of two square to fit the domain. size_t sz = 2; size_t pw = 1; { size_t sz0 = std::max(max_x + 1 - min_x, max_y + 1 - min_y); while (sz < sz0) { sz = sz << 1; ++ pw; } } size_t sz2 = sz * sz; Pointfs line; line.reserve(sz2); for (size_t i = 0; i < sz2; ++ i) { Point p = hilbert_n_to_xy(i); line.push_back(Pointf(p.x + min_x, p.y + min_y)); } return line; } Pointfs FillOctagramSpiral::_generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y) { // Radius to achieve. coordf_t rmax = std::sqrt(coordf_t(max_x)*coordf_t(max_x)+coordf_t(max_y)*coordf_t(max_y)) * std::sqrt(2.) + 1.5; // Now unwind the spiral. coordf_t r = 0; coordf_t r_inc = sqrt(2.); Pointfs out; out.push_back(Pointf(0, 0)); while (r < rmax) { r += r_inc; coordf_t rx = r / sqrt(2.); coordf_t r2 = r + rx; out.push_back(Pointf( r, 0.)); out.push_back(Pointf( r2, rx)); out.push_back(Pointf( rx, rx)); out.push_back(Pointf( rx, r2)); out.push_back(Pointf(0., r)); out.push_back(Pointf(-rx, r2)); out.push_back(Pointf(-rx, rx)); out.push_back(Pointf(-r2, rx)); out.push_back(Pointf(-r, 0.)); out.push_back(Pointf(-r2, -rx)); out.push_back(Pointf(-rx, -rx)); out.push_back(Pointf(-rx, -r2)); out.push_back(Pointf(0., -r)); out.push_back(Pointf( rx, -r2)); out.push_back(Pointf( rx, -rx)); out.push_back(Pointf( r2+r_inc, -rx)); } return out; } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillPlanePath.hpp000066400000000000000000000033551301441720000236750ustar00rootroot00000000000000#ifndef slic3r_FillPlanePath_hpp_ #define slic3r_FillPlanePath_hpp_ #include #include "../libslic3r.h" #include "FillBase.hpp" namespace Slic3r { // The original Perl code used path generators from Math::PlanePath library: // http://user42.tuxfamily.org/math-planepath/ // http://user42.tuxfamily.org/math-planepath/gallery.html class FillPlanePath : public Fill { public: virtual ~FillPlanePath() {} protected: virtual void _fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out); virtual float _layer_angle(size_t idx) const { return 0.f; } virtual bool _centered() const = 0; virtual Pointfs _generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y) = 0; }; class FillArchimedeanChords : public FillPlanePath { public: virtual ~FillArchimedeanChords() {} protected: virtual bool _centered() const { return true; } virtual Pointfs _generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y); }; class FillHilbertCurve : public FillPlanePath { public: virtual ~FillHilbertCurve() {} protected: virtual bool _centered() const { return false; } virtual Pointfs _generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y); }; class FillOctagramSpiral : public FillPlanePath { public: virtual ~FillOctagramSpiral() {} protected: virtual bool _centered() const { return true; } virtual Pointfs _generate(coord_t min_x, coord_t min_y, coord_t max_x, coord_t max_y); }; } // namespace Slic3r #endif // slic3r_FillPlanePath_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillRectilinear.cpp000066400000000000000000000145321301441720000242540ustar00rootroot00000000000000#include "../ClipperUtils.hpp" #include "../ExPolygon.hpp" #include "../PolylineCollection.hpp" #include "../Surface.hpp" #include "FillRectilinear.hpp" namespace Slic3r { void FillRectilinear::_fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out) { // rotate polygons so that we can work with vertical lines here expolygon.rotate(- direction.first); this->_min_spacing = scale_(this->spacing); assert(params.density > 0.0001f && params.density <= 1.f); this->_line_spacing = coord_t(coordf_t(this->_min_spacing) / params.density); this->_diagonal_distance = this->_line_spacing * 2; this->_line_oscillation = this->_line_spacing - this->_min_spacing; // only for Line infill BoundingBox bounding_box = expolygon.contour.bounding_box(); // define flow spacing according to requested density if (params.density > 0.9999f && !params.dont_adjust) { this->_line_spacing = this->_adjust_solid_spacing(bounding_box.size().x, this->_line_spacing); this->spacing = unscale(this->_line_spacing); } else { // extend bounding box so that our pattern will be aligned with other layers // Transform the reference point to the rotated coordinate system. bounding_box.merge(_align_to_grid( bounding_box.min, Point(this->_line_spacing, this->_line_spacing), direction.second.rotated(- direction.first))); } // generate the basic pattern coord_t x_max = bounding_box.max.x + SCALED_EPSILON; Lines lines; for (coord_t x = bounding_box.min.x; x <= x_max; x += this->_line_spacing) lines.push_back(this->_line(lines.size(), x, bounding_box.min.y, bounding_box.max.y)); if (this->_horizontal_lines()) { coord_t y_max = bounding_box.max.y + SCALED_EPSILON; for (coord_t y = bounding_box.min.y; y <= y_max; y += this->_line_spacing) lines.push_back(Line(Point(bounding_box.min.x, y), Point(bounding_box.max.x, y))); } // clip paths against a slightly larger expolygon, so that the first and last paths // are kept even if the expolygon has vertical sides // the minimum offset for preventing edge lines from being clipped is SCALED_EPSILON; // however we use a larger offset to support expolygons with slightly skewed sides and // not perfectly straight //FIXME Vojtech: Update the intersecton function to work directly with lines. Polylines polylines_src; polylines_src.reserve(lines.size()); for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++ it) { polylines_src.push_back(Polyline()); Points &pts = polylines_src.back().points; pts.reserve(2); pts.push_back(it->a); pts.push_back(it->b); } Polylines polylines = intersection(polylines_src, offset((Polygons)expolygon, scale_(0.02)), false); // FIXME Vojtech: This is only performed for horizontal lines, not for the vertical lines! const float INFILL_OVERLAP_OVER_SPACING = 0.3f; // How much to extend an infill path from expolygon outside? coord_t extra = coord_t(floor(this->_min_spacing * INFILL_OVERLAP_OVER_SPACING + 0.5f)); for (Polylines::iterator it_polyline = polylines.begin(); it_polyline != polylines.end(); ++ it_polyline) { Point *first_point = &it_polyline->points.front(); Point *last_point = &it_polyline->points.back(); if (first_point->y > last_point->y) std::swap(first_point, last_point); first_point->y -= extra; last_point->y += extra; } size_t n_polylines_out_old = polylines_out.size(); // connect lines if (! params.dont_connect && ! polylines.empty()) { // prevent calling leftmost_point() on empty collections // offset the expolygon by max(min_spacing/2, extra) ExPolygon expolygon_off; { ExPolygons expolygons_off = offset_ex(expolygon, this->_min_spacing/2); if (! expolygons_off.empty()) { // When expanding a polygon, the number of islands could only shrink. Therefore the offset_ex shall generate exactly one expanded island for one input island. assert(expolygons_off.size() == 1); std::swap(expolygon_off, expolygons_off.front()); } } Polylines chained = PolylineCollection::chained_path_from( #if SLIC3R_CPPVER >= 11 std::move(polylines), #else polylines, #endif PolylineCollection::leftmost_point(polylines), false); // reverse allowed bool first = true; for (Polylines::iterator it_polyline = chained.begin(); it_polyline != chained.end(); ++ it_polyline) { if (! first) { // Try to connect the lines. Points &pts_end = polylines_out.back().points; const Point &first_point = it_polyline->points.front(); const Point &last_point = pts_end.back(); // Distance in X, Y. const Vector distance = first_point.vector_to(last_point); // TODO: we should also check that both points are on a fill_boundary to avoid // connecting paths on the boundaries of internal regions if (this->_can_connect(std::abs(distance.x), std::abs(distance.y)) && expolygon_off.contains(Line(last_point, first_point))) { // Append the polyline. pts_end.insert(pts_end.end(), it_polyline->points.begin(), it_polyline->points.end()); continue; } } // The lines cannot be connected. #if SLIC3R_CPPVER >= 11 polylines_out.push_back(std::move(*it_polyline)); #else polylines_out.push_back(Polyline()); std::swap(polylines_out.back(), *it_polyline); #endif first = false; } } // paths must be rotated back for (Polylines::iterator it = polylines_out.begin() + n_polylines_out_old; it != polylines_out.end(); ++ it) { // No need to translate, the absolute position is irrelevant. // it->translate(- direction.second.x, - direction.second.y); it->rotate(direction.first); } } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillRectilinear.hpp000066400000000000000000000043531301441720000242610ustar00rootroot00000000000000#ifndef slic3r_FillRectilinear_hpp_ #define slic3r_FillRectilinear_hpp_ #include "../libslic3r.h" #include "FillBase.hpp" namespace Slic3r { class Surface; class FillRectilinear : public Fill { public: virtual ~FillRectilinear() {} protected: virtual void _fill_surface_single( const FillParams ¶ms, unsigned int thickness_layers, const std::pair &direction, ExPolygon &expolygon, Polylines &polylines_out); coord_t _min_spacing; coord_t _line_spacing; // distance threshold for allowing the horizontal infill lines to be connected into a continuous path coord_t _diagonal_distance; // only for line infill coord_t _line_oscillation; // Enabled for the grid infill, disabled for the rectilinear and line infill. virtual bool _horizontal_lines() const { return false; } virtual Line _line(int i, coord_t x, coord_t y_min, coord_t y_max) const { return Line(Point(x, y_min), Point(x, y_max)); } virtual bool _can_connect(coord_t dist_X, coord_t dist_Y) { return dist_X <= this->_diagonal_distance && dist_Y <= this->_diagonal_distance; } }; class FillLine : public FillRectilinear { public: virtual ~FillLine() {} protected: virtual Line _line(int i, coord_t x, coord_t y_min, coord_t y_max) const { coord_t osc = (i & 1) ? this->_line_oscillation : 0; return Line(Point(x - osc, y_min), Point(x + osc, y_max)); } virtual bool _can_connect(coord_t dist_X, coord_t dist_Y) { coord_t TOLERANCE = 10 * SCALED_EPSILON; return (dist_X >= (this->_line_spacing - this->_line_oscillation) - TOLERANCE) && (dist_X <= (this->_line_spacing + this->_line_oscillation) + TOLERANCE) && (dist_Y <= this->_diagonal_distance); } }; class FillGrid : public FillRectilinear { public: virtual ~FillGrid() {} protected: // The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill. virtual float _layer_angle(size_t idx) const { return 0.f; } // Flag for Slic3r::Fill::Rectilinear to fill both directions. virtual bool _horizontal_lines() const { return true; } }; }; // namespace Slic3r #endif // slic3r_FillRectilinear_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillRectilinear2.cpp000066400000000000000000002361041301441720000243370ustar00rootroot00000000000000#include #include #include #include #include #include #include "../ClipperUtils.hpp" #include "../ExPolygon.hpp" #include "../Surface.hpp" #include "FillRectilinear2.hpp" // #define SLIC3R_DEBUG // Make assert active if SLIC3R_DEBUG #ifdef SLIC3R_DEBUG #undef NDEBUG #include "SVG.hpp" #endif #include // We want our version of assert. #include "../libslic3r.h" #ifndef myassert #define myassert assert #endif namespace Slic3r { #ifndef clamp template static inline T clamp(T low, T high, T x) { return std::max(low, std::min(high, x)); } #endif /* clamp */ #ifndef sqr template static inline T sqr(T x) { return x * x; } #endif /* sqr */ #ifndef mag2 static inline coordf_t mag2(const Point &p) { return sqr(coordf_t(p.x)) + sqr(coordf_t(p.y)); } #endif /* mag2 */ #ifndef mag static inline coordf_t mag(const Point &p) { return std::sqrt(mag2(p)); } #endif /* mag */ enum Orientation { ORIENTATION_CCW = 1, ORIENTATION_CW = -1, ORIENTATION_COLINEAR = 0 }; // Return orientation of the three points (clockwise, counter-clockwise, colinear) // The predicate is exact for the coord_t type, using 64bit signed integers for the temporaries. //FIXME Make sure the temporaries do not overflow, // which means, the coord_t types must not have some of the topmost bits utilized. static inline Orientation orient(const Point &a, const Point &b, const Point &c) { // BOOST_STATIC_ASSERT(sizeof(coord_t) * 2 == sizeof(int64_t)); int64_t u = int64_t(b.x) * int64_t(c.y) - int64_t(b.y) * int64_t(c.x); int64_t v = int64_t(a.x) * int64_t(c.y) - int64_t(a.y) * int64_t(c.x); int64_t w = int64_t(a.x) * int64_t(b.y) - int64_t(a.y) * int64_t(b.x); int64_t d = u - v + w; return (d > 0) ? ORIENTATION_CCW : ((d == 0) ? ORIENTATION_COLINEAR : ORIENTATION_CW); } // Return orientation of the polygon. // The input polygon must not contain duplicate points. static inline bool is_ccw(const Polygon &poly) { // The polygon shall be at least a triangle. myassert(poly.points.size() >= 3); if (poly.points.size() < 3) return true; // 1) Find the lowest lexicographical point. int imin = 0; for (size_t i = 1; i < poly.points.size(); ++ i) { const Point &pmin = poly.points[imin]; const Point &p = poly.points[i]; if (p.x < pmin.x || (p.x == pmin.x && p.y < pmin.y)) imin = i; } // 2) Detect the orientation of the corner imin. size_t iPrev = ((imin == 0) ? poly.points.size() : imin) - 1; size_t iNext = ((imin + 1 == poly.points.size()) ? 0 : imin + 1); Orientation o = orient(poly.points[iPrev], poly.points[imin], poly.points[iNext]); // The lowest bottom point must not be collinear if the polygon does not contain duplicate points // or overlapping segments. myassert(o != ORIENTATION_COLINEAR); return o == ORIENTATION_CCW; } // Having a segment of a closed polygon, calculate its Euclidian length. // The segment indices seg1 and seg2 signify an end point of an edge in the forward direction of the loop, // therefore the point p1 lies on poly.points[seg1-1], poly.points[seg1] etc. static inline coordf_t segment_length(const Polygon &poly, size_t seg1, const Point &p1, size_t seg2, const Point &p2) { #ifdef SLIC3R_DEBUG // Verify that p1 lies on seg1. This is difficult to verify precisely, // but at least verify, that p1 lies in the bounding box of seg1. for (size_t i = 0; i < 2; ++ i) { size_t seg = (i == 0) ? seg1 : seg2; Point px = (i == 0) ? p1 : p2; Point pa = poly.points[((seg == 0) ? poly.points.size() : seg) - 1]; Point pb = poly.points[seg]; if (pa.x > pb.x) std::swap(pa.x, pb.x); if (pa.y > pb.y) std::swap(pa.y, pb.y); myassert(px.x >= pa.x && px.x <= pb.x); myassert(px.y >= pa.y && px.y <= pb.y); } #endif /* SLIC3R_DEBUG */ const Point *pPrev = &p1; const Point *pThis = NULL; coordf_t len = 0; if (seg1 <= seg2) { for (size_t i = seg1; i < seg2; ++ i, pPrev = pThis) len += pPrev->distance_to(*(pThis = &poly.points[i])); } else { for (size_t i = seg1; i < poly.points.size(); ++ i, pPrev = pThis) len += pPrev->distance_to(*(pThis = &poly.points[i])); for (size_t i = 0; i < seg2; ++ i, pPrev = pThis) len += pPrev->distance_to(*(pThis = &poly.points[i])); } len += pPrev->distance_to(p2); return len; } // Append a segment of a closed polygon to a polyline. // The segment indices seg1 and seg2 signify an end point of an edge in the forward direction of the loop. // Only insert intermediate points between seg1 and seg2. static inline void polygon_segment_append(Points &out, const Polygon &polygon, size_t seg1, size_t seg2) { if (seg1 == seg2) { // Nothing to append from this segment. } else if (seg1 < seg2) { // Do not append a point pointed to by seg2. out.insert(out.end(), polygon.points.begin() + seg1, polygon.points.begin() + seg2); } else { out.reserve(out.size() + seg2 + polygon.points.size() - seg1); out.insert(out.end(), polygon.points.begin() + seg1, polygon.points.end()); // Do not append a point pointed to by seg2. out.insert(out.end(), polygon.points.begin(), polygon.points.begin() + seg2); } } // Append a segment of a closed polygon to a polyline. // The segment indices seg1 and seg2 signify an end point of an edge in the forward direction of the loop, // but this time the segment is traversed backward. // Only insert intermediate points between seg1 and seg2. static inline void polygon_segment_append_reversed(Points &out, const Polygon &polygon, size_t seg1, size_t seg2) { if (seg1 >= seg2) { out.reserve(seg1 - seg2); for (size_t i = seg1; i > seg2; -- i) out.push_back(polygon.points[i - 1]); } else { // it could be, that seg1 == seg2. In that case, append the complete loop. out.reserve(out.size() + seg2 + polygon.points.size() - seg1); for (size_t i = seg1; i > 0; -- i) out.push_back(polygon.points[i - 1]); for (size_t i = polygon.points.size(); i > seg2; -- i) out.push_back(polygon.points[i - 1]); } } // Intersection point of a vertical line with a polygon segment. class SegmentIntersection { public: SegmentIntersection() : iContour(0), iSegment(0), pos_p(0), pos_q(1), type(UNKNOWN), consumed_vertical_up(false), consumed_perimeter_right(false) {} // Index of a contour in ExPolygonWithOffset, with which this vertical line intersects. size_t iContour; // Index of a segment in iContour, with which this vertical line intersects. size_t iSegment; // y position of the intersection, ratinal number. int64_t pos_p; uint32_t pos_q; coord_t pos() const { // Division rounds both positive and negative down to zero. // Add half of q for an arithmetic rounding effect. int64_t p = pos_p; if (p < 0) p -= int64_t(pos_q>>1); else p += int64_t(pos_q>>1); return coord_t(p / int64_t(pos_q)); } // Kind of intersection. With the original contour, or with the inner offestted contour? // A vertical segment will be at least intersected by OUTER_LOW, OUTER_HIGH, // but it could be intersected with OUTER_LOW, INNER_LOW, INNER_HIGH, OUTER_HIGH, // and there may be more than one pair of INNER_LOW, INNER_HIGH between OUTER_LOW, OUTER_HIGH. enum SegmentIntersectionType { OUTER_LOW = 0, OUTER_HIGH = 1, INNER_LOW = 2, INNER_HIGH = 3, UNKNOWN = -1 }; SegmentIntersectionType type; // Was this segment along the y axis consumed? // Up means up along the vertical segment. bool consumed_vertical_up; // Was a segment of the inner perimeter contour consumed? // Right means right from the vertical segment. bool consumed_perimeter_right; // For the INNER_LOW type, this point may be connected to another INNER_LOW point following a perimeter contour. // For the INNER_HIGH type, this point may be connected to another INNER_HIGH point following a perimeter contour. // If INNER_LOW is connected to INNER_HIGH or vice versa, // one has to make sure the vertical infill line does not overlap with the connecting perimeter line. bool is_inner() const { return type == INNER_LOW || type == INNER_HIGH; } bool is_outer() const { return type == OUTER_LOW || type == OUTER_HIGH; } bool is_low () const { return type == INNER_LOW || type == OUTER_LOW; } bool is_high () const { return type == INNER_HIGH || type == OUTER_HIGH; } // Compare two y intersection points given by rational numbers. // Note that the rational number is given as pos_p/pos_q, where pos_p is int64 and pos_q is uint32. // This function calculates pos_p * other.pos_q < other.pos_p * pos_q as a 48bit number. // We don't use 128bit intrinsic data types as these are usually not supported by 32bit compilers and // we don't need the full 128bit precision anyway. bool operator<(const SegmentIntersection &other) const { assert(pos_q > 0); assert(other.pos_q > 0); if (pos_p == 0 || other.pos_p == 0) { // Because the denominators are positive and one of the nominators is zero, // following simple statement holds. return pos_p < other.pos_p; } else { // None of the nominators is zero. char sign1 = (pos_p > 0) ? 1 : -1; char sign2 = (other.pos_p > 0) ? 1 : -1; char signs = sign1 * sign2; assert(signs == 1 || signs == -1); if (signs < 0) { // The nominators have different signs. return sign1 < 0; } else { // The nominators have the same sign. // Absolute values uint64_t p1, p2; if (sign1 > 0) { p1 = uint64_t(pos_p); p2 = uint64_t(other.pos_p); } else { p1 = uint64_t(- pos_p); p2 = uint64_t(- other.pos_p); }; // Multiply low and high 32bit words of p1 by other_pos.q // 32bit x 32bit => 64bit // l_hi and l_lo overlap by 32 bits. uint64_t l_hi = (p1 >> 32) * uint64_t(other.pos_q); uint64_t l_lo = (p1 & 0xffffffffll) * uint64_t(other.pos_q); l_hi += (l_lo >> 32); uint64_t r_hi = (p2 >> 32) * uint64_t(pos_q); uint64_t r_lo = (p2 & 0xffffffffll) * uint64_t(pos_q); r_hi += (r_lo >> 32); // Compare the high 64 bits. if (l_hi == r_hi) { // Compare the low 32 bits. l_lo &= 0xffffffffll; r_lo &= 0xffffffffll; return (sign1 < 0) ? (l_lo > r_lo) : (l_lo < r_lo); } return (sign1 < 0) ? (l_hi > r_hi) : (l_hi < r_hi); } } } bool operator==(const SegmentIntersection &other) const { assert(pos_q > 0); assert(other.pos_q > 0); if (pos_p == 0 || other.pos_p == 0) { // Because the denominators are positive and one of the nominators is zero, // following simple statement holds. return pos_p == other.pos_p; } // None of the nominators is zero, none of the denominators is zero. bool positive = pos_p > 0; if (positive != (other.pos_p > 0)) return false; // The nominators have the same sign. // Absolute values uint64_t p1 = positive ? uint64_t(pos_p) : uint64_t(- pos_p); uint64_t p2 = positive ? uint64_t(other.pos_p) : uint64_t(- other.pos_p); // Multiply low and high 32bit words of p1 by other_pos.q // 32bit x 32bit => 64bit // l_hi and l_lo overlap by 32 bits. uint64_t l_lo = (p1 & 0xffffffffll) * uint64_t(other.pos_q); uint64_t r_lo = (p2 & 0xffffffffll) * uint64_t(pos_q); if (l_lo != r_lo) return false; uint64_t l_hi = (p1 >> 32) * uint64_t(other.pos_q); uint64_t r_hi = (p2 >> 32) * uint64_t(pos_q); return l_hi + (l_lo >> 32) == r_hi + (r_lo >> 32); } }; // A vertical line with intersection points with polygons. class SegmentedIntersectionLine { public: // Index of this vertical intersection line. size_t idx; // x position of this vertical intersection line. coord_t pos; // List of intersection points with polygons, sorted increasingly by the y axis. std::vector intersections; }; // A container maintaining an expolygon with its inner offsetted polygon. // The purpose of the inner offsetted polygon is to provide segments to connect the infill lines. struct ExPolygonWithOffset { public: ExPolygonWithOffset( const ExPolygon &expolygon, float angle, coord_t aoffset1, coord_t aoffset2) { // Copy and rotate the source polygons. polygons_src = expolygon; polygons_src.contour.rotate(angle); for (Polygons::iterator it = polygons_src.holes.begin(); it != polygons_src.holes.end(); ++ it) it->rotate(angle); double mitterLimit = 3.; // for the infill pattern, don't cut the corners. // default miterLimt = 3 //double mitterLimit = 10.; myassert(aoffset1 < 0); myassert(aoffset2 < 0); myassert(aoffset2 < aoffset1); bool sticks_removed = remove_sticks(polygons_src); // if (sticks_removed) printf("Sticks removed!\n"); polygons_outer = offset(polygons_src, aoffset1, CLIPPER_OFFSET_SCALE, ClipperLib::jtMiter, mitterLimit); polygons_inner = offset(polygons_outer, aoffset2 - aoffset1, CLIPPER_OFFSET_SCALE, ClipperLib::jtMiter, mitterLimit); // Filter out contours with zero area or small area, contours with 2 points only. const double min_area_threshold = 0.01 * aoffset2 * aoffset2; remove_small(polygons_outer, min_area_threshold); remove_small(polygons_inner, min_area_threshold); remove_sticks(polygons_outer); remove_sticks(polygons_inner); n_contours_outer = polygons_outer.size(); n_contours_inner = polygons_inner.size(); n_contours = n_contours_outer + n_contours_inner; polygons_ccw.assign(n_contours, false); for (size_t i = 0; i < n_contours; ++ i) { contour(i).remove_duplicate_points(); myassert(! contour(i).has_duplicate_points()); polygons_ccw[i] = is_ccw(contour(i)); } } // Any contour with offset1 bool is_contour_outer(size_t idx) const { return idx < n_contours_outer; } // Any contour with offset2 bool is_contour_inner(size_t idx) const { return idx >= n_contours_outer; } const Polygon& contour(size_t idx) const { return is_contour_outer(idx) ? polygons_outer[idx] : polygons_inner[idx - n_contours_outer]; } Polygon& contour(size_t idx) { return is_contour_outer(idx) ? polygons_outer[idx] : polygons_inner[idx - n_contours_outer]; } bool is_contour_ccw(size_t idx) const { return polygons_ccw[idx]; } BoundingBox bounding_box_src() const { return get_extents(polygons_src); } BoundingBox bounding_box_outer() const { return get_extents(polygons_outer); } BoundingBox bounding_box_inner() const { return get_extents(polygons_inner); } #ifdef SLIC3R_DEBUG void export_to_svg(Slic3r::SVG &svg) { svg.draw_outline(polygons_src, "black"); svg.draw_outline(polygons_outer, "green"); svg.draw_outline(polygons_inner, "brown"); } #endif /* SLIC3R_DEBUG */ ExPolygon polygons_src; Polygons polygons_outer; Polygons polygons_inner; size_t n_contours_outer; size_t n_contours_inner; size_t n_contours; protected: // For each polygon of polygons_inner, remember its orientation. std::vector polygons_ccw; }; static inline int distance_of_segmens(const Polygon &poly, size_t seg1, size_t seg2, bool forward) { int d = int(seg2) - int(seg1); if (! forward) d = - d; if (d < 0) d += int(poly.points.size()); return d; } // For a vertical line, an inner contour and an intersection point, // find an intersection point on the previous resp. next vertical line. // The intersection point is connected with the prev resp. next intersection point with iInnerContour. // Return -1 if there is no such point on the previous resp. next vertical line. static inline int intersection_on_prev_next_vertical_line( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, bool dir_is_next) { size_t iVerticalLineOther = iVerticalLine; if (dir_is_next) { if (++ iVerticalLineOther == segs.size()) // No successive vertical line. return -1; } else if (iVerticalLineOther -- == 0) { // No preceding vertical line. return -1; } const SegmentedIntersectionLine &il = segs[iVerticalLine]; const SegmentIntersection &itsct = il.intersections[iIntersection]; const SegmentedIntersectionLine &il2 = segs[iVerticalLineOther]; const Polygon &poly = poly_with_offset.contour(iInnerContour); // const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour); const bool forward = itsct.is_low() == dir_is_next; // Resulting index of an intersection point on il2. int out = -1; // Find an intersection point on iVerticalLineOther, intersecting iInnerContour // at the same orientation as iIntersection, and being closest to iIntersection // in the number of contour segments, when following the direction of the contour. int dmin = std::numeric_limits::max(); for (size_t i = 0; i < il2.intersections.size(); ++ i) { const SegmentIntersection &itsct2 = il2.intersections[i]; if (itsct.iContour == itsct2.iContour && itsct.type == itsct2.type) { /* if (itsct.is_low()) { myassert(itsct.type == SegmentIntersection::INNER_LOW); myassert(iIntersection > 0); myassert(il.intersections[iIntersection-1].type == SegmentIntersection::OUTER_LOW); myassert(i > 0); if (il2.intersections[i-1].is_inner()) // Take only the lowest inner intersection point. continue; myassert(il2.intersections[i-1].type == SegmentIntersection::OUTER_LOW); } else { myassert(itsct.type == SegmentIntersection::INNER_HIGH); myassert(iIntersection+1 < il.intersections.size()); myassert(il.intersections[iIntersection+1].type == SegmentIntersection::OUTER_HIGH); myassert(i+1 < il2.intersections.size()); if (il2.intersections[i+1].is_inner()) // Take only the highest inner intersection point. continue; myassert(il2.intersections[i+1].type == SegmentIntersection::OUTER_HIGH); } */ // The intersection points lie on the same contour and have the same orientation. // Find the intersection point with a shortest path in the direction of the contour. int d = distance_of_segmens(poly, itsct.iSegment, itsct2.iSegment, forward); if (d < dmin) { out = i; dmin = d; } } } //FIXME this routine is not asymptotic optimal, it will be slow if there are many intersection points along the line. return out; } static inline int intersection_on_prev_vertical_line( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection) { return intersection_on_prev_next_vertical_line(poly_with_offset, segs, iVerticalLine, iInnerContour, iIntersection, false); } static inline int intersection_on_next_vertical_line( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection) { return intersection_on_prev_next_vertical_line(poly_with_offset, segs, iVerticalLine, iInnerContour, iIntersection, true); } enum IntersectionTypeOtherVLine { // There is no connection point on the other vertical line. INTERSECTION_TYPE_OTHER_VLINE_UNDEFINED = -1, // Connection point on the other vertical segment was found // and it could be followed. INTERSECTION_TYPE_OTHER_VLINE_OK = 0, // The connection segment connects to a middle of a vertical segment. // Cannot follow. INTERSECTION_TYPE_OTHER_VLINE_INNER, // Cannot extend the contor to this intersection point as either the connection segment // or the succeeding vertical segment were already consumed. INTERSECTION_TYPE_OTHER_VLINE_CONSUMED, // Not the first intersection along the contor. This intersection point // has been preceded by an intersection point along the vertical line. INTERSECTION_TYPE_OTHER_VLINE_NOT_FIRST, }; // Find an intersection on a previous line, but return -1, if the connecting segment of a perimeter was already extruded. static inline IntersectionTypeOtherVLine intersection_type_on_prev_next_vertical_line( const std::vector &segs, size_t iVerticalLine, size_t iIntersection, size_t iIntersectionOther, bool dir_is_next) { // This routine will propose a connecting line even if the connecting perimeter segment intersects // iVertical line multiple times before reaching iIntersectionOther. if (iIntersectionOther == -1) return INTERSECTION_TYPE_OTHER_VLINE_UNDEFINED; myassert(dir_is_next ? (iVerticalLine + 1 < segs.size()) : (iVerticalLine > 0)); const SegmentedIntersectionLine &il_this = segs[iVerticalLine]; const SegmentIntersection &itsct_this = il_this.intersections[iIntersection]; const SegmentedIntersectionLine &il_other = segs[dir_is_next ? (iVerticalLine+1) : (iVerticalLine-1)]; const SegmentIntersection &itsct_other = il_other.intersections[iIntersectionOther]; myassert(itsct_other.is_inner()); myassert(iIntersectionOther > 0); myassert(iIntersectionOther + 1 < il_other.intersections.size()); // Is iIntersectionOther at the boundary of a vertical segment? const SegmentIntersection &itsct_other2 = il_other.intersections[itsct_other.is_low() ? iIntersectionOther - 1 : iIntersectionOther + 1]; if (itsct_other2.is_inner()) // Cannot follow a perimeter segment into the middle of another vertical segment. // Only perimeter segments connecting to the end of a vertical segment are followed. return INTERSECTION_TYPE_OTHER_VLINE_INNER; myassert(itsct_other.is_low() == itsct_other2.is_low()); if (dir_is_next ? itsct_this.consumed_perimeter_right : itsct_other.consumed_perimeter_right) // This perimeter segment was already consumed. return INTERSECTION_TYPE_OTHER_VLINE_CONSUMED; if (itsct_other.is_low() ? itsct_other.consumed_vertical_up : il_other.intersections[iIntersectionOther-1].consumed_vertical_up) // This vertical segment was already consumed. return INTERSECTION_TYPE_OTHER_VLINE_CONSUMED; return INTERSECTION_TYPE_OTHER_VLINE_OK; } static inline IntersectionTypeOtherVLine intersection_type_on_prev_vertical_line( const std::vector &segs, size_t iVerticalLine, size_t iIntersection, size_t iIntersectionPrev) { return intersection_type_on_prev_next_vertical_line(segs, iVerticalLine, iIntersection, iIntersectionPrev, false); } static inline IntersectionTypeOtherVLine intersection_type_on_next_vertical_line( const std::vector &segs, size_t iVerticalLine, size_t iIntersection, size_t iIntersectionNext) { return intersection_type_on_prev_next_vertical_line(segs, iVerticalLine, iIntersection, iIntersectionNext, true); } // Measure an Euclidian length of a perimeter segment when going from iIntersection to iIntersection2. static inline coordf_t measure_perimeter_prev_next_segment_length( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, size_t iIntersection2, bool dir_is_next) { size_t iVerticalLineOther = iVerticalLine; if (dir_is_next) { if (++ iVerticalLineOther == segs.size()) // No successive vertical line. return coordf_t(-1); } else if (iVerticalLineOther -- == 0) { // No preceding vertical line. return coordf_t(-1); } const SegmentedIntersectionLine &il = segs[iVerticalLine]; const SegmentIntersection &itsct = il.intersections[iIntersection]; const SegmentedIntersectionLine &il2 = segs[iVerticalLineOther]; const SegmentIntersection &itsct2 = il2.intersections[iIntersection2]; const Polygon &poly = poly_with_offset.contour(iInnerContour); // const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour); myassert(itsct.type == itsct2.type); myassert(itsct.iContour == itsct2.iContour); myassert(itsct.is_inner()); const bool forward = itsct.is_low() == dir_is_next; Point p1(il.pos, itsct.pos()); Point p2(il2.pos, itsct2.pos()); return forward ? segment_length(poly, itsct .iSegment, p1, itsct2.iSegment, p2) : segment_length(poly, itsct2.iSegment, p2, itsct .iSegment, p1); } static inline coordf_t measure_perimeter_prev_segment_length( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, size_t iIntersection2) { return measure_perimeter_prev_next_segment_length(poly_with_offset, segs, iVerticalLine, iInnerContour, iIntersection, iIntersection2, false); } static inline coordf_t measure_perimeter_next_segment_length( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, size_t iIntersection2) { return measure_perimeter_prev_next_segment_length(poly_with_offset, segs, iVerticalLine, iInnerContour, iIntersection, iIntersection2, true); } // Append the points of a perimeter segment when going from iIntersection to iIntersection2. // The first point (the point of iIntersection) will not be inserted, // the last point will be inserted. static inline void emit_perimeter_prev_next_segment( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, size_t iIntersection2, Polyline &out, bool dir_is_next) { size_t iVerticalLineOther = iVerticalLine; if (dir_is_next) { ++ iVerticalLineOther; myassert(iVerticalLineOther < segs.size()); } else { myassert(iVerticalLineOther > 0); -- iVerticalLineOther; } const SegmentedIntersectionLine &il = segs[iVerticalLine]; const SegmentIntersection &itsct = il.intersections[iIntersection]; const SegmentedIntersectionLine &il2 = segs[iVerticalLineOther]; const SegmentIntersection &itsct2 = il2.intersections[iIntersection2]; const Polygon &poly = poly_with_offset.contour(iInnerContour); // const bool ccw = poly_with_offset.is_contour_ccw(iInnerContour); myassert(itsct.type == itsct2.type); myassert(itsct.iContour == itsct2.iContour); myassert(itsct.is_inner()); const bool forward = itsct.is_low() == dir_is_next; // Do not append the first point. // out.points.push_back(Point(il.pos, itsct.pos)); if (forward) polygon_segment_append(out.points, poly, itsct.iSegment, itsct2.iSegment); else polygon_segment_append_reversed(out.points, poly, itsct.iSegment, itsct2.iSegment); // Append the last point. out.points.push_back(Point(il2.pos, itsct2.pos())); } static inline coordf_t measure_perimeter_segment_on_vertical_line_length( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, size_t iIntersection2, bool forward) { const SegmentedIntersectionLine &il = segs[iVerticalLine]; const SegmentIntersection &itsct = il.intersections[iIntersection]; const SegmentIntersection &itsct2 = il.intersections[iIntersection2]; const Polygon &poly = poly_with_offset.contour(iInnerContour); myassert(itsct.is_inner()); myassert(itsct2.is_inner()); myassert(itsct.type != itsct2.type); myassert(itsct.iContour == iInnerContour); myassert(itsct.iContour == itsct2.iContour); Point p1(il.pos, itsct.pos()); Point p2(il.pos, itsct2.pos()); return forward ? segment_length(poly, itsct .iSegment, p1, itsct2.iSegment, p2) : segment_length(poly, itsct2.iSegment, p2, itsct .iSegment, p1); } // Append the points of a perimeter segment when going from iIntersection to iIntersection2. // The first point (the point of iIntersection) will not be inserted, // the last point will be inserted. static inline void emit_perimeter_segment_on_vertical_line( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t iVerticalLine, size_t iInnerContour, size_t iIntersection, size_t iIntersection2, Polyline &out, bool forward) { const SegmentedIntersectionLine &il = segs[iVerticalLine]; const SegmentIntersection &itsct = il.intersections[iIntersection]; const SegmentIntersection &itsct2 = il.intersections[iIntersection2]; const Polygon &poly = poly_with_offset.contour(iInnerContour); myassert(itsct.is_inner()); myassert(itsct2.is_inner()); myassert(itsct.type != itsct2.type); myassert(itsct.iContour == iInnerContour); myassert(itsct.iContour == itsct2.iContour); // Do not append the first point. // out.points.push_back(Point(il.pos, itsct.pos)); if (forward) polygon_segment_append(out.points, poly, itsct.iSegment, itsct2.iSegment); else polygon_segment_append_reversed(out.points, poly, itsct.iSegment, itsct2.iSegment); // Append the last point. out.points.push_back(Point(il.pos, itsct2.pos())); } //TBD: For precise infill, measure the area of a slab spanned by an infill line. /* static inline float measure_outer_contour_slab( const ExPolygonWithOffset &poly_with_offset, const std::vector &segs, size_t i_vline, size_t iIntersection) { const SegmentedIntersectionLine &il = segs[i_vline]; const SegmentIntersection &itsct = il.intersections[i_vline]; const SegmentIntersection &itsct2 = il.intersections[iIntersection2]; const Polygon &poly = poly_with_offset.contour((itsct.iContour); myassert(itsct.is_outer()); myassert(itsct2.is_outer()); myassert(itsct.type != itsct2.type); myassert(itsct.iContour == itsct2.iContour); if (! itsct.is_outer() || ! itsct2.is_outer() || itsct.type == itsct2.type || itsct.iContour != itsct2.iContour) // Error, return zero area. return 0.f; // Find possible connection points on the previous / next vertical line. int iPrev = intersection_on_prev_vertical_line(poly_with_offset, segs, i_vline, itsct.iContour, i_intersection); int iNext = intersection_on_next_vertical_line(poly_with_offset, segs, i_vline, itsct.iContour, i_intersection); // Find possible connection points on the same vertical line. int iAbove = iBelow = -1; // Does the perimeter intersect the current vertical line above intrsctn? for (size_t i = i_intersection + 1; i + 1 < seg.intersections.size(); ++ i) if (seg.intersections[i].iContour == itsct.iContour) { iAbove = i; break; } // Does the perimeter intersect the current vertical line below intrsctn? for (int i = int(i_intersection) - 1; i > 0; -- i) if (seg.intersections[i].iContour == itsct.iContour) { iBelow = i; break; } if (iSegAbove != -1 && seg.intersections[iAbove].type == SegmentIntersection::OUTER_HIGH) { // Invalidate iPrev resp. iNext, if the perimeter crosses the current vertical line earlier than iPrev resp. iNext. // The perimeter contour orientation. const Polygon &poly = poly_with_offset.contour(itsct.iContour); { int d_horiz = (iPrev == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, segs[i_vline-1].intersections[iPrev].iSegment, itsct.iSegment, true); int d_down = (iBelow == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, iSegBelow, itsct.iSegment, true); int d_up = (iAbove == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, iSegAbove, itsct.iSegment, true); if (intrsctn_type_prev == INTERSECTION_TYPE_OTHER_VLINE_OK && d_horiz > std::min(d_down, d_up)) // The vertical crossing comes eralier than the prev crossing. // Disable the perimeter going back. intrsctn_type_prev = INTERSECTION_TYPE_OTHER_VLINE_NOT_FIRST; if (d_up > std::min(d_horiz, d_down)) // The horizontal crossing comes earlier than the vertical crossing. vert_seg_dir_valid_mask &= ~DIR_BACKWARD; } { int d_horiz = (iNext == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, itsct.iSegment, segs[i_vline+1].intersections[iNext].iSegment, true); int d_down = (iSegBelow == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, itsct.iSegment, iSegBelow, true); int d_up = (iSegAbove == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, itsct.iSegment, iSegAbove, true); if (d_up > std::min(d_horiz, d_down)) // The horizontal crossing comes earlier than the vertical crossing. vert_seg_dir_valid_mask &= ~DIR_FORWARD; } } } */ enum DirectionMask { DIR_FORWARD = 1, DIR_BACKWARD = 2 }; bool FillRectilinear2::fill_surface_by_lines(const Surface *surface, const FillParams ¶ms, float angleBase, float pattern_shift, Polylines &polylines_out) { // At the end, only the new polylines will be rotated back. size_t n_polylines_out_initial = polylines_out.size(); // Shrink the input polygon a bit first to not push the infill lines out of the perimeters. // const float INFILL_OVERLAP_OVER_SPACING = 0.3f; const float INFILL_OVERLAP_OVER_SPACING = 0.45f; myassert(INFILL_OVERLAP_OVER_SPACING > 0 && INFILL_OVERLAP_OVER_SPACING < 0.5f); // Rotate polygons so that we can work with vertical lines here std::pair rotate_vector = this->_infill_direction(surface); rotate_vector.first += angleBase; myassert(params.density > 0.0001f && params.density <= 1.f); coord_t line_spacing = coord_t(scale_(this->spacing) / params.density); // On the polygons of poly_with_offset, the infill lines will be connected. ExPolygonWithOffset poly_with_offset( surface->expolygon, - rotate_vector.first, scale_(- (0.5 - INFILL_OVERLAP_OVER_SPACING) * this->spacing), scale_(- 0.5 * this->spacing)); if (poly_with_offset.n_contours_inner == 0) { // Not a single infill line fits. //FIXME maybe one shall trigger the gap fill here? return true; } BoundingBox bounding_box = poly_with_offset.bounding_box_src(); // define flow spacing according to requested density bool full_infill = params.density > 0.9999f; if (full_infill && !params.dont_adjust) { line_spacing = this->_adjust_solid_spacing(bounding_box.size().x, line_spacing); this->spacing = unscale(line_spacing); } else { // extend bounding box so that our pattern will be aligned with other layers // Transform the reference point to the rotated coordinate system. Point refpt = rotate_vector.second.rotated(- rotate_vector.first); // _align_to_grid will not work correctly with positive pattern_shift. coord_t pattern_shift_scaled = coord_t(scale_(pattern_shift)) % line_spacing; refpt.x -= (pattern_shift_scaled > 0) ? pattern_shift_scaled : (line_spacing + pattern_shift_scaled); bounding_box.merge(_align_to_grid( bounding_box.min, Point(line_spacing, line_spacing), refpt)); } // Intersect a set of euqally spaced vertical lines wiht expolygon. // n_vlines = ceil(bbox_width / line_spacing) size_t n_vlines = (bounding_box.max.x - bounding_box.min.x + line_spacing - 1) / line_spacing; coord_t x0 = bounding_box.min.x + (line_spacing + SCALED_EPSILON) / 2; #ifdef SLIC3R_DEBUG static int iRun = 0; BoundingBox bbox_svg = poly_with_offset.bounding_box_outer(); ::Slic3r::SVG svg(debug_out_path("FillRectilinear2-%d.svg", iRun), bbox_svg); // , scale_(1.)); poly_with_offset.export_to_svg(svg); { ::Slic3r::SVG svg(debug_out_path("FillRectilinear2-initial-%d.svg", iRun), bbox_svg); // , scale_(1.)); poly_with_offset.export_to_svg(svg); } iRun ++; #endif /* SLIC3R_DEBUG */ // For each contour // Allocate storage for the segments. std::vector segs(n_vlines, SegmentedIntersectionLine()); for (size_t i = 0; i < n_vlines; ++ i) { segs[i].idx = i; segs[i].pos = x0 + i * line_spacing; } for (size_t iContour = 0; iContour < poly_with_offset.n_contours; ++ iContour) { const Points &contour = poly_with_offset.contour(iContour).points; if (contour.size() < 2) continue; // For each segment for (size_t iSegment = 0; iSegment < contour.size(); ++ iSegment) { size_t iPrev = ((iSegment == 0) ? contour.size() : iSegment) - 1; const Point &p1 = contour[iPrev]; const Point &p2 = contour[iSegment]; // Which of the equally spaced vertical lines is intersected by this segment? coord_t l = p1.x; coord_t r = p2.x; if (l > r) std::swap(l, r); // il, ir are the left / right indices of vertical lines intersecting a segment int il = (l - x0) / line_spacing; while (il * line_spacing + x0 < l) ++ il; il = std::max(int(0), il); int ir = (r - x0 + line_spacing) / line_spacing; while (ir * line_spacing + x0 > r) -- ir; ir = std::min(int(segs.size()) - 1, ir); if (il > ir) // No vertical line intersects this segment. continue; myassert(il >= 0 && il < segs.size()); myassert(ir >= 0 && ir < segs.size()); for (int i = il; i <= ir; ++ i) { coord_t this_x = segs[i].pos; assert(this_x == i * line_spacing + x0); SegmentIntersection is; is.iContour = iContour; is.iSegment = iSegment; myassert(l <= this_x); myassert(r >= this_x); // Calculate the intersection position in y axis. x is known. if (p1.x == this_x) { if (p2.x == this_x) { // Ignore strictly vertical segments. continue; } is.pos_p = p1.y; is.pos_q = 1; } else if (p2.x == this_x) { is.pos_p = p2.y; is.pos_q = 1; } else { // First calculate the intersection parameter 't' as a rational number with non negative denominator. if (p2.x > p1.x) { is.pos_p = this_x - p1.x; is.pos_q = p2.x - p1.x; } else { is.pos_p = p1.x - this_x; is.pos_q = p1.x - p2.x; } myassert(is.pos_p >= 0 && is.pos_p <= is.pos_q); // Make an intersection point from the 't'. is.pos_p *= int64_t(p2.y - p1.y); is.pos_p += p1.y * int64_t(is.pos_q); } // +-1 to take rounding into account. myassert(is.pos() + 1 >= std::min(p1.y, p2.y)); myassert(is.pos() <= std::max(p1.y, p2.y) + 1); segs[i].intersections.push_back(is); } } } // Sort the intersections along their segments, specify the intersection types. for (size_t i_seg = 0; i_seg < segs.size(); ++ i_seg) { SegmentedIntersectionLine &sil = segs[i_seg]; // Sort the intersection points using exact rational arithmetic. std::sort(sil.intersections.begin(), sil.intersections.end()); #if 0 // Verify the order, bubble sort the intersections until sorted. bool modified = false; do { modified = false; for (size_t i = 1; i < sil.intersections.size(); ++ i) { size_t iContour1 = sil.intersections[i-1].iContour; size_t iContour2 = sil.intersections[i].iContour; const Points &contour1 = poly_with_offset.contour(iContour1).points; const Points &contour2 = poly_with_offset.contour(iContour2).points; size_t iSegment1 = sil.intersections[i-1].iSegment; size_t iPrev1 = ((iSegment1 == 0) ? contour1.size() : iSegment1) - 1; size_t iSegment2 = sil.intersections[i].iSegment; size_t iPrev2 = ((iSegment2 == 0) ? contour2.size() : iSegment2) - 1; bool swap = false; if (iContour1 == iContour2 && iSegment1 == iSegment2) { // The same segment, it has to be vertical. myassert(iPrev1 == iPrev2); swap = contour1[iPrev1].y > contour1[iContour1].y; #ifdef SLIC3R_DEBUG if (swap) printf("Swapping when single vertical segment\n"); #endif } else { // Segments are in a general position. Here an exact airthmetics may come into play. coord_t y1max = std::max(contour1[iPrev1].y, contour1[iSegment1].y); coord_t y2min = std::min(contour2[iPrev2].y, contour2[iSegment2].y); if (y1max < y2min) { // The segments are separated, nothing to do. } else { // Use an exact predicate to verify, that segment1 is below segment2. const Point *a = &contour1[iPrev1]; const Point *b = &contour1[iSegment1]; const Point *c = &contour2[iPrev2]; const Point *d = &contour2[iSegment2]; #ifdef SLIC3R_DEBUG const Point x1(sil.pos, sil.intersections[i-1].pos); const Point x2(sil.pos, sil.intersections[i ].pos); bool successive = false; #endif /* SLIC3R_DEBUG */ // Sort the points in the two segments by x. if (a->x > b->x) std::swap(a, b); if (c->x > d->x) std::swap(c, d); myassert(a->x <= sil.pos); myassert(c->x <= sil.pos); myassert(b->x >= sil.pos); myassert(d->x >= sil.pos); // Sort the two segments, so the segment will be on the left of . bool upper_more_left = false; if (a->x > c->x) { upper_more_left = true; std::swap(a, c); std::swap(b, d); } if (a == c) { // The segments iSegment1 and iSegment2 are directly connected. myassert(iContour1 == iContour2); myassert(iSegment1 == iPrev2 || iPrev1 == iSegment2); std::swap(c, d); myassert(a != c && b != c); #ifdef SLIC3R_DEBUG successive = true; #endif /* SLIC3R_DEBUG */ } #ifdef SLIC3R_DEBUG else if (b == d) { // The segments iSegment1 and iSegment2 are directly connected. myassert(iContour1 == iContour2); myassert(iSegment1 == iPrev2 || iPrev1 == iSegment2); myassert(a != c && b != c); successive = true; } #endif /* SLIC3R_DEBUG */ Orientation o = orient(*a, *b, *c); myassert(o != ORIENTATION_COLINEAR); swap = upper_more_left != (o == ORIENTATION_CW); #ifdef SLIC3R_DEBUG if (swap) printf(successive ? "Swapping when iContour1 == iContour2 and successive segments\n" : "Swapping when exact predicate\n"); #endif } } if (swap) { // Swap the intersection points, but keep the original positions, so they stay sorted by the y axis. std::swap(sil.intersections[i-1], sil.intersections[i]); std::swap(sil.intersections[i-1].pos_p, sil.intersections[i].pos_p); std::swap(sil.intersections[i-1].pos_q, sil.intersections[i].pos_q); modified = true; } } } while (modified); #endif // Assign the intersection types, remove duplicate or overlapping intersection points. // When a loop vertex touches a vertical line, intersection point is generated for both segments. // If such two segments are oriented equally, then one of them is removed. // Otherwise the vertex is tangential to the vertical line and both segments are removed. // The same rule applies, if the loop is pinched into a single point and this point touches the vertical line: // The loop has a zero vertical size at the vertical line, therefore the intersection point is removed. size_t j = 0; for (size_t i = 0; i < sil.intersections.size(); ++ i) { // What is the orientation of the segment at the intersection point? size_t iContour = sil.intersections[i].iContour; const Points &contour = poly_with_offset.contour(iContour).points; size_t iSegment = sil.intersections[i].iSegment; size_t iPrev = ((iSegment == 0) ? contour.size() : iSegment) - 1; coord_t dir = contour[iSegment].x - contour[iPrev].x; // bool ccw = poly_with_offset.is_contour_ccw(iContour); // bool low = (dir > 0) == ccw; bool low = dir > 0; sil.intersections[i].type = poly_with_offset.is_contour_outer(iContour) ? (low ? SegmentIntersection::OUTER_LOW : SegmentIntersection::OUTER_HIGH) : (low ? SegmentIntersection::INNER_LOW : SegmentIntersection::INNER_HIGH); if (j > 0 && sil.intersections[i].pos() == sil.intersections[j-1].pos() && sil.intersections[i].iContour == sil.intersections[j-1].iContour) { if (sil.intersections[i].type == sil.intersections[j-1].type) { // This has to be a corner point crossing the vertical line. // Remove the second intersection point. #ifdef SLIC3R_DEBUG size_t iSegment2 = sil.intersections[j-1].iSegment; size_t iPrev2 = ((iSegment2 == 0) ? contour.size() : iSegment2) - 1; myassert(iSegment == iPrev2 || iSegment2 == iPrev); #endif /* SLIC3R_DEBUG */ } else { // This is a loop returning to the same point. // It may as well be a vertex of a loop touching this vertical line. // Remove both the lines. -- j; } } else { if (j < i) sil.intersections[j] = sil.intersections[i]; ++ j; } //FIXME solve a degenerate case, where there is a vertical segment on this vertical line and the contour // follows from left to right or vice versa, leading to low,low or high,high intersections. } // Shrink the list of intersections, if any of the intersection was removed during the classification. if (j < sil.intersections.size()) sil.intersections.erase(sil.intersections.begin() + j, sil.intersections.end()); } // Verify the segments. If something is wrong, give up. #define ASSERT_OR_RETURN(CONDITION) do { assert(CONDITION); if (! (CONDITION)) return false; } while (0) for (size_t i_seg = 0; i_seg < segs.size(); ++ i_seg) { SegmentedIntersectionLine &sil = segs[i_seg]; // The intersection points have to be even. ASSERT_OR_RETURN((sil.intersections.size() & 1) == 0); for (size_t i = 0; i < sil.intersections.size();) { // An intersection segment crossing the bigger contour may cross the inner offsetted contour even number of times. ASSERT_OR_RETURN(sil.intersections[i].type == SegmentIntersection::OUTER_LOW); size_t j = i + 1; ASSERT_OR_RETURN(j < sil.intersections.size()); ASSERT_OR_RETURN(sil.intersections[j].type == SegmentIntersection::INNER_LOW || sil.intersections[j].type == SegmentIntersection::OUTER_HIGH); for (; j < sil.intersections.size() && sil.intersections[j].is_inner(); ++ j) ; ASSERT_OR_RETURN(j < sil.intersections.size()); ASSERT_OR_RETURN((j & 1) == 1); ASSERT_OR_RETURN(sil.intersections[j].type == SegmentIntersection::OUTER_HIGH); ASSERT_OR_RETURN(i + 1 == j || sil.intersections[j - 1].type == SegmentIntersection::INNER_HIGH); i = j + 1; } } #undef ASSERT_OR_RETURN #ifdef SLIC3R_DEBUG // Paint the segments and finalize the SVG file. for (size_t i_seg = 0; i_seg < segs.size(); ++ i_seg) { SegmentedIntersectionLine &sil = segs[i_seg]; for (size_t i = 0; i < sil.intersections.size();) { size_t j = i + 1; for (; j < sil.intersections.size() && sil.intersections[j].is_inner(); ++ j) ; if (i + 1 == j) { svg.draw(Line(Point(sil.pos, sil.intersections[i].pos()), Point(sil.pos, sil.intersections[j].pos())), "blue"); } else { svg.draw(Line(Point(sil.pos, sil.intersections[i].pos()), Point(sil.pos, sil.intersections[i+1].pos())), "green"); svg.draw(Line(Point(sil.pos, sil.intersections[i+1].pos()), Point(sil.pos, sil.intersections[j-1].pos())), (j - i + 1 > 4) ? "yellow" : "magenta"); svg.draw(Line(Point(sil.pos, sil.intersections[j-1].pos()), Point(sil.pos, sil.intersections[j].pos())), "green"); } i = j + 1; } } svg.Close(); #endif /* SLIC3R_DEBUG */ // For each outer only chords, measure their maximum distance to the bow of the outer contour. // Mark an outer only chord as consumed, if the distance is low. for (size_t i_vline = 0; i_vline < segs.size(); ++ i_vline) { SegmentedIntersectionLine &seg = segs[i_vline]; for (size_t i_intersection = 0; i_intersection + 1 < seg.intersections.size(); ++ i_intersection) { if (seg.intersections[i_intersection].type == SegmentIntersection::OUTER_LOW && seg.intersections[i_intersection+1].type == SegmentIntersection::OUTER_HIGH) { bool consumed = false; // if (full_infill) { // measure_outer_contour_slab(poly_with_offset, segs, i_vline, i_ntersection); // } else consumed = true; seg.intersections[i_intersection].consumed_vertical_up = consumed; } } } // Now construct a graph. // Find the first point. // Naively one would expect to achieve best results by chaining the paths by the shortest distance, // but that procedure does not create the longest continuous paths. // A simple "sweep left to right" procedure achieves better results. size_t i_vline = 0; size_t i_intersection = size_t(-1); // Follow the line, connect the lines into a graph. // Until no new line could be added to the output path: Point pointLast; Polyline *polyline_current = NULL; if (! polylines_out.empty()) pointLast = polylines_out.back().points.back(); for (;;) { if (i_intersection == size_t(-1)) { // The path has been interrupted. Find a next starting point, closest to the previous extruder position. coordf_t dist2min = std::numeric_limits().max(); for (size_t i_vline2 = 0; i_vline2 < segs.size(); ++ i_vline2) { const SegmentedIntersectionLine &seg = segs[i_vline2]; if (! seg.intersections.empty()) { myassert(seg.intersections.size() > 1); // Even number of intersections with the loops. myassert((seg.intersections.size() & 1) == 0); myassert(seg.intersections.front().type == SegmentIntersection::OUTER_LOW); for (size_t i = 0; i < seg.intersections.size(); ++ i) { const SegmentIntersection &intrsctn = seg.intersections[i]; if (intrsctn.is_outer()) { myassert(intrsctn.is_low() || i > 0); bool consumed = intrsctn.is_low() ? intrsctn.consumed_vertical_up : seg.intersections[i-1].consumed_vertical_up; if (! consumed) { coordf_t dist2 = sqr(coordf_t(pointLast.x - seg.pos)) + sqr(coordf_t(pointLast.y - intrsctn.pos())); if (dist2 < dist2min) { dist2min = dist2; i_vline = i_vline2; i_intersection = i; //FIXME We are taking the first left point always. Verify, that the caller chains the paths // by a shortest distance, while reversing the paths if needed. //if (polylines_out.empty()) // Initial state, take the first line, which is the first from the left. goto found; } } } } } } if (i_intersection == size_t(-1)) // We are finished. break; found: // Start a new path. polylines_out.push_back(Polyline()); polyline_current = &polylines_out.back(); // Emit the first point of a path. pointLast = Point(segs[i_vline].pos, segs[i_vline].intersections[i_intersection].pos()); polyline_current->points.push_back(pointLast); } // From the initial point (i_vline, i_intersection), follow a path. SegmentedIntersectionLine &seg = segs[i_vline]; SegmentIntersection *intrsctn = &seg.intersections[i_intersection]; bool going_up = intrsctn->is_low(); bool try_connect = false; if (going_up) { myassert(! intrsctn->consumed_vertical_up); myassert(i_intersection + 1 < seg.intersections.size()); // Step back to the beginning of the vertical segment to mark it as consumed. if (intrsctn->is_inner()) { myassert(i_intersection > 0); -- intrsctn; -- i_intersection; } // Consume the complete vertical segment up to the outer contour. do { intrsctn->consumed_vertical_up = true; ++ intrsctn; ++ i_intersection; myassert(i_intersection < seg.intersections.size()); } while (intrsctn->type != SegmentIntersection::OUTER_HIGH); if ((intrsctn - 1)->is_inner()) { // Step back. -- intrsctn; -- i_intersection; myassert(intrsctn->type == SegmentIntersection::INNER_HIGH); try_connect = true; } } else { // Going down. myassert(intrsctn->is_high()); myassert(i_intersection > 0); myassert(! (intrsctn - 1)->consumed_vertical_up); // Consume the complete vertical segment up to the outer contour. if (intrsctn->is_inner()) intrsctn->consumed_vertical_up = true; do { myassert(i_intersection > 0); -- intrsctn; -- i_intersection; intrsctn->consumed_vertical_up = true; } while (intrsctn->type != SegmentIntersection::OUTER_LOW); if ((intrsctn + 1)->is_inner()) { // Step back. ++ intrsctn; ++ i_intersection; myassert(intrsctn->type == SegmentIntersection::INNER_LOW); try_connect = true; } } if (try_connect) { // Decide, whether to finish the segment, or whether to follow the perimeter. // 1) Find possible connection points on the previous / next vertical line. int iPrev = intersection_on_prev_vertical_line(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection); int iNext = intersection_on_next_vertical_line(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection); IntersectionTypeOtherVLine intrsctn_type_prev = intersection_type_on_prev_vertical_line(segs, i_vline, i_intersection, iPrev); IntersectionTypeOtherVLine intrsctn_type_next = intersection_type_on_next_vertical_line(segs, i_vline, i_intersection, iNext); // 2) Find possible connection points on the same vertical line. int iAbove = -1; int iBelow = -1; int iSegAbove = -1; int iSegBelow = -1; { SegmentIntersection::SegmentIntersectionType type_crossing = (intrsctn->type == SegmentIntersection::INNER_LOW) ? SegmentIntersection::INNER_HIGH : SegmentIntersection::INNER_LOW; // Does the perimeter intersect the current vertical line above intrsctn? for (size_t i = i_intersection + 1; i + 1 < seg.intersections.size(); ++ i) // if (seg.intersections[i].iContour == intrsctn->iContour && seg.intersections[i].type == type_crossing) { if (seg.intersections[i].iContour == intrsctn->iContour) { iAbove = i; iSegAbove = seg.intersections[i].iSegment; break; } // Does the perimeter intersect the current vertical line below intrsctn? for (size_t i = i_intersection - 1; i > 0; -- i) // if (seg.intersections[i].iContour == intrsctn->iContour && seg.intersections[i].type == type_crossing) { if (seg.intersections[i].iContour == intrsctn->iContour) { iBelow = i; iSegBelow = seg.intersections[i].iSegment; break; } } // 3) Sort the intersection points, clear iPrev / iNext / iSegBelow / iSegAbove, // if it is preceded by any other intersection point along the contour. unsigned int vert_seg_dir_valid_mask = (going_up ? (iSegAbove != -1 && seg.intersections[iAbove].type == SegmentIntersection::INNER_LOW) : (iSegBelow != -1 && seg.intersections[iBelow].type == SegmentIntersection::INNER_HIGH)) ? (DIR_FORWARD | DIR_BACKWARD) : 0; { // Invalidate iPrev resp. iNext, if the perimeter crosses the current vertical line earlier than iPrev resp. iNext. // The perimeter contour orientation. const bool forward = intrsctn->is_low(); // == poly_with_offset.is_contour_ccw(intrsctn->iContour); const Polygon &poly = poly_with_offset.contour(intrsctn->iContour); { int d_horiz = (iPrev == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, segs[i_vline-1].intersections[iPrev].iSegment, intrsctn->iSegment, forward); int d_down = (iSegBelow == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, iSegBelow, intrsctn->iSegment, forward); int d_up = (iSegAbove == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, iSegAbove, intrsctn->iSegment, forward); if (intrsctn_type_prev == INTERSECTION_TYPE_OTHER_VLINE_OK && d_horiz > std::min(d_down, d_up)) // The vertical crossing comes eralier than the prev crossing. // Disable the perimeter going back. intrsctn_type_prev = INTERSECTION_TYPE_OTHER_VLINE_NOT_FIRST; if (going_up ? (d_up > std::min(d_horiz, d_down)) : (d_down > std::min(d_horiz, d_up))) // The horizontal crossing comes earlier than the vertical crossing. vert_seg_dir_valid_mask &= ~(forward ? DIR_BACKWARD : DIR_FORWARD); } { int d_horiz = (iNext == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, intrsctn->iSegment, segs[i_vline+1].intersections[iNext].iSegment, forward); int d_down = (iSegBelow == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, intrsctn->iSegment, iSegBelow, forward); int d_up = (iSegAbove == -1) ? std::numeric_limits::max() : distance_of_segmens(poly, intrsctn->iSegment, iSegAbove, forward); if (intrsctn_type_next == INTERSECTION_TYPE_OTHER_VLINE_OK && d_horiz > std::min(d_down, d_up)) // The vertical crossing comes eralier than the prev crossing. // Disable the perimeter going forward. intrsctn_type_next = INTERSECTION_TYPE_OTHER_VLINE_NOT_FIRST; if (going_up ? (d_up > std::min(d_horiz, d_down)) : (d_down > std::min(d_horiz, d_up))) // The horizontal crossing comes earlier than the vertical crossing. vert_seg_dir_valid_mask &= ~(forward ? DIR_FORWARD : DIR_BACKWARD); } } // 4) Try to connect to a previous or next vertical line, making a zig-zag pattern. if (intrsctn_type_prev == INTERSECTION_TYPE_OTHER_VLINE_OK || intrsctn_type_next == INTERSECTION_TYPE_OTHER_VLINE_OK) { coordf_t distPrev = (intrsctn_type_prev != INTERSECTION_TYPE_OTHER_VLINE_OK) ? std::numeric_limits::max() : measure_perimeter_prev_segment_length(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iPrev); coordf_t distNext = (intrsctn_type_next != INTERSECTION_TYPE_OTHER_VLINE_OK) ? std::numeric_limits::max() : measure_perimeter_next_segment_length(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iNext); // Take the shorter path. //FIXME this may not be always the best strategy to take the shortest connection line now. bool take_next = (intrsctn_type_prev == INTERSECTION_TYPE_OTHER_VLINE_OK && intrsctn_type_next == INTERSECTION_TYPE_OTHER_VLINE_OK) ? (distNext < distPrev) : intrsctn_type_next == INTERSECTION_TYPE_OTHER_VLINE_OK; myassert(intrsctn->is_inner()); bool skip = params.dont_connect || (link_max_length > 0 && (take_next ? distNext : distPrev) > link_max_length); if (skip) { // Just skip the connecting contour and start a new path. goto dont_connect; polyline_current->points.push_back(Point(seg.pos, intrsctn->pos())); polylines_out.push_back(Polyline()); polyline_current = &polylines_out.back(); const SegmentedIntersectionLine &il2 = segs[take_next ? (i_vline + 1) : (i_vline - 1)]; polyline_current->points.push_back(Point(il2.pos, il2.intersections[take_next ? iNext : iPrev].pos())); } else { polyline_current->points.push_back(Point(seg.pos, intrsctn->pos())); emit_perimeter_prev_next_segment(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, take_next ? iNext : iPrev, *polyline_current, take_next); } // Mark both the left and right connecting segment as consumed, because one cannot go to this intersection point as it has been consumed. if (iPrev != -1) segs[i_vline-1].intersections[iPrev].consumed_perimeter_right = true; if (iNext != -1) intrsctn->consumed_perimeter_right = true; //FIXME consume the left / right connecting segments at the other end of this line? Currently it is not critical because a perimeter segment is not followed if the vertical segment at the other side has already been consumed. // Advance to the neighbor line. if (take_next) { ++ i_vline; i_intersection = iNext; } else { -- i_vline; i_intersection = iPrev; } continue; } // 5) Try to connect to a previous or next point on the same vertical line. if (vert_seg_dir_valid_mask) { bool valid = true; // Verify, that there is no intersection with the inner contour up to the end of the contour segment. // Verify, that the successive segment has not been consumed yet. if (going_up) { if (seg.intersections[iAbove].consumed_vertical_up) { valid = false; } else { for (int i = (int)i_intersection + 1; i < iAbove && valid; ++i) if (seg.intersections[i].is_inner()) valid = false; } } else { if (seg.intersections[iBelow-1].consumed_vertical_up) { valid = false; } else { for (int i = iBelow + 1; i < (int)i_intersection && valid; ++i) if (seg.intersections[i].is_inner()) valid = false; } } if (valid) { const Polygon &poly = poly_with_offset.contour(intrsctn->iContour); int iNext = going_up ? iAbove : iBelow; int iSegNext = going_up ? iSegAbove : iSegBelow; bool dir_forward = (vert_seg_dir_valid_mask == (DIR_FORWARD | DIR_BACKWARD)) ? // Take the shorter length between the current and the next intersection point. (distance_of_segmens(poly, intrsctn->iSegment, iSegNext, true) < distance_of_segmens(poly, intrsctn->iSegment, iSegNext, false)) : (vert_seg_dir_valid_mask == DIR_FORWARD); // Skip this perimeter line? bool skip = params.dont_connect; if (! skip && link_max_length > 0) { coordf_t link_length = measure_perimeter_segment_on_vertical_line_length( poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iNext, dir_forward); skip = link_length > link_max_length; } polyline_current->points.push_back(Point(seg.pos, intrsctn->pos())); if (skip) { // Just skip the connecting contour and start a new path. polylines_out.push_back(Polyline()); polyline_current = &polylines_out.back(); polyline_current->points.push_back(Point(seg.pos, seg.intersections[iNext].pos())); } else { // Consume the connecting contour and the next segment. emit_perimeter_segment_on_vertical_line(poly_with_offset, segs, i_vline, intrsctn->iContour, i_intersection, iNext, *polyline_current, dir_forward); } // Mark both the left and right connecting segment as consumed, because one cannot go to this intersection point as it has been consumed. // If there are any outer intersection points skipped (bypassed) by the contour, // mark them as processed. if (going_up) { for (int i = (int)i_intersection; i < iAbove; ++ i) seg.intersections[i].consumed_vertical_up = true; } else { for (int i = iBelow; i < (int)i_intersection; ++ i) seg.intersections[i].consumed_vertical_up = true; } // seg.intersections[going_up ? i_intersection : i_intersection - 1].consumed_vertical_up = true; intrsctn->consumed_perimeter_right = true; i_intersection = iNext; if (going_up) ++ intrsctn; else -- intrsctn; intrsctn->consumed_perimeter_right = true; continue; } } dont_connect: // No way to continue the current polyline. Take the rest of the line up to the outer contour. // This will finish the polyline, starting another polyline at a new point. if (going_up) ++ intrsctn; else -- intrsctn; } // Finish the current vertical line, // reset the current vertical line to pick a new starting point in the next round. myassert(intrsctn->is_outer()); myassert(intrsctn->is_high() == going_up); pointLast = Point(seg.pos, intrsctn->pos()); polyline_current->points.push_back(pointLast); // Handle duplicate points and zero length segments. polyline_current->remove_duplicate_points(); myassert(! polyline_current->has_duplicate_points()); // Handle nearly zero length edges. if (polyline_current->points.size() <= 1 || (polyline_current->points.size() == 2 && std::abs(polyline_current->points.front().x - polyline_current->points.back().x) < SCALED_EPSILON && std::abs(polyline_current->points.front().y - polyline_current->points.back().y) < SCALED_EPSILON)) polylines_out.pop_back(); intrsctn = NULL; i_intersection = -1; polyline_current = NULL; } #ifdef SLIC3R_DEBUG { { ::Slic3r::SVG svg(debug_out_path("FillRectilinear2-final-%03d.svg", iRun), bbox_svg); // , scale_(1.)); poly_with_offset.export_to_svg(svg); for (size_t i = n_polylines_out_initial; i < polylines_out.size(); ++ i) svg.draw(polylines_out[i].lines(), "black"); } // Paint a picture per polyline. This makes it easier to discover the order of the polylines and their overlap. for (size_t i_polyline = n_polylines_out_initial; i_polyline < polylines_out.size(); ++ i_polyline) { ::Slic3r::SVG svg(debug_out_path("FillRectilinear2-final-%03d-%03d.svg", iRun, i_polyline), bbox_svg); // , scale_(1.)); svg.draw(polylines_out[i_polyline].lines(), "black"); } } #endif /* SLIC3R_DEBUG */ // paths must be rotated back for (Polylines::iterator it = polylines_out.begin() + n_polylines_out_initial; it != polylines_out.end(); ++ it) { // No need to translate, the absolute position is irrelevant. // it->translate(- rotate_vector.second.x, - rotate_vector.second.y); myassert(! it->has_duplicate_points()); it->rotate(rotate_vector.first); //FIXME rather simplify the paths to avoid very short edges? //myassert(! it->has_duplicate_points()); it->remove_duplicate_points(); } #ifdef SLIC3R_DEBUG // Verify, that there are no duplicate points in the sequence. for (Polylines::iterator it = polylines_out.begin(); it != polylines_out.end(); ++ it) myassert(! it->has_duplicate_points()); #endif /* SLIC3R_DEBUG */ return true; } Polylines FillRectilinear2::fill_surface(const Surface *surface, const FillParams ¶ms) { Polylines polylines_out; if (! fill_surface_by_lines(surface, params, 0.f, 0.f, polylines_out)) { printf("FillRectilinear2::fill_surface() failed to fill a region.\n"); } return polylines_out; } Polylines FillGrid2::fill_surface(const Surface *surface, const FillParams ¶ms) { // Each linear fill covers half of the target coverage. FillParams params2 = params; params2.density *= 0.5f; Polylines polylines_out; if (! fill_surface_by_lines(surface, params2, 0.f, 0.f, polylines_out) || ! fill_surface_by_lines(surface, params2, float(M_PI / 2.), 0.f, polylines_out)) { printf("FillGrid2::fill_surface() failed to fill a region.\n"); } return polylines_out; } Polylines FillTriangles::fill_surface(const Surface *surface, const FillParams ¶ms) { // Each linear fill covers 1/3 of the target coverage. FillParams params2 = params; params2.density *= 0.333333333f; Polylines polylines_out; if (! fill_surface_by_lines(surface, params2, 0.f, 0., polylines_out) || ! fill_surface_by_lines(surface, params2, float(M_PI / 3.), 0., polylines_out) || ! fill_surface_by_lines(surface, params2, float(2. * M_PI / 3.), 0.5 * this->spacing / params2.density, polylines_out)) { printf("FillTriangles::fill_surface() failed to fill a region.\n"); } return polylines_out; } Polylines FillStars::fill_surface(const Surface *surface, const FillParams ¶ms) { // Each linear fill covers 1/3 of the target coverage. FillParams params2 = params; params2.density *= 0.333333333f; Polylines polylines_out; if (! fill_surface_by_lines(surface, params2, 0.f, 0., polylines_out) || ! fill_surface_by_lines(surface, params2, float(M_PI / 3.), 0., polylines_out) || ! fill_surface_by_lines(surface, params2, float(2. * M_PI / 3.), 0., polylines_out)) { printf("FillStars::fill_surface() failed to fill a region.\n"); } return polylines_out; } Polylines FillCubic::fill_surface(const Surface *surface, const FillParams ¶ms) { // Each linear fill covers 1/3 of the target coverage. FillParams params2 = params; params2.density *= 0.333333333f; Polylines polylines_out; if (! fill_surface_by_lines(surface, params2, 0.f, z, polylines_out) || ! fill_surface_by_lines(surface, params2, float(M_PI / 3.), -z, polylines_out) || // Rotated by PI*2/3 + PI to achieve reverse sloping wall. ! fill_surface_by_lines(surface, params2, float(M_PI * 2. / 3.), z, polylines_out)) { printf("FillCubic::fill_surface() failed to fill a region.\n"); } return polylines_out; } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/Fill/FillRectilinear2.hpp000066400000000000000000000036751301441720000243510ustar00rootroot00000000000000#ifndef slic3r_FillRectilinear2_hpp_ #define slic3r_FillRectilinear2_hpp_ #include "../libslic3r.h" #include "FillBase.hpp" namespace Slic3r { class Surface; class FillRectilinear2 : public Fill { public: virtual ~FillRectilinear2() {} virtual Polylines fill_surface(const Surface *surface, const FillParams ¶ms); protected: bool fill_surface_by_lines(const Surface *surface, const FillParams ¶ms, float angleBase, float pattern_shift, Polylines &polylines_out); }; class FillGrid2 : public FillRectilinear2 { public: virtual ~FillGrid2() {} virtual Polylines fill_surface(const Surface *surface, const FillParams ¶ms); protected: // The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill. virtual float _layer_angle(size_t idx) const { return 0.f; } }; class FillTriangles : public FillRectilinear2 { public: virtual ~FillTriangles() {} virtual Polylines fill_surface(const Surface *surface, const FillParams ¶ms); protected: // The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill. virtual float _layer_angle(size_t idx) const { return 0.f; } }; class FillStars : public FillRectilinear2 { public: virtual ~FillStars() {} virtual Polylines fill_surface(const Surface *surface, const FillParams ¶ms); protected: // The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill. virtual float _layer_angle(size_t idx) const { return 0.f; } }; class FillCubic : public FillRectilinear2 { public: virtual ~FillCubic() {} virtual Polylines fill_surface(const Surface *surface, const FillParams ¶ms); protected: // The grid fill will keep the angle constant between the layers, see the implementation of Slic3r::Fill. virtual float _layer_angle(size_t idx) const { return 0.f; } }; }; // namespace Slic3r #endif // slic3r_FillRectilinear2_hpp_ Slic3r-version_1.31.6/xs/src/libslic3r/Flow.cpp000066400000000000000000000104741301441720000212260ustar00rootroot00000000000000#include "Flow.hpp" #include #include namespace Slic3r { /* This constructor builds a Flow object from an extrusion width config setting and other context properties. */ Flow Flow::new_from_config_width(FlowRole role, const ConfigOptionFloatOrPercent &width, float nozzle_diameter, float height, float bridge_flow_ratio) { // we need layer height unless it's a bridge if (height <= 0 && bridge_flow_ratio == 0) CONFESS("Invalid flow height supplied to new_from_config_width()"); float w; if (bridge_flow_ratio > 0) { // if bridge flow was requested, calculate bridge width height = w = Flow::_bridge_width(nozzle_diameter, bridge_flow_ratio); } else if (!width.percent && width.value == 0) { // if user left option to 0, calculate a sane default width w = Flow::_auto_width(role, nozzle_diameter, height); } else { // if user set a manual value, use it w = width.get_abs_value(height); } return Flow(w, height, nozzle_diameter, bridge_flow_ratio > 0); } /* This constructor builds a Flow object from a given centerline spacing. */ Flow Flow::new_from_spacing(float spacing, float nozzle_diameter, float height, bool bridge) { // we need layer height unless it's a bridge if (height <= 0 && !bridge) CONFESS("Invalid flow height supplied to new_from_spacing()"); float w = Flow::_width_from_spacing(spacing, nozzle_diameter, height, bridge); if (bridge) height = w; return Flow(w, height, nozzle_diameter, bridge); } /* This method returns the centerline spacing between two adjacent extrusions having the same extrusion width (and other properties). */ float Flow::spacing() const { if (this->bridge) { return this->width + BRIDGE_EXTRA_SPACING; } // rectangle with semicircles at the ends float min_flow_spacing = this->width - this->height * (1 - PI/4.0); return this->width - OVERLAP_FACTOR * (this->width - min_flow_spacing); } /* This method returns the centerline spacing between an extrusion using this flow and another one using another flow. this->spacing(other) shall return the same value as other.spacing(*this) */ float Flow::spacing(const Flow &other) const { assert(this->height == other.height); assert(this->bridge == other.bridge); if (this->bridge) { return this->width/2 + other.width/2 + BRIDGE_EXTRA_SPACING; } return this->spacing()/2 + other.spacing()/2; } /* This method returns extrusion volume per head move unit. */ double Flow::mm3_per_mm() const { if (this->bridge) { return (this->width * this->width) * PI/4.0; } // rectangle with semicircles at the ends return this->width * this->height + (this->height*this->height) / 4.0 * (PI-4.0); } /* This static method returns bridge width for a given nozzle diameter. */ float Flow::_bridge_width(float nozzle_diameter, float bridge_flow_ratio) { return (bridge_flow_ratio == 1.) ? // optimization to avoid sqrt() nozzle_diameter : sqrt(bridge_flow_ratio) * nozzle_diameter; } /* This static method returns a sane extrusion width default. */ float Flow::_auto_width(FlowRole role, float nozzle_diameter, float height) { // here we calculate a sane default by matching the flow speed (at the nozzle) and the feed rate // shape: rectangle with semicircles at the ends float width = ((nozzle_diameter*nozzle_diameter) * PI + (height*height) * (4.0 - PI)) / (4.0 * height); float min = nozzle_diameter * 1.05; float max = -1; if (role == frExternalPerimeter || role == frSupportMaterial || role == frSupportMaterialInterface) { min = max = nozzle_diameter; } else if (role != frInfill) { // do not limit width for sparse infill so that we use full native flow for it max = nozzle_diameter * 1.7; } if (max != -1 && width > max) width = max; if (width < min) width = min; return width; } /* This static method returns the extrusion width value corresponding to the supplied centerline spacing. */ float Flow::_width_from_spacing(float spacing, float nozzle_diameter, float height, bool bridge) { if (bridge) { return spacing - BRIDGE_EXTRA_SPACING; } // rectangle with semicircles at the ends return spacing + OVERLAP_FACTOR * height * (1 - PI/4.0); } } Slic3r-version_1.31.6/xs/src/libslic3r/Flow.hpp000066400000000000000000000031461301441720000212310ustar00rootroot00000000000000#ifndef slic3r_Flow_hpp_ #define slic3r_Flow_hpp_ #include "libslic3r.h" #include "Config.hpp" #include "ExtrusionEntity.hpp" namespace Slic3r { #define BRIDGE_EXTRA_SPACING 0.05 #define OVERLAP_FACTOR 1.0 enum FlowRole { frExternalPerimeter, frPerimeter, frInfill, frSolidInfill, frTopSolidInfill, frSupportMaterial, frSupportMaterialInterface, }; class Flow { public: float width, height, nozzle_diameter; bool bridge; Flow(float _w, float _h, float _nd, bool _bridge = false) : width(_w), height(_h), nozzle_diameter(_nd), bridge(_bridge) {}; float spacing() const; float spacing(const Flow &other) const; double mm3_per_mm() const; coord_t scaled_width() const { return scale_(this->width); }; coord_t scaled_spacing() const { return scale_(this->spacing()); }; coord_t scaled_spacing(const Flow &other) const { return scale_(this->spacing(other)); }; static Flow new_from_config_width(FlowRole role, const ConfigOptionFloatOrPercent &width, float nozzle_diameter, float height, float bridge_flow_ratio); static Flow new_from_spacing(float spacing, float nozzle_diameter, float height, bool bridge); private: static float _bridge_width(float nozzle_diameter, float bridge_flow_ratio); static float _auto_width(FlowRole role, float nozzle_diameter, float height); static float _width_from_spacing(float spacing, float nozzle_diameter, float height, bool bridge); static float _spacing(float width, float nozzle_diameter, float height, float bridge_flow_ratio); }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/GCode.cpp000066400000000000000000001222051301441720000212740ustar00rootroot00000000000000#include "GCode.hpp" #include "ExtrusionEntity.hpp" #include "EdgeGrid.hpp" #include #include #include #include "SVG.hpp" #if 0 // Enable debugging and asserts, even in the release build. #define DEBUG #define _DEBUG #undef NDEBUG #endif #include namespace Slic3r { AvoidCrossingPerimeters::AvoidCrossingPerimeters() : use_external_mp(false), use_external_mp_once(false), disable_once(true), _external_mp(NULL), _layer_mp(NULL) { } AvoidCrossingPerimeters::~AvoidCrossingPerimeters() { if (this->_external_mp != NULL) delete this->_external_mp; if (this->_layer_mp != NULL) delete this->_layer_mp; } void AvoidCrossingPerimeters::init_external_mp(const ExPolygons &islands) { if (this->_external_mp != NULL) delete this->_external_mp; this->_external_mp = new MotionPlanner(islands); } void AvoidCrossingPerimeters::init_layer_mp(const ExPolygons &islands) { if (this->_layer_mp != NULL) delete this->_layer_mp; this->_layer_mp = new MotionPlanner(islands); } Polyline AvoidCrossingPerimeters::travel_to(GCode &gcodegen, Point point) { if (this->use_external_mp || this->use_external_mp_once) { // get current origin set in gcodegen // (the one that will be used to translate the G-code coordinates by) Point scaled_origin = Point::new_scale(gcodegen.origin.x, gcodegen.origin.y); // represent last_pos in absolute G-code coordinates Point last_pos = gcodegen.last_pos(); last_pos.translate(scaled_origin); // represent point in absolute G-code coordinates point.translate(scaled_origin); // calculate path Polyline travel = this->_external_mp->shortest_path(last_pos, point); //exit(0); // translate the path back into the shifted coordinate system that gcodegen // is currently using for writing coordinates travel.translate(scaled_origin.negative()); return travel; } else { return this->_layer_mp->shortest_path(gcodegen.last_pos(), point); } } OozePrevention::OozePrevention() : enable(false) { } std::string OozePrevention::pre_toolchange(GCode &gcodegen) { std::string gcode; // move to the nearest standby point if (!this->standby_points.empty()) { // get current position in print coordinates Pointf3 writer_pos = gcodegen.writer.get_position(); Point pos = Point::new_scale(writer_pos.x, writer_pos.y); // find standby point Point standby_point; pos.nearest_point(this->standby_points, &standby_point); /* We don't call gcodegen.travel_to() because we don't need retraction (it was already triggered by the caller) nor avoid_crossing_perimeters and also because the coordinates of the destination point must not be transformed by origin nor current extruder offset. */ gcode += gcodegen.writer.travel_to_xy(Pointf::new_unscale(standby_point), "move to standby position"); } if (gcodegen.config.standby_temperature_delta.value != 0) { // we assume that heating is always slower than cooling, so no need to block gcode += gcodegen.writer.set_temperature (this->_get_temp(gcodegen) + gcodegen.config.standby_temperature_delta.value, false); } return gcode; } std::string OozePrevention::post_toolchange(GCode &gcodegen) { std::string gcode; if (gcodegen.config.standby_temperature_delta.value != 0) { gcode += gcodegen.writer.set_temperature(this->_get_temp(gcodegen), true); } return gcode; } int OozePrevention::_get_temp(GCode &gcodegen) { return (gcodegen.layer != NULL && gcodegen.layer->id() == 0) ? gcodegen.config.first_layer_temperature.get_at(gcodegen.writer.extruder()->id) : gcodegen.config.temperature.get_at(gcodegen.writer.extruder()->id); } Wipe::Wipe() : enable(false) { } bool Wipe::has_path() { return !this->path.points.empty(); } void Wipe::reset_path() { this->path = Polyline(); } std::string Wipe::wipe(GCode &gcodegen, bool toolchange) { std::string gcode; /* Reduce feedrate a bit; travel speed is often too high to move on existing material. Too fast = ripping of existing material; too slow = short wipe path, thus more blob. */ double wipe_speed = gcodegen.writer.config.travel_speed.value * 0.8; // get the retraction length double length = toolchange ? gcodegen.writer.extruder()->retract_length_toolchange() : gcodegen.writer.extruder()->retract_length(); if (length > 0) { /* Calculate how long we need to travel in order to consume the required amount of retraction. In other words, how far do we move in XY at wipe_speed for the time needed to consume retract_length at retract_speed? */ double wipe_dist = scale_(length / gcodegen.writer.extruder()->retract_speed() * wipe_speed); /* Take the stored wipe path and replace first point with the current actual position (they might be different, for example, in case of loop clipping). */ Polyline wipe_path; wipe_path.append(gcodegen.last_pos()); wipe_path.append( this->path.points.begin() + 1, this->path.points.end() ); wipe_path.clip_end(wipe_path.length() - wipe_dist); // subdivide the retraction in segments double retracted = 0; Lines lines = wipe_path.lines(); for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { double segment_length = line->length(); /* Reduce retraction length a bit to avoid effective retraction speed to be greater than the configured one due to rounding (TODO: test and/or better math for this) */ double dE = length * (segment_length / wipe_dist) * 0.95; gcode += gcodegen.writer.set_speed(wipe_speed*60, "", gcodegen.enable_cooling_markers ? ";_WIPE" : ""); gcode += gcodegen.writer.extrude_to_xy( gcodegen.point_to_gcode(line->b), -dE, "wipe and retract" ); retracted += dE; } gcodegen.writer.extruder()->retracted += retracted; // prevent wiping again on same path this->reset_path(); } return gcode; } #define EXTRUDER_CONFIG(OPT) this->config.OPT.get_at(this->writer.extruder()->id) GCode::GCode() : placeholder_parser(NULL), enable_loop_clipping(true), enable_cooling_markers(false), enable_extrusion_role_markers(false), enable_analyzer_markers(false), layer_count(0), layer_index(-1), layer(NULL), first_layer(false), elapsed_time(0.0), volumetric_speed(0), _last_pos_defined(false), _lower_layer_edge_grid(NULL), _last_extrusion_role(erNone) { } GCode::~GCode() { delete _lower_layer_edge_grid; _lower_layer_edge_grid = NULL; } const Point& GCode::last_pos() const { return this->_last_pos; } void GCode::set_last_pos(const Point &pos) { this->_last_pos = pos; this->_last_pos_defined = true; } bool GCode::last_pos_defined() const { return this->_last_pos_defined; } void GCode::apply_print_config(const PrintConfig &print_config) { this->writer.apply_print_config(print_config); this->config.apply(print_config); } void GCode::set_extruders(const std::vector &extruder_ids) { this->writer.set_extruders(extruder_ids); // enable wipe path generation if any extruder has wipe enabled this->wipe.enable = false; for (std::vector::const_iterator it = extruder_ids.begin(); it != extruder_ids.end(); ++it) { if (this->config.wipe.get_at(*it)) { this->wipe.enable = true; break; } } } void GCode::set_origin(const Pointf &pointf) { // if origin increases (goes towards right), last_pos decreases because it goes towards left const Point translate( scale_(this->origin.x - pointf.x), scale_(this->origin.y - pointf.y) ); this->_last_pos.translate(translate); this->wipe.path.translate(translate); this->origin = pointf; } std::string GCode::preamble() { std::string gcode = this->writer.preamble(); /* Perform a *silent* move to z_offset: we need this to initialize the Z position of our writer object so that any initial lift taking place before the first layer change will raise the extruder from the correct initial Z instead of 0. */ this->writer.travel_to_z(this->config.z_offset.value); return gcode; } std::string GCode::change_layer(const Layer &layer) { this->layer = &layer; this->layer_index++; this->first_layer = (layer.id() == 0); delete this->_lower_layer_edge_grid; this->_lower_layer_edge_grid = NULL; std::string gcode; if (enable_analyzer_markers) { // Store the binary pointer to the layer object directly into the G-code to be accessed by the GCodeAnalyzer. char buf[64]; sprintf(buf, ";_LAYEROBJ:%p\n", this->layer); gcode += buf; } // avoid computing islands and overhangs if they're not needed if (this->config.avoid_crossing_perimeters) { ExPolygons islands; union_(layer.slices, &islands, true); this->avoid_crossing_perimeters.init_layer_mp(islands); } if (this->layer_count > 0) { gcode += this->writer.update_progress(this->layer_index, this->layer_count); } coordf_t z = layer.print_z + this->config.z_offset.value; // in unscaled coordinates if (EXTRUDER_CONFIG(retract_layer_change) && this->writer.will_move_z(z)) { gcode += this->retract(); } { std::ostringstream comment; comment << "move to next layer (" << this->layer_index << ")"; gcode += this->writer.travel_to_z(z, comment.str()); } // forget last wiping path as wiping after raising Z is pointless this->wipe.reset_path(); return gcode; } static inline const char* ExtrusionRole2String(const ExtrusionRole role) { switch (role) { case erNone: return "erNone"; case erPerimeter: return "erPerimeter"; case erExternalPerimeter: return "erExternalPerimeter"; case erOverhangPerimeter: return "erOverhangPerimeter"; case erInternalInfill: return "erInternalInfill"; case erSolidInfill: return "erSolidInfill"; case erTopSolidInfill: return "erTopSolidInfill"; case erBridgeInfill: return "erBridgeInfill"; case erGapFill: return "erGapFill"; case erSkirt: return "erSkirt"; case erSupportMaterial: return "erSupportMaterial"; case erSupportMaterialInterface: return "erSupportMaterialInterface"; default: return "erInvalid"; }; } static inline const char* ExtrusionLoopRole2String(const ExtrusionLoopRole role) { switch (role) { case elrDefault: return "elrDefault"; case elrContourInternalPerimeter: return "elrContourInternalPerimeter"; case elrSkirt: return "elrSkirt"; default: return "elrInvalid"; } }; // Return a value in <0, 1> of a cubic B-spline kernel centered around zero. // The B-spline is re-scaled so it has value 1 at zero. static inline float bspline_kernel(float x) { x = std::abs(x); if (x < 1.f) { return 1.f - (3. / 2.) * x * x + (3.f / 4.f) * x * x * x; } else if (x < 2.f) { x -= 1.f; float x2 = x * x; float x3 = x2 * x; return (1.f / 4.f) - (3.f / 4.f) * x + (3.f / 4.f) * x2 - (1.f / 4.f) * x3; } else return 0; } static float extrudate_overlap_penalty(float nozzle_r, float weight_zero, float overlap_distance) { // The extrudate is not fully supported by the lower layer. Fit a polynomial penalty curve. // Solved by sympy package: /* from sympy import * (x,a,b,c,d,r,z)=symbols('x a b c d r z') p = a + b*x + c*x*x + d*x*x*x p2 = p.subs(solve([p.subs(x, -r), p.diff(x).subs(x, -r), p.diff(x,x).subs(x, -r), p.subs(x, 0)-z], [a, b, c, d])) from sympy.plotting import plot plot(p2.subs(r,0.2).subs(z,1.), (x, -1, 3), adaptive=False, nb_of_points=400) */ if (overlap_distance < - nozzle_r) { // The extrudate is fully supported by the lower layer. This is the ideal case, therefore zero penalty. return 0.f; } else { float x = overlap_distance / nozzle_r; float x2 = x * x; float x3 = x2 * x; return weight_zero * (1.f + 3.f * x + 3.f * x2 + x3); } } static Points::iterator project_point_to_polygon_and_insert(Polygon &polygon, const Point &pt, double eps) { assert(polygon.points.size() >= 2); if (polygon.points.size() <= 1) if (polygon.points.size() == 1) return polygon.points.begin(); Point pt_min; double d_min = std::numeric_limits::max(); size_t i_min = size_t(-1); for (size_t i = 0; i < polygon.points.size(); ++ i) { size_t j = i + 1; if (j == polygon.points.size()) j = 0; const Point &p1 = polygon.points[i]; const Point &p2 = polygon.points[j]; const Slic3r::Point v_seg = p1.vector_to(p2); const Slic3r::Point v_pt = p1.vector_to(pt); const int64_t l2_seg = int64_t(v_seg.x) * int64_t(v_seg.x) + int64_t(v_seg.y) * int64_t(v_seg.y); int64_t t_pt = int64_t(v_seg.x) * int64_t(v_pt.x) + int64_t(v_seg.y) * int64_t(v_pt.y); if (t_pt < 0) { // Closest to p1. double dabs = sqrt(int64_t(v_pt.x) * int64_t(v_pt.x) + int64_t(v_pt.y) * int64_t(v_pt.y)); if (dabs < d_min) { d_min = dabs; i_min = i; pt_min = p1; } } else if (t_pt > l2_seg) { // Closest to p2. Then p2 is the starting point of another segment, which shall be discovered in the next step. continue; } else { // Closest to the segment. assert(t_pt >= 0 && t_pt <= l2_seg); int64_t d_seg = int64_t(v_seg.y) * int64_t(v_pt.x) - int64_t(v_seg.x) * int64_t(v_pt.y); double d = double(d_seg) / sqrt(double(l2_seg)); double dabs = std::abs(d); if (dabs < d_min) { d_min = dabs; i_min = i; // Evaluate the foot point. pt_min = p1; double linv = double(d_seg) / double(l2_seg); pt_min.x = pt.x - coord_t(floor(double(v_seg.y) * linv + 0.5)); pt_min.y = pt.y + coord_t(floor(double(v_seg.x) * linv + 0.5)); assert(Line(p1, p2).distance_to(pt_min) < scale_(1e-5)); } } } assert(i_min != size_t(-1)); if (pt_min.distance_to(polygon.points[i_min]) > eps) { // Insert a new point on the segment i_min, i_min+1. return polygon.points.insert(polygon.points.begin() + (i_min + 1), pt_min); } return polygon.points.begin() + i_min; } std::vector polygon_parameter_by_length(const Polygon &polygon) { // Parametrize the polygon by its length. std::vector lengths(polygon.points.size()+1, 0.); for (size_t i = 1; i < polygon.points.size(); ++ i) lengths[i] = lengths[i-1] + polygon.points[i].distance_to(polygon.points[i-1]); lengths.back() = lengths[lengths.size()-2] + polygon.points.front().distance_to(polygon.points.back()); return lengths; } std::vector polygon_angles_at_vertices(const Polygon &polygon, const std::vector &lengths, float min_arm_length) { assert(polygon.points.size() + 1 == lengths.size()); if (min_arm_length > 0.25f * lengths.back()) min_arm_length = 0.25f * lengths.back(); // Find the initial prev / next point span. size_t idx_prev = polygon.points.size(); size_t idx_curr = 0; size_t idx_next = 1; while (idx_prev > idx_curr && lengths.back() - lengths[idx_prev] < min_arm_length) -- idx_prev; while (idx_next < idx_prev && lengths[idx_next] < min_arm_length) ++ idx_next; std::vector angles(polygon.points.size(), 0.f); for (; idx_curr < polygon.points.size(); ++ idx_curr) { // Move idx_prev up until the distance between idx_prev and idx_curr is lower than min_arm_length. if (idx_prev >= idx_curr) { while (idx_prev < polygon.points.size() && lengths.back() - lengths[idx_prev] + lengths[idx_curr] > min_arm_length) ++ idx_prev; if (idx_prev == polygon.points.size()) idx_prev = 0; } while (idx_prev < idx_curr && lengths[idx_curr] - lengths[idx_prev] > min_arm_length) ++ idx_prev; // Move idx_prev one step back. if (idx_prev == 0) idx_prev = polygon.points.size() - 1; else -- idx_prev; // Move idx_next up until the distance between idx_curr and idx_next is greater than min_arm_length. if (idx_curr <= idx_next) { while (idx_next < polygon.points.size() && lengths[idx_next] - lengths[idx_curr] < min_arm_length) ++ idx_next; if (idx_next == polygon.points.size()) idx_next = 0; } while (idx_next < idx_curr && lengths.back() - lengths[idx_curr] + lengths[idx_next] < min_arm_length) ++ idx_next; // Calculate angle between idx_prev, idx_curr, idx_next. const Point &p0 = polygon.points[idx_prev]; const Point &p1 = polygon.points[idx_curr]; const Point &p2 = polygon.points[idx_next]; const Point v1 = p0.vector_to(p1); const Point v2 = p1.vector_to(p2); int64_t dot = int64_t(v1.x)*int64_t(v2.x) + int64_t(v1.y)*int64_t(v2.y); int64_t cross = int64_t(v1.x)*int64_t(v2.y) - int64_t(v1.y)*int64_t(v2.x); float angle = float(atan2(double(cross), double(dot))); angles[idx_curr] = angle; } return angles; } std::string GCode::extrude(ExtrusionLoop loop, std::string description, double speed) { // get a copy; don't modify the orientation of the original loop object otherwise // next copies (if any) would not detect the correct orientation if (this->layer->lower_layer != NULL) { if (this->_lower_layer_edge_grid == NULL) { // Create the distance field for a layer below. const coord_t distance_field_resolution = scale_(1.f); this->_lower_layer_edge_grid = new EdgeGrid::Grid(); this->_lower_layer_edge_grid->create(this->layer->lower_layer->slices, distance_field_resolution); this->_lower_layer_edge_grid->calculate_sdf(); #if 0 { static int iRun = 0; BoundingBox bbox = this->_lower_layer_edge_grid->bbox(); bbox.min.x -= scale_(5.f); bbox.min.y -= scale_(5.f); bbox.max.x += scale_(5.f); bbox.max.y += scale_(5.f); EdgeGrid::save_png(*this->_lower_layer_edge_grid, bbox, scale_(0.1f), debug_out_path("GCode_extrude_loop_edge_grid-%d.png", iRun++)); } #endif } } // extrude all loops ccw bool was_clockwise = loop.make_counter_clockwise(); SeamPosition seam_position = this->config.seam_position; if (loop.role == elrSkirt) seam_position = spNearest; // find the point of the loop that is closest to the current extruder position // or randomize if requested Point last_pos = this->last_pos(); if (this->config.spiral_vase) { loop.split_at(last_pos); } else if (seam_position == spNearest || seam_position == spAligned) { Polygon polygon = loop.polygon(); const coordf_t nozzle_dmr = EXTRUDER_CONFIG(nozzle_diameter); const coord_t nozzle_r = scale_(0.5*nozzle_dmr); // Retrieve the last start position for this object. float last_pos_weight = 1.f; if (seam_position == spAligned && this->layer != NULL && this->_seam_position.count(this->layer->object()) > 0) { last_pos = this->_seam_position[this->layer->object()]; last_pos_weight = 5.f; } // Insert a projection of last_pos into the polygon. size_t last_pos_proj_idx; { Points::iterator it = project_point_to_polygon_and_insert(polygon, last_pos, 0.1 * nozzle_r); last_pos_proj_idx = it - polygon.points.begin(); } Point last_pos_proj = polygon.points[last_pos_proj_idx]; // Parametrize the polygon by its length. std::vector lengths = polygon_parameter_by_length(polygon); // For each polygon point, store a penalty. // First calculate the angles, store them as penalties. The angles are caluculated over a minimum arm length of nozzle_r. std::vector penalties = polygon_angles_at_vertices(polygon, lengths, nozzle_r); // No penalty for reflex points, slight penalty for convex points, high penalty for flat surfaces. const float penaltyConvexVertex = 1.f; const float penaltyFlatSurface = 5.f; const float penaltySeam = 1.3f; const float penaltyOverhangHalf = 10.f; // Penalty for visible seams. for (size_t i = 0; i < polygon.points.size(); ++ i) { float ccwAngle = penalties[i]; if (was_clockwise) ccwAngle = - ccwAngle; float penalty = 0; // if (ccwAngle <- float(PI/3.)) if (ccwAngle <- float(0.6 * PI)) // Sharp reflex vertex. We love that, it hides the seam perfectly. penalty = 0.f; // else if (ccwAngle > float(PI/3.)) else if (ccwAngle > float(0.6 * PI)) // Seams on sharp convex vertices are more visible than on reflex vertices. penalty = penaltyConvexVertex; else if (ccwAngle < 0.f) { // Interpolate penalty between maximum and zero. penalty = penaltyFlatSurface * bspline_kernel(ccwAngle * (PI * 2. / 3.)); } else { assert(ccwAngle >= 0.f); // Interpolate penalty between maximum and the penalty for a convex vertex. penalty = penaltyConvexVertex + (penaltyFlatSurface - penaltyConvexVertex) * bspline_kernel(ccwAngle * (PI * 2. / 3.)); } // Give a negative penalty for points close to the last point or the prefered seam location. //float dist_to_last_pos_proj = last_pos_proj.distance_to(polygon.points[i]); float dist_to_last_pos_proj = (i < last_pos_proj_idx) ? std::min(lengths[last_pos_proj_idx] - lengths[i], lengths.back() - lengths[last_pos_proj_idx] + lengths[i]) : std::min(lengths[i] - lengths[last_pos_proj_idx], lengths.back() - lengths[i] + lengths[last_pos_proj_idx]); float dist_max = 0.1f * lengths.back(); // 5.f * nozzle_dmr penalty -= last_pos_weight * bspline_kernel(dist_to_last_pos_proj / dist_max); penalties[i] = std::max(0.f, penalty); } // Penalty for overhangs. if (this->_lower_layer_edge_grid) { // Use the edge grid distance field structure over the lower layer to calculate overhangs. coord_t nozzle_r = scale_(0.5*nozzle_dmr); coord_t search_r = scale_(0.8*nozzle_dmr); for (size_t i = 0; i < polygon.points.size(); ++ i) { const Point &p = polygon.points[i]; coordf_t dist; // Signed distance is positive outside the object, negative inside the object. // The point is considered at an overhang, if it is more than nozzle radius // outside of the lower layer contour. bool found = this->_lower_layer_edge_grid->signed_distance(p, search_r, dist); // If the approximate Signed Distance Field was initialized over this->_lower_layer_edge_grid, // then the signed distnace shall always be known. assert(found); penalties[i] += extrudate_overlap_penalty(nozzle_r, penaltyOverhangHalf, dist); } } // Find a point with a minimum penalty. size_t idx_min = std::min_element(penalties.begin(), penalties.end()) - penalties.begin(); // Export the contour into a SVG file. #if 0 { static int iRun = 0; SVG svg(debug_out_path("GCode_extrude_loop-%d.svg", iRun ++)); if (this->layer->lower_layer != NULL) svg.draw(this->layer->lower_layer->slices.expolygons); for (size_t i = 0; i < loop.paths.size(); ++ i) svg.draw(loop.paths[i].as_polyline(), "red"); Polylines polylines; for (size_t i = 0; i < loop.paths.size(); ++ i) polylines.push_back(loop.paths[i].as_polyline()); Slic3r::Polygons polygons; coordf_t nozzle_dmr = EXTRUDER_CONFIG(nozzle_diameter); coord_t delta = scale_(0.5*nozzle_dmr); Slic3r::offset(polylines, &polygons, delta); // for (size_t i = 0; i < polygons.size(); ++ i) svg.draw((Polyline)polygons[i], "blue"); svg.draw(last_pos, "green", 3); svg.draw(polygon.points[idx_min], "yellow", 3); svg.Close(); } #endif // Split the loop at the point with a minium penalty. if (!loop.split_at_vertex(polygon.points[idx_min])) // The point is not in the original loop. Insert it. loop.split_at(polygon.points[idx_min]); } else if (seam_position == spRandom) { if (loop.role == elrContourInternalPerimeter) { // This loop does not contain any other loop. Set a random position. // The other loops will get a seam close to the random point chosen // on the inner most contour. //FIXME This works correctly for inner contours first only. //FIXME Better parametrize the loop by its length. Polygon polygon = loop.polygon(); Point centroid = polygon.centroid(); last_pos = Point(polygon.bounding_box().max.x, centroid.y); last_pos.rotate(fmod((float)rand()/16.0, 2.0*PI), centroid); } loop.split_at(last_pos); } // clip the path to avoid the extruder to get exactly on the first point of the loop; // if polyline was shorter than the clipping distance we'd get a null polyline, so // we discard it in that case double clip_length = this->enable_loop_clipping ? scale_(EXTRUDER_CONFIG(nozzle_diameter)) * LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER : 0; // get paths ExtrusionPaths paths; loop.clip_end(clip_length, &paths); if (paths.empty()) return ""; // apply the small perimeter speed if (paths.front().is_perimeter() && loop.length() <= SMALL_PERIMETER_LENGTH) { if (speed == -1) speed = this->config.get_abs_value("small_perimeter_speed"); } // extrude along the path std::string gcode; for (ExtrusionPaths::const_iterator path = paths.begin(); path != paths.end(); ++path) // description += ExtrusionLoopRole2String(loop.role); // description += ExtrusionRole2String(path->role); gcode += this->_extrude(*path, description, speed); // reset acceleration gcode += this->writer.set_acceleration(this->config.default_acceleration.value); if (this->wipe.enable) this->wipe.path = paths.front().polyline; // TODO: don't limit wipe to last path // make a little move inwards before leaving loop if (paths.back().role == erExternalPerimeter && this->layer != NULL && this->config.perimeters > 1) { // detect angle between last and first segment // the side depends on the original winding order of the polygon (left for contours, right for holes) Point a = paths.front().polyline.points[1]; // second point Point b = *(paths.back().polyline.points.end()-3); // second to last point if (was_clockwise) { // swap points Point c = a; a = b; b = c; } double angle = paths.front().first_point().ccw_angle(a, b) / 3; // turn left if contour, turn right if hole if (was_clockwise) angle *= -1; // create the destination point along the first segment and rotate it // we make sure we don't exceed the segment length because we don't know // the rotation of the second segment so we might cross the object boundary Line first_segment( paths.front().polyline.points[0], paths.front().polyline.points[1] ); double distance = std::min( scale_(EXTRUDER_CONFIG(nozzle_diameter)), first_segment.length() ); Point point = first_segment.point_at(distance); point.rotate(angle, first_segment.a); // generate the travel move gcode += this->writer.travel_to_xy(this->point_to_gcode(point), "move inwards before travel"); } return gcode; } std::string GCode::extrude(const ExtrusionEntity &entity, std::string description, double speed) { if (const ExtrusionPath* path = dynamic_cast(&entity)) { return this->extrude(*path, description, speed); } else if (const ExtrusionLoop* loop = dynamic_cast(&entity)) { return this->extrude(*loop, description, speed); } else { CONFESS("Invalid argument supplied to extrude()"); return ""; } } std::string GCode::extrude(const ExtrusionPath &path, std::string description, double speed) { // description += ExtrusionRole2String(path.role); std::string gcode = this->_extrude(path, description, speed); // reset acceleration gcode += this->writer.set_acceleration(this->config.default_acceleration.value); return gcode; } std::string GCode::_extrude(ExtrusionPath path, std::string description, double speed) { path.simplify(SCALED_RESOLUTION); std::string gcode; // go to first point of extrusion path if (!this->_last_pos_defined || !this->_last_pos.coincides_with(path.first_point())) { gcode += this->travel_to( path.first_point(), path.role, "move to first " + description + " point" ); } // compensate retraction gcode += this->unretract(); // adjust acceleration { double acceleration; if (this->config.first_layer_acceleration.value > 0 && this->first_layer) { acceleration = this->config.first_layer_acceleration.value; } else if (this->config.perimeter_acceleration.value > 0 && path.is_perimeter()) { acceleration = this->config.perimeter_acceleration.value; } else if (this->config.bridge_acceleration.value > 0 && path.is_bridge()) { acceleration = this->config.bridge_acceleration.value; } else if (this->config.infill_acceleration.value > 0 && path.is_infill()) { acceleration = this->config.infill_acceleration.value; } else { acceleration = this->config.default_acceleration.value; } gcode += this->writer.set_acceleration(acceleration); } // calculate extrusion length per distance unit double e_per_mm = this->writer.extruder()->e_per_mm3 * path.mm3_per_mm; if (this->writer.extrusion_axis().empty()) e_per_mm = 0; // set speed if (speed == -1) { if (path.role == erPerimeter) { speed = this->config.get_abs_value("perimeter_speed"); } else if (path.role == erExternalPerimeter) { speed = this->config.get_abs_value("external_perimeter_speed"); } else if (path.role == erOverhangPerimeter || path.role == erBridgeInfill) { speed = this->config.get_abs_value("bridge_speed"); } else if (path.role == erInternalInfill) { speed = this->config.get_abs_value("infill_speed"); } else if (path.role == erSolidInfill) { speed = this->config.get_abs_value("solid_infill_speed"); } else if (path.role == erTopSolidInfill) { speed = this->config.get_abs_value("top_solid_infill_speed"); } else if (path.role == erGapFill) { speed = this->config.get_abs_value("gap_fill_speed"); } else { CONFESS("Invalid speed"); } } if (this->first_layer) { speed = this->config.get_abs_value("first_layer_speed", speed); } if (this->volumetric_speed != 0 && speed == 0) { speed = this->volumetric_speed / path.mm3_per_mm; } if (this->config.max_volumetric_speed.value > 0) { // cap speed with max_volumetric_speed anyway (even if user is not using autospeed) speed = std::min( speed, this->config.max_volumetric_speed.value / path.mm3_per_mm ); } if (EXTRUDER_CONFIG(filament_max_volumetric_speed) > 0) { // cap speed with max_volumetric_speed anyway (even if user is not using autospeed) speed = std::min( speed, EXTRUDER_CONFIG(filament_max_volumetric_speed) / path.mm3_per_mm ); } double F = speed * 60; // convert mm/sec to mm/min // extrude arc or line if (this->enable_extrusion_role_markers || this->enable_analyzer_markers) { if (path.role != this->_last_extrusion_role) { this->_last_extrusion_role = path.role; char buf[32]; sprintf(buf, ";_EXTRUSION_ROLE:%d\n", int(path.role)); gcode += buf; } } if (path.is_bridge() && this->enable_cooling_markers) gcode += ";_BRIDGE_FAN_START\n"; gcode += this->writer.set_speed(F, "", this->enable_cooling_markers ? ";_EXTRUDE_SET_SPEED" : ""); double path_length = 0; { std::string comment = this->config.gcode_comments ? description : ""; Lines lines = path.polyline.lines(); for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { const double line_length = line->length() * SCALING_FACTOR; path_length += line_length; gcode += this->writer.extrude_to_xy( this->point_to_gcode(line->b), e_per_mm * line_length, comment ); } } if (this->wipe.enable) { this->wipe.path = path.polyline; this->wipe.path.reverse(); } if (path.is_bridge() && this->enable_cooling_markers) gcode += ";_BRIDGE_FAN_END\n"; this->set_last_pos(path.last_point()); if (this->config.cooling) this->elapsed_time += path_length / F * 60; return gcode; } // This method accepts &point in print coordinates. std::string GCode::travel_to(const Point &point, ExtrusionRole role, std::string comment) { /* Define the travel move as a line between current position and the taget point. This is expressed in print coordinates, so it will need to be translated by this->origin in order to get G-code coordinates. */ Polyline travel; travel.append(this->last_pos()); travel.append(point); // check whether a straight travel move would need retraction bool needs_retraction = this->needs_retraction(travel, role); // if a retraction would be needed, try to use avoid_crossing_perimeters to plan a // multi-hop travel path inside the configuration space if (needs_retraction && this->config.avoid_crossing_perimeters && !this->avoid_crossing_perimeters.disable_once) { travel = this->avoid_crossing_perimeters.travel_to(*this, point); // check again whether the new travel path still needs a retraction needs_retraction = this->needs_retraction(travel, role); //if (needs_retraction && this->layer_index > 1) exit(0); } // Re-allow avoid_crossing_perimeters for the next travel moves this->avoid_crossing_perimeters.disable_once = false; this->avoid_crossing_perimeters.use_external_mp_once = false; // generate G-code for the travel move std::string gcode; if (needs_retraction) gcode += this->retract(); // use G1 because we rely on paths being straight (G0 may make round paths) Lines lines = travel.lines(); double path_length = 0; for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { const double line_length = line->length() * SCALING_FACTOR; path_length += line_length; gcode += this->writer.travel_to_xy(this->point_to_gcode(line->b), comment); } if (this->config.cooling) this->elapsed_time += path_length / this->config.get_abs_value("travel_speed"); return gcode; } bool GCode::needs_retraction(const Polyline &travel, ExtrusionRole role) { if (travel.length() < scale_(EXTRUDER_CONFIG(retract_before_travel))) { // skip retraction if the move is shorter than the configured threshold return false; } if (role == erSupportMaterial) { const SupportLayer* support_layer = dynamic_cast(this->layer); if (support_layer != NULL && support_layer->support_islands.contains(travel)) { // skip retraction if this is a travel move inside a support material island return false; } } if (this->config.only_retract_when_crossing_perimeters && this->layer != NULL) { if (this->config.fill_density.value > 0 && this->layer->any_internal_region_slice_contains(travel)) { /* skip retraction if travel is contained in an internal slice *and* internal infill is enabled (so that stringing is entirely not visible) */ return false; } else if (this->layer->any_bottom_region_slice_contains(travel) && this->layer->upper_layer != NULL && this->layer->upper_layer->slices.contains(travel) && (this->config.bottom_solid_layers.value >= 2 || this->config.fill_density.value > 0)) { /* skip retraction if travel is contained in an *infilled* bottom slice but only if it's also covered by an *infilled* upper layer's slice so that it's not visible from above (a bottom surface might not have an upper slice in case of a thin membrane) */ return false; } } // retract if only_retract_when_crossing_perimeters is disabled or doesn't apply return true; } std::string GCode::retract(bool toolchange) { std::string gcode; if (this->writer.extruder() == NULL) return gcode; // wipe (if it's enabled for this extruder and we have a stored wipe path) if (EXTRUDER_CONFIG(wipe) && this->wipe.has_path()) { gcode += this->wipe.wipe(*this, toolchange); } /* The parent class will decide whether we need to perform an actual retraction (the extruder might be already retracted fully or partially). We call these methods even if we performed wipe, since this will ensure the entire retraction length is honored in case wipe path was too short. */ gcode += toolchange ? this->writer.retract_for_toolchange() : this->writer.retract(); gcode += this->writer.reset_e(); if (this->writer.extruder()->retract_length() > 0 || this->config.use_firmware_retraction) gcode += this->writer.lift(); return gcode; } std::string GCode::unretract() { std::string gcode; gcode += this->writer.unlift(); gcode += this->writer.unretract(); return gcode; } std::string GCode::set_extruder(unsigned int extruder_id) { this->placeholder_parser->set("current_extruder", extruder_id); if (!this->writer.need_toolchange(extruder_id)) return ""; // if we are running a single-extruder setup, just set the extruder and return nothing if (!this->writer.multiple_extruders) { return this->writer.toolchange(extruder_id); } // prepend retraction on the current extruder std::string gcode = this->retract(true); // append custom toolchange G-code if (this->writer.extruder() != NULL && !this->config.toolchange_gcode.value.empty()) { PlaceholderParser pp = *this->placeholder_parser; pp.set("previous_extruder", this->writer.extruder()->id); pp.set("next_extruder", extruder_id); gcode += pp.process(this->config.toolchange_gcode.value) + '\n'; } // if ooze prevention is enabled, park current extruder in the nearest // standby point and set it to the standby temperature if (this->ooze_prevention.enable && this->writer.extruder() != NULL) gcode += this->ooze_prevention.pre_toolchange(*this); // append the toolchange command gcode += this->writer.toolchange(extruder_id); // set the new extruder to the operating temperature if (this->ooze_prevention.enable) gcode += this->ooze_prevention.post_toolchange(*this); return gcode; } // convert a model-space scaled point into G-code coordinates Pointf GCode::point_to_gcode(const Point &point) { Pointf extruder_offset = EXTRUDER_CONFIG(extruder_offset); return Pointf( unscale(point.x) + this->origin.x - extruder_offset.x, unscale(point.y) + this->origin.y - extruder_offset.y ); } } Slic3r-version_1.31.6/xs/src/libslic3r/GCode.hpp000066400000000000000000000116031301441720000213000ustar00rootroot00000000000000#ifndef slic3r_GCode_hpp_ #define slic3r_GCode_hpp_ #include "libslic3r.h" #include "ExPolygon.hpp" #include "GCodeWriter.hpp" #include "Layer.hpp" #include "MotionPlanner.hpp" #include "Point.hpp" #include "PlaceholderParser.hpp" #include "Print.hpp" #include "PrintConfig.hpp" #include namespace Slic3r { // Forward declarations. class GCode; namespace EdgeGrid { class Grid; } class AvoidCrossingPerimeters { public: // this flag triggers the use of the external configuration space bool use_external_mp; bool use_external_mp_once; // just for the next travel move // this flag disables avoid_crossing_perimeters just for the next travel move // we enable it by default for the first travel move in print bool disable_once; AvoidCrossingPerimeters(); ~AvoidCrossingPerimeters(); void init_external_mp(const ExPolygons &islands); void init_layer_mp(const ExPolygons &islands); Polyline travel_to(GCode &gcodegen, Point point); private: MotionPlanner* _external_mp; MotionPlanner* _layer_mp; }; class OozePrevention { public: bool enable; Points standby_points; OozePrevention(); std::string pre_toolchange(GCode &gcodegen); std::string post_toolchange(GCode &gcodegen); private: int _get_temp(GCode &gcodegen); }; class Wipe { public: bool enable; Polyline path; Wipe(); bool has_path(); void reset_path(); std::string wipe(GCode &gcodegen, bool toolchange = false); }; class GCode { public: /* Origin of print coordinates expressed in unscaled G-code coordinates. This affects the input arguments supplied to the extrude*() and travel_to() methods. */ Pointf origin; FullPrintConfig config; GCodeWriter writer; PlaceholderParser* placeholder_parser; OozePrevention ooze_prevention; Wipe wipe; AvoidCrossingPerimeters avoid_crossing_perimeters; bool enable_loop_clipping; // If enabled, the G-code generator will put following comments at the ends // of the G-code lines: _EXTRUDE_SET_SPEED, _WIPE, _BRIDGE_FAN_START, _BRIDGE_FAN_END // Those comments are received and consumed (removed from the G-code) by the CoolingBuffer.pm Perl module. bool enable_cooling_markers; // Markers for the Pressure Equalizer to recognize the extrusion type. // The Pressure Equalizer removes the markers from the final G-code. bool enable_extrusion_role_markers; // Extended markers for the G-code Analyzer. // The G-code Analyzer will remove these comments from the final G-code. bool enable_analyzer_markers; // How many times will change_layer() be called? // change_layer() will update the progress bar. size_t layer_count; // Progress bar indicator. Increments from -1 up to layer_count. int layer_index; // Current layer processed. Insequential printing mode, only a single copy will be printed. // In non-sequential mode, all its copies will be printed. const Layer* layer; std::map _seam_position; // Distance Field structure to EdgeGrid::Grid *_lower_layer_edge_grid; bool first_layer; // this flag triggers first layer speeds // Used by the CoolingBuffer.pm Perl module to calculate time spent per layer change. // This value is not quite precise. First it only accouts for extrusion moves and travel moves, // it does not account for wipe, retract / unretract moves. // second it does not account for the velocity profiles of the printer. float elapsed_time; // seconds double volumetric_speed; // Support for the extrusion role markers. Which marker is active? ExtrusionRole _last_extrusion_role; GCode(); ~GCode(); const Point& last_pos() const; void set_last_pos(const Point &pos); bool last_pos_defined() const; void apply_print_config(const PrintConfig &print_config); void set_extruders(const std::vector &extruder_ids); void set_origin(const Pointf &pointf); std::string preamble(); std::string change_layer(const Layer &layer); std::string extrude(const ExtrusionEntity &entity, std::string description = "", double speed = -1); std::string extrude(ExtrusionLoop loop, std::string description = "", double speed = -1); std::string extrude(const ExtrusionPath &path, std::string description = "", double speed = -1); std::string travel_to(const Point &point, ExtrusionRole role, std::string comment); bool needs_retraction(const Polyline &travel, ExtrusionRole role = erNone); std::string retract(bool toolchange = false); std::string unretract(); std::string set_extruder(unsigned int extruder_id); Pointf point_to_gcode(const Point &point); private: Point _last_pos; bool _last_pos_defined; std::string _extrude(ExtrusionPath path, std::string description = "", double speed = -1); }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/GCode/000077500000000000000000000000001301441720000205665ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/libslic3r/GCode/Analyzer.cpp000066400000000000000000000245341301441720000230670ustar00rootroot00000000000000#include #include #include #include "../libslic3r.h" #include "../PrintConfig.hpp" #include "Analyzer.hpp" namespace Slic3r { void GCodeMovesDB::reset() { for (size_t i = 0; i < m_layers.size(); ++ i) delete m_layers[i]; m_layers.clear(); } GCodeAnalyzer::GCodeAnalyzer(const Slic3r::GCodeConfig *config) : m_config(config) { reset(); m_moves = new GCodeMovesDB(); } GCodeAnalyzer::~GCodeAnalyzer() { delete m_moves; } void GCodeAnalyzer::reset() { output_buffer.clear(); output_buffer_length = 0; m_current_extruder = 0; // Zero the position of the XYZE axes + the current feed memset(m_current_pos, 0, sizeof(float) * 5); m_current_extrusion_role = erNone; m_current_extrusion_width = 0; m_current_extrusion_height = 0; // Expect the first command to fill the nozzle (deretract). m_retracted = true; m_moves->reset(); } const char* GCodeAnalyzer::process(const char *szGCode, bool flush) { // Reset length of the output_buffer. output_buffer_length = 0; if (szGCode != 0) { const char *p = szGCode; while (*p != 0) { // Find end of the line. const char *endl = p; // Slic3r always generates end of lines in a Unix style. for (; *endl != 0 && *endl != '\n'; ++ endl) ; // Process a G-code line, store it into the provided GCodeLine object. bool should_output = process_line(p, endl - p); if (*endl == '\n') ++ endl; if (should_output) push_to_output(p, endl - p); p = endl; } } return output_buffer.data(); } // Is a white space? static inline bool is_ws(const char c) { return c == ' ' || c == '\t'; } // Is it an end of line? Consider a comment to be an end of line as well. static inline bool is_eol(const char c) { return c == 0 || c == '\r' || c == '\n' || c == ';'; }; // Is it a white space or end of line? static inline bool is_ws_or_eol(const char c) { return is_ws(c) || is_eol(c); }; // Eat whitespaces. static void eatws(const char *&line) { while (is_ws(*line)) ++ line; } // Parse an int starting at the current position of a line. // If succeeded, the line pointer is advanced. static inline int parse_int(const char *&line) { char *endptr = NULL; long result = strtol(line, &endptr, 10); if (endptr == NULL || !is_ws_or_eol(*endptr)) throw std::runtime_error("GCodePressureEqualizer: Error parsing an int"); line = endptr; return int(result); }; // Parse an int starting at the current position of a line. // If succeeded, the line pointer is advanced. static inline float parse_float(const char *&line) { char *endptr = NULL; float result = strtof(line, &endptr); if (endptr == NULL || !is_ws_or_eol(*endptr)) throw std::runtime_error("GCodePressureEqualizer: Error parsing a float"); line = endptr; return result; }; #define EXTRUSION_ROLE_TAG ";_EXTRUSION_ROLE:" bool GCodeAnalyzer::process_line(const char *line, const size_t len) { if (strncmp(line, EXTRUSION_ROLE_TAG, strlen(EXTRUSION_ROLE_TAG)) == 0) { line += strlen(EXTRUSION_ROLE_TAG); int role = atoi(line); this->m_current_extrusion_role = ExtrusionRole(role); return false; } /* // Set the type, copy the line to the buffer. buf.type = GCODE_MOVE_TYPE_OTHER; buf.modified = false; if (buf.raw.size() < len + 1) buf.raw.assign(line, line + len + 1); else memcpy(buf.raw.data(), line, len); buf.raw[len] = 0; buf.raw_length = len; memcpy(buf.pos_start, m_current_pos, sizeof(float)*5); memcpy(buf.pos_end, m_current_pos, sizeof(float)*5); memset(buf.pos_provided, 0, 5); buf.volumetric_extrusion_rate = 0.f; buf.volumetric_extrusion_rate_start = 0.f; buf.volumetric_extrusion_rate_end = 0.f; buf.max_volumetric_extrusion_rate_slope_positive = 0.f; buf.max_volumetric_extrusion_rate_slope_negative = 0.f; buf.extrusion_role = m_current_extrusion_role; // Parse the G-code line, store the result into the buf. switch (toupper(*line ++)) { case 'G': { int gcode = parse_int(line); eatws(line); switch (gcode) { case 0: case 1: { // G0, G1: A FFF 3D printer does not make a difference between the two. float new_pos[5]; memcpy(new_pos, m_current_pos, sizeof(float)*5); bool changed[5] = { false, false, false, false, false }; while (!is_eol(*line)) { char axis = toupper(*line++); int i = -1; switch (axis) { case 'X': case 'Y': case 'Z': i = axis - 'X'; break; case 'E': i = 3; break; case 'F': i = 4; break; default: assert(false); } if (i == -1) throw std::runtime_error(std::string("GCodePressureEqualizer: Invalid axis for G0/G1: ") + axis); buf.pos_provided[i] = true; new_pos[i] = parse_float(line); if (i == 3 && m_config->use_relative_e_distances.value) new_pos[i] += m_current_pos[i]; changed[i] = new_pos[i] != m_current_pos[i]; eatws(line); } if (changed[3]) { // Extrusion, retract or unretract. float diff = new_pos[3] - m_current_pos[3]; if (diff < 0) { buf.type = GCODE_MOVE_TYPE_RETRACT; m_retracted = true; } else if (! changed[0] && ! changed[1] && ! changed[2]) { // assert(m_retracted); buf.type = GCODE_MOVE_TYPE_UNRETRACT; m_retracted = false; } else { assert(changed[0] || changed[1]); // Moving in XY plane. buf.type = GCODE_MOVE_TYPE_EXTRUDE; // Calculate the volumetric extrusion rate. float diff[4]; for (size_t i = 0; i < 4; ++ i) diff[i] = new_pos[i] - m_current_pos[i]; // volumetric extrusion rate = A_filament * F_xyz * L_e / L_xyz [mm^3/min] float len2 = diff[0]*diff[0]+diff[1]*diff[1]+diff[2]*diff[2]; float rate = m_filament_crossections[m_current_extruder] * new_pos[4] * sqrt((diff[3]*diff[3])/len2); buf.volumetric_extrusion_rate = rate; buf.volumetric_extrusion_rate_start = rate; buf.volumetric_extrusion_rate_end = rate; m_stat.update(rate, sqrt(len2)); if (rate < 10.f) { printf("Extremely low flow rate: %f\n", rate); } } } else if (changed[0] || changed[1] || changed[2]) { // Moving without extrusion. buf.type = GCODE_MOVE_TYPE_MOVE; } memcpy(m_current_pos, new_pos, sizeof(float) * 5); break; } case 92: { // G92 : Set Position // Set a logical coordinate position to a new value without actually moving the machine motors. // Which axes to set? bool set = false; while (!is_eol(*line)) { char axis = toupper(*line++); switch (axis) { case 'X': case 'Y': case 'Z': m_current_pos[axis - 'X'] = (!is_ws_or_eol(*line)) ? parse_float(line) : 0.f; set = true; break; case 'E': m_current_pos[3] = (!is_ws_or_eol(*line)) ? parse_float(line) : 0.f; set = true; break; default: throw std::runtime_error(std::string("GCodePressureEqualizer: Incorrect axis in a G92 G-code: ") + axis); } eatws(line); } assert(set); break; } case 10: case 22: // Firmware retract. buf.type = GCODE_MOVE_TYPE_RETRACT; m_retracted = true; break; case 11: case 23: // Firmware unretract. buf.type = GCODE_MOVE_TYPE_UNRETRACT; m_retracted = false; break; default: // Ignore the rest. break; } break; } case 'M': { int mcode = parse_int(line); eatws(line); switch (mcode) { default: // Ignore the rest of the M-codes. break; } break; } case 'T': { // Activate an extruder head. int new_extruder = parse_int(line); if (new_extruder != m_current_extruder) { m_current_extruder = new_extruder; m_retracted = true; buf.type = GCODE_MOVE_TYPE_TOOL_CHANGE; } else { buf.type = GCODE_MOVE_TYPE_NOOP; } break; } } buf.extruder_id = m_current_extruder; memcpy(buf.pos_end, m_current_pos, sizeof(float)*5); */ return true; } void GCodeAnalyzer::push_to_output(const char *text, const size_t len, bool add_eol) { // New length of the output buffer content. size_t len_new = output_buffer_length + len + 1; if (add_eol) ++ len_new; // Resize the output buffer to a power of 2 higher than the required memory. if (output_buffer.size() < len_new) { size_t v = len_new; // Compute the next highest power of 2 of 32-bit v // http://graphics.stanford.edu/~seander/bithacks.html v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; output_buffer.resize(v); } // Copy the text to the output. if (len != 0) { memcpy(output_buffer.data() + output_buffer_length, text, len); output_buffer_length += len; } if (add_eol) output_buffer[output_buffer_length ++] = '\n'; output_buffer[output_buffer_length] = 0; } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/GCode/Analyzer.hpp000066400000000000000000000153551301441720000230750ustar00rootroot00000000000000#ifndef slic3r_GCode_PressureEqualizer_hpp_ #define slic3r_GCode_PressureEqualizer_hpp_ #include "../libslic3r.h" #include "../PrintConfig.hpp" #include "../ExtrusionEntity.hpp" namespace Slic3r { enum GCodeMoveType { GCODE_MOVE_TYPE_NOOP, GCODE_MOVE_TYPE_RETRACT, GCODE_MOVE_TYPE_UNRETRACT, GCODE_MOVE_TYPE_TOOL_CHANGE, GCODE_MOVE_TYPE_MOVE, GCODE_MOVE_TYPE_EXTRUDE, }; // For visualization purposes, for the purposes of the G-code analysis and timing. // The size of this structure is 56B. // Keep the size of this structure as small as possible, because all moves of a complete print // may be held in RAM. struct GCodeMove { bool moving_xy(const float* pos_start) const { return fabs(pos_end[0] - pos_start[0]) > 0.f || fabs(pos_end[1] - pos_start[1]) > 0.f; } bool moving_xy() const { return moving_xy(get_pos_start()); } bool moving_z (const float* pos_start) const { return fabs(pos_end[2] - pos_start[2]) > 0.f; } bool moving_z () const { return moving_z(get_pos_start()); } bool extruding(const float* pos_start) const { return moving_xy() && pos_end[3] > pos_start[3]; } bool extruding() const { return extruding(get_pos_start()); } bool retracting(const float* pos_start) const { return pos_end[3] < pos_start[3]; } bool retracting() const { return retracting(get_pos_start()); } bool deretracting(const float* pos_start) const { return ! moving_xy() && pos_end[3] > pos_start[3]; } bool deretracting() const { return deretracting(get_pos_start()); } float dist_xy2(const float* pos_start) const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]); } float dist_xy2() const { return dist_xy2(get_pos_start()); } float dist_xyz2(const float* pos_start) const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]) + (pos_end[2] - pos_start[2]) * (pos_end[2] - pos_start[2]); } float dist_xyz2() const { return dist_xyz2(get_pos_start()); } float dist_xy(const float* pos_start) const { return sqrt(dist_xy2(pos_start)); } float dist_xy() const { return dist_xy(get_pos_start()); } float dist_xyz(const float* pos_start) const { return sqrt(dist_xyz2(pos_start)); } float dist_xyz() const { return dist_xyz(get_pos_start()); } float dist_e(const float* pos_start) const { return fabs(pos_end[3] - pos_start[3]); } float dist_e() const { return dist_e(get_pos_start()); } float feedrate() const { return pos_end[4]; } float time(const float* pos_start) const { return dist_xyz(pos_start) / feedrate(); } float time() const { return time(get_pos_start()); } float time_inv(const float* pos_start) const { return feedrate() / dist_xyz(pos_start); } float time_inv() const { return time_inv(get_pos_start()); } const float* get_pos_start() const { assert(type != GCODE_MOVE_TYPE_NOOP); return this[-1].pos_end; } // Pack the enums to conserve space. With C++x11 the allocation size could be declared for enums, but for old C++ this is the only portable way. // GCodeLineType uint8_t type; // Index of the active extruder. uint8_t extruder_id; // ExtrusionRole uint8_t extrusion_role; // For example, is it a bridge flow? Is the fan on? uint8_t flags; // X,Y,Z,E,F. Storing the state of the currently active extruder only. float pos_end[5]; // Extrusion width, height for this segment in um. uint16_t extrusion_width; uint16_t extrusion_height; }; typedef std::vector GCodeMoves; struct GCodeLayer { // Index of an object printed. size_t object_idx; // Index of an object instance printed. size_t object_instance_idx; // Index of the layer printed. size_t layer_idx; // Top z coordinate of the layer printed. float layer_z_top; // Moves over this layer. The 0th move is always of type GCODELINETYPE_NOOP and // it sets the initial position and tool for the layer. GCodeMoves moves; // Indices into m_moves, where the tool changes happen. // This is useful, if one wants to display just only a piece of the path quickly. std::vector tool_changes; }; typedef std::vector GCodeLayerPtrs; class GCodeMovesDB { public: GCodeMovesDB() {}; ~GCodeMovesDB() { reset(); } void reset(); GCodeLayerPtrs m_layers; }; // Processes a G-code to extract moves and their types. // This information is then used to render the print simulation colored by the extrusion type // or various speeds. // The GCodeAnalyzer is employed as a G-Code filter. It reads the G-code as it is generated, // parses the comments generated by Slic3r just for the analyzer, and removes these comments. class GCodeAnalyzer { public: GCodeAnalyzer(const Slic3r::GCodeConfig *config); ~GCodeAnalyzer(); void reset(); // Process a next batch of G-code lines. Flush the internal buffers if asked for. const char* process(const char *szGCode, bool flush); // Length of the buffer returned by process(). size_t get_output_buffer_length() const { return output_buffer_length; } private: // Keeps the reference, does not own the config. const Slic3r::GCodeConfig *m_config; // Internal data. // X,Y,Z,E,F float m_current_pos[5]; size_t m_current_extruder; ExtrusionRole m_current_extrusion_role; uint16_t m_current_extrusion_width; uint16_t m_current_extrusion_height; bool m_retracted; GCodeMovesDB *m_moves; // Output buffer will only grow. It will not be reallocated over and over. std::vector output_buffer; size_t output_buffer_length; bool process_line(const char *line, const size_t len); // Push the text to the end of the output_buffer. void push_to_output(const char *text, const size_t len, bool add_eol = true); }; } // namespace Slic3r #endif /* slic3r_GCode_PressureEqualizer_hpp_ */ Slic3r-version_1.31.6/xs/src/libslic3r/GCode/PressureEqualizer.cpp000066400000000000000000000621251301441720000247720ustar00rootroot00000000000000#include #include #include #include "../libslic3r.h" #include "../PrintConfig.hpp" #include "PressureEqualizer.hpp" namespace Slic3r { GCodePressureEqualizer::GCodePressureEqualizer(const Slic3r::GCodeConfig *config) : m_config(config) { reset(); } GCodePressureEqualizer::~GCodePressureEqualizer() { } void GCodePressureEqualizer::reset() { circular_buffer_pos = 0; circular_buffer_size = 100; circular_buffer_items = 0; circular_buffer.assign(circular_buffer_size, GCodeLine()); output_buffer.clear(); output_buffer_length = 0; m_current_extruder = 0; // Zero the position of the XYZE axes + the current feed memset(m_current_pos, 0, sizeof(float) * 5); m_current_extrusion_role = erNone; // Expect the first command to fill the nozzle (deretract). m_retracted = true; // Calculate filamet crossections for the multiple extruders. m_filament_crossections.clear(); for (size_t i = 0; i < m_config->filament_diameter.values.size(); ++ i) { double r = m_config->filament_diameter.values[i]; double a = 0.25f*M_PI*r*r; m_filament_crossections.push_back(float(a)); } m_max_segment_length = 20.f; // Volumetric rate of a 0.45mm x 0.2mm extrusion at 60mm/s XY movement: 0.45*0.2*60*60=5.4*60 = 324 mm^3/min // Volumetric rate of a 0.45mm x 0.2mm extrusion at 20mm/s XY movement: 0.45*0.2*20*60=1.8*60 = 108 mm^3/min // Slope of the volumetric rate, changing from 20mm/s to 60mm/s over 2 seconds: (5.4-1.8)*60*60/2=60*60*1.8 = 6480 mm^3/min^2 = 1.8 mm^3/s^2 m_max_volumetric_extrusion_rate_slope_positive = (this->m_config == NULL) ? 6480.f : this->m_config->max_volumetric_extrusion_rate_slope_positive.value * 60.f * 60.f; m_max_volumetric_extrusion_rate_slope_negative = (this->m_config == NULL) ? 6480.f : this->m_config->max_volumetric_extrusion_rate_slope_negative.value * 60.f * 60.f; for (size_t i = 0; i < numExtrusionRoles; ++ i) { m_max_volumetric_extrusion_rate_slopes[i].negative = m_max_volumetric_extrusion_rate_slope_negative; m_max_volumetric_extrusion_rate_slopes[i].positive = m_max_volumetric_extrusion_rate_slope_positive; } // Don't regulate the pressure in infill. m_max_volumetric_extrusion_rate_slopes[erBridgeInfill].negative = 0; m_max_volumetric_extrusion_rate_slopes[erBridgeInfill].positive = 0; // Don't regulate the pressure in gap fill. m_max_volumetric_extrusion_rate_slopes[erGapFill].negative = 0; m_max_volumetric_extrusion_rate_slopes[erGapFill].positive = 0; m_stat.reset(); line_idx = 0; } const char* GCodePressureEqualizer::process(const char *szGCode, bool flush) { // Reset length of the output_buffer. output_buffer_length = 0; if (szGCode != 0) { const char *p = szGCode; while (*p != 0) { // Find end of the line. const char *endl = p; // Slic3r always generates end of lines in a Unix style. for (; *endl != 0 && *endl != '\n'; ++ endl) ; if (circular_buffer_items == circular_buffer_size) // Buffer is full. Push out the oldest line. output_gcode_line(circular_buffer[circular_buffer_pos]); else ++ circular_buffer_items; // Process a G-code line, store it into the provided GCodeLine object. size_t idx_tail = circular_buffer_pos; circular_buffer_pos = circular_buffer_idx_next(circular_buffer_pos); if (! process_line(p, endl - p, circular_buffer[idx_tail])) { // The line has to be forgotten. It contains comment marks, which shall be // filtered out of the target g-code. circular_buffer_pos = idx_tail; -- circular_buffer_items; } p = endl; if (*p == '\n') ++ p; } } if (flush) { // Flush the remaining valid lines of the circular buffer. for (size_t idx = circular_buffer_idx_head(); circular_buffer_items > 0; -- circular_buffer_items) { output_gcode_line(circular_buffer[idx]); if (++ idx == circular_buffer_size) idx = 0; } // Reset the index pointer. assert(circular_buffer_items == 0); circular_buffer_pos = 0; #if 1 printf("Statistics: \n"); printf("Minimum volumetric extrusion rate: %f\n", m_stat.volumetric_extrusion_rate_min); printf("Maximum volumetric extrusion rate: %f\n", m_stat.volumetric_extrusion_rate_max); if (m_stat.extrusion_length > 0) m_stat.volumetric_extrusion_rate_avg /= m_stat.extrusion_length; printf("Average volumetric extrusion rate: %f\n", m_stat.volumetric_extrusion_rate_avg); m_stat.reset(); #endif } return output_buffer.data(); } // Is a white space? static inline bool is_ws(const char c) { return c == ' ' || c == '\t'; } // Is it an end of line? Consider a comment to be an end of line as well. static inline bool is_eol(const char c) { return c == 0 || c == '\r' || c == '\n' || c == ';'; }; // Is it a white space or end of line? static inline bool is_ws_or_eol(const char c) { return is_ws(c) || is_eol(c); }; // Eat whitespaces. static void eatws(const char *&line) { while (is_ws(*line)) ++ line; } // Parse an int starting at the current position of a line. // If succeeded, the line pointer is advanced. static inline int parse_int(const char *&line) { char *endptr = NULL; long result = strtol(line, &endptr, 10); if (endptr == NULL || !is_ws_or_eol(*endptr)) throw std::runtime_error("GCodePressureEqualizer: Error parsing an int"); line = endptr; return int(result); }; // Parse an int starting at the current position of a line. // If succeeded, the line pointer is advanced. static inline float parse_float(const char *&line) { char *endptr = NULL; float result = strtof(line, &endptr); if (endptr == NULL || !is_ws_or_eol(*endptr)) throw std::runtime_error("GCodePressureEqualizer: Error parsing a float"); line = endptr; return result; }; #define EXTRUSION_ROLE_TAG ";_EXTRUSION_ROLE:" bool GCodePressureEqualizer::process_line(const char *line, const size_t len, GCodeLine &buf) { if (strncmp(line, EXTRUSION_ROLE_TAG, strlen(EXTRUSION_ROLE_TAG)) == 0) { line += strlen(EXTRUSION_ROLE_TAG); int role = atoi(line); this->m_current_extrusion_role = ExtrusionRole(role); ++ line_idx; return false; } // Set the type, copy the line to the buffer. buf.type = GCODELINETYPE_OTHER; buf.modified = false; if (buf.raw.size() < len + 1) buf.raw.assign(line, line + len + 1); else memcpy(buf.raw.data(), line, len); buf.raw[len] = 0; buf.raw_length = len; memcpy(buf.pos_start, m_current_pos, sizeof(float)*5); memcpy(buf.pos_end, m_current_pos, sizeof(float)*5); memset(buf.pos_provided, 0, 5); buf.volumetric_extrusion_rate = 0.f; buf.volumetric_extrusion_rate_start = 0.f; buf.volumetric_extrusion_rate_end = 0.f; buf.max_volumetric_extrusion_rate_slope_positive = 0.f; buf.max_volumetric_extrusion_rate_slope_negative = 0.f; buf.extrusion_role = m_current_extrusion_role; // Parse the G-code line, store the result into the buf. switch (toupper(*line ++)) { case 'G': { int gcode = parse_int(line); eatws(line); switch (gcode) { case 0: case 1: { // G0, G1: A FFF 3D printer does not make a difference between the two. float new_pos[5]; memcpy(new_pos, m_current_pos, sizeof(float)*5); bool changed[5] = { false, false, false, false, false }; while (!is_eol(*line)) { char axis = toupper(*line++); int i = -1; switch (axis) { case 'X': case 'Y': case 'Z': i = axis - 'X'; break; case 'E': i = 3; break; case 'F': i = 4; break; default: assert(false); } if (i == -1) throw std::runtime_error(std::string("GCodePressureEqualizer: Invalid axis for G0/G1: ") + axis); buf.pos_provided[i] = true; new_pos[i] = parse_float(line); if (i == 3 && m_config->use_relative_e_distances.value) new_pos[i] += m_current_pos[i]; changed[i] = new_pos[i] != m_current_pos[i]; eatws(line); } if (changed[3]) { // Extrusion, retract or unretract. float diff = new_pos[3] - m_current_pos[3]; if (diff < 0) { buf.type = GCODELINETYPE_RETRACT; m_retracted = true; } else if (! changed[0] && ! changed[1] && ! changed[2]) { // assert(m_retracted); buf.type = GCODELINETYPE_UNRETRACT; m_retracted = false; } else { assert(changed[0] || changed[1]); // Moving in XY plane. buf.type = GCODELINETYPE_EXTRUDE; // Calculate the volumetric extrusion rate. float diff[4]; for (size_t i = 0; i < 4; ++ i) diff[i] = new_pos[i] - m_current_pos[i]; // volumetric extrusion rate = A_filament * F_xyz * L_e / L_xyz [mm^3/min] float len2 = diff[0]*diff[0]+diff[1]*diff[1]+diff[2]*diff[2]; float rate = m_filament_crossections[m_current_extruder] * new_pos[4] * sqrt((diff[3]*diff[3])/len2); buf.volumetric_extrusion_rate = rate; buf.volumetric_extrusion_rate_start = rate; buf.volumetric_extrusion_rate_end = rate; m_stat.update(rate, sqrt(len2)); if (rate < 40.f) { printf("Extremely low flow rate: %f. Line %d, Length: %f, extrusion: %f Old position: (%f, %f, %f), new position: (%f, %f, %f)\n", rate, int(line_idx), sqrt(len2), sqrt((diff[3]*diff[3])/len2), m_current_pos[0], m_current_pos[1], m_current_pos[2], new_pos[0], new_pos[1], new_pos[2]); } } } else if (changed[0] || changed[1] || changed[2]) { // Moving without extrusion. buf.type = GCODELINETYPE_MOVE; } memcpy(m_current_pos, new_pos, sizeof(float) * 5); break; } case 92: { // G92 : Set Position // Set a logical coordinate position to a new value without actually moving the machine motors. // Which axes to set? bool set = false; while (!is_eol(*line)) { char axis = toupper(*line++); switch (axis) { case 'X': case 'Y': case 'Z': m_current_pos[axis - 'X'] = (!is_ws_or_eol(*line)) ? parse_float(line) : 0.f; set = true; break; case 'E': m_current_pos[3] = (!is_ws_or_eol(*line)) ? parse_float(line) : 0.f; set = true; break; default: throw std::runtime_error(std::string("GCodePressureEqualizer: Incorrect axis in a G92 G-code: ") + axis); } eatws(line); } assert(set); break; } case 10: case 22: // Firmware retract. buf.type = GCODELINETYPE_RETRACT; m_retracted = true; break; case 11: case 23: // Firmware unretract. buf.type = GCODELINETYPE_UNRETRACT; m_retracted = false; break; default: // Ignore the rest. break; } break; } case 'M': { int mcode = parse_int(line); eatws(line); switch (mcode) { default: // Ignore the rest of the M-codes. break; } break; } case 'T': { // Activate an extruder head. int new_extruder = parse_int(line); if (new_extruder != m_current_extruder) { m_current_extruder = new_extruder; m_retracted = true; buf.type = GCODELINETYPE_TOOL_CHANGE; } else { buf.type = GCODELINETYPE_NOOP; } break; } } buf.extruder_id = m_current_extruder; memcpy(buf.pos_end, m_current_pos, sizeof(float)*5); adjust_volumetric_rate(); ++ line_idx; return true; } void GCodePressureEqualizer::output_gcode_line(GCodeLine &line) { if (! line.modified) { push_to_output(line.raw.data(), line.raw_length, true); return; } // The line was modified. // Find the comment. const char *comment = line.raw.data(); while (*comment != ';' && *comment != 0) ++comment; if (*comment != ';') comment = NULL; // Emit the line with lowered extrusion rates. float l2 = line.dist_xyz2(); float l = sqrt(l2); size_t nSegments = size_t(ceil(l / m_max_segment_length)); if (nSegments == 1) { // Just update this segment. push_line_to_output(line, line.feedrate() * line.volumetric_correction_avg(), comment); } else { bool accelerating = line.volumetric_extrusion_rate_start < line.volumetric_extrusion_rate_end; // Update the initial and final feed rate values. line.pos_start[4] = line.volumetric_extrusion_rate_start * line.pos_end[4] / line.volumetric_extrusion_rate; line.pos_end [4] = line.volumetric_extrusion_rate_end * line.pos_end[4] / line.volumetric_extrusion_rate; float feed_avg = 0.5f * (line.pos_start[4] + line.pos_end[4]); // Limiting volumetric extrusion rate slope for this segment. float max_volumetric_extrusion_rate_slope = accelerating ? line.max_volumetric_extrusion_rate_slope_positive : line.max_volumetric_extrusion_rate_slope_negative; // Total time for the segment, corrected for the possibly lowered volumetric feed rate, // if accelerating / decelerating over the complete segment. float t_total = line.dist_xyz() / feed_avg; // Time of the acceleration / deceleration part of the segment, if accelerating / decelerating // with the maximum volumetric extrusion rate slope. float t_acc = 0.5f * (line.volumetric_extrusion_rate_start + line.volumetric_extrusion_rate_end) / max_volumetric_extrusion_rate_slope; float l_acc = l; float l_steady = 0.f; if (t_acc < t_total) { // One may achieve higher print speeds if part of the segment is not speed limited. float l_acc = t_acc * feed_avg; float l_steady = l - l_acc; if (l_steady < 0.5f * m_max_segment_length) { l_acc = l; l_steady = 0.f; } else nSegments = size_t(ceil(l_acc / m_max_segment_length)); } float pos_start[5]; float pos_end [5]; float pos_end2 [4]; memcpy(pos_start, line.pos_start, sizeof(float)*5); memcpy(pos_end , line.pos_end , sizeof(float)*5); if (l_steady > 0.f) { // There will be a steady feed segment emitted. if (accelerating) { // Prepare the final steady feed rate segment. memcpy(pos_end2, pos_end, sizeof(float)*4); float t = l_acc / l; for (int i = 0; i < 4; ++ i) { pos_end[i] = pos_start[i] + (pos_end[i] - pos_start[i]) * t; line.pos_provided[i] = true; } } else { // Emit the steady feed rate segment. float t = l_steady / l; for (int i = 0; i < 4; ++ i) { line.pos_end[i] = pos_start[i] + (pos_end[i] - pos_start[i]) * t; line.pos_provided[i] = true; } push_line_to_output(line, pos_start[4], comment); comment = NULL; memcpy(line.pos_start, line.pos_end, sizeof(float)*5); memcpy(pos_start, line.pos_end, sizeof(float)*5); } } // Split the segment into pieces. for (size_t i = 1; i < nSegments; ++ i) { float t = float(i) / float(nSegments); for (size_t j = 0; j < 4; ++ j) { line.pos_end[j] = pos_start[j] + (pos_end[j] - pos_start[j]) * t; line.pos_provided[j] = true; } // Interpolate the feed rate at the center of the segment. push_line_to_output(line, pos_start[4] + (pos_end[4] - pos_start[4]) * (float(i) - 0.5f) / float(nSegments), comment); comment = NULL; memcpy(line.pos_start, line.pos_end, sizeof(float)*5); } if (l_steady > 0.f && accelerating) { for (int i = 0; i < 4; ++ i) { line.pos_end[i] = pos_end2[i]; line.pos_provided[i] = true; } push_line_to_output(line, pos_end[4], comment); } } } void GCodePressureEqualizer::adjust_volumetric_rate() { if (circular_buffer_items < 2) return; // Go back from the current circular_buffer_pos and lower the feedtrate to decrease the slope of the extrusion rate changes. const size_t idx_head = circular_buffer_idx_head(); const size_t idx_tail = circular_buffer_idx_prev(circular_buffer_idx_tail()); size_t idx = idx_tail; if (idx == idx_head || ! circular_buffer[idx].extruding()) // Nothing to do, the last move is not extruding. return; float feedrate_per_extrusion_role[numExtrusionRoles]; for (size_t i = 0; i < numExtrusionRoles; ++ i) feedrate_per_extrusion_role[i] = FLT_MAX; feedrate_per_extrusion_role[circular_buffer[idx].extrusion_role] = circular_buffer[idx].volumetric_extrusion_rate_start; bool modified = true; while (modified && idx != idx_head) { size_t idx_prev = circular_buffer_idx_prev(idx); for (; ! circular_buffer[idx_prev].extruding() && idx_prev != idx_head; idx_prev = circular_buffer_idx_prev(idx_prev)) ; if (! circular_buffer[idx_prev].extruding()) break; // Volumetric extrusion rate at the start of the succeding segment. float rate_succ = circular_buffer[idx].volumetric_extrusion_rate_start; // What is the gradient of the extrusion rate between idx_prev and idx? idx = idx_prev; GCodeLine &line = circular_buffer[idx]; for (size_t iRole = 1; iRole < numExtrusionRoles; ++ iRole) { float rate_slope = m_max_volumetric_extrusion_rate_slopes[iRole].negative; if (rate_slope == 0) // The negative rate is unlimited. continue; float rate_end = feedrate_per_extrusion_role[iRole]; if (iRole == line.extrusion_role && rate_succ < rate_end) // Limit by the succeeding volumetric flow rate. rate_end = rate_succ; if (line.volumetric_extrusion_rate_end > rate_end) { line.volumetric_extrusion_rate_end = rate_end; line.modified = true; } else if (iRole == line.extrusion_role) { rate_end = line.volumetric_extrusion_rate_end; } else if (rate_end == FLT_MAX) { // The rate for ExtrusionRole iRole is unlimited. continue; } else { // Use the original, 'floating' extrusion rate as a starting point for the limiter. } // modified = false; float rate_start = rate_end + rate_slope * line.time_corrected(); if (rate_start < line.volumetric_extrusion_rate_start) { // Limit the volumetric extrusion rate at the start of this segment due to a segment // of ExtrusionType iRole, which will be extruded in the future. line.volumetric_extrusion_rate_start = rate_start; line.max_volumetric_extrusion_rate_slope_negative = rate_slope; line.modified = true; // modified = true; } feedrate_per_extrusion_role[iRole] = (iRole == line.extrusion_role) ? line.volumetric_extrusion_rate_start : rate_start; } } // Go forward and adjust the feedrate to decrease the slope of the extrusion rate changes. for (size_t i = 0; i < numExtrusionRoles; ++ i) feedrate_per_extrusion_role[i] = FLT_MAX; feedrate_per_extrusion_role[circular_buffer[idx].extrusion_role] = circular_buffer[idx].volumetric_extrusion_rate_end; assert(circular_buffer[idx].extruding()); while (idx != idx_tail) { size_t idx_next = circular_buffer_idx_next(idx); for (; ! circular_buffer[idx_next].extruding() && idx_next != idx_tail; idx_next = circular_buffer_idx_next(idx_next)) ; if (! circular_buffer[idx_next].extruding()) break; float rate_prec = circular_buffer[idx].volumetric_extrusion_rate_end; // What is the gradient of the extrusion rate between idx_prev and idx? idx = idx_next; GCodeLine &line = circular_buffer[idx]; for (size_t iRole = 1; iRole < numExtrusionRoles; ++ iRole) { float rate_slope = m_max_volumetric_extrusion_rate_slopes[iRole].positive; if (rate_slope == 0) // The positive rate is unlimited. continue; float rate_start = feedrate_per_extrusion_role[iRole]; if (iRole == line.extrusion_role && rate_prec < rate_start) rate_start = rate_prec; if (line.volumetric_extrusion_rate_start > rate_start) { line.volumetric_extrusion_rate_start = rate_start; line.modified = true; } else if (iRole == line.extrusion_role) { rate_start = line.volumetric_extrusion_rate_start; } else if (rate_start == FLT_MAX) { // The rate for ExtrusionRole iRole is unlimited. continue; } else { // Use the original, 'floating' extrusion rate as a starting point for the limiter. } float rate_end = (rate_slope == 0) ? FLT_MAX : rate_start + rate_slope * line.time_corrected(); if (rate_end < line.volumetric_extrusion_rate_end) { // Limit the volumetric extrusion rate at the start of this segment due to a segment // of ExtrusionType iRole, which was extruded before. line.volumetric_extrusion_rate_end = rate_end; line.max_volumetric_extrusion_rate_slope_positive = rate_slope; line.modified = true; } feedrate_per_extrusion_role[iRole] = (iRole == line.extrusion_role) ? line.volumetric_extrusion_rate_end : rate_end; } } } void GCodePressureEqualizer::push_axis_to_output(const char axis, const float value, bool add_eol) { char buf[2048]; int len = sprintf(buf, (axis == 'E') ? " %c%.3f" : " %c%.5f", axis, value); push_to_output(buf, len, add_eol); } void GCodePressureEqualizer::push_to_output(const char *text, const size_t len, bool add_eol) { // New length of the output buffer content. size_t len_new = output_buffer_length + len + 1; if (add_eol) ++ len_new; // Resize the output buffer to a power of 2 higher than the required memory. if (output_buffer.size() < len_new) { size_t v = len_new; // Compute the next highest power of 2 of 32-bit v // http://graphics.stanford.edu/~seander/bithacks.html v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; output_buffer.resize(v); } // Copy the text to the output. if (len != 0) { memcpy(output_buffer.data() + output_buffer_length, text, len); output_buffer_length += len; } if (add_eol) output_buffer[output_buffer_length ++] = '\n'; output_buffer[output_buffer_length] = 0; } void GCodePressureEqualizer::push_line_to_output(const GCodeLine &line, const float new_feedrate, const char *comment) { push_to_output("G1", 2, false); for (char i = 0; i < 3; ++ i) if (line.pos_provided[i]) push_axis_to_output('X'+i, line.pos_end[i]); push_axis_to_output('E', m_config->use_relative_e_distances.value ? (line.pos_end[3] - line.pos_start[3]) : line.pos_end[3]); // if (line.pos_provided[4] || fabs(line.feedrate() - new_feedrate) > 1e-5) push_axis_to_output('F', new_feedrate); // output comment and EOL push_to_output(comment, (comment == NULL) ? 0 : strlen(comment), true); } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/GCode/PressureEqualizer.hpp000066400000000000000000000221131301441720000247700ustar00rootroot00000000000000#ifndef slic3r_GCode_PressureEqualizer_hpp_ #define slic3r_GCode_PressureEqualizer_hpp_ #include "../libslic3r.h" #include "../PrintConfig.hpp" #include "../ExtrusionEntity.hpp" namespace Slic3r { // Processes a G-code. Finds changes in the volumetric extrusion speed and adjusts the transitions // between these paths to limit fast changes in the volumetric extrusion speed. class GCodePressureEqualizer { public: GCodePressureEqualizer(const Slic3r::GCodeConfig *config); ~GCodePressureEqualizer(); void reset(); // Process a next batch of G-code lines. Flush the internal buffers if asked for. const char* process(const char *szGCode, bool flush); size_t get_output_buffer_length() const { return output_buffer_length; } private: struct Statistics { void reset() { volumetric_extrusion_rate_min = std::numeric_limits::max(); volumetric_extrusion_rate_max = 0.f; volumetric_extrusion_rate_avg = 0.f; extrusion_length = 0.f; } void update(float volumetric_extrusion_rate, float length) { volumetric_extrusion_rate_min = std::min(volumetric_extrusion_rate_min, volumetric_extrusion_rate); volumetric_extrusion_rate_max = std::max(volumetric_extrusion_rate_max, volumetric_extrusion_rate); volumetric_extrusion_rate_avg += volumetric_extrusion_rate * length; extrusion_length += length; } float volumetric_extrusion_rate_min; float volumetric_extrusion_rate_max; float volumetric_extrusion_rate_avg; float extrusion_length; }; struct Statistics m_stat; // Keeps the reference, does not own the config. const Slic3r::GCodeConfig *m_config; // Private configuration values // How fast could the volumetric extrusion rate increase / decrase? mm^3/sec^2 struct ExtrusionRateSlope { float positive; float negative; }; enum { numExtrusionRoles = erSupportMaterialInterface + 1 }; ExtrusionRateSlope m_max_volumetric_extrusion_rate_slopes[numExtrusionRoles]; float m_max_volumetric_extrusion_rate_slope_positive; float m_max_volumetric_extrusion_rate_slope_negative; // Maximum segment length to split a long segment, if the initial and the final flow rate differ. float m_max_segment_length; // Configuration extracted from config. // Area of the crossestion of each filament. Necessary to calculate the volumetric flow rate. std::vector m_filament_crossections; // Internal data. // X,Y,Z,E,F float m_current_pos[5]; size_t m_current_extruder; ExtrusionRole m_current_extrusion_role; bool m_retracted; enum GCodeLineType { GCODELINETYPE_INVALID, GCODELINETYPE_NOOP, GCODELINETYPE_OTHER, GCODELINETYPE_RETRACT, GCODELINETYPE_UNRETRACT, GCODELINETYPE_TOOL_CHANGE, GCODELINETYPE_MOVE, GCODELINETYPE_EXTRUDE, }; struct GCodeLine { GCodeLine() : type(GCODELINETYPE_INVALID), raw_length(0), modified(false), extruder_id(0), volumetric_extrusion_rate(0.f), volumetric_extrusion_rate_start(0.f), volumetric_extrusion_rate_end(0.f) {} bool moving_xy() const { return fabs(pos_end[0] - pos_start[0]) > 0.f || fabs(pos_end[1] - pos_start[1]) > 0.f; } bool moving_z () const { return fabs(pos_end[2] - pos_start[2]) > 0.f; } bool extruding() const { return moving_xy() && pos_end[3] > pos_start[3]; } bool retracting() const { return pos_end[3] < pos_start[3]; } bool deretracting() const { return ! moving_xy() && pos_end[3] > pos_start[3]; } float dist_xy2() const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]); } float dist_xyz2() const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]) + (pos_end[2] - pos_start[2]) * (pos_end[2] - pos_start[2]); } float dist_xy() const { return sqrt(dist_xy2()); } float dist_xyz() const { return sqrt(dist_xyz2()); } float dist_e() const { return fabs(pos_end[3] - pos_start[3]); } float feedrate() const { return pos_end[4]; } float time() const { return dist_xyz() / feedrate(); } float time_inv() const { return feedrate() / dist_xyz(); } float volumetric_correction_avg() const { float avg_correction = 0.5f * (volumetric_extrusion_rate_start + volumetric_extrusion_rate_end) / volumetric_extrusion_rate; assert(avg_correction > 0.f); assert(avg_correction <= 1.00000001f); return avg_correction; } float time_corrected() const { return time() * volumetric_correction_avg(); } GCodeLineType type; // We try to keep the string buffer once it has been allocated, so it will not be reallocated over and over. std::vector raw; size_t raw_length; // If modified, the raw text has to be adapted by the new extrusion rate, // or maybe the line needs to be split into multiple lines. bool modified; // float timeStart; // float timeEnd; // X,Y,Z,E,F. Storing the state of the currently active extruder only. float pos_start[5]; float pos_end[5]; // Was the axis found on the G-code line? X,Y,Z,F bool pos_provided[5]; // Index of the active extruder. size_t extruder_id; // Extrusion role of this segment. ExtrusionRole extrusion_role; // Current volumetric extrusion rate. float volumetric_extrusion_rate; // Volumetric extrusion rate at the start of this segment. float volumetric_extrusion_rate_start; // Volumetric extrusion rate at the end of this segment. float volumetric_extrusion_rate_end; // Volumetric extrusion rate slope limiting this segment. // If set to zero, the slope is unlimited. float max_volumetric_extrusion_rate_slope_positive; float max_volumetric_extrusion_rate_slope_negative; }; // Circular buffer of GCode lines. The circular buffer size will be limited to circular_buffer_size. std::vector circular_buffer; // Current position of the circular buffer (index, where to write the next line to, the line has to be pushed out before it is overwritten). size_t circular_buffer_pos; // Circular buffer size, configuration value. size_t circular_buffer_size; // Number of valid lines in the circular buffer. Lower or equal to circular_buffer_size. size_t circular_buffer_items; // Output buffer will only grow. It will not be reallocated over and over. std::vector output_buffer; size_t output_buffer_length; // For debugging purposes. Index of the G-code line processed. size_t line_idx; bool process_line(const char *line, const size_t len, GCodeLine &buf); void output_gcode_line(GCodeLine &buf); // Go back from the current circular_buffer_pos and lower the feedtrate to decrease the slope of the extrusion rate changes. // Then go forward and adjust the feedrate to decrease the slope of the extrusion rate changes. void adjust_volumetric_rate(); // Push the text to the end of the output_buffer. void push_to_output(const char *text, const size_t len, bool add_eol = true); // Push an axis assignment to the end of the output buffer. void push_axis_to_output(const char axis, const float value, bool add_eol = false); // Push a G-code line to the output, void push_line_to_output(const GCodeLine &line, const float new_feedrate, const char *comment); size_t circular_buffer_idx_head() const { size_t idx = circular_buffer_pos + circular_buffer_size - circular_buffer_items; if (idx >= circular_buffer_size) idx -= circular_buffer_size; return idx; } size_t circular_buffer_idx_tail() const { return circular_buffer_pos; } size_t circular_buffer_idx_prev(size_t idx) const { idx += circular_buffer_size - 1; if (idx >= circular_buffer_size) idx -= circular_buffer_size; return idx; } size_t circular_buffer_idx_next(size_t idx) const { if (++ idx >= circular_buffer_size) idx -= circular_buffer_size; return idx; } }; } // namespace Slic3r #endif /* slic3r_GCode_PressureEqualizer_hpp_ */ Slic3r-version_1.31.6/xs/src/libslic3r/GCodeSender.cpp000066400000000000000000000366401301441720000224440ustar00rootroot00000000000000#ifdef BOOST_LIBS #include "GCodeSender.hpp" #include #include #include #include #include #include #include #if defined(__APPLE__) || defined(__linux) || defined(__OpenBSD__) #include #endif #if __APPLE__ #include #include #endif #ifdef __linux #include #include #endif //#define DEBUG_SERIAL #ifdef DEBUG_SERIAL #include std::fstream fs; #endif #define KEEP_SENT 20 namespace Slic3r { namespace asio = boost::asio; GCodeSender::GCodeSender() : io(), serial(io), can_send(false), sent(0), open(false), error(false), connected(false), queue_paused(false) {} GCodeSender::~GCodeSender() { this->disconnect(); } bool GCodeSender::connect(std::string devname, unsigned int baud_rate) { this->disconnect(); this->set_error_status(false); try { this->serial.open(devname); } catch (boost::system::system_error &e) { this->set_error_status(true); return false; } this->serial.set_option(asio::serial_port_base::parity(asio::serial_port_base::parity::odd)); this->serial.set_option(asio::serial_port_base::character_size(asio::serial_port_base::character_size(8))); this->serial.set_option(asio::serial_port_base::flow_control(asio::serial_port_base::flow_control::none)); this->serial.set_option(asio::serial_port_base::stop_bits(asio::serial_port_base::stop_bits::one)); this->set_baud_rate(baud_rate); this->serial.close(); this->serial.open(devname); this->serial.set_option(asio::serial_port_base::parity(asio::serial_port_base::parity::none)); // set baud rate again because set_option overwrote it this->set_baud_rate(baud_rate); this->open = true; this->reset(); // a reset firmware expect line numbers to start again from 1 this->sent = 0; this->last_sent.clear(); /* Initialize debugger */ #ifdef DEBUG_SERIAL fs.open("serial.txt", std::fstream::out | std::fstream::trunc); #endif // this gives some work to the io_service before it is started // (post() runs the supplied function in its thread) this->io.post(boost::bind(&GCodeSender::do_read, this)); // start reading in the background thread boost::thread t(boost::bind(&asio::io_service::run, &this->io)); this->background_thread.swap(t); return true; } void GCodeSender::set_baud_rate(unsigned int baud_rate) { try { // This does not support speeds > 115200 this->serial.set_option(asio::serial_port_base::baud_rate(baud_rate)); } catch (boost::system::system_error &e) { boost::asio::serial_port::native_handle_type handle = this->serial.native_handle(); #if __APPLE__ termios ios; ::tcgetattr(handle, &ios); ::cfsetspeed(&ios, baud_rate); speed_t newSpeed = baud_rate; ioctl(handle, IOSSIOSPEED, &newSpeed); ::tcsetattr(handle, TCSANOW, &ios); #elif __linux termios ios; ::tcgetattr(handle, &ios); ::cfsetispeed(&ios, B38400); ::cfsetospeed(&ios, B38400); ::tcflush(handle, TCIFLUSH); ::tcsetattr(handle, TCSANOW, &ios); struct serial_struct ss; ioctl(handle, TIOCGSERIAL, &ss); ss.flags = (ss.flags & ~ASYNC_SPD_MASK) | ASYNC_SPD_CUST; ss.custom_divisor = (ss.baud_base + (baud_rate / 2)) / baud_rate; //cout << "bbase " << ss.baud_base << " div " << ss.custom_divisor; long closestSpeed = ss.baud_base / ss.custom_divisor; //cout << " Closest speed " << closestSpeed << endl; ss.reserved_char[0] = 0; if (closestSpeed < baud_rate * 98 / 100 || closestSpeed > baud_rate * 102 / 100) { printf("Failed to set baud rate\n"); } ioctl(handle, TIOCSSERIAL, &ss); printf("< set_baud_rate: %u\n", baud_rate); #elif __OpenBSD__ struct termios ios; ::tcgetattr(handle, &ios); ::cfsetspeed(&ios, baud_rate); if (::tcsetattr(handle, TCSAFLUSH, &ios) != 0) printf("Failed to set baud rate: %s\n", strerror(errno)); #else //throw invalid_argument ("OS does not currently support custom bauds"); #endif } } void GCodeSender::disconnect() { if (!this->open) return; this->open = false; this->connected = false; this->io.post(boost::bind(&GCodeSender::do_close, this)); this->background_thread.join(); this->io.reset(); /* if (this->error_status()) { throw(boost::system::system_error(boost::system::error_code(), "Error while closing the device")); } */ #ifdef DEBUG_SERIAL fs.close(); #endif } bool GCodeSender::is_connected() const { return this->connected; } bool GCodeSender::wait_connected(unsigned int timeout) const { using namespace boost::posix_time; ptime t0 = second_clock::local_time() + seconds(timeout); while (!this->connected) { if (second_clock::local_time() > t0) return false; boost::this_thread::sleep(boost::posix_time::milliseconds(100)); } return true; } size_t GCodeSender::queue_size() const { boost::lock_guard l(this->queue_mutex); return this->queue.size(); } void GCodeSender::pause_queue() { boost::lock_guard l(this->queue_mutex); this->queue_paused = true; } void GCodeSender::resume_queue() { { boost::lock_guard l(this->queue_mutex); this->queue_paused = false; } this->send(); } void GCodeSender::purge_queue(bool priority) { boost::lock_guard l(this->queue_mutex); if (priority) { // clear priority queue std::list empty; std::swap(this->priqueue, empty); } else { // clear queue std::queue empty; std::swap(this->queue, empty); this->queue_paused = false; } } // purge log and return its contents std::vector GCodeSender::purge_log() { boost::lock_guard l(this->log_mutex); std::vector retval; retval.reserve(this->log.size()); while (!this->log.empty()) { retval.push_back(this->log.front()); this->log.pop(); } return retval; } std::string GCodeSender::getT() const { boost::lock_guard l(this->log_mutex); return this->T; } std::string GCodeSender::getB() const { boost::lock_guard l(this->log_mutex); return this->B; } void GCodeSender::do_close() { this->set_error_status(false); boost::system::error_code ec; this->serial.cancel(ec); if (ec) this->set_error_status(true); this->serial.close(ec); if (ec) this->set_error_status(true); } void GCodeSender::set_error_status(bool e) { boost::lock_guard l(this->error_mutex); this->error = e; } bool GCodeSender::error_status() const { boost::lock_guard l(this->error_mutex); return this->error; } void GCodeSender::do_read() { // read one line asio::async_read_until( this->serial, this->read_buffer, '\n', boost::bind( &GCodeSender::on_read, this, asio::placeholders::error, asio::placeholders::bytes_transferred ) ); } void GCodeSender::on_read(const boost::system::error_code& error, size_t bytes_transferred) { this->set_error_status(false); if (error) { if (error.value() == 45) { // OS X bug: http://osdir.com/ml/lib.boost.asio.user/2008-08/msg00004.html this->do_read(); } else { // printf("ERROR: [%d] %s\n", error.value(), error.message().c_str()); // error can be true even because the serial port was closed. // In this case it is not a real error, so ignore. if (this->open) { this->do_close(); this->set_error_status(true); } } return; } std::istream is(&this->read_buffer); std::string line; std::getline(is, line); if (!line.empty()) { #ifdef DEBUG_SERIAL fs << "<< " << line << std::endl << std::flush; #endif // note that line might contain \r at its end // parse incoming line if (!this->connected && (boost::starts_with(line, "start") || boost::starts_with(line, "Grbl ") || boost::starts_with(line, "ok") || boost::contains(line, "T:"))) { this->connected = true; { boost::lock_guard l(this->queue_mutex); this->can_send = true; } this->send(); } else if (boost::starts_with(line, "ok")) { { boost::lock_guard l(this->queue_mutex); this->can_send = true; } this->send(); } else if (boost::istarts_with(line, "resend") // Marlin uses "Resend: " || boost::istarts_with(line, "rs")) { // extract the first number from line boost::algorithm::trim_left_if(line, !boost::algorithm::is_digit()); size_t toresend = boost::lexical_cast(line.substr(0, line.find_first_not_of("0123456789"))); if (toresend >= this->sent - this->last_sent.size()) { { boost::lock_guard l(this->queue_mutex); // move the unsent lines to priqueue this->priqueue.insert( this->priqueue.begin(), // insert at the beginning this->last_sent.begin() + toresend - (this->sent - this->last_sent.size()) - 1, this->last_sent.end() ); // we can empty last_sent because it's not useful anymore this->last_sent.clear(); // start resending with the requested line number this->sent = toresend - 1; this->can_send = true; } this->send(); } else { printf("Cannot resend " PRINTF_ZU " (oldest we have is " PRINTF_ZU ")\n", toresend, this->sent - this->last_sent.size()); } } else if (boost::starts_with(line, "wait")) { // ignore } else { // push any other line into the log boost::lock_guard l(this->log_mutex); this->log.push(line); } // parse temperature info { size_t pos = line.find("T:"); if (pos != std::string::npos && line.size() > pos + 2) { // we got temperature info boost::lock_guard l(this->log_mutex); this->T = line.substr(pos+2, line.find_first_not_of("0123456789.", pos+2) - (pos+2)); pos = line.find("B:"); if (pos != std::string::npos && line.size() > pos + 2) { // we got bed temperature info this->B = line.substr(pos+2, line.find_first_not_of("0123456789.", pos+2) - (pos+2)); } } } } this->do_read(); } void GCodeSender::send(const std::vector &lines, bool priority) { // append lines to queue { boost::lock_guard l(this->queue_mutex); for (std::vector::const_iterator line = lines.begin(); line != lines.end(); ++line) { if (priority) { this->priqueue.push_back(*line); } else { this->queue.push(*line); } } } this->send(); } void GCodeSender::send(const std::string &line, bool priority) { // append line to queue { boost::lock_guard l(this->queue_mutex); if (priority) { this->priqueue.push_back(line); } else { this->queue.push(line); } } this->send(); } void GCodeSender::send() { this->io.post(boost::bind(&GCodeSender::do_send, this)); } void GCodeSender::do_send() { boost::lock_guard l(this->queue_mutex); // printer is not connected or we're still waiting for the previous ack if (!this->can_send) return; std::string line; while (!this->priqueue.empty() || (!this->queue.empty() && !this->queue_paused)) { if (!this->priqueue.empty()) { line = this->priqueue.front(); this->priqueue.pop_front(); } else { line = this->queue.front(); this->queue.pop(); } // strip comments size_t comment_pos = line.find_first_of(';'); if (comment_pos != std::string::npos) line.erase(comment_pos, std::string::npos); boost::algorithm::trim(line); // if line is not empty, send it if (!line.empty()) break; // if line is empty, process next item in queue } if (line.empty()) return; // compute full line this->sent++; std::string full_line = "N" + boost::lexical_cast(this->sent) + " " + line; // calculate checksum int cs = 0; for (std::string::const_iterator it = full_line.begin(); it != full_line.end(); ++it) cs = cs ^ *it; // write line to device full_line += "*"; full_line += boost::lexical_cast(cs); full_line += "\n"; #ifdef DEBUG_SERIAL fs << ">> " << full_line << std::flush; #endif this->last_sent.push_back(line); this->can_send = false; if (this->last_sent.size() > KEEP_SENT) this->last_sent.erase(this->last_sent.begin(), this->last_sent.end() - KEEP_SENT); // we can't supply asio::buffer(full_line) to async_write() because full_line is on the // stack and the buffer would lose its underlying storage causing memory corruption std::ostream os(&this->write_buffer); os << full_line; asio::async_write(this->serial, this->write_buffer, boost::bind(&GCodeSender::on_write, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } void GCodeSender::on_write(const boost::system::error_code& error, size_t bytes_transferred) { this->set_error_status(false); if (error) { if (this->open) { this->do_close(); this->set_error_status(true); } return; } this->do_send(); } void GCodeSender::set_DTR(bool on) { #if defined(_WIN32) && !defined(__SYMBIAN32__) asio::serial_port_service::native_handle_type handle = this->serial.native_handle(); if (on) EscapeCommFunction(handle, SETDTR); else EscapeCommFunction(handle, CLRDTR); #else int fd = this->serial.native_handle(); int status; ioctl(fd, TIOCMGET, &status); if (on) status |= TIOCM_DTR; else status &= ~TIOCM_DTR; ioctl(fd, TIOCMSET, &status); #endif } void GCodeSender::reset() { this->set_DTR(false); boost::this_thread::sleep(boost::posix_time::milliseconds(200)); this->set_DTR(true); boost::this_thread::sleep(boost::posix_time::milliseconds(200)); this->set_DTR(false); boost::this_thread::sleep(boost::posix_time::milliseconds(1000)); { boost::lock_guard l(this->queue_mutex); this->can_send = true; } } } #endif Slic3r-version_1.31.6/xs/src/libslic3r/GCodeSender.hpp000066400000000000000000000042141301441720000224410ustar00rootroot00000000000000#ifndef slic3r_GCodeSender_hpp_ #define slic3r_GCodeSender_hpp_ #ifdef BOOST_LIBS #include "libslic3r.h" #include #include #include #include #include #include namespace Slic3r { namespace asio = boost::asio; class GCodeSender : private boost::noncopyable { public: GCodeSender(); ~GCodeSender(); bool connect(std::string devname, unsigned int baud_rate); void send(const std::vector &lines, bool priority = false); void send(const std::string &s, bool priority = false); void disconnect(); bool error_status() const; bool is_connected() const; bool wait_connected(unsigned int timeout = 3) const; size_t queue_size() const; void pause_queue(); void resume_queue(); void purge_queue(bool priority = false); std::vector purge_log(); std::string getT() const; std::string getB() const; void set_DTR(bool on); void reset(); private: asio::io_service io; asio::serial_port serial; boost::thread background_thread; boost::asio::streambuf read_buffer, write_buffer; bool open; // whether the serial socket is connected bool connected; // whether the printer is online bool error; mutable boost::mutex error_mutex; // this mutex guards queue, priqueue, can_send, queue_paused, sent, last_sent mutable boost::mutex queue_mutex; std::queue queue; std::list priqueue; bool can_send; bool queue_paused; size_t sent; std::vector last_sent; // this mutex guards log, T, B mutable boost::mutex log_mutex; std::queue log; std::string T, B; void set_baud_rate(unsigned int baud_rate); void set_error_status(bool e); void do_send(); void on_write(const boost::system::error_code& error, size_t bytes_transferred); void do_close(); void do_read(); void on_read(const boost::system::error_code& error, size_t bytes_transferred); void send(); }; } // namespace Slic3r #endif /* BOOST_LIBS */ #endif /* slic3r_GCodeSender_hpp_ */ Slic3r-version_1.31.6/xs/src/libslic3r/GCodeWriter.cpp000066400000000000000000000362621301441720000225000ustar00rootroot00000000000000#include "GCodeWriter.hpp" #include #include #include #include #define FLAVOR_IS(val) this->config.gcode_flavor == val #define FLAVOR_IS_NOT(val) this->config.gcode_flavor != val #define COMMENT(comment) if (this->config.gcode_comments && !comment.empty()) gcode << " ; " << comment; #define PRECISION(val, precision) std::fixed << std::setprecision(precision) << val #define XYZF_NUM(val) PRECISION(val, 3) #define E_NUM(val) PRECISION(val, 5) namespace Slic3r { Extruder* GCodeWriter::extruder() { return this->_extruder; } std::string GCodeWriter::extrusion_axis() const { return this->_extrusion_axis; } void GCodeWriter::apply_print_config(const PrintConfig &print_config) { this->config.apply(print_config, true); this->_extrusion_axis = this->config.get_extrusion_axis(); } void GCodeWriter::set_extruders(const std::vector &extruder_ids) { for (std::vector::const_iterator i = extruder_ids.begin(); i != extruder_ids.end(); ++i) { this->extruders.insert( std::pair(*i, Extruder(*i, &this->config)) ); } /* we enable support for multiple extruder if any extruder greater than 0 is used (even if prints only uses that one) since we need to output Tx commands first extruder has index 0 */ this->multiple_extruders = (*std::max_element(extruder_ids.begin(), extruder_ids.end())) > 0; } std::string GCodeWriter::preamble() { std::ostringstream gcode; if (FLAVOR_IS_NOT(gcfMakerWare)) { gcode << "G21 ; set units to millimeters\n"; gcode << "G90 ; use absolute coordinates\n"; } if (FLAVOR_IS(gcfRepRap) || FLAVOR_IS(gcfTeacup)) { if (this->config.use_relative_e_distances) { gcode << "M83 ; use relative distances for extrusion\n"; } else { gcode << "M82 ; use absolute distances for extrusion\n"; } gcode << this->reset_e(true); } return gcode.str(); } std::string GCodeWriter::postamble() const { std::ostringstream gcode; if (FLAVOR_IS(gcfMachinekit)) gcode << "M2 ; end of program\n"; return gcode.str(); } std::string GCodeWriter::set_temperature(unsigned int temperature, bool wait, int tool) const { if (wait && (FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish))) return ""; std::string code, comment; if (wait && FLAVOR_IS_NOT(gcfTeacup)) { code = "M109"; comment = "set temperature and wait for it to be reached"; } else { code = "M104"; comment = "set temperature"; } std::ostringstream gcode; gcode << code << " "; if (FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMachinekit)) { gcode << "P"; } else { gcode << "S"; } gcode << temperature; if (tool != -1 && (this->multiple_extruders || FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish))) { gcode << " T" << tool; } gcode << " ; " << comment << "\n"; if (FLAVOR_IS(gcfTeacup) && wait) gcode << "M116 ; wait for temperature to be reached\n"; return gcode.str(); } std::string GCodeWriter::set_bed_temperature(unsigned int temperature, bool wait) const { std::string code, comment; if (wait && FLAVOR_IS_NOT(gcfTeacup)) { if (FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish)) { code = "M109"; } else { code = "M190"; } comment = "set bed temperature and wait for it to be reached"; } else { code = "M140"; comment = "set bed temperature"; } std::ostringstream gcode; gcode << code << " "; if (FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMachinekit)) { gcode << "P"; } else { gcode << "S"; } gcode << temperature << " ; " << comment << "\n"; if (FLAVOR_IS(gcfTeacup) && wait) gcode << "M116 ; wait for bed temperature to be reached\n"; return gcode.str(); } std::string GCodeWriter::set_fan(unsigned int speed, bool dont_save) { std::ostringstream gcode; if (this->_last_fan_speed != speed || dont_save) { if (!dont_save) this->_last_fan_speed = speed; if (speed == 0) { if (FLAVOR_IS(gcfTeacup)) { gcode << "M106 S0"; } else if (FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish)) { gcode << "M127"; } else { gcode << "M107"; } if (this->config.gcode_comments) gcode << " ; disable fan"; gcode << "\n"; } else { if (FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish)) { gcode << "M126"; } else { gcode << "M106 "; if (FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMachinekit)) { gcode << "P"; } else { gcode << "S"; } gcode << (255.0 * speed / 100.0); } if (this->config.gcode_comments) gcode << " ; enable fan"; gcode << "\n"; } } return gcode.str(); } std::string GCodeWriter::set_acceleration(unsigned int acceleration) { if (acceleration == 0 || acceleration == this->_last_acceleration) return ""; this->_last_acceleration = acceleration; std::ostringstream gcode; gcode << "M204 S" << acceleration; if (this->config.gcode_comments) gcode << " ; adjust acceleration"; gcode << "\n"; return gcode.str(); } std::string GCodeWriter::reset_e(bool force) { if (FLAVOR_IS(gcfMach3) || FLAVOR_IS(gcfMakerWare) || FLAVOR_IS(gcfSailfish)) return ""; if (this->_extruder != NULL) { if (this->_extruder->E == 0 && !force) return ""; this->_extruder->E = 0; } if (!this->_extrusion_axis.empty() && !this->config.use_relative_e_distances) { std::ostringstream gcode; gcode << "G92 " << this->_extrusion_axis << "0"; if (this->config.gcode_comments) gcode << " ; reset extrusion distance"; gcode << "\n"; return gcode.str(); } else { return ""; } } std::string GCodeWriter::update_progress(unsigned int num, unsigned int tot, bool allow_100) const { if (FLAVOR_IS_NOT(gcfMakerWare) && FLAVOR_IS_NOT(gcfSailfish)) return ""; unsigned int percent = 100.0 * num / tot; if (!allow_100) percent = std::min(percent, (unsigned int)99); std::ostringstream gcode; gcode << "M73 P" << percent; if (this->config.gcode_comments) gcode << " ; update progress"; gcode << "\n"; return gcode.str(); } bool GCodeWriter::need_toolchange(unsigned int extruder_id) const { // return false if this extruder was already selected return (this->_extruder == NULL) || (this->_extruder->id != extruder_id); } std::string GCodeWriter::set_extruder(unsigned int extruder_id) { if (!this->need_toolchange(extruder_id)) return ""; return this->toolchange(extruder_id); } std::string GCodeWriter::toolchange(unsigned int extruder_id) { // set the new extruder this->_extruder = &this->extruders.find(extruder_id)->second; // return the toolchange command // if we are running a single-extruder setup, just set the extruder and return nothing std::ostringstream gcode; if (this->multiple_extruders) { if (FLAVOR_IS(gcfMakerWare)) { gcode << "M135 T"; } else if (FLAVOR_IS(gcfSailfish)) { gcode << "M108 T"; } else { gcode << "T"; } gcode << extruder_id; if (this->config.gcode_comments) gcode << " ; change extruder"; gcode << "\n"; gcode << this->reset_e(true); } return gcode.str(); } std::string GCodeWriter::set_speed(double F, const std::string &comment, const std::string &cooling_marker) const { std::ostringstream gcode; gcode << "G1 F" << F; COMMENT(comment); gcode << cooling_marker; gcode << "\n"; return gcode.str(); } std::string GCodeWriter::travel_to_xy(const Pointf &point, const std::string &comment) { this->_pos.x = point.x; this->_pos.y = point.y; std::ostringstream gcode; gcode << "G1 X" << XYZF_NUM(point.x) << " Y" << XYZF_NUM(point.y) << " F" << XYZF_NUM(this->config.travel_speed.value * 60.0); COMMENT(comment); gcode << "\n"; return gcode.str(); } std::string GCodeWriter::travel_to_xyz(const Pointf3 &point, const std::string &comment) { /* If target Z is lower than current Z but higher than nominal Z we don't perform the Z move but we only move in the XY plane and adjust the nominal Z by reducing the lift amount that will be used for unlift. */ if (!this->will_move_z(point.z)) { double nominal_z = this->_pos.z - this->_lifted; this->_lifted = this->_lifted - (point.z - nominal_z); return this->travel_to_xy(point); } /* In all the other cases, we perform an actual XYZ move and cancel the lift. */ this->_lifted = 0; this->_pos = point; std::ostringstream gcode; gcode << "G1 X" << XYZF_NUM(point.x) << " Y" << XYZF_NUM(point.y) << " Z" << XYZF_NUM(point.z) << " F" << XYZF_NUM(this->config.travel_speed.value * 60.0); COMMENT(comment); gcode << "\n"; return gcode.str(); } std::string GCodeWriter::travel_to_z(double z, const std::string &comment) { /* If target Z is lower than current Z but higher than nominal Z we don't perform the move but we only adjust the nominal Z by reducing the lift amount that will be used for unlift. */ if (!this->will_move_z(z)) { double nominal_z = this->_pos.z - this->_lifted; this->_lifted = this->_lifted - (z - nominal_z); return ""; } /* In all the other cases, we perform an actual Z move and cancel the lift. */ this->_lifted = 0; return this->_travel_to_z(z, comment); } std::string GCodeWriter::_travel_to_z(double z, const std::string &comment) { this->_pos.z = z; std::ostringstream gcode; gcode << "G1 Z" << XYZF_NUM(z) << " F" << XYZF_NUM(this->config.travel_speed.value * 60.0); COMMENT(comment); gcode << "\n"; return gcode.str(); } bool GCodeWriter::will_move_z(double z) const { /* If target Z is lower than current Z but higher than nominal Z we don't perform an actual Z move. */ if (this->_lifted > 0) { double nominal_z = this->_pos.z - this->_lifted; if (z >= nominal_z && z <= this->_pos.z) return false; } return true; } std::string GCodeWriter::extrude_to_xy(const Pointf &point, double dE, const std::string &comment) { this->_pos.x = point.x; this->_pos.y = point.y; this->_extruder->extrude(dE); std::ostringstream gcode; gcode << "G1 X" << XYZF_NUM(point.x) << " Y" << XYZF_NUM(point.y) << " " << this->_extrusion_axis << E_NUM(this->_extruder->E); COMMENT(comment); gcode << "\n"; return gcode.str(); } std::string GCodeWriter::extrude_to_xyz(const Pointf3 &point, double dE, const std::string &comment) { this->_pos = point; this->_lifted = 0; this->_extruder->extrude(dE); std::ostringstream gcode; gcode << "G1 X" << XYZF_NUM(point.x) << " Y" << XYZF_NUM(point.y) << " Z" << XYZF_NUM(point.z) << " " << this->_extrusion_axis << E_NUM(this->_extruder->E); COMMENT(comment); gcode << "\n"; return gcode.str(); } std::string GCodeWriter::retract() { return this->_retract( this->_extruder->retract_length(), this->_extruder->retract_restart_extra(), "retract" ); } std::string GCodeWriter::retract_for_toolchange() { return this->_retract( this->_extruder->retract_length_toolchange(), this->_extruder->retract_restart_extra_toolchange(), "retract for toolchange" ); } std::string GCodeWriter::_retract(double length, double restart_extra, const std::string &comment) { std::ostringstream gcode; /* If firmware retraction is enabled, we use a fake value of 1 since we ignore the actual configured retract_length which might be 0, in which case the retraction logic gets skipped. */ if (this->config.use_firmware_retraction) length = 1; // If we use volumetric E values we turn lengths into volumes */ if (this->config.use_volumetric_e) { double d = this->_extruder->filament_diameter(); double area = d * d * PI/4; length = length * area; restart_extra = restart_extra * area; } double dE = this->_extruder->retract(length, restart_extra); if (dE != 0) { if (this->config.use_firmware_retraction) { if (FLAVOR_IS(gcfMachinekit)) gcode << "G22 ; retract\n"; else gcode << "G10 ; retract\n"; } else { gcode << "G1 " << this->_extrusion_axis << E_NUM(this->_extruder->E) << " F" << this->_extruder->retract_speed_mm_min; COMMENT(comment); gcode << "\n"; } } if (FLAVOR_IS(gcfMakerWare)) gcode << "M103 ; extruder off\n"; return gcode.str(); } std::string GCodeWriter::unretract() { std::ostringstream gcode; if (FLAVOR_IS(gcfMakerWare)) gcode << "M101 ; extruder on\n"; double dE = this->_extruder->unretract(); if (dE != 0) { if (this->config.use_firmware_retraction) { if (FLAVOR_IS(gcfMachinekit)) gcode << "G23 ; unretract\n"; else gcode << "G11 ; unretract\n"; gcode << this->reset_e(); } else { // use G1 instead of G0 because G0 will blend the restart with the previous travel move gcode << "G1 " << this->_extrusion_axis << E_NUM(this->_extruder->E) << " F" << this->_extruder->retract_speed_mm_min; if (this->config.gcode_comments) gcode << " ; unretract"; gcode << "\n"; } } return gcode.str(); } /* If this method is called more than once before calling unlift(), it will not perform subsequent lifts, even if Z was raised manually (i.e. with travel_to_z()) and thus _lifted was reduced. */ std::string GCodeWriter::lift() { // check whether the above/below conditions are met double target_lift = 0; { double above = this->config.retract_lift_above.get_at(this->_extruder->id); double below = this->config.retract_lift_below.get_at(this->_extruder->id); if (this->_pos.z >= above && (below == 0 || this->_pos.z <= below)) target_lift = this->config.retract_lift.get_at(this->_extruder->id); } if (this->_lifted == 0 && target_lift > 0) { this->_lifted = target_lift; return this->_travel_to_z(this->_pos.z + target_lift, "lift Z"); } return ""; } std::string GCodeWriter::unlift() { std::string gcode; if (this->_lifted > 0) { gcode += this->_travel_to_z(this->_pos.z - this->_lifted, "restore layer Z"); this->_lifted = 0; } return gcode; } Pointf3 GCodeWriter::get_position() const { return this->_pos; } } Slic3r-version_1.31.6/xs/src/libslic3r/GCodeWriter.hpp000066400000000000000000000051401301441720000224740ustar00rootroot00000000000000#ifndef slic3r_GCodeWriter_hpp_ #define slic3r_GCodeWriter_hpp_ #include "libslic3r.h" #include #include "Extruder.hpp" #include "Point.hpp" #include "PrintConfig.hpp" namespace Slic3r { class GCodeWriter { public: GCodeConfig config; std::map extruders; bool multiple_extruders; GCodeWriter() : multiple_extruders(false), _extrusion_axis("E"), _extruder(NULL), _last_acceleration(0), _last_fan_speed(0), _lifted(0) {}; Extruder* extruder(); std::string extrusion_axis() const; void apply_print_config(const PrintConfig &print_config); void set_extruders(const std::vector &extruder_ids); std::string preamble(); std::string postamble() const; std::string set_temperature(unsigned int temperature, bool wait = false, int tool = -1) const; std::string set_bed_temperature(unsigned int temperature, bool wait = false) const; std::string set_fan(unsigned int speed, bool dont_save = false); std::string set_acceleration(unsigned int acceleration); std::string reset_e(bool force = false); std::string update_progress(unsigned int num, unsigned int tot, bool allow_100 = false) const; bool need_toolchange(unsigned int extruder_id) const; std::string set_extruder(unsigned int extruder_id); std::string toolchange(unsigned int extruder_id); std::string set_speed(double F, const std::string &comment = std::string(), const std::string &cooling_marker = std::string()) const; std::string travel_to_xy(const Pointf &point, const std::string &comment = std::string()); std::string travel_to_xyz(const Pointf3 &point, const std::string &comment = std::string()); std::string travel_to_z(double z, const std::string &comment = std::string()); bool will_move_z(double z) const; std::string extrude_to_xy(const Pointf &point, double dE, const std::string &comment = std::string()); std::string extrude_to_xyz(const Pointf3 &point, double dE, const std::string &comment = std::string()); std::string retract(); std::string retract_for_toolchange(); std::string unretract(); std::string lift(); std::string unlift(); Pointf3 get_position() const; private: std::string _extrusion_axis; Extruder* _extruder; unsigned int _last_acceleration; unsigned int _last_fan_speed; double _lifted; Pointf3 _pos; std::string _travel_to_z(double z, const std::string &comment); std::string _retract(double length, double restart_extra, const std::string &comment); }; } /* namespace Slic3r */ #endif /* slic3r_GCodeWriter_hpp_ */ Slic3r-version_1.31.6/xs/src/libslic3r/Geometry.cpp000066400000000000000000001245741301441720000221210ustar00rootroot00000000000000#include "Geometry.hpp" #include "ClipperUtils.hpp" #include "ExPolygon.hpp" #include "Line.hpp" #include "PolylineCollection.hpp" #include "clipper.hpp" #include #include #include #include #include #include #include #include #include #ifdef SLIC3R_DEBUG #include "SVG.hpp" #endif #ifdef SLIC3R_DEBUG namespace boost { namespace polygon { // The following code for the visualization of the boost Voronoi diagram is based on: // // Boost.Polygon library voronoi_graphic_utils.hpp header file // Copyright Andrii Sydorchuk 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) template class voronoi_visual_utils { public: // Discretize parabolic Voronoi edge. // Parabolic Voronoi edges are always formed by one point and one segment // from the initial input set. // // Args: // point: input point. // segment: input segment. // max_dist: maximum discretization distance. // discretization: point discretization of the given Voronoi edge. // // Template arguments: // InCT: coordinate type of the input geometries (usually integer). // Point: point type, should model point concept. // Segment: segment type, should model segment concept. // // Important: // discretization should contain both edge endpoints initially. template class Point, template class Segment> static typename enable_if< typename gtl_and< typename gtl_if< typename is_point_concept< typename geometry_concept< Point >::type >::type >::type, typename gtl_if< typename is_segment_concept< typename geometry_concept< Segment >::type >::type >::type >::type, void >::type discretize( const Point& point, const Segment& segment, const CT max_dist, std::vector< Point >* discretization) { // Apply the linear transformation to move start point of the segment to // the point with coordinates (0, 0) and the direction of the segment to // coincide the positive direction of the x-axis. CT segm_vec_x = cast(x(high(segment))) - cast(x(low(segment))); CT segm_vec_y = cast(y(high(segment))) - cast(y(low(segment))); CT sqr_segment_length = segm_vec_x * segm_vec_x + segm_vec_y * segm_vec_y; // Compute x-coordinates of the endpoints of the edge // in the transformed space. CT projection_start = sqr_segment_length * get_point_projection((*discretization)[0], segment); CT projection_end = sqr_segment_length * get_point_projection((*discretization)[1], segment); // Compute parabola parameters in the transformed space. // Parabola has next representation: // f(x) = ((x-rot_x)^2 + rot_y^2) / (2.0*rot_y). CT point_vec_x = cast(x(point)) - cast(x(low(segment))); CT point_vec_y = cast(y(point)) - cast(y(low(segment))); CT rot_x = segm_vec_x * point_vec_x + segm_vec_y * point_vec_y; CT rot_y = segm_vec_x * point_vec_y - segm_vec_y * point_vec_x; // Save the last point. Point last_point = (*discretization)[1]; discretization->pop_back(); // Use stack to avoid recursion. std::stack point_stack; point_stack.push(projection_end); CT cur_x = projection_start; CT cur_y = parabola_y(cur_x, rot_x, rot_y); // Adjust max_dist parameter in the transformed space. const CT max_dist_transformed = max_dist * max_dist * sqr_segment_length; while (!point_stack.empty()) { CT new_x = point_stack.top(); CT new_y = parabola_y(new_x, rot_x, rot_y); // Compute coordinates of the point of the parabola that is // furthest from the current line segment. CT mid_x = (new_y - cur_y) / (new_x - cur_x) * rot_y + rot_x; CT mid_y = parabola_y(mid_x, rot_x, rot_y); // Compute maximum distance between the given parabolic arc // and line segment that discretize it. CT dist = (new_y - cur_y) * (mid_x - cur_x) - (new_x - cur_x) * (mid_y - cur_y); dist = dist * dist / ((new_y - cur_y) * (new_y - cur_y) + (new_x - cur_x) * (new_x - cur_x)); if (dist <= max_dist_transformed) { // Distance between parabola and line segment is less than max_dist. point_stack.pop(); CT inter_x = (segm_vec_x * new_x - segm_vec_y * new_y) / sqr_segment_length + cast(x(low(segment))); CT inter_y = (segm_vec_x * new_y + segm_vec_y * new_x) / sqr_segment_length + cast(y(low(segment))); discretization->push_back(Point(inter_x, inter_y)); cur_x = new_x; cur_y = new_y; } else { point_stack.push(mid_x); } } // Update last point. discretization->back() = last_point; } private: // Compute y(x) = ((x - a) * (x - a) + b * b) / (2 * b). static CT parabola_y(CT x, CT a, CT b) { return ((x - a) * (x - a) + b * b) / (b + b); } // Get normalized length of the distance between: // 1) point projection onto the segment // 2) start point of the segment // Return this length divided by the segment length. This is made to avoid // sqrt computation during transformation from the initial space to the // transformed one and vice versa. The assumption is made that projection of // the point lies between the start-point and endpoint of the segment. template class Point, template class Segment> static typename enable_if< typename gtl_and< typename gtl_if< typename is_point_concept< typename geometry_concept< Point >::type >::type >::type, typename gtl_if< typename is_segment_concept< typename geometry_concept< Segment >::type >::type >::type >::type, CT >::type get_point_projection( const Point& point, const Segment& segment) { CT segment_vec_x = cast(x(high(segment))) - cast(x(low(segment))); CT segment_vec_y = cast(y(high(segment))) - cast(y(low(segment))); CT point_vec_x = x(point) - cast(x(low(segment))); CT point_vec_y = y(point) - cast(y(low(segment))); CT sqr_segment_length = segment_vec_x * segment_vec_x + segment_vec_y * segment_vec_y; CT vec_dot = segment_vec_x * point_vec_x + segment_vec_y * point_vec_y; return vec_dot / sqr_segment_length; } template static CT cast(const InCT& value) { return static_cast(value); } }; } } // namespace boost::polygon #endif using namespace boost::polygon; // provides also high() and low() namespace Slic3r { namespace Geometry { static bool sort_points (Point a, Point b) { return (a.x < b.x) || (a.x == b.x && a.y < b.y); } /* This implementation is based on Andrew's monotone chain 2D convex hull algorithm */ Polygon convex_hull(Points points) { assert(points.size() >= 3); // sort input points std::sort(points.begin(), points.end(), sort_points); int n = points.size(), k = 0; Polygon hull; hull.points.resize(2*n); // Build lower hull for (int i = 0; i < n; i++) { while (k >= 2 && points[i].ccw(hull.points[k-2], hull.points[k-1]) <= 0) k--; hull.points[k++] = points[i]; } // Build upper hull for (int i = n-2, t = k+1; i >= 0; i--) { while (k >= t && points[i].ccw(hull.points[k-2], hull.points[k-1]) <= 0) k--; hull.points[k++] = points[i]; } hull.points.resize(k); assert( hull.points.front().coincides_with(hull.points.back()) ); hull.points.pop_back(); return hull; } Polygon convex_hull(const Polygons &polygons) { Points pp; for (Polygons::const_iterator p = polygons.begin(); p != polygons.end(); ++p) { pp.insert(pp.end(), p->points.begin(), p->points.end()); } return convex_hull(pp); } /* accepts an arrayref of points and returns a list of indices according to a nearest-neighbor walk */ void chained_path(const Points &points, std::vector &retval, Point start_near) { PointConstPtrs my_points; std::map indices; my_points.reserve(points.size()); for (Points::const_iterator it = points.begin(); it != points.end(); ++it) { my_points.push_back(&*it); indices[&*it] = it - points.begin(); } retval.reserve(points.size()); while (!my_points.empty()) { Points::size_type idx = start_near.nearest_point_index(my_points); start_near = *my_points[idx]; retval.push_back(indices[ my_points[idx] ]); my_points.erase(my_points.begin() + idx); } } void chained_path(const Points &points, std::vector &retval) { if (points.empty()) return; // can't call front() on empty vector chained_path(points, retval, points.front()); } /* retval and items must be different containers */ template void chained_path_items(Points &points, T &items, T &retval) { std::vector indices; chained_path(points, indices); for (std::vector::const_iterator it = indices.begin(); it != indices.end(); ++it) retval.push_back(items[*it]); } template void chained_path_items(Points &points, ClipperLib::PolyNodes &items, ClipperLib::PolyNodes &retval); bool directions_parallel(double angle1, double angle2, double max_diff) { double diff = fabs(angle1 - angle2); max_diff += EPSILON; return diff < max_diff || fabs(diff - PI) < max_diff; } template bool contains(const std::vector &vector, const Point &point) { for (typename std::vector::const_iterator it = vector.begin(); it != vector.end(); ++it) { if (it->contains(point)) return true; } return false; } template bool contains(const ExPolygons &vector, const Point &point); double rad2deg(double angle) { return angle / PI * 180.0; } double rad2deg_dir(double angle) { angle = (angle < PI) ? (-angle + PI/2.0) : (angle + PI/2.0); if (angle < 0) angle += PI; return rad2deg(angle); } double deg2rad(double angle) { return PI * angle / 180.0; } void simplify_polygons(const Polygons &polygons, double tolerance, Polygons* retval) { Polygons pp; for (Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++it) { Polygon p = *it; p.points.push_back(p.points.front()); p.points = MultiPoint::_douglas_peucker(p.points, tolerance); p.points.pop_back(); pp.push_back(p); } Slic3r::simplify_polygons(pp, retval); } double linint(double value, double oldmin, double oldmax, double newmin, double newmax) { return (value - oldmin) * (newmax - newmin) / (oldmax - oldmin) + newmin; } #if 0 // Point with a weight, by which the points are sorted. // If the points have the same weight, sort them lexicographically by their positions. struct ArrangeItem { ArrangeItem() {} Pointf pos; coordf_t weight; bool operator<(const ArrangeItem &other) const { return weight < other.weight || ((weight == other.weight) && (pos.y < other.pos.y || (pos.y == other.pos.y && pos.x < other.pos.x))); } }; Pointfs arrange(size_t num_parts, const Pointf &part_size, coordf_t gap, const BoundingBoxf* bed_bounding_box) { // Use actual part size (the largest) plus separation distance (half on each side) in spacing algorithm. const Pointf cell_size(part_size.x + gap, part_size.y + gap); const BoundingBoxf bed_bbox = (bed_bounding_box != NULL && bed_bounding_box->defined) ? *bed_bounding_box : // Bogus bed size, large enough not to trigger the unsufficient bed size error. BoundingBoxf( Pointf(0, 0), Pointf(cell_size.x * num_parts, cell_size.y * num_parts)); // This is how many cells we have available into which to put parts. size_t cellw = size_t(floor((bed_bbox.size().x + gap) / cell_size.x)); size_t cellh = size_t(floor((bed_bbox.size().y + gap) / cell_size.y)); if (num_parts > cellw * cellh) CONFESS(PRINTF_ZU " parts won't fit in your print area!\n", num_parts); // Get a bounding box of cellw x cellh cells, centered at the center of the bed. Pointf cells_size(cellw * cell_size.x - gap, cellh * cell_size.y - gap); Pointf cells_offset(bed_bbox.center() - 0.5 * cells_size); BoundingBoxf cells_bb(cells_offset, cells_size + cells_offset); // List of cells, sorted by distance from center. std::vector cellsorder(cellw * cellh, ArrangeItem()); for (size_t j = 0; j < cellh; ++ j) { // Center of the jth row on the bed. coordf_t cy = linint(j + 0.5, 0., double(cellh), cells_bb.min.y, cells_bb.max.y); // Offset from the bed center. coordf_t yd = cells_bb.center().y - cy; for (size_t i = 0; i < cellw; ++ i) { // Center of the ith column on the bed. coordf_t cx = linint(i + 0.5, 0., double(cellw), cells_bb.min.x, cells_bb.max.x); // Offset from the bed center. coordf_t xd = cells_bb.center().x - cx; // Cell with a distance from the bed center. ArrangeItem &ci = cellsorder[j * cellw + i]; // Cell center ci.pos.x = cx; ci.pos.y = cy; // Square distance of the cell center to the bed center. ci.weight = xd * xd + yd * yd; } } // Sort the cells lexicographically by their distances to the bed center and left to right / bttom to top. std::sort(cellsorder.begin(), cellsorder.end()); cellsorder.erase(cellsorder.begin() + num_parts, cellsorder.end()); // Return the (left,top) corners of the cells. Pointfs positions; positions.reserve(num_parts); for (std::vector::const_iterator it = cellsorder.begin(); it != cellsorder.end(); ++ it) positions.push_back(Pointf(it->pos.x - 0.5 * part_size.x, it->pos.y - 0.5 * part_size.y)); return positions; } #else class ArrangeItem { public: Pointf pos; size_t index_x, index_y; coordf_t dist; }; class ArrangeItemIndex { public: coordf_t index; ArrangeItem item; ArrangeItemIndex(coordf_t _index, ArrangeItem _item) : index(_index), item(_item) {}; }; bool arrange(size_t total_parts, const Pointf &part_size, coordf_t dist, const BoundingBoxf* bb, Pointfs &positions) { positions.clear(); Pointf part = part_size; // use actual part size (the largest) plus separation distance (half on each side) in spacing algorithm part.x += dist; part.y += dist; Pointf area; if (bb != NULL && bb->defined) { area = bb->size(); } else { // bogus area size, large enough not to trigger the error below area.x = part.x * total_parts; area.y = part.y * total_parts; } // this is how many cells we have available into which to put parts size_t cellw = floor((area.x + dist) / part.x); size_t cellh = floor((area.y + dist) / part.y); if (total_parts > (cellw * cellh)) return false; // total space used by cells Pointf cells(cellw * part.x, cellh * part.y); // bounding box of total space used by cells BoundingBoxf cells_bb; cells_bb.merge(Pointf(0,0)); // min cells_bb.merge(cells); // max // center bounding box to area cells_bb.translate( (area.x - cells.x) / 2, (area.y - cells.y) / 2 ); // list of cells, sorted by distance from center std::vector cellsorder; // work out distance for all cells, sort into list for (size_t i = 0; i <= cellw-1; ++i) { for (size_t j = 0; j <= cellh-1; ++j) { coordf_t cx = linint(i + 0.5, 0, cellw, cells_bb.min.x, cells_bb.max.x); coordf_t cy = linint(j + 0.5, 0, cellh, cells_bb.min.y, cells_bb.max.y); coordf_t xd = fabs((area.x / 2) - cx); coordf_t yd = fabs((area.y / 2) - cy); ArrangeItem c; c.pos.x = cx; c.pos.y = cy; c.index_x = i; c.index_y = j; c.dist = xd * xd + yd * yd - fabs((cellw / 2) - (i + 0.5)); // binary insertion sort { coordf_t index = c.dist; size_t low = 0; size_t high = cellsorder.size(); while (low < high) { size_t mid = (low + ((high - low) / 2)) | 0; coordf_t midval = cellsorder[mid].index; if (midval < index) { low = mid + 1; } else if (midval > index) { high = mid; } else { cellsorder.insert(cellsorder.begin() + mid, ArrangeItemIndex(index, c)); goto ENDSORT; } } cellsorder.insert(cellsorder.begin() + low, ArrangeItemIndex(index, c)); } ENDSORT: ; } } // the extents of cells actually used by objects coordf_t lx = 0; coordf_t ty = 0; coordf_t rx = 0; coordf_t by = 0; // now find cells actually used by objects, map out the extents so we can position correctly for (size_t i = 1; i <= total_parts; ++i) { ArrangeItemIndex c = cellsorder[i - 1]; coordf_t cx = c.item.index_x; coordf_t cy = c.item.index_y; if (i == 1) { lx = rx = cx; ty = by = cy; } else { if (cx > rx) rx = cx; if (cx < lx) lx = cx; if (cy > by) by = cy; if (cy < ty) ty = cy; } } // now we actually place objects into cells, positioned such that the left and bottom borders are at 0 for (size_t i = 1; i <= total_parts; ++i) { ArrangeItemIndex c = cellsorder.front(); cellsorder.erase(cellsorder.begin()); coordf_t cx = c.item.index_x - lx; coordf_t cy = c.item.index_y - ty; positions.push_back(Pointf(cx * part.x, cy * part.y)); } if (bb != NULL && bb->defined) { for (Pointfs::iterator p = positions.begin(); p != positions.end(); ++p) { p->x += bb->min.x; p->y += bb->min.y; } } return true; } #endif #ifdef SLIC3R_DEBUG // The following code for the visualization of the boost Voronoi diagram is based on: // // Boost.Polygon library voronoi_visualizer.cpp file // Copyright Andrii Sydorchuk 2010-2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) namespace Voronoi { namespace Internal { typedef double coordinate_type; typedef boost::polygon::point_data point_type; typedef boost::polygon::segment_data segment_type; typedef boost::polygon::rectangle_data rect_type; // typedef voronoi_builder VB; typedef boost::polygon::voronoi_diagram VD; typedef VD::cell_type cell_type; typedef VD::cell_type::source_index_type source_index_type; typedef VD::cell_type::source_category_type source_category_type; typedef VD::edge_type edge_type; typedef VD::cell_container_type cell_container_type; typedef VD::cell_container_type vertex_container_type; typedef VD::edge_container_type edge_container_type; typedef VD::const_cell_iterator const_cell_iterator; typedef VD::const_vertex_iterator const_vertex_iterator; typedef VD::const_edge_iterator const_edge_iterator; static const std::size_t EXTERNAL_COLOR = 1; inline void color_exterior(const VD::edge_type* edge) { if (edge->color() == EXTERNAL_COLOR) return; edge->color(EXTERNAL_COLOR); edge->twin()->color(EXTERNAL_COLOR); const VD::vertex_type* v = edge->vertex1(); if (v == NULL || !edge->is_primary()) return; v->color(EXTERNAL_COLOR); const VD::edge_type* e = v->incident_edge(); do { color_exterior(e); e = e->rot_next(); } while (e != v->incident_edge()); } inline point_type retrieve_point(const std::vector &segments, const cell_type& cell) { assert(cell.source_category() == SOURCE_CATEGORY_SEGMENT_START_POINT || cell.source_category() == SOURCE_CATEGORY_SEGMENT_END_POINT); return (cell.source_category() == SOURCE_CATEGORY_SEGMENT_START_POINT) ? low(segments[cell.source_index()]) : high(segments[cell.source_index()]); } inline void clip_infinite_edge(const std::vector &segments, const edge_type& edge, coordinate_type bbox_max_size, std::vector* clipped_edge) { const cell_type& cell1 = *edge.cell(); const cell_type& cell2 = *edge.twin()->cell(); point_type origin, direction; // Infinite edges could not be created by two segment sites. if (cell1.contains_point() && cell2.contains_point()) { point_type p1 = retrieve_point(segments, cell1); point_type p2 = retrieve_point(segments, cell2); origin.x((p1.x() + p2.x()) * 0.5); origin.y((p1.y() + p2.y()) * 0.5); direction.x(p1.y() - p2.y()); direction.y(p2.x() - p1.x()); } else { origin = cell1.contains_segment() ? retrieve_point(segments, cell2) : retrieve_point(segments, cell1); segment_type segment = cell1.contains_segment() ? segments[cell1.source_index()] : segments[cell2.source_index()]; coordinate_type dx = high(segment).x() - low(segment).x(); coordinate_type dy = high(segment).y() - low(segment).y(); if ((low(segment) == origin) ^ cell1.contains_point()) { direction.x(dy); direction.y(-dx); } else { direction.x(-dy); direction.y(dx); } } coordinate_type koef = bbox_max_size / (std::max)(fabs(direction.x()), fabs(direction.y())); if (edge.vertex0() == NULL) { clipped_edge->push_back(point_type( origin.x() - direction.x() * koef, origin.y() - direction.y() * koef)); } else { clipped_edge->push_back( point_type(edge.vertex0()->x(), edge.vertex0()->y())); } if (edge.vertex1() == NULL) { clipped_edge->push_back(point_type( origin.x() + direction.x() * koef, origin.y() + direction.y() * koef)); } else { clipped_edge->push_back( point_type(edge.vertex1()->x(), edge.vertex1()->y())); } } inline void sample_curved_edge(const std::vector &segments, const edge_type& edge, std::vector &sampled_edge, coordinate_type max_dist) { point_type point = edge.cell()->contains_point() ? retrieve_point(segments, *edge.cell()) : retrieve_point(segments, *edge.twin()->cell()); segment_type segment = edge.cell()->contains_point() ? segments[edge.twin()->cell()->source_index()] : segments[edge.cell()->source_index()]; ::boost::polygon::voronoi_visual_utils::discretize(point, segment, max_dist, &sampled_edge); } } /* namespace Internal */ } // namespace Voronoi static inline void dump_voronoi_to_svg(const Lines &lines, /* const */ voronoi_diagram &vd, const ThickPolylines *polylines, const char *path) { const double scale = 0.2; const std::string inputSegmentPointColor = "lightseagreen"; const coord_t inputSegmentPointRadius = coord_t(0.09 * scale / SCALING_FACTOR); const std::string inputSegmentColor = "lightseagreen"; const coord_t inputSegmentLineWidth = coord_t(0.03 * scale / SCALING_FACTOR); const std::string voronoiPointColor = "black"; const coord_t voronoiPointRadius = coord_t(0.06 * scale / SCALING_FACTOR); const std::string voronoiLineColorPrimary = "black"; const std::string voronoiLineColorSecondary = "green"; const std::string voronoiArcColor = "red"; const coord_t voronoiLineWidth = coord_t(0.02 * scale / SCALING_FACTOR); const bool internalEdgesOnly = false; const bool primaryEdgesOnly = false; BoundingBox bbox = BoundingBox(lines); bbox.min.x -= coord_t(1. / SCALING_FACTOR); bbox.min.y -= coord_t(1. / SCALING_FACTOR); bbox.max.x += coord_t(1. / SCALING_FACTOR); bbox.max.y += coord_t(1. / SCALING_FACTOR); ::Slic3r::SVG svg(path, bbox); if (polylines != NULL) svg.draw(*polylines, "lime", "lime", voronoiLineWidth); // bbox.scale(1.2); // For clipping of half-lines to some reasonable value. // The line will then be clipped by the SVG viewer anyway. const double bbox_dim_max = double(bbox.max.x - bbox.min.x) + double(bbox.max.y - bbox.min.y); // For the discretization of the Voronoi parabolic segments. const double discretization_step = 0.0005 * bbox_dim_max; // Make a copy of the input segments with the double type. std::vector segments; for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++ it) segments.push_back(Voronoi::Internal::segment_type( Voronoi::Internal::point_type(double(it->a.x), double(it->a.y)), Voronoi::Internal::point_type(double(it->b.x), double(it->b.y)))); // Color exterior edges. for (voronoi_diagram::const_edge_iterator it = vd.edges().begin(); it != vd.edges().end(); ++it) if (!it->is_finite()) Voronoi::Internal::color_exterior(&(*it)); // Draw the end points of the input polygon. for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++it) { svg.draw(it->a, inputSegmentPointColor, inputSegmentPointRadius); svg.draw(it->b, inputSegmentPointColor, inputSegmentPointRadius); } // Draw the input polygon. for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++it) svg.draw(Line(Point(coord_t(it->a.x), coord_t(it->a.y)), Point(coord_t(it->b.x), coord_t(it->b.y))), inputSegmentColor, inputSegmentLineWidth); #if 1 // Draw voronoi vertices. for (voronoi_diagram::const_vertex_iterator it = vd.vertices().begin(); it != vd.vertices().end(); ++it) if (! internalEdgesOnly || it->color() != Voronoi::Internal::EXTERNAL_COLOR) svg.draw(Point(coord_t(it->x()), coord_t(it->y())), voronoiPointColor, voronoiPointRadius); for (voronoi_diagram::const_edge_iterator it = vd.edges().begin(); it != vd.edges().end(); ++it) { if (primaryEdgesOnly && !it->is_primary()) continue; if (internalEdgesOnly && (it->color() == Voronoi::Internal::EXTERNAL_COLOR)) continue; std::vector samples; std::string color = voronoiLineColorPrimary; if (!it->is_finite()) { Voronoi::Internal::clip_infinite_edge(segments, *it, bbox_dim_max, &samples); if (! it->is_primary()) color = voronoiLineColorSecondary; } else { // Store both points of the segment into samples. sample_curved_edge will split the initial line // until the discretization_step is reached. samples.push_back(Voronoi::Internal::point_type(it->vertex0()->x(), it->vertex0()->y())); samples.push_back(Voronoi::Internal::point_type(it->vertex1()->x(), it->vertex1()->y())); if (it->is_curved()) { Voronoi::Internal::sample_curved_edge(segments, *it, samples, discretization_step); color = voronoiArcColor; } else if (! it->is_primary()) color = voronoiLineColorSecondary; } for (std::size_t i = 0; i + 1 < samples.size(); ++i) svg.draw(Line(Point(coord_t(samples[i].x()), coord_t(samples[i].y())), Point(coord_t(samples[i+1].x()), coord_t(samples[i+1].y()))), color, voronoiLineWidth); } #endif if (polylines != NULL) svg.draw(*polylines, "blue", voronoiLineWidth); svg.Close(); } #endif /* SLIC3R_DEBUG */ // Euclidian distance of two boost::polygon points. template T dist(const boost::polygon::point_data &p1,const boost::polygon::point_data &p2) { T dx = p2.x() - p1.x(); T dy = p2.y() - p1.y(); return sqrt(dx*dx+dy*dy); } // Find a foot point of "px" on a segment "seg". template inline point_type project_point_to_segment(segment_type &seg, point_type &px) { typedef typename point_type::coordinate_type T; const point_type &p0 = low(seg); const point_type &p1 = high(seg); const point_type dir(p1.x()-p0.x(), p1.y()-p0.y()); const point_type dproj(px.x()-p0.x(), px.y()-p0.y()); const T t = (dir.x()*dproj.x() + dir.y()*dproj.y()) / (dir.x()*dir.x() + dir.y()*dir.y()); assert(t >= T(-1e-6) && t <= T(1. + 1e-6)); return point_type(p0.x() + t*dir.x(), p0.y() + t*dir.y()); } template inline const typename VD::point_type retrieve_cell_point(const typename VD::cell_type& cell, const SEGMENTS &segments) { assert(cell.source_category() == SOURCE_CATEGORY_SEGMENT_START_POINT || cell.source_category() == SOURCE_CATEGORY_SEGMENT_END_POINT); return (cell.source_category() == SOURCE_CATEGORY_SEGMENT_START_POINT) ? low(segments[cell.source_index()]) : high(segments[cell.source_index()]); } template inline std::pair measure_edge_thickness(const VD &vd, const typename VD::edge_type& edge, const SEGMENTS &segments) { typedef typename VD::coord_type T; const typename VD::point_type pa(edge.vertex0()->x(), edge.vertex0()->y()); const typename VD::point_type pb(edge.vertex1()->x(), edge.vertex1()->y()); const typename VD::cell_type &cell1 = *edge.cell(); const typename VD::cell_type &cell2 = *edge.twin()->cell(); if (cell1.contains_segment()) { if (cell2.contains_segment()) { // Both cells contain a linear segment, the left / right cells are symmetric. // Project pa, pb to the left segment. const typename VD::segment_type segment1 = segments[cell1.source_index()]; const typename VD::point_type p1a = project_point_to_segment(segment1, pa); const typename VD::point_type p1b = project_point_to_segment(segment1, pb); return std::pair(T(2.)*dist(pa, p1a), T(2.)*dist(pb, p1b)); } else { // 1st cell contains a linear segment, 2nd cell contains a point. // The medial axis between the cells is a parabolic arc. // Project pa, pb to the left segment. const typename VD::point_type p2 = retrieve_cell_point(cell2, segments); return std::pair(T(2.)*dist(pa, p2), T(2.)*dist(pb, p2)); } } else if (cell2.contains_segment()) { // 1st cell contains a point, 2nd cell contains a linear segment. // The medial axis between the cells is a parabolic arc. const typename VD::point_type p1 = retrieve_cell_point(cell1, segments); return std::pair(T(2.)*dist(pa, p1), T(2.)*dist(pb, p1)); } else { // Both cells contain a point. The left / right regions are triangular and symmetric. const typename VD::point_type p1 = retrieve_cell_point(cell1, segments); return std::pair(T(2.)*dist(pa, p1), T(2.)*dist(pb, p1)); } } // Converts the Line instances of Lines vector to VD::segment_type. template class Lines2VDSegments { public: Lines2VDSegments(const Lines &alines) : lines(alines) {} typename VD::segment_type operator[](size_t idx) const { return typename VD::segment_type( typename VD::point_type(typename VD::coord_type(lines[idx].a.x), typename VD::coord_type(lines[idx].a.y)), typename VD::point_type(typename VD::coord_type(lines[idx].b.x), typename VD::coord_type(lines[idx].b.y))); } private: const Lines &lines; }; void MedialAxis::build(ThickPolylines* polylines) { construct_voronoi(this->lines.begin(), this->lines.end(), &this->vd); /* // DEBUG: dump all Voronoi edges { for (VD::const_edge_iterator edge = this->vd.edges().begin(); edge != this->vd.edges().end(); ++edge) { if (edge->is_infinite()) continue; ThickPolyline polyline; polyline.points.push_back(Point( edge->vertex0()->x(), edge->vertex0()->y() )); polyline.points.push_back(Point( edge->vertex1()->x(), edge->vertex1()->y() )); polylines->push_back(polyline); } return; } */ typedef const VD::vertex_type vert_t; typedef const VD::edge_type edge_t; // collect valid edges (i.e. prune those not belonging to MAT) // note: this keeps twins, so it inserts twice the number of the valid edges this->valid_edges.clear(); { std::set seen_edges; for (VD::const_edge_iterator edge = this->vd.edges().begin(); edge != this->vd.edges().end(); ++edge) { // if we only process segments representing closed loops, none if the // infinite edges (if any) would be part of our MAT anyway if (edge->is_secondary() || edge->is_infinite()) continue; // don't re-validate twins if (seen_edges.find(&*edge) != seen_edges.end()) continue; // TODO: is this needed? seen_edges.insert(&*edge); seen_edges.insert(edge->twin()); if (!this->validate_edge(&*edge)) continue; this->valid_edges.insert(&*edge); this->valid_edges.insert(edge->twin()); } } this->edges = this->valid_edges; // iterate through the valid edges to build polylines while (!this->edges.empty()) { const edge_t* edge = *this->edges.begin(); // start a polyline ThickPolyline polyline; polyline.points.push_back(Point( edge->vertex0()->x(), edge->vertex0()->y() )); polyline.points.push_back(Point( edge->vertex1()->x(), edge->vertex1()->y() )); polyline.width.push_back(this->thickness[edge].first); polyline.width.push_back(this->thickness[edge].second); // remove this edge and its twin from the available edges (void)this->edges.erase(edge); (void)this->edges.erase(edge->twin()); // get next points this->process_edge_neighbors(edge, &polyline); // get previous points { ThickPolyline rpolyline; this->process_edge_neighbors(edge->twin(), &rpolyline); polyline.points.insert(polyline.points.begin(), rpolyline.points.rbegin(), rpolyline.points.rend()); polyline.width.insert(polyline.width.begin(), rpolyline.width.rbegin(), rpolyline.width.rend()); polyline.endpoints.first = rpolyline.endpoints.second; } assert(polyline.width.size() == polyline.points.size()*2 - 2); // prevent loop endpoints from being extended if (polyline.first_point().coincides_with(polyline.last_point())) { polyline.endpoints.first = false; polyline.endpoints.second = false; } // append polyline to result polylines->push_back(polyline); } #ifdef SLIC3R_DEBUG { static int iRun = 0; dump_voronoi_to_svg(this->lines, this->vd, polylines, debug_out_path("MedialAxis-%d.svg", iRun ++).c_str()); printf("Thick lines: "); for (ThickPolylines::const_iterator it = polylines->begin(); it != polylines->end(); ++ it) { ThickLines lines = it->thicklines(); for (ThickLines::const_iterator it2 = lines.begin(); it2 != lines.end(); ++ it2) { printf("%f,%f ", it2->a_width, it2->b_width); } } printf("\n"); } #endif /* SLIC3R_DEBUG */ } void MedialAxis::build(Polylines* polylines) { ThickPolylines tp; this->build(&tp); polylines->insert(polylines->end(), tp.begin(), tp.end()); } void MedialAxis::process_edge_neighbors(const VD::edge_type* edge, ThickPolyline* polyline) { while (true) { // Since rot_next() works on the edge starting point but we want // to find neighbors on the ending point, we just swap edge with // its twin. const VD::edge_type* twin = edge->twin(); // count neighbors for this edge std::vector neighbors; for (const VD::edge_type* neighbor = twin->rot_next(); neighbor != twin; neighbor = neighbor->rot_next()) { if (this->valid_edges.count(neighbor) > 0) neighbors.push_back(neighbor); } // if we have a single neighbor then we can continue recursively if (neighbors.size() == 1) { const VD::edge_type* neighbor = neighbors.front(); // break if this is a closed loop if (this->edges.count(neighbor) == 0) return; Point new_point(neighbor->vertex1()->x(), neighbor->vertex1()->y()); polyline->points.push_back(new_point); polyline->width.push_back(this->thickness[neighbor].first); polyline->width.push_back(this->thickness[neighbor].second); (void)this->edges.erase(neighbor); (void)this->edges.erase(neighbor->twin()); edge = neighbor; } else if (neighbors.size() == 0) { polyline->endpoints.second = true; return; } else { // T-shaped or star-shaped joint return; } } } bool MedialAxis::validate_edge(const VD::edge_type* edge) { // construct the line representing this edge of the Voronoi diagram const Line line( Point( edge->vertex0()->x(), edge->vertex0()->y() ), Point( edge->vertex1()->x(), edge->vertex1()->y() ) ); // discard edge if it lies outside the supplied shape // this could maybe be optimized (checking inclusion of the endpoints // might give false positives as they might belong to the contour itself) if (this->expolygon != NULL) { if (line.a.coincides_with(line.b)) { // in this case, contains(line) returns a false positive if (!this->expolygon->contains(line.a)) return false; } else { if (!this->expolygon->contains(line)) return false; } } // retrieve the original line segments which generated the edge we're checking const VD::cell_type* cell_l = edge->cell(); const VD::cell_type* cell_r = edge->twin()->cell(); const Line &segment_l = this->retrieve_segment(cell_l); const Line &segment_r = this->retrieve_segment(cell_r); /* SVG svg("edge.svg"); svg.draw(*this->expolygon); svg.draw(line); svg.draw(segment_l, "red"); svg.draw(segment_r, "blue"); svg.Close(); */ /* Calculate thickness of the cross-section at both the endpoints of this edge. Our Voronoi edge is part of a CCW sequence going around its Voronoi cell located on the left side. (segment_l). This edge's twin goes around segment_r. Thus, segment_r is oriented in the same direction as our main edge, and segment_l is oriented in the same direction as our twin edge. We used to only consider the (half-)distances to segment_r, and that works whenever segment_l and segment_r are almost specular and facing. However, at curves they are staggered and they only face for a very little length (our very short edge represents such visibility). Both w0 and w1 can be calculated either towards cell_l or cell_r with equal results by Voronoi definition. When cell_l or cell_r don't refer to the segment but only to an endpoint, we calculate the distance to that endpoint instead. */ coordf_t w0 = cell_r->contains_segment() ? line.a.distance_to(segment_r)*2 : line.a.distance_to(this->retrieve_endpoint(cell_r))*2; coordf_t w1 = cell_l->contains_segment() ? line.b.distance_to(segment_l)*2 : line.b.distance_to(this->retrieve_endpoint(cell_l))*2; if (cell_l->contains_segment() && cell_r->contains_segment()) { // calculate the relative angle between the two boundary segments double angle = fabs(segment_r.orientation() - segment_l.orientation()); if (angle > PI) angle = 2*PI - angle; assert(angle >= 0 && angle <= PI); // fabs(angle) ranges from 0 (collinear, same direction) to PI (collinear, opposite direction) // we're interested only in segments close to the second case (facing segments) // so we allow some tolerance. // this filter ensures that we're dealing with a narrow/oriented area (longer than thick) // we don't run it on edges not generated by two segments (thus generated by one segment // and the endpoint of another segment), since their orientation would not be meaningful if (PI - angle > PI/8) { // angle is not narrow enough // only apply this filter to segments that are not too short otherwise their // angle could possibly be not meaningful if (w0 < SCALED_EPSILON || w1 < SCALED_EPSILON || line.length() >= this->min_width) return false; } } else { if (w0 < SCALED_EPSILON || w1 < SCALED_EPSILON) return false; } if (w0 < this->min_width && w1 < this->min_width) return false; if (w0 > this->max_width && w1 > this->max_width) return false; this->thickness[edge] = std::make_pair(w0, w1); this->thickness[edge->twin()] = std::make_pair(w1, w0); return true; } const Line& MedialAxis::retrieve_segment(const VD::cell_type* cell) const { return this->lines[cell->source_index()]; } const Point& MedialAxis::retrieve_endpoint(const VD::cell_type* cell) const { const Line& line = this->retrieve_segment(cell); if (cell->source_category() == SOURCE_CATEGORY_SEGMENT_START_POINT) { return line.a; } else { return line.b; } } } } Slic3r-version_1.31.6/xs/src/libslic3r/Geometry.hpp000066400000000000000000000046541301441720000221220ustar00rootroot00000000000000#ifndef slic3r_Geometry_hpp_ #define slic3r_Geometry_hpp_ #include "libslic3r.h" #include "BoundingBox.hpp" #include "ExPolygon.hpp" #include "Polygon.hpp" #include "Polyline.hpp" #include "boost/polygon/voronoi.hpp" using boost::polygon::voronoi_builder; using boost::polygon::voronoi_diagram; namespace Slic3r { namespace Geometry { Polygon convex_hull(Points points); Polygon convex_hull(const Polygons &polygons); void chained_path(const Points &points, std::vector &retval, Point start_near); void chained_path(const Points &points, std::vector &retval); template void chained_path_items(Points &points, T &items, T &retval); bool directions_parallel(double angle1, double angle2, double max_diff = 0); template bool contains(const std::vector &vector, const Point &point); double rad2deg(double angle); double rad2deg_dir(double angle); double deg2rad(double angle); void simplify_polygons(const Polygons &polygons, double tolerance, Polygons* retval); double linint(double value, double oldmin, double oldmax, double newmin, double newmax); bool arrange( // input size_t num_parts, const Pointf &part_size, coordf_t gap, const BoundingBoxf* bed_bounding_box, // output Pointfs &positions); class MedialAxis { public: Lines lines; const ExPolygon* expolygon; double max_width; double min_width; MedialAxis(double _max_width, double _min_width, const ExPolygon* _expolygon = NULL) : max_width(_max_width), min_width(_min_width), expolygon(_expolygon) {}; void build(ThickPolylines* polylines); void build(Polylines* polylines); private: class VD : public voronoi_diagram { public: typedef double coord_type; typedef boost::polygon::point_data point_type; typedef boost::polygon::segment_data segment_type; typedef boost::polygon::rectangle_data rect_type; }; VD vd; std::set edges, valid_edges; std::map > thickness; void process_edge_neighbors(const VD::edge_type* edge, ThickPolyline* polyline); bool validate_edge(const VD::edge_type* edge); const Line& retrieve_segment(const VD::cell_type* cell) const; const Point& retrieve_endpoint(const VD::cell_type* cell) const; }; } } #endif Slic3r-version_1.31.6/xs/src/libslic3r/Layer.cpp000066400000000000000000000266221301441720000213750ustar00rootroot00000000000000#include "Layer.hpp" #include "ClipperUtils.hpp" #include "Geometry.hpp" #include "Print.hpp" #include "Fill/Fill.hpp" #include "SVG.hpp" namespace Slic3r { Layer::Layer(size_t id, PrintObject *object, coordf_t height, coordf_t print_z, coordf_t slice_z) : upper_layer(NULL), lower_layer(NULL), regions(), slicing_errors(false), slice_z(slice_z), print_z(print_z), height(height), slices(), _id(id), _object(object) { } Layer::~Layer() { // remove references to self if (NULL != this->upper_layer) { this->upper_layer->lower_layer = NULL; } if (NULL != this->lower_layer) { this->lower_layer->upper_layer = NULL; } this->clear_regions(); } size_t Layer::id() const { return this->_id; } void Layer::set_id(size_t id) { this->_id = id; } PrintObject* Layer::object() { return this->_object; } const PrintObject* Layer::object() const { return this->_object; } size_t Layer::region_count() const { return this->regions.size(); } void Layer::clear_regions() { for (size_t i = 0; i < this->regions.size(); ++ i) delete this->regions[i]; this->regions.clear(); } LayerRegion* Layer::add_region(PrintRegion* print_region) { LayerRegion* region = new LayerRegion(this, print_region); this->regions.push_back(region); return region; } void Layer::delete_region(int idx) { LayerRegionPtrs::iterator i = this->regions.begin() + idx; LayerRegion* item = *i; this->regions.erase(i); delete item; } // merge all regions' slices to get islands void Layer::make_slices() { ExPolygons slices; if (this->regions.size() == 1) { // optimization: if we only have one region, take its slices slices = this->regions.front()->slices; } else { Polygons slices_p; FOREACH_LAYERREGION(this, layerm) { polygons_append(slices_p, to_polygons((*layerm)->slices)); } union_(slices_p, &slices); } this->slices.expolygons.clear(); this->slices.expolygons.reserve(slices.size()); // prepare ordering points Points ordering_points; ordering_points.reserve(slices.size()); for (ExPolygons::const_iterator ex = slices.begin(); ex != slices.end(); ++ex) ordering_points.push_back(ex->contour.first_point()); // sort slices std::vector order; Slic3r::Geometry::chained_path(ordering_points, order); // populate slices vector for (std::vector::const_iterator it = order.begin(); it != order.end(); ++it) this->slices.expolygons.push_back(STDMOVE(slices[*it])); } void Layer::merge_slices() { if (this->regions.size() == 1) { // Optimization, also more robust. Don't merge classified pieces of layerm->slices, // but use the non-split islands of a layer. For a single region print, these shall be equal. this->regions.front()->slices.surfaces.clear(); surfaces_append(this->regions.front()->slices.surfaces, this->slices.expolygons, stInternal); } else { FOREACH_LAYERREGION(this, layerm) { ExPolygons expp; // without safety offset, artifacts are generated (GH #2494) union_(to_polygons(STDMOVE((*layerm)->slices.surfaces)), &expp, true); (*layerm)->slices.surfaces.clear(); surfaces_append((*layerm)->slices.surfaces, expp, stInternal); } } } template bool Layer::any_internal_region_slice_contains(const T &item) const { FOREACH_LAYERREGION(this, layerm) { if ((*layerm)->slices.any_internal_contains(item)) return true; } return false; } template bool Layer::any_internal_region_slice_contains(const Polyline &item) const; template bool Layer::any_bottom_region_slice_contains(const T &item) const { FOREACH_LAYERREGION(this, layerm) { if ((*layerm)->slices.any_bottom_contains(item)) return true; } return false; } template bool Layer::any_bottom_region_slice_contains(const Polyline &item) const; // Here the perimeters are created cummulatively for all layer regions sharing the same parameters influencing the perimeters. // The perimeter paths and the thin fills (ExtrusionEntityCollection) are assigned to the first compatible layer region. // The resulting fill surface is split back among the originating regions. void Layer::make_perimeters() { #ifdef SLIC3R_DEBUG printf("Making perimeters for layer " PRINTF_ZU "\n", this->id()); #endif // keep track of regions whose perimeters we have already generated std::set done; FOREACH_LAYERREGION(this, layerm) { size_t region_id = layerm - this->regions.begin(); if (done.find(region_id) != done.end()) continue; done.insert(region_id); const PrintRegionConfig &config = (*layerm)->region()->config; // find compatible regions LayerRegionPtrs layerms; layerms.push_back(*layerm); for (LayerRegionPtrs::const_iterator it = layerm + 1; it != this->regions.end(); ++it) { LayerRegion* other_layerm = *it; const PrintRegionConfig &other_config = other_layerm->region()->config; if (config.perimeter_extruder == other_config.perimeter_extruder && config.perimeters == other_config.perimeters && config.perimeter_speed == other_config.perimeter_speed && config.gap_fill_speed == other_config.gap_fill_speed && config.overhangs == other_config.overhangs && config.serialize("perimeter_extrusion_width").compare(other_config.serialize("perimeter_extrusion_width")) == 0 && config.thin_walls == other_config.thin_walls && config.external_perimeters_first == other_config.external_perimeters_first) { layerms.push_back(other_layerm); done.insert(it - this->regions.begin()); } } if (layerms.size() == 1) { // optimization (*layerm)->fill_surfaces.surfaces.clear(); (*layerm)->make_perimeters((*layerm)->slices, &(*layerm)->fill_surfaces); (*layerm)->fill_expolygons = to_expolygons((*layerm)->fill_surfaces.surfaces); } else { SurfaceCollection new_slices; { // group slices (surfaces) according to number of extra perimeters std::map slices; // extra_perimeters => [ surface, surface... ] for (LayerRegionPtrs::iterator l = layerms.begin(); l != layerms.end(); ++l) { for (Surfaces::iterator s = (*l)->slices.surfaces.begin(); s != (*l)->slices.surfaces.end(); ++s) { slices[s->extra_perimeters].push_back(*s); } } // merge the surfaces assigned to each group for (std::map::const_iterator it = slices.begin(); it != slices.end(); ++it) surfaces_append(new_slices.surfaces, union_ex(it->second, true), it->second.front()); } // make perimeters SurfaceCollection fill_surfaces; (*layerm)->make_perimeters(new_slices, &fill_surfaces); // assign fill_surfaces to each layer if (!fill_surfaces.surfaces.empty()) { for (LayerRegionPtrs::iterator l = layerms.begin(); l != layerms.end(); ++l) { // Separate the fill surfaces. ExPolygons expp = intersection_ex(to_polygons(fill_surfaces), (*l)->slices); (*l)->fill_expolygons = expp; (*l)->fill_surfaces.surfaces.clear(); surfaces_append((*l)->fill_surfaces.surfaces, STDMOVE(expp), fill_surfaces.surfaces.front()); } } } } } void Layer::make_fills() { #ifdef SLIC3R_DEBUG printf("Making fills for layer " PRINTF_ZU "\n", this->id()); #endif for (LayerRegionPtrs::iterator it_layerm = regions.begin(); it_layerm != regions.end(); ++ it_layerm) { LayerRegion &layerm = *(*it_layerm); layerm.fills.clear(); make_fill(layerm, layerm.fills); #ifndef NDEBUG for (size_t i = 0; i < layerm.fills.entities.size(); ++ i) assert(dynamic_cast(layerm.fills.entities[i]) != NULL); #endif } } void Layer::export_region_slices_to_svg(const char *path) { BoundingBox bbox; for (LayerRegionPtrs::const_iterator region = this->regions.begin(); region != this->regions.end(); ++region) for (Surfaces::const_iterator surface = (*region)->slices.surfaces.begin(); surface != (*region)->slices.surfaces.end(); ++surface) bbox.merge(get_extents(surface->expolygon)); Point legend_size = export_surface_type_legend_to_svg_box_size(); Point legend_pos(bbox.min.x, bbox.max.y); bbox.merge(Point(std::max(bbox.min.x + legend_size.x, bbox.max.x), bbox.max.y + legend_size.y)); SVG svg(path, bbox); const float transparency = 0.5f; for (LayerRegionPtrs::const_iterator region = this->regions.begin(); region != this->regions.end(); ++region) for (Surfaces::const_iterator surface = (*region)->slices.surfaces.begin(); surface != (*region)->slices.surfaces.end(); ++surface) svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency); export_surface_type_legend_to_svg(svg, legend_pos); svg.Close(); } // Export to "out/LayerRegion-name-%d.svg" with an increasing index with every export. void Layer::export_region_slices_to_svg_debug(const char *name) { static size_t idx = 0; this->export_region_slices_to_svg(debug_out_path("Layer-slices-%s-%d.svg", name, idx ++).c_str()); } void Layer::export_region_fill_surfaces_to_svg(const char *path) { BoundingBox bbox; for (LayerRegionPtrs::const_iterator region = this->regions.begin(); region != this->regions.end(); ++region) for (Surfaces::const_iterator surface = (*region)->fill_surfaces.surfaces.begin(); surface != (*region)->fill_surfaces.surfaces.end(); ++surface) bbox.merge(get_extents(surface->expolygon)); Point legend_size = export_surface_type_legend_to_svg_box_size(); Point legend_pos(bbox.min.x, bbox.max.y); bbox.merge(Point(std::max(bbox.min.x + legend_size.x, bbox.max.x), bbox.max.y + legend_size.y)); SVG svg(path, bbox); const float transparency = 0.5f; for (LayerRegionPtrs::const_iterator region = this->regions.begin(); region != this->regions.end(); ++region) for (Surfaces::const_iterator surface = (*region)->fill_surfaces.surfaces.begin(); surface != (*region)->fill_surfaces.surfaces.end(); ++surface) svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency); export_surface_type_legend_to_svg(svg, legend_pos); svg.Close(); } // Export to "out/LayerRegion-name-%d.svg" with an increasing index with every export. void Layer::export_region_fill_surfaces_to_svg_debug(const char *name) { static size_t idx = 0; this->export_region_fill_surfaces_to_svg(debug_out_path("Layer-fill_surfaces-%s-%d.svg", name, idx ++).c_str()); } SupportLayer::SupportLayer(size_t id, PrintObject *object, coordf_t height, coordf_t print_z, coordf_t slice_z) : Layer(id, object, height, print_z, slice_z) { } SupportLayer::~SupportLayer() { } } Slic3r-version_1.31.6/xs/src/libslic3r/Layer.hpp000066400000000000000000000126331301441720000213770ustar00rootroot00000000000000#ifndef slic3r_Layer_hpp_ #define slic3r_Layer_hpp_ #include "libslic3r.h" #include "Flow.hpp" #include "SurfaceCollection.hpp" #include "ExtrusionEntityCollection.hpp" #include "ExPolygonCollection.hpp" #include "PolylineCollection.hpp" namespace Slic3r { typedef std::pair t_layer_height_range; typedef std::map t_layer_height_ranges; class Layer; class PrintRegion; class PrintObject; // TODO: make stuff private class LayerRegion { friend class Layer; public: Layer* layer(); PrintRegion* region() { return this->_region; } const PrintRegion* region() const { return this->_region; } // collection of surfaces generated by slicing the original geometry // divided by type top/bottom/internal SurfaceCollection slices; // collection of extrusion paths/loops filling gaps ExtrusionEntityCollection thin_fills; // Unspecified fill polygons, used for overhang detection ("ensure vertical wall thickness feature") // and for re-starting of infills. ExPolygons fill_expolygons; // collection of surfaces for infill generation SurfaceCollection fill_surfaces; // Collection of perimeter surfaces. This is a cached result of diff(slices, fill_surfaces). // While not necessary, the memory consumption is meager and it speeds up calculation. // The perimeter_surfaces keep the IDs of the slices (top/bottom/) SurfaceCollection perimeter_surfaces; // collection of expolygons representing the bridged areas (thus not // needing support material) Polygons bridged; // collection of polylines representing the unsupported bridge edges PolylineCollection unsupported_bridge_edges; // ordered collection of extrusion paths/loops to build all perimeters // (this collection contains only ExtrusionEntityCollection objects) ExtrusionEntityCollection perimeters; // ordered collection of extrusion paths to fill surfaces // (this collection contains only ExtrusionEntityCollection objects) ExtrusionEntityCollection fills; Flow flow(FlowRole role, bool bridge = false, double width = -1) const; void slices_to_fill_surfaces_clipped(); void prepare_fill_surfaces(); void make_perimeters(const SurfaceCollection &slices, SurfaceCollection* fill_surfaces); void process_external_surfaces(const Layer* lower_layer); double infill_area_threshold() const; void export_region_slices_to_svg(const char *path); void export_region_fill_surfaces_to_svg(const char *path); // Export to "out/LayerRegion-name-%d.svg" with an increasing index with every export. void export_region_slices_to_svg_debug(const char *name); void export_region_fill_surfaces_to_svg_debug(const char *name); private: Layer *_layer; PrintRegion *_region; LayerRegion(Layer *layer, PrintRegion *region); ~LayerRegion(); }; typedef std::vector LayerRegionPtrs; class Layer { friend class PrintObject; public: size_t id() const; void set_id(size_t id); PrintObject* object(); const PrintObject* object() const; Layer *upper_layer; Layer *lower_layer; LayerRegionPtrs regions; bool slicing_errors; coordf_t slice_z; // Z used for slicing in unscaled coordinates coordf_t print_z; // Z used for printing in unscaled coordinates coordf_t height; // layer height in unscaled coordinates // collection of expolygons generated by slicing the original geometry; // also known as 'islands' (all regions and surface types are merged here) // The slices are chained by the shortest traverse distance and this traversal // order will be recovered by the G-code generator. ExPolygonCollection slices; size_t region_count() const; const LayerRegion* get_region(int idx) const { return this->regions.at(idx); } LayerRegion* get_region(int idx) { return this->regions.at(idx); } LayerRegion* add_region(PrintRegion* print_region); void make_slices(); void merge_slices(); template bool any_internal_region_slice_contains(const T &item) const; template bool any_bottom_region_slice_contains(const T &item) const; void make_perimeters(); void make_fills(); void export_region_slices_to_svg(const char *path); void export_region_fill_surfaces_to_svg(const char *path); // Export to "out/LayerRegion-name-%d.svg" with an increasing index with every export. void export_region_slices_to_svg_debug(const char *name); void export_region_fill_surfaces_to_svg_debug(const char *name); protected: size_t _id; // sequential number of layer, 0-based PrintObject *_object; Layer(size_t id, PrintObject *object, coordf_t height, coordf_t print_z, coordf_t slice_z); virtual ~Layer(); void clear_regions(); void delete_region(int idx); }; class SupportLayer : public Layer { friend class PrintObject; public: // Polygons covered by the supports: base, interface and contact areas. ExPolygonCollection support_islands; // Extrusion paths for the support base. ExtrusionEntityCollection support_fills; // Extrusion paths for the support interface and contacts. ExtrusionEntityCollection support_interface_fills; protected: SupportLayer(size_t id, PrintObject *object, coordf_t height, coordf_t print_z, coordf_t slice_z); virtual ~SupportLayer(); }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/LayerRegion.cpp000066400000000000000000000467331301441720000225460ustar00rootroot00000000000000#include "Layer.hpp" #include "BridgeDetector.hpp" #include "ClipperUtils.hpp" #include "PerimeterGenerator.hpp" #include "Print.hpp" #include "Surface.hpp" #include "BoundingBox.hpp" #include "SVG.hpp" #include #include namespace Slic3r { LayerRegion::LayerRegion(Layer *layer, PrintRegion *region) : _layer(layer), _region(region) { } LayerRegion::~LayerRegion() { } Layer* LayerRegion::layer() { return this->_layer; } Flow LayerRegion::flow(FlowRole role, bool bridge, double width) const { return this->_region->flow( role, this->_layer->height, bridge, this->_layer->id() == 0, width, *this->_layer->object() ); } // Fill in layerm->fill_surfaces by trimming the layerm->slices by the cummulative layerm->fill_surfaces. void LayerRegion::slices_to_fill_surfaces_clipped() { // Note: this method should be idempotent, but fill_surfaces gets modified // in place. However we're now only using its boundaries (which are invariant) // so we're safe. This guarantees idempotence of prepare_infill() also in case // that combine_infill() turns some fill_surface into VOID surfaces. // Polygons fill_boundaries = to_polygons(STDMOVE(this->fill_surfaces)); Polygons fill_boundaries = to_polygons(this->fill_expolygons); this->fill_surfaces.surfaces.clear(); for (Surfaces::const_iterator surface = this->slices.surfaces.begin(); surface != this->slices.surfaces.end(); ++ surface) surfaces_append( this->fill_surfaces.surfaces, intersection_ex(to_polygons(surface->expolygon), fill_boundaries), surface->surface_type); } void LayerRegion::make_perimeters(const SurfaceCollection &slices, SurfaceCollection* fill_surfaces) { this->perimeters.clear(); this->thin_fills.clear(); PerimeterGenerator g( // input: &slices, this->layer()->height, this->flow(frPerimeter), &this->region()->config, &this->layer()->object()->config, &this->layer()->object()->print()->config, // output: &this->perimeters, &this->thin_fills, fill_surfaces ); if (this->layer()->lower_layer != NULL) // Cummulative sum of polygons over all the regions. g.lower_slices = &this->layer()->lower_layer->slices; g.layer_id = this->layer()->id(); g.ext_perimeter_flow = this->flow(frExternalPerimeter); g.overhang_flow = this->region()->flow(frPerimeter, -1, true, false, -1, *this->layer()->object()); g.solid_infill_flow = this->flow(frSolidInfill); g.process(); } //#define EXTERNAL_SURFACES_OFFSET_PARAMETERS CLIPPER_OFFSET_SCALE, ClipperLib::jtMiter, 3. //#define EXTERNAL_SURFACES_OFFSET_PARAMETERS CLIPPER_OFFSET_SCALE, ClipperLib::jtMiter, 1.5 #define EXTERNAL_SURFACES_OFFSET_PARAMETERS CLIPPER_OFFSET_SCALE, ClipperLib::jtSquare, 0. void LayerRegion::process_external_surfaces(const Layer* lower_layer) { const Surfaces &surfaces = this->fill_surfaces.surfaces; const double margin = scale_(EXTERNAL_INFILL_MARGIN); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING export_region_fill_surfaces_to_svg_debug("3_process_external_surfaces-initial"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ // 1) Collect bottom and bridge surfaces, each of them grown by a fixed 3mm offset // for better anchoring. // Bottom surfaces, grown. Surfaces bottom; // Bridge surfaces, initialy not grown. Surfaces bridges; // Top surfaces, grown. Surfaces top; // Internal surfaces, not grown. Surfaces internal; // Areas, where an infill of various types (top, bottom, bottom bride, sparse, void) could be placed. //FIXME if non zero infill, then fill_boundaries could be cheaply initialized from layerm->fill_expolygons. Polygons fill_boundaries; // Collect top surfaces and internal surfaces. // Collect fill_boundaries: If we're slicing with no infill, we can't extend external surfaces over non-existent infill. // This loop destroys the surfaces (aliasing this->fill_surfaces.surfaces) by moving into top/internal/fill_boundaries! { // bottom_polygons are used to trim inflated top surfaces. fill_boundaries.reserve(number_polygons(surfaces)); bool has_infill = this->region()->config.fill_density.value > 0.; for (Surfaces::iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) { if (surface->surface_type == stTop) { // Collect the top surfaces, inflate them and trim them by the bottom surfaces. // This gives the priority to bottom surfaces. surfaces_append(top, offset_ex(surface->expolygon, float(margin), EXTERNAL_SURFACES_OFFSET_PARAMETERS), *surface); } else if (surface->surface_type == stBottom || (surface->surface_type == stBottomBridge && lower_layer == NULL)) { // Grown by 3mm. surfaces_append(bottom, offset_ex(surface->expolygon, float(margin), EXTERNAL_SURFACES_OFFSET_PARAMETERS), *surface); } else if (surface->surface_type == stBottomBridge) { if (! surface->empty()) bridges.push_back(*surface); } bool internal_surface = surface->surface_type != stTop && ! surface->is_bottom(); if (has_infill || surface->surface_type != stInternal) { if (internal_surface) // Make a copy as the following line uses the move semantics. internal.push_back(*surface); polygons_append(fill_boundaries, STDMOVE(surface->expolygon)); } else if (internal_surface) internal.push_back(STDMOVE(*surface)); } } #if 0 { static int iRun = 0; bridges.export_to_svg(debug_out_path("bridges-before-grouping-%d.svg", iRun ++), true); } #endif if (bridges.empty()) { fill_boundaries = union_(fill_boundaries, true); } else { // 1) Calculate the inflated bridge regions, each constrained to its island. ExPolygons fill_boundaries_ex = union_ex(fill_boundaries, true); std::vector bridges_grown; std::vector bridge_bboxes; #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static int iRun = 0; SVG svg(debug_out_path("3_process_external_surfaces-fill_regions-%d.svg", iRun ++).c_str(), get_extents(fill_boundaries_ex)); svg.draw(fill_boundaries_ex); svg.draw_outline(fill_boundaries_ex, "black", "blue", scale_(0.05)); svg.Close(); } // export_region_fill_surfaces_to_svg_debug("3_process_external_surfaces-initial"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ { // Bridge expolygons, grown, to be tested for intersection with other bridge regions. std::vector fill_boundaries_ex_bboxes = get_extents_vector(fill_boundaries_ex); bridges_grown.reserve(bridges.size()); bridge_bboxes.reserve(bridges.size()); for (size_t i = 0; i < bridges.size(); ++ i) { // Find the island of this bridge. const Point pt = bridges[i].expolygon.contour.points.front(); int idx_island = -1; for (int j = 0; j < int(fill_boundaries_ex.size()); ++ j) if (fill_boundaries_ex_bboxes[j].contains(pt) && fill_boundaries_ex[j].contains(pt)) { idx_island = j; break; } // Grown by 3mm. Polygons polys = offset(bridges[i].expolygon, float(margin), EXTERNAL_SURFACES_OFFSET_PARAMETERS); if (idx_island == -1) { printf("Bridge did not fall into the source region!\r\n"); } else { // Found an island, to which this bridge region belongs. Trim it, polys = intersection(polys, to_polygons(fill_boundaries_ex[idx_island])); } bridge_bboxes.push_back(get_extents(polys)); bridges_grown.push_back(STDMOVE(polys)); } } // 2) Group the bridge surfaces by overlaps. std::vector bridge_group(bridges.size(), (size_t)-1); size_t n_groups = 0; for (size_t i = 0; i < bridges.size(); ++ i) { // A grup id for this bridge. size_t group_id = (bridge_group[i] == -1) ? (n_groups ++) : bridge_group[i]; bridge_group[i] = group_id; // For all possibly overlaping bridges: for (size_t j = i + 1; j < bridges.size(); ++ j) { if (! bridge_bboxes[i].overlap(bridge_bboxes[j])) continue; if (intersection(bridges_grown[i], bridges_grown[j], false).empty()) continue; // The two bridge regions intersect. Give them the same group id. if (bridge_group[j] != -1) { // The j'th bridge has been merged with some other bridge before. size_t group_id_new = bridge_group[j]; for (size_t k = 0; k < j; ++ k) if (bridge_group[k] == group_id) bridge_group[k] = group_id_new; group_id = group_id_new; } bridge_group[j] = group_id; } } // 3) Merge the groups with the same group id, detect bridges. { for (size_t group_id = 0; group_id < n_groups; ++ group_id) { size_t n_bridges_merged = 0; size_t idx_last = (size_t)-1; for (size_t i = 0; i < bridges.size(); ++ i) { if (bridge_group[i] == group_id) { ++ n_bridges_merged; idx_last = i; } } if (n_bridges_merged == 0) // This group has no regions assigned as these were moved into another group. continue; // Collect the initial ungrown regions and the grown polygons. ExPolygons initial; Polygons grown; for (size_t i = 0; i < bridges.size(); ++ i) { if (bridge_group[i] != group_id) continue; initial.push_back(STDMOVE(bridges[i].expolygon)); polygons_append(grown, bridges_grown[i]); } // detect bridge direction before merging grown surfaces otherwise adjacent bridges // would get merged into a single one while they need different directions // also, supply the original expolygon instead of the grown one, because in case // of very thin (but still working) anchors, the grown expolygon would go beyond them BridgeDetector bd( initial, lower_layer->slices, //FIXME parameters are not correct! // flow(FlowRole role, bool bridge = false, double width = -1) const; this->flow(frInfill, true, this->layer()->height).scaled_width() ); #ifdef SLIC3R_DEBUG printf("Processing bridge at layer " PRINTF_ZU ":\n", this->layer()->id()); #endif if (bd.detect_angle()) { bridges[idx_last].bridge_angle = bd.angle; if (this->layer()->object()->config.support_material) { polygons_append(this->bridged, bd.coverage()); this->unsupported_bridge_edges.append(bd.unsupported_edges()); } } // without safety offset, artifacts are generated (GH #2494) surfaces_append(bottom, union_ex(grown, true), bridges[idx_last]); } fill_boundaries = STDMOVE(to_polygons(fill_boundaries_ex)); } #if 0 { static int iRun = 0; bridges.export_to_svg(debug_out_path("bridges-after-grouping-%d.svg", iRun ++), true); } #endif } Surfaces new_surfaces; { // Merge top and bottom in a single collection. surfaces_append(top, STDMOVE(bottom)); // Intersect the grown surfaces with the actual fill boundaries. Polygons bottom_polygons = to_polygons(bottom); for (size_t i = 0; i < top.size(); ++ i) { Surface &s1 = top[i]; if (s1.empty()) continue; Polygons polys; polygons_append(polys, STDMOVE(s1)); for (size_t j = i + 1; j < top.size(); ++ j) { Surface &s2 = top[j]; if (! s2.empty() && surfaces_could_merge(s1, s2)) polygons_append(polys, STDMOVE(s2)); } if (s1.surface_type == stTop) // Trim the top surfaces by the bottom surfaces. This gives the priority to the bottom surfaces. polys = diff(polys, bottom_polygons); surfaces_append( new_surfaces, // Don't use a safety offset as fill_boundaries were already united using the safety offset. STDMOVE(intersection_ex(polys, fill_boundaries, false)), s1); } } // Subtract the new top surfaces from the other non-top surfaces and re-add them. Polygons new_polygons = to_polygons(new_surfaces); for (size_t i = 0; i < internal.size(); ++ i) { Surface &s1 = internal[i]; if (s1.empty()) continue; Polygons polys; polygons_append(polys, STDMOVE(s1)); for (size_t j = i + 1; j < internal.size(); ++ j) { Surface &s2 = internal[j]; if (! s2.empty() && surfaces_could_merge(s1, s2)) polygons_append(polys, STDMOVE(s2)); } ExPolygons new_expolys = diff_ex(polys, new_polygons); polygons_append(new_polygons, to_polygons(new_expolys)); surfaces_append(new_surfaces, STDMOVE(new_expolys), s1); } this->fill_surfaces.surfaces = STDMOVE(new_surfaces); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING export_region_fill_surfaces_to_svg_debug("3_process_external_surfaces-final"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } void LayerRegion::prepare_fill_surfaces() { #ifdef SLIC3R_DEBUG_SLICE_PROCESSING export_region_slices_to_svg_debug("2_prepare_fill_surfaces-initial"); export_region_fill_surfaces_to_svg_debug("2_prepare_fill_surfaces-initial"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ /* Note: in order to make the psPrepareInfill step idempotent, we should never alter fill_surfaces boundaries on which our idempotency relies since that's the only meaningful information returned by psPerimeters. */ // if no solid layers are requested, turn top/bottom surfaces to internal if (this->region()->config.top_solid_layers == 0) { for (Surfaces::iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) if (surface->surface_type == stTop) surface->surface_type = (this->layer()->object()->config.infill_only_where_needed) ? stInternalVoid : stInternal; } if (this->region()->config.bottom_solid_layers == 0) { for (Surfaces::iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) { if (surface->surface_type == stBottom || surface->surface_type == stBottomBridge) surface->surface_type = stInternal; } } // turn too small internal regions into solid regions according to the user setting if (this->region()->config.fill_density.value > 0) { // scaling an area requires two calls! double min_area = scale_(scale_(this->region()->config.solid_infill_below_area.value)); for (Surfaces::iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) { if (surface->surface_type == stInternal && surface->area() <= min_area) surface->surface_type = stInternalSolid; } } #ifdef SLIC3R_DEBUG_SLICE_PROCESSING export_region_slices_to_svg_debug("2_prepare_fill_surfaces-final"); export_region_fill_surfaces_to_svg_debug("2_prepare_fill_surfaces-final"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } double LayerRegion::infill_area_threshold() const { double ss = this->flow(frSolidInfill).scaled_spacing(); return ss*ss; } void LayerRegion::export_region_slices_to_svg(const char *path) { BoundingBox bbox; for (Surfaces::const_iterator surface = this->slices.surfaces.begin(); surface != this->slices.surfaces.end(); ++surface) bbox.merge(get_extents(surface->expolygon)); Point legend_size = export_surface_type_legend_to_svg_box_size(); Point legend_pos(bbox.min.x, bbox.max.y); bbox.merge(Point(std::max(bbox.min.x + legend_size.x, bbox.max.x), bbox.max.y + legend_size.y)); SVG svg(path, bbox); const float transparency = 0.5f; for (Surfaces::const_iterator surface = this->slices.surfaces.begin(); surface != this->slices.surfaces.end(); ++surface) svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency); for (Surfaces::const_iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) svg.draw(surface->expolygon.lines(), surface_type_to_color_name(surface->surface_type)); export_surface_type_legend_to_svg(svg, legend_pos); svg.Close(); } // Export to "out/LayerRegion-name-%d.svg" with an increasing index with every export. void LayerRegion::export_region_slices_to_svg_debug(const char *name) { static std::map idx_map; size_t &idx = idx_map[name]; this->export_region_slices_to_svg(debug_out_path("LayerRegion-slices-%s-%d.svg", name, idx ++).c_str()); } void LayerRegion::export_region_fill_surfaces_to_svg(const char *path) { BoundingBox bbox; for (Surfaces::const_iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) bbox.merge(get_extents(surface->expolygon)); Point legend_size = export_surface_type_legend_to_svg_box_size(); Point legend_pos(bbox.min.x, bbox.max.y); bbox.merge(Point(std::max(bbox.min.x + legend_size.x, bbox.max.x), bbox.max.y + legend_size.y)); SVG svg(path, bbox); const float transparency = 0.5f; for (Surfaces::const_iterator surface = this->fill_surfaces.surfaces.begin(); surface != this->fill_surfaces.surfaces.end(); ++surface) { svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency); svg.draw_outline(surface->expolygon, "black", "blue", scale_(0.05)); } export_surface_type_legend_to_svg(svg, legend_pos); svg.Close(); } // Export to "out/LayerRegion-name-%d.svg" with an increasing index with every export. void LayerRegion::export_region_fill_surfaces_to_svg_debug(const char *name) { static std::map idx_map; size_t &idx = idx_map[name]; this->export_region_fill_surfaces_to_svg(debug_out_path("LayerRegion-fill_surfaces-%s-%d.svg", name, idx ++).c_str()); } } Slic3r-version_1.31.6/xs/src/libslic3r/Line.cpp000066400000000000000000000115611301441720000212040ustar00rootroot00000000000000#include "Geometry.hpp" #include "Line.hpp" #include "Polyline.hpp" #include #include #include namespace Slic3r { std::string Line::wkt() const { std::ostringstream ss; ss << "LINESTRING(" << this->a.x << " " << this->a.y << "," << this->b.x << " " << this->b.y << ")"; return ss.str(); } Line::operator Lines() const { Lines lines; lines.push_back(*this); return lines; } Line::operator Polyline() const { Polyline pl; pl.points.push_back(this->a); pl.points.push_back(this->b); return pl; } void Line::scale(double factor) { this->a.scale(factor); this->b.scale(factor); } void Line::translate(double x, double y) { this->a.translate(x, y); this->b.translate(x, y); } void Line::rotate(double angle, const Point ¢er) { this->a.rotate(angle, center); this->b.rotate(angle, center); } void Line::reverse() { std::swap(this->a, this->b); } double Line::length() const { return this->a.distance_to(this->b); } Point Line::midpoint() const { return Point((this->a.x + this->b.x) / 2.0, (this->a.y + this->b.y) / 2.0); } void Line::point_at(double distance, Point* point) const { double len = this->length(); *point = this->a; if (this->a.x != this->b.x) point->x = this->a.x + (this->b.x - this->a.x) * distance / len; if (this->a.y != this->b.y) point->y = this->a.y + (this->b.y - this->a.y) * distance / len; } Point Line::point_at(double distance) const { Point p; this->point_at(distance, &p); return p; } bool Line::intersection_infinite(const Line &other, Point* point) const { Vector x = this->a.vector_to(other.a); Vector d1 = this->vector(); Vector d2 = other.vector(); double cross = d1.x * d2.y - d1.y * d2.x; if (std::fabs(cross) < EPSILON) return false; double t1 = (x.x * d2.y - x.y * d2.x)/cross; point->x = this->a.x + d1.x * t1; point->y = this->a.y + d1.y * t1; return true; } bool Line::coincides_with(const Line &line) const { return this->a.coincides_with(line.a) && this->b.coincides_with(line.b); } double Line::distance_to(const Point &point) const { return point.distance_to(*this); } double Line::atan2_() const { return atan2(this->b.y - this->a.y, this->b.x - this->a.x); } double Line::orientation() const { double angle = this->atan2_(); if (angle < 0) angle = 2*PI + angle; return angle; } double Line::direction() const { double atan2 = this->atan2_(); return (fabs(atan2 - PI) < EPSILON) ? 0 : (atan2 < 0) ? (atan2 + PI) : atan2; } bool Line::parallel_to(double angle) const { return Slic3r::Geometry::directions_parallel(this->direction(), angle); } bool Line::parallel_to(const Line &line) const { return this->parallel_to(line.direction()); } Vector Line::vector() const { return Vector(this->b.x - this->a.x, this->b.y - this->a.y); } Vector Line::normal() const { return Vector((this->b.y - this->a.y), -(this->b.x - this->a.x)); } void Line::extend_end(double distance) { // relocate last point by extending the segment by the specified length Line line = *this; line.reverse(); this->b = line.point_at(-distance); } void Line::extend_start(double distance) { // relocate first point by extending the first segment by the specified length this->a = this->point_at(-distance); } bool Line::intersection(const Line& line, Point* intersection) const { double denom = ((double)(line.b.y - line.a.y)*(this->b.x - this->a.x)) - ((double)(line.b.x - line.a.x)*(this->b.y - this->a.y)); double nume_a = ((double)(line.b.x - line.a.x)*(this->a.y - line.a.y)) - ((double)(line.b.y - line.a.y)*(this->a.x - line.a.x)); double nume_b = ((double)(this->b.x - this->a.x)*(this->a.y - line.a.y)) - ((double)(this->b.y - this->a.y)*(this->a.x - line.a.x)); if (fabs(denom) < EPSILON) { if (fabs(nume_a) < EPSILON && fabs(nume_b) < EPSILON) { return false; // coincident } return false; // parallel } double ua = nume_a / denom; double ub = nume_b / denom; if (ua >= 0 && ua <= 1.0f && ub >= 0 && ub <= 1.0f) { // Get the intersection point. intersection->x = this->a.x + ua*(this->b.x - this->a.x); intersection->y = this->a.y + ua*(this->b.y - this->a.y); return true; } return false; // not intersecting } double Line::ccw(const Point& point) const { return point.ccw(*this); } Pointf3 Linef3::intersect_plane(double z) const { return Pointf3( this->a.x + (this->b.x - this->a.x) * (z - this->a.z) / (this->b.z - this->a.z), this->a.y + (this->b.y - this->a.y) * (z - this->a.z) / (this->b.z - this->a.z), z ); } void Linef3::scale(double factor) { this->a.scale(factor); this->b.scale(factor); } } Slic3r-version_1.31.6/xs/src/libslic3r/Line.hpp000066400000000000000000000045201301441720000212060ustar00rootroot00000000000000#ifndef slic3r_Line_hpp_ #define slic3r_Line_hpp_ #include "libslic3r.h" #include "Point.hpp" namespace Slic3r { class Line; class Linef3; class Polyline; class ThickLine; typedef std::vector Lines; typedef std::vector ThickLines; class Line { public: Point a; Point b; Line() {}; explicit Line(Point _a, Point _b): a(_a), b(_b) {}; std::string wkt() const; operator Lines() const; operator Polyline() const; void scale(double factor); void translate(double x, double y); void rotate(double angle, const Point ¢er); void reverse(); double length() const; Point midpoint() const; void point_at(double distance, Point* point) const; Point point_at(double distance) const; bool intersection_infinite(const Line &other, Point* point) const; bool coincides_with(const Line &line) const; double distance_to(const Point &point) const; bool parallel_to(double angle) const; bool parallel_to(const Line &line) const; double atan2_() const; double orientation() const; double direction() const; Vector vector() const; Vector normal() const; void extend_end(double distance); void extend_start(double distance); bool intersection(const Line& line, Point* intersection) const; double ccw(const Point& point) const; }; class ThickLine : public Line { public: coordf_t a_width, b_width; ThickLine() : a_width(0), b_width(0) {}; ThickLine(Point _a, Point _b) : a_width(0), b_width(0), Line(_a, _b) {}; }; class Linef { public: Pointf a; Pointf b; Linef() {}; explicit Linef(Pointf _a, Pointf _b): a(_a), b(_b) {}; }; class Linef3 { public: Pointf3 a; Pointf3 b; Linef3() {}; explicit Linef3(Pointf3 _a, Pointf3 _b): a(_a), b(_b) {}; Pointf3 intersect_plane(double z) const; void scale(double factor); }; } // start Boost #include namespace boost { namespace polygon { template <> struct geometry_concept { typedef segment_concept type; }; template <> struct segment_traits { typedef coord_t coordinate_type; typedef Point point_type; static inline point_type get(const Line& line, direction_1d dir) { return dir.to_int() ? line.b : line.a; } }; } } // end Boost #endif Slic3r-version_1.31.6/xs/src/libslic3r/Model.cpp000066400000000000000000000614531301441720000213620ustar00rootroot00000000000000#include "Model.hpp" #include "Geometry.hpp" namespace Slic3r { Model::Model() {} Model::Model(const Model &other) { // copy materials for (ModelMaterialMap::const_iterator i = other.materials.begin(); i != other.materials.end(); ++i) this->add_material(i->first, *i->second); // copy objects this->objects.reserve(other.objects.size()); for (ModelObjectPtrs::const_iterator i = other.objects.begin(); i != other.objects.end(); ++i) this->add_object(**i, true); } Model& Model::operator= (Model other) { this->swap(other); return *this; } void Model::swap(Model &other) { std::swap(this->materials, other.materials); std::swap(this->objects, other.objects); } Model::~Model() { this->clear_objects(); this->clear_materials(); } ModelObject* Model::add_object() { ModelObject* new_object = new ModelObject(this); this->objects.push_back(new_object); return new_object; } ModelObject* Model::add_object(const ModelObject &other, bool copy_volumes) { ModelObject* new_object = new ModelObject(this, other, copy_volumes); this->objects.push_back(new_object); return new_object; } void Model::delete_object(size_t idx) { ModelObjectPtrs::iterator i = this->objects.begin() + idx; delete *i; this->objects.erase(i); } void Model::clear_objects() { // int instead of size_t because it can be -1 when vector is empty for (int i = this->objects.size()-1; i >= 0; --i) this->delete_object(i); } void Model::delete_material(t_model_material_id material_id) { ModelMaterialMap::iterator i = this->materials.find(material_id); if (i != this->materials.end()) { delete i->second; this->materials.erase(i); } } void Model::clear_materials() { while (!this->materials.empty()) this->delete_material( this->materials.begin()->first ); } ModelMaterial* Model::add_material(t_model_material_id material_id) { ModelMaterial* material = this->get_material(material_id); if (material == NULL) { material = this->materials[material_id] = new ModelMaterial(this); } return material; } ModelMaterial* Model::add_material(t_model_material_id material_id, const ModelMaterial &other) { // delete existing material if any ModelMaterial* material = this->get_material(material_id); if (material != NULL) { delete material; } // set new material material = new ModelMaterial(this, other); this->materials[material_id] = material; return material; } ModelMaterial* Model::get_material(t_model_material_id material_id) { ModelMaterialMap::iterator i = this->materials.find(material_id); if (i == this->materials.end()) { return NULL; } else { return i->second; } } bool Model::has_objects_with_no_instances() const { for (ModelObjectPtrs::const_iterator i = this->objects.begin(); i != this->objects.end(); ++i) { if ((*i)->instances.empty()) { return true; } } return false; } // makes sure all objects have at least one instance bool Model::add_default_instances() { // apply a default position to all objects not having one for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { if ((*o)->instances.empty()) { (*o)->add_instance(); } } return true; } // this returns the bounding box of the *transformed* instances BoundingBoxf3 Model::bounding_box() const { BoundingBoxf3 bb; for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { bb.merge((*o)->bounding_box()); } return bb; } void Model::center_instances_around_point(const Pointf &point) { BoundingBoxf3 bb = this->bounding_box(); Sizef3 size = bb.size(); coordf_t shift_x = -bb.min.x + point.x - size.x/2; coordf_t shift_y = -bb.min.y + point.y - size.y/2; for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { for (ModelInstancePtrs::const_iterator i = (*o)->instances.begin(); i != (*o)->instances.end(); ++i) { (*i)->offset.translate(shift_x, shift_y); } (*o)->invalidate_bounding_box(); } } void Model::align_instances_to_origin() { BoundingBoxf3 bb = this->bounding_box(); Pointf new_center = (Pointf)bb.size(); new_center.translate(-new_center.x/2, -new_center.y/2); this->center_instances_around_point(new_center); } void Model::translate(coordf_t x, coordf_t y, coordf_t z) { for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { (*o)->translate(x, y, z); } } // flattens everything to a single mesh TriangleMesh Model::mesh() const { TriangleMesh mesh; for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { mesh.merge((*o)->mesh()); } return mesh; } // flattens everything to a single mesh TriangleMesh Model::raw_mesh() const { TriangleMesh mesh; for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { mesh.merge((*o)->raw_mesh()); } return mesh; } bool Model::_arrange(const Pointfs &sizes, coordf_t dist, const BoundingBoxf* bb, Pointfs &out) const { // we supply unscaled data to arrange() return Slic3r::Geometry::arrange( sizes.size(), // number of parts BoundingBoxf(sizes).max, // width and height of a single cell dist, // distance between cells bb, // bounding box of the area to fill out // output positions ); } /* arrange objects preserving their instance count but altering their instance positions */ bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb) { // get the (transformed) size of each instance so that we take // into account their different transformations when packing Pointfs instance_sizes; for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { for (size_t i = 0; i < (*o)->instances.size(); ++i) { instance_sizes.push_back((*o)->instance_bounding_box(i).size()); } } Pointfs positions; if (! this->_arrange(instance_sizes, dist, bb, positions)) return false; for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { for (ModelInstancePtrs::const_iterator i = (*o)->instances.begin(); i != (*o)->instances.end(); ++i) { (*i)->offset = positions.back(); positions.pop_back(); } (*o)->invalidate_bounding_box(); } return true; } /* duplicate the entire model preserving instance relative positions */ void Model::duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb) { Pointfs model_sizes(copies_num-1, this->bounding_box().size()); Pointfs positions; if (! this->_arrange(model_sizes, dist, bb, positions)) CONFESS("Cannot duplicate part as the resulting objects would not fit on the print bed.\n"); // note that this will leave the object count unaltered for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { // make a copy of the pointers in order to avoid recursion when appending their copies ModelInstancePtrs instances = (*o)->instances; for (ModelInstancePtrs::const_iterator i = instances.begin(); i != instances.end(); ++i) { for (Pointfs::const_iterator pos = positions.begin(); pos != positions.end(); ++pos) { ModelInstance* instance = (*o)->add_instance(**i); instance->offset.translate(*pos); } } (*o)->invalidate_bounding_box(); } } /* this will append more instances to each object and then automatically rearrange everything */ void Model::duplicate_objects(size_t copies_num, coordf_t dist, const BoundingBoxf* bb) { for (ModelObjectPtrs::const_iterator o = this->objects.begin(); o != this->objects.end(); ++o) { // make a copy of the pointers in order to avoid recursion when appending their copies ModelInstancePtrs instances = (*o)->instances; for (ModelInstancePtrs::const_iterator i = instances.begin(); i != instances.end(); ++i) { for (size_t k = 2; k <= copies_num; ++k) (*o)->add_instance(**i); } } this->arrange_objects(dist, bb); } void Model::duplicate_objects_grid(size_t x, size_t y, coordf_t dist) { if (this->objects.size() > 1) throw "Grid duplication is not supported with multiple objects"; if (this->objects.empty()) throw "No objects!"; ModelObject* object = this->objects.front(); object->clear_instances(); Sizef3 size = object->bounding_box().size(); for (size_t x_copy = 1; x_copy <= x; ++x_copy) { for (size_t y_copy = 1; y_copy <= y; ++y_copy) { ModelInstance* instance = object->add_instance(); instance->offset.x = (size.x + dist) * (x_copy-1); instance->offset.y = (size.y + dist) * (y_copy-1); } } } ModelMaterial::ModelMaterial(Model *model) : model(model) {} ModelMaterial::ModelMaterial(Model *model, const ModelMaterial &other) : attributes(other.attributes), config(other.config), model(model) {} void ModelMaterial::apply(const t_model_material_attributes &attributes) { this->attributes.insert(attributes.begin(), attributes.end()); } ModelObject::ModelObject(Model *model) : model(model), _bounding_box_valid(false) {} ModelObject::ModelObject(Model *model, const ModelObject &other, bool copy_volumes) : name(other.name), input_file(other.input_file), instances(), volumes(), config(other.config), layer_height_ranges(other.layer_height_ranges), origin_translation(other.origin_translation), _bounding_box(other._bounding_box), _bounding_box_valid(other._bounding_box_valid), model(model) { if (copy_volumes) { this->volumes.reserve(other.volumes.size()); for (ModelVolumePtrs::const_iterator i = other.volumes.begin(); i != other.volumes.end(); ++i) this->add_volume(**i); } this->instances.reserve(other.instances.size()); for (ModelInstancePtrs::const_iterator i = other.instances.begin(); i != other.instances.end(); ++i) this->add_instance(**i); } ModelObject& ModelObject::operator= (ModelObject other) { this->swap(other); return *this; } void ModelObject::swap(ModelObject &other) { std::swap(this->input_file, other.input_file); std::swap(this->instances, other.instances); std::swap(this->volumes, other.volumes); std::swap(this->config, other.config); std::swap(this->layer_height_ranges, other.layer_height_ranges); std::swap(this->origin_translation, other.origin_translation); std::swap(this->_bounding_box, other._bounding_box); std::swap(this->_bounding_box_valid, other._bounding_box_valid); } ModelObject::~ModelObject() { this->clear_volumes(); this->clear_instances(); } ModelVolume* ModelObject::add_volume(const TriangleMesh &mesh) { ModelVolume* v = new ModelVolume(this, mesh); this->volumes.push_back(v); this->invalidate_bounding_box(); return v; } ModelVolume* ModelObject::add_volume(const ModelVolume &other) { ModelVolume* v = new ModelVolume(this, other); this->volumes.push_back(v); this->invalidate_bounding_box(); return v; } void ModelObject::delete_volume(size_t idx) { ModelVolumePtrs::iterator i = this->volumes.begin() + idx; delete *i; this->volumes.erase(i); this->invalidate_bounding_box(); } void ModelObject::clear_volumes() { // int instead of size_t because it can be -1 when vector is empty for (int i = this->volumes.size()-1; i >= 0; --i) this->delete_volume(i); } ModelInstance* ModelObject::add_instance() { ModelInstance* i = new ModelInstance(this); this->instances.push_back(i); this->invalidate_bounding_box(); return i; } ModelInstance* ModelObject::add_instance(const ModelInstance &other) { ModelInstance* i = new ModelInstance(this, other); this->instances.push_back(i); this->invalidate_bounding_box(); return i; } void ModelObject::delete_instance(size_t idx) { ModelInstancePtrs::iterator i = this->instances.begin() + idx; delete *i; this->instances.erase(i); this->invalidate_bounding_box(); } void ModelObject::delete_last_instance() { this->delete_instance(this->instances.size() - 1); } void ModelObject::clear_instances() { for (size_t i = 0; i < this->instances.size(); ++i) this->delete_instance(i); } // this returns the bounding box of the *transformed* instances BoundingBoxf3 ModelObject::bounding_box() { if (!this->_bounding_box_valid) this->update_bounding_box(); return this->_bounding_box; } void ModelObject::invalidate_bounding_box() { this->_bounding_box_valid = false; } void ModelObject::update_bounding_box() { // this->_bounding_box = this->mesh().bounding_box(); BoundingBoxf3 raw_bbox; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { if ((*v)->modifier) continue; raw_bbox.merge((*v)->mesh.bounding_box()); } BoundingBoxf3 bb; for (ModelInstancePtrs::const_iterator i = this->instances.begin(); i != this->instances.end(); ++i) bb.merge((*i)->transform_bounding_box(raw_bbox)); this->_bounding_box = bb; this->_bounding_box_valid = true; } // flattens all volumes and instances into a single mesh TriangleMesh ModelObject::mesh() const { TriangleMesh mesh; TriangleMesh raw_mesh = this->raw_mesh(); for (ModelInstancePtrs::const_iterator i = this->instances.begin(); i != this->instances.end(); ++i) { TriangleMesh m = raw_mesh; (*i)->transform_mesh(&m); mesh.merge(m); } return mesh; } TriangleMesh ModelObject::raw_mesh() const { TriangleMesh mesh; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { if ((*v)->modifier) continue; mesh.merge((*v)->mesh); } return mesh; } BoundingBoxf3 ModelObject::raw_bounding_box() const { BoundingBoxf3 bb; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { if ((*v)->modifier) continue; if (this->instances.empty()) CONFESS("Can't call raw_bounding_box() with no instances"); bb.merge(this->instances.front()->transform_mesh_bounding_box(&(*v)->mesh, true)); } return bb; } // this returns the bounding box of the *transformed* given instance BoundingBoxf3 ModelObject::instance_bounding_box(size_t instance_idx) const { BoundingBoxf3 bb; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { if ((*v)->modifier) continue; bb.merge(this->instances[instance_idx]->transform_mesh_bounding_box(&(*v)->mesh, true)); } return bb; } void ModelObject::center_around_origin() { // calculate the displacements needed to // center this object around the origin BoundingBoxf3 bb; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) if (! (*v)->modifier) bb.merge((*v)->mesh.bounding_box()); // first align to origin on XYZ Vectorf3 vector(-bb.min.x, -bb.min.y, -bb.min.z); // then center it on XY Sizef3 size = bb.size(); vector.x -= size.x/2; vector.y -= size.y/2; this->translate(vector); this->origin_translation.translate(vector); if (!this->instances.empty()) { for (ModelInstancePtrs::const_iterator i = this->instances.begin(); i != this->instances.end(); ++i) { // apply rotation and scaling to vector as well before translating instance, // in order to leave final position unaltered Vectorf3 v = vector.negative(); v.rotate((*i)->rotation, (*i)->offset); v.scale((*i)->scaling_factor); (*i)->offset.translate(v.x, v.y); } this->invalidate_bounding_box(); } } void ModelObject::translate(const Vectorf3 &vector) { this->translate(vector.x, vector.y, vector.z); } void ModelObject::translate(coordf_t x, coordf_t y, coordf_t z) { for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { (*v)->mesh.translate(x, y, z); } if (this->_bounding_box_valid) this->_bounding_box.translate(x, y, z); } void ModelObject::scale(const Pointf3 &versor) { for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { (*v)->mesh.scale(versor); } // reset origin translation since it doesn't make sense anymore this->origin_translation = Pointf3(0,0,0); this->invalidate_bounding_box(); } void ModelObject::rotate(float angle, const Axis &axis) { for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { (*v)->mesh.rotate(angle, axis); } this->origin_translation = Pointf3(0,0,0); this->invalidate_bounding_box(); } void ModelObject::mirror(const Axis &axis) { for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { (*v)->mesh.mirror(axis); } this->origin_translation = Pointf3(0,0,0); this->invalidate_bounding_box(); } size_t ModelObject::materials_count() const { std::set material_ids; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { material_ids.insert((*v)->material_id()); } return material_ids.size(); } size_t ModelObject::facets_count() const { size_t num = 0; for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { if ((*v)->modifier) continue; num += (*v)->mesh.stl.stats.number_of_facets; } return num; } bool ModelObject::needed_repair() const { for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { if ((*v)->modifier) continue; if ((*v)->mesh.needed_repair()) return true; } return false; } void ModelObject::cut(coordf_t z, Model* model) const { // clone this one to duplicate instances, materials etc. ModelObject* upper = model->add_object(*this); ModelObject* lower = model->add_object(*this); upper->clear_volumes(); lower->clear_volumes(); for (ModelVolumePtrs::const_iterator v = this->volumes.begin(); v != this->volumes.end(); ++v) { ModelVolume* volume = *v; if (volume->modifier) { // don't cut modifiers upper->add_volume(*volume); lower->add_volume(*volume); } else { TriangleMeshSlicer tms(&volume->mesh); TriangleMesh upper_mesh, lower_mesh; // TODO: shouldn't we use object bounding box instead of per-volume bb? tms.cut(z + volume->mesh.bounding_box().min.z, &upper_mesh, &lower_mesh); upper_mesh.repair(); lower_mesh.repair(); upper_mesh.reset_repair_stats(); lower_mesh.reset_repair_stats(); if (upper_mesh.facets_count() > 0) { ModelVolume* vol = upper->add_volume(upper_mesh); vol->name = volume->name; vol->config = volume->config; vol->set_material(volume->material_id(), *volume->material()); } if (lower_mesh.facets_count() > 0) { ModelVolume* vol = lower->add_volume(lower_mesh); vol->name = volume->name; vol->config = volume->config; vol->set_material(volume->material_id(), *volume->material()); } } } } void ModelObject::split(ModelObjectPtrs* new_objects) { if (this->volumes.size() > 1) { // We can't split meshes if there's more than one volume, because // we can't group the resulting meshes by object afterwards new_objects->push_back(this); return; } ModelVolume* volume = this->volumes.front(); TriangleMeshPtrs meshptrs = volume->mesh.split(); for (TriangleMeshPtrs::iterator mesh = meshptrs.begin(); mesh != meshptrs.end(); ++mesh) { (*mesh)->repair(); ModelObject* new_object = this->model->add_object(*this, false); ModelVolume* new_volume = new_object->add_volume(**mesh); new_volume->name = volume->name; new_volume->config = volume->config; new_volume->modifier = volume->modifier; new_volume->material_id(volume->material_id()); new_objects->push_back(new_object); delete *mesh; } return; } ModelVolume::ModelVolume(ModelObject* object, const TriangleMesh &mesh) : mesh(mesh), modifier(false), object(object) {} ModelVolume::ModelVolume(ModelObject* object, const ModelVolume &other) : name(other.name), mesh(other.mesh), config(other.config), modifier(other.modifier), object(object) { this->material_id(other.material_id()); } t_model_material_id ModelVolume::material_id() const { return this->_material_id; } void ModelVolume::material_id(t_model_material_id material_id) { this->_material_id = material_id; // ensure this->_material_id references an existing material (void)this->object->get_model()->add_material(material_id); } ModelMaterial* ModelVolume::material() const { return this->object->get_model()->get_material(this->_material_id); } void ModelVolume::set_material(t_model_material_id material_id, const ModelMaterial &material) { this->_material_id = material_id; (void)this->object->get_model()->add_material(material_id, material); } ModelMaterial* ModelVolume::assign_unique_material() { Model* model = this->get_object()->get_model(); // as material-id "0" is reserved by the AMF spec we start from 1 this->_material_id = 1 + model->materials.size(); // watchout for implicit cast return model->add_material(this->_material_id); } ModelInstance::ModelInstance(ModelObject *object) : rotation(0), scaling_factor(1), object(object) {} ModelInstance::ModelInstance(ModelObject *object, const ModelInstance &other) : rotation(other.rotation), scaling_factor(other.scaling_factor), offset(other.offset), object(object) {} void ModelInstance::transform_mesh(TriangleMesh* mesh, bool dont_translate) const { mesh->rotate_z(this->rotation); // rotate around mesh origin mesh->scale(this->scaling_factor); // scale around mesh origin if (!dont_translate) mesh->translate(this->offset.x, this->offset.y, 0); } BoundingBoxf3 ModelInstance::transform_mesh_bounding_box(const TriangleMesh* mesh, bool dont_translate) const { // rotate around mesh origin double c = cos(this->rotation); double s = sin(this->rotation); BoundingBoxf3 bbox; for (int i = 0; i < mesh->stl.stats.number_of_facets; ++ i) { const stl_facet &facet = mesh->stl.facet_start[i]; for (int j = 0; j < 3; ++ j) { stl_vertex v = facet.vertex[j]; double xold = v.x; double yold = v.y; v.x = float(c * xold - s * yold); v.y = float(s * xold + c * yold); v.x *= float(this->scaling_factor); v.y *= float(this->scaling_factor); v.z *= float(this->scaling_factor); if (!dont_translate) { v.x += this->offset.x; v.y += this->offset.y; } bbox.merge(Pointf3(v.x, v.y, v.z)); } } return bbox; } BoundingBoxf3 ModelInstance::transform_bounding_box(const BoundingBoxf3 &bbox, bool dont_translate) const { // rotate around mesh origin double c = cos(this->rotation); double s = sin(this->rotation); Pointf3 pts[4] = { bbox.min, bbox.max, Pointf3(bbox.min.x, bbox.max.y, bbox.min.z), Pointf3(bbox.max.x, bbox.min.y, bbox.max.z) }; BoundingBoxf3 out; for (int i = 0; i < 4; ++ i) { Pointf3 &v = pts[i]; double xold = v.x; double yold = v.y; v.x = float(c * xold - s * yold); v.y = float(s * xold + c * yold); v.x *= this->scaling_factor; v.y *= this->scaling_factor; v.z *= this->scaling_factor; if (!dont_translate) { v.x += this->offset.x; v.y += this->offset.y; } out.merge(v); } return out; } void ModelInstance::transform_polygon(Polygon* polygon) const { polygon->rotate(this->rotation); // rotate around polygon origin polygon->scale(this->scaling_factor); // scale around polygon origin } } Slic3r-version_1.31.6/xs/src/libslic3r/Model.hpp000066400000000000000000000220431301441720000213570ustar00rootroot00000000000000#ifndef slic3r_Model_hpp_ #define slic3r_Model_hpp_ #include "libslic3r.h" #include "PrintConfig.hpp" #include "Layer.hpp" #include "Point.hpp" #include "TriangleMesh.hpp" #include #include #include #include namespace Slic3r { class ModelInstance; class ModelMaterial; class ModelObject; class ModelVolume; typedef std::string t_model_material_id; typedef std::string t_model_material_attribute; typedef std::map t_model_material_attributes; typedef std::map ModelMaterialMap; typedef std::vector ModelObjectPtrs; typedef std::vector ModelVolumePtrs; typedef std::vector ModelInstancePtrs; // The print bed content. // Description of a triangular model with multiple materials, multiple instances with various affine transformations // and with multiple modifier meshes. // A model groups multiple objects, each object having possibly multiple instances, // all objects may share mutliple materials. class Model { public: // Materials are owned by a model and referenced by objects through t_model_material_id. // Single material may be shared by multiple models. ModelMaterialMap materials; // Objects are owned by a model. Each model may have multiple instances, each instance having its own transformation (shift, scale, rotation). ModelObjectPtrs objects; Model(); Model(const Model &other); Model& operator= (Model other); void swap(Model &other); ~Model(); ModelObject* add_object(); ModelObject* add_object(const ModelObject &other, bool copy_volumes = true); void delete_object(size_t idx); void clear_objects(); ModelMaterial* add_material(t_model_material_id material_id); ModelMaterial* add_material(t_model_material_id material_id, const ModelMaterial &other); ModelMaterial* get_material(t_model_material_id material_id); void delete_material(t_model_material_id material_id); void clear_materials(); bool has_objects_with_no_instances() const; bool add_default_instances(); BoundingBoxf3 bounding_box() const; void center_instances_around_point(const Pointf &point); void align_instances_to_origin(); void translate(coordf_t x, coordf_t y, coordf_t z); TriangleMesh mesh() const; TriangleMesh raw_mesh() const; bool _arrange(const Pointfs &sizes, coordf_t dist, const BoundingBoxf* bb, Pointfs &out) const; bool arrange_objects(coordf_t dist, const BoundingBoxf* bb = NULL); // Croaks if the duplicated objects do not fit the print bed. void duplicate(size_t copies_num, coordf_t dist, const BoundingBoxf* bb = NULL); void duplicate_objects(size_t copies_num, coordf_t dist, const BoundingBoxf* bb = NULL); void duplicate_objects_grid(size_t x, size_t y, coordf_t dist); }; // Material, which may be shared across multiple ModelObjects of a single Model. class ModelMaterial { friend class Model; public: // Attributes are defined by the AMF file format, but they don't seem to be used by Slic3r for any purpose. t_model_material_attributes attributes; // Dynamic configuration storage for the object specific configuration values, overriding the global configuration. DynamicPrintConfig config; Model* get_model() const { return this->model; }; void apply(const t_model_material_attributes &attributes); private: // Parent, owning this material. Model* model; ModelMaterial(Model *model); ModelMaterial(Model *model, const ModelMaterial &other); }; // A printable object, possibly having multiple print volumes (each with its own set of parameters and materials), // and possibly having multiple modifier volumes, each modifier volume with its set of parameters and materials. // Each ModelObject may be instantiated mutliple times, each instance having different placement on the print bed, // different rotation and different uniform scaling. class ModelObject { friend class Model; public: std::string name; std::string input_file; // Instances of this ModelObject. Each instance defines a shift on the print bed, rotation around the Z axis and a uniform scaling. // Instances are owned by this ModelObject. ModelInstancePtrs instances; // Printable and modifier volumes, each with its material ID and a set of override parameters. // ModelVolumes are owned by this ModelObject. ModelVolumePtrs volumes; // Configuration parameters specific to a single ModelObject, overriding the global Slic3r settings. DynamicPrintConfig config; // Variation of a layer thickness for spans of Z coordinates. t_layer_height_ranges layer_height_ranges; /* This vector accumulates the total translation applied to the object by the center_around_origin() method. Callers might want to apply the same translation to new volumes before adding them to this object in order to preserve alignment when user expects that. */ Pointf3 origin_translation; // these should be private but we need to expose them via XS until all methods are ported BoundingBoxf3 _bounding_box; bool _bounding_box_valid; Model* get_model() const { return this->model; }; ModelVolume* add_volume(const TriangleMesh &mesh); ModelVolume* add_volume(const ModelVolume &volume); void delete_volume(size_t idx); void clear_volumes(); ModelInstance* add_instance(); ModelInstance* add_instance(const ModelInstance &instance); void delete_instance(size_t idx); void delete_last_instance(); void clear_instances(); BoundingBoxf3 bounding_box(); void invalidate_bounding_box(); TriangleMesh mesh() const; TriangleMesh raw_mesh() const; BoundingBoxf3 raw_bounding_box() const; BoundingBoxf3 instance_bounding_box(size_t instance_idx) const; void center_around_origin(); void translate(const Vectorf3 &vector); void translate(coordf_t x, coordf_t y, coordf_t z); void scale(const Pointf3 &versor); void rotate(float angle, const Axis &axis); void mirror(const Axis &axis); size_t materials_count() const; size_t facets_count() const; bool needed_repair() const; void cut(coordf_t z, Model* model) const; void split(ModelObjectPtrs* new_objects); void update_bounding_box(); // this is a private method but we expose it until we need to expose it via XS private: // Parent object, owning this ModelObject. Model* model; ModelObject(Model *model); ModelObject(Model *model, const ModelObject &other, bool copy_volumes = true); ModelObject& operator= (ModelObject other); void swap(ModelObject &other); ~ModelObject(); }; // An object STL, or a modifier volume, over which a different set of parameters shall be applied. // ModelVolume instances are owned by a ModelObject. class ModelVolume { friend class ModelObject; public: std::string name; // The triangular model. TriangleMesh mesh; // Configuration parameters specific to an object model geometry or a modifier volume, // overriding the global Slic3r settings and the ModelObject settings. DynamicPrintConfig config; // Is it an object to be printed, or a modifier volume? bool modifier; // A parent object owning this modifier volume. ModelObject* get_object() const { return this->object; }; t_model_material_id material_id() const; void material_id(t_model_material_id material_id); ModelMaterial* material() const; void set_material(t_model_material_id material_id, const ModelMaterial &material); ModelMaterial* assign_unique_material(); private: // Parent object owning this ModelVolume. ModelObject* object; t_model_material_id _material_id; ModelVolume(ModelObject *object, const TriangleMesh &mesh); ModelVolume(ModelObject *object, const ModelVolume &other); }; // A single instance of a ModelObject. // Knows the affine transformation of an object. class ModelInstance { friend class ModelObject; public: double rotation; // Rotation around the Z axis, in radians around mesh center point double scaling_factor; Pointf offset; // in unscaled coordinates ModelObject* get_object() const { return this->object; }; // To be called on an external mesh void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const; // Calculate a bounding box of a transformed mesh. To be called on an external mesh. BoundingBoxf3 transform_mesh_bounding_box(const TriangleMesh* mesh, bool dont_translate = false) const; // Transform an external bounding box. BoundingBoxf3 transform_bounding_box(const BoundingBoxf3 &bbox, bool dont_translate = false) const; // To be called on an external polygon. It does not translate the polygon, only rotates and scales. void transform_polygon(Polygon* polygon) const; private: // Parent object, owning this instance. ModelObject* object; ModelInstance(ModelObject *object); ModelInstance(ModelObject *object, const ModelInstance &other); }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/MotionPlanner.cpp000066400000000000000000000366131301441720000231070ustar00rootroot00000000000000#include "BoundingBox.hpp" #include "MotionPlanner.hpp" #include // for numeric_limits #include #include "boost/polygon/voronoi.hpp" using boost::polygon::voronoi_builder; using boost::polygon::voronoi_diagram; namespace Slic3r { MotionPlanner::MotionPlanner(const ExPolygons &islands) : initialized(false) { ExPolygons expp; for (ExPolygons::const_iterator island = islands.begin(); island != islands.end(); ++island) island->simplify(SCALED_EPSILON, &expp); for (ExPolygons::const_iterator island = expp.begin(); island != expp.end(); ++island) this->islands.push_back(MotionPlannerEnv(*island)); } MotionPlanner::~MotionPlanner() { for (std::vector::iterator graph = this->graphs.begin(); graph != this->graphs.end(); ++graph) delete *graph; } size_t MotionPlanner::islands_count() const { return this->islands.size(); } void MotionPlanner::initialize() { if (this->initialized) return; if (this->islands.empty()) return; // prevent initialization of empty BoundingBox // loop through islands in order to create inner expolygons and collect their contours Polygons outer_holes; for (std::vector::iterator island = this->islands.begin(); island != this->islands.end(); ++island) { // generate the internal env boundaries by shrinking the island // we'll use these inner rings for motion planning (endpoints of the Voronoi-based // graph, visibility check) in order to avoid moving too close to the boundaries island->env = offset_ex(island->island, -MP_INNER_MARGIN); // island contours are holes of our external environment outer_holes.push_back(island->island.contour); } // generate outer contour as bounding box of everything BoundingBox bb; for (Polygons::const_iterator contour = outer_holes.begin(); contour != outer_holes.end(); ++contour) bb.merge(contour->bounding_box()); // grow outer contour Polygons contour = offset(bb.polygon(), +MP_OUTER_MARGIN*2); assert(contour.size() == 1); // make expolygon for outer environment ExPolygons outer = diff_ex(contour, outer_holes); assert(outer.size() == 1); this->outer.island = outer.front(); this->outer.env = ExPolygonCollection(diff_ex(contour, offset(outer_holes, +MP_OUTER_MARGIN))); this->graphs.resize(this->islands.size() + 1, NULL); this->initialized = true; } const MotionPlannerEnv& MotionPlanner::get_env(int island_idx) const { if (island_idx == -1) { return this->outer; } else { return this->islands[island_idx]; } } Polyline MotionPlanner::shortest_path(const Point &from, const Point &to) { // if we have an empty configuration space, return a straight move if (this->islands.empty()) return Line(from, to); // Are both points in the same island? int island_idx = -1; for (std::vector::const_iterator island = this->islands.begin(); island != this->islands.end(); ++island) { if (island->island.contains(from) && island->island.contains(to)) { // since both points are in the same island, is a direct move possible? // if so, we avoid generating the visibility environment if (island->island.contains(Line(from, to))) return Line(from, to); island_idx = island - this->islands.begin(); break; } } // lazy generation of configuration space this->initialize(); // get environment MotionPlannerEnv env = this->get_env(island_idx); if (env.env.expolygons.empty()) { // if this environment is empty (probably because it's too small), perform straight move // and avoid running the algorithms on empty dataset return Line(from, to); } // Now check whether points are inside the environment. Point inner_from = from; Point inner_to = to; if (island_idx == -1) { // TODO: instead of using the nearest_env_point() logic, we should // create a temporary graph where we connect 'from' and 'to' to the // nodes which don't require more than one crossing, and let Dijkstra // figure out the entire path - this should also replace the call to // find_node() below if (!env.island.contains(inner_from)) { // Find the closest inner point to start from. inner_from = env.nearest_env_point(from, to); } if (!env.island.contains(inner_to)) { // Find the closest inner point to start from. inner_to = env.nearest_env_point(to, inner_from); } } // perform actual path search MotionPlannerGraph* graph = this->init_graph(island_idx); Polyline polyline = graph->shortest_path(graph->find_node(inner_from), graph->find_node(inner_to)); polyline.points.insert(polyline.points.begin(), from); polyline.points.push_back(to); { // grow our environment slightly in order for simplify_by_visibility() // to work best by considering moves on boundaries valid as well ExPolygonCollection grown_env(offset_ex(env.env, +SCALED_EPSILON)); if (island_idx == -1) { /* If 'from' or 'to' are not inside our env, they were connected using the nearest_env_point() search which maybe produce ugly paths since it does not include the endpoint in the Dijkstra search; the simplify_by_visibility() call below will not work in many cases where the endpoint is not contained in grown_env (whose contour was arbitrarily constructed with MP_OUTER_MARGIN, which may not be enough for, say, including a skirt point). So we prune the extra points manually. */ if (!grown_env.contains(from)) { // delete second point while the line connecting first to third crosses the // boundaries as many times as the current first to second while (polyline.points.size() > 2 && intersection((Lines)Line(from, polyline.points[2]), grown_env).size() == 1) { polyline.points.erase(polyline.points.begin() + 1); } } if (!grown_env.contains(to)) { while (polyline.points.size() > 2 && intersection((Lines)Line(*(polyline.points.end() - 3), to), grown_env).size() == 1) { polyline.points.erase(polyline.points.end() - 2); } } } // remove unnecessary vertices // Note: this is computationally intensive and does not look very necessary // now that we prune the endpoints with the logic above, // so we comment it for now until a good test case arises //polyline.simplify_by_visibility(grown_env); /* SVG svg("shortest_path.svg"); svg.draw(grown_env.expolygons); svg.arrows = false; for (MotionPlannerGraph::adjacency_list_t::const_iterator it = graph->adjacency_list.begin(); it != graph->adjacency_list.end(); ++it) { Point a = graph->nodes[it - graph->adjacency_list.begin()]; for (std::vector::const_iterator n = it->begin(); n != it->end(); ++n) { Point b = graph->nodes[n->target]; svg.draw(Line(a, b)); } } svg.arrows = true; svg.draw(from); svg.draw(inner_from, "red"); svg.draw(to); svg.draw(inner_to, "red"); svg.draw(polyline, "red"); svg.Close(); */ } return polyline; } MotionPlannerGraph* MotionPlanner::init_graph(int island_idx) { if (this->graphs[island_idx + 1] == NULL) { // if this graph doesn't exist, initialize it MotionPlannerGraph* graph = this->graphs[island_idx + 1] = new MotionPlannerGraph(); /* We don't add polygon boundaries as graph edges, because we'd need to connect them to the Voronoi-generated edges by recognizing coinciding nodes. */ typedef voronoi_diagram VD; VD vd; // mapping between Voronoi vertices and graph nodes typedef std::map t_vd_vertices; t_vd_vertices vd_vertices; // get boundaries as lines MotionPlannerEnv env = this->get_env(island_idx); Lines lines = env.env.lines(); boost::polygon::construct_voronoi(lines.begin(), lines.end(), &vd); // traverse the Voronoi diagram and generate graph nodes and edges for (VD::const_edge_iterator edge = vd.edges().begin(); edge != vd.edges().end(); ++edge) { if (edge->is_infinite()) continue; const VD::vertex_type* v0 = edge->vertex0(); const VD::vertex_type* v1 = edge->vertex1(); Point p0 = Point(v0->x(), v0->y()); Point p1 = Point(v1->x(), v1->y()); // skip edge if any of its endpoints is outside our configuration space if (!env.island.contains_b(p0) || !env.island.contains_b(p1)) continue; t_vd_vertices::const_iterator i_v0 = vd_vertices.find(v0); size_t v0_idx; if (i_v0 == vd_vertices.end()) { graph->nodes.push_back(p0); vd_vertices[v0] = v0_idx = graph->nodes.size()-1; } else { v0_idx = i_v0->second; } t_vd_vertices::const_iterator i_v1 = vd_vertices.find(v1); size_t v1_idx; if (i_v1 == vd_vertices.end()) { graph->nodes.push_back(p1); vd_vertices[v1] = v1_idx = graph->nodes.size()-1; } else { v1_idx = i_v1->second; } // Euclidean distance is used as weight for the graph edge double dist = graph->nodes[v0_idx].distance_to(graph->nodes[v1_idx]); graph->add_edge(v0_idx, v1_idx, dist); } return graph; } return this->graphs[island_idx + 1]; } Point MotionPlannerEnv::nearest_env_point(const Point &from, const Point &to) const { /* In order to ensure that the move between 'from' and the initial env point does not violate any of the configuration space boundaries, we limit our search to the points that satisfy this condition. */ /* Assume that this method is never called when 'env' contains 'from'; so 'from' is either inside a hole or outside all contours */ // get the points of the hole containing 'from', if any Points pp; for (ExPolygons::const_iterator ex = this->env.expolygons.begin(); ex != this->env.expolygons.end(); ++ex) { for (Polygons::const_iterator h = ex->holes.begin(); h != ex->holes.end(); ++h) { if (h->contains(from)) { pp = *h; } } if (!pp.empty()) break; } /* If 'from' is not inside a hole, it's outside of all contours, so take all contours' points */ if (pp.empty()) { for (ExPolygons::const_iterator ex = this->env.expolygons.begin(); ex != this->env.expolygons.end(); ++ex) { Points contour_pp = ex->contour; pp.insert(pp.end(), contour_pp.begin(), contour_pp.end()); } } /* Find the candidate result and check that it doesn't cross too many boundaries. */ while (pp.size() >= 2) { // find the point in pp that is closest to both 'from' and 'to' size_t result = from.nearest_waypoint_index(pp, to); // as we assume 'from' is outside env, any node will require at least one crossing if (intersection((Lines)Line(from, pp[result]), this->island).size() > 1) { // discard result pp.erase(pp.begin() + result); } else { return pp[result]; } } // if we're here, return last point if any (better than nothing) if (!pp.empty()) { return pp.front(); } // if we have no points at all, then we have an empty environment and we // make this method behave as a no-op (we shouldn't get here by the way) return from; } void MotionPlannerGraph::add_edge(size_t from, size_t to, double weight) { // extend adjacency list until this start node if (this->adjacency_list.size() < from+1) this->adjacency_list.resize(from+1); this->adjacency_list[from].push_back(neighbor(to, weight)); } size_t MotionPlannerGraph::find_node(const Point &point) const { /* for (Points::const_iterator p = this->nodes.begin(); p != this->nodes.end(); ++p) { if (p->coincides_with(point)) return p - this->nodes.begin(); } */ return point.nearest_point_index(this->nodes); } Polyline MotionPlannerGraph::shortest_path(size_t from, size_t to) { // this prevents a crash in case for some reason we got here with an empty adjacency list if (this->adjacency_list.empty()) return Polyline(); const weight_t max_weight = std::numeric_limits::infinity(); std::vector dist; std::vector previous; { // number of nodes size_t n = this->adjacency_list.size(); // initialize dist and previous dist.clear(); dist.resize(n, max_weight); dist[from] = 0; // distance from 'from' to itself previous.clear(); previous.resize(n, -1); // initialize the Q with all nodes std::set Q; for (node_t i = 0; i < n; ++i) Q.insert(i); while (!Q.empty()) { // get node in Q having the minimum dist ('from' in the first loop) node_t u; { double min_dist = -1; for (std::set::const_iterator n = Q.begin(); n != Q.end(); ++n) { if (dist[*n] < min_dist || min_dist == -1) { u = *n; min_dist = dist[*n]; } } } Q.erase(u); // stop searching if we reached our destination if (u == to) break; // Visit each edge starting from node u const std::vector &neighbors = this->adjacency_list[u]; for (std::vector::const_iterator neighbor_iter = neighbors.begin(); neighbor_iter != neighbors.end(); ++neighbor_iter) { // neighbor node is v node_t v = neighbor_iter->target; // skip if we already visited this if (Q.find(v) == Q.end()) continue; // calculate total distance weight_t alt = dist[u] + neighbor_iter->weight; // if total distance through u is shorter than the previous // distance (if any) between 'from' and 'v', replace it if (alt < dist[v]) { dist[v] = alt; previous[v] = u; } } } } Polyline polyline; for (node_t vertex = to; vertex != -1; vertex = previous[vertex]) polyline.points.push_back(this->nodes[vertex]); polyline.points.push_back(this->nodes[from]); polyline.reverse(); return polyline; } } Slic3r-version_1.31.6/xs/src/libslic3r/MotionPlanner.hpp000066400000000000000000000034441301441720000231100ustar00rootroot00000000000000#ifndef slic3r_MotionPlanner_hpp_ #define slic3r_MotionPlanner_hpp_ #include "libslic3r.h" #include "ClipperUtils.hpp" #include "ExPolygonCollection.hpp" #include "Polyline.hpp" #include #include #include #define MP_INNER_MARGIN scale_(1.0) #define MP_OUTER_MARGIN scale_(2.0) namespace Slic3r { class MotionPlanner; class MotionPlannerEnv { friend class MotionPlanner; public: ExPolygon island; ExPolygonCollection env; MotionPlannerEnv() {}; MotionPlannerEnv(const ExPolygon &island) : island(island) {}; Point nearest_env_point(const Point &from, const Point &to) const; }; class MotionPlannerGraph { friend class MotionPlanner; private: typedef int node_t; typedef double weight_t; struct neighbor { node_t target; weight_t weight; neighbor(node_t arg_target, weight_t arg_weight) : target(arg_target), weight(arg_weight) { } }; typedef std::vector< std::vector > adjacency_list_t; adjacency_list_t adjacency_list; public: Points nodes; //std::map, double> edges; void add_edge(size_t from, size_t to, double weight); size_t find_node(const Point &point) const; Polyline shortest_path(size_t from, size_t to); }; class MotionPlanner { public: MotionPlanner(const ExPolygons &islands); ~MotionPlanner(); Polyline shortest_path(const Point &from, const Point &to); size_t islands_count() const; private: bool initialized; std::vector islands; MotionPlannerEnv outer; std::vector graphs; void initialize(); MotionPlannerGraph* init_graph(int island_idx); const MotionPlannerEnv& get_env(int island_idx) const; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/MultiPoint.cpp000066400000000000000000000145701301441720000224240ustar00rootroot00000000000000#include "MultiPoint.hpp" #include "BoundingBox.hpp" namespace Slic3r { MultiPoint::operator Points() const { return this->points; } void MultiPoint::scale(double factor) { for (Points::iterator it = points.begin(); it != points.end(); ++it) { (*it).scale(factor); } } void MultiPoint::translate(double x, double y) { for (Points::iterator it = points.begin(); it != points.end(); ++it) { (*it).translate(x, y); } } void MultiPoint::translate(const Point &vector) { this->translate(vector.x, vector.y); } void MultiPoint::rotate(double angle) { double s = sin(angle); double c = cos(angle); for (Points::iterator it = points.begin(); it != points.end(); ++it) { double cur_x = (double)it->x; double cur_y = (double)it->y; it->x = (coord_t)round(c * cur_x - s * cur_y); it->y = (coord_t)round(c * cur_y + s * cur_x); } } void MultiPoint::rotate(double angle, const Point ¢er) { double s = sin(angle); double c = cos(angle); for (Points::iterator it = points.begin(); it != points.end(); ++it) { double dx = double(it->x - center.x); double dy = double(it->y - center.y); it->x = (coord_t)round(double(center.x) + c * dx - s * dy); it->y = (coord_t)round(double(center.y) + c * dy + s * dx); } } void MultiPoint::reverse() { std::reverse(this->points.begin(), this->points.end()); } Point MultiPoint::first_point() const { return this->points.front(); } double MultiPoint::length() const { Lines lines = this->lines(); double len = 0; for (Lines::iterator it = lines.begin(); it != lines.end(); ++it) { len += it->length(); } return len; } int MultiPoint::find_point(const Point &point) const { for (Points::const_iterator it = this->points.begin(); it != this->points.end(); ++it) { if (it->coincides_with(point)) return it - this->points.begin(); } return -1; // not found } bool MultiPoint::has_boundary_point(const Point &point) const { double dist = point.distance_to(point.projection_onto(*this)); return dist < SCALED_EPSILON; } BoundingBox MultiPoint::bounding_box() const { return BoundingBox(this->points); } bool MultiPoint::has_duplicate_points() const { for (size_t i = 1; i < points.size(); ++i) if (points[i-1].coincides_with(points[i])) return true; return false; } bool MultiPoint::remove_duplicate_points() { size_t j = 0; for (size_t i = 1; i < points.size(); ++i) { if (points[j].coincides_with(points[i])) { // Just increase index i. } else { ++ j; if (j < i) points[j] = points[i]; } } if (++ j < points.size()) { points.erase(points.begin() + j, points.end()); return true; } return false; } void MultiPoint::append(const Point &point) { this->points.push_back(point); } void MultiPoint::append(const Points &points) { this->append(points.begin(), points.end()); } void MultiPoint::append(const Points::const_iterator &begin, const Points::const_iterator &end) { this->points.insert(this->points.end(), begin, end); } bool MultiPoint::intersection(const Line& line, Point* intersection) const { Lines lines = this->lines(); for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++it) { if (it->intersection(line, intersection)) return true; } return false; } std::string MultiPoint::dump_perl() const { std::ostringstream ret; ret << "["; for (Points::const_iterator p = this->points.begin(); p != this->points.end(); ++p) { ret << p->dump_perl(); if (p != this->points.end()-1) ret << ","; } ret << "]"; return ret.str(); } //FIXME This is very inefficient in term of memory use. // The recursive algorithm shall run in place, not allocating temporary data in each recursion. Points MultiPoint::_douglas_peucker(const Points &points, const double tolerance) { assert(points.size() >= 2); Points results; double dmax = 0; size_t index = 0; Line full(points.front(), points.back()); for (Points::const_iterator it = points.begin() + 1; it != points.end(); ++it) { // we use shortest distance, not perpendicular distance double d = it->distance_to(full); if (d > dmax) { index = it - points.begin(); dmax = d; } } if (dmax >= tolerance) { Points dp0; dp0.reserve(index + 1); dp0.insert(dp0.end(), points.begin(), points.begin() + index + 1); // Recursive call. Points dp1 = MultiPoint::_douglas_peucker(dp0, tolerance); results.reserve(results.size() + dp1.size() - 1); results.insert(results.end(), dp1.begin(), dp1.end() - 1); dp0.clear(); dp0.reserve(points.size() - index); dp0.insert(dp0.end(), points.begin() + index, points.end()); // Recursive call. dp1 = MultiPoint::_douglas_peucker(dp0, tolerance); results.reserve(results.size() + dp1.size()); results.insert(results.end(), dp1.begin(), dp1.end()); } else { results.push_back(points.front()); results.push_back(points.back()); } return results; } BoundingBox get_extents(const MultiPoint &mp) { return BoundingBox(mp.points); } BoundingBox get_extents_rotated(const Points &points, double angle) { BoundingBox bbox; if (! points.empty()) { double s = sin(angle); double c = cos(angle); Points::const_iterator it = points.begin(); double cur_x = (double)it->x; double cur_y = (double)it->y; bbox.min.x = bbox.max.x = (coord_t)round(c * cur_x - s * cur_y); bbox.min.y = bbox.max.y = (coord_t)round(c * cur_y + s * cur_x); for (++it; it != points.end(); ++it) { double cur_x = (double)it->x; double cur_y = (double)it->y; coord_t x = (coord_t)round(c * cur_x - s * cur_y); coord_t y = (coord_t)round(c * cur_y + s * cur_x); bbox.min.x = std::min(x, bbox.min.x); bbox.min.y = std::min(y, bbox.min.y); bbox.max.x = std::max(x, bbox.max.x); bbox.max.y = std::max(y, bbox.max.y); } bbox.defined = true; } return bbox; } BoundingBox get_extents_rotated(const MultiPoint &mp, double angle) { return get_extents_rotated(mp.points, angle); } } Slic3r-version_1.31.6/xs/src/libslic3r/MultiPoint.hpp000066400000000000000000000033231301441720000224230ustar00rootroot00000000000000#ifndef slic3r_MultiPoint_hpp_ #define slic3r_MultiPoint_hpp_ #include "libslic3r.h" #include #include #include "Line.hpp" #include "Point.hpp" namespace Slic3r { class BoundingBox; class MultiPoint { public: Points points; operator Points() const; MultiPoint() {}; explicit MultiPoint(const Points &_points): points(_points) {}; void scale(double factor); void translate(double x, double y); void translate(const Point &vector); void rotate(double angle); void rotate(double angle, const Point ¢er); void reverse(); Point first_point() const; virtual Point last_point() const = 0; virtual Lines lines() const = 0; double length() const; bool is_valid() const { return this->points.size() >= 2; } int find_point(const Point &point) const; bool has_boundary_point(const Point &point) const; BoundingBox bounding_box() const; // Return true if there are exact duplicates. bool has_duplicate_points() const; // Remove exact duplicates, return true if any duplicate has been removed. bool remove_duplicate_points(); void append(const Point &point); void append(const Points &points); void append(const Points::const_iterator &begin, const Points::const_iterator &end); bool intersection(const Line& line, Point* intersection) const; std::string dump_perl() const; static Points _douglas_peucker(const Points &points, const double tolerance); }; extern BoundingBox get_extents(const MultiPoint &mp); extern BoundingBox get_extents_rotated(const std::vector &points, double angle); extern BoundingBox get_extents_rotated(const MultiPoint &mp, double angle); } // namespace Slic3r #endif Slic3r-version_1.31.6/xs/src/libslic3r/PerimeterGenerator.cpp000066400000000000000000000626061301441720000241260ustar00rootroot00000000000000#include "PerimeterGenerator.hpp" #include "ClipperUtils.hpp" #include "ExtrusionEntityCollection.hpp" #include #include namespace Slic3r { void PerimeterGenerator::process() { // other perimeters this->_mm3_per_mm = this->perimeter_flow.mm3_per_mm(); coord_t pwidth = this->perimeter_flow.scaled_width(); coord_t pspacing = this->perimeter_flow.scaled_spacing(); // external perimeters this->_ext_mm3_per_mm = this->ext_perimeter_flow.mm3_per_mm(); coord_t ext_pwidth = this->ext_perimeter_flow.scaled_width(); coord_t ext_pspacing = this->ext_perimeter_flow.scaled_spacing(); coord_t ext_pspacing2 = this->ext_perimeter_flow.scaled_spacing(this->perimeter_flow); // overhang perimeters this->_mm3_per_mm_overhang = this->overhang_flow.mm3_per_mm(); // solid infill coord_t ispacing = this->solid_infill_flow.scaled_spacing(); // Calculate the minimum required spacing between two adjacent traces. // This should be equal to the nominal flow spacing but we experiment // with some tolerance in order to avoid triggering medial axis when // some squishing might work. Loops are still spaced by the entire // flow spacing; this only applies to collapsing parts. // For ext_min_spacing we use the ext_pspacing calculated for two adjacent // external loops (which is the correct way) instead of using ext_pspacing2 // which is the spacing between external and internal, which is not correct // and would make the collapsing (thus the details resolution) dependent on // internal flow which is unrelated. coord_t min_spacing = pspacing * (1 - INSET_OVERLAP_TOLERANCE); coord_t ext_min_spacing = ext_pspacing * (1 - INSET_OVERLAP_TOLERANCE); // prepare grown lower layer slices for overhang detection if (this->lower_slices != NULL && this->config->overhangs) { // We consider overhang any part where the entire nozzle diameter is not supported by the // lower layer, so we take lower slices and offset them by half the nozzle diameter used // in the current layer double nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->perimeter_extruder-1); this->_lower_slices_p = offset(*this->lower_slices, scale_(+nozzle_diameter/2)); } // we need to process each island separately because we might have different // extra perimeters for each one for (Surfaces::const_iterator surface = this->slices->surfaces.begin(); surface != this->slices->surfaces.end(); ++surface) { // detect how many perimeters must be generated for this island signed short loop_number = this->config->perimeters + surface->extra_perimeters; loop_number--; // 0-indexed loops Polygons gaps; Polygons last = surface->expolygon.simplify_p(SCALED_RESOLUTION); if (loop_number >= 0) { // no loops = -1 std::vector contours(loop_number+1); // depth => loops std::vector holes(loop_number+1); // depth => loops ThickPolylines thin_walls; // we loop one time more than needed in order to find gaps after the last perimeter was applied for (signed short i = 0; i <= loop_number+1; ++i) { // outer loop is 0 Polygons offsets; if (i == 0) { // the minimum thickness of a single loop is: // ext_width/2 + ext_spacing/2 + spacing/2 + width/2 if (this->config->thin_walls) { offsets = offset2( last, -(ext_pwidth/2 + ext_min_spacing/2 - 1), +(ext_min_spacing/2 - 1) ); } else { offsets = offset(last, -ext_pwidth/2); } // look for thin walls if (this->config->thin_walls) { Polygons diffpp = diff( last, offset(offsets, +ext_pwidth/2), true // medial axis requires non-overlapping geometry ); // the following offset2 ensures almost nothing in @thin_walls is narrower than $min_width // (actually, something larger than that still may exist due to mitering or other causes) coord_t min_width = scale_(this->ext_perimeter_flow.nozzle_diameter / 3); ExPolygons expp = offset2_ex(diffpp, -min_width/2, +min_width/2); // the maximum thickness of our thin wall area is equal to the minimum thickness of a single loop for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex) ex->medial_axis(ext_pwidth + ext_pspacing2, min_width, &thin_walls); #ifdef DEBUG printf(" " PRINTF_ZU " thin walls detected\n", thin_walls.size()); #endif /* if (false) { require "Slic3r/SVG.pm"; Slic3r::SVG::output( "medial_axis.svg", no_arrows => 1, #expolygons => \@expp, polylines => \@thin_walls, ); } */ } } else { //FIXME Is this offset correct if the line width of the inner perimeters differs // from the line width of the infill? coord_t distance = (i == 1) ? ext_pspacing2 : pspacing; if (this->config->thin_walls) { // This path will ensure, that the perimeters do not overfill, as in // prusa3d/Slic3r GH #32, but with the cost of rounding the perimeters // excessively, creating gaps, which then need to be filled in by the not very // reliable gap fill algorithm. // Also the offset2(perimeter, -x, x) may sometimes lead to a perimeter, which is larger than // the original. offsets = offset2( last, -(distance + min_spacing/2 - 1), +(min_spacing/2 - 1) ); } else { // If "detect thin walls" is not enabled, this paths will be entered, which // leads to overflows, as in prusa3d/Slic3r GH #32 offsets = offset( last, -distance ); } // look for gaps if (this->config->gap_fill_speed.value > 0 && this->config->fill_density.value > 0) { // not using safety offset here would "detect" very narrow gaps // (but still long enough to escape the area threshold) that gap fill // won't be able to fill but we'd still remove from infill area Polygons diff_pp = diff( offset(last, -0.5*distance), offset(offsets, +0.5*distance + 10) // safety offset ); gaps.insert(gaps.end(), diff_pp.begin(), diff_pp.end()); } } if (offsets.empty()) break; if (i > loop_number) break; // we were only looking for gaps this time last = offsets; for (Polygons::const_iterator polygon = offsets.begin(); polygon != offsets.end(); ++polygon) { PerimeterGeneratorLoop loop(*polygon, i); loop.is_contour = polygon->is_counter_clockwise(); if (loop.is_contour) { contours[i].push_back(loop); } else { holes[i].push_back(loop); } } } // nest loops: holes first for (signed short d = 0; d <= loop_number; ++d) { PerimeterGeneratorLoops &holes_d = holes[d]; // loop through all holes having depth == d for (signed short i = 0; i < holes_d.size(); ++i) { const PerimeterGeneratorLoop &loop = holes_d[i]; // find the hole loop that contains this one, if any for (signed short t = d+1; t <= loop_number; ++t) { for (signed short j = 0; j < holes[t].size(); ++j) { PerimeterGeneratorLoop &candidate_parent = holes[t][j]; if (candidate_parent.polygon.contains(loop.polygon.first_point())) { candidate_parent.children.push_back(loop); holes_d.erase(holes_d.begin() + i); --i; goto NEXT_LOOP; } } } // if no hole contains this hole, find the contour loop that contains it for (signed short t = loop_number; t >= 0; --t) { for (signed short j = 0; j < contours[t].size(); ++j) { PerimeterGeneratorLoop &candidate_parent = contours[t][j]; if (candidate_parent.polygon.contains(loop.polygon.first_point())) { candidate_parent.children.push_back(loop); holes_d.erase(holes_d.begin() + i); --i; goto NEXT_LOOP; } } } NEXT_LOOP: ; } } // nest contour loops for (signed short d = loop_number; d >= 1; --d) { PerimeterGeneratorLoops &contours_d = contours[d]; // loop through all contours having depth == d for (signed short i = 0; i < contours_d.size(); ++i) { const PerimeterGeneratorLoop &loop = contours_d[i]; // find the contour loop that contains it for (signed short t = d-1; t >= 0; --t) { for (signed short j = 0; j < contours[t].size(); ++j) { PerimeterGeneratorLoop &candidate_parent = contours[t][j]; if (candidate_parent.polygon.contains(loop.polygon.first_point())) { candidate_parent.children.push_back(loop); contours_d.erase(contours_d.begin() + i); --i; goto NEXT_CONTOUR; } } } NEXT_CONTOUR: ; } } // at this point, all loops should be in contours[0] ExtrusionEntityCollection entities = this->_traverse_loops(contours.front(), thin_walls); // if brim will be printed, reverse the order of perimeters so that // we continue inwards after having finished the brim // TODO: add test for perimeter order if (this->config->external_perimeters_first || (this->layer_id == 0 && this->print_config->brim_width.value > 0)) entities.reverse(); // append perimeters for this slice as a collection if (!entities.empty()) this->loops->append(entities); } // for each loop of an island // fill gaps if (!gaps.empty()) { /* SVG svg("gaps.svg"); svg.draw(union_ex(gaps)); svg.Close(); */ // collapse double min = 0.2*pwidth * (1 - INSET_OVERLAP_TOLERANCE); double max = 2*pspacing; ExPolygons gaps_ex = diff_ex( offset2(gaps, -min/2, +min/2), offset2(gaps, -max/2, +max/2), true ); ThickPolylines polylines; for (ExPolygons::const_iterator ex = gaps_ex.begin(); ex != gaps_ex.end(); ++ex) ex->medial_axis(max, min, &polylines); if (!polylines.empty()) { ExtrusionEntityCollection gap_fill = this->_variable_width(polylines, erGapFill, this->solid_infill_flow); this->gap_fill->append(gap_fill.entities); /* Make sure we don't infill narrow parts that are already gap-filled (we only consider this surface's gaps to reduce the diff() complexity). Growing actual extrusions ensures that gaps not filled by medial axis are not subtracted from fill surfaces (they might be too short gaps that medial axis skips but infill might join with other infill regions and use zigzag). */ //FIXME Vojtech: This grows by a rounded extrusion width, not by line spacing, // therefore it may cover the area, but no the volume. last = diff(last, gap_fill.polygons_covered_by_width(10.f)); } } // create one more offset to be used as boundary for fill // we offset by half the perimeter spacing (to get to the actual infill boundary) // and then we offset back and forth by half the infill spacing to only consider the // non-collapsing regions coord_t inset = 0; if (loop_number == 0) { // one loop inset += ext_pspacing2/2; } else if (loop_number > 0) { // two or more loops inset += pspacing/2; } // only apply infill overlap if we actually have one perimeter if (inset > 0) inset -= this->config->get_abs_value("infill_overlap", inset + ispacing/2); { ExPolygons expp = union_ex(last); // simplify infill contours according to resolution Polygons pp; for (ExPolygons::const_iterator ex = expp.begin(); ex != expp.end(); ++ex) ex->simplify_p(SCALED_RESOLUTION, &pp); // collapse too narrow infill areas coord_t min_perimeter_infill_spacing = ispacing * (1 - INSET_OVERLAP_TOLERANCE); // append infill areas to fill_surfaces surfaces_append( this->fill_surfaces->surfaces, offset2_ex( pp, -inset -min_perimeter_infill_spacing/2, +min_perimeter_infill_spacing/2), stInternal); } } // for each island } ExtrusionEntityCollection PerimeterGenerator::_traverse_loops(const PerimeterGeneratorLoops &loops, ThickPolylines &thin_walls) const { // loops is an arrayref of ::Loop objects // turn each one into an ExtrusionLoop object ExtrusionEntityCollection coll; for (PerimeterGeneratorLoops::const_iterator loop = loops.begin(); loop != loops.end(); ++loop) { bool is_external = loop->is_external(); ExtrusionRole role; ExtrusionLoopRole loop_role; role = is_external ? erExternalPerimeter : erPerimeter; if (loop->is_internal_contour()) { // Note that we set loop role to ContourInternalPerimeter // also when loop is both internal and external (i.e. // there's only one contour loop). loop_role = elrContourInternalPerimeter; } else { loop_role = elrDefault; } // detect overhanging/bridging perimeters ExtrusionPaths paths; if (this->config->overhangs && this->layer_id > 0 && !(this->object_config->support_material && this->object_config->support_material_contact_distance.value == 0)) { // get non-overhang paths by intersecting this loop with the grown lower slices { Polylines polylines; intersection((Polygons)loop->polygon, this->_lower_slices_p, &polylines); for (Polylines::const_iterator polyline = polylines.begin(); polyline != polylines.end(); ++polyline) { ExtrusionPath path(role); path.polyline = *polyline; path.mm3_per_mm = is_external ? this->_ext_mm3_per_mm : this->_mm3_per_mm; path.width = is_external ? this->ext_perimeter_flow.width : this->perimeter_flow.width; path.height = this->layer_height; paths.push_back(path); } } // get overhang paths by checking what parts of this loop fall // outside the grown lower slices (thus where the distance between // the loop centerline and original lower slices is >= half nozzle diameter { Polylines polylines; diff((Polygons)loop->polygon, this->_lower_slices_p, &polylines); for (Polylines::const_iterator polyline = polylines.begin(); polyline != polylines.end(); ++polyline) { ExtrusionPath path(erOverhangPerimeter); path.polyline = *polyline; path.mm3_per_mm = this->_mm3_per_mm_overhang; path.width = this->overhang_flow.width; path.height = this->overhang_flow.height; paths.push_back(path); } } // reapply the nearest point search for starting point // We allow polyline reversal because Clipper may have randomly // reversed polylines during clipping. paths = ExtrusionEntityCollection(paths).chained_path(); } else { ExtrusionPath path(role); path.polyline = loop->polygon.split_at_first_point(); path.mm3_per_mm = is_external ? this->_ext_mm3_per_mm : this->_mm3_per_mm; path.width = is_external ? this->ext_perimeter_flow.width : this->perimeter_flow.width; path.height = this->layer_height; paths.push_back(path); } coll.append(ExtrusionLoop(paths, loop_role)); } // append thin walls to the nearest-neighbor search (only for first iteration) if (!thin_walls.empty()) { ExtrusionEntityCollection tw = this->_variable_width (thin_walls, erExternalPerimeter, this->ext_perimeter_flow); coll.append(tw.entities); thin_walls.clear(); } // sort entities into a new collection using a nearest-neighbor search, // preserving the original indices which are useful for detecting thin walls ExtrusionEntityCollection sorted_coll; coll.chained_path(&sorted_coll, false, &sorted_coll.orig_indices); // traverse children and build the final collection ExtrusionEntityCollection entities; for (std::vector::const_iterator idx = sorted_coll.orig_indices.begin(); idx != sorted_coll.orig_indices.end(); ++idx) { if (*idx >= loops.size()) { // this is a thin wall // let's get it from the sorted collection as it might have been reversed size_t i = idx - sorted_coll.orig_indices.begin(); entities.append(*sorted_coll.entities[i]); } else { const PerimeterGeneratorLoop &loop = loops[*idx]; ExtrusionLoop eloop = *dynamic_cast(coll.entities[*idx]); ExtrusionEntityCollection children = this->_traverse_loops(loop.children, thin_walls); if (loop.is_contour) { eloop.make_counter_clockwise(); entities.append(children.entities); entities.append(eloop); } else { eloop.make_clockwise(); entities.append(eloop); entities.append(children.entities); } } } return entities; } ExtrusionEntityCollection PerimeterGenerator::_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow) const { // this value determines granularity of adaptive width, as G-code does not allow // variable extrusion within a single move; this value shall only affect the amount // of segments, and any pruning shall be performed before we apply this tolerance const double tolerance = scale_(0.05); ExtrusionEntityCollection coll; for (ThickPolylines::const_iterator p = polylines.begin(); p != polylines.end(); ++p) { ExtrusionPaths paths; ExtrusionPath path(role); ThickLines lines = p->thicklines(); for (size_t i = 0; i < lines.size(); ++i) { const ThickLine& line = lines[i]; const coordf_t line_len = line.length(); if (line_len < SCALED_EPSILON) continue; double thickness_delta = fabs(line.a_width - line.b_width); if (thickness_delta > tolerance) { const unsigned short segments = ceil(thickness_delta / tolerance); const coordf_t seg_len = line_len / segments; Points pp; std::vector width; { pp.push_back(line.a); width.push_back(line.a_width); for (size_t j = 1; j < segments; ++j) { pp.push_back(line.point_at(j*seg_len)); coordf_t w = line.a_width + (j*seg_len) * (line.b_width-line.a_width) / line_len; width.push_back(w); width.push_back(w); } pp.push_back(line.b); width.push_back(line.b_width); assert(pp.size() == segments + 1); assert(width.size() == segments*2); } // delete this line and insert new ones lines.erase(lines.begin() + i); for (size_t j = 0; j < segments; ++j) { ThickLine new_line(pp[j], pp[j+1]); new_line.a_width = width[2*j]; new_line.b_width = width[2*j+1]; lines.insert(lines.begin() + i + j, new_line); } --i; continue; } const double w = fmax(line.a_width, line.b_width); if (path.polyline.points.empty()) { path.polyline.append(line.a); path.polyline.append(line.b); flow.width = unscale(w); #ifdef SLIC3R_DEBUG printf(" filling %f gap\n", flow.width); #endif path.mm3_per_mm = flow.mm3_per_mm(); path.width = flow.width; path.height = flow.height; } else { thickness_delta = fabs(scale_(flow.width) - w); if (thickness_delta <= tolerance) { // the width difference between this line and the current flow width is // within the accepted tolerance path.polyline.append(line.b); } else { // we need to initialize a new line paths.push_back(path); path = ExtrusionPath(role); --i; } } } if (path.polyline.is_valid()) paths.push_back(path); // append paths to collection if (!paths.empty()) { if (paths.front().first_point().coincides_with(paths.back().last_point())) { coll.append(ExtrusionLoop(paths)); } else { coll.append(paths); } } } return coll; } bool PerimeterGeneratorLoop::is_internal_contour() const { if (this->is_contour) { // an internal contour is a contour containing no other contours for (std::vector::const_iterator loop = this->children.begin(); loop != this->children.end(); ++loop) { if (loop->is_contour) { return false; } } return true; } return false; } } Slic3r-version_1.31.6/xs/src/libslic3r/PerimeterGenerator.hpp000066400000000000000000000063321301441720000241250ustar00rootroot00000000000000#ifndef slic3r_PerimeterGenerator_hpp_ #define slic3r_PerimeterGenerator_hpp_ #include "libslic3r.h" #include #include "ExPolygonCollection.hpp" #include "Flow.hpp" #include "Polygon.hpp" #include "PrintConfig.hpp" #include "SurfaceCollection.hpp" namespace Slic3r { // Hierarchy of perimeters. class PerimeterGeneratorLoop { public: // Polygon of this contour. Polygon polygon; // Is it a contour or a hole? // Contours are CCW oriented, holes are CW oriented. bool is_contour; // Depth in the hierarchy. External perimeter has depth = 0. An external perimeter could be both a contour and a hole. unsigned short depth; // Children contour, may be both CCW and CW oriented (outer contours or holes). std::vector children; PerimeterGeneratorLoop(Polygon polygon, unsigned short depth) : polygon(polygon), is_contour(false), depth(depth) {}; // External perimeter. It may be CCW or CW oriented (outer contour or hole contour). bool is_external() const { return this->depth == 0; } // An island, which may have holes, but it does not have another internal island. bool is_internal_contour() const; }; typedef std::vector PerimeterGeneratorLoops; class PerimeterGenerator { public: // Inputs: const SurfaceCollection* slices; const ExPolygonCollection* lower_slices; double layer_height; int layer_id; Flow perimeter_flow; Flow ext_perimeter_flow; Flow overhang_flow; Flow solid_infill_flow; PrintRegionConfig* config; PrintObjectConfig* object_config; PrintConfig* print_config; // Outputs: ExtrusionEntityCollection* loops; ExtrusionEntityCollection* gap_fill; SurfaceCollection* fill_surfaces; PerimeterGenerator( // Input: const SurfaceCollection* slices, double layer_height, Flow flow, PrintRegionConfig* config, PrintObjectConfig* object_config, PrintConfig* print_config, // Output: // Loops with the external thin walls ExtrusionEntityCollection* loops, // Gaps without the thin walls ExtrusionEntityCollection* gap_fill, // Infills without the gap fills SurfaceCollection* fill_surfaces) : slices(slices), lower_slices(NULL), layer_height(layer_height), layer_id(-1), perimeter_flow(flow), ext_perimeter_flow(flow), overhang_flow(flow), solid_infill_flow(flow), config(config), object_config(object_config), print_config(print_config), loops(loops), gap_fill(gap_fill), fill_surfaces(fill_surfaces), _ext_mm3_per_mm(-1), _mm3_per_mm(-1), _mm3_per_mm_overhang(-1) {}; void process(); private: double _ext_mm3_per_mm; double _mm3_per_mm; double _mm3_per_mm_overhang; Polygons _lower_slices_p; ExtrusionEntityCollection _traverse_loops(const PerimeterGeneratorLoops &loops, ThickPolylines &thin_walls) const; ExtrusionEntityCollection _variable_width (const ThickPolylines &polylines, ExtrusionRole role, Flow flow) const; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/PlaceholderParser.cpp000066400000000000000000000117671301441720000237240ustar00rootroot00000000000000#include "PlaceholderParser.hpp" #include #include #include #include #ifdef _MSC_VER #include // provides **_environ #else #include // provides **environ #endif #ifdef __APPLE__ #include #undef environ #define environ (*_NSGetEnviron()) #else #ifdef _MSC_VER #define environ _environ #else extern char **environ; #endif #endif namespace Slic3r { PlaceholderParser::PlaceholderParser() { this->set("version", SLIC3R_VERSION); this->apply_env_variables(); this->update_timestamp(); } void PlaceholderParser::update_timestamp() { time_t rawtime; time(&rawtime); struct tm* timeinfo = localtime(&rawtime); { std::ostringstream ss; ss << (1900 + timeinfo->tm_year); ss << std::setw(2) << std::setfill('0') << (1 + timeinfo->tm_mon); ss << std::setw(2) << std::setfill('0') << timeinfo->tm_mday; ss << "-"; ss << std::setw(2) << std::setfill('0') << timeinfo->tm_hour; ss << std::setw(2) << std::setfill('0') << timeinfo->tm_min; ss << std::setw(2) << std::setfill('0') << timeinfo->tm_sec; this->set("timestamp", ss.str()); } this->set("year", 1900 + timeinfo->tm_year); this->set("month", 1 + timeinfo->tm_mon); this->set("day", timeinfo->tm_mday); this->set("hour", timeinfo->tm_hour); this->set("minute", timeinfo->tm_min); this->set("second", timeinfo->tm_sec); } void PlaceholderParser::apply_config(const DynamicPrintConfig &config) { t_config_option_keys opt_keys = config.keys(); for (t_config_option_keys::const_iterator i = opt_keys.begin(); i != opt_keys.end(); ++i) { const t_config_option_key &opt_key = *i; const ConfigOptionDef* def = config.def->get(opt_key); if (def->multiline) continue; const ConfigOption* opt = config.option(opt_key); if (const ConfigOptionVectorBase* optv = dynamic_cast(opt)) { // set placeholders for options with multiple values // TODO: treat [bed_shape] as single, not multiple this->set(opt_key, optv->vserialize()); } else if (const ConfigOptionPoint* optp = dynamic_cast(opt)) { this->set(opt_key, optp->serialize()); Pointf val = *optp; this->set(opt_key + "_X", val.x); this->set(opt_key + "_Y", val.y); } else { // set single-value placeholders this->set(opt_key, opt->serialize()); } } } void PlaceholderParser::apply_env_variables() { for (char** env = environ; *env; env++) { if (strncmp(*env, "SLIC3R_", 7) == 0) { std::stringstream ss(*env); std::string key, value; std::getline(ss, key, '='); ss >> value; this->set(key, value); } } } void PlaceholderParser::set(const std::string &key, const std::string &value) { this->_single[key] = value; this->_multiple.erase(key); } void PlaceholderParser::set(const std::string &key, int value) { std::ostringstream ss; ss << value; this->set(key, ss.str()); } void PlaceholderParser::set(const std::string &key, std::vector values) { if (values.empty()) { this->_multiple.erase(key); this->_single.erase(key); } else { this->_multiple[key] = values; this->_single[key] = values.front(); } } std::string PlaceholderParser::process(std::string str) const { // replace single options, like [foo] for (t_strstr_map::const_iterator it = this->_single.begin(); it != this->_single.end(); ++it) { std::stringstream ss; ss << '[' << it->first << ']'; this->find_and_replace(str, ss.str(), it->second); } // replace multiple options like [foo_0] by looping until we have enough values // or until a previous match was found (this handles non-existing indices reasonably // without a regex) for (t_strstrs_map::const_iterator it = this->_multiple.begin(); it != this->_multiple.end(); ++it) { const std::vector &values = it->second; bool found = false; for (size_t i = 0; (i < values.size()) || found; ++i) { std::stringstream ss; ss << '[' << it->first << '_' << i << ']'; if (i < values.size()) { found = this->find_and_replace(str, ss.str(), values[i]); } else { found = this->find_and_replace(str, ss.str(), values.front()); } } } return str; } bool PlaceholderParser::find_and_replace(std::string &source, std::string const &find, std::string const &replace) const { bool found = false; for (std::string::size_type i = 0; (i = source.find(find, i)) != std::string::npos; ) { source.replace(i, find.length(), replace); i += replace.length(); found = true; } return found; } } Slic3r-version_1.31.6/xs/src/libslic3r/PlaceholderParser.hpp000066400000000000000000000016561301441720000237250ustar00rootroot00000000000000#ifndef slic3r_PlaceholderParser_hpp_ #define slic3r_PlaceholderParser_hpp_ #include "libslic3r.h" #include #include #include #include "PrintConfig.hpp" namespace Slic3r { typedef std::map t_strstr_map; typedef std::map > t_strstrs_map; class PlaceholderParser { public: t_strstr_map _single; t_strstrs_map _multiple; PlaceholderParser(); void update_timestamp(); void apply_config(const DynamicPrintConfig &config); void apply_env_variables(); void set(const std::string &key, const std::string &value); void set(const std::string &key, int value); void set(const std::string &key, std::vector values); std::string process(std::string str) const; private: bool find_and_replace(std::string &source, std::string const &find, std::string const &replace) const; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/Point.cpp000066400000000000000000000256351301441720000214150ustar00rootroot00000000000000#include "Point.hpp" #include "Line.hpp" #include "MultiPoint.hpp" #include #include namespace Slic3r { Point::Point(double x, double y) { this->x = lrint(x); this->y = lrint(y); } bool Point::operator==(const Point& rhs) const { return this->coincides_with(rhs); } std::string Point::wkt() const { std::ostringstream ss; ss << "POINT(" << this->x << " " << this->y << ")"; return ss.str(); } std::string Point::dump_perl() const { std::ostringstream ss; ss << "[" << this->x << "," << this->y << "]"; return ss.str(); } void Point::scale(double factor) { this->x *= factor; this->y *= factor; } void Point::translate(double x, double y) { this->x += x; this->y += y; } void Point::translate(const Vector &vector) { this->translate(vector.x, vector.y); } void Point::rotate(double angle) { double cur_x = (double)this->x; double cur_y = (double)this->y; double s = sin(angle); double c = cos(angle); this->x = (coord_t)round(c * cur_x - s * cur_y); this->y = (coord_t)round(c * cur_y + s * cur_x); } void Point::rotate(double angle, const Point ¢er) { double cur_x = (double)this->x; double cur_y = (double)this->y; double s = sin(angle); double c = cos(angle); double dx = cur_x - (double)center.x; double dy = cur_y - (double)center.y; this->x = (coord_t)round( (double)center.x + c * dx - s * dy ); this->y = (coord_t)round( (double)center.y + c * dy + s * dx ); } bool Point::coincides_with_epsilon(const Point &point) const { return std::abs(this->x - point.x) < SCALED_EPSILON && std::abs(this->y - point.y) < SCALED_EPSILON; } int Point::nearest_point_index(const Points &points) const { PointConstPtrs p; p.reserve(points.size()); for (Points::const_iterator it = points.begin(); it != points.end(); ++it) p.push_back(&*it); return this->nearest_point_index(p); } template inline T sqr(const T x) { return x * x; } int Point::nearest_point_index(const PointConstPtrs &points) const { int idx = -1; double distance = -1; // double because long is limited to 2147483647 on some platforms and it's not enough for (PointConstPtrs::const_iterator it = points.begin(); it != points.end(); ++it) { /* If the X distance of the candidate is > than the total distance of the best previous candidate, we know we don't want it */ double d = sqr(this->x - (*it)->x); if (distance != -1 && d > distance) continue; /* If the Y distance of the candidate is > than the total distance of the best previous candidate, we know we don't want it */ d += sqr(this->y - (*it)->y); if (distance != -1 && d > distance) continue; idx = it - points.begin(); distance = d; if (distance < EPSILON) break; } return idx; } /* This method finds the point that is closest to both this point and the supplied one */ size_t Point::nearest_waypoint_index(const Points &points, const Point &dest) const { size_t idx = -1; double distance = -1; // double because long is limited to 2147483647 on some platforms and it's not enough for (Points::const_iterator p = points.begin(); p != points.end(); ++p) { // distance from this to candidate double d = sqr(this->x - p->x) + sqr(this->y - p->y); // distance from candidate to dest d += sqr(p->x - dest.x) + sqr(p->y - dest.y); // if the total distance is greater than current min distance, ignore it if (distance != -1 && d > distance) continue; idx = p - points.begin(); distance = d; if (distance < EPSILON) break; } return idx; } int Point::nearest_point_index(const PointPtrs &points) const { PointConstPtrs p; p.reserve(points.size()); for (PointPtrs::const_iterator it = points.begin(); it != points.end(); ++it) p.push_back(*it); return this->nearest_point_index(p); } bool Point::nearest_point(const Points &points, Point* point) const { int idx = this->nearest_point_index(points); if (idx == -1) return false; *point = points.at(idx); return true; } bool Point::nearest_waypoint(const Points &points, const Point &dest, Point* point) const { int idx = this->nearest_waypoint_index(points, dest); if (idx == -1) return false; *point = points.at(idx); return true; } double Point::distance_to(const Point &point) const { double dx = ((double)point.x - this->x); double dy = ((double)point.y - this->y); return sqrt(dx*dx + dy*dy); } /* distance to the closest point of line */ double Point::distance_to(const Line &line) const { const double dx = line.b.x - line.a.x; const double dy = line.b.y - line.a.y; const double l2 = dx*dx + dy*dy; // avoid a sqrt if (l2 == 0.0) return this->distance_to(line.a); // line.a == line.b case // Consider the line extending the segment, parameterized as line.a + t (line.b - line.a). // We find projection of this point onto the line. // It falls where t = [(this-line.a) . (line.b-line.a)] / |line.b-line.a|^2 const double t = ((this->x - line.a.x) * dx + (this->y - line.a.y) * dy) / l2; if (t < 0.0) return this->distance_to(line.a); // beyond the 'a' end of the segment else if (t > 1.0) return this->distance_to(line.b); // beyond the 'b' end of the segment Point projection( line.a.x + t * dx, line.a.y + t * dy ); return this->distance_to(projection); } double Point::perp_distance_to(const Line &line) const { if (line.a.coincides_with(line.b)) return this->distance_to(line.a); double n = (double)(line.b.x - line.a.x) * (double)(line.a.y - this->y) - (double)(line.a.x - this->x) * (double)(line.b.y - line.a.y); return std::abs(n) / line.length(); } /* Three points are a counter-clockwise turn if ccw > 0, clockwise if * ccw < 0, and collinear if ccw = 0 because ccw is a determinant that * gives the signed area of the triangle formed by p1, p2 and this point. * In other words it is the 2D cross product of p1-p2 and p1-this, i.e. * z-component of their 3D cross product. * We return double because it must be big enough to hold 2*max(|coordinate|)^2 */ double Point::ccw(const Point &p1, const Point &p2) const { return (double)(p2.x - p1.x)*(double)(this->y - p1.y) - (double)(p2.y - p1.y)*(double)(this->x - p1.x); } double Point::ccw(const Line &line) const { return this->ccw(line.a, line.b); } // returns the CCW angle between this-p1 and this-p2 // i.e. this assumes a CCW rotation from p1 to p2 around this double Point::ccw_angle(const Point &p1, const Point &p2) const { double angle = atan2(p1.x - this->x, p1.y - this->y) - atan2(p2.x - this->x, p2.y - this->y); // we only want to return only positive angles return angle <= 0 ? angle + 2*PI : angle; } Point Point::projection_onto(const MultiPoint &poly) const { Point running_projection = poly.first_point(); double running_min = this->distance_to(running_projection); Lines lines = poly.lines(); for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { Point point_temp = this->projection_onto(*line); if (this->distance_to(point_temp) < running_min) { running_projection = point_temp; running_min = this->distance_to(running_projection); } } return running_projection; } Point Point::projection_onto(const Line &line) const { if (line.a.coincides_with(line.b)) return line.a; /* (Ported from VisiLibity by Karl J. Obermeyer) The projection of point_temp onto the line determined by line_segment_temp can be represented as an affine combination expressed in the form projection of Point = theta*line_segment_temp.first + (1.0-theta)*line_segment_temp.second. If theta is outside the interval [0,1], then one of the Line_Segment's endpoints must be closest to calling Point. */ double lx = (double)(line.b.x - line.a.x); double ly = (double)(line.b.y - line.a.y); double theta = ( (double)(line.b.x - this->x)*lx + (double)(line.b.y- this->y)*ly ) / ( sqr(lx) + sqr(ly) ); if (0.0 <= theta && theta <= 1.0) return theta * line.a + (1.0-theta) * line.b; // Else pick closest endpoint. if (this->distance_to(line.a) < this->distance_to(line.b)) { return line.a; } else { return line.b; } } Point Point::negative() const { return Point(-this->x, -this->y); } Vector Point::vector_to(const Point &point) const { return Vector(point.x - this->x, point.y - this->y); } std::ostream& operator<<(std::ostream &stm, const Pointf &pointf) { return stm << pointf.x << "," << pointf.y; } std::string Pointf::wkt() const { std::ostringstream ss; ss << "POINT(" << this->x << " " << this->y << ")"; return ss.str(); } std::string Pointf::dump_perl() const { std::ostringstream ss; ss << "[" << this->x << "," << this->y << "]"; return ss.str(); } void Pointf::scale(double factor) { this->x *= factor; this->y *= factor; } void Pointf::translate(double x, double y) { this->x += x; this->y += y; } void Pointf::translate(const Vectorf &vector) { this->translate(vector.x, vector.y); } void Pointf::rotate(double angle) { double cur_x = this->x; double cur_y = this->y; double s = sin(angle); double c = cos(angle); this->x = c * cur_x - s * cur_y; this->y = c * cur_y + s * cur_x; } void Pointf::rotate(double angle, const Pointf ¢er) { double cur_x = this->x; double cur_y = this->y; double s = sin(angle); double c = cos(angle); double dx = cur_x - center.x; double dy = cur_y - center.y; this->x = center.x + c * dx - s * dy; this->y = center.y + c * dy + s * dx; } Pointf Pointf::negative() const { return Pointf(-this->x, -this->y); } Vectorf Pointf::vector_to(const Pointf &point) const { return Vectorf(point.x - this->x, point.y - this->y); } void Pointf3::scale(double factor) { Pointf::scale(factor); this->z *= factor; } void Pointf3::translate(const Vectorf3 &vector) { this->translate(vector.x, vector.y, vector.z); } void Pointf3::translate(double x, double y, double z) { Pointf::translate(x, y); this->z += z; } double Pointf3::distance_to(const Pointf3 &point) const { double dx = ((double)point.x - this->x); double dy = ((double)point.y - this->y); double dz = ((double)point.z - this->z); return sqrt(dx*dx + dy*dy + dz*dz); } Pointf3 Pointf3::negative() const { return Pointf3(-this->x, -this->y, -this->z); } Vectorf3 Pointf3::vector_to(const Pointf3 &point) const { return Vectorf3(point.x - this->x, point.y - this->y, point.z - this->z); } } Slic3r-version_1.31.6/xs/src/libslic3r/Point.hpp000066400000000000000000000143531301441720000214150ustar00rootroot00000000000000#ifndef slic3r_Point_hpp_ #define slic3r_Point_hpp_ #include "libslic3r.h" #include #include #include #include namespace Slic3r { class Line; class Linef; class MultiPoint; class Point; class Pointf; class Pointf3; typedef Point Vector; typedef Pointf Vectorf; typedef Pointf3 Vectorf3; typedef std::vector Points; typedef std::vector PointPtrs; typedef std::vector PointConstPtrs; typedef std::vector Pointfs; typedef std::vector Pointf3s; class Point { public: coord_t x; coord_t y; Point(coord_t _x = 0, coord_t _y = 0): x(_x), y(_y) {}; Point(int _x, int _y): x(_x), y(_y) {}; Point(long long _x, long long _y): x(_x), y(_y) {}; // for Clipper Point(double x, double y); static Point new_scale(coordf_t x, coordf_t y) { return Point(scale_(x), scale_(y)); }; bool operator==(const Point& rhs) const; std::string wkt() const; std::string dump_perl() const; void scale(double factor); void translate(double x, double y); void translate(const Vector &vector); void rotate(double angle); void rotate(double angle, const Point ¢er); Point rotated(double angle) const { Point res(*this); res.rotate(angle); return res; } Point rotated(double angle, const Point ¢er) const { Point res(*this); res.rotate(angle, center); return res; } bool coincides_with(const Point &point) const { return this->x == point.x && this->y == point.y; } bool coincides_with_epsilon(const Point &point) const; int nearest_point_index(const Points &points) const; int nearest_point_index(const PointConstPtrs &points) const; int nearest_point_index(const PointPtrs &points) const; size_t nearest_waypoint_index(const Points &points, const Point &point) const; bool nearest_point(const Points &points, Point* point) const; bool nearest_waypoint(const Points &points, const Point &dest, Point* point) const; double distance_to(const Point &point) const; double distance_to(const Line &line) const; double perp_distance_to(const Line &line) const; double ccw(const Point &p1, const Point &p2) const; double ccw(const Line &line) const; double ccw_angle(const Point &p1, const Point &p2) const; Point projection_onto(const MultiPoint &poly) const; Point projection_onto(const Line &line) const; Point negative() const; Vector vector_to(const Point &point) const; }; inline Point operator+(const Point& point1, const Point& point2) { return Point(point1.x + point2.x, point1.y + point2.y); } inline Point operator-(const Point& point1, const Point& point2) { return Point(point1.x - point2.x, point1.y - point2.y); } inline Point operator*(double scalar, const Point& point2) { return Point(scalar * point2.x, scalar * point2.y); } class Point3 : public Point { public: coord_t z; explicit Point3(coord_t _x = 0, coord_t _y = 0, coord_t _z = 0): Point(_x, _y), z(_z) {}; }; std::ostream& operator<<(std::ostream &stm, const Pointf &pointf); class Pointf { public: coordf_t x; coordf_t y; explicit Pointf(coordf_t _x = 0, coordf_t _y = 0): x(_x), y(_y) {}; static Pointf new_unscale(coord_t x, coord_t y) { return Pointf(unscale(x), unscale(y)); }; static Pointf new_unscale(const Point &p) { return Pointf(unscale(p.x), unscale(p.y)); }; std::string wkt() const; std::string dump_perl() const; void scale(double factor); void translate(double x, double y); void translate(const Vectorf &vector); void rotate(double angle); void rotate(double angle, const Pointf ¢er); Pointf negative() const; Vectorf vector_to(const Pointf &point) const; }; inline Pointf operator+(const Pointf& point1, const Pointf& point2) { return Pointf(point1.x + point2.x, point1.y + point2.y); } inline Pointf operator-(const Pointf& point1, const Pointf& point2) { return Pointf(point1.x - point2.x, point1.y - point2.y); } inline Pointf operator*(double scalar, const Pointf& point2) { return Pointf(scalar * point2.x, scalar * point2.y); } class Pointf3 : public Pointf { public: coordf_t z; explicit Pointf3(coordf_t _x = 0, coordf_t _y = 0, coordf_t _z = 0): Pointf(_x, _y), z(_z) {}; static Pointf3 new_unscale(coord_t x, coord_t y, coord_t z) { return Pointf3(unscale(x), unscale(y), unscale(z)); }; void scale(double factor); void translate(const Vectorf3 &vector); void translate(double x, double y, double z); double distance_to(const Pointf3 &point) const; Pointf3 negative() const; Vectorf3 vector_to(const Pointf3 &point) const; }; } // start Boost #include #include namespace boost { namespace polygon { template <> struct geometry_concept { typedef coordinate_concept type; }; /* Boost.Polygon already defines a specialization for coordinate_traits as of 1.60: https://github.com/boostorg/polygon/commit/0ac7230dd1f8f34cb12b86c8bb121ae86d3d9b97 */ #if BOOST_VERSION < 106000 template <> struct coordinate_traits { typedef coord_t coordinate_type; typedef long double area_type; typedef long long manhattan_area_type; typedef unsigned long long unsigned_area_type; typedef long long coordinate_difference; typedef long double coordinate_distance; }; #endif template <> struct geometry_concept { typedef point_concept type; }; template <> struct point_traits { typedef coord_t coordinate_type; static inline coordinate_type get(const Point& point, orientation_2d orient) { return (orient == HORIZONTAL) ? point.x : point.y; } }; template <> struct point_mutable_traits { typedef coord_t coordinate_type; static inline void set(Point& point, orientation_2d orient, coord_t value) { if (orient == HORIZONTAL) point.x = value; else point.y = value; } static inline Point construct(coord_t x_value, coord_t y_value) { Point retval; retval.x = x_value; retval.y = y_value; return retval; } }; } } // end Boost #endif Slic3r-version_1.31.6/xs/src/libslic3r/Polygon.cpp000066400000000000000000000306631301441720000217500ustar00rootroot00000000000000#include "BoundingBox.hpp" #include "ClipperUtils.hpp" #include "Polygon.hpp" #include "Polyline.hpp" namespace Slic3r { Polygon::operator Polygons() const { Polygons pp; pp.push_back(*this); return pp; } Polygon::operator Polyline() const { return this->split_at_first_point(); } Point& Polygon::operator[](Points::size_type idx) { return this->points[idx]; } const Point& Polygon::operator[](Points::size_type idx) const { return this->points[idx]; } Point Polygon::last_point() const { return this->points.front(); // last point == first point for polygons } Lines Polygon::lines() const { return to_lines(*this); } Polyline Polygon::split_at_vertex(const Point &point) const { // find index of point for (Points::const_iterator it = this->points.begin(); it != this->points.end(); ++it) { if (it->coincides_with(point)) { return this->split_at_index(it - this->points.begin()); } } CONFESS("Point not found"); return Polyline(); } // Split a closed polygon into an open polyline, with the split point duplicated at both ends. Polyline Polygon::split_at_index(int index) const { Polyline polyline; polyline.points.reserve(this->points.size() + 1); for (Points::const_iterator it = this->points.begin() + index; it != this->points.end(); ++it) polyline.points.push_back(*it); for (Points::const_iterator it = this->points.begin(); it != this->points.begin() + index + 1; ++it) polyline.points.push_back(*it); return polyline; } // Split a closed polygon into an open polyline, with the split point duplicated at both ends. Polyline Polygon::split_at_first_point() const { return this->split_at_index(0); } Points Polygon::equally_spaced_points(double distance) const { return this->split_at_first_point().equally_spaced_points(distance); } /* int64_t Polygon::area2x() const { size_t n = poly.size(); if (n < 3) return 0; int64_t a = 0; for (size_t i = 0, j = n - 1; i < n; ++i) a += int64_t(poly[j].x + poly[i].x) * int64_t(poly[j].y - poly[i].y); j = i; } return -a * 0.5; } */ double Polygon::area() const { size_t n = points.size(); if (n < 3) return 0.; double a = 0.; for (size_t i = 0, j = n - 1; i < n; ++i) { a += double(points[j].x + points[i].x) * double(points[i].y - points[j].y); j = i; } return 0.5 * a; } bool Polygon::is_counter_clockwise() const { ClipperLib::Path p; Slic3rMultiPoint_to_ClipperPath(*this, &p); return ClipperLib::Orientation(p); } bool Polygon::is_clockwise() const { return !this->is_counter_clockwise(); } bool Polygon::make_counter_clockwise() { if (!this->is_counter_clockwise()) { this->reverse(); return true; } return false; } bool Polygon::make_clockwise() { if (this->is_counter_clockwise()) { this->reverse(); return true; } return false; } bool Polygon::is_valid() const { return this->points.size() >= 3; } // Does an unoriented polygon contain a point? // Tested by counting intersections along a horizontal line. bool Polygon::contains(const Point &point) const { // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html bool result = false; Points::const_iterator i = this->points.begin(); Points::const_iterator j = this->points.end() - 1; for (; i != this->points.end(); j = i++) { //FIXME this test is not numerically robust. Particularly, it does not handle horizontal segments at y == point.y well. // Does the ray with y == point.y intersect this line segment? #if 1 if ( ((i->y > point.y) != (j->y > point.y)) && ((double)point.x < (double)(j->x - i->x) * (double)(point.y - i->y) / (double)(j->y - i->y) + (double)i->x) ) result = !result; #else if ((i->y > point.y) != (j->y > point.y)) { // Orientation predicated relative to i-th point. double orient = (double)(point.x - i->x) * (double)(j->y - i->y) - (double)(point.y - i->y) * (double)(j->x - i->x); if ((i->y > j->y) ? (orient > 0.) : (orient < 0.)) result = !result; } #endif } return result; } // this only works on CCW polygons as CW will be ripped out by Clipper's simplify_polygons() Polygons Polygon::simplify(double tolerance) const { // repeat first point at the end in order to apply Douglas-Peucker // on the whole polygon Points points = this->points; points.push_back(points.front()); Polygon p(MultiPoint::_douglas_peucker(points, tolerance)); p.points.pop_back(); Polygons pp; pp.push_back(p); simplify_polygons(pp, &pp); return pp; } void Polygon::simplify(double tolerance, Polygons &polygons) const { Polygons pp = this->simplify(tolerance); polygons.reserve(polygons.size() + pp.size()); polygons.insert(polygons.end(), pp.begin(), pp.end()); } // Only call this on convex polygons or it will return invalid results void Polygon::triangulate_convex(Polygons* polygons) const { for (Points::const_iterator it = this->points.begin() + 2; it != this->points.end(); ++it) { Polygon p; p.points.reserve(3); p.points.push_back(this->points.front()); p.points.push_back(*(it-1)); p.points.push_back(*it); // this should be replaced with a more efficient call to a merge_collinear_segments() method if (p.area() > 0) polygons->push_back(p); } } // center of mass Point Polygon::centroid() const { double area_temp = this->area(); double x_temp = 0; double y_temp = 0; Polyline polyline = this->split_at_first_point(); for (Points::const_iterator point = polyline.points.begin(); point != polyline.points.end() - 1; ++point) { x_temp += (double)( point->x + (point+1)->x ) * ( (double)point->x*(point+1)->y - (double)(point+1)->x*point->y ); y_temp += (double)( point->y + (point+1)->y ) * ( (double)point->x*(point+1)->y - (double)(point+1)->x*point->y ); } return Point(x_temp/(6*area_temp), y_temp/(6*area_temp)); } std::string Polygon::wkt() const { std::ostringstream wkt; wkt << "POLYGON(("; for (Points::const_iterator p = this->points.begin(); p != this->points.end(); ++p) { wkt << p->x << " " << p->y; if (p != this->points.end()-1) wkt << ","; } wkt << "))"; return wkt.str(); } // find all concave vertices (i.e. having an internal angle greater than the supplied angle) // (external = right side, thus we consider ccw orientation) Points Polygon::concave_points(double angle) const { Points points; angle = 2*PI - angle; // check whether first point forms a concave angle if (this->points.front().ccw_angle(this->points.back(), *(this->points.begin()+1)) <= angle) points.push_back(this->points.front()); // check whether points 1..(n-1) form concave angles for (Points::const_iterator p = this->points.begin()+1; p != this->points.end()-1; ++p) { if (p->ccw_angle(*(p-1), *(p+1)) <= angle) points.push_back(*p); } // check whether last point forms a concave angle if (this->points.back().ccw_angle(*(this->points.end()-2), this->points.front()) <= angle) points.push_back(this->points.back()); return points; } // find all convex vertices (i.e. having an internal angle smaller than the supplied angle) // (external = right side, thus we consider ccw orientation) Points Polygon::convex_points(double angle) const { Points points; angle = 2*PI - angle; // check whether first point forms a convex angle if (this->points.front().ccw_angle(this->points.back(), *(this->points.begin()+1)) >= angle) points.push_back(this->points.front()); // check whether points 1..(n-1) form convex angles for (Points::const_iterator p = this->points.begin()+1; p != this->points.end()-1; ++p) { if (p->ccw_angle(*(p-1), *(p+1)) >= angle) points.push_back(*p); } // check whether last point forms a convex angle if (this->points.back().ccw_angle(*(this->points.end()-2), this->points.front()) >= angle) points.push_back(this->points.back()); return points; } BoundingBox get_extents(const Polygon &poly) { return poly.bounding_box(); } BoundingBox get_extents(const Polygons &polygons) { BoundingBox bb; if (! polygons.empty()) { bb = get_extents(polygons.front()); for (size_t i = 1; i < polygons.size(); ++ i) bb.merge(get_extents(polygons[i])); } return bb; } BoundingBox get_extents_rotated(const Polygon &poly, double angle) { return get_extents_rotated(poly.points, angle); } BoundingBox get_extents_rotated(const Polygons &polygons, double angle) { BoundingBox bb; if (! polygons.empty()) { bb = get_extents_rotated(polygons.front().points, angle); for (size_t i = 1; i < polygons.size(); ++ i) bb.merge(get_extents_rotated(polygons[i].points, angle)); } return bb; } extern std::vector get_extents_vector(const Polygons &polygons) { std::vector out; out.reserve(polygons.size()); for (Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++ it) out.push_back(get_extents(*it)); return out; } static inline bool is_stick(const Point &p1, const Point &p2, const Point &p3) { Point v1 = p2 - p1; Point v2 = p3 - p2; int64_t dir = int64_t(v1.x) * int64_t(v2.x) + int64_t(v1.y) * int64_t(v2.y); if (dir > 0) // p3 does not turn back to p1. Do not remove p2. return false; double l2_1 = double(v1.x) * double(v1.x) + double(v1.y) * double(v1.y); double l2_2 = double(v2.x) * double(v2.x) + double(v2.y) * double(v2.y); if (dir == 0) // p1, p2, p3 may make a perpendicular corner, or there is a zero edge length. // Remove p2 if it is coincident with p1 or p2. return l2_1 == 0 || l2_2 == 0; // p3 turns back to p1 after p2. Are p1, p2, p3 collinear? // Calculate distance from p3 to a segment (p1, p2) or from p1 to a segment(p2, p3), // whichever segment is longer double cross = double(v1.x) * double(v2.y) - double(v2.x) * double(v1.y); double dist2 = cross * cross / std::max(l2_1, l2_2); return dist2 < EPSILON * EPSILON; } bool remove_sticks(Polygon &poly) { bool modified = false; size_t j = 1; for (size_t i = 1; i + 1 < poly.points.size(); ++ i) { if (! is_stick(poly[j-1], poly[i], poly[i+1])) { // Keep the point. if (j < i) poly.points[j] = poly.points[i]; ++ j; } } if (++ j < poly.points.size()) { poly.points[j-1] = poly.points.back(); poly.points.erase(poly.points.begin() + j, poly.points.end()); modified = true; } while (poly.points.size() >= 3 && is_stick(poly.points[poly.points.size()-2], poly.points.back(), poly.points.front())) { poly.points.pop_back(); modified = true; } while (poly.points.size() >= 3 && is_stick(poly.points.back(), poly.points.front(), poly.points[1])) poly.points.erase(poly.points.begin()); return modified; } bool remove_sticks(Polygons &polys) { bool modified = false; size_t j = 0; for (size_t i = 0; i < polys.size(); ++ i) { modified |= remove_sticks(polys[i]); if (polys[i].points.size() >= 3) { if (j < i) std::swap(polys[i].points, polys[j].points); ++ j; } } if (j < polys.size()) polys.erase(polys.begin() + j, polys.end()); return modified; } bool remove_degenerate(Polygons &polys) { bool modified = false; size_t j = 0; for (size_t i = 0; i < polys.size(); ++ i) { if (polys[i].points.size() >= 3) { if (j < i) std::swap(polys[i].points, polys[j].points); ++ j; } else modified = true; } if (j < polys.size()) polys.erase(polys.begin() + j, polys.end()); return modified; } bool remove_small(Polygons &polys, double min_area) { bool modified = false; size_t j = 0; for (size_t i = 0; i < polys.size(); ++ i) { if (std::abs(polys[i].area()) >= min_area) { if (j < i) std::swap(polys[i].points, polys[j].points); ++ j; } else modified = true; } if (j < polys.size()) polys.erase(polys.begin() + j, polys.end()); return modified; } } Slic3r-version_1.31.6/xs/src/libslic3r/Polygon.hpp000066400000000000000000000165231301441720000217540ustar00rootroot00000000000000#ifndef slic3r_Polygon_hpp_ #define slic3r_Polygon_hpp_ #include "libslic3r.h" #include #include #include "Line.hpp" #include "MultiPoint.hpp" #include "Polyline.hpp" namespace Slic3r { class Polygon; typedef std::vector Polygons; class Polygon : public MultiPoint { public: operator Polygons() const; operator Polyline() const; Point& operator[](Points::size_type idx); const Point& operator[](Points::size_type idx) const; Polygon() {}; explicit Polygon(const Points &points): MultiPoint(points) {}; Point last_point() const; virtual Lines lines() const; Polyline split_at_vertex(const Point &point) const; // Split a closed polygon into an open polyline, with the split point duplicated at both ends. Polyline split_at_index(int index) const; // Split a closed polygon into an open polyline, with the split point duplicated at both ends. Polyline split_at_first_point() const; Points equally_spaced_points(double distance) const; double area() const; bool is_counter_clockwise() const; bool is_clockwise() const; bool make_counter_clockwise(); bool make_clockwise(); bool is_valid() const; // Does an unoriented polygon contain a point? // Tested by counting intersections along a horizontal line. bool contains(const Point &point) const; Polygons simplify(double tolerance) const; void simplify(double tolerance, Polygons &polygons) const; void triangulate_convex(Polygons* polygons) const; Point centroid() const; std::string wkt() const; Points concave_points(double angle = PI) const; Points convex_points(double angle = PI) const; }; extern BoundingBox get_extents(const Polygon &poly); extern BoundingBox get_extents(const Polygons &polygons); extern BoundingBox get_extents_rotated(const Polygon &poly, double angle); extern BoundingBox get_extents_rotated(const Polygons &polygons, double angle); extern std::vector get_extents_vector(const Polygons &polygons); // Remove sticks (tentacles with zero area) from the polygon. extern bool remove_sticks(Polygon &poly); extern bool remove_sticks(Polygons &polys); // Remove polygons with less than 3 edges. extern bool remove_degenerate(Polygons &polys); extern bool remove_small(Polygons &polys, double min_area); // Append a vector of polygons at the end of another vector of polygons. inline void polygons_append(Polygons &dst, const Polygons &src) { dst.insert(dst.end(), src.begin(), src.end()); } #if SLIC3R_CPPVER >= 11 inline void polygons_append(Polygons &dst, Polygons &&src) { if (dst.empty()) dst = std::move(src); else std::move(std::begin(src), std::end(src), std::back_inserter(dst)); } #endif inline void polygons_rotate(Polygons &polys, double angle) { for (Polygons::iterator p = polys.begin(); p != polys.end(); ++p) p->rotate(angle); } inline Lines to_lines(const Polygon &poly) { Lines lines; lines.reserve(poly.points.size()); for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it) lines.push_back(Line(*it, *(it + 1))); lines.push_back(Line(poly.points.back(), poly.points.front())); return lines; } inline Lines to_lines(const Polygons &polys) { size_t n_lines = 0; for (size_t i = 0; i < polys.size(); ++ i) n_lines += polys[i].points.size(); Lines lines; lines.reserve(n_lines); for (size_t i = 0; i < polys.size(); ++ i) { const Polygon &poly = polys[i]; for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it) lines.push_back(Line(*it, *(it + 1))); lines.push_back(Line(poly.points.back(), poly.points.front())); } return lines; } inline Polylines to_polylines(const Polygons &polys) { Polylines polylines; polylines.assign(polys.size(), Polyline()); size_t idx = 0; for (Polygons::const_iterator it = polys.begin(); it != polys.end(); ++ it) { Polyline &pl = polylines[idx ++]; pl.points = it->points; pl.points.push_back(it->points.front()); } assert(idx == polylines.size()); return polylines; } #if SLIC3R_CPPVER >= 11 inline Polylines to_polylines(Polygons &&polys) { Polylines polylines; polylines.assign(polys.size(), Polyline()); size_t idx = 0; for (Polygons::const_iterator it = polys.begin(); it != polys.end(); ++ it) { Polyline &pl = polylines[idx ++]; pl.points = std::move(it->points); pl.points.push_back(it->points.front()); } assert(idx == polylines.size()); return polylines; } #endif } // Slic3r // start Boost #include namespace boost { namespace polygon { template <> struct geometry_concept{ typedef polygon_concept type; }; template <> struct polygon_traits { typedef coord_t coordinate_type; typedef Points::const_iterator iterator_type; typedef Point point_type; // Get the begin iterator static inline iterator_type begin_points(const Polygon& t) { return t.points.begin(); } // Get the end iterator static inline iterator_type end_points(const Polygon& t) { return t.points.end(); } // Get the number of sides of the polygon static inline std::size_t size(const Polygon& t) { return t.points.size(); } // Get the winding direction of the polygon static inline winding_direction winding(const Polygon& t) { return unknown_winding; } }; template <> struct polygon_mutable_traits { // expects stl style iterators template static inline Polygon& set_points(Polygon& polygon, iT input_begin, iT input_end) { polygon.points.clear(); while (input_begin != input_end) { polygon.points.push_back(Point()); boost::polygon::assign(polygon.points.back(), *input_begin); ++input_begin; } // skip last point since Boost will set last point = first point polygon.points.pop_back(); return polygon; } }; template <> struct geometry_concept { typedef polygon_set_concept type; }; //next we map to the concept through traits template <> struct polygon_set_traits { typedef coord_t coordinate_type; typedef Polygons::const_iterator iterator_type; typedef Polygons operator_arg_type; static inline iterator_type begin(const Polygons& polygon_set) { return polygon_set.begin(); } static inline iterator_type end(const Polygons& polygon_set) { return polygon_set.end(); } //don't worry about these, just return false from them static inline bool clean(const Polygons& polygon_set) { return false; } static inline bool sorted(const Polygons& polygon_set) { return false; } }; template <> struct polygon_set_mutable_traits { template static inline void set(Polygons& polygons, input_iterator_type input_begin, input_iterator_type input_end) { polygons.assign(input_begin, input_end); } }; } } // end Boost #endif Slic3r-version_1.31.6/xs/src/libslic3r/Polyline.cpp000066400000000000000000000161561301441720000221150ustar00rootroot00000000000000#include "BoundingBox.hpp" #include "Polyline.hpp" #include "ExPolygon.hpp" #include "ExPolygonCollection.hpp" #include "Line.hpp" #include "Polygon.hpp" #include #include namespace Slic3r { Polyline::operator Polylines() const { Polylines polylines; polylines.push_back(*this); return polylines; } Polyline::operator Line() const { if (this->points.size() > 2) CONFESS("Can't convert polyline with more than two points to a line"); return Line(this->points.front(), this->points.back()); } Point Polyline::last_point() const { return this->points.back(); } Point Polyline::leftmost_point() const { Point p = this->points.front(); for (Points::const_iterator it = this->points.begin() + 1; it != this->points.end(); ++it) { if (it->x < p.x) p = *it; } return p; } Lines Polyline::lines() const { Lines lines; if (this->points.size() >= 2) { lines.reserve(this->points.size() - 1); for (Points::const_iterator it = this->points.begin(); it != this->points.end()-1; ++it) { lines.push_back(Line(*it, *(it + 1))); } } return lines; } // removes the given distance from the end of the polyline void Polyline::clip_end(double distance) { while (distance > 0) { Point last_point = this->last_point(); this->points.pop_back(); if (this->points.empty()) break; double last_segment_length = last_point.distance_to(this->last_point()); if (last_segment_length <= distance) { distance -= last_segment_length; continue; } Line segment(last_point, this->last_point()); this->points.push_back(segment.point_at(distance)); distance = 0; } } // removes the given distance from the start of the polyline void Polyline::clip_start(double distance) { this->reverse(); this->clip_end(distance); if (this->points.size() >= 2) this->reverse(); } void Polyline::extend_end(double distance) { // relocate last point by extending the last segment by the specified length Line line( this->points.back(), *(this->points.end() - 2) ); this->points.back() = line.point_at(-distance); } void Polyline::extend_start(double distance) { // relocate first point by extending the first segment by the specified length this->points.front() = Line(this->points.front(), this->points[1]).point_at(-distance); } /* this method returns a collection of points picked on the polygon contour so that they are evenly spaced according to the input distance */ Points Polyline::equally_spaced_points(double distance) const { Points points; points.push_back(this->first_point()); double len = 0; for (Points::const_iterator it = this->points.begin() + 1; it != this->points.end(); ++it) { double segment_length = it->distance_to(*(it-1)); len += segment_length; if (len < distance) continue; if (len == distance) { points.push_back(*it); len = 0; continue; } double take = segment_length - (len - distance); // how much we take of this segment Line segment(*(it-1), *it); points.push_back(segment.point_at(take)); --it; len = -take; } return points; } void Polyline::simplify(double tolerance) { this->points = MultiPoint::_douglas_peucker(this->points, tolerance); } /* This method simplifies all *lines* contained in the supplied area */ template void Polyline::simplify_by_visibility(const T &area) { Points &pp = this->points; size_t s = 0; bool did_erase = false; for (size_t i = s+2; i < pp.size(); i = s + 2) { if (area.contains(Line(pp[s], pp[i]))) { pp.erase(pp.begin() + s + 1, pp.begin() + i); did_erase = true; } else { ++s; } } if (did_erase) this->simplify_by_visibility(area); } template void Polyline::simplify_by_visibility(const ExPolygon &area); template void Polyline::simplify_by_visibility(const ExPolygonCollection &area); void Polyline::split_at(const Point &point, Polyline* p1, Polyline* p2) const { if (this->points.empty()) return; // find the line to split at size_t line_idx = 0; Point p = this->first_point(); double min = point.distance_to(p); Lines lines = this->lines(); for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { Point p_tmp = point.projection_onto(*line); if (point.distance_to(p_tmp) < min) { p = p_tmp; min = point.distance_to(p); line_idx = line - lines.begin(); } } // create first half p1->points.clear(); for (Lines::const_iterator line = lines.begin(); line != lines.begin() + line_idx + 1; ++line) { if (!line->a.coincides_with(p)) p1->points.push_back(line->a); } // we add point instead of p because they might differ because of numerical issues // and caller might want to rely on point belonging to result polylines p1->points.push_back(point); // create second half p2->points.clear(); p2->points.push_back(point); for (Lines::const_iterator line = lines.begin() + line_idx; line != lines.end(); ++line) { p2->points.push_back(line->b); } } bool Polyline::is_straight() const { /* Check that each segment's direction is equal to the line connecting first point and last point. (Checking each line against the previous one would cause the error to accumulate.) */ double dir = Line(this->first_point(), this->last_point()).direction(); Lines lines = this->lines(); for (Lines::const_iterator line = lines.begin(); line != lines.end(); ++line) { if (!line->parallel_to(dir)) return false; } return true; } std::string Polyline::wkt() const { std::ostringstream wkt; wkt << "LINESTRING(("; for (Points::const_iterator p = this->points.begin(); p != this->points.end(); ++p) { wkt << p->x << " " << p->y; if (p != this->points.end()-1) wkt << ","; } wkt << "))"; return wkt.str(); } BoundingBox get_extents(const Polyline &polyline) { return polyline.bounding_box(); } BoundingBox get_extents(const Polylines &polylines) { BoundingBox bb; if (! polylines.empty()) { bb = polylines.front().bounding_box(); for (size_t i = 1; i < polylines.size(); ++ i) bb.merge(polylines[i]); } return bb; } ThickLines ThickPolyline::thicklines() const { ThickLines lines; if (this->points.size() >= 2) { lines.reserve(this->points.size() - 1); for (size_t i = 0; i < this->points.size()-1; ++i) { ThickLine line(this->points[i], this->points[i+1]); line.a_width = this->width[2*i]; line.b_width = this->width[2*i+1]; lines.push_back(line); } } return lines; } void ThickPolyline::reverse() { Polyline::reverse(); std::reverse(this->width.begin(), this->width.end()); std::swap(this->endpoints.first, this->endpoints.second); } } Slic3r-version_1.31.6/xs/src/libslic3r/Polyline.hpp000066400000000000000000000042061301441720000221130ustar00rootroot00000000000000#ifndef slic3r_Polyline_hpp_ #define slic3r_Polyline_hpp_ #include "libslic3r.h" #include "Line.hpp" #include "MultiPoint.hpp" #include #include namespace Slic3r { class Polyline; class ThickPolyline; typedef std::vector Polylines; typedef std::vector ThickPolylines; class Polyline : public MultiPoint { public: operator Polylines() const; operator Line() const; Point last_point() const; Point leftmost_point() const; virtual Lines lines() const; void clip_end(double distance); void clip_start(double distance); void extend_end(double distance); void extend_start(double distance); Points equally_spaced_points(double distance) const; void simplify(double tolerance); template void simplify_by_visibility(const T &area); void split_at(const Point &point, Polyline* p1, Polyline* p2) const; bool is_straight() const; std::string wkt() const; }; extern BoundingBox get_extents(const Polyline &polyline); extern BoundingBox get_extents(const Polylines &polylines); inline Lines to_lines(const Polyline &poly) { Lines lines; if (poly.points.size() >= 2) { lines.reserve(poly.points.size() - 1); for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it) lines.push_back(Line(*it, *(it + 1))); } return lines; } inline Lines to_lines(const Polylines &polys) { size_t n_lines = 0; for (size_t i = 0; i < polys.size(); ++ i) if (polys[i].points.size() > 1) n_lines += polys[i].points.size() - 1; Lines lines; lines.reserve(n_lines); for (size_t i = 0; i < polys.size(); ++ i) { const Polyline &poly = polys[i]; for (Points::const_iterator it = poly.points.begin(); it != poly.points.end()-1; ++it) lines.push_back(Line(*it, *(it + 1))); } return lines; } class ThickPolyline : public Polyline { public: std::vector width; std::pair endpoints; ThickPolyline() : endpoints(std::make_pair(false, false)) {}; ThickLines thicklines() const; void reverse(); }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/PolylineCollection.cpp000066400000000000000000000076501301441720000241300ustar00rootroot00000000000000#include "PolylineCollection.hpp" namespace Slic3r { struct Chaining { Point first; Point last; size_t idx; }; #ifndef sqr template inline T sqr(T x) { return x * x; } #endif /* sqr */ template inline int nearest_point_index(const std::vector &pairs, const Point &start_near, bool no_reverse) { T dmin = std::numeric_limits::max(); int idx = 0; for (std::vector::const_iterator it = pairs.begin(); it != pairs.end(); ++it) { T d = sqr(T(start_near.x - it->first.x)); if (d <= dmin) { d += sqr(T(start_near.y - it->first.y)); if (d < dmin) { idx = (it - pairs.begin()) * 2; dmin = d; if (dmin < EPSILON) break; } } if (! no_reverse) { d = sqr(T(start_near.x - it->last.x)); if (d <= dmin) { d += sqr(T(start_near.y - it->last.y)); if (d < dmin) { idx = (it - pairs.begin()) * 2 + 1; dmin = d; if (dmin < EPSILON) break; } } } } return idx; } Polylines PolylineCollection::_chained_path_from( const Polylines &src, Point start_near, bool no_reverse #if SLIC3R_CPPVER >= 11 , bool move_from_src #endif ) { std::vector endpoints; endpoints.reserve(src.size()); for (size_t i = 0; i < src.size(); ++ i) { Chaining c; c.first = src[i].first_point(); if (! no_reverse) c.last = src[i].last_point(); c.idx = i; endpoints.push_back(c); } Polylines retval; while (! endpoints.empty()) { // find nearest point int endpoint_index = nearest_point_index(endpoints, start_near, no_reverse); assert(endpoint_index >= 0 && endpoint_index < endpoints.size() * 2); #if SLIC3R_CPPVER > 11 if (move_from_src) { retval.push_back(std::move(src[endpoints[endpoint_index/2].idx])); } else { retval.push_back(src[endpoints[endpoint_index/2].idx]); } #else retval.push_back(src[endpoints[endpoint_index/2].idx]); #endif if (endpoint_index & 1) retval.back().reverse(); endpoints.erase(endpoints.begin() + endpoint_index/2); start_near = retval.back().last_point(); } return retval; } #if SLIC3R_CPPVER >= 11 Polylines PolylineCollection::chained_path(Polylines &&src, bool no_reverse) { return (src.empty() || src.front().points.empty()) ? Polylines() : _chained_path_from(src, src.front().first_point(), no_reverse, true); } Polylines PolylineCollection::chained_path_from(Polylines &&src, Point start_near, bool no_reverse) { return _chained_path_from(src, start_near, no_reverse, true); } #endif Polylines PolylineCollection::chained_path(const Polylines &src, bool no_reverse) { return (src.empty() || src.front().points.empty()) ? Polylines() : _chained_path_from(src, src.front().first_point(), no_reverse #if SLIC3R_CPPVER >= 11 , false #endif ); } Polylines PolylineCollection::chained_path_from(const Polylines &src, Point start_near, bool no_reverse) { return _chained_path_from(src, start_near, no_reverse #if SLIC3R_CPPVER >= 11 , false #endif ); } Point PolylineCollection::leftmost_point(const Polylines &polylines) { if (polylines.empty()) CONFESS("leftmost_point() called on empty PolylineCollection"); Polylines::const_iterator it = polylines.begin(); Point p = it->leftmost_point(); for (++ it; it != polylines.end(); ++it) { Point p2 = it->leftmost_point(); if (p2.x < p.x) p = p2; } return p; } void PolylineCollection::append(const Polylines &pp) { this->polylines.insert(this->polylines.end(), pp.begin(), pp.end()); } } // namespace Slic3r Slic3r-version_1.31.6/xs/src/libslic3r/PolylineCollection.hpp000066400000000000000000000024611301441720000241300ustar00rootroot00000000000000#ifndef slic3r_PolylineCollection_hpp_ #define slic3r_PolylineCollection_hpp_ #include "libslic3r.h" #include "Polyline.hpp" namespace Slic3r { class PolylineCollection { static Polylines _chained_path_from( const Polylines &src, Point start_near, bool no_reverse #if SLIC3R_CPPVER >= 11 , bool move_from_src #endif ); public: Polylines polylines; void chained_path(PolylineCollection* retval, bool no_reverse = false) const { retval->polylines = chained_path(this->polylines, no_reverse); } void chained_path_from(Point start_near, PolylineCollection* retval, bool no_reverse = false) const { retval->polylines = chained_path_from(this->polylines, start_near, no_reverse); } Point leftmost_point() const { return leftmost_point(polylines); } void append(const Polylines &polylines); static Point leftmost_point(const Polylines &polylines); #if SLIC3R_CPPVER >= 11 static Polylines chained_path(Polylines &&src, bool no_reverse = false); static Polylines chained_path_from(Polylines &&src, Point start_near, bool no_reverse = false); #endif static Polylines chained_path(const Polylines &src, bool no_reverse = false); static Polylines chained_path_from(const Polylines &src, Point start_near, bool no_reverse = false); }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/Print.cpp000066400000000000000000000735451301441720000214230ustar00rootroot00000000000000#include "Print.hpp" #include "BoundingBox.hpp" #include "ClipperUtils.hpp" #include "Flow.hpp" #include "Geometry.hpp" #include "SupportMaterial.hpp" #include namespace Slic3r { template bool PrintState::is_started(StepClass step) const { return this->started.find(step) != this->started.end(); } template bool PrintState::is_done(StepClass step) const { return this->done.find(step) != this->done.end(); } template void PrintState::set_started(StepClass step) { this->started.insert(step); } template void PrintState::set_done(StepClass step) { this->done.insert(step); } template bool PrintState::invalidate(StepClass step) { bool invalidated = this->started.erase(step) > 0; this->done.erase(step); return invalidated; } template class PrintState; template class PrintState; Print::Print() : total_used_filament(0), total_extruded_volume(0) { } Print::~Print() { clear_objects(); clear_regions(); } void Print::clear_objects() { for (int i = this->objects.size()-1; i >= 0; --i) this->delete_object(i); this->clear_regions(); } PrintObject* Print::get_object(size_t idx) { return objects.at(idx); } void Print::delete_object(size_t idx) { PrintObjectPtrs::iterator i = this->objects.begin() + idx; // before deleting object, invalidate all of its steps in order to // invalidate all of the dependent ones in Print (*i)->invalidate_all_steps(); // destroy object and remove it from our container delete *i; this->objects.erase(i); // TODO: purge unused regions } void Print::reload_object(size_t idx) { /* TODO: this method should check whether the per-object config and per-material configs have changed in such a way that regions need to be rearranged or we can just apply the diff and invalidate something. Same logic as apply_config() For now we just re-add all objects since we haven't implemented this incremental logic yet. This should also check whether object volumes (parts) have changed. */ // collect all current model objects ModelObjectPtrs model_objects; FOREACH_OBJECT(this, object) { model_objects.push_back((*object)->model_object()); } // remove our print objects this->clear_objects(); // re-add model objects for (ModelObjectPtrs::iterator it = model_objects.begin(); it != model_objects.end(); ++it) { this->add_model_object(*it); } } bool Print::reload_model_instances() { bool invalidated = false; FOREACH_OBJECT(this, object) { if ((*object)->reload_model_instances()) invalidated = true; } return invalidated; } void Print::clear_regions() { for (int i = this->regions.size()-1; i >= 0; --i) this->delete_region(i); } PrintRegion* Print::get_region(size_t idx) { return regions.at(idx); } PrintRegion* Print::add_region() { PrintRegion *region = new PrintRegion(this); regions.push_back(region); return region; } void Print::delete_region(size_t idx) { PrintRegionPtrs::iterator i = this->regions.begin() + idx; delete *i; this->regions.erase(i); } bool Print::invalidate_state_by_config_options(const std::vector &opt_keys) { std::set steps; std::set osteps; // this method only accepts PrintConfig option keys for (std::vector::const_iterator opt_key = opt_keys.begin(); opt_key != opt_keys.end(); ++opt_key) { if (*opt_key == "skirts" || *opt_key == "skirt_height" || *opt_key == "skirt_distance" || *opt_key == "min_skirt_length" || *opt_key == "ooze_prevention") { steps.insert(psSkirt); } else if (*opt_key == "brim_width") { steps.insert(psBrim); steps.insert(psSkirt); } else if (*opt_key == "nozzle_diameter" || *opt_key == "resolution") { osteps.insert(posSlice); } else if (*opt_key == "avoid_crossing_perimeters" || *opt_key == "bed_shape" || *opt_key == "bed_temperature" || *opt_key == "bridge_acceleration" || *opt_key == "bridge_fan_speed" || *opt_key == "complete_objects" || *opt_key == "cooling" || *opt_key == "default_acceleration" || *opt_key == "disable_fan_first_layers" || *opt_key == "duplicate_distance" || *opt_key == "end_gcode" || *opt_key == "extruder_clearance_height" || *opt_key == "extruder_clearance_radius" || *opt_key == "extruder_offset" || *opt_key == "extrusion_axis" || *opt_key == "extrusion_multiplier" || *opt_key == "fan_always_on" || *opt_key == "fan_below_layer_time" || *opt_key == "filament_diameter" || *opt_key == "first_layer_acceleration" || *opt_key == "first_layer_bed_temperature" || *opt_key == "first_layer_speed" || *opt_key == "first_layer_temperature" || *opt_key == "gcode_arcs" || *opt_key == "gcode_comments" || *opt_key == "gcode_flavor" || *opt_key == "infill_acceleration" || *opt_key == "infill_first" || *opt_key == "layer_gcode" || *opt_key == "min_fan_speed" || *opt_key == "max_fan_speed" || *opt_key == "min_print_speed" || *opt_key == "notes" || *opt_key == "only_retract_when_crossing_perimeters" || *opt_key == "output_filename_format" || *opt_key == "perimeter_acceleration" || *opt_key == "post_process" || *opt_key == "pressure_advance" || *opt_key == "retract_before_travel" || *opt_key == "retract_layer_change" || *opt_key == "retract_length" || *opt_key == "retract_length_toolchange" || *opt_key == "retract_lift" || *opt_key == "retract_lift_above" || *opt_key == "retract_lift_below" || *opt_key == "retract_restart_extra" || *opt_key == "retract_restart_extra_toolchange" || *opt_key == "retract_speed" || *opt_key == "slowdown_below_layer_time" || *opt_key == "spiral_vase" || *opt_key == "standby_temperature_delta" || *opt_key == "start_gcode" || *opt_key == "temperature" || *opt_key == "threads" || *opt_key == "toolchange_gcode" || *opt_key == "travel_speed" || *opt_key == "use_firmware_retraction" || *opt_key == "use_relative_e_distances" || *opt_key == "wipe" || *opt_key == "z_offset" || *opt_key == "max_volumetric_extrusion_rate_slope_negative" || *opt_key == "max_volumetric_extrusion_rate_slope_positive") { // these options only affect G-code export, so nothing to invalidate } else if (*opt_key == "first_layer_extrusion_width") { osteps.insert(posPerimeters); osteps.insert(posInfill); osteps.insert(posSupportMaterial); steps.insert(psSkirt); steps.insert(psBrim); } else { // for legacy, if we can't handle this option let's invalidate all steps return this->invalidate_all_steps(); } } bool invalidated = false; for (std::set::const_iterator step = steps.begin(); step != steps.end(); ++step) { if (this->invalidate_step(*step)) invalidated = true; } for (std::set::const_iterator ostep = osteps.begin(); ostep != osteps.end(); ++ostep) { FOREACH_OBJECT(this, object) { if ((*object)->invalidate_step(*ostep)) invalidated = true; } } return invalidated; } bool Print::invalidate_step(PrintStep step) { bool invalidated = this->state.invalidate(step); // propagate to dependent steps if (step == psSkirt) { this->invalidate_step(psBrim); } return invalidated; } bool Print::invalidate_all_steps() { // make a copy because when invalidating steps the iterators are not working anymore std::set steps = this->state.started; bool invalidated = false; for (std::set::const_iterator step = steps.begin(); step != steps.end(); ++step) { if (this->invalidate_step(*step)) invalidated = true; } return invalidated; } // returns true if an object step is done on all objects // and there's at least one object bool Print::step_done(PrintObjectStep step) const { if (this->objects.empty()) return false; FOREACH_OBJECT(this, object) { if (!(*object)->state.is_done(step)) return false; } return true; } // returns 0-based indices of used extruders std::set Print::object_extruders() const { std::set extruders; FOREACH_REGION(this, region) { // these checks reflect the same logic used in the GUI for enabling/disabling // extruder selection fields if ((*region)->config.perimeters.value > 0 || this->config.brim_width.value > 0) extruders.insert((*region)->config.perimeter_extruder - 1); if ((*region)->config.fill_density.value > 0) extruders.insert((*region)->config.infill_extruder - 1); if ((*region)->config.top_solid_layers.value > 0 || (*region)->config.bottom_solid_layers.value > 0) extruders.insert((*region)->config.solid_infill_extruder - 1); } return extruders; } // returns 0-based indices of used extruders std::set Print::support_material_extruders() const { std::set extruders; FOREACH_OBJECT(this, object) { if ((*object)->has_support_material()) { extruders.insert((*object)->config.support_material_extruder - 1); extruders.insert((*object)->config.support_material_interface_extruder - 1); } } return extruders; } // returns 0-based indices of used extruders std::set Print::extruders() const { std::set extruders = this->object_extruders(); std::set s_extruders = this->support_material_extruders(); extruders.insert(s_extruders.begin(), s_extruders.end()); return extruders; } void Print::_simplify_slices(double distance) { FOREACH_OBJECT(this, object) { FOREACH_LAYER(*object, layer) { (*layer)->slices.simplify(distance); FOREACH_LAYERREGION(*layer, layerm) { (*layerm)->slices.simplify(distance); } } } } double Print::max_allowed_layer_height() const { std::vector nozzle_diameter; std::set extruders = this->extruders(); for (std::set::const_iterator e = extruders.begin(); e != extruders.end(); ++e) { nozzle_diameter.push_back(this->config.nozzle_diameter.get_at(*e)); } return *std::max_element(nozzle_diameter.begin(), nozzle_diameter.end()); } /* Caller is responsible for supplying models whose objects don't collide and have explicit instance positions */ void Print::add_model_object(ModelObject* model_object, int idx) { DynamicPrintConfig object_config = model_object->config; // clone object_config.normalize(); // initialize print object and store it at the given position PrintObject* o; { BoundingBoxf3 bb = model_object->raw_bounding_box(); if (idx != -1) { // replacing existing object PrintObjectPtrs::iterator old_it = this->objects.begin() + idx; // before deleting object, invalidate all of its steps in order to // invalidate all of the dependent ones in Print (*old_it)->invalidate_all_steps(); delete *old_it; this->objects[idx] = o = new PrintObject(this, model_object, bb); } else { o = new PrintObject(this, model_object, bb); objects.push_back(o); // invalidate steps this->invalidate_step(psSkirt); this->invalidate_step(psBrim); } } for (ModelVolumePtrs::const_iterator v_i = model_object->volumes.begin(); v_i != model_object->volumes.end(); ++v_i) { size_t volume_id = v_i - model_object->volumes.begin(); ModelVolume* volume = *v_i; // get the config applied to this volume PrintRegionConfig config = this->_region_config_from_model_volume(*volume); // find an existing print region with the same config int region_id = -1; for (PrintRegionPtrs::const_iterator region = this->regions.begin(); region != this->regions.end(); ++region) { if (config.equals((*region)->config)) { region_id = region - this->regions.begin(); break; } } // if no region exists with the same config, create a new one if (region_id == -1) { PrintRegion* r = this->add_region(); r->config.apply(config); region_id = this->regions.size() - 1; } // assign volume to region o->add_region_volume(region_id, volume_id); } // apply config to print object o->config.apply(this->default_object_config); o->config.apply(object_config, true); } bool Print::apply_config(DynamicPrintConfig config) { // we get a copy of the config object so we can modify it safely config.normalize(); // apply variables to placeholder parser this->placeholder_parser.apply_config(config); bool invalidated = false; // handle changes to print config t_config_option_keys print_diff = this->config.diff(config); if (!print_diff.empty()) { this->config.apply(config, true); if (this->invalidate_state_by_config_options(print_diff)) invalidated = true; } // handle changes to object config defaults this->default_object_config.apply(config, true); FOREACH_OBJECT(this, obj_ptr) { // we don't assume that config contains a full ObjectConfig, // so we base it on the current print-wise default PrintObjectConfig new_config = this->default_object_config; new_config.apply(config, true); // we override the new config with object-specific options { DynamicPrintConfig model_object_config = (*obj_ptr)->model_object()->config; model_object_config.normalize(); new_config.apply(model_object_config, true); } // check whether the new config is different from the current one t_config_option_keys diff = (*obj_ptr)->config.diff(new_config); if (!diff.empty()) { (*obj_ptr)->config.apply(new_config, true); if ((*obj_ptr)->invalidate_state_by_config_options(diff)) invalidated = true; } } // handle changes to regions config defaults this->default_region_config.apply(config, true); // All regions now have distinct settings. // Check whether applying the new region config defaults we'd get different regions. bool rearrange_regions = false; std::vector other_region_configs; FOREACH_REGION(this, it_r) { size_t region_id = it_r - this->regions.begin(); PrintRegion* region = *it_r; std::vector this_region_configs; FOREACH_OBJECT(this, it_o) { PrintObject* object = *it_o; std::vector ®ion_volumes = object->region_volumes[region_id]; for (std::vector::const_iterator volume_id = region_volumes.begin(); volume_id != region_volumes.end(); ++volume_id) { ModelVolume* volume = object->model_object()->volumes.at(*volume_id); PrintRegionConfig new_config = this->_region_config_from_model_volume(*volume); for (std::vector::iterator it = this_region_configs.begin(); it != this_region_configs.end(); ++it) { // if the new config for this volume differs from the other // volume configs currently associated to this region, it means // the region subdivision does not make sense anymore if (!it->equals(new_config)) { rearrange_regions = true; goto NEXT_REGION; } } this_region_configs.push_back(new_config); for (std::vector::iterator it = other_region_configs.begin(); it != other_region_configs.end(); ++it) { // if the new config for this volume equals any of the other // volume configs that are not currently associated to this // region, it means the region subdivision does not make // sense anymore if (it->equals(new_config)) { rearrange_regions = true; goto NEXT_REGION; } } // if we're here and the new region config is different from the old // one, we need to apply the new config and invalidate all objects // (possible optimization: only invalidate objects using this region) t_config_option_keys region_config_diff = region->config.diff(new_config); if (!region_config_diff.empty()) { region->config.apply(new_config); FOREACH_OBJECT(this, o) { if ((*o)->invalidate_state_by_config_options(region_config_diff)) invalidated = true; } } } } other_region_configs.insert(other_region_configs.end(), this_region_configs.begin(), this_region_configs.end()); NEXT_REGION: continue; } if (rearrange_regions) { // the current subdivision of regions does not make sense anymore. // we need to remove all objects and re-add them ModelObjectPtrs model_objects; FOREACH_OBJECT(this, o) { model_objects.push_back((*o)->model_object()); } this->clear_objects(); for (ModelObjectPtrs::iterator it = model_objects.begin(); it != model_objects.end(); ++it) { this->add_model_object(*it); } invalidated = true; } return invalidated; } bool Print::has_infinite_skirt() const { return (this->config.skirt_height == -1 && this->config.skirts > 0) || (this->config.ooze_prevention && this->extruders().size() > 1); } bool Print::has_skirt() const { return (this->config.skirt_height > 0 && this->config.skirts > 0) || this->has_infinite_skirt(); } std::string Print::validate() const { if (this->config.complete_objects) { // check horizontal clearance { Polygons a; FOREACH_OBJECT(this, i_object) { PrintObject* object = *i_object; /* get convex hull of all meshes assigned to this print object (this is the same as model_object()->raw_mesh.convex_hull() but probably more efficient */ Polygon convex_hull; { Polygons mesh_convex_hulls; for (size_t i = 0; i < this->regions.size(); ++i) { for (std::vector::const_iterator it = object->region_volumes[i].begin(); it != object->region_volumes[i].end(); ++it) { Polygon hull = object->model_object()->volumes[*it]->mesh.convex_hull(); mesh_convex_hulls.push_back(hull); } } // make a single convex hull for all of them convex_hull = Slic3r::Geometry::convex_hull(mesh_convex_hulls); } // apply the same transformations we apply to the actual meshes when slicing them object->model_object()->instances.front()->transform_polygon(&convex_hull); // grow convex hull with the clearance margin { Polygons grown_hull; offset(convex_hull, &grown_hull, scale_(this->config.extruder_clearance_radius.value)/2, 1, jtRound, scale_(0.1)); convex_hull = grown_hull.front(); } // now we check that no instance of convex_hull intersects any of the previously checked object instances for (Points::const_iterator copy = object->_shifted_copies.begin(); copy != object->_shifted_copies.end(); ++copy) { Polygon p = convex_hull; p.translate(*copy); if (intersects(a, p)) return "Some objects are too close; your extruder will collide with them."; union_(a, p, &a); } } } // check vertical clearance { std::vector object_height; FOREACH_OBJECT(this, i_object) { PrintObject* object = *i_object; object_height.insert(object_height.end(), object->copies().size(), object->size.z); } std::sort(object_height.begin(), object_height.end()); // ignore the tallest *copy* (this is why we repeat height for all of them): // it will be printed as last one so its height doesn't matter object_height.pop_back(); if (!object_height.empty() && object_height.back() > scale_(this->config.extruder_clearance_height.value)) return "Some objects are too tall and cannot be printed without extruder collisions."; } } // end if (this->config.complete_objects) if (this->config.spiral_vase) { size_t total_copies_count = 0; FOREACH_OBJECT(this, i_object) total_copies_count += (*i_object)->copies().size(); if (total_copies_count > 1) return "The Spiral Vase option can only be used when printing a single object."; if (this->regions.size() > 1) return "The Spiral Vase option can only be used when printing single material objects."; } { // find the smallest nozzle diameter std::set extruders = this->extruders(); if (extruders.empty()) return "The supplied settings will cause an empty print."; std::set nozzle_diameters; for (std::set::iterator it = extruders.begin(); it != extruders.end(); ++it) nozzle_diameters.insert(this->config.nozzle_diameter.get_at(*it)); double min_nozzle_diameter = *std::min_element(nozzle_diameters.begin(), nozzle_diameters.end()); FOREACH_OBJECT(this, i_object) { PrintObject* object = *i_object; // validate first_layer_height double first_layer_height = object->config.get_abs_value("first_layer_height"); double first_layer_min_nozzle_diameter; if (object->config.raft_layers > 0) { // if we have raft layers, only support material extruder is used on first layer size_t first_layer_extruder = object->config.raft_layers == 1 ? object->config.support_material_interface_extruder-1 : object->config.support_material_extruder-1; first_layer_min_nozzle_diameter = this->config.nozzle_diameter.get_at(first_layer_extruder); } else { // if we don't have raft layers, any nozzle diameter is potentially used in first layer first_layer_min_nozzle_diameter = min_nozzle_diameter; } if (first_layer_height > first_layer_min_nozzle_diameter) return "First layer height can't be greater than nozzle diameter"; // validate layer_height if (object->config.layer_height.value > min_nozzle_diameter) return "Layer height can't be greater than nozzle diameter"; } } return std::string(); } // the bounding box of objects placed in copies position // (without taking skirt/brim/support material into account) BoundingBox Print::bounding_box() const { BoundingBox bb; FOREACH_OBJECT(this, object) { for (Points::const_iterator copy = (*object)->_shifted_copies.begin(); copy != (*object)->_shifted_copies.end(); ++copy) { bb.merge(*copy); Point p = *copy; p.translate((*object)->size); bb.merge(p); } } return bb; } // the total bounding box of extrusions, including skirt/brim/support material // this methods needs to be called even when no steps were processed, so it should // only use configuration values BoundingBox Print::total_bounding_box() const { // get objects bounding box BoundingBox bb = this->bounding_box(); // we need to offset the objects bounding box by at least half the perimeters extrusion width Flow perimeter_flow = this->objects.front()->get_layer(0)->get_region(0)->flow(frPerimeter); double extra = perimeter_flow.width/2; // consider support material if (this->has_support_material()) { extra = std::max(extra, SUPPORT_MATERIAL_MARGIN); } // consider brim and skirt if (this->config.brim_width.value > 0) { Flow brim_flow = this->brim_flow(); extra = std::max(extra, this->config.brim_width.value + brim_flow.width/2); } if (this->has_skirt()) { int skirts = this->config.skirts.value; if (skirts == 0 && this->has_infinite_skirt()) skirts = 1; Flow skirt_flow = this->skirt_flow(); extra = std::max( extra, this->config.brim_width.value + this->config.skirt_distance.value + skirts * skirt_flow.spacing() + skirt_flow.width/2 ); } if (extra > 0) bb.offset(scale_(extra)); return bb; } double Print::skirt_first_layer_height() const { if (this->objects.empty()) CONFESS("skirt_first_layer_height() can't be called without PrintObjects"); return this->objects.front()->config.get_abs_value("first_layer_height"); } Flow Print::brim_flow() const { ConfigOptionFloatOrPercent width = this->config.first_layer_extrusion_width; if (width.value == 0) width = this->regions.front()->config.perimeter_extrusion_width; /* We currently use a random region's perimeter extruder. While this works for most cases, we should probably consider all of the perimeter extruders and take the one with, say, the smallest index. The same logic should be applied to the code that selects the extruder during G-code generation as well. */ return Flow::new_from_config_width( frPerimeter, width, this->config.nozzle_diameter.get_at(this->regions.front()->config.perimeter_extruder-1), this->skirt_first_layer_height(), 0 ); } Flow Print::skirt_flow() const { ConfigOptionFloatOrPercent width = this->config.first_layer_extrusion_width; if (width.value == 0) width = this->regions.front()->config.perimeter_extrusion_width; /* We currently use a random object's support material extruder. While this works for most cases, we should probably consider all of the support material extruders and take the one with, say, the smallest index; The same logic should be applied to the code that selects the extruder during G-code generation as well. */ return Flow::new_from_config_width( frPerimeter, width, this->config.nozzle_diameter.get_at(this->objects.front()->config.support_material_extruder-1), this->skirt_first_layer_height(), 0 ); } PrintRegionConfig Print::_region_config_from_model_volume(const ModelVolume &volume) { PrintRegionConfig config = this->default_region_config; { DynamicPrintConfig other_config = volume.get_object()->config; other_config.normalize(); config.apply(other_config, true); } { DynamicPrintConfig other_config = volume.config; other_config.normalize(); config.apply(other_config, true); } if (!volume.material_id().empty()) { DynamicPrintConfig material_config = volume.material()->config; material_config.normalize(); config.apply(material_config, true); } return config; } bool Print::has_support_material() const { FOREACH_OBJECT(this, object) { if ((*object)->has_support_material()) return true; } return false; } /* This method assigns extruders to the volumes having a material but not having extruders set in the volume config. */ void Print::auto_assign_extruders(ModelObject* model_object) const { // only assign extruders if object has more than one volume if (model_object->volumes.size() < 2) return; size_t extruders = this->config.nozzle_diameter.values.size(); for (ModelVolumePtrs::const_iterator v = model_object->volumes.begin(); v != model_object->volumes.end(); ++v) { if (!(*v)->material_id().empty()) { //FIXME Vojtech: This assigns an extruder ID even to a modifier volume, if it has a material assigned. size_t extruder_id = (v - model_object->volumes.begin()) + 1; if (!(*v)->config.has("extruder")) (*v)->config.opt("extruder", true)->value = extruder_id; } } } } Slic3r-version_1.31.6/xs/src/libslic3r/Print.hpp000066400000000000000000000170061301441720000214160ustar00rootroot00000000000000#ifndef slic3r_Print_hpp_ #define slic3r_Print_hpp_ #include "libslic3r.h" #include #include #include #include "BoundingBox.hpp" #include "Flow.hpp" #include "PrintConfig.hpp" #include "Point.hpp" #include "Layer.hpp" #include "Model.hpp" #include "PlaceholderParser.hpp" namespace Slic3r { class Print; class PrintObject; class ModelObject; // Print step IDs for keeping track of the print state. enum PrintStep { psSkirt, psBrim, }; enum PrintObjectStep { posSlice, posPerimeters, posPrepareInfill, posInfill, posSupportMaterial, }; // To be instantiated over PrintStep or PrintObjectStep enums. template class PrintState { public: std::set started, done; bool is_started(StepType step) const; bool is_done(StepType step) const; void set_started(StepType step); void set_done(StepType step); bool invalidate(StepType step); }; // A PrintRegion object represents a group of volumes to print // sharing the same config (including the same assigned extruder(s)) class PrintRegion { friend class Print; public: PrintRegionConfig config; Print* print(); Flow flow(FlowRole role, double layer_height, bool bridge, bool first_layer, double width, const PrintObject &object) const; private: Print* _print; PrintRegion(Print* print); ~PrintRegion(); }; typedef std::vector LayerPtrs; typedef std::vector SupportLayerPtrs; class BoundingBoxf3; // TODO: for temporary constructor parameter class PrintObject { friend class Print; public: // map of (vectors of volume ids), indexed by region_id /* (we use map instead of vector so that we don't have to worry about resizing it and the [] operator adds new items automagically) */ std::map< size_t,std::vector > region_volumes; PrintObjectConfig config; t_layer_height_ranges layer_height_ranges; // this is set to true when LayerRegion->slices is split in top/internal/bottom // so that next call to make_perimeters() performs a union() before computing loops bool typed_slices; Point3 size; // XYZ in scaled coordinates // scaled coordinates to add to copies (to compensate for the alignment // operated when creating the object but still preserving a coherent API // for external callers) Point _copies_shift; // Slic3r::Point objects in scaled G-code coordinates in our coordinates Points _shifted_copies; LayerPtrs layers; SupportLayerPtrs support_layers; PrintState state; Print* print() { return this->_print; } const Print* print() const { return this->_print; } ModelObject* model_object() { return this->_model_object; } const ModelObject* model_object() const { return this->_model_object; } Points copies() const { return this->_copies; } bool add_copy(const Pointf &point); bool delete_last_copy(); bool delete_all_copies(); bool set_copies(const Points &points); bool reload_model_instances(); BoundingBox bounding_box() const { // since the object is aligned to origin, bounding box coincides with size return BoundingBox(Point(0,0), this->size); } // adds region_id, too, if necessary void add_region_volume(int region_id, int volume_id); size_t total_layer_count() const; size_t layer_count() const; void clear_layers(); Layer* get_layer(int idx) { return this->layers.at(idx); } const Layer* get_layer(int idx) const { return this->layers.at(idx); } // print_z: top of the layer; slice_z: center of the layer. Layer* add_layer(int id, coordf_t height, coordf_t print_z, coordf_t slice_z); void delete_layer(int idx); size_t support_layer_count() const; void clear_support_layers(); SupportLayer* get_support_layer(int idx); SupportLayer* add_support_layer(int id, coordf_t height, coordf_t print_z); void delete_support_layer(int idx); // methods for handling state bool invalidate_state_by_config_options(const std::vector &opt_keys); bool invalidate_step(PrintObjectStep step); bool invalidate_all_steps(); bool has_support_material() const; void detect_surfaces_type(); void process_external_surfaces(); void discover_vertical_shells(); void bridge_over_infill(); private: Print* _print; ModelObject* _model_object; Points _copies; // Slic3r::Point objects in scaled G-code coordinates // TODO: call model_object->get_bounding_box() instead of accepting // parameter PrintObject(Print* print, ModelObject* model_object, const BoundingBoxf3 &modobj_bbox); ~PrintObject() {} }; typedef std::vector PrintObjectPtrs; typedef std::vector PrintRegionPtrs; // The complete print tray with possibly multiple objects. class Print { public: PrintConfig config; PrintObjectConfig default_object_config; PrintRegionConfig default_region_config; PrintObjectPtrs objects; PrintRegionPtrs regions; PlaceholderParser placeholder_parser; // TODO: status_cb double total_used_filament, total_extruded_volume; std::map filament_stats; PrintState state; // ordered collections of extrusion paths to build skirt loops and brim ExtrusionEntityCollection skirt, brim; Print(); ~Print(); // methods for handling objects void clear_objects(); PrintObject* get_object(size_t idx); void delete_object(size_t idx); void reload_object(size_t idx); bool reload_model_instances(); // methods for handling regions PrintRegion* get_region(size_t idx); PrintRegion* add_region(); // methods for handling state bool invalidate_state_by_config_options(const std::vector &opt_keys); bool invalidate_step(PrintStep step); bool invalidate_all_steps(); bool step_done(PrintObjectStep step) const; void add_model_object(ModelObject* model_object, int idx = -1); bool apply_config(DynamicPrintConfig config); bool has_infinite_skirt() const; bool has_skirt() const; // Returns an empty string if valid, otherwise returns an error message. std::string validate() const; BoundingBox bounding_box() const; BoundingBox total_bounding_box() const; double skirt_first_layer_height() const; Flow brim_flow() const; Flow skirt_flow() const; std::set object_extruders() const; std::set support_material_extruders() const; std::set extruders() const; void _simplify_slices(double distance); double max_allowed_layer_height() const; bool has_support_material() const; void auto_assign_extruders(ModelObject* model_object) const; private: void clear_regions(); void delete_region(size_t idx); PrintRegionConfig _region_config_from_model_volume(const ModelVolume &volume); }; #define FOREACH_BASE(type, container, iterator) for (type::const_iterator iterator = (container).begin(); iterator != (container).end(); ++iterator) #define FOREACH_REGION(print, region) FOREACH_BASE(PrintRegionPtrs, (print)->regions, region) #define FOREACH_OBJECT(print, object) FOREACH_BASE(PrintObjectPtrs, (print)->objects, object) #define FOREACH_LAYER(object, layer) FOREACH_BASE(LayerPtrs, (object)->layers, layer) #define FOREACH_LAYERREGION(layer, layerm) FOREACH_BASE(LayerRegionPtrs, (layer)->regions, layerm) } #endif Slic3r-version_1.31.6/xs/src/libslic3r/PrintConfig.cpp000066400000000000000000002115061301441720000225400ustar00rootroot00000000000000#include "PrintConfig.hpp" namespace Slic3r { PrintConfigDef::PrintConfigDef() { t_optiondef_map &Options = this->options; ConfigOptionDef* def; def = this->add("avoid_crossing_perimeters", coBool); def->label = "Avoid crossing perimeters"; def->tooltip = "Optimize travel moves in order to minimize the crossing of perimeters. This is mostly useful with Bowden extruders which suffer from oozing. This feature slows down both the print and the G-code generation."; def->cli = "avoid-crossing-perimeters!"; def->default_value = new ConfigOptionBool(false); def = this->add("bed_shape", coPoints); def->label = "Bed shape"; { ConfigOptionPoints* opt = new ConfigOptionPoints(); opt->values.push_back(Pointf(0,0)); opt->values.push_back(Pointf(200,0)); opt->values.push_back(Pointf(200,200)); opt->values.push_back(Pointf(0,200)); def->default_value = opt; } def = this->add("bed_temperature", coInt); def->label = "Other layers"; def->tooltip = "Bed temperature for layers after the first one. Set this to zero to disable bed temperature control commands in the output."; def->cli = "bed-temperature=i"; def->full_label = "Bed temperature"; def->min = 0; def->max = 300; def->default_value = new ConfigOptionInt(0); def = this->add("before_layer_gcode", coString); def->label = "Before layer change G-code"; def->tooltip = "This custom code is inserted at every layer change, right before the Z move. Note that you can use placeholder variables for all Slic3r settings as well as [layer_num] and [layer_z]."; def->cli = "before-layer-gcode=s"; def->multiline = true; def->full_width = true; def->height = 50; def->default_value = new ConfigOptionString(""); def = this->add("bottom_solid_layers", coInt); def->label = "Bottom"; def->category = "Layers and Perimeters"; def->tooltip = "Number of solid layers to generate on bottom surfaces."; def->cli = "bottom-solid-layers=i"; def->full_label = "Bottom solid layers"; def->min = 0; def->default_value = new ConfigOptionInt(3); def = this->add("bridge_acceleration", coFloat); def->label = "Bridge"; def->tooltip = "This is the acceleration your printer will use for bridges. Set zero to disable acceleration control for bridges."; def->sidetext = "mm/s²"; def->cli = "bridge-acceleration=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("bridge_fan_speed", coInt); def->label = "Bridges fan speed"; def->tooltip = "This fan speed is enforced during all bridges and overhangs."; def->sidetext = "%"; def->cli = "bridge-fan-speed=i"; def->min = 0; def->max = 100; def->default_value = new ConfigOptionInt(100); def = this->add("bridge_flow_ratio", coFloat); def->label = "Bridge flow ratio"; def->category = "Advanced"; def->tooltip = "This factor affects the amount of plastic for bridging. You can decrease it slightly to pull the extrudates and prevent sagging, although default settings are usually good and you should experiment with cooling (use a fan) before tweaking this."; def->cli = "bridge-flow-ratio=f"; def->min = 0; def->default_value = new ConfigOptionFloat(1); def = this->add("bridge_speed", coFloat); def->label = "Bridges"; def->category = "Speed"; def->tooltip = "Speed for printing bridges."; def->sidetext = "mm/s"; def->cli = "bridge-speed=f"; def->aliases.push_back("bridge_feed_rate"); def->min = 0; def->default_value = new ConfigOptionFloat(60); def = this->add("brim_width", coFloat); def->label = "Brim width"; def->tooltip = "Horizontal width of the brim that will be printed around each object on the first layer."; def->sidetext = "mm"; def->cli = "brim-width=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("complete_objects", coBool); def->label = "Complete individual objects"; def->tooltip = "When printing multiple objects or copies, this feature will complete each object before moving onto next one (and starting it from its bottom layer). This feature is useful to avoid the risk of ruined prints. Slic3r should warn and prevent you from extruder collisions, but beware."; def->cli = "complete-objects!"; def->default_value = new ConfigOptionBool(false); def = this->add("cooling", coBool); def->label = "Enable auto cooling"; def->tooltip = "This flag enables the automatic cooling logic that adjusts print speed and fan speed according to layer printing time."; def->cli = "cooling!"; def->default_value = new ConfigOptionBool(true); def = this->add("default_acceleration", coFloat); def->label = "Default"; def->tooltip = "This is the acceleration your printer will be reset to after the role-specific acceleration values are used (perimeter/infill). Set zero to prevent resetting acceleration at all."; def->sidetext = "mm/s²"; def->cli = "default-acceleration=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("disable_fan_first_layers", coInt); def->label = "Disable fan for the first"; def->tooltip = "You can set this to a positive value to disable fan at all during the first layers, so that it does not make adhesion worse."; def->sidetext = "layers"; def->cli = "disable-fan-first-layers=i"; def->min = 0; def->max = 1000; def->default_value = new ConfigOptionInt(3); def = this->add("dont_support_bridges", coBool); def->label = "Don't support bridges"; def->category = "Support material"; def->tooltip = "Experimental option for preventing support material from being generated under bridged areas."; def->cli = "dont-support-bridges!"; def->default_value = new ConfigOptionBool(true); def = this->add("duplicate_distance", coFloat); def->label = "Distance between copies"; def->tooltip = "Distance used for the auto-arrange feature of the plater."; def->sidetext = "mm"; def->cli = "duplicate-distance=f"; def->aliases.push_back("multiply_distance"); def->min = 0; def->default_value = new ConfigOptionFloat(6); def = this->add("end_gcode", coString); def->label = "End G-code"; def->tooltip = "This end procedure is inserted at the end of the output file. Note that you can use placeholder variables for all Slic3r settings."; def->cli = "end-gcode=s"; def->multiline = true; def->full_width = true; def->height = 120; def->default_value = new ConfigOptionString("M104 S0 ; turn off temperature\nG28 X0 ; home X axis\nM84 ; disable motors\n"); def = this->add("ensure_vertical_shell_thickness", coBool); def->label = "Ensure vertical shell thickness"; def->category = "Layers and Perimeters"; def->tooltip = "Add solid infill near sloping surfaces to guarantee the vertical shell thickness (top+bottom solid layers)."; def->cli = "ensure-vertical-shell-thickness!"; def->default_value = new ConfigOptionBool(false); def = this->add("external_fill_pattern", coEnum); def->label = "Top/bottom fill pattern"; def->category = "Infill"; def->tooltip = "Fill pattern for top/bottom infill. This only affects the external visible layer, and not its adjacent solid shells."; def->cli = "external-fill-pattern|solid-fill-pattern=s"; def->enum_keys_map = ConfigOptionEnum::get_enum_values(); def->enum_values.push_back("rectilinear"); def->enum_values.push_back("concentric"); def->enum_values.push_back("hilbertcurve"); def->enum_values.push_back("archimedeanchords"); def->enum_values.push_back("octagramspiral"); def->enum_labels.push_back("Rectilinear"); def->enum_labels.push_back("Concentric"); def->enum_labels.push_back("Hilbert Curve"); def->enum_labels.push_back("Archimedean Chords"); def->enum_labels.push_back("Octagram Spiral"); def->aliases.push_back("solid_fill_pattern"); def->default_value = new ConfigOptionEnum(ipRectilinear); def = this->add("external_perimeter_extrusion_width", coFloatOrPercent); def->label = "External perimeters"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for external perimeters. If left zero, an automatic value will be used that maximizes accuracy of the external visible surfaces. If expressed as percentage (for example 200%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "external-perimeter-extrusion-width=s"; def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("external_perimeter_speed", coFloatOrPercent); def->label = "External perimeters"; def->category = "Speed"; def->tooltip = "This separate setting will affect the speed of external perimeters (the visible ones). If expressed as percentage (for example: 80%) it will be calculated on the perimeters speed setting above. Set to zero for auto."; def->sidetext = "mm/s or %"; def->cli = "external-perimeter-speed=s"; def->ratio_over = "perimeter_speed"; def->min = 0; def->default_value = new ConfigOptionFloatOrPercent(50, true); def = this->add("external_perimeters_first", coBool); def->label = "External perimeters first"; def->category = "Layers and Perimeters"; def->tooltip = "Print contour perimeters from the outermost one to the innermost one instead of the default inverse order."; def->cli = "external-perimeters-first!"; def->default_value = new ConfigOptionBool(false); def = this->add("extra_perimeters", coBool); def->label = "Extra perimeters if needed"; def->category = "Layers and Perimeters"; def->tooltip = "Add more perimeters when needed for avoiding gaps in sloping walls."; def->cli = "extra-perimeters!"; def->default_value = new ConfigOptionBool(true); def = this->add("extruder", coInt); def->gui_type = "i_enum_open"; def->label = "Extruder"; def->category = "Extruders"; def->tooltip = "The extruder to use (unless more specific extruder settings are specified)."; def->cli = "extruder=i"; def->min = 0; // 0 = inherit defaults def->enum_labels.push_back("default"); // override label for item 0 def->enum_labels.push_back("1"); def->enum_labels.push_back("2"); def->enum_labels.push_back("3"); def->enum_labels.push_back("4"); def = this->add("extruder_clearance_height", coFloat); def->label = "Height"; def->tooltip = "Set this to the vertical distance between your nozzle tip and (usually) the X carriage rods. In other words, this is the height of the clearance cylinder around your extruder, and it represents the maximum depth the extruder can peek before colliding with other printed objects."; def->sidetext = "mm"; def->cli = "extruder-clearance-height=f"; def->min = 0; def->default_value = new ConfigOptionFloat(20); def = this->add("extruder_clearance_radius", coFloat); def->label = "Radius"; def->tooltip = "Set this to the clearance radius around your extruder. If the extruder is not centered, choose the largest value for safety. This setting is used to check for collisions and to display the graphical preview in the plater."; def->sidetext = "mm"; def->cli = "extruder-clearance-radius=f"; def->min = 0; def->default_value = new ConfigOptionFloat(20); def = this->add("extruder_offset", coPoints); def->label = "Extruder offset"; def->tooltip = "If your firmware doesn't handle the extruder displacement you need the G-code to take it into account. This option lets you specify the displacement of each extruder with respect to the first one. It expects positive coordinates (they will be subtracted from the XY coordinate)."; def->sidetext = "mm"; def->cli = "extruder-offset=s@"; { ConfigOptionPoints* opt = new ConfigOptionPoints(); opt->values.push_back(Pointf(0,0)); def->default_value = opt; } def = this->add("extrusion_axis", coString); def->label = "Extrusion axis"; def->tooltip = "Use this option to set the axis letter associated to your printer's extruder (usually E but some printers use A)."; def->cli = "extrusion-axis=s"; def->default_value = new ConfigOptionString("E"); def = this->add("extrusion_multiplier", coFloats); def->label = "Extrusion multiplier"; def->tooltip = "This factor changes the amount of flow proportionally. You may need to tweak this setting to get nice surface finish and correct single wall widths. Usual values are between 0.9 and 1.1. If you think you need to change this more, check filament diameter and your firmware E steps."; def->cli = "extrusion-multiplier=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(1); def->default_value = opt; } def = this->add("extrusion_width", coFloatOrPercent); def->label = "Default extrusion width"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width. If left to zero, Slic3r calculates a width automatically. If expressed as percentage (for example: 230%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for auto)"; def->cli = "extrusion-width=s"; def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("fan_always_on", coBool); def->label = "Keep fan always on"; def->tooltip = "If this is enabled, fan will never be disabled and will be kept running at least at its minimum speed. Useful for PLA, harmful for ABS."; def->cli = "fan-always-on!"; def->default_value = new ConfigOptionBool(false); def = this->add("fan_below_layer_time", coInt); def->label = "Enable fan if layer print time is below"; def->tooltip = "If layer print time is estimated below this number of seconds, fan will be enabled and its speed will be calculated by interpolating the minimum and maximum speeds."; def->sidetext = "approximate seconds"; def->cli = "fan-below-layer-time=i"; def->width = 60; def->min = 0; def->max = 1000; def->default_value = new ConfigOptionInt(60); def = this->add("filament_colour", coStrings); def->label = "Color"; def->tooltip = "This is only used in the Slic3r interface as a visual help."; def->cli = "filament-color=s@"; def->gui_type = "color"; { ConfigOptionStrings* opt = new ConfigOptionStrings(); opt->values.push_back("#FFFFFF"); def->default_value = opt; } def = this->add("filament_notes", coStrings); def->label = "Filament notes"; def->tooltip = "You can put your notes regarding the filament here."; def->cli = "filament-notes=s@"; def->multiline = true; def->full_width = true; def->height = 130; { ConfigOptionStrings* opt = new ConfigOptionStrings(); opt->values.push_back(""); def->default_value = opt; } def = this->add("filament_max_volumetric_speed", coFloats); def->label = "Max volumetric speed"; def->tooltip = "Maximum volumetric speed allowed for this filament. Limits the maximum volumetric speed of a print to the minimum of print and filament volumetric speed. Set to zero for no limit."; def->sidetext = "mm³/s"; def->cli = "filament-max-volumetric-speed=f@"; def->min = 0; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0.f); def->default_value = opt; } def = this->add("filament_diameter", coFloats); def->label = "Diameter"; def->tooltip = "Enter your filament diameter here. Good precision is required, so use a caliper and do multiple measurements along the filament, then compute the average."; def->sidetext = "mm"; def->cli = "filament-diameter=f@"; def->min = 0; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(3); def->default_value = opt; } def = this->add("filament_settings_id", coString); def->default_value = new ConfigOptionString(""); def = this->add("fill_angle", coFloat); def->label = "Fill angle"; def->category = "Infill"; def->tooltip = "Default base angle for infill orientation. Cross-hatching will be applied to this. Bridges will be infilled using the best direction Slic3r can detect, so this setting does not affect them."; def->sidetext = "°"; def->cli = "fill-angle=i"; def->min = 0; def->max = 359; def->default_value = new ConfigOptionFloat(45); def = this->add("fill_density", coPercent); def->gui_type = "f_enum_open"; def->gui_flags = "show_value"; def->label = "Fill density"; def->category = "Infill"; def->tooltip = "Density of internal infill, expressed in the range 0% - 100%."; def->sidetext = "%"; def->cli = "fill-density=s"; def->min = 0; def->max = 100; def->enum_values.push_back("0"); def->enum_values.push_back("5"); def->enum_values.push_back("10"); def->enum_values.push_back("15"); def->enum_values.push_back("20"); def->enum_values.push_back("25"); def->enum_values.push_back("30"); def->enum_values.push_back("40"); def->enum_values.push_back("50"); def->enum_values.push_back("60"); def->enum_values.push_back("70"); def->enum_values.push_back("80"); def->enum_values.push_back("90"); def->enum_values.push_back("100"); def->enum_labels.push_back("0%"); def->enum_labels.push_back("5%"); def->enum_labels.push_back("10%"); def->enum_labels.push_back("15%"); def->enum_labels.push_back("20%"); def->enum_labels.push_back("25%"); def->enum_labels.push_back("30%"); def->enum_labels.push_back("40%"); def->enum_labels.push_back("50%"); def->enum_labels.push_back("60%"); def->enum_labels.push_back("70%"); def->enum_labels.push_back("80%"); def->enum_labels.push_back("90%"); def->enum_labels.push_back("100%"); def->default_value = new ConfigOptionPercent(20); def = this->add("fill_pattern", coEnum); def->label = "Fill pattern"; def->category = "Infill"; def->tooltip = "Fill pattern for general low-density infill."; def->cli = "fill-pattern=s"; def->enum_keys_map = ConfigOptionEnum::get_enum_values(); def->enum_values.push_back("rectilinear"); def->enum_values.push_back("grid"); def->enum_values.push_back("triangles"); def->enum_values.push_back("stars"); def->enum_values.push_back("cubic"); def->enum_values.push_back("line"); def->enum_values.push_back("concentric"); def->enum_values.push_back("honeycomb"); def->enum_values.push_back("3dhoneycomb"); def->enum_values.push_back("hilbertcurve"); def->enum_values.push_back("archimedeanchords"); def->enum_values.push_back("octagramspiral"); def->enum_labels.push_back("Rectilinear"); def->enum_labels.push_back("Grid"); def->enum_labels.push_back("Triangles"); def->enum_labels.push_back("Stars"); def->enum_labels.push_back("Cubic"); def->enum_labels.push_back("Line"); def->enum_labels.push_back("Concentric"); def->enum_labels.push_back("Honeycomb"); def->enum_labels.push_back("3D Honeycomb"); def->enum_labels.push_back("Hilbert Curve"); def->enum_labels.push_back("Archimedean Chords"); def->enum_labels.push_back("Octagram Spiral"); def->default_value = new ConfigOptionEnum(ipHoneycomb); def = this->add("first_layer_acceleration", coFloat); def->label = "First layer"; def->tooltip = "This is the acceleration your printer will use for first layer. Set zero to disable acceleration control for first layer."; def->sidetext = "mm/s²"; def->cli = "first-layer-acceleration=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("first_layer_bed_temperature", coInt); def->label = "First layer"; def->tooltip = "Heated build plate temperature for the first layer. Set this to zero to disable bed temperature control commands in the output."; def->cli = "first-layer-bed-temperature=i"; def->max = 0; def->max = 300; def->default_value = new ConfigOptionInt(0); def = this->add("first_layer_extrusion_width", coFloatOrPercent); def->label = "First layer"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for first layer. You can use this to force fatter extrudates for better adhesion. If expressed as percentage (for example 120%) it will be computed over first layer height. If set to zero, it will use the Default Extrusion Width."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "first-layer-extrusion-width=s"; def->ratio_over = "first_layer_height"; def->default_value = new ConfigOptionFloatOrPercent(200, true); def = this->add("first_layer_height", coFloatOrPercent); def->label = "First layer height"; def->category = "Layers and Perimeters"; def->tooltip = "When printing with very low layer heights, you might still want to print a thicker bottom layer to improve adhesion and tolerance for non perfect build plates. This can be expressed as an absolute value or as a percentage (for example: 150%) over the default layer height."; def->sidetext = "mm or %"; def->cli = "first-layer-height=s"; def->ratio_over = "layer_height"; def->default_value = new ConfigOptionFloatOrPercent(0.35, false); def = this->add("first_layer_speed", coFloatOrPercent); def->label = "First layer speed"; def->tooltip = "If expressed as absolute value in mm/s, this speed will be applied to all the print moves of the first layer, regardless of their type. If expressed as a percentage (for example: 40%) it will scale the default speeds."; def->sidetext = "mm/s or %"; def->cli = "first-layer-speed=s"; def->min = 0; def->default_value = new ConfigOptionFloatOrPercent(30, false); def = this->add("first_layer_temperature", coInts); def->label = "First layer"; def->tooltip = "Extruder temperature for first layer. If you want to control temperature manually during print, set this to zero to disable temperature control commands in the output file."; def->cli = "first-layer-temperature=i@"; def->min = 0; def->max = 500; { ConfigOptionInts* opt = new ConfigOptionInts(); opt->values.push_back(200); def->default_value = opt; } def = this->add("gap_fill_speed", coFloat); def->label = "Gap fill"; def->category = "Speed"; def->tooltip = "Speed for filling small gaps using short zigzag moves. Keep this reasonably low to avoid too much shaking and resonance issues. Set zero to disable gaps filling."; def->sidetext = "mm/s"; def->cli = "gap-fill-speed=f"; def->min = 0; def->default_value = new ConfigOptionFloat(20); def = this->add("gcode_arcs", coBool); def->label = "Use native G-code arcs"; def->tooltip = "This experimental feature tries to detect arcs from segments and generates G2/G3 arc commands instead of multiple straight G1 commands."; def->cli = "gcode-arcs!"; def->default_value = new ConfigOptionBool(0); def = this->add("gcode_comments", coBool); def->label = "Verbose G-code"; def->tooltip = "Enable this to get a commented G-code file, with each line explained by a descriptive text. If you print from SD card, the additional weight of the file could make your firmware slow down."; def->cli = "gcode-comments!"; def->default_value = new ConfigOptionBool(0); def = this->add("gcode_flavor", coEnum); def->label = "G-code flavor"; def->tooltip = "Some G/M-code commands, including temperature control and others, are not universal. Set this option to your printer's firmware to get a compatible output. The \"No extrusion\" flavor prevents Slic3r from exporting any extrusion value at all."; def->cli = "gcode-flavor=s"; def->enum_keys_map = ConfigOptionEnum::get_enum_values(); def->enum_values.push_back("reprap"); def->enum_values.push_back("teacup"); def->enum_values.push_back("makerware"); def->enum_values.push_back("sailfish"); def->enum_values.push_back("mach3"); def->enum_values.push_back("machinekit"); def->enum_values.push_back("no-extrusion"); def->enum_labels.push_back("RepRap (Marlin/Sprinter/Repetier)"); def->enum_labels.push_back("Teacup"); def->enum_labels.push_back("MakerWare (MakerBot)"); def->enum_labels.push_back("Sailfish (MakerBot)"); def->enum_labels.push_back("Mach3/LinuxCNC"); def->enum_labels.push_back("Machinekit"); def->enum_labels.push_back("No extrusion"); def->default_value = new ConfigOptionEnum(gcfRepRap); def = this->add("infill_acceleration", coFloat); def->label = "Infill"; def->tooltip = "This is the acceleration your printer will use for infill. Set zero to disable acceleration control for infill."; def->sidetext = "mm/s²"; def->cli = "infill-acceleration=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("infill_every_layers", coInt); def->label = "Combine infill every"; def->category = "Infill"; def->tooltip = "This feature allows to combine infill and speed up your print by extruding thicker infill layers while preserving thin perimeters, thus accuracy."; def->sidetext = "layers"; def->cli = "infill-every-layers=i"; def->full_label = "Combine infill every n layers"; def->min = 1; def->default_value = new ConfigOptionInt(1); def = this->add("infill_extruder", coInt); def->label = "Infill extruder"; def->category = "Extruders"; def->tooltip = "The extruder to use when printing infill."; def->cli = "infill-extruder=i"; def->min = 1; def->default_value = new ConfigOptionInt(1); def = this->add("infill_extrusion_width", coFloatOrPercent); def->label = "Infill"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for infill. You may want to use fatter extrudates to speed up the infill and make your parts stronger. If expressed as percentage (for example 90%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "infill-extrusion-width=s"; def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("infill_first", coBool); def->label = "Infill before perimeters"; def->tooltip = "This option will switch the print order of perimeters and infill, making the latter first."; def->cli = "infill-first!"; def->default_value = new ConfigOptionBool(false); def = this->add("infill_only_where_needed", coBool); def->label = "Only infill where needed"; def->category = "Infill"; def->tooltip = "This option will limit infill to the areas actually needed for supporting ceilings (it will act as internal support material). If enabled, slows down the G-code generation due to the multiple checks involved."; def->cli = "infill-only-where-needed!"; def->default_value = new ConfigOptionBool(false); def = this->add("infill_overlap", coFloatOrPercent); def->label = "Infill/perimeters overlap"; def->category = "Advanced"; def->tooltip = "This setting applies an additional overlap between infill and perimeters for better bonding. Theoretically this shouldn't be needed, but backlash might cause gaps. If expressed as percentage (example: 15%) it is calculated over perimeter extrusion width."; def->sidetext = "mm or %"; def->cli = "infill-overlap=s"; def->ratio_over = "perimeter_extrusion_width"; def->default_value = new ConfigOptionFloatOrPercent(15, true); def = this->add("infill_speed", coFloat); def->label = "Infill"; def->category = "Speed"; def->tooltip = "Speed for printing the internal fill. Set to zero for auto."; def->sidetext = "mm/s"; def->cli = "infill-speed=f"; def->aliases.push_back("print_feed_rate"); def->aliases.push_back("infill_feed_rate"); def->min = 0; def->default_value = new ConfigOptionFloat(80); def = this->add("interface_shells", coBool); def->label = "Interface shells"; def->tooltip = "Force the generation of solid shells between adjacent materials/volumes. Useful for multi-extruder prints with translucent materials or manual soluble support material."; def->cli = "interface-shells!"; def->category = "Layers and Perimeters"; def->default_value = new ConfigOptionBool(false); def = this->add("layer_gcode", coString); def->label = "After layer change G-code"; def->tooltip = "This custom code is inserted at every layer change, right after the Z move and before the extruder moves to the first layer point. Note that you can use placeholder variables for all Slic3r settings as well as [layer_num] and [layer_z]."; def->cli = "after-layer-gcode|layer-gcode=s"; def->multiline = true; def->full_width = true; def->height = 50; def->default_value = new ConfigOptionString(""); def = this->add("layer_height", coFloat); def->label = "Layer height"; def->category = "Layers and Perimeters"; def->tooltip = "This setting controls the height (and thus the total number) of the slices/layers. Thinner layers give better accuracy but take more time to print."; def->sidetext = "mm"; def->cli = "layer-height=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0.3); def = this->add("max_fan_speed", coInt); def->label = "Max"; def->tooltip = "This setting represents the maximum speed of your fan."; def->sidetext = "%"; def->cli = "max-fan-speed=i"; def->min = 0; def->max = 100; def->default_value = new ConfigOptionInt(100); def = this->add("max_print_speed", coFloat); def->label = "Max print speed"; def->tooltip = "When setting other speed settings to 0 Slic3r will autocalculate the optimal speed in order to keep constant extruder pressure. This experimental setting is used to set the highest print speed you want to allow."; def->sidetext = "mm/s"; def->cli = "max-print-speed=f"; def->min = 1; def->default_value = new ConfigOptionFloat(80); def = this->add("max_volumetric_speed", coFloat); def->label = "Max volumetric speed"; def->tooltip = "This experimental setting is used to set the maximum volumetric speed your extruder supports."; def->sidetext = "mm³/s"; def->cli = "max-volumetric-speed=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("max_volumetric_extrusion_rate_slope_positive", coFloat); def->label = "Max volumetric slope positive"; def->tooltip = "This experimental setting is used to limit the speed of change in extrusion rate. A value of 1.8 mm³/s² ensures, that a change from the extrusion rate " "of 1.8 mm³/s (0.45mm extrusion width, 0.2mm extrusion height, feedrate 20 mm/s) to 5.4 mm³/s (feedrate 60 mm/s) will take at least 2 seconds."; def->sidetext = "mm³/s²"; def->cli = "max-volumetric-extrusion-rate-slope-positive=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("max_volumetric_extrusion_rate_slope_negative", coFloat); def->label = "Max volumetric slope negative"; def->tooltip = "This experimental setting is used to limit the speed of change in extrusion rate. A value of 1.8 mm³/s² ensures, that a change from the extrusion rate " "of 1.8 mm³/s (0.45mm extrusion width, 0.2mm extrusion height, feedrate 20 mm/s) to 5.4 mm³/s (feedrate 60 mm/s) will take at least 2 seconds."; def->sidetext = "mm³/s²"; def->cli = "max-volumetric-extrusion-rate-slope-negative=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("min_fan_speed", coInt); def->label = "Min"; def->tooltip = "This setting represents the minimum PWM your fan needs to work."; def->sidetext = "%"; def->cli = "min-fan-speed=i"; def->min = 0; def->max = 100; def->default_value = new ConfigOptionInt(35); def = this->add("min_print_speed", coFloat); def->label = "Min print speed"; def->tooltip = "Slic3r will not scale speed down below this speed."; def->sidetext = "mm/s"; def->cli = "min-print-speed=f"; def->min = 0; def->default_value = new ConfigOptionFloat(10); def = this->add("min_skirt_length", coFloat); def->label = "Minimum extrusion length"; def->tooltip = "Generate no less than the number of skirt loops required to consume the specified amount of filament on the bottom layer. For multi-extruder machines, this minimum applies to each extruder."; def->sidetext = "mm"; def->cli = "min-skirt-length=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("notes", coString); def->label = "Configuration notes"; def->tooltip = "You can put here your personal notes. This text will be added to the G-code header comments."; def->cli = "notes=s"; def->multiline = true; def->full_width = true; def->height = 130; def->default_value = new ConfigOptionString(""); def = this->add("nozzle_diameter", coFloats); def->label = "Nozzle diameter"; def->tooltip = "This is the diameter of your extruder nozzle (for example: 0.5, 0.35 etc.)"; def->sidetext = "mm"; def->cli = "nozzle-diameter=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0.5); def->default_value = opt; } def = this->add("octoprint_apikey", coString); def->label = "API Key"; def->tooltip = "Slic3r can upload G-code files to OctoPrint. This field should contain the API Key required for authentication."; def->cli = "octoprint-apikey=s"; def->default_value = new ConfigOptionString(""); def = this->add("octoprint_host", coString); def->label = "Host or IP"; def->tooltip = "Slic3r can upload G-code files to OctoPrint. This field should contain the hostname or IP address of the OctoPrint instance."; def->cli = "octoprint-host=s"; def->default_value = new ConfigOptionString(""); def = this->add("only_retract_when_crossing_perimeters", coBool); def->label = "Only retract when crossing perimeters"; def->tooltip = "Disables retraction when the travel path does not exceed the upper layer's perimeters (and thus any ooze will be probably invisible)."; def->cli = "only-retract-when-crossing-perimeters!"; def->default_value = new ConfigOptionBool(true); def = this->add("ooze_prevention", coBool); def->label = "Enable"; def->tooltip = "This option will drop the temperature of the inactive extruders to prevent oozing. It will enable a tall skirt automatically and move extruders outside such skirt when changing temperatures."; def->cli = "ooze-prevention!"; def->default_value = new ConfigOptionBool(false); def = this->add("output_filename_format", coString); def->label = "Output filename format"; def->tooltip = "You can use all configuration options as variables inside this template. For example: [layer_height], [fill_density] etc. You can also use [timestamp], [year], [month], [day], [hour], [minute], [second], [version], [input_filename], [input_filename_base]."; def->cli = "output-filename-format=s"; def->full_width = true; def->default_value = new ConfigOptionString("[input_filename_base].gcode"); def = this->add("overhangs", coBool); def->label = "Detect bridging perimeters"; def->category = "Layers and Perimeters"; def->tooltip = "Experimental option to adjust flow for overhangs (bridge flow will be used), to apply bridge speed to them and enable fan."; def->cli = "overhangs!"; def->default_value = new ConfigOptionBool(true); def = this->add("perimeter_acceleration", coFloat); def->label = "Perimeters"; def->tooltip = "This is the acceleration your printer will use for perimeters. A high value like 9000 usually gives good results if your hardware is up to the job. Set zero to disable acceleration control for perimeters."; def->sidetext = "mm/s²"; def->cli = "perimeter-acceleration=f"; def->default_value = new ConfigOptionFloat(0); def = this->add("perimeter_extruder", coInt); def->label = "Perimeter extruder"; def->category = "Extruders"; def->tooltip = "The extruder to use when printing perimeters and brim. First extruder is 1."; def->cli = "perimeter-extruder=i"; def->aliases.push_back("perimeters_extruder"); def->min = 1; def->default_value = new ConfigOptionInt(1); def = this->add("perimeter_extrusion_width", coFloatOrPercent); def->label = "Perimeters"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for perimeters. You may want to use thinner extrudates to get more accurate surfaces. If expressed as percentage (for example 200%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "perimeter-extrusion-width=s"; def->aliases.push_back("perimeters_extrusion_width"); def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("perimeter_speed", coFloat); def->label = "Perimeters"; def->category = "Speed"; def->tooltip = "Speed for perimeters (contours, aka vertical shells). Set to zero for auto."; def->sidetext = "mm/s"; def->cli = "perimeter-speed=f"; def->aliases.push_back("perimeter_feed_rate"); def->min = 0; def->default_value = new ConfigOptionFloat(60); def = this->add("perimeters", coInt); def->label = "Perimeters"; def->category = "Layers and Perimeters"; def->tooltip = "This option sets the number of perimeters to generate for each layer. Note that Slic3r may increase this number automatically when it detects sloping surfaces which benefit from a higher number of perimeters if the Extra Perimeters option is enabled."; def->sidetext = "(minimum)"; def->cli = "perimeters=i"; def->aliases.push_back("perimeter_offsets"); def->min = 0; def->default_value = new ConfigOptionInt(3); def = this->add("post_process", coStrings); def->label = "Post-processing scripts"; def->tooltip = "If you want to process the output G-code through custom scripts, just list their absolute paths here. Separate multiple scripts with a semicolon. Scripts will be passed the absolute path to the G-code file as the first argument, and they can access the Slic3r config settings by reading environment variables."; def->cli = "post-process=s@"; def->gui_flags = "serialized"; def->multiline = true; def->full_width = true; def->height = 60; def = this->add("print_settings_id", coString); def->default_value = new ConfigOptionString(""); def = this->add("printer_settings_id", coString); def->default_value = new ConfigOptionString(""); def = this->add("pressure_advance", coFloat); def->label = "Pressure advance"; def->tooltip = "When set to a non-zero value, this experimental option enables pressure regulation. It's the K constant for the advance algorithm that pushes more or less filament upon speed changes. It's useful for Bowden-tube extruders. Reasonable values are in range 0-10."; def->cli = "pressure-advance=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("raft_layers", coInt); def->label = "Raft layers"; def->category = "Support material"; def->tooltip = "The object will be raised by this number of layers, and support material will be generated under it."; def->sidetext = "layers"; def->cli = "raft-layers=i"; def->min = 0; def->default_value = new ConfigOptionInt(0); def = this->add("resolution", coFloat); def->label = "Resolution"; def->tooltip = "Minimum detail resolution, used to simplify the input file for speeding up the slicing job and reducing memory usage. High-resolution models often carry more detail than printers can render. Set to zero to disable any simplification and use full resolution from input."; def->sidetext = "mm"; def->cli = "resolution=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("retract_before_travel", coFloats); def->label = "Minimum travel after retraction"; def->tooltip = "Retraction is not triggered when travel moves are shorter than this length."; def->sidetext = "mm"; def->cli = "retract-before-travel=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(2); def->default_value = opt; } def = this->add("retract_layer_change", coBools); def->label = "Retract on layer change"; def->tooltip = "This flag enforces a retraction whenever a Z move is done."; def->cli = "retract-layer-change!"; { ConfigOptionBools* opt = new ConfigOptionBools(); opt->values.push_back(false); def->default_value = opt; } def = this->add("retract_length", coFloats); def->label = "Length"; def->full_label = "Retraction Length"; def->tooltip = "When retraction is triggered, filament is pulled back by the specified amount (the length is measured on raw filament, before it enters the extruder)."; def->sidetext = "mm (zero to disable)"; def->cli = "retract-length=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(2); def->default_value = opt; } def = this->add("retract_length_toolchange", coFloats); def->label = "Length"; def->full_label = "Retraction Length (Toolchange)"; def->tooltip = "When retraction is triggered before changing tool, filament is pulled back by the specified amount (the length is measured on raw filament, before it enters the extruder)."; def->sidetext = "mm (zero to disable)"; def->cli = "retract-length-toolchange=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(10); def->default_value = opt; } def = this->add("retract_lift", coFloats); def->label = "Lift Z"; def->tooltip = "If you set this to a positive value, Z is quickly raised every time a retraction is triggered. When using multiple extruders, only the setting for the first extruder will be considered."; def->sidetext = "mm"; def->cli = "retract-lift=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0); def->default_value = opt; } def = this->add("retract_lift_above", coFloats); def->label = "Above Z"; def->full_label = "Only lift Z above"; def->tooltip = "If you set this to a positive value, Z lift will only take place above the specified absolute Z. You can tune this setting for skipping lift on the first layers."; def->sidetext = "mm"; def->cli = "retract-lift-above=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0); def->default_value = opt; } def = this->add("retract_lift_below", coFloats); def->label = "Below Z"; def->full_label = "Only lift Z below"; def->tooltip = "If you set this to a positive value, Z lift will only take place below the specified absolute Z. You can tune this setting for limiting lift to the first layers."; def->sidetext = "mm"; def->cli = "retract-lift-below=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0); def->default_value = opt; } def = this->add("retract_restart_extra", coFloats); def->label = "Extra length on restart"; def->tooltip = "When the retraction is compensated after the travel move, the extruder will push this additional amount of filament. This setting is rarely needed."; def->sidetext = "mm"; def->cli = "retract-restart-extra=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0); def->default_value = opt; } def = this->add("retract_restart_extra_toolchange", coFloats); def->label = "Extra length on restart"; def->tooltip = "When the retraction is compensated after changing tool, the extruder will push this additional amount of filament."; def->sidetext = "mm"; def->cli = "retract-restart-extra-toolchange=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(0); def->default_value = opt; } def = this->add("retract_speed", coFloats); def->label = "Speed"; def->full_label = "Retraction Speed"; def->tooltip = "The speed for retractions (it only applies to the extruder motor)."; def->sidetext = "mm/s"; def->cli = "retract-speed=f@"; { ConfigOptionFloats* opt = new ConfigOptionFloats(); opt->values.push_back(40); def->default_value = opt; } def = this->add("seam_position", coEnum); def->label = "Seam position"; def->category = "Layers and perimeters"; def->tooltip = "Position of perimeters starting points."; def->cli = "seam-position=s"; def->enum_keys_map = ConfigOptionEnum::get_enum_values(); def->enum_values.push_back("random"); def->enum_values.push_back("nearest"); def->enum_values.push_back("aligned"); // def->enum_values.push_back("preferred"); def->enum_labels.push_back("Random"); def->enum_labels.push_back("Nearest"); def->enum_labels.push_back("Aligned"); // def->enum_labels.push_back("Preferred Direction"); def->default_value = new ConfigOptionEnum(spAligned); #if 0 def = this->add("seam_preferred_direction", coFloat); // def->gui_type = "slider"; def->label = "Direction"; def->sidetext = "°"; def->full_label = "Preferred direction of the seam"; def->tooltip = "Seam preferred direction"; def->cli = "seam-preferred-direction=f"; def->min = 0; def->max = 360; def->default_value = new ConfigOptionFloat(0); def = this->add("seam_preferred_direction_jitter", coFloat); // def->gui_type = "slider"; def->label = "Jitter"; def->sidetext = "°"; def->full_label = "Seam preferred direction jitter"; def->tooltip = "Preferred direction of the seam - jitter"; def->cli = "seam-preferred-direction-jitter=f"; def->min = 0; def->max = 360; def->default_value = new ConfigOptionFloat(30); #endif def = this->add("serial_port", coString); def->gui_type = "select_open"; def->label = ""; def->full_label = "Serial port"; def->tooltip = "USB/serial port for printer connection."; def->cli = "serial-port=s"; def->width = 200; def->default_value = new ConfigOptionString(""); def = this->add("serial_speed", coInt); def->gui_type = "i_enum_open"; def->label = "Speed"; def->full_label = "Serial port speed"; def->tooltip = "Speed (baud) of USB/serial port for printer connection."; def->cli = "serial-speed=i"; def->min = 1; def->max = 300000; def->enum_values.push_back("115200"); def->enum_values.push_back("250000"); def->default_value = new ConfigOptionInt(250000); def = this->add("skirt_distance", coFloat); def->label = "Distance from object"; def->tooltip = "Distance between skirt and object(s). Set this to zero to attach the skirt to the object(s) and get a brim for better adhesion."; def->sidetext = "mm"; def->cli = "skirt-distance=f"; def->min = 0; def->default_value = new ConfigOptionFloat(6); def = this->add("skirt_height", coInt); def->label = "Skirt height"; def->tooltip = "Height of skirt expressed in layers. Set this to a tall value to use skirt as a shield against drafts."; def->sidetext = "layers"; def->cli = "skirt-height=i"; def->default_value = new ConfigOptionInt(1); def = this->add("skirts", coInt); def->label = "Loops (minimum)"; def->full_label = "Skirt Loops"; def->tooltip = "Number of loops for the skirt. If the Minimum Extrusion Length option is set, the number of loops might be greater than the one configured here. Set this to zero to disable skirt completely."; def->cli = "skirts=i"; def->min = 0; def->default_value = new ConfigOptionInt(1); def = this->add("slowdown_below_layer_time", coInt); def->label = "Slow down if layer print time is below"; def->tooltip = "If layer print time is estimated below this number of seconds, print moves speed will be scaled down to extend duration to this value."; def->sidetext = "approximate seconds"; def->cli = "slowdown-below-layer-time=i"; def->width = 60; def->min = 0; def->max = 1000; def->default_value = new ConfigOptionInt(5); def = this->add("small_perimeter_speed", coFloatOrPercent); def->label = "Small perimeters"; def->category = "Speed"; def->tooltip = "This separate setting will affect the speed of perimeters having radius <= 6.5mm (usually holes). If expressed as percentage (for example: 80%) it will be calculated on the perimeters speed setting above. Set to zero for auto."; def->sidetext = "mm/s or %"; def->cli = "small-perimeter-speed=s"; def->ratio_over = "perimeter_speed"; def->min = 0; def->default_value = new ConfigOptionFloatOrPercent(15, false); def = this->add("solid_infill_below_area", coFloat); def->label = "Solid infill threshold area"; def->category = "Infill"; def->tooltip = "Force solid infill for regions having a smaller area than the specified threshold."; def->sidetext = "mm²"; def->cli = "solid-infill-below-area=f"; def->min = 0; def->default_value = new ConfigOptionFloat(70); def = this->add("solid_infill_extruder", coInt); def->label = "Solid infill extruder"; def->category = "Extruders"; def->tooltip = "The extruder to use when printing solid infill."; def->cli = "solid-infill-extruder=i"; def->min = 1; def->default_value = new ConfigOptionInt(1); def = this->add("solid_infill_every_layers", coInt); def->label = "Solid infill every"; def->category = "Infill"; def->tooltip = "This feature allows to force a solid layer every given number of layers. Zero to disable. You can set this to any value (for example 9999); Slic3r will automatically choose the maximum possible number of layers to combine according to nozzle diameter and layer height."; def->sidetext = "layers"; def->cli = "solid-infill-every-layers=i"; def->min = 0; def->default_value = new ConfigOptionInt(0); def = this->add("solid_infill_extrusion_width", coFloatOrPercent); def->label = "Solid infill"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for infill for solid surfaces. If expressed as percentage (for example 90%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "solid-infill-extrusion-width=s"; def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("solid_infill_speed", coFloatOrPercent); def->label = "Solid infill"; def->category = "Speed"; def->tooltip = "Speed for printing solid regions (top/bottom/internal horizontal shells). This can be expressed as a percentage (for example: 80%) over the default infill speed above. Set to zero for auto."; def->sidetext = "mm/s or %"; def->cli = "solid-infill-speed=s"; def->ratio_over = "infill_speed"; def->aliases.push_back("solid_infill_feed_rate"); def->min = 0; def->default_value = new ConfigOptionFloatOrPercent(20, false); def = this->add("solid_layers", coInt); def->label = "Solid layers"; def->tooltip = "Number of solid layers to generate on top and bottom surfaces."; def->cli = "solid-layers=i"; def->shortcut.push_back("top_solid_layers"); def->shortcut.push_back("bottom_solid_layers"); def->min = 0; def = this->add("spiral_vase", coBool); def->label = "Spiral vase"; def->tooltip = "This feature will raise Z gradually while printing a single-walled object in order to remove any visible seam. This option requires a single perimeter, no infill, no top solid layers and no support material. You can still set any number of bottom solid layers as well as skirt/brim loops. It won't work when printing more than an object."; def->cli = "spiral-vase!"; def->default_value = new ConfigOptionBool(false); def = this->add("standby_temperature_delta", coInt); def->label = "Temperature variation"; def->tooltip = "Temperature difference to be applied when an extruder is not active. Enables a full-height \"sacrificial\" skirt on which the nozzles are periodically wiped."; def->sidetext = "∆°C"; def->cli = "standby-temperature-delta=i"; def->min = -500; def->max = 500; def->default_value = new ConfigOptionInt(-5); def = this->add("start_gcode", coString); def->label = "Start G-code"; def->tooltip = "This start procedure is inserted at the beginning, after bed has reached the target temperature and extruder just started heating, and before extruder has finished heating. If Slic3r detects M104 or M190 in your custom codes, such commands will not be prepended automatically so you're free to customize the order of heating commands and other custom actions. Note that you can use placeholder variables for all Slic3r settings, so you can put a \"M109 S[first_layer_temperature]\" command wherever you want."; def->cli = "start-gcode=s"; def->multiline = true; def->full_width = true; def->height = 120; def->default_value = new ConfigOptionString("G28 ; home all axes\nG1 Z5 F5000 ; lift nozzle\n"); def = this->add("support_material", coBool); def->label = "Generate support material"; def->category = "Support material"; def->tooltip = "Enable support material generation."; def->cli = "support-material!"; def->default_value = new ConfigOptionBool(false); def = this->add("support_material_angle", coInt); def->label = "Pattern angle"; def->category = "Support material"; def->tooltip = "Use this setting to rotate the support material pattern on the horizontal plane."; def->sidetext = "°"; def->cli = "support-material-angle=i"; def->min = 0; def->max = 359; def->default_value = new ConfigOptionInt(0); def = this->add("support_material_buildplate_only", coBool); def->label = "Support on build plate only"; def->category = "Support material"; def->tooltip = "Only create support if it lies on a build plate. Don't create support on a print."; def->cli = "support-material-buildplate-only!"; def->default_value = new ConfigOptionBool(false); def = this->add("support_material_contact_distance", coFloat); def->gui_type = "f_enum_open"; def->label = "Contact Z distance"; def->category = "Support material"; def->tooltip = "The vertical distance between object and support material interface. Setting this to 0 will also prevent Slic3r from using bridge flow and speed for the first object layer."; def->sidetext = "mm"; def->cli = "support-material-contact-distance=f"; def->min = 0; def->enum_values.push_back("0"); def->enum_values.push_back("0.2"); def->enum_labels.push_back("0 (soluble)"); def->enum_labels.push_back("0.2 (detachable)"); def->default_value = new ConfigOptionFloat(0.2); def = this->add("support_material_enforce_layers", coInt); def->label = "Enforce support for the first"; def->category = "Support material"; def->tooltip = "Generate support material for the specified number of layers counting from bottom, regardless of whether normal support material is enabled or not and regardless of any angle threshold. This is useful for getting more adhesion of objects having a very thin or poor footprint on the build plate."; def->sidetext = "layers"; def->cli = "support-material-enforce-layers=f"; def->full_label = "Enforce support for the first n layers"; def->min = 0; def->default_value = new ConfigOptionInt(0); def = this->add("support_material_extruder", coInt); def->label = "Support material/raft/skirt extruder"; def->category = "Extruders"; def->tooltip = "The extruder to use when printing support material, raft and skirt."; def->cli = "support-material-extruder=i"; def->min = 1; def->default_value = new ConfigOptionInt(1); def = this->add("support_material_extrusion_width", coFloatOrPercent); def->label = "Support material"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for support material. If expressed as percentage (for example 90%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "support-material-extrusion-width=s"; def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("support_material_interface_extruder", coInt); def->label = "Support material/raft interface extruder"; def->category = "Extruders"; def->tooltip = "The extruder to use when printing support material interface. This affects raft too."; def->cli = "support-material-interface-extruder=i"; def->min = 1; def->default_value = new ConfigOptionInt(1); def = this->add("support_material_interface_layers", coInt); def->label = "Interface layers"; def->category = "Support material"; def->tooltip = "Number of interface layers to insert between the object(s) and support material."; def->sidetext = "layers"; def->cli = "support-material-interface-layers=i"; def->min = 0; def->default_value = new ConfigOptionInt(3); def = this->add("support_material_interface_spacing", coFloat); def->label = "Interface pattern spacing"; def->category = "Support material"; def->tooltip = "Spacing between interface lines. Set zero to get a solid interface."; def->sidetext = "mm"; def->cli = "support-material-interface-spacing=f"; def->min = 0; def->default_value = new ConfigOptionFloat(0); def = this->add("support_material_interface_speed", coFloatOrPercent); def->label = "Support material interface"; def->category = "Support material"; def->tooltip = "Speed for printing support material interface layers. If expressed as percentage (for example 50%) it will be calculated over support material speed."; def->sidetext = "mm/s or %"; def->cli = "support-material-interface-speed=s"; def->ratio_over = "support_material_speed"; def->min = 0; def->default_value = new ConfigOptionFloatOrPercent(100, true); def = this->add("support_material_pattern", coEnum); def->label = "Pattern"; def->category = "Support material"; def->tooltip = "Pattern used to generate support material."; def->cli = "support-material-pattern=s"; def->enum_keys_map = ConfigOptionEnum::get_enum_values(); def->enum_values.push_back("rectilinear"); def->enum_values.push_back("rectilinear-grid"); def->enum_values.push_back("honeycomb"); def->enum_values.push_back("pillars"); def->enum_labels.push_back("rectilinear"); def->enum_labels.push_back("rectilinear grid"); def->enum_labels.push_back("honeycomb"); def->enum_labels.push_back("pillars"); def->default_value = new ConfigOptionEnum(smpPillars); def = this->add("support_material_spacing", coFloat); def->label = "Pattern spacing"; def->category = "Support material"; def->tooltip = "Spacing between support material lines."; def->sidetext = "mm"; def->cli = "support-material-spacing=f"; def->min = 0; def->default_value = new ConfigOptionFloat(2.5); def = this->add("support_material_speed", coFloat); def->label = "Support material"; def->category = "Support material"; def->tooltip = "Speed for printing support material."; def->sidetext = "mm/s"; def->cli = "support-material-speed=f"; def->min = 0; def->default_value = new ConfigOptionFloat(60); def = this->add("support_material_threshold", coInt); def->label = "Overhang threshold"; def->category = "Support material"; def->tooltip = "Support material will not be generated for overhangs whose slope angle (90° = vertical) is above the given threshold. In other words, this value represent the most horizontal slope (measured from the horizontal plane) that you can print without support material. Set to zero for automatic detection (recommended)."; def->sidetext = "°"; def->cli = "support-material-threshold=i"; def->min = 0; def->max = 90; def->default_value = new ConfigOptionInt(0); def = this->add("support_material_with_sheath", coBool); def->label = "With sheath around the support"; def->category = "Support material"; def->tooltip = "Add a sheath (a single perimeter line) around the base support. This makes the support more reliable, but also more difficult to remove."; def->cli = "support-material-with-sheath!"; def->default_value = new ConfigOptionBool(true); def = this->add("temperature", coInts); def->label = "Other layers"; def->tooltip = "Extruder temperature for layers after the first one. Set this to zero to disable temperature control commands in the output."; def->cli = "temperature=i@"; def->full_label = "Temperature"; def->max = 0; def->max = 500; { ConfigOptionInts* opt = new ConfigOptionInts(); opt->values.push_back(200); def->default_value = opt; } def = this->add("thin_walls", coBool); def->label = "Detect thin walls"; def->category = "Layers and Perimeters"; def->tooltip = "Detect single-width walls (parts where two extrusions don't fit and we need to collapse them into a single trace)."; def->cli = "thin-walls!"; def->default_value = new ConfigOptionBool(true); def = this->add("threads", coInt); def->label = "Threads"; def->tooltip = "Threads are used to parallelize long-running tasks. Optimal threads number is slightly above the number of available cores/processors."; def->cli = "threads|j=i"; def->readonly = true; def->min = 1; def->max = 16; def->default_value = new ConfigOptionInt(2); def = this->add("toolchange_gcode", coString); def->label = "Tool change G-code"; def->tooltip = "This custom code is inserted right before every extruder change. Note that you can use placeholder variables for all Slic3r settings as well as [previous_extruder] and [next_extruder]."; def->cli = "toolchange-gcode=s"; def->multiline = true; def->full_width = true; def->height = 50; def->default_value = new ConfigOptionString(""); def = this->add("top_infill_extrusion_width", coFloatOrPercent); def->label = "Top solid infill"; def->category = "Extrusion Width"; def->tooltip = "Set this to a non-zero value to set a manual extrusion width for infill for top surfaces. You may want to use thinner extrudates to fill all narrow regions and get a smoother finish. If expressed as percentage (for example 90%) it will be computed over layer height."; def->sidetext = "mm or % (leave 0 for default)"; def->cli = "top-infill-extrusion-width=s"; def->default_value = new ConfigOptionFloatOrPercent(0, false); def = this->add("top_solid_infill_speed", coFloatOrPercent); def->label = "Top solid infill"; def->category = "Speed"; def->tooltip = "Speed for printing top solid layers (it only applies to the uppermost external layers and not to their internal solid layers). You may want to slow down this to get a nicer surface finish. This can be expressed as a percentage (for example: 80%) over the solid infill speed above. Set to zero for auto."; def->sidetext = "mm/s or %"; def->cli = "top-solid-infill-speed=s"; def->ratio_over = "solid_infill_speed"; def->min = 0; def->default_value = new ConfigOptionFloatOrPercent(15, false); def = this->add("top_solid_layers", coInt); def->label = "Top"; def->category = "Layers and Perimeters"; def->tooltip = "Number of solid layers to generate on top surfaces."; def->cli = "top-solid-layers=i"; def->full_label = "Top solid layers"; def->min = 0; def->default_value = new ConfigOptionInt(3); def = this->add("travel_speed", coFloat); def->label = "Travel"; def->tooltip = "Speed for travel moves (jumps between distant extrusion points)."; def->sidetext = "mm/s"; def->cli = "travel-speed=f"; def->aliases.push_back("travel_feed_rate"); def->min = 1; def->default_value = new ConfigOptionFloat(130); def = this->add("use_firmware_retraction", coBool); def->label = "Use firmware retraction"; def->tooltip = "This experimental setting uses G10 and G11 commands to have the firmware handle the retraction. This is only supported in recent Marlin."; def->cli = "use-firmware-retraction!"; def->default_value = new ConfigOptionBool(false); def = this->add("use_relative_e_distances", coBool); def->label = "Use relative E distances"; def->tooltip = "If your firmware requires relative E values, check this, otherwise leave it unchecked. Most firmwares use absolute values."; def->cli = "use-relative-e-distances!"; def->default_value = new ConfigOptionBool(false); def = this->add("use_volumetric_e", coBool); def->label = "Use volumetric E"; def->tooltip = "This experimental setting uses outputs the E values in cubic millimeters instead of linear millimeters. If your firmware doesn't already know filament diameter(s), you can put commands like 'M200 D[filament_diameter_0] T0' in your start G-code in order to turn volumetric mode on and use the filament diameter associated to the filament selected in Slic3r. This is only supported in recent Marlin."; def->cli = "use-volumetric-e!"; def->default_value = new ConfigOptionBool(false); def = this->add("wipe", coBools); def->label = "Wipe while retracting"; def->tooltip = "This flag will move the nozzle while retracting to minimize the possible blob on leaky extruders."; def->cli = "wipe!"; { ConfigOptionBools* opt = new ConfigOptionBools(); opt->values.push_back(false); def->default_value = opt; } def = this->add("xy_size_compensation", coFloat); def->label = "XY Size Compensation"; def->category = "Advanced"; def->tooltip = "The object will be grown/shrunk in the XY plane by the configured value (negative = inwards, positive = outwards). This might be useful for fine-tuning hole sizes."; def->sidetext = "mm"; def->cli = "xy-size-compensation=f"; def->default_value = new ConfigOptionFloat(0); def = this->add("z_offset", coFloat); def->label = "Z offset"; def->tooltip = "This value will be added (or subtracted) from all the Z coordinates in the output G-code. It is used to compensate for bad Z endstop position: for example, if your endstop zero actually leaves the nozzle 0.3mm far from the print bed, set this to -0.3 (or fix your endstop)."; def->sidetext = "mm"; def->cli = "z-offset=f"; def->default_value = new ConfigOptionFloat(0); } PrintConfigDef print_config_def; void DynamicPrintConfig::normalize() { if (this->has("extruder")) { int extruder = this->option("extruder")->getInt(); this->erase("extruder"); if (extruder != 0) { if (!this->has("infill_extruder")) this->option("infill_extruder", true)->setInt(extruder); if (!this->has("perimeter_extruder")) this->option("perimeter_extruder", true)->setInt(extruder); if (!this->has("support_material_extruder")) this->option("support_material_extruder", true)->setInt(extruder); if (!this->has("support_material_interface_extruder")) this->option("support_material_interface_extruder", true)->setInt(extruder); } } if (!this->has("solid_infill_extruder") && this->has("infill_extruder")) this->option("solid_infill_extruder", true)->setInt(this->option("infill_extruder")->getInt()); if (this->has("spiral_vase") && this->opt("spiral_vase", true)->value) { { // this should be actually done only on the spiral layers instead of all ConfigOptionBools* opt = this->opt("retract_layer_change", true); opt->values.assign(opt->values.size(), false); // set all values to false } { this->opt("perimeters", true)->value = 1; this->opt("top_solid_layers", true)->value = 0; this->opt("fill_density", true)->value = 0; } } } double PrintConfigBase::min_object_distance() const { double extruder_clearance_radius = this->option("extruder_clearance_radius")->getFloat(); double duplicate_distance = this->option("duplicate_distance")->getFloat(); // min object distance is max(duplicate_distance, clearance_radius) return (this->option("complete_objects")->getBool() && extruder_clearance_radius > duplicate_distance) ? extruder_clearance_radius : duplicate_distance; } } Slic3r-version_1.31.6/xs/src/libslic3r/PrintConfig.hpp000066400000000000000000000516161301441720000225510ustar00rootroot00000000000000// Configuration store of Slic3r. // // The configuration store is either static or dynamic. // DynamicPrintConfig is used mainly at the user interface. while the StaticPrintConfig is used // during the slicing and the g-code generation. // // The classes derived from StaticPrintConfig form a following hierarchy. // Virtual inheritance is used for some of the parent objects. // // FullPrintConfig // PrintObjectConfig // PrintRegionConfig // PrintConfig // GCodeConfig // HostConfig // #ifndef slic3r_PrintConfig_hpp_ #define slic3r_PrintConfig_hpp_ #include "libslic3r.h" #include "Config.hpp" #define OPT_PTR(KEY) if (opt_key == #KEY) return &this->KEY namespace Slic3r { enum GCodeFlavor { gcfRepRap, gcfTeacup, gcfMakerWare, gcfSailfish, gcfMach3, gcfMachinekit, gcfNoExtrusion, }; enum InfillPattern { ipRectilinear, ipGrid, ipTriangles, ipStars, ipCubic, ipLine, ipConcentric, ipHoneycomb, ip3DHoneycomb, ipHilbertCurve, ipArchimedeanChords, ipOctagramSpiral, }; enum SupportMaterialPattern { smpRectilinear, smpRectilinearGrid, smpHoneycomb, smpPillars, }; enum SeamPosition { spRandom, spNearest, spAligned //, spPreferred }; template<> inline t_config_enum_values ConfigOptionEnum::get_enum_values() { t_config_enum_values keys_map; keys_map["reprap"] = gcfRepRap; keys_map["teacup"] = gcfTeacup; keys_map["makerware"] = gcfMakerWare; keys_map["sailfish"] = gcfSailfish; keys_map["mach3"] = gcfMach3; keys_map["machinekit"] = gcfMachinekit; keys_map["no-extrusion"] = gcfNoExtrusion; return keys_map; } template<> inline t_config_enum_values ConfigOptionEnum::get_enum_values() { t_config_enum_values keys_map; keys_map["rectilinear"] = ipRectilinear; keys_map["grid"] = ipGrid; keys_map["triangles"] = ipTriangles; keys_map["stars"] = ipStars; keys_map["cubic"] = ipCubic; keys_map["line"] = ipLine; keys_map["concentric"] = ipConcentric; keys_map["honeycomb"] = ipHoneycomb; keys_map["3dhoneycomb"] = ip3DHoneycomb; keys_map["hilbertcurve"] = ipHilbertCurve; keys_map["archimedeanchords"] = ipArchimedeanChords; keys_map["octagramspiral"] = ipOctagramSpiral; return keys_map; } template<> inline t_config_enum_values ConfigOptionEnum::get_enum_values() { t_config_enum_values keys_map; keys_map["rectilinear"] = smpRectilinear; keys_map["rectilinear-grid"] = smpRectilinearGrid; keys_map["honeycomb"] = smpHoneycomb; keys_map["pillars"] = smpPillars; return keys_map; } template<> inline t_config_enum_values ConfigOptionEnum::get_enum_values() { t_config_enum_values keys_map; keys_map["random"] = spRandom; keys_map["nearest"] = spNearest; keys_map["aligned"] = spAligned; // keys_map["preferred"] = spPreferred; return keys_map; } // Defines each and every confiuration option of Slic3r, including the properties of the GUI dialogs. // Does not store the actual values, but defines default values. class PrintConfigDef : public ConfigDef { public: PrintConfigDef(); }; // The one and only global definition of SLic3r configuration options. // This definition is constant. extern PrintConfigDef print_config_def; // Slic3r configuration storage with print_config_def assigned. class PrintConfigBase : public virtual ConfigBase { public: PrintConfigBase() { this->def = &print_config_def; }; double min_object_distance() const; }; // Slic3r dynamic configuration, used to override the configuration // per object, per modification volume or per printing material. // The dynamic configuration is also used to store user modifications of the print global parameters, // so the modified configuration values may be diffed against the active configuration // to invalidate the proper slicing resp. g-code generation processing steps. // This object is mapped to Perl as Slic3r::Config. class DynamicPrintConfig : public PrintConfigBase, public DynamicConfig { public: DynamicPrintConfig() : PrintConfigBase(), DynamicConfig() {}; void normalize(); }; class StaticPrintConfig : public PrintConfigBase, public StaticConfig { public: StaticPrintConfig() : PrintConfigBase(), StaticConfig() {}; }; // This object is mapped to Perl as Slic3r::Config::PrintObject. class PrintObjectConfig : public virtual StaticPrintConfig { public: ConfigOptionBool dont_support_bridges; ConfigOptionFloatOrPercent extrusion_width; ConfigOptionFloatOrPercent first_layer_height; ConfigOptionBool infill_only_where_needed; ConfigOptionBool interface_shells; ConfigOptionFloat layer_height; ConfigOptionInt raft_layers; ConfigOptionEnum seam_position; // ConfigOptionFloat seam_preferred_direction; // ConfigOptionFloat seam_preferred_direction_jitter; ConfigOptionBool support_material; ConfigOptionInt support_material_angle; ConfigOptionBool support_material_buildplate_only; ConfigOptionFloat support_material_contact_distance; ConfigOptionInt support_material_enforce_layers; ConfigOptionInt support_material_extruder; ConfigOptionFloatOrPercent support_material_extrusion_width; ConfigOptionInt support_material_interface_extruder; ConfigOptionInt support_material_interface_layers; ConfigOptionFloat support_material_interface_spacing; ConfigOptionFloatOrPercent support_material_interface_speed; ConfigOptionEnum support_material_pattern; ConfigOptionFloat support_material_spacing; ConfigOptionFloat support_material_speed; ConfigOptionInt support_material_threshold; ConfigOptionBool support_material_with_sheath; ConfigOptionFloat xy_size_compensation; PrintObjectConfig(bool initialize = true) : StaticPrintConfig() { if (initialize) this->set_defaults(); } virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) { OPT_PTR(dont_support_bridges); OPT_PTR(extrusion_width); OPT_PTR(first_layer_height); OPT_PTR(infill_only_where_needed); OPT_PTR(interface_shells); OPT_PTR(layer_height); OPT_PTR(raft_layers); OPT_PTR(seam_position); // OPT_PTR(seam_preferred_direction); // OPT_PTR(seam_preferred_direction_jitter); OPT_PTR(support_material); OPT_PTR(support_material_angle); OPT_PTR(support_material_buildplate_only); OPT_PTR(support_material_contact_distance); OPT_PTR(support_material_enforce_layers); OPT_PTR(support_material_extruder); OPT_PTR(support_material_extrusion_width); OPT_PTR(support_material_interface_extruder); OPT_PTR(support_material_interface_layers); OPT_PTR(support_material_interface_spacing); OPT_PTR(support_material_interface_speed); OPT_PTR(support_material_pattern); OPT_PTR(support_material_spacing); OPT_PTR(support_material_speed); OPT_PTR(support_material_threshold); OPT_PTR(support_material_with_sheath); OPT_PTR(xy_size_compensation); return NULL; }; }; // This object is mapped to Perl as Slic3r::Config::PrintRegion. class PrintRegionConfig : public virtual StaticPrintConfig { public: ConfigOptionInt bottom_solid_layers; ConfigOptionFloat bridge_flow_ratio; ConfigOptionFloat bridge_speed; ConfigOptionBool ensure_vertical_shell_thickness; ConfigOptionEnum external_fill_pattern; ConfigOptionFloatOrPercent external_perimeter_extrusion_width; ConfigOptionFloatOrPercent external_perimeter_speed; ConfigOptionBool external_perimeters_first; ConfigOptionBool extra_perimeters; ConfigOptionFloat fill_angle; ConfigOptionPercent fill_density; ConfigOptionEnum fill_pattern; ConfigOptionFloat gap_fill_speed; ConfigOptionInt infill_extruder; ConfigOptionFloatOrPercent infill_extrusion_width; ConfigOptionInt infill_every_layers; ConfigOptionFloatOrPercent infill_overlap; ConfigOptionFloat infill_speed; ConfigOptionBool overhangs; ConfigOptionInt perimeter_extruder; ConfigOptionFloatOrPercent perimeter_extrusion_width; ConfigOptionFloat perimeter_speed; ConfigOptionInt perimeters; ConfigOptionFloatOrPercent small_perimeter_speed; ConfigOptionFloat solid_infill_below_area; ConfigOptionInt solid_infill_extruder; ConfigOptionFloatOrPercent solid_infill_extrusion_width; ConfigOptionInt solid_infill_every_layers; ConfigOptionFloatOrPercent solid_infill_speed; ConfigOptionBool thin_walls; ConfigOptionFloatOrPercent top_infill_extrusion_width; ConfigOptionInt top_solid_layers; ConfigOptionFloatOrPercent top_solid_infill_speed; PrintRegionConfig(bool initialize = true) : StaticPrintConfig() { if (initialize) this->set_defaults(); } virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) { OPT_PTR(bottom_solid_layers); OPT_PTR(bridge_flow_ratio); OPT_PTR(bridge_speed); OPT_PTR(ensure_vertical_shell_thickness); OPT_PTR(external_fill_pattern); OPT_PTR(external_perimeter_extrusion_width); OPT_PTR(external_perimeter_speed); OPT_PTR(external_perimeters_first); OPT_PTR(extra_perimeters); OPT_PTR(fill_angle); OPT_PTR(fill_density); OPT_PTR(fill_pattern); OPT_PTR(gap_fill_speed); OPT_PTR(infill_extruder); OPT_PTR(infill_extrusion_width); OPT_PTR(infill_every_layers); OPT_PTR(infill_overlap); OPT_PTR(infill_speed); OPT_PTR(overhangs); OPT_PTR(perimeter_extruder); OPT_PTR(perimeter_extrusion_width); OPT_PTR(perimeter_speed); OPT_PTR(perimeters); OPT_PTR(small_perimeter_speed); OPT_PTR(solid_infill_below_area); OPT_PTR(solid_infill_extruder); OPT_PTR(solid_infill_extrusion_width); OPT_PTR(solid_infill_every_layers); OPT_PTR(solid_infill_speed); OPT_PTR(thin_walls); OPT_PTR(top_infill_extrusion_width); OPT_PTR(top_solid_infill_speed); OPT_PTR(top_solid_layers); return NULL; }; }; // This object is mapped to Perl as Slic3r::Config::GCode. class GCodeConfig : public virtual StaticPrintConfig { public: ConfigOptionString before_layer_gcode; ConfigOptionString end_gcode; ConfigOptionString extrusion_axis; ConfigOptionFloats extrusion_multiplier; ConfigOptionFloats filament_diameter; ConfigOptionFloats filament_max_volumetric_speed; ConfigOptionBool gcode_comments; ConfigOptionEnum gcode_flavor; ConfigOptionString layer_gcode; ConfigOptionFloat max_print_speed; ConfigOptionFloat max_volumetric_speed; ConfigOptionFloat max_volumetric_extrusion_rate_slope_positive; ConfigOptionFloat max_volumetric_extrusion_rate_slope_negative; ConfigOptionFloat pressure_advance; ConfigOptionFloats retract_length; ConfigOptionFloats retract_length_toolchange; ConfigOptionFloats retract_lift; ConfigOptionFloats retract_lift_above; ConfigOptionFloats retract_lift_below; ConfigOptionFloats retract_restart_extra; ConfigOptionFloats retract_restart_extra_toolchange; ConfigOptionFloats retract_speed; ConfigOptionString start_gcode; ConfigOptionString toolchange_gcode; ConfigOptionFloat travel_speed; ConfigOptionBool use_firmware_retraction; ConfigOptionBool use_relative_e_distances; ConfigOptionBool use_volumetric_e; GCodeConfig(bool initialize = true) : StaticPrintConfig() { if (initialize) this->set_defaults(); } virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) { OPT_PTR(before_layer_gcode); OPT_PTR(end_gcode); OPT_PTR(extrusion_axis); OPT_PTR(extrusion_multiplier); OPT_PTR(filament_diameter); OPT_PTR(filament_max_volumetric_speed); OPT_PTR(gcode_comments); OPT_PTR(gcode_flavor); OPT_PTR(layer_gcode); OPT_PTR(max_print_speed); OPT_PTR(max_volumetric_speed); OPT_PTR(max_volumetric_extrusion_rate_slope_positive); OPT_PTR(max_volumetric_extrusion_rate_slope_negative); OPT_PTR(pressure_advance); OPT_PTR(retract_length); OPT_PTR(retract_length_toolchange); OPT_PTR(retract_lift); OPT_PTR(retract_lift_above); OPT_PTR(retract_lift_below); OPT_PTR(retract_restart_extra); OPT_PTR(retract_restart_extra_toolchange); OPT_PTR(retract_speed); OPT_PTR(start_gcode); OPT_PTR(toolchange_gcode); OPT_PTR(travel_speed); OPT_PTR(use_firmware_retraction); OPT_PTR(use_relative_e_distances); OPT_PTR(use_volumetric_e); return NULL; }; std::string get_extrusion_axis() const { if ((this->gcode_flavor.value == gcfMach3) || (this->gcode_flavor.value == gcfMachinekit)) { return "A"; } else if (this->gcode_flavor.value == gcfNoExtrusion) { return ""; } else { return this->extrusion_axis.value; } }; }; // This object is mapped to Perl as Slic3r::Config::Print. class PrintConfig : public GCodeConfig { public: ConfigOptionBool avoid_crossing_perimeters; ConfigOptionPoints bed_shape; ConfigOptionInt bed_temperature; ConfigOptionFloat bridge_acceleration; ConfigOptionInt bridge_fan_speed; ConfigOptionFloat brim_width; ConfigOptionBool complete_objects; ConfigOptionBool cooling; ConfigOptionFloat default_acceleration; ConfigOptionInt disable_fan_first_layers; ConfigOptionFloat duplicate_distance; ConfigOptionFloat extruder_clearance_height; ConfigOptionFloat extruder_clearance_radius; ConfigOptionPoints extruder_offset; ConfigOptionBool fan_always_on; ConfigOptionInt fan_below_layer_time; ConfigOptionStrings filament_colour; ConfigOptionStrings filament_notes; ConfigOptionFloat first_layer_acceleration; ConfigOptionInt first_layer_bed_temperature; ConfigOptionFloatOrPercent first_layer_extrusion_width; ConfigOptionFloatOrPercent first_layer_speed; ConfigOptionInts first_layer_temperature; ConfigOptionBool gcode_arcs; ConfigOptionFloat infill_acceleration; ConfigOptionBool infill_first; ConfigOptionInt max_fan_speed; ConfigOptionInt min_fan_speed; ConfigOptionFloat min_print_speed; ConfigOptionFloat min_skirt_length; ConfigOptionString notes; ConfigOptionFloats nozzle_diameter; ConfigOptionBool only_retract_when_crossing_perimeters; ConfigOptionBool ooze_prevention; ConfigOptionString output_filename_format; ConfigOptionFloat perimeter_acceleration; ConfigOptionStrings post_process; ConfigOptionFloat resolution; ConfigOptionFloats retract_before_travel; ConfigOptionBools retract_layer_change; ConfigOptionFloat skirt_distance; ConfigOptionInt skirt_height; ConfigOptionInt skirts; ConfigOptionInt slowdown_below_layer_time; ConfigOptionBool spiral_vase; ConfigOptionInt standby_temperature_delta; ConfigOptionInts temperature; ConfigOptionInt threads; ConfigOptionBools wipe; ConfigOptionFloat z_offset; PrintConfig(bool initialize = true) : GCodeConfig(false) { if (initialize) this->set_defaults(); } virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) { OPT_PTR(avoid_crossing_perimeters); OPT_PTR(bed_shape); OPT_PTR(bed_temperature); OPT_PTR(bridge_acceleration); OPT_PTR(bridge_fan_speed); OPT_PTR(brim_width); OPT_PTR(complete_objects); OPT_PTR(cooling); OPT_PTR(default_acceleration); OPT_PTR(disable_fan_first_layers); OPT_PTR(duplicate_distance); OPT_PTR(extruder_clearance_height); OPT_PTR(extruder_clearance_radius); OPT_PTR(extruder_offset); OPT_PTR(fan_always_on); OPT_PTR(fan_below_layer_time); OPT_PTR(filament_colour); OPT_PTR(filament_notes); OPT_PTR(first_layer_acceleration); OPT_PTR(first_layer_bed_temperature); OPT_PTR(first_layer_extrusion_width); OPT_PTR(first_layer_speed); OPT_PTR(first_layer_temperature); OPT_PTR(gcode_arcs); OPT_PTR(infill_acceleration); OPT_PTR(infill_first); OPT_PTR(max_fan_speed); OPT_PTR(min_fan_speed); OPT_PTR(min_print_speed); OPT_PTR(min_skirt_length); OPT_PTR(notes); OPT_PTR(nozzle_diameter); OPT_PTR(only_retract_when_crossing_perimeters); OPT_PTR(ooze_prevention); OPT_PTR(output_filename_format); OPT_PTR(perimeter_acceleration); OPT_PTR(post_process); OPT_PTR(resolution); OPT_PTR(retract_before_travel); OPT_PTR(retract_layer_change); OPT_PTR(skirt_distance); OPT_PTR(skirt_height); OPT_PTR(skirts); OPT_PTR(slowdown_below_layer_time); OPT_PTR(spiral_vase); OPT_PTR(standby_temperature_delta); OPT_PTR(temperature); OPT_PTR(threads); OPT_PTR(wipe); OPT_PTR(z_offset); // look in parent class ConfigOption* opt; if ((opt = GCodeConfig::optptr(opt_key, create)) != NULL) return opt; return NULL; }; }; class HostConfig : public virtual StaticPrintConfig { public: ConfigOptionString octoprint_host; ConfigOptionString octoprint_apikey; ConfigOptionString serial_port; ConfigOptionInt serial_speed; HostConfig(bool initialize = true) : StaticPrintConfig() { if (initialize) this->set_defaults(); } virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) { OPT_PTR(octoprint_host); OPT_PTR(octoprint_apikey); OPT_PTR(serial_port); OPT_PTR(serial_speed); return NULL; }; }; // This object is mapped to Perl as Slic3r::Config::Full. class FullPrintConfig : public PrintObjectConfig, public PrintRegionConfig, public PrintConfig, public HostConfig { public: FullPrintConfig(bool initialize = true) : PrintObjectConfig(false), PrintRegionConfig(false), PrintConfig(false), HostConfig(false) { if (initialize) this->set_defaults(); } virtual ConfigOption* optptr(const t_config_option_key &opt_key, bool create = false) { ConfigOption* opt; if ((opt = PrintObjectConfig::optptr(opt_key, create)) != NULL) return opt; if ((opt = PrintRegionConfig::optptr(opt_key, create)) != NULL) return opt; if ((opt = PrintConfig::optptr(opt_key, create)) != NULL) return opt; if ((opt = HostConfig::optptr(opt_key, create)) != NULL) return opt; return NULL; }; }; } #endif Slic3r-version_1.31.6/xs/src/libslic3r/PrintObject.cpp000066400000000000000000001243661301441720000225500ustar00rootroot00000000000000#include "Print.hpp" #include "BoundingBox.hpp" #include "ClipperUtils.hpp" #include "Geometry.hpp" #include "SVG.hpp" #include namespace Slic3r { PrintObject::PrintObject(Print* print, ModelObject* model_object, const BoundingBoxf3 &modobj_bbox) : typed_slices(false), _print(print), _model_object(model_object) { // Compute the translation to be applied to our meshes so that we work with smaller coordinates { // Translate meshes so that our toolpath generation algorithms work with smaller // XY coordinates; this translation is an optimization and not strictly required. // A cloned mesh will be aligned to 0 before slicing in _slice_region() since we // don't assume it's already aligned and we don't alter the original position in model. // We store the XY translation so that we can place copies correctly in the output G-code // (copies are expressed in G-code coordinates and this translation is not publicly exposed). this->_copies_shift = Point( scale_(modobj_bbox.min.x), scale_(modobj_bbox.min.y)); // Scale the object size and store it Pointf3 size = modobj_bbox.size(); this->size = Point3(scale_(size.x), scale_(size.y), scale_(size.z)); } this->reload_model_instances(); this->layer_height_ranges = model_object->layer_height_ranges; } bool PrintObject::add_copy(const Pointf &point) { Points points = this->_copies; points.push_back(Point::new_scale(point.x, point.y)); return this->set_copies(points); } bool PrintObject::delete_last_copy() { Points points = this->_copies; points.pop_back(); return this->set_copies(points); } bool PrintObject::delete_all_copies() { Points points; return this->set_copies(points); } bool PrintObject::set_copies(const Points &points) { this->_copies = points; // order copies with a nearest neighbor search and translate them by _copies_shift this->_shifted_copies.clear(); this->_shifted_copies.reserve(points.size()); // order copies with a nearest-neighbor search std::vector ordered_copies; Slic3r::Geometry::chained_path(points, ordered_copies); for (std::vector::const_iterator it = ordered_copies.begin(); it != ordered_copies.end(); ++it) { Point copy = points[*it]; copy.translate(this->_copies_shift); this->_shifted_copies.push_back(copy); } bool invalidated = false; if (this->_print->invalidate_step(psSkirt)) invalidated = true; if (this->_print->invalidate_step(psBrim)) invalidated = true; return invalidated; } bool PrintObject::reload_model_instances() { Points copies; for (ModelInstancePtrs::const_iterator i = this->_model_object->instances.begin(); i != this->_model_object->instances.end(); ++i) { copies.push_back(Point::new_scale((*i)->offset.x, (*i)->offset.y)); } return this->set_copies(copies); } void PrintObject::add_region_volume(int region_id, int volume_id) { region_volumes[region_id].push_back(volume_id); } /* This is the *total* layer count (including support layers) this value is not supposed to be compared with Layer::id since they have different semantics */ size_t PrintObject::total_layer_count() const { return this->layer_count() + this->support_layer_count(); } size_t PrintObject::layer_count() const { return this->layers.size(); } void PrintObject::clear_layers() { for (int i = this->layers.size()-1; i >= 0; --i) this->delete_layer(i); } Layer* PrintObject::add_layer(int id, coordf_t height, coordf_t print_z, coordf_t slice_z) { Layer* layer = new Layer(id, this, height, print_z, slice_z); layers.push_back(layer); return layer; } void PrintObject::delete_layer(int idx) { LayerPtrs::iterator i = this->layers.begin() + idx; delete *i; this->layers.erase(i); } size_t PrintObject::support_layer_count() const { return this->support_layers.size(); } void PrintObject::clear_support_layers() { for (int i = this->support_layers.size()-1; i >= 0; --i) this->delete_support_layer(i); } SupportLayer* PrintObject::get_support_layer(int idx) { return this->support_layers.at(idx); } SupportLayer* PrintObject::add_support_layer(int id, coordf_t height, coordf_t print_z) { SupportLayer* layer = new SupportLayer(id, this, height, print_z, -1); support_layers.push_back(layer); return layer; } void PrintObject::delete_support_layer(int idx) { SupportLayerPtrs::iterator i = this->support_layers.begin() + idx; delete *i; this->support_layers.erase(i); } bool PrintObject::invalidate_state_by_config_options(const std::vector &opt_keys) { std::set steps; // this method only accepts PrintObjectConfig and PrintRegionConfig option keys for (std::vector::const_iterator opt_key = opt_keys.begin(); opt_key != opt_keys.end(); ++opt_key) { if (*opt_key == "perimeters" || *opt_key == "extra_perimeters" || *opt_key == "gap_fill_speed" || *opt_key == "overhangs" || *opt_key == "first_layer_extrusion_width" || *opt_key == "perimeter_extrusion_width" || *opt_key == "infill_overlap" || *opt_key == "thin_walls" || *opt_key == "external_perimeters_first") { steps.insert(posPerimeters); } else if (*opt_key == "layer_height" || *opt_key == "first_layer_height" || *opt_key == "xy_size_compensation" || *opt_key == "raft_layers") { steps.insert(posSlice); } else if (*opt_key == "support_material" || *opt_key == "support_material_angle" || *opt_key == "support_material_extruder" || *opt_key == "support_material_extrusion_width" || *opt_key == "support_material_interface_layers" || *opt_key == "support_material_interface_extruder" || *opt_key == "support_material_interface_spacing" || *opt_key == "support_material_interface_speed" || *opt_key == "support_material_buildplate_only" || *opt_key == "support_material_pattern" || *opt_key == "support_material_spacing" || *opt_key == "support_material_threshold" || *opt_key == "support_material_with_sheath" || *opt_key == "dont_support_bridges" || *opt_key == "first_layer_extrusion_width") { steps.insert(posSupportMaterial); } else if (*opt_key == "interface_shells" || *opt_key == "infill_only_where_needed" || *opt_key == "infill_every_layers" || *opt_key == "solid_infill_every_layers" || *opt_key == "bottom_solid_layers" || *opt_key == "top_solid_layers" || *opt_key == "solid_infill_below_area" || *opt_key == "infill_extruder" || *opt_key == "solid_infill_extruder" || *opt_key == "infill_extrusion_width" || *opt_key == "ensure_vertical_shell_thickness") { steps.insert(posPrepareInfill); } else if (*opt_key == "external_fill_pattern" || *opt_key == "external_fill_link_max_length" || *opt_key == "fill_angle" || *opt_key == "fill_pattern" || *opt_key == "fill_link_max_length" || *opt_key == "top_infill_extrusion_width" || *opt_key == "first_layer_extrusion_width") { steps.insert(posInfill); } else if (*opt_key == "fill_density" || *opt_key == "solid_infill_extrusion_width") { steps.insert(posPerimeters); steps.insert(posPrepareInfill); } else if (*opt_key == "external_perimeter_extrusion_width" || *opt_key == "perimeter_extruder") { steps.insert(posPerimeters); steps.insert(posSupportMaterial); } else if (*opt_key == "bridge_flow_ratio") { steps.insert(posPerimeters); steps.insert(posInfill); } else if (*opt_key == "seam_position" || *opt_key == "seam_preferred_direction" || *opt_key == "seam_preferred_direction_jitter" || *opt_key == "support_material_speed" || *opt_key == "bridge_speed" || *opt_key == "external_perimeter_speed" || *opt_key == "infill_speed" || *opt_key == "perimeter_speed" || *opt_key == "small_perimeter_speed" || *opt_key == "solid_infill_speed" || *opt_key == "top_solid_infill_speed") { // these options only affect G-code export, so nothing to invalidate } else { // for legacy, if we can't handle this option let's invalidate all steps return this->invalidate_all_steps(); } } bool invalidated = false; for (std::set::const_iterator step = steps.begin(); step != steps.end(); ++step) { if (this->invalidate_step(*step)) invalidated = true; } return invalidated; } bool PrintObject::invalidate_step(PrintObjectStep step) { bool invalidated = this->state.invalidate(step); // propagate to dependent steps if (step == posPerimeters) { this->invalidate_step(posPrepareInfill); this->_print->invalidate_step(psSkirt); this->_print->invalidate_step(psBrim); } else if (step == posPrepareInfill) { this->invalidate_step(posInfill); } else if (step == posInfill) { this->_print->invalidate_step(psSkirt); this->_print->invalidate_step(psBrim); } else if (step == posSlice) { this->invalidate_step(posPerimeters); this->invalidate_step(posSupportMaterial); } else if (step == posSupportMaterial) { this->_print->invalidate_step(psSkirt); this->_print->invalidate_step(psBrim); } return invalidated; } bool PrintObject::invalidate_all_steps() { // make a copy because when invalidating steps the iterators are not working anymore std::set steps = this->state.started; bool invalidated = false; for (std::set::const_iterator step = steps.begin(); step != steps.end(); ++step) { if (this->invalidate_step(*step)) invalidated = true; } return invalidated; } bool PrintObject::has_support_material() const { return this->config.support_material || this->config.raft_layers > 0 || this->config.support_material_enforce_layers > 0; } // This function analyzes slices of a region (SurfaceCollection slices). // Each region slice (instance of Surface) is analyzed, whether it is supported or whether it is the top surface. // Initially all slices are of type S_TYPE_INTERNAL. // Slices are compared against the top / bottom slices and regions and classified to the following groups: // S_TYPE_TOP - Part of a region, which is not covered by any upper layer. This surface will be filled with a top solid infill. // S_TYPE_BOTTOMBRIDGE - Part of a region, which is not fully supported, but it hangs in the air, or it hangs losely on a support or a raft. // S_TYPE_BOTTOM - Part of a region, which is not supported by the same region, but it is supported either by another region, or by a soluble interface layer. // S_TYPE_INTERNAL - Part of a region, which is supported by the same region type. // If a part of a region is of S_TYPE_BOTTOM and S_TYPE_TOP, the S_TYPE_BOTTOM wins. void PrintObject::detect_surfaces_type() { // Slic3r::debugf "Detecting solid surfaces...\n"; for (int idx_region = 0; idx_region < this->_print->regions.size(); ++ idx_region) { #ifdef SLIC3R_DEBUG_SLICE_PROCESSING for (int idx_layer = 0; idx_layer < int(this->layer_count()); ++ idx_layer) { LayerRegion *layerm = this->layers[idx_layer]->get_region(idx_region); layerm->export_region_fill_surfaces_to_svg_debug("1_detect_surfaces_type-initial"); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ for (int idx_layer = 0; idx_layer < int(this->layer_count()); ++ idx_layer) { Layer *layer = this->layers[idx_layer]; LayerRegion *layerm = layer->get_region(idx_region); // comparison happens against the *full* slices (considering all regions) // unless internal shells are requested Layer *upper_layer = idx_layer + 1 < this->layer_count() ? this->get_layer(idx_layer + 1) : NULL; Layer *lower_layer = idx_layer > 0 ? this->get_layer(idx_layer - 1) : NULL; // collapse very narrow parts (using the safety offset in the diff is not enough) float offset = layerm->flow(frExternalPerimeter).scaled_width() / 10.f; Polygons layerm_slices_surfaces = to_polygons(layerm->slices.surfaces); // find top surfaces (difference between current surfaces // of current layer and upper one) Surfaces top; if (upper_layer) { // Config value $self->config->interface_shells is true, if a support is separated from the object // by a soluble material (for example a PVA plastic). Polygons upper_slices = this->config.interface_shells.value ? to_polygons(upper_layer->get_region(idx_region)->slices.surfaces) : to_polygons(upper_layer->slices); surfaces_append(top, offset2_ex(diff(layerm_slices_surfaces, upper_slices, true), -offset, offset), stTop); } else { // if no upper layer, all surfaces of this one are solid // we clone surfaces because we're going to clear the slices collection top = layerm->slices.surfaces; for (Surfaces::iterator it = top.begin(); it != top.end(); ++ it) it->surface_type = stTop; } // find bottom surfaces (difference between current surfaces // of current layer and lower one) Surfaces bottom; if (lower_layer) { // If we have soluble support material, don't bridge. The overhang will be squished against a soluble layer separating // the support from the print. SurfaceType surface_type_bottom = (this->config.support_material.value && this->config.support_material_contact_distance.value == 0) ? stBottom : stBottomBridge; // Any surface lying on the void is a true bottom bridge (an overhang) surfaces_append( bottom, offset2_ex( diff(layerm_slices_surfaces, to_polygons(lower_layer->slices), true), -offset, offset), surface_type_bottom); // if user requested internal shells, we need to identify surfaces // lying on other slices not belonging to this region //FIXME Vojtech: config.internal_shells or config.interface_shells? Is it some legacy code? // Why shall multiple regions over soluble support be treated specially? if (this->config.interface_shells.value) { // non-bridging bottom surfaces: any part of this layer lying // on something else, excluding those lying on our own region surfaces_append( bottom, offset2_ex( diff( intersection(layerm_slices_surfaces, to_polygons(lower_layer->slices)), // supported to_polygons(lower_layer->get_region(idx_region)->slices.surfaces), true), -offset, offset), stBottom); } } else { // if no lower layer, all surfaces of this one are solid // we clone surfaces because we're going to clear the slices collection bottom = layerm->slices.surfaces; // if we have raft layers, consider bottom layer as a bridge // just like any other bottom surface lying on the void SurfaceType surface_type_bottom = (this->config.raft_layers.value > 0 && this->config.support_material_contact_distance.value > 0) ? stBottomBridge : stBottom; for (Surfaces::iterator it = bottom.begin(); it != bottom.end(); ++ it) it->surface_type = surface_type_bottom; } // now, if the object contained a thin membrane, we could have overlapping bottom // and top surfaces; let's do an intersection to discover them and consider them // as bottom surfaces (to allow for bridge detection) if (! top.empty() && ! bottom.empty()) { // Polygons overlapping = intersection(to_polygons(top), to_polygons(bottom)); // Slic3r::debugf " layer %d contains %d membrane(s)\n", $layerm->layer->id, scalar(@$overlapping) // if $Slic3r::debug; Polygons top_polygons = to_polygons(STDMOVE(top)); top.clear(); surfaces_append(top, #if 0 offset2_ex(diff(top_polygons, to_polygons(bottom), true), -offset, offset), #else diff_ex(top_polygons, to_polygons(bottom), false), #endif stTop); } // save surfaces to layer layerm->slices.surfaces.clear(); // find internal surfaces (difference between top/bottom surfaces and others) { Polygons topbottom = to_polygons(top); polygons_append(topbottom, to_polygons(bottom)); surfaces_append(layerm->slices.surfaces, #if 0 offset2_ex(diff(layerm_slices_surfaces, topbottom, true), -offset, offset), #else diff_ex(layerm_slices_surfaces, topbottom, false), #endif stInternal); } surfaces_append(layerm->slices.surfaces, STDMOVE(top)); surfaces_append(layerm->slices.surfaces, STDMOVE(bottom)); // Slic3r::debugf " layer %d has %d bottom, %d top and %d internal surfaces\n", // $layerm->layer->id, scalar(@bottom), scalar(@top), scalar(@internal) if $Slic3r::debug; #ifdef SLIC3R_DEBUG_SLICE_PROCESSING layerm->export_region_slices_to_svg_debug("detect_surfaces_type-final"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } // for each layer of a region // Fill in layerm->fill_surfaces by trimming the layerm->slices by the cummulative layerm->fill_surfaces. for (int idx_layer = 0; idx_layer < int(this->layer_count()); ++ idx_layer) { LayerRegion *layerm = this->layers[idx_layer]->get_region(idx_region); layerm->slices_to_fill_surfaces_clipped(); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING layerm->export_region_fill_surfaces_to_svg_debug("1_detect_surfaces_type-final"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } // for each layer of a region } // for each $self->print->region_count } void PrintObject::process_external_surfaces() { FOREACH_REGION(this->_print, region) { size_t region_id = region - this->_print->regions.begin(); FOREACH_LAYER(this, layer_it) { const Layer* lower_layer = (layer_it == this->layers.begin()) ? NULL : *(layer_it-1); (*layer_it)->get_region(region_id)->process_external_surfaces(lower_layer); } } } struct DiscoverVerticalShellsCacheEntry { DiscoverVerticalShellsCacheEntry() : valid(false) {} // Collected polygons, offsetted Polygons slices; Polygons fill_surfaces; // Is this cache entry valid? bool valid; }; void PrintObject::discover_vertical_shells() { PROFILE_FUNC(); const SurfaceType surfaces_bottom[2] = { stBottom, stBottomBridge }; for (size_t idx_region = 0; idx_region < this->_print->regions.size(); ++ idx_region) { PROFILE_BLOCK(discover_vertical_shells_region); const PrintRegion ®ion = *this->_print->get_region(idx_region); if (! region.config.ensure_vertical_shell_thickness.value) // This region will be handled by discover_horizontal_shells(). continue; int n_extra_top_layers = std::max(0, region.config.top_solid_layers.value - 1); int n_extra_bottom_layers = std::max(0, region.config.bottom_solid_layers.value - 1); if (n_extra_top_layers + n_extra_bottom_layers == 0) // Zero or 1 layer, there is no additional vertical wall thickness enforced. continue; // Cyclic buffers of pre-calculated offsetted top/bottom surfaces. std::vector cache_top_regions(n_extra_top_layers, DiscoverVerticalShellsCacheEntry()); std::vector cache_bottom_regions(n_extra_bottom_layers, DiscoverVerticalShellsCacheEntry()); for (size_t idx_layer = 0; idx_layer < this->layers.size(); ++ idx_layer) { PROFILE_BLOCK(discover_vertical_shells_region_layer); Layer *layer = this->layers[idx_layer]; LayerRegion *layerm = layer->get_region(idx_region); Flow solid_infill_flow = layerm->flow(frSolidInfill); coord_t infill_line_spacing = solid_infill_flow.scaled_spacing(); // Find a union of perimeters below / above this surface to guarantee a minimum shell thickness. Polygons shell; Polygons holes; #ifdef SLIC3R_DEBUG_SLICE_PROCESSING ExPolygons shell_ex; #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ float min_perimeter_infill_spacing = float(infill_line_spacing) * 1.05f; if (1) { PROFILE_BLOCK(discover_vertical_shells_region_layer_collect); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static size_t idx = 0; SVG svg_cummulative(debug_out_path("discover_vertical_shells-perimeters-before-union-run%d.svg", idx), this->bounding_box()); for (int n = (int)idx_layer - n_extra_bottom_layers; n <= (int)idx_layer + n_extra_top_layers; ++ n) { if (n < 0 || n >= (int)this->layers.size()) continue; ExPolygons &expolys = this->layers[n]->perimeter_expolygons; for (size_t i = 0; i < expolys.size(); ++ i) { SVG svg(debug_out_path("discover_vertical_shells-perimeters-before-union-run%d-layer%d-expoly%d.svg", idx, n, i), get_extents(expolys[i])); svg.draw(expolys[i]); svg.draw_outline(expolys[i].contour, "black", scale_(0.05)); svg.draw_outline(expolys[i].holes, "blue", scale_(0.05)); svg.Close(); svg_cummulative.draw(expolys[i]); svg_cummulative.draw_outline(expolys[i].contour, "black", scale_(0.05)); svg_cummulative.draw_outline(expolys[i].holes, "blue", scale_(0.05)); } } ++ idx; } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ // Reset the top / bottom inflated regions caches of entries, which are out of the moving window. if (n_extra_top_layers > 0) cache_top_regions[idx_layer % n_extra_top_layers].valid = false; if (n_extra_bottom_layers > 0 && idx_layer > 0) cache_bottom_regions[(idx_layer - 1) % n_extra_bottom_layers].valid = false; bool hole_first = true; for (int n = (int)idx_layer - n_extra_bottom_layers; n <= (int)idx_layer + n_extra_top_layers; ++ n) if (n >= 0 && n < (int)this->layers.size()) { Layer &neighbor_layer = *this->layers[n]; LayerRegion &neighbor_region = *neighbor_layer.get_region(int(idx_region)); Polygons newholes; for (size_t idx_region = 0; idx_region < this->_print->regions.size(); ++ idx_region) polygons_append(newholes, to_polygons(neighbor_layer.get_region(idx_region)->fill_expolygons)); if (hole_first) { hole_first = false; polygons_append(holes, STDMOVE(newholes)); } else if (! holes.empty()) { holes = intersection(holes, newholes); } size_t n_shell_old = shell.size(); if (n > int(idx_layer)) { // Collect top surfaces. DiscoverVerticalShellsCacheEntry &cache = cache_top_regions[n % n_extra_top_layers]; if (! cache.valid) { cache.valid = true; // neighbor_region.slices contain the source top regions, // so one would think that they encompass the top fill_surfaces. But the fill_surfaces could have been // expanded before, therefore they may protrude out of neighbor_region.slices's top surfaces. //FIXME one should probably use the cummulative top surfaces over all regions here. cache.slices = offset(to_expolygons(neighbor_region.slices.filter_by_type(stTop)), min_perimeter_infill_spacing); cache.fill_surfaces = offset(to_expolygons(neighbor_region.fill_surfaces.filter_by_type(stTop)), min_perimeter_infill_spacing); } polygons_append(shell, cache.slices); polygons_append(shell, cache.fill_surfaces); } else if (n < int(idx_layer)) { // Collect bottom and bottom bridge surfaces. DiscoverVerticalShellsCacheEntry &cache = cache_bottom_regions[n % n_extra_bottom_layers]; if (! cache.valid) { cache.valid = true; //FIXME one should probably use the cummulative top surfaces over all regions here. cache.slices = offset(to_expolygons(neighbor_region.slices.filter_by_types(surfaces_bottom, 2)), min_perimeter_infill_spacing); cache.fill_surfaces = offset(to_expolygons(neighbor_region.fill_surfaces.filter_by_types(surfaces_bottom, 2)), min_perimeter_infill_spacing); } polygons_append(shell, cache.slices); polygons_append(shell, cache.fill_surfaces); } // Running the union_ using the Clipper library piece by piece is cheaper // than running the union_ all at once. if (n_shell_old < shell.size()) shell = union_(shell, false); } #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static size_t idx = 0; SVG svg(debug_out_path("discover_vertical_shells-perimeters-before-union-%d.svg", idx ++), get_extents(shell)); svg.draw(shell); svg.draw_outline(shell, "black", scale_(0.05)); svg.Close(); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ #if 0 { PROFILE_BLOCK(discover_vertical_shells_region_layer_shell_); // shell = union_(shell, true); shell = union_(shell, false); } #endif #ifdef SLIC3R_DEBUG_SLICE_PROCESSING shell_ex = union_ex(shell, true); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } //if (shell.empty()) // continue; #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static size_t idx = 0; SVG svg(debug_out_path("discover_vertical_shells-perimeters-after-union-%d.svg", idx ++), get_extents(shell)); svg.draw(shell_ex); svg.draw_outline(shell_ex, "black", "blue", scale_(0.05)); svg.Close(); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static size_t idx = 0; SVG svg(debug_out_path("discover_vertical_shells-internal-wshell-%d.svg", idx ++), get_extents(shell)); svg.draw(layerm->fill_surfaces.filter_by_type(stInternal), "yellow", 0.5); svg.draw_outline(layerm->fill_surfaces.filter_by_type(stInternal), "black", "blue", scale_(0.05)); svg.draw(shell_ex, "blue", 0.5); svg.draw_outline(shell_ex, "black", "blue", scale_(0.05)); svg.Close(); } { static size_t idx = 0; SVG svg(debug_out_path("discover_vertical_shells-internalvoid-wshell-%d.svg", idx ++), get_extents(shell)); svg.draw(layerm->fill_surfaces.filter_by_type(stInternalVoid), "yellow", 0.5); svg.draw_outline(layerm->fill_surfaces.filter_by_type(stInternalVoid), "black", "blue", scale_(0.05)); svg.draw(shell_ex, "blue", 0.5); svg.draw_outline(shell_ex, "black", "blue", scale_(0.05)); svg.Close(); } { static size_t idx = 0; SVG svg(debug_out_path("discover_vertical_shells-internalvoid-wshell-%d.svg", idx ++), get_extents(shell)); svg.draw(layerm->fill_surfaces.filter_by_type(stInternalVoid), "yellow", 0.5); svg.draw_outline(layerm->fill_surfaces.filter_by_type(stInternalVoid), "black", "blue", scale_(0.05)); svg.draw(shell_ex, "blue", 0.5); svg.draw_outline(shell_ex, "black", "blue", scale_(0.05)); svg.Close(); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ // Trim the shells region by the internal & internal void surfaces. const SurfaceType surfaceTypesInternal[] = { stInternal, stInternalVoid, stInternalSolid }; const Polygons polygonsInternal = to_polygons(layerm->fill_surfaces.filter_by_types(surfaceTypesInternal, 2)); shell = intersection(shell, polygonsInternal, true); polygons_append(shell, diff(polygonsInternal, holes)); if (shell.empty()) continue; // Append the internal solids, so they will be merged with the new ones. polygons_append(shell, to_polygons(layerm->fill_surfaces.filter_by_type(stInternalSolid))); // These regions will be filled by a rectilinear full infill. Currently this type of infill // only fills regions, which fit at least a single line. To avoid gaps in the sparse infill, // make sure that this region does not contain parts narrower than the infill spacing width. #ifdef SLIC3R_DEBUG_SLICE_PROCESSING Polygons shell_before = shell; #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ #if 1 // Intentionally inflate a bit more than how much the region has been shrunk, // so there will be some overlap between this solid infill and the other infill regions (mainly the sparse infill). shell = offset2(shell, - 0.5f * min_perimeter_infill_spacing, 0.8f * min_perimeter_infill_spacing, CLIPPER_OFFSET_SCALE, ClipperLib::jtSquare); if (shell.empty()) continue; #else // Ensure each region is at least 3x infill line width wide, so it could be filled in. // float margin = float(infill_line_spacing) * 3.f; float margin = float(infill_line_spacing) * 1.5f; // we use a higher miterLimit here to handle areas with acute angles // in those cases, the default miterLimit would cut the corner and we'd // get a triangle in $too_narrow; if we grow it below then the shell // would have a different shape from the external surface and we'd still // have the same angle, so the next shell would be grown even more and so on. Polygons too_narrow = diff(shell, offset2(shell, -margin, margin, CLIPPER_OFFSET_SCALE, ClipperLib::jtMiter, 5.), true); if (! too_narrow.empty()) { // grow the collapsing parts and add the extra area to the neighbor layer // as well as to our original surfaces so that we support this // additional area in the next shell too // make sure our grown surfaces don't exceed the fill area polygons_append(shell, intersection(offset(too_narrow, margin), polygonsInternal)); } #endif ExPolygons new_internal_solid = intersection_ex(polygonsInternal, shell, false); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static size_t idx = 0; SVG svg(debug_out_path("discover_vertical_shells-regularized-%d.svg", idx ++), get_extents(shell_before)); // Source shell. svg.draw(union_ex(shell_before, true)); // Shell trimmed to the internal surfaces. svg.draw_outline(union_ex(shell, true), "black", "blue", scale_(0.05)); // Regularized infill region. svg.draw_outline(new_internal_solid, "red", "magenta", scale_(0.05)); svg.Close(); } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ // Trim the internal & internalvoid by the shell. Slic3r::ExPolygons new_internal = diff_ex( to_polygons(layerm->fill_surfaces.filter_by_type(stInternal)), shell, false ); Slic3r::ExPolygons new_internal_void = diff_ex( to_polygons(layerm->fill_surfaces.filter_by_type(stInternalVoid)), shell, false ); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING { static size_t idx = 0; SVG::export_expolygons(debug_out_path("discover_vertical_shells-new_internal-%d.svg", idx), get_extents(shell), new_internal, "black", "blue", scale_(0.05)); SVG::export_expolygons(debug_out_path("discover_vertical_shells-new_internal_void-%d.svg", idx), get_extents(shell), new_internal_void, "black", "blue", scale_(0.05)); SVG::export_expolygons(debug_out_path("discover_vertical_shells-new_internal_solid-%d.svg", idx), get_extents(shell), new_internal_solid, "black", "blue", scale_(0.05)); ++ idx; } #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ // Assign resulting internal surfaces to layer. const SurfaceType surfaceTypesKeep[] = { stTop, stBottom, stBottomBridge }; layerm->fill_surfaces.keep_types(surfaceTypesKeep, sizeof(surfaceTypesKeep)/sizeof(SurfaceType)); layerm->fill_surfaces.append(stInternal , new_internal); layerm->fill_surfaces.append(stInternalVoid , new_internal_void); layerm->fill_surfaces.append(stInternalSolid, new_internal_solid); #ifdef SLIC3R_DEBUG_SLICE_PROCESSING layerm->export_region_slices_to_svg_debug("4_discover_vertical_shells"); layerm->export_region_fill_surfaces_to_svg_debug("4_discover_vertical_shells"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } // for each layer } // for each region // Write the profiler measurements to file PROFILE_UPDATE(); PROFILE_OUTPUT(debug_out_path("discover_vertical_shells-profile.txt").c_str()); } /* This method applies bridge flow to the first internal solid layer above sparse infill */ void PrintObject::bridge_over_infill() { FOREACH_REGION(this->_print, region) { size_t region_id = region - this->_print->regions.begin(); // skip bridging in case there are no voids if ((*region)->config.fill_density.value == 100) continue; // get bridge flow Flow bridge_flow = (*region)->flow( frSolidInfill, -1, // layer height, not relevant for bridge flow true, // bridge false, // first layer -1, // custom width, not relevant for bridge flow *this ); FOREACH_LAYER(this, layer_it) { // skip first layer if (layer_it == this->layers.begin()) continue; Layer* layer = *layer_it; LayerRegion* layerm = layer->get_region(region_id); // extract the stInternalSolid surfaces that might be transformed into bridges Polygons internal_solid; layerm->fill_surfaces.filter_by_type(stInternalSolid, &internal_solid); // check whether the lower area is deep enough for absorbing the extra flow // (for obvious physical reasons but also for preventing the bridge extrudates // from overflowing in 3D preview) ExPolygons to_bridge; { Polygons to_bridge_pp = internal_solid; // iterate through lower layers spanned by bridge_flow double bottom_z = layer->print_z - bridge_flow.height; for (int i = (layer_it - this->layers.begin()) - 1; i >= 0; --i) { const Layer* lower_layer = this->layers[i]; // stop iterating if layer is lower than bottom_z if (lower_layer->print_z < bottom_z) break; // iterate through regions and collect internal surfaces Polygons lower_internal; FOREACH_LAYERREGION(lower_layer, lower_layerm_it) (*lower_layerm_it)->fill_surfaces.filter_by_type(stInternal, &lower_internal); // intersect such lower internal surfaces with the candidate solid surfaces to_bridge_pp = intersection(to_bridge_pp, lower_internal); } // there's no point in bridging too thin/short regions //FIXME Vojtech: The offset2 function is not a geometric offset, // therefore it may create 1) gaps, and 2) sharp corners, which are outside the original contour. // The gaps will be filled by a separate region, which makes the infill less stable and it takes longer. { double min_width = bridge_flow.scaled_width() * 3; to_bridge_pp = offset2(to_bridge_pp, -min_width, +min_width); } if (to_bridge_pp.empty()) continue; // convert into ExPolygons to_bridge = union_ex(to_bridge_pp); } #ifdef SLIC3R_DEBUG printf("Bridging " PRINTF_ZU " internal areas at layer " PRINTF_ZU "\n", to_bridge.size(), layer->id()); #endif // compute the remaning internal solid surfaces as difference ExPolygons not_to_bridge = diff_ex(internal_solid, to_bridge, true); to_bridge = intersection_ex(to_polygons(to_bridge), internal_solid, true); // build the new collection of fill_surfaces { layerm->fill_surfaces.remove_type(stInternalSolid); for (ExPolygons::const_iterator ex = to_bridge.begin(); ex != to_bridge.end(); ++ex) layerm->fill_surfaces.surfaces.push_back(Surface(stInternalBridge, *ex)); for (ExPolygons::const_iterator ex = not_to_bridge.begin(); ex != not_to_bridge.end(); ++ex) layerm->fill_surfaces.surfaces.push_back(Surface(stInternalSolid, *ex)); } /* # exclude infill from the layers below if needed # see discussion at https://github.com/alexrj/Slic3r/issues/240 # Update: do not exclude any infill. Sparse infill is able to absorb the excess material. if (0) { my $excess = $layerm->extruders->{infill}->bridge_flow->width - $layerm->height; for (my $i = $layer_id-1; $excess >= $self->get_layer($i)->height; $i--) { Slic3r::debugf " skipping infill below those areas at layer %d\n", $i; foreach my $lower_layerm (@{$self->get_layer($i)->regions}) { my @new_surfaces = (); # subtract the area from all types of surfaces foreach my $group (@{$lower_layerm->fill_surfaces->group}) { push @new_surfaces, map $group->[0]->clone(expolygon => $_), @{diff_ex( [ map $_->p, @$group ], [ map @$_, @$to_bridge ], )}; push @new_surfaces, map Slic3r::Surface->new( expolygon => $_, surface_type => S_TYPE_INTERNALVOID, ), @{intersection_ex( [ map $_->p, @$group ], [ map @$_, @$to_bridge ], )}; } $lower_layerm->fill_surfaces->clear; $lower_layerm->fill_surfaces->append($_) for @new_surfaces; } $excess -= $self->get_layer($i)->height; } } */ #ifdef SLIC3R_DEBUG_SLICE_PROCESSING layerm->export_region_slices_to_svg_debug("7_bridge_over_infill"); layerm->export_region_fill_surfaces_to_svg_debug("7_bridge_over_infill"); #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */ } } } } Slic3r-version_1.31.6/xs/src/libslic3r/PrintRegion.cpp000066400000000000000000000044511301441720000225550ustar00rootroot00000000000000#include "Print.hpp" namespace Slic3r { PrintRegion::PrintRegion(Print* print) : _print(print) { } PrintRegion::~PrintRegion() { } Print* PrintRegion::print() { return this->_print; } Flow PrintRegion::flow(FlowRole role, double layer_height, bool bridge, bool first_layer, double width, const PrintObject &object) const { ConfigOptionFloatOrPercent config_width; if (width != -1) { // use the supplied custom width, if any config_width.value = width; config_width.percent = false; } else { // otherwise, get extrusion width from configuration // (might be an absolute value, or a percent value, or zero for auto) if (first_layer && this->_print->config.first_layer_extrusion_width.value > 0) { config_width = this->_print->config.first_layer_extrusion_width; } else if (role == frExternalPerimeter) { config_width = this->config.external_perimeter_extrusion_width; } else if (role == frPerimeter) { config_width = this->config.perimeter_extrusion_width; } else if (role == frInfill) { config_width = this->config.infill_extrusion_width; } else if (role == frSolidInfill) { config_width = this->config.solid_infill_extrusion_width; } else if (role == frTopSolidInfill) { config_width = this->config.top_infill_extrusion_width; } else { CONFESS("Unknown role"); } } if (config_width.value == 0) { config_width = object.config.extrusion_width; } // get the configured nozzle_diameter for the extruder associated // to the flow role requested size_t extruder = 0; // 1-based if (role == frPerimeter || role == frExternalPerimeter) { extruder = this->config.perimeter_extruder; } else if (role == frInfill) { extruder = this->config.infill_extruder; } else if (role == frSolidInfill || role == frTopSolidInfill) { extruder = this->config.solid_infill_extruder; } else { CONFESS("Unknown role $role"); } double nozzle_diameter = this->_print->config.nozzle_diameter.get_at(extruder-1); return Flow::new_from_config_width(role, config_width, nozzle_diameter, layer_height, bridge ? (float)this->config.bridge_flow_ratio : 0.0); } } Slic3r-version_1.31.6/xs/src/libslic3r/SVG.cpp000066400000000000000000000275721301441720000207650ustar00rootroot00000000000000#include "SVG.hpp" #include #define COORD(x) ((float)unscale((x))*10) namespace Slic3r { bool SVG::open(const char* afilename) { this->filename = afilename; this->f = fopen(afilename, "w"); if (this->f == NULL) return false; fprintf(this->f, "\n" "\n" "\n" " \n" " \n" " \n" ); return true; } bool SVG::open(const char* afilename, const BoundingBox &bbox, const coord_t bbox_offset, bool aflipY) { this->filename = afilename; this->origin = bbox.min - Point(bbox_offset, bbox_offset); this->flipY = aflipY; this->f = ::fopen(afilename, "w"); if (f == NULL) return false; float w = COORD(bbox.max.x - bbox.min.x + 2 * bbox_offset); float h = COORD(bbox.max.y - bbox.min.y + 2 * bbox_offset); fprintf(this->f, "\n" "\n" "\n" " \n" " \n" " \n", h, w); return true; } void SVG::draw(const Line &line, std::string stroke, coordf_t stroke_width) { fprintf(this->f, " arrows) fprintf(this->f, " marker-end=\"url(#endArrow)\""); fprintf(this->f, "/>\n"); } void SVG::draw(const ThickLine &line, const std::string &fill, const std::string &stroke, coordf_t stroke_width) { Pointf dir(line.b.x-line.a.x, line.b.y-line.a.y); Pointf perp(-dir.y, dir.x); coordf_t len = sqrt(perp.x*perp.x + perp.y*perp.y); coordf_t da = coordf_t(0.5)*line.a_width/len; coordf_t db = coordf_t(0.5)*line.b_width/len; fprintf(this->f, " \n", COORD(line.a.x-da*perp.x-origin.x), COORD(line.a.y-da*perp.y-origin.y), COORD(line.b.x-db*perp.x-origin.x), COORD(line.b.y-db*perp.y-origin.y), COORD(line.b.x+db*perp.x-origin.x), COORD(line.b.y+db*perp.y-origin.y), COORD(line.a.x+da*perp.x-origin.x), COORD(line.a.y+da*perp.y-origin.y), fill.c_str(), stroke.c_str(), (stroke_width == 0) ? 1.f : COORD(stroke_width)); } void SVG::draw(const Lines &lines, std::string stroke, coordf_t stroke_width) { for (Lines::const_iterator it = lines.begin(); it != lines.end(); ++it) this->draw(*it, stroke, stroke_width); } void SVG::draw(const IntersectionLines &lines, std::string stroke) { for (IntersectionLines::const_iterator it = lines.begin(); it != lines.end(); ++it) this->draw((Line)*it, stroke); } void SVG::draw(const ExPolygon &expolygon, std::string fill, const float fill_opacity) { this->fill = fill; std::string d; Polygons pp = expolygon; for (Polygons::const_iterator p = pp.begin(); p != pp.end(); ++p) { d += this->get_path_d(*p, true) + " "; } this->path(d, true, 0, fill_opacity); } void SVG::draw_outline(const ExPolygon &expolygon, std::string stroke_outer, std::string stroke_holes, coordf_t stroke_width) { draw_outline(expolygon.contour, stroke_outer, stroke_width); for (Polygons::const_iterator it = expolygon.holes.begin(); it != expolygon.holes.end(); ++ it) { draw_outline(*it, stroke_holes, stroke_width); } } void SVG::draw(const ExPolygons &expolygons, std::string fill, const float fill_opacity) { for (ExPolygons::const_iterator it = expolygons.begin(); it != expolygons.end(); ++it) this->draw(*it, fill, fill_opacity); } void SVG::draw_outline(const ExPolygons &expolygons, std::string stroke_outer, std::string stroke_holes, coordf_t stroke_width) { for (ExPolygons::const_iterator it = expolygons.begin(); it != expolygons.end(); ++ it) draw_outline(*it, stroke_outer, stroke_holes, stroke_width); } void SVG::draw(const Surface &surface, std::string fill, const float fill_opacity) { draw(surface.expolygon, fill, fill_opacity); } void SVG::draw_outline(const Surface &surface, std::string stroke_outer, std::string stroke_holes, coordf_t stroke_width) { draw_outline(surface.expolygon, stroke_outer, stroke_holes, stroke_width); } void SVG::draw(const Surfaces &surfaces, std::string fill, const float fill_opacity) { for (Surfaces::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it) this->draw(*it, fill, fill_opacity); } void SVG::draw_outline(const Surfaces &surfaces, std::string stroke_outer, std::string stroke_holes, coordf_t stroke_width) { for (Surfaces::const_iterator it = surfaces.begin(); it != surfaces.end(); ++ it) draw_outline(*it, stroke_outer, stroke_holes, stroke_width); } void SVG::draw(const SurfacesPtr &surfaces, std::string fill, const float fill_opacity) { for (SurfacesPtr::const_iterator it = surfaces.begin(); it != surfaces.end(); ++it) this->draw(*(*it), fill, fill_opacity); } void SVG::draw_outline(const SurfacesPtr &surfaces, std::string stroke_outer, std::string stroke_holes, coordf_t stroke_width) { for (SurfacesPtr::const_iterator it = surfaces.begin(); it != surfaces.end(); ++ it) draw_outline(*(*it), stroke_outer, stroke_holes, stroke_width); } void SVG::draw(const Polygon &polygon, std::string fill) { this->fill = fill; this->path(this->get_path_d(polygon, true), !fill.empty(), 0, 1.f); } void SVG::draw(const Polygons &polygons, std::string fill) { for (Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++it) this->draw(*it, fill); } void SVG::draw(const Polyline &polyline, std::string stroke, coordf_t stroke_width) { this->stroke = stroke; this->path(this->get_path_d(polyline, false), false, stroke_width, 1.f); } void SVG::draw(const Polylines &polylines, std::string stroke, coordf_t stroke_width) { for (Polylines::const_iterator it = polylines.begin(); it != polylines.end(); ++it) this->draw(*it, stroke, stroke_width); } void SVG::draw(const ThickLines &thicklines, const std::string &fill, const std::string &stroke, coordf_t stroke_width) { for (ThickLines::const_iterator it = thicklines.begin(); it != thicklines.end(); ++it) this->draw(*it, fill, stroke, stroke_width); } void SVG::draw(const ThickPolylines &polylines, const std::string &stroke, coordf_t stroke_width) { for (ThickPolylines::const_iterator it = polylines.begin(); it != polylines.end(); ++it) this->draw((Polyline)*it, stroke, stroke_width); } void SVG::draw(const ThickPolylines &thickpolylines, const std::string &fill, const std::string &stroke, coordf_t stroke_width) { for (ThickPolylines::const_iterator it = thickpolylines.begin(); it != thickpolylines.end(); ++ it) draw(it->thicklines(), fill, stroke, stroke_width); } void SVG::draw(const Point &point, std::string fill, coord_t iradius) { float radius = (iradius == 0) ? 3.f : COORD(iradius); std::ostringstream svg; svg << " "; fprintf(this->f, "%s\n", svg.str().c_str()); } void SVG::draw(const Points &points, std::string fill, coord_t radius) { for (Points::const_iterator it = points.begin(); it != points.end(); ++it) this->draw(*it, fill, radius); } void SVG::draw(const ClipperLib::Path &polygon, double scale, std::string stroke, coordf_t stroke_width) { this->stroke = stroke; this->path(this->get_path_d(polygon, scale, true), false, stroke_width, 1.f); } void SVG::draw(const ClipperLib::Paths &polygons, double scale, std::string stroke, coordf_t stroke_width) { for (ClipperLib::Paths::const_iterator it = polygons.begin(); it != polygons.end(); ++ it) draw(*it, scale, stroke, stroke_width); } void SVG::draw_outline(const Polygon &polygon, std::string stroke, coordf_t stroke_width) { this->stroke = stroke; this->path(this->get_path_d(polygon, true), false, stroke_width, 1.f); } void SVG::draw_outline(const Polygons &polygons, std::string stroke, coordf_t stroke_width) { for (Polygons::const_iterator it = polygons.begin(); it != polygons.end(); ++ it) draw_outline(*it, stroke, stroke_width); } void SVG::path(const std::string &d, bool fill, coordf_t stroke_width, const float fill_opacity) { float lineWidth = 0.f; if (! fill) lineWidth = (stroke_width == 0) ? 2.f : COORD(stroke_width); fprintf( this->f, " \n", d.c_str(), fill ? this->fill.c_str() : "none", this->stroke.c_str(), lineWidth, (this->arrows && !fill) ? " marker-end=\"url(#endArrow)\"" : "", fill_opacity ); } std::string SVG::get_path_d(const MultiPoint &mp, bool closed) const { std::ostringstream d; d << "M "; for (Points::const_iterator p = mp.points.begin(); p != mp.points.end(); ++p) { d << COORD(p->x - origin.x) << " "; d << COORD(p->y - origin.y) << " "; } if (closed) d << "z"; return d.str(); } std::string SVG::get_path_d(const ClipperLib::Path &path, double scale, bool closed) const { std::ostringstream d; d << "M "; for (ClipperLib::Path::const_iterator p = path.begin(); p != path.end(); ++p) { d << COORD(scale * p->X - origin.x) << " "; d << COORD(scale * p->Y - origin.y) << " "; } if (closed) d << "z"; return d.str(); } void SVG::draw_text(const Point &pt, const char *text, const char *color) { fprintf(this->f, "%s", COORD(pt.x-origin.x), COORD(pt.y-origin.y), color, text); } void SVG::draw_legend(const Point &pt, const char *text, const char *color) { fprintf(this->f, "", COORD(pt.x-origin.x), COORD(pt.y-origin.y), color); fprintf(this->f, "%s", COORD(pt.x-origin.x) + 20.f, COORD(pt.y-origin.y), "black", text); } void SVG::Close() { fprintf(this->f, "\n"); fclose(this->f); this->f = NULL; // printf("SVG written to %s\n", this->filename.c_str()); } void SVG::export_expolygons(const char *path, const BoundingBox &bbox, const Slic3r::ExPolygons &expolygons, std::string stroke_outer, std::string stroke_holes, coordf_t stroke_width) { SVG svg(path, bbox); svg.draw(expolygons); svg.draw_outline(expolygons, stroke_outer, stroke_holes, stroke_width); svg.Close(); } } ��������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/SVG.hpp������������������������������������������������������0000664�0000000�0000000�00000013252�13014417200�0020760�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef slic3r_SVG_hpp_ #define slic3r_SVG_hpp_ #include "libslic3r.h" #include "clipper.hpp" #include "ExPolygon.hpp" #include "Line.hpp" #include "TriangleMesh.hpp" #include "Surface.hpp" namespace Slic3r { class SVG { public: bool arrows; std::string fill, stroke; Point origin; bool flipY; SVG(const char* afilename) : arrows(false), fill("grey"), stroke("black"), filename(afilename), flipY(false) { open(filename); } SVG(const char* afilename, const BoundingBox &bbox, const coord_t bbox_offset = scale_(1.), bool aflipY = false) : arrows(false), fill("grey"), stroke("black"), filename(afilename), origin(bbox.min - Point(bbox_offset, bbox_offset)), flipY(aflipY) { open(filename, bbox, bbox_offset, aflipY); } SVG(const std::string &filename) : arrows(false), fill("grey"), stroke("black"), filename(filename), flipY(false) { open(filename); } SVG(const std::string &filename, const BoundingBox &bbox, const coord_t bbox_offset = scale_(1.), bool aflipY = false) : arrows(false), fill("grey"), stroke("black"), filename(filename), origin(bbox.min - Point(bbox_offset, bbox_offset)), flipY(aflipY) { open(filename, bbox, bbox_offset, aflipY); } ~SVG() { if (f != NULL) Close(); } bool open(const char* filename); bool open(const char* filename, const BoundingBox &bbox, const coord_t bbox_offset = scale_(1.), bool flipY = false); bool open(const std::string &filename) { return open(filename.c_str()); } bool open(const std::string &filename, const BoundingBox &bbox, const coord_t bbox_offset = scale_(1.), bool flipY = false) { return open(filename.c_str(), bbox, bbox_offset, flipY); } void draw(const Line &line, std::string stroke = "black", coordf_t stroke_width = 0); void draw(const ThickLine &line, const std::string &fill, const std::string &stroke, coordf_t stroke_width = 0); void draw(const Lines &lines, std::string stroke = "black", coordf_t stroke_width = 0); void draw(const IntersectionLines &lines, std::string stroke = "black"); void draw(const ExPolygon &expolygon, std::string fill = "grey", const float fill_opacity=1.f); void draw_outline(const ExPolygon &polygon, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0); void draw(const ExPolygons &expolygons, std::string fill = "grey", const float fill_opacity=1.f); void draw_outline(const ExPolygons &polygons, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0); void draw(const Surface &surface, std::string fill = "grey", const float fill_opacity=1.f); void draw_outline(const Surface &surface, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0); void draw(const Surfaces &surfaces, std::string fill = "grey", const float fill_opacity=1.f); void draw_outline(const Surfaces &surfaces, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0); void draw(const SurfacesPtr &surfaces, std::string fill = "grey", const float fill_opacity=1.f); void draw_outline(const SurfacesPtr &surfaces, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0); void draw(const Polygon &polygon, std::string fill = "grey"); void draw_outline(const Polygon &polygon, std::string stroke = "black", coordf_t stroke_width = 0); void draw(const Polygons &polygons, std::string fill = "grey"); void draw_outline(const Polygons &polygons, std::string stroke = "black", coordf_t stroke_width = 0); void draw(const Polyline &polyline, std::string stroke = "black", coordf_t stroke_width = 0); void draw(const Polylines &polylines, std::string stroke = "black", coordf_t stroke_width = 0); void draw(const ThickLines &thicklines, const std::string &fill = "lime", const std::string &stroke = "black", coordf_t stroke_width = 0); void draw(const ThickPolylines &polylines, const std::string &stroke = "black", coordf_t stroke_width = 0); void draw(const ThickPolylines &thickpolylines, const std::string &fill, const std::string &stroke, coordf_t stroke_width); void draw(const Point &point, std::string fill = "black", coord_t radius = 0); void draw(const Points &points, std::string fill = "black", coord_t radius = 0); // Support for rendering the ClipperLib paths void draw(const ClipperLib::Path &polygon, double scale, std::string fill = "grey", coordf_t stroke_width = 0); void draw(const ClipperLib::Paths &polygons, double scale, std::string fill = "grey", coordf_t stroke_width = 0); void draw_text(const Point &pt, const char *text, const char *color); void draw_legend(const Point &pt, const char *text, const char *color); void Close(); private: std::string filename; FILE* f; void path(const std::string &d, bool fill, coordf_t stroke_width, const float fill_opacity); std::string get_path_d(const MultiPoint &mp, bool closed = false) const; std::string get_path_d(const ClipperLib::Path &mp, double scale, bool closed = false) const; public: static void export_expolygons(const char *path, const BoundingBox &bbox, const Slic3r::ExPolygons &expolygons, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0); static void export_expolygons(const std::string &path, const BoundingBox &bbox, const Slic3r::ExPolygons &expolygons, std::string stroke_outer = "black", std::string stroke_holes = "blue", coordf_t stroke_width = 0) { export_expolygons(path.c_str(), bbox, expolygons, stroke_outer, stroke_holes, stroke_width); } }; } #endif ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/SupportMaterial.cpp������������������������������������������0000664�0000000�0000000�00000253166�13014417200�0023461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#include "ClipperUtils.hpp" #include "ExtrusionEntityCollection.hpp" #include "PerimeterGenerator.hpp" #include "Print.hpp" #include "Layer.hpp" #include "SupportMaterial.hpp" #include "Fill/FillBase.hpp" #include "SVG.hpp" #include #include #include #define SLIC3R_DEBUG namespace Slic3r { // Increment used to reach MARGIN in steps to avoid trespassing thin objects #define NUM_MARGIN_STEPS 3 // Dimensions of a tree-like structure to save material #define PILLAR_SIZE (2.5) #define PILLAR_SPACING 10 PrintObjectSupportMaterial::PrintObjectSupportMaterial(const PrintObject *object) : m_object (object), m_print_config (&object->print()->config), m_object_config (&object->config), m_first_layer_flow (Flow::new_from_config_width( frSupportMaterial, (object->print()->config.first_layer_extrusion_width.value > 0) ? object->print()->config.first_layer_extrusion_width : object->config.support_material_extrusion_width, object->print()->config.nozzle_diameter.get_at(object->config.support_material_extruder-1), object->config.get_abs_value("first_layer_height"), false )), m_support_material_flow (Flow::new_from_config_width( frSupportMaterial, (object->config.support_material_extrusion_width.value > 0) ? object->config.support_material_extrusion_width : object->config.extrusion_width, object->print()->config.nozzle_diameter.get_at(object->config.support_material_extruder-1), object->config.layer_height.value, false)), m_support_material_interface_flow(Flow::new_from_config_width( frSupportMaterialInterface, (object->config.support_material_extrusion_width.value > 0) ? object->config.support_material_extrusion_width : object->config.extrusion_width, object->print()->config.nozzle_diameter.get_at(object->config.support_material_interface_extruder-1), object->config.layer_height.value, false)), m_soluble_interface (object->config.support_material_contact_distance.value == 0), m_support_material_raft_base_flow(0, 0, 0, false), m_support_material_raft_interface_flow(0, 0, 0, false), m_support_material_raft_contact_flow(0, 0, 0, false), m_has_raft (object->config.raft_layers.value > 0), m_num_base_raft_layers (0), m_num_interface_raft_layers (0), m_num_contact_raft_layers (0), // If set, the raft contact layer is laid with round strings, which are easily detachable // from both the below and above layes. // Otherwise a normal flow is used and the strings are squashed against the layer below, // creating a firm bond with the layer below and making the interface top surface flat. #if 1 // This is the standard Slic3r behavior. m_raft_contact_layer_bridging(false), m_object_1st_layer_bridging (true), #else // This is more akin to what Simplify3D or Zortrax do. m_raft_contact_layer_bridging(true), m_object_1st_layer_bridging (false), #endif m_raft_height (0.), m_raft_base_height (0.), m_raft_interface_height (0.), m_raft_contact_height (0.), // 50 mirons layer m_support_layer_height_min (0.05), m_support_layer_height_max (0.), m_support_interface_layer_height_max(0.), m_gap_extra_above (0.2), m_gap_extra_below (0.2), m_gap_xy (0.2), // If enabled, the support layers will be synchronized with object layers. // This does not prevent the support layers to be combined. m_synchronize_support_layers_with_object(false), // If disabled and m_synchronize_support_layers_with_object, // the support layers will be synchronized with the object layers exactly, no layer will be combined. m_combine_support_layers (true) { // Based on the raft style and size, initialize the raft layers and the 1st object layer attributes. size_t num_raft_layers = m_object_config->raft_layers.value; //FIXME better to draw thin strings, which are easier to remove from the object. if (m_has_raft) { if (m_raft_contact_layer_bridging) m_support_material_raft_contact_flow = Flow::new_from_spacing( m_support_material_raft_interface_flow.spacing(), m_support_material_raft_interface_flow.nozzle_diameter, m_support_material_raft_interface_flow.height, true); if (m_raft_contact_layer_bridging && num_raft_layers == 1) // The bridging contact layer will not bond to the bed well on its own. // Ensure there is at least the 1st layer printed with a firm squash. ++ num_raft_layers; // Split the raft layers into a single contact layer // and an equal number of interface and base layers, // with m_num_interface_raft_layers >= m_num_base_raft_layers. m_num_contact_raft_layers = 1; m_num_interface_raft_layers = num_raft_layers / 2; m_num_base_raft_layers = num_raft_layers - m_num_contact_raft_layers - m_num_interface_raft_layers; assert(m_num_interface_raft_layers >= m_num_base_raft_layers); assert(m_num_contact_raft_layers + m_num_base_raft_layers + m_num_interface_raft_layers == num_raft_layers); m_raft_contact_height = m_num_contact_raft_layers * m_support_material_raft_contact_flow.height; if (m_num_base_raft_layers > 0) { m_raft_base_height = first_layer_height() + (m_num_base_raft_layers - 1) * m_support_material_raft_base_flow.height; m_raft_interface_height = m_num_interface_raft_layers * m_support_material_raft_interface_flow.height; } else if (m_num_interface_raft_layers > 0) { m_raft_base_height = 0; m_raft_interface_height = first_layer_height() + (m_num_interface_raft_layers - 1) * m_support_material_raft_interface_flow.height; } else { m_raft_base_height = 0; m_raft_interface_height = 0; } m_raft_height = m_raft_base_height + m_raft_interface_height + m_raft_contact_height; // Find the layer height of the 1st object layer. if (m_object_1st_layer_bridging) { // Use an average nozzle diameter. std::set extruders = m_object->print()->object_extruders(); coordf_t nozzle_dmr = 0; for (std::set::const_iterator it = extruders.begin(); it != extruders.end(); ++ it) { nozzle_dmr += m_object->print()->config.nozzle_diameter.get_at(*it); } nozzle_dmr /= extruders.size(); m_object_1st_layer_height = nozzle_dmr; } else { m_object_1st_layer_height = m_object->config.layer_height.value; for (t_layer_height_ranges::const_iterator it = m_object->layer_height_ranges.begin(); it != m_object->layer_height_ranges.end(); ++ it) { if (m_object_1st_layer_height >= it->first.first && m_object_1st_layer_height <= it->first.second) { m_object_1st_layer_height = it->second; break; } } } m_object_1st_layer_gap = m_soluble_interface ? 0. : m_object_config->support_material_contact_distance.value; m_object_1st_layer_print_z = m_raft_height + m_object_1st_layer_gap + m_object_1st_layer_height; } else { // No raft. m_raft_contact_layer_bridging = false; m_object_1st_layer_bridging = false; m_object_1st_layer_height = m_first_layer_flow.height; m_object_1st_layer_gap = 0; m_object_1st_layer_print_z = m_object_1st_layer_height; } } // Using the std::deque as an allocator. inline PrintObjectSupportMaterial::MyLayer& layer_allocate( std::deque &layer_storage, PrintObjectSupportMaterial::SupporLayerType layer_type) { layer_storage.push_back(PrintObjectSupportMaterial::MyLayer()); layer_storage.back().layer_type = layer_type; return layer_storage.back(); } inline void layers_append(PrintObjectSupportMaterial::MyLayersPtr &dst, const PrintObjectSupportMaterial::MyLayersPtr &src) { dst.insert(dst.end(), src.begin(), src.end()); } // Compare layers lexicographically. struct MyLayersPtrCompare { bool operator()(const PrintObjectSupportMaterial::MyLayer* layer1, const PrintObjectSupportMaterial::MyLayer* layer2) const { return *layer1 < *layer2; } }; void PrintObjectSupportMaterial::generate(PrintObject &object) { coordf_t max_object_layer_height = 0.; for (size_t i = 0; i < object.layer_count(); ++ i) max_object_layer_height = std::max(max_object_layer_height, object.get_layer(i)->height); if (m_support_layer_height_max == 0) m_support_layer_height_max = std::max(max_object_layer_height, 0.75 * m_support_material_flow.nozzle_diameter); if (m_support_interface_layer_height_max == 0) m_support_interface_layer_height_max = std::max(max_object_layer_height, 0.75 * m_support_material_interface_flow.nozzle_diameter); // Layer instances will be allocated by std::deque and they will be kept until the end of this function call. // The layers will be referenced by various LayersPtr (of type std::vector) MyLayerStorage layer_storage; // Determine the top contact surfaces of the support, defined as: // contact = overhangs - clearance + margin // This method is responsible for identifying what contact surfaces // should the support material expose to the object in order to guarantee // that it will be effective, regardless of how it's built below. // If raft is to be generated, the 1st top_contact layer will contain the 1st object layer silhouette without holes. MyLayersPtr top_contacts = this->top_contact_layers(object, layer_storage); if (top_contacts.empty()) // Nothing is supported, no supports are generated. return; #ifdef SLIC3R_DEBUG static int iRun = 0; iRun ++; for (MyLayersPtr::const_iterator it = top_contacts.begin(); it != top_contacts.end(); ++ it) { const MyLayer &layer = *(*it); ::Slic3r::SVG svg(debug_out_path("support-top-contacts-%d-%lf.svg", iRun, layer.print_z), get_extents(layer.polygons)); Slic3r::ExPolygons expolys = union_ex(layer.polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ // Determine the bottom contact surfaces of the supports over the top surfaces of the object. // Depending on whether the support is soluble or not, the contact layer thickness is decided. MyLayersPtr bottom_contacts = this->bottom_contact_layers(object, top_contacts, layer_storage); #ifdef SLIC3R_DEBUG for (MyLayersPtr::const_iterator it = bottom_contacts.begin(); it != bottom_contacts.end(); ++ it) { const MyLayer &layer = *(*it); ::Slic3r::SVG svg(debug_out_path("support-bottom-contacts-%d-%lf.svg", iRun, layer.print_z), get_extents(layer.polygons)); Slic3r::ExPolygons expolys = union_ex(layer.polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ // Because the top and bottom contacts are thick slabs, they may overlap causing over extrusion // and unwanted strong bonds to the object. // Rather trim the top contacts by their overlapping bottom contacts to leave a gap instead of over extruding. this->trim_top_contacts_by_bottom_contacts(object, bottom_contacts, top_contacts); // Generate empty intermediate layers between the top / bottom support contact layers, // The layers may or may not be synchronized with the object layers, depending on the configuration. // For example, a single nozzle multi material printing will need to generate a waste tower, which in turn // wastes less material, if there are as little layers as possible, therefore minimizing the material swaps. MyLayersPtr intermediate_layers = this->raft_and_intermediate_support_layers( object, bottom_contacts, top_contacts, layer_storage, max_object_layer_height); // Fill in intermediate layers between the top / bottom support contact layers, trimmed by the object. this->generate_base_layers(object, bottom_contacts, top_contacts, intermediate_layers); #ifdef SLIC3R_DEBUG for (MyLayersPtr::const_iterator it = intermediate_layers.begin(); it != intermediate_layers.end(); ++ it) { const MyLayer &layer = *(*it); ::Slic3r::SVG svg(debug_out_path("support-base-layers-%d-%lf.svg", iRun, layer.print_z), get_extents(layer.polygons)); Slic3r::ExPolygons expolys = union_ex(layer.polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ // If raft is to be generated, the 1st top_contact layer will contain the 1st object layer silhouette without holes. // Add the bottom contacts to the raft, inflate the support bases. // There is a contact layer below the 1st object layer in the bottom contacts. // There is also a 1st intermediate layer containing bases of support columns. // Extend the bases of the support columns and create the raft base. Polygons raft = this->generate_raft_base(object, bottom_contacts, intermediate_layers); /* // If we wanted to apply some special logic to the first support layers lying on // object's top surfaces this is the place to detect them LayersSet shape; if (m_objectconfig->support_material_pattern.value == smpPillars) shape = this->generate_pillars_shape(contact, support_z); */ // Propagate top / bottom contact layers to generate interface layers. MyLayersPtr interface_layers = this->generate_interface_layers( object, bottom_contacts, top_contacts, intermediate_layers, layer_storage); #ifdef SLIC3R_DEBUG for (MyLayersPtr::const_iterator it = interface_layers.begin(); it != interface_layers.end(); ++ it) { const MyLayer &layer = *(*it); ::Slic3r::SVG svg(debug_out_path("support-interface-layers-%d-%lf.svg", iRun, layer.print_z), get_extents(layer.polygons)); Slic3r::ExPolygons expolys = union_ex(layer.polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ /* // Clip with the pillars. if (! shape.empty()) { this->clip_with_shape(interface, shape); this->clip_with_shape(base, shape); } */ // Install support layers into the object. MyLayersPtr layers_sorted; layers_sorted.reserve(bottom_contacts.size() + top_contacts.size() + intermediate_layers.size() + interface_layers.size()); layers_append(layers_sorted, bottom_contacts); layers_append(layers_sorted, top_contacts); layers_append(layers_sorted, intermediate_layers); layers_append(layers_sorted, interface_layers); std::sort(layers_sorted.begin(), layers_sorted.end(), MyLayersPtrCompare()); int layer_id = 0; for (int i = 0; i < int(layers_sorted.size());) { // Find the last layer with the same print_z, find the minimum layer height of all. int j = i + 1; coordf_t height_min = layers_sorted[i]->height; for (; j < layers_sorted.size() && layers_sorted[i]->print_z == layers_sorted[j]->print_z; ++ j) height_min = std::min(height_min, layers_sorted[j]->height); object.add_support_layer(layer_id, height_min, layers_sorted[i]->print_z); if (layer_id > 0) { SupportLayer *sl1 = object.support_layers[object.support_layer_count()-2]; SupportLayer *sl2 = object.support_layers.back(); sl1->upper_layer = sl2; sl2->lower_layer = sl1; } i = j; ++ layer_id; } // Generate the actual toolpaths and save them into each layer. this->generate_toolpaths(object, raft, bottom_contacts, top_contacts, intermediate_layers, interface_layers); } void collect_region_slices_by_type(const Layer &layer, SurfaceType surface_type, Polygons &out) { // 1) Count the new polygons first. size_t n_polygons_new = 0; for (LayerRegionPtrs::const_iterator it_region = layer.regions.begin(); it_region != layer.regions.end(); ++ it_region) { const LayerRegion ®ion = *(*it_region); const SurfaceCollection &slices = region.slices; for (Surfaces::const_iterator it = slices.surfaces.begin(); it != slices.surfaces.end(); ++ it) { const Surface &surface = *it; if (surface.surface_type == surface_type) n_polygons_new += surface.expolygon.holes.size() + 1; } } // 2) Collect the new polygons. out.reserve(out.size() + n_polygons_new); for (LayerRegionPtrs::const_iterator it_region = layer.regions.begin(); it_region != layer.regions.end(); ++ it_region) { const LayerRegion ®ion = *(*it_region); const SurfaceCollection &slices = region.slices; for (Surfaces::const_iterator it = slices.surfaces.begin(); it != slices.surfaces.end(); ++ it) { const Surface &surface = *it; if (surface.surface_type == surface_type) polygons_append(out, surface.expolygon); } } } Polygons collect_region_slices_by_type(const Layer &layer, SurfaceType surface_type) { Polygons out; collect_region_slices_by_type(layer, surface_type, out); return out; } // Collect outer contours of all expolygons in all layer region slices. void collect_region_slices_outer(const Layer &layer, Polygons &out) { // 1) Count the new polygons first. size_t n_polygons_new = 0; for (LayerRegionPtrs::const_iterator it_region = layer.regions.begin(); it_region != layer.regions.end(); ++ it_region) { const LayerRegion ®ion = *(*it_region); n_polygons_new += region.slices.surfaces.size(); } // 2) Collect the new polygons. out.reserve(out.size() + n_polygons_new); for (LayerRegionPtrs::const_iterator it_region = layer.regions.begin(); it_region != layer.regions.end(); ++ it_region) { const LayerRegion ®ion = *(*it_region); for (Surfaces::const_iterator it = region.slices.surfaces.begin(); it != region.slices.surfaces.end(); ++ it) out.push_back(it->expolygon.contour); } } // Collect outer contours of all expolygons in all layer region slices. Polygons collect_region_slices_outer(const Layer &layer) { Polygons out; collect_region_slices_outer(layer, out); return out; } // Collect outer contours of all expolygons in all layer region slices. void collect_slices_outer(const Layer &layer, Polygons &out) { out.reserve(out.size() + layer.slices.expolygons.size()); for (ExPolygons::const_iterator it = layer.slices.expolygons.begin(); it != layer.slices.expolygons.end(); ++ it) out.push_back(it->contour); } // Collect outer contours of all expolygons in all layer region slices. Polygons collect_slices_outer(const Layer &layer) { Polygons out; collect_slices_outer(layer, out); return out; } // Find the top contact surfaces of the support or the raft. PrintObjectSupportMaterial::MyLayersPtr PrintObjectSupportMaterial::top_contact_layers(const PrintObject &object, MyLayerStorage &layer_storage) const { #ifdef SLIC3R_DEBUG static int iRun = 0; ++ iRun; #endif /* SLIC3R_DEBUG */ // Output layers, sorte by top Z. MyLayersPtr contact_out; // If user specified a custom angle threshold, convert it to radians. double threshold_rad = 0.; if (m_object_config->support_material_threshold.value > 0) { threshold_rad = M_PI * double(m_object_config->support_material_threshold.value + 1) / 180.; // +1 makes the threshold inclusive // Slic3r::debugf "Threshold angle = %d°\n", rad2deg($threshold_rad); } // Build support on a build plate only? If so, then collect top surfaces into $buildplate_only_top_surfaces // and subtract $buildplate_only_top_surfaces from the contact surfaces, so // there is no contact surface supported by a top surface. bool buildplate_only = m_object_config->support_material.value && m_object_config->support_material_buildplate_only.value; Polygons buildplate_only_top_surfaces; // Determine top contact areas. for (size_t layer_id = 0; layer_id < object.layer_count(); ++ layer_id) { // Note that layer_id < layer->id when raft_layers > 0 as the layer->id incorporates the raft layers. // So layer_id == 0 means first object layer and layer->id == 0 means first print layer if there are no explicit raft layers. if (this->has_raft()) { if (! this->has_support() && layer_id > 0) // If we are only going to generate raft. Just check for the 'overhangs' of the first object layer. break; // Check for the overhangs at any object layer including the 1st layer. } else if (layer_id == 0) { // No raft, 1st object layer cannot be supported by a support contact layer as it sticks directly to print bed. continue; } const Layer &layer = *object.get_layer(layer_id); if (buildplate_only) { // Collect the top surfaces up to this layer and merge them. Polygons projection_new = collect_region_slices_by_type(layer, stTop); if (! projection_new.empty()) { // Merge the new top surfaces with the preceding top surfaces. // Apply the safety offset to the newly added polygons, so they will connect // with the polygons collected before, // but don't apply the safety offset during the union operation as it would // inflate the polygons over and over. projection_new = offset(projection_new, scale_(0.01)); polygons_append(buildplate_only_top_surfaces, projection_new); buildplate_only_top_surfaces = union_(buildplate_only_top_surfaces, false); // don't apply the safety offset. } } // Detect overhangs and contact areas needed to support them. Polygons overhang_polygons; Polygons contact_polygons; if (layer_id == 0) { // This is the first object layer, so the object is being printed on a raft and // we're here just to get the object footprint for the raft. // We only consider contours and discard holes to get a more continuous raft. overhang_polygons = collect_slices_outer(layer); // Extend by SUPPORT_MATERIAL_MARGIN, which is 1.5mm contact_polygons = offset(overhang_polygons, scale_(SUPPORT_MATERIAL_MARGIN)); } else { // Generate overhang / contact_polygons for non-raft layers. const Layer &lower_layer = *object.get_layer(int(layer_id)-1); for (LayerRegionPtrs::const_iterator it_layerm = layer.regions.begin(); it_layerm != layer.regions.end(); ++ it_layerm) { const LayerRegion &layerm = *(*it_layerm); // Extrusion width accounts for the roundings of the extrudates. // It is the maximum widh of the extrudate. coord_t fw = layerm.flow(frExternalPerimeter).scaled_width(); coordf_t lower_layer_offset = (layer_id < m_object_config->support_material_enforce_layers.value) ? // Enforce a full possible support, ignore the overhang angle. 0 : (threshold_rad > 0. ? // Overhang defined by an angle. scale_(lower_layer.height * cos(threshold_rad) / sin(threshold_rad)) : // Overhang defined by half the extrusion width. 0.5 * fw); // Overhang polygons for this layer and region. Polygons diff_polygons; if (lower_layer_offset == 0.) { // Support everything. diff_polygons = diff( (Polygons)layerm.slices, (Polygons)lower_layer.slices); } else { // Get the regions needing a suport. diff_polygons = diff( (Polygons)layerm.slices, offset((Polygons)lower_layer.slices, lower_layer_offset)); // Collapse very tiny spots. diff_polygons = offset2(diff_polygons, -0.1*fw, +0.1*fw); if (diff_polygons.empty()) continue; // Offset the support regions back to a full overhang, restrict them to the full overhang. diff_polygons = diff(intersection(offset(diff_polygons, lower_layer_offset), (Polygons)layerm.slices), (Polygons)lower_layer.slices); } if (diff_polygons.empty()) continue; #ifdef SLIC3R_DEBUG { ::Slic3r::SVG svg(debug_out_path("support-top-contacts-raw-run%d-layer%d-region%d.svg", iRun, layer_id, it_layerm - layer.regions.begin()), get_extents(diff_polygons)); Slic3r::ExPolygons expolys = union_ex(diff_polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ if (m_object_config->dont_support_bridges) { // compute the area of bridging perimeters // Note: this is duplicate code from GCode.pm, we need to refactor Polygons bridged_perimeters; { Flow bridge_flow = layerm.flow(frPerimeter, true); coordf_t nozzle_diameter = m_print_config->nozzle_diameter.get_at( layerm.region()->config.perimeter_extruder-1); Polygons lower_grown_slices = offset((Polygons)lower_layer.slices, 0.5f*scale_(nozzle_diameter)); // TODO: split_at_first_point() could split a bridge mid-way Polylines overhang_perimeters; for (ExtrusionEntitiesPtr::const_iterator it_island = layerm.perimeters.entities.begin(); it_island != layerm.perimeters.entities.end(); ++ it_island) { const ExtrusionEntityCollection *island = dynamic_cast(*it_island); assert(island != NULL); for (size_t i = 0; i < island->entities.size(); ++ i) { ExtrusionEntity *entity = island->entities[i]; ExtrusionLoop *loop = dynamic_cast(entity); overhang_perimeters.push_back(loop ? loop->as_polyline() : dynamic_cast(entity)->polyline); } } // workaround for Clipper bug, see Slic3r::Polygon::clip_as_polyline() for (Polylines::iterator it = overhang_perimeters.begin(); it != overhang_perimeters.end(); ++ it) it->points[0].x += 1; diff(overhang_perimeters, lower_grown_slices, &overhang_perimeters); // only consider straight overhangs // only consider overhangs having endpoints inside layer's slices // convert bridging polylines into polygons by inflating them with their thickness // since we're dealing with bridges, we can't assume width is larger than spacing, // so we take the largest value and also apply safety offset to be ensure no gaps // are left in between coordf_t w = std::max(bridge_flow.scaled_width(), bridge_flow.scaled_spacing()); for (Polylines::iterator it = overhang_perimeters.begin(); it != overhang_perimeters.end(); ++ it) { if (it->is_straight()) { it->extend_start(fw); it->extend_end(fw); if (layer.slices.contains(it->first_point()) && layer.slices.contains(it->last_point())) { // Offset a polyline into a polygon. Polylines tmp; tmp.push_back(*it); Polygons out; offset(tmp, &out, 0.5f * w + 10.f); polygons_append(bridged_perimeters, out); } } } bridged_perimeters = union_(bridged_perimeters); } if (1) { // remove the entire bridges and only support the unsupported edges Polygons bridges; for (Surfaces::const_iterator it = layerm.fill_surfaces.surfaces.begin(); it != layerm.fill_surfaces.surfaces.end(); ++ it) if (it->surface_type == stBottomBridge && it->bridge_angle != -1) polygons_append(bridges, it->expolygon); polygons_append(bridged_perimeters, bridges); diff_polygons = diff(diff_polygons, bridged_perimeters, true); Polygons unsupported_bridge_polygons; for (Polylines::const_iterator it = layerm.unsupported_bridge_edges.polylines.begin(); it != layerm.unsupported_bridge_edges.polylines.end(); ++ it) { // Offset a polyline into a polygon. Polylines tmp; tmp.push_back(*it); Polygons out; offset(tmp, &out, scale_(SUPPORT_MATERIAL_MARGIN)); polygons_append(unsupported_bridge_polygons, out); } polygons_append(diff_polygons, intersection(unsupported_bridge_polygons, bridges)); } else { // just remove bridged areas diff_polygons = diff(diff_polygons, layerm.bridged, true); } } // if (m_objconfig->dont_support_bridges) if (buildplate_only) { // Don't support overhangs above the top surfaces. // This step is done before the contact surface is calculated by growing the overhang region. diff_polygons = diff(diff_polygons, buildplate_only_top_surfaces); } if (diff_polygons.empty()) continue; #ifdef SLIC3R_DEBUG { ::Slic3r::SVG svg(debug_out_path("support-top-contacts-filtered-run%d-layer%d-region%d.svg", iRun, layer_id, it_layerm - layer.regions.begin()), get_extents(diff_polygons)); Slic3r::ExPolygons expolys = union_ex(diff_polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ polygons_append(overhang_polygons, diff_polygons); // Let's define the required contact area by using a max gap of half the upper // extrusion width and extending the area according to the configured margin. // We increment the area in steps because we don't want our support to overflow // on the other side of the object (if it's very thin). { //FIMXE 1) Make the offset configurable, 2) Make the Z span configurable. Polygons slices_margin = offset((Polygons)lower_layer.slices, float(0.5*fw)); if (buildplate_only) { // Trim the inflated contact surfaces by the top surfaces as well. polygons_append(slices_margin, buildplate_only_top_surfaces); slices_margin = union_(slices_margin); } // Offset the contact polygons outside. for (size_t i = 0; i < NUM_MARGIN_STEPS; ++ i) { diff_polygons = diff( offset( diff_polygons, SUPPORT_MATERIAL_MARGIN / NUM_MARGIN_STEPS, CLIPPER_OFFSET_SCALE, ClipperLib::jtRound, // round mitter limit scale_(0.05) * CLIPPER_OFFSET_SCALE), slices_margin); } } polygons_append(contact_polygons, diff_polygons); } // for each layer.region } // end of Generate overhang/contact_polygons for non-raft layers. // now apply the contact areas to the layer were they need to be made if (! contact_polygons.empty()) { // get the average nozzle diameter used on this layer MyLayer &new_layer = layer_allocate(layer_storage, sltTopContact); new_layer.idx_object_layer_above = layer_id; if (m_soluble_interface) { // Align the contact surface height with a layer immediately below the supported layer. new_layer.height = (layer_id > 0) ? // Interface layer will be synchronized with the object. object.get_layer(layer_id - 1)->height : // Don't know the thickness of the raft layer yet. 0.; new_layer.print_z = layer.print_z - layer.height; new_layer.bottom_z = new_layer.print_z - new_layer.height; } else { // Contact layer will be printed with a normal flow, but // it will support layers printed with a bridging flow. //FIXME Probably printing with the bridge flow? How about the unsupported perimeters? Are they printed with the bridging flow? // In the future we may switch to a normal extrusion flow for the supported bridges. // Get the average nozzle diameter used on this layer. coordf_t nozzle_dmr = 0.; size_t n_nozzle_dmrs = 0; for (LayerRegionPtrs::const_iterator it_region_ptr = layer.regions.begin(); it_region_ptr != layer.regions.end(); ++ it_region_ptr) { const PrintRegion ®ion = *(*it_region_ptr)->region(); nozzle_dmr += m_print_config->nozzle_diameter.get_at(region.config.perimeter_extruder.value - 1); nozzle_dmr += m_print_config->nozzle_diameter.get_at(region.config.infill_extruder.value - 1); nozzle_dmr += m_print_config->nozzle_diameter.get_at(region.config.solid_infill_extruder.value - 1); n_nozzle_dmrs += 3; } nozzle_dmr /= coordf_t(n_nozzle_dmrs); new_layer.print_z = layer.print_z - nozzle_dmr - m_object_config->support_material_contact_distance; // Don't know the height of the top contact layer yet. The top contact layer is printed with a normal flow and // its height will be set adaptively later on. new_layer.height = 0.; new_layer.bottom_z = new_layer.print_z; } // Ignore this contact area if it's too low. // Don't want to print a layer below the first layer height as it may not stick well. //FIXME there may be a need for a single layer support, then one may decide to print it either as a bottom contact or a top contact // and it may actually make sense to do it with a thinner layer than the first layer height. if (new_layer.print_z < this->first_layer_height() + m_support_layer_height_min) continue; new_layer.polygons.swap(contact_polygons); // Store the overhang polygons as the aux_polygons. // The overhang polygons are used in the path generator for planning of the contact circles. new_layer.aux_polygons = new Polygons(); new_layer.aux_polygons->swap(overhang_polygons); contact_out.push_back(&new_layer); if (0) { // Slic3r::SVG::output("out\\contact_" . $contact_z . ".svg", // green_expolygons => union_ex($buildplate_only_top_surfaces), // blue_expolygons => union_ex(\@contact), // red_expolygons => union_ex(\@overhang), // ); } } } return contact_out; } PrintObjectSupportMaterial::MyLayersPtr PrintObjectSupportMaterial::bottom_contact_layers( const PrintObject &object, const MyLayersPtr &top_contacts, MyLayerStorage &layer_storage) const { // find object top surfaces // we'll use them to clip our support and detect where does it stick MyLayersPtr bottom_contacts; if (! m_object_config->support_material_buildplate_only.value && ! top_contacts.empty()) { // Sum of unsupported contact areas above the current layer.print_z. Polygons projection; // Last top contact layer visited when collecting the projection of contact areas. int contact_idx = int(top_contacts.size()) - 1; for (int layer_id = int(object.total_layer_count()) - 2; layer_id >= 0; -- layer_id) { const Layer &layer = *object.get_layer(layer_id); Polygons top = collect_region_slices_by_type(layer, stTop); if (top.empty()) continue; // Collect projections of all contact areas above or at the same level as this top surface. for (; contact_idx >= 0 && top_contacts[contact_idx]->print_z >= layer.print_z; -- contact_idx) polygons_append(projection, top_contacts[contact_idx]->polygons); // Now find whether any projection of the contact surfaces above layer.print_z not yet supported by any // top surfaces above layer.print_z falls onto this top surface. // touching are the contact surfaces supported exclusively by this top surfaaces. Polygons touching = intersection(projection, top); if (touching.empty()) continue; // Allocate a new bottom contact layer. MyLayer &layer_new = layer_allocate(layer_storage, sltBottomContact); bottom_contacts.push_back(&layer_new); // Grow top surfaces so that interface and support generation are generated // with some spacing from object - it looks we don't need the actual // top shapes so this can be done here layer_new.height = m_soluble_interface ? // Align the interface layer with the object's layer height. object.get_layer(layer_id + 1)->height : // Place a bridge flow interface layer over the top surface. m_support_material_interface_flow.nozzle_diameter; layer_new.print_z = layer.print_z + layer_new.height + (m_soluble_interface ? 0. : m_object_config->support_material_contact_distance.value); layer_new.bottom_z = layer.print_z; layer_new.idx_object_layer_below = layer_id; layer_new.bridging = ! m_soluble_interface; //FIXME how much to inflate the top surface? Polygons poly_new = offset(touching, float(m_support_material_flow.scaled_width())); layer_new.polygons.swap(poly_new); // Remove the areas that touched from the projection that will continue on next, lower, top surfaces. projection = diff(projection, touching); } } return bottom_contacts; } // Trim the top_contacts layers with the bottom_contacts layers if they overlap, so there would not be enough vertical space for both of them. void PrintObjectSupportMaterial::trim_top_contacts_by_bottom_contacts( const PrintObject &object, const MyLayersPtr &bottom_contacts, MyLayersPtr &top_contacts) const { size_t idx_top_first = 0; // For all bottom contact layers: for (size_t idx_bottom = 0; idx_bottom < bottom_contacts.size() && idx_top_first < top_contacts.size(); ++ idx_bottom) { const MyLayer &layer_bottom = *bottom_contacts[idx_bottom]; // Find the first top layer overlapping with layer_bottom. while (idx_top_first < top_contacts.size() && top_contacts[idx_top_first]->print_z <= layer_bottom.print_z - layer_bottom.height) ++ idx_top_first; // For all top contact layers overlapping with the thick bottom contact layer: for (size_t idx_top = idx_top_first; idx_top < top_contacts.size(); ++ idx_top) { MyLayer &layer_top = *top_contacts[idx_top]; coordf_t interface_z = m_soluble_interface ? (layer_top.bottom_z + EPSILON) : (layer_top.bottom_z - m_support_layer_height_min); if (interface_z < layer_bottom.print_z) { // Layers overlap. Trim layer_top with layer_bottom. layer_top.polygons = diff(layer_top.polygons, layer_bottom.polygons); } else break; } } } PrintObjectSupportMaterial::MyLayersPtr PrintObjectSupportMaterial::raft_and_intermediate_support_layers( const PrintObject &object, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, MyLayerStorage &layer_storage, const coordf_t max_object_layer_height) const { MyLayersPtr intermediate_layers; // Collect and sort the extremes (bottoms of the top contacts and tops of the bottom contacts). std::vector extremes; extremes.reserve(top_contacts.size() + bottom_contacts.size()); for (size_t i = 0; i < top_contacts.size(); ++ i) // Bottoms of the top contact layers. In case of non-soluble supports, // the top contact layer thickness is not known yet. extremes.push_back(LayerExtreme(top_contacts[i], false)); for (size_t i = 0; i < bottom_contacts.size(); ++ i) // Tops of the bottom contact layers. extremes.push_back(LayerExtreme(bottom_contacts[i], true)); if (extremes.empty()) return intermediate_layers; std::sort(extremes.begin(), extremes.end()); // Top of the 0th layer. coordf_t top_z_0th = this->raft_base_height() + this->raft_interface_height(); assert(extremes.front().z() > top_z_0th && extremes.front().z() >= this->first_layer_height()); // Generate intermediate layers. // The first intermediate layer is the same as the 1st layer if there is no raft, // or the bottom of the first intermediate layer is aligned with the bottom of the raft contact layer. // Intermediate layers are always printed with a normal etrusion flow (non-bridging). for (size_t idx_extreme = 0; idx_extreme < extremes.size(); ++ idx_extreme) { LayerExtreme *extr1 = (idx_extreme == 0) ? NULL : &extremes[idx_extreme-1]; coordf_t extr1z = (extr1 == NULL) ? top_z_0th : extr1->z(); LayerExtreme &extr2 = extremes[idx_extreme]; coordf_t extr2z = extr2.z(); coordf_t dist = extr2z - extr1z; assert(dist > 0.); // Insert intermediate layers. size_t n_layers_extra = size_t(ceil(dist / m_support_layer_height_max)); coordf_t step = dist / coordf_t(n_layers_extra); if (! m_soluble_interface && extr2.layer->layer_type == sltTopContact) { assert(extr2.layer->height == 0.); // This is a top interface layer, which does not have a height assigned yet. Do it now. if (m_synchronize_support_layers_with_object) { //FIXME // Find the } extr2.layer->height = step; extr2.layer->bottom_z = extr2.layer->print_z - step; -- n_layers_extra; if (extr2.layer->bottom_z < this->first_layer_height()) { // Split the span into two layers: the top layer up to the first layer height, // and the new intermediate layer below. // 1) Adjust the bottom of this top layer. assert(n_layers_extra == 0); extr2.layer->bottom_z = extr2z = this->first_layer_height(); extr2.layer->height = extr2.layer->print_z - extr2.layer->bottom_z; // 2) Insert a new intermediate layer. MyLayer &layer_new = layer_allocate(layer_storage, stlIntermediate); layer_new.bottom_z = extr1z; layer_new.print_z = this->first_layer_height(); layer_new.height = layer_new.print_z - layer_new.bottom_z; intermediate_layers.push_back(&layer_new); continue; } } if (n_layers_extra > 0 && extr1z + step < this->first_layer_height()) { MyLayer &layer_new = layer_allocate(layer_storage, stlIntermediate); layer_new.bottom_z = extr1z; layer_new.print_z = extr1z = this->first_layer_height(); layer_new.height = layer_new.print_z - layer_new.bottom_z; intermediate_layers.push_back(&layer_new); dist = extr2z - extr1z; assert(dist >= 0.); n_layers_extra = size_t(ceil(dist / m_support_layer_height_max)); coordf_t step = dist / coordf_t(n_layers_extra); } for (size_t i = 0; i < n_layers_extra; ++ i) { MyLayer &layer_new = layer_allocate(layer_storage, stlIntermediate); layer_new.height = step; layer_new.bottom_z = (i + 1 == n_layers_extra) ? extr2z : extr1z + i * step; layer_new.print_z = layer_new.bottom_z + step; intermediate_layers.push_back(&layer_new); } } return intermediate_layers; } // At this stage there shall be intermediate_layers allocated between bottom_contacts and top_contacts, but they have no polygons assigned. // Also the bottom/top_contacts shall have a thickness assigned already. void PrintObjectSupportMaterial::generate_base_layers( const PrintObject &object, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, MyLayersPtr &intermediate_layers) const { if (top_contacts.empty()) // No top contacts -> no intermediate layers will be produced. return; // coordf_t fillet_radius_scaled = scale_(m_object_config->support_material_spacing); //FIXME make configurable: coordf_t overlap_extra_above = 0.01; coordf_t overlap_extra_below = 0.01; int idx_top_contact_above = int(top_contacts.size()) - 1; int idx_top_contact_overlapping = int(top_contacts.size()) - 1; int idx_bottom_contact_overlapping = int(bottom_contacts.size()) - 1; for (int idx_intermediate = int(intermediate_layers.size()) - 1; idx_intermediate >= 0; -- idx_intermediate) { MyLayer &layer_intermediate = *intermediate_layers[idx_intermediate]; // New polygons for layer_intermediate. Polygons polygons_new; // Find a top_contact layer touching the layer_intermediate from above, if any, and collect its polygons into polygons_new. while (idx_top_contact_above >= 0 && top_contacts[idx_top_contact_above]->bottom_z > layer_intermediate.print_z + EPSILON) -- idx_top_contact_above; if (idx_top_contact_above >= 0 && top_contacts[idx_top_contact_above]->print_z > layer_intermediate.print_z) polygons_append(polygons_new, top_contacts[idx_top_contact_above]->polygons); // Add polygons from the intermediate layer above. if (idx_intermediate + 1 < int(intermediate_layers.size())) polygons_append(polygons_new, intermediate_layers[idx_intermediate+1]->polygons); // Polygons to trim polygons_new. Polygons polygons_trimming; // Find the first top_contact layer intersecting with this layer. while (idx_top_contact_overlapping >= 0 && top_contacts[idx_top_contact_overlapping]->bottom_z > layer_intermediate.print_z + overlap_extra_above - EPSILON) -- idx_top_contact_overlapping; // Collect all the top_contact layer intersecting with this layer. for (int i = idx_top_contact_overlapping; i >= 0; -- i) { MyLayer &layer_top_overlapping = *top_contacts[i]; if (layer_top_overlapping.print_z < layer_intermediate.bottom_z - overlap_extra_below) break; polygons_append(polygons_trimming, layer_top_overlapping.polygons); } // Find the first bottom_contact layer intersecting with this layer. while (idx_bottom_contact_overlapping >= 0 && bottom_contacts[idx_bottom_contact_overlapping]->bottom_z > layer_intermediate.print_z + overlap_extra_above - EPSILON) -- idx_bottom_contact_overlapping; // Collect all the top_contact layer intersecting with this layer. for (int i = idx_bottom_contact_overlapping; i >= 0; -- i) { MyLayer &layer_bottom_overlapping = *bottom_contacts[idx_bottom_contact_overlapping]; if (layer_bottom_overlapping.print_z < layer_intermediate.print_z - layer_intermediate.height - overlap_extra_below) break; polygons_append(polygons_trimming, layer_bottom_overlapping.polygons); } // Trim the polygons, store them. if (polygons_trimming.empty()) layer_intermediate.polygons.swap(polygons_new); else layer_intermediate.polygons = diff( polygons_new, polygons_trimming, true); // safety offset to merge the touching source polygons /* if (0) { // Fillet the base polygons and trim them again with the top, interface and contact layers. $base->{$i} = diff( offset2( $base->{$i}, $fillet_radius_scaled, -$fillet_radius_scaled, # Use a geometric offsetting for filleting. CLIPPER_OFFSET_SCALE, JT_ROUND, 0.2*$fillet_radius_scaled*CLIPPER_OFFSET_SCALE), $trim_polygons, false); // don't apply the safety offset. } */ } #ifdef SLIC3R_DEBUG static int iRun = 0; iRun ++; for (MyLayersPtr::const_iterator it = top_contacts.begin(); it != top_contacts.end(); ++ it) { const MyLayer &layer = *(*it); ::Slic3r::SVG svg(debug_out_path("support-intermediate-layers-untrimmed-%d-%lf.svg", iRun, layer.print_z), get_extents(layer.polygons)); Slic3r::ExPolygons expolys = union_ex(layer.polygons, false); svg.draw(expolys); } #endif /* SLIC3R_DEBUG */ //FIXME This could be parallelized. const coordf_t gap_extra_above = 0.1f; const coordf_t gap_extra_below = 0.1f; const coord_t gap_xy_scaled = m_support_material_flow.scaled_width(); size_t idx_object_layer_overlapping = 0; // For all intermediate layers: for (MyLayersPtr::iterator it_layer = intermediate_layers.begin(); it_layer != intermediate_layers.end(); ++ it_layer) { MyLayer &layer_intermediate = *(*it_layer); if (layer_intermediate.polygons.empty()) continue; // Find the overlapping object layers including the extra above / below gap. while (idx_object_layer_overlapping < object.layer_count() && object.get_layer(idx_object_layer_overlapping)->print_z < layer_intermediate.print_z - layer_intermediate.height - gap_extra_below + EPSILON) ++ idx_object_layer_overlapping; // Collect all the object layers intersecting with this layer. Polygons polygons_trimming; for (int i = idx_object_layer_overlapping; i < object.layer_count(); ++ i) { const Layer &object_layer = *object.get_layer(i); if (object_layer.print_z > layer_intermediate.print_z + gap_extra_above - EPSILON) break; polygons_append(polygons_trimming, (Polygons)object_layer.slices); } // $layer->slices contains the full shape of layer, thus including // perimeter's width. $support contains the full shape of support // material, thus including the width of its foremost extrusion. // We leave a gap equal to a full extrusion width. layer_intermediate.polygons = diff( layer_intermediate.polygons, offset(polygons_trimming, gap_xy_scaled)); } } Polygons PrintObjectSupportMaterial::generate_raft_base( const PrintObject &object, const MyLayersPtr &bottom_contacts, MyLayersPtr &intermediate_layers) const { assert(! bottom_contacts.empty()); Polygons raft_polygons; #if 0 const float inflate_factor = scale_(3.); if (this->has_raft()) { MyLayer &contacts = *bottom_contacts.front(); MyLayer &columns_base = *intermediate_layers.front(); if (m_num_base_raft_layers == 0 && m_num_interface_raft_layers == 0 && m_num_contact_raft_layers == 1) { // Having only the contact layer, which has the height of the 1st layer. // We are free to merge the contacts with the columns_base, they will be printed the same way. polygons_append(contacts.polygons, offset(columns_base.polygons, inflate_factor)); contacts.polygons = union_(contacts.polygons); } else { // Having multiple raft layers. assert(m_num_interface_raft_layers > 0); // Extend the raft base by the bases of the support columns, add the raft contacts. raft_polygons = raft_interface_polygons; //FIXME make the offset configurable. polygons_append(raft_polygons, offset(columns_base.polygons, inflate_factor)); raft_polygons = union_(raft_polygons); } } else { // No raft. The 1st intermediate layer contains the bases of the support columns. // Expand the polygons, but trim with the object. MyLayer &columns_base = *intermediate_layers.front(); columns_base.polygons = diff( offset(columns_base.polygons, inflate_factor), offset(m_object->get_layer(0), safety_factor); } #endif return raft_polygons; } // Convert some of the intermediate layers into top/bottom interface layers. PrintObjectSupportMaterial::MyLayersPtr PrintObjectSupportMaterial::generate_interface_layers( const PrintObject &object, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, MyLayersPtr &intermediate_layers, MyLayerStorage &layer_storage) const { // Old comment: // Compute interface area on this layer as diff of upper contact area // (or upper interface area) and layer slices. // This diff is responsible of the contact between support material and // the top surfaces of the object. We should probably offset the top // surfaces vertically before performing the diff, but this needs // investigation. // my $area_threshold = $self->interface_flow->scaled_spacing ** 2; MyLayersPtr interface_layers; // Contact layer is considered an interface layer, therefore run the following block only if support_material_interface_layers > 1. if (! intermediate_layers.empty() && m_object_config->support_material_interface_layers > 1) { // Index of the first top contact layer intersecting the current intermediate layer. size_t idx_top_contact_first = 0; // Index of the first bottom contact layer intersecting the current intermediate layer. size_t idx_bottom_contact_first = 0; // For all intermediate layers, collect top contact surfaces, which are not further than support_material_interface_layers. //FIXME this could be parallelized. for (size_t idx_intermediate_layer = 0; idx_intermediate_layer < intermediate_layers.size(); ++ idx_intermediate_layer) { MyLayer &intermediate_layer = *intermediate_layers[idx_intermediate_layer]; // Top / bottom Z coordinate of a slab, over which we are collecting the top / bottom contact surfaces. coordf_t top_z = intermediate_layers[std::min(intermediate_layers.size()-1, idx_intermediate_layer + m_object_config->support_material_interface_layers - 1)]->print_z; coordf_t bottom_z = intermediate_layers[std::max(0, int(idx_intermediate_layer) - int(m_object_config->support_material_interface_layers) + 1)]->bottom_z; // Move idx_top_contact_first up until above the current print_z. while (idx_top_contact_first < top_contacts.size() && top_contacts[idx_top_contact_first]->print_z < intermediate_layer.print_z) ++ idx_top_contact_first; // Collect the top contact areas above this intermediate layer, below top_z. Polygons polygons_top_contact_projected; for (size_t idx_top_contact = idx_top_contact_first; idx_top_contact < top_contacts.size(); ++ idx_top_contact) { const MyLayer &top_contact_layer = *top_contacts[idx_top_contact]; if (top_contact_layer.bottom_z - EPSILON > top_z) break; polygons_append(polygons_top_contact_projected, top_contact_layer.polygons); } // Move idx_bottom_contact_first up until touching bottom_z. while (idx_bottom_contact_first < bottom_contacts.size() && bottom_contacts[idx_bottom_contact_first]->print_z + EPSILON < bottom_z) ++ idx_bottom_contact_first; // Collect the top contact areas above this intermediate layer, below top_z. Polygons polygons_bottom_contact_projected; for (size_t idx_bottom_contact = idx_bottom_contact_first; idx_bottom_contact < bottom_contacts.size(); ++ idx_bottom_contact) { const MyLayer &bottom_contact_layer = *bottom_contacts[idx_bottom_contact]; if (bottom_contact_layer.print_z - EPSILON > intermediate_layer.bottom_z) break; polygons_append(polygons_bottom_contact_projected, bottom_contact_layer.polygons); } if (polygons_top_contact_projected.empty() && polygons_bottom_contact_projected.empty()) continue; // Insert a new layer into top_interface_layers. MyLayer &layer_new = layer_allocate(layer_storage, polygons_top_contact_projected.empty() ? sltBottomInterface : sltTopInterface); layer_new.print_z = intermediate_layer.print_z; layer_new.bottom_z = intermediate_layer.bottom_z; layer_new.height = intermediate_layer.height; layer_new.bridging = intermediate_layer.bridging; interface_layers.push_back(&layer_new); polygons_append(polygons_top_contact_projected, polygons_bottom_contact_projected); polygons_top_contact_projected = union_(polygons_top_contact_projected, true); layer_new.polygons = intersection(intermediate_layer.polygons, polygons_top_contact_projected); //FIXME filter layer_new.polygons islands by a minimum area? // $interface_area = [ grep abs($_->area) >= $area_threshold, @$interface_area ]; intermediate_layer.polygons = diff(intermediate_layer.polygons, polygons_top_contact_projected, false); } } return interface_layers; } void PrintObjectSupportMaterial::generate_toolpaths( const PrintObject &object, const Polygons &raft, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, const MyLayersPtr &intermediate_layers, const MyLayersPtr &interface_layers) const { // Shape of the top contact area. int n_contact_loops = 1; coordf_t circle_radius = 1.5 * m_support_material_interface_flow.scaled_width(); coordf_t circle_distance = 3. * circle_radius; Polygon circle; circle.points.reserve(6); for (size_t i = 0; i < 6; ++ i) { double angle = double(i) * M_PI / 3.; circle.points.push_back(Point(circle_radius * cos(angle), circle_radius * sin(angle))); } // Slic3r::debugf "Generating patterns\n"; // Prepare fillers. SupportMaterialPattern support_pattern = m_object_config->support_material_pattern; bool with_sheath = m_object_config->support_material_with_sheath; InfillPattern infill_pattern; std::vector angles; angles.push_back(m_object_config->support_material_angle); switch (support_pattern) { case smpRectilinearGrid: angles.push_back(angles[0] + 90.); // fall through case smpRectilinear: infill_pattern = ipRectilinear; break; case smpHoneycomb: case smpPillars: infill_pattern = ipHoneycomb; break; } #if SLIC3R_CPPVER >= 11 std::unique_ptr filler_interface = std::unique_ptr(Fill::new_from_type(ipRectilinear)); std::unique_ptr filler_support = std::unique_ptr(Fill::new_from_type(infill_pattern)); #else std::auto_ptr filler_interface = std::auto_ptr(Fill::new_from_type(ipRectilinear)); std::auto_ptr filler_support = std::auto_ptr(Fill::new_from_type(infill_pattern)); #endif { BoundingBox bbox_object = object.bounding_box(); filler_interface->set_bounding_box(bbox_object); filler_support->set_bounding_box(bbox_object); } coordf_t interface_angle = m_object_config->support_material_angle + 90.; coordf_t interface_spacing = m_object_config->support_material_interface_spacing.value + m_support_material_interface_flow.spacing(); coordf_t interface_density = (interface_spacing == 0.) ? 1. : (m_support_material_interface_flow.spacing() / interface_spacing); coordf_t support_spacing = m_object_config->support_material_spacing.value + m_support_material_flow.spacing(); coordf_t support_density = (support_spacing == 0.) ? 1. : (m_support_material_flow.spacing() / support_spacing); //FIXME Parallelize the support generator: /* Slic3r::parallelize( threads => $self->print_config->threads, items => [ 0 .. n_$object.support_layers} ], thread_cb => sub { my $q = shift; while (defined (my $layer_id = $q->dequeue)) { $process_layer->($layer_id); } }, no_threads_cb => sub { $process_layer->($_) for 0 .. n_{$object.support_layers}; }, ); */ // Indices of the 1st layer in their respective container at the support layer height. size_t idx_layer_bottom_contact = 0; size_t idx_layer_top_contact = 0; size_t idx_layer_intermediate = 0; size_t idx_layer_inteface = 0; for (size_t support_layer_id = 0; support_layer_id < object.support_layers.size(); ++ support_layer_id) { SupportLayer &support_layer = *object.support_layers[support_layer_id]; // Find polygons with the same print_z. Polygons bottom_contact_polygons; Polygons top_contact_polygons; Polygons base_polygons; Polygons interface_polygons; // Increment the layer indices to find a layer at support_layer.print_z. for (; idx_layer_bottom_contact < bottom_contacts .size() && bottom_contacts [idx_layer_bottom_contact]->print_z < support_layer.print_z - EPSILON; ++ idx_layer_bottom_contact) ; for (; idx_layer_top_contact < top_contacts .size() && top_contacts [idx_layer_top_contact ]->print_z < support_layer.print_z - EPSILON; ++ idx_layer_top_contact ) ; for (; idx_layer_intermediate < intermediate_layers.size() && intermediate_layers[idx_layer_intermediate ]->print_z < support_layer.print_z - EPSILON; ++ idx_layer_intermediate ) ; for (; idx_layer_inteface < interface_layers .size() && interface_layers [idx_layer_inteface ]->print_z < support_layer.print_z - EPSILON; ++ idx_layer_inteface ) ; // Copy polygons from the layers. if (idx_layer_bottom_contact < bottom_contacts.size() && bottom_contacts[idx_layer_bottom_contact]->print_z < support_layer.print_z + EPSILON) bottom_contact_polygons = bottom_contacts[idx_layer_bottom_contact]->polygons; if (idx_layer_top_contact < top_contacts.size() && top_contacts[idx_layer_top_contact]->print_z < support_layer.print_z + EPSILON) top_contact_polygons = top_contacts[idx_layer_top_contact]->polygons; if (idx_layer_inteface < interface_layers.size() && interface_layers[idx_layer_inteface]->print_z < support_layer.print_z + EPSILON) interface_polygons = interface_layers[idx_layer_inteface]->polygons; if (idx_layer_intermediate < intermediate_layers.size() && intermediate_layers[idx_layer_intermediate]->print_z < support_layer.print_z + EPSILON) base_polygons = intermediate_layers[idx_layer_intermediate]->polygons; // We redefine flows locally by applying this layer's height. Flow flow = m_support_material_flow; Flow interface_flow = m_support_material_interface_flow; flow.height = support_layer.height; interface_flow.height = support_layer.height; /* if (1) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("out\\layer_" . $z . ".svg", blue_expolygons => union_ex($base), red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), ); } */ // Store inslands, over which the retract will be disabled. { Polygons polys(bottom_contact_polygons); polygons_append(polys, interface_polygons); polygons_append(polys, base_polygons); polygons_append(polys, top_contact_polygons); ExPolygons islands = union_ex(polys); support_layer.support_islands.expolygons.insert(support_layer.support_islands.expolygons.end(), islands.begin(), islands.end()); } Polygons contact_infill_polygons; if (! top_contact_polygons.empty()) { // Having a top interface layer. if (m_object_config->support_material_interface_layers == 0) // If no interface layers were requested, we treat the contact layer exactly as a generic base layer. polygons_append(base_polygons, top_contact_polygons); else if (n_contact_loops == 0) // If no loops are allowed, we treat the contact layer exactly as a generic interface layer. polygons_append(interface_polygons, top_contact_polygons); else if (! top_contact_polygons.empty()) { // Create loop paths and Polygons overhang_polygons = (top_contacts[idx_layer_top_contact]->aux_polygons == NULL) ? Polygons() : *top_contacts[idx_layer_top_contact]->aux_polygons; // Generate the outermost loop. // Find centerline of the external loop (or any other kind of extrusions should the loop be skipped) top_contact_polygons = offset(top_contact_polygons, - 0.5 * interface_flow.scaled_width()); Polygons loops0; { // find centerline of the external loop of the contours // only consider the loops facing the overhang Polygons external_loops; // Positions of the loop centers. Polygons circles; { Polygons overhang_with_margin = offset(overhang_polygons, 0.5 * interface_flow.scaled_width()); for (Polygons::const_iterator it_contact = top_contact_polygons.begin(); it_contact != top_contact_polygons.end(); ++ it_contact) { Polylines tmp; tmp.push_back(it_contact->split_at_first_point()); if (! intersection(tmp, overhang_with_margin).empty()) { external_loops.push_back(*it_contact); Points positions_new = it_contact->equally_spaced_points(circle_distance); for (Points::const_iterator it_center = positions_new.begin(); it_center != positions_new.end(); ++ it_center) { circles.push_back(circle); Polygon &circle_new = circles.back(); for (size_t i = 0; i < circle_new.points.size(); ++ i) circle_new.points[i].translate(*it_center); } } } } // Apply a pattern to the loop. loops0 = diff(external_loops, circles); } Polylines loop_lines; { // make more loops Polygons loop_polygons = loops0; for (size_t i = 1; i < n_contact_loops; ++ i) polygons_append(loop_polygons, offset2( loops0, - int(i) * interface_flow.scaled_spacing() - 0.5 * interface_flow.scaled_spacing(), 0.5 * interface_flow.scaled_spacing())); // clip such loops to the side oriented towards the object loop_lines.reserve(loop_polygons.size()); for (Polygons::const_iterator it = loop_polygons.begin(); it != loop_polygons.end(); ++ it) loop_lines.push_back(it->split_at_first_point()); loop_lines = intersection(loop_lines, offset(overhang_polygons, scale_(SUPPORT_MATERIAL_MARGIN))); } // add the contact infill area to the interface area // note that growing loops by $circle_radius ensures no tiny // extrusions are left inside the circles; however it creates // a very large gap between loops and contact_infill_polygons, so maybe another // solution should be found to achieve both goals { Polygons loop_polygons; offset(loop_lines, &loop_polygons, circle_radius * 1.1); contact_infill_polygons = diff(top_contact_polygons, loop_polygons); } // Transform loops into ExtrusionPath objects. for (Polylines::const_iterator it_polyline = loop_lines.begin(); it_polyline != loop_lines.end(); ++ it_polyline) { ExtrusionPath *extrusion_path = new ExtrusionPath(erSupportMaterialInterface); support_layer.support_interface_fills.entities.push_back(extrusion_path); extrusion_path->polyline = *it_polyline; extrusion_path->mm3_per_mm = interface_flow.mm3_per_mm(); extrusion_path->width = interface_flow.width; extrusion_path->height = support_layer.height; } } } // interface and contact infill if (! interface_polygons.empty() || ! contact_infill_polygons.empty()) { //FIXME When paralellizing, each thread shall have its own copy of the fillers. filler_interface->angle = interface_angle; filler_interface->spacing = interface_flow.spacing(); // find centerline of the external loop interface_polygons = offset2(interface_polygons, SCALED_EPSILON, - SCALED_EPSILON - 0.5 * interface_flow.scaled_width()); // join regions by offsetting them to ensure they're merged polygons_append(interface_polygons, contact_infill_polygons); interface_polygons = offset(interface_polygons, SCALED_EPSILON); // turn base support into interface when it's contained in our holes // (this way we get wider interface anchoring) { Polygons interface_polygons_new; interface_polygons_new.reserve(interface_polygons.size()); for (Polygons::iterator it_polygon = interface_polygons.begin(); it_polygon != interface_polygons.end(); ++ it_polygon) { if (it_polygon->is_clockwise()) { Polygons hole; hole.push_back(*it_polygon); hole.back().make_counter_clockwise(); if (diff(hole, base_polygons, true).empty()) continue; } interface_polygons_new.push_back(Polygon()); interface_polygons_new.back().points.swap(it_polygon->points); } interface_polygons.swap(interface_polygons_new); } base_polygons = diff(base_polygons, interface_polygons); ExPolygons to_fill = union_ex(interface_polygons); for (ExPolygons::const_iterator it_expolygon = to_fill.begin(); it_expolygon != to_fill.end(); ++ it_expolygon) { Surface surface(stInternal, *it_expolygon); FillParams fill_params; fill_params.density = interface_density; fill_params.complete = true; Polylines polylines = filler_interface->fill_surface(&surface, fill_params); for (Polylines::const_iterator it_polyline = polylines.begin(); it_polyline != polylines.end(); ++ it_polyline) { ExtrusionPath *extrusion_path = new ExtrusionPath(erSupportMaterialInterface); support_layer.support_interface_fills.entities.push_back(extrusion_path); extrusion_path->polyline = *it_polyline; extrusion_path->mm3_per_mm = interface_flow.mm3_per_mm(); extrusion_path->width = interface_flow.width; extrusion_path->height = support_layer.height; } } } // support or flange if (! base_polygons.empty()) { //FIXME When paralellizing, each thread shall have its own copy of the fillers. Fill *filler = filler_support.get(); filler->angle = angles[support_layer_id % angles.size()]; // We don't use $base_flow->spacing because we need a constant spacing // value that guarantees that all layers are correctly aligned. filler->spacing = flow.spacing(); coordf_t density = support_density; Flow base_flow = flow; // find centerline of the external loop/extrusions ExPolygons to_infill = offset2_ex(base_polygons, SCALED_EPSILON, - SCALED_EPSILON - 0.5*flow.scaled_width()); /* if (1) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("out\\to_infill_base" . $z . ".svg", red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), blue_expolygons => $to_infill, ); } */ if (support_layer_id == 0) { // Base flange. filler = filler_interface.get(); filler->angle = m_object_config->support_material_angle + 90.; density = 0.5; base_flow = m_first_layer_flow; // use the proper spacing for first layer as we don't need to align // its pattern to the other layers //FIXME When paralellizing, each thread shall have its own copy of the fillers. filler->spacing = base_flow.spacing(); } else if (with_sheath) { // Draw a perimeter all around the support infill. This makes the support stable, but difficult to remove. // TODO: use brim ordering algorithm Polygons to_infill_polygons = to_polygons(to_infill); for (Polygons::const_iterator it_polyline = to_infill_polygons.begin(); it_polyline != to_infill_polygons.end(); ++ it_polyline) { ExtrusionPath *extrusion_path = new ExtrusionPath(erSupportMaterial); support_layer.support_fills.entities.push_back(extrusion_path); extrusion_path->polyline = *it_polyline; extrusion_path->mm3_per_mm = flow.mm3_per_mm(); extrusion_path->width = flow.width; extrusion_path->height = support_layer.height; } // TODO: use offset2_ex() to_infill = offset_ex(to_infill_polygons, - flow.scaled_spacing()); } for (ExPolygons::const_iterator it_expolygon = to_infill.begin(); it_expolygon != to_infill.end(); ++ it_expolygon) { Surface surface(stInternal, *it_expolygon); FillParams fill_params; fill_params.density = density; fill_params.complete = true; Polylines polylines = filler->fill_surface(&surface, fill_params); for (Polylines::const_iterator it_polyline = polylines.begin(); it_polyline != polylines.end(); ++ it_polyline) { ExtrusionPath *extrusion_path = new ExtrusionPath(erSupportMaterial); support_layer.support_fills.entities.push_back(extrusion_path); extrusion_path->polyline = *it_polyline; extrusion_path->mm3_per_mm = base_flow.mm3_per_mm(); extrusion_path->width = base_flow.width; extrusion_path->height = support_layer.height; } } } // support or flange if (! bottom_contact_polygons.empty()) { //FIXME When paralellizing, each thread shall have its own copy of the fillers. Fill *filler = filler_support.get(); filler->angle = angles[support_layer_id % angles.size()]; // We don't use $base_flow->spacing because we need a constant spacing // value that guarantees that all layers are correctly aligned. filler->spacing = flow.spacing(); coordf_t density = support_density; Flow base_flow = flow; // find centerline of the external loop/extrusions ExPolygons to_infill = offset2_ex(base_polygons, SCALED_EPSILON, - SCALED_EPSILON - 0.5*flow.scaled_width()); /* if (1) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("out\\to_infill_base" . $z . ".svg", red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), blue_expolygons => $to_infill, ); } */ if (support_layer_id == 0) { // Base flange. filler = filler_interface.get(); filler->angle = m_object_config->support_material_angle + 90.; density = 0.5; base_flow = m_first_layer_flow; // use the proper spacing for first layer as we don't need to align // its pattern to the other layers //FIXME When paralellizing, each thread shall have its own copy of the fillers. filler->spacing = base_flow.spacing(); } else if (with_sheath) { // Draw a perimeter all around the support infill. This makes the support stable, but difficult to remove. // TODO: use brim ordering algorithm Polygons to_infill_polygons = to_polygons(to_infill); for (Polygons::const_iterator it_polyline = to_infill_polygons.begin(); it_polyline != to_infill_polygons.end(); ++ it_polyline) { ExtrusionPath *extrusion_path = new ExtrusionPath(erSupportMaterial); support_layer.support_fills.entities.push_back(extrusion_path); extrusion_path->polyline = *it_polyline; extrusion_path->mm3_per_mm = flow.mm3_per_mm(); extrusion_path->width = flow.width; extrusion_path->height = support_layer.height; } // TODO: use offset2_ex() to_infill = offset_ex(to_infill_polygons, - flow.scaled_spacing()); } for (ExPolygons::const_iterator it_expolygon = to_infill.begin(); it_expolygon != to_infill.end(); ++ it_expolygon) { Surface surface(stInternal, *it_expolygon); FillParams fill_params; fill_params.density = density; fill_params.complete = true; Polylines polylines = filler->fill_surface(&surface, fill_params); for (Polylines::const_iterator it_polyline = polylines.begin(); it_polyline != polylines.end(); ++ it_polyline) { ExtrusionPath *extrusion_path = new ExtrusionPath(erSupportMaterial); support_layer.support_fills.entities.push_back(extrusion_path); extrusion_path->polyline = *it_polyline; extrusion_path->mm3_per_mm = base_flow.mm3_per_mm(); extrusion_path->width = base_flow.width; extrusion_path->height = support_layer.height; } } } /* if (0) { require "Slic3r/SVG.pm"; Slic3r::SVG::output("islands_" . $z . ".svg", red_expolygons => union_ex($contact), green_expolygons => union_ex($interface), green_polylines => [ map $_->unpack->polyline, @{$layer->support_contact_fills} ], polylines => [ map $_->unpack->polyline, @{$layer->support_fills} ], ); } */ } // for each support_layer_id } /* void PrintObjectSupportMaterial::clip_by_pillars( const PrintObject &object, LayersPtr &bottom_contacts, LayersPtr &top_contacts, LayersPtr &intermediate_contacts); { // this prevents supplying an empty point set to BoundingBox constructor if (top_contacts.empty()) return; coord_t pillar_size = scale_(PILLAR_SIZE); coord_t pillar_spacing = scale_(PILLAR_SPACING); // A regular grid of pillars, filling the 2D bounding box. Polygons grid; { // Rectangle with a side of 2.5x2.5mm. Polygon pillar; pillar.points.push_back(Point(0, 0)); pillar.points.push_back(Point(pillar_size, 0)); pillar.points.push_back(Point(pillar_size, pillar_size)); pillar.points.push_back(Point(0, pillar_size)); // 2D bounding box of the projection of all contact polygons. BoundingBox bbox; for (LayersPtr::const_iterator it = top_contacts.begin(); it != top_contacts.end(); ++ it) bbox.merge(get_extents((*it)->polygons)); grid.reserve(size_t(ceil(bb.size().x / pillar_spacing)) * size_t(ceil(bb.size().y / pillar_spacing))); for (coord_t x = bb.min.x; x <= bb.max.x - pillar_size; x += pillar_spacing) { for (coord_t y = bb.min.y; y <= bb.max.y - pillar_size; y += pillar_spacing) { grid.push_back(pillar); for (size_t i = 0; i < pillar.points.size(); ++ i) grid.back().points[i].translate(Point(x, y)); } } } // add pillars to every layer for my $i (0..n_support_z) { $shape->[$i] = [ @$grid ]; } // build capitals for my $i (0..n_support_z) { my $z = $support_z->[$i]; my $capitals = intersection( $grid, $contact->{$z} // [], ); // work on one pillar at time (if any) to prevent the capitals from being merged // but store the contact area supported by the capital because we need to make // sure nothing is left my $contact_supported_by_capitals = []; foreach my $capital (@$capitals) { // enlarge capital tops $capital = offset([$capital], +($pillar_spacing - $pillar_size)/2); push @$contact_supported_by_capitals, @$capital; for (my $j = $i-1; $j >= 0; $j--) { my $jz = $support_z->[$j]; $capital = offset($capital, -$self->interface_flow->scaled_width/2); last if !@$capitals; push @{ $shape->[$j] }, @$capital; } } // Capitals will not generally cover the whole contact area because there will be // remainders. For now we handle this situation by projecting such unsupported // areas to the ground, just like we would do with a normal support. my $contact_not_supported_by_capitals = diff( $contact->{$z} // [], $contact_supported_by_capitals, ); if (@$contact_not_supported_by_capitals) { for (my $j = $i-1; $j >= 0; $j--) { push @{ $shape->[$j] }, @$contact_not_supported_by_capitals; } } } } sub clip_with_shape { my ($self, $support, $shape) = @_; foreach my $i (keys %$support) { // don't clip bottom layer with shape so that we // can generate a continuous base flange // also don't clip raft layers next if $i == 0; next if $i < $self->object_config->raft_layers; $support->{$i} = intersection( $support->{$i}, $shape->[$i], ); } } */ } // namespace Slic3r ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/SupportMaterial.hpp������������������������������������������0000664�0000000�0000000�00000023050�13014417200�0023451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef slic3r_SupportMaterial_hpp_ #define slic3r_SupportMaterial_hpp_ #include "Flow.hpp" #include "PrintConfig.hpp" namespace Slic3r { class PrintObject; class PrintConfig; class PrintObjectConfig; // how much we extend support around the actual contact area #define SUPPORT_MATERIAL_MARGIN 1.5 // This class manages raft and supports for a single PrintObject. // Instantiated by Slic3r::Print::Object->_support_material() // This class is instantiated before the slicing starts as Object.pm will query // the parameters of the raft to determine the 1st layer height and thickness. class PrintObjectSupportMaterial { public: enum SupporLayerType { sltUnknown = 0, sltRaft, stlFirstLayer, sltBottomContact, sltBottomInterface, sltBase, sltTopInterface, sltTopContact, // Some undecided type yet. It will turn into stlBase first, then it may turn into stlBottomInterface or stlTopInterface. stlIntermediate, }; class MyLayer { public: MyLayer() : layer_type(sltUnknown), print_z(0.), bottom_z(0.), height(0.), idx_object_layer_above(size_t(-1)), idx_object_layer_below(size_t(-1)), bridging(false), aux_polygons(NULL) {} ~MyLayer() { delete aux_polygons; aux_polygons = NULL; } bool operator==(const MyLayer &layer2) const { return print_z == layer2.print_z && height == layer2.height && bridging == layer2.bridging; } bool operator<(const MyLayer &layer2) const { if (print_z < layer2.print_z) { return true; } else if (print_z == layer2.print_z) { if (height > layer2.height) return true; else if (height == layer2.height) { return bridging < layer2.bridging; } else return false; } else return false; } SupporLayerType layer_type; // Z used for printing in unscaled coordinates coordf_t print_z; // Bottom height of this layer. For soluble layers, bottom_z + height = print_z, // otherwise bottom_z + gap + height = print_z. coordf_t bottom_z; // layer height in unscaled coordinates coordf_t height; // Index of a PrintObject layer_id supported by this layer. This will be set for top contact layers. // If this is not a contact layer, it will be set to size_t(-1). size_t idx_object_layer_above; // Index of a PrintObject layer_id, which supports this layer. This will be set for bottom contact layers. // If this is not a contact layer, it will be set to size_t(-1). size_t idx_object_layer_below; // Use a bridging flow when printing this support layer. bool bridging; // Polygons to be filled by the support pattern. Polygons polygons; // Currently for the contact layers only: Overhangs are stored here. Polygons *aux_polygons; }; struct LayerExtreme { LayerExtreme(MyLayer *alayer, bool ais_top) : layer(alayer), is_top(ais_top) {} MyLayer *layer; // top or bottom extreme bool is_top; coordf_t z() const { return is_top ? layer->print_z : layer->print_z - layer->height; } bool operator<(const LayerExtreme &other) const { return z() < other.z(); } }; /* struct LayerPrintZ_Hash { size_t operator()(const MyLayer &layer) const { return std::hash()(layer.print_z)^std::hash()(layer.height)^size_t(layer.bridging); } }; */ typedef std::vector MyLayersPtr; typedef std::deque MyLayerStorage; public: PrintObjectSupportMaterial(const PrintObject *object); // Height of the 1st layer is user configured as it is important for the print // to stick to he print bed. coordf_t first_layer_height() const { return m_object_config->first_layer_height.value; } // Is raft enabled? bool has_raft() const { return m_has_raft; } // Has any support? bool has_support() const { return m_object_config->support_material.value; } // How many raft layers are there below the 1st object layer? // The 1st object layer_id will be offsetted by this number. size_t num_raft_layers() const { return m_object_config->raft_layers.value; } // num_raft_layers() == num_raft_base_layers() + num_raft_interface_layers() + num_raft_contact_layers(). size_t num_raft_base_layers() const { return m_num_base_raft_layers; } size_t num_raft_interface_layers() const { return m_num_interface_raft_layers; } size_t num_raft_contact_layers() const { return m_num_contact_raft_layers; } coordf_t raft_height() const { return m_raft_height; } coordf_t raft_base_height() const { return m_raft_base_height; } coordf_t raft_interface_height() const { return m_raft_interface_height; } coordf_t raft_contact_height() const { return m_raft_contact_height; } bool raft_bridging() const { return m_raft_contact_layer_bridging; } // 1st layer of the object will be printed depeding on the raft settings. coordf_t first_object_layer_print_z() const { return m_object_1st_layer_print_z; } coordf_t first_object_layer_height() const { return m_object_1st_layer_height; } coordf_t first_object_layer_gap() const { return m_object_1st_layer_gap; } bool first_object_layer_bridging() const { return m_object_1st_layer_bridging; } // Generate support material for the object. // New support layers will be added to the object, // with extrusion paths and islands filled in for each support layer. void generate(PrintObject &object); private: // Generate top contact layers supporting overhangs. // For a soluble interface material synchronize the layer heights with the object, otherwise leave the layer height undefined. // If supports over bed surface only are requested, don't generate contact layers over an object. MyLayersPtr top_contact_layers(const PrintObject &object, MyLayerStorage &layer_storage) const; // Generate bottom contact layers supporting the top contact layers. // For a soluble interface material synchronize the layer heights with the object, // otherwise set the layer height to a bridging flow of a support interface nozzle. MyLayersPtr bottom_contact_layers(const PrintObject &object, const MyLayersPtr &top_contacts, MyLayerStorage &layer_storage) const; // Trim the top_contacts layers with the bottom_contacts layers if they overlap, so there would not be enough vertical space for both of them. void trim_top_contacts_by_bottom_contacts(const PrintObject &object, const MyLayersPtr &bottom_contacts, MyLayersPtr &top_contacts) const; // Generate raft layers and the intermediate support layers between the bottom contact and top contact surfaces. MyLayersPtr raft_and_intermediate_support_layers( const PrintObject &object, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, MyLayerStorage &layer_storage, const coordf_t max_object_layer_height) const; void generate_base_layers( const PrintObject &object, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, MyLayersPtr &intermediate_layers) const; Polygons generate_raft_base( const PrintObject &object, const MyLayersPtr &bottom_contacts, MyLayersPtr &intermediate_layers) const; MyLayersPtr generate_interface_layers( const PrintObject &object, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, MyLayersPtr &intermediate_layers, MyLayerStorage &layer_storage) const; /* void generate_pillars_shape(); void clip_with_shape(); */ // Produce the actual G-code. void generate_toolpaths( const PrintObject &object, const Polygons &raft, const MyLayersPtr &bottom_contacts, const MyLayersPtr &top_contacts, const MyLayersPtr &intermediate_layers, const MyLayersPtr &interface_layers) const; const PrintObject *m_object; const PrintConfig *m_print_config; const PrintObjectConfig *m_object_config; Flow m_first_layer_flow; Flow m_support_material_flow; Flow m_support_material_interface_flow; bool m_soluble_interface; Flow m_support_material_raft_base_flow; Flow m_support_material_raft_interface_flow; Flow m_support_material_raft_contact_flow; bool m_has_raft; size_t m_num_base_raft_layers; size_t m_num_interface_raft_layers; size_t m_num_contact_raft_layers; // If set, the raft contact layer is laid with round strings, which are easily detachable // from both the below and above layes. // Otherwise a normal flow is used and the strings are squashed against the layer below, // creating a firm bond with the layer below and making the interface top surface flat. coordf_t m_raft_height; coordf_t m_raft_base_height; coordf_t m_raft_interface_height; coordf_t m_raft_contact_height; bool m_raft_contact_layer_bridging; coordf_t m_object_1st_layer_print_z; coordf_t m_object_1st_layer_height; coordf_t m_object_1st_layer_gap; bool m_object_1st_layer_bridging; coordf_t m_object_layer_height_max; coordf_t m_support_layer_height_min; coordf_t m_support_layer_height_max; coordf_t m_support_interface_layer_height_max; coordf_t m_gap_extra_above; coordf_t m_gap_extra_below; coordf_t m_gap_xy; // If enabled, the support layers will be synchronized with object layers. // This does not prevent the support layers to be combined. bool m_synchronize_support_layers_with_object; // If disabled and m_synchronize_support_layers_with_object, // the support layers will be synchronized with the object layers exactly, no layer will be combined. bool m_combine_support_layers; }; } // namespace Slic3r #endif /* slic3r_SupportMaterial_hpp_ */ ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/Surface.cpp��������������������������������������������������0000664�0000000�0000000�00000010650�13014417200�0021703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#include "BoundingBox.hpp" #include "Surface.hpp" #include "SVG.hpp" namespace Slic3r { Surface::operator Polygons() const { return this->expolygon; } double Surface::area() const { return this->expolygon.area(); } bool Surface::is_solid() const { return this->surface_type == stTop || this->surface_type == stBottom || this->surface_type == stBottomBridge || this->surface_type == stInternalSolid || this->surface_type == stInternalBridge; } bool Surface::is_external() const { return this->surface_type == stTop || this->surface_type == stBottom || this->surface_type == stBottomBridge; } bool Surface::is_internal() const { return this->surface_type == stInternal || this->surface_type == stInternalBridge || this->surface_type == stInternalSolid || this->surface_type == stInternalVoid; } bool Surface::is_bottom() const { return this->surface_type == stBottom || this->surface_type == stBottomBridge; } bool Surface::is_bridge() const { return this->surface_type == stBottomBridge || this->surface_type == stInternalBridge; } BoundingBox get_extents(const Surface &surface) { return get_extents(surface.expolygon.contour); } BoundingBox get_extents(const Surfaces &surfaces) { BoundingBox bbox; if (! surfaces.empty()) { bbox = get_extents(surfaces.front()); for (size_t i = 1; i < surfaces.size(); ++ i) bbox.merge(get_extents(surfaces[i])); } return bbox; } BoundingBox get_extents(const SurfacesPtr &surfaces) { BoundingBox bbox; if (! surfaces.empty()) { bbox = get_extents(*surfaces.front()); for (size_t i = 1; i < surfaces.size(); ++ i) bbox.merge(get_extents(*surfaces[i])); } return bbox; } const char* surface_type_to_color_name(const SurfaceType surface_type) { switch (surface_type) { case stTop: return "rgb(255,0,0)"; // "red"; case stBottom: return "rgb(0,255,0)"; // "green"; case stBottomBridge: return "rgb(0,0,255)"; // "blue"; case stInternal: return "rgb(255,255,128)"; // yellow case stInternalSolid: return "rgb(255,0,255)"; // magenta case stInternalBridge: return "rgb(0,255,255)"; case stInternalVoid: return "rgb(128,128,128)"; case stPerimeter: return "rgb(128,0,0)"; // maroon default: return "rgb(64,64,64)"; }; } Point export_surface_type_legend_to_svg_box_size() { return Point(scale_(1.+10.*8.), scale_(3.)); } void export_surface_type_legend_to_svg(SVG &svg, const Point &pos) { // 1st row coord_t pos_x0 = pos.x + scale_(1.); coord_t pos_x = pos_x0; coord_t pos_y = pos.y + scale_(1.5); coord_t step_x = scale_(10.); svg.draw_legend(Point(pos_x, pos_y), "perimeter" , surface_type_to_color_name(stPerimeter)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "top" , surface_type_to_color_name(stTop)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "bottom" , surface_type_to_color_name(stBottom)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "bottom bridge" , surface_type_to_color_name(stBottomBridge)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "invalid" , surface_type_to_color_name(SurfaceType(-1))); // 2nd row pos_x = pos_x0; pos_y = pos.y+scale_(2.8); svg.draw_legend(Point(pos_x, pos_y), "internal" , surface_type_to_color_name(stInternal)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "internal solid" , surface_type_to_color_name(stInternalSolid)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "internal bridge", surface_type_to_color_name(stInternalBridge)); pos_x += step_x; svg.draw_legend(Point(pos_x, pos_y), "internal void" , surface_type_to_color_name(stInternalVoid)); } bool export_to_svg(const char *path, const Surfaces &surfaces, const float transparency) { BoundingBox bbox; for (Surfaces::const_iterator surface = surfaces.begin(); surface != surfaces.end(); ++surface) bbox.merge(get_extents(surface->expolygon)); SVG svg(path, bbox); for (Surfaces::const_iterator surface = surfaces.begin(); surface != surfaces.end(); ++surface) svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency); svg.Close(); return true; } } ����������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/Surface.hpp��������������������������������������������������0000664�0000000�0000000�00000021567�13014417200�0021721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef slic3r_Surface_hpp_ #define slic3r_Surface_hpp_ #include "libslic3r.h" #include "ExPolygon.hpp" namespace Slic3r { enum SurfaceType { // Top horizontal surface, visible from the top. stTop, // Bottom horizontal surface, visible from the bottom, printed with a normal extrusion flow. stBottom, // Bottom horizontal surface, visible from the bottom, unsupported, printed with a bridging extrusion flow. stBottomBridge, // Normal sparse infill. stInternal, // Full infill, supporting the top surfaces and/or defining the verticall wall thickness. stInternalSolid, // 1st layer of dense infill over sparse infill, printed with a bridging extrusion flow. stInternalBridge, // stInternal turns into void surfaces if the sparse infill is used for supports only, // or if sparse infill layers get combined into a single layer. stInternalVoid, // Inner/outer perimeters. stPerimeter }; class Surface { public: SurfaceType surface_type; ExPolygon expolygon; double thickness; // in mm unsigned short thickness_layers; // in layers double bridge_angle; // in radians, ccw, 0 = East, only 0+ (negative means undefined) unsigned short extra_perimeters; Surface(SurfaceType _surface_type, const ExPolygon &_expolygon) : surface_type(_surface_type), expolygon(_expolygon), thickness(-1), thickness_layers(1), bridge_angle(-1), extra_perimeters(0) {}; Surface(const Surface &other, const ExPolygon &_expolygon) : surface_type(other.surface_type), expolygon(_expolygon), thickness(other.thickness), thickness_layers(other.thickness_layers), bridge_angle(other.bridge_angle), extra_perimeters(other.extra_perimeters) {}; #if SLIC3R_CPPVER >= 11 Surface(SurfaceType _surface_type, const ExPolygon &&_expolygon) : surface_type(_surface_type), expolygon(std::move(_expolygon)), thickness(-1), thickness_layers(1), bridge_angle(-1), extra_perimeters(0) {}; Surface(const Surface &other, const ExPolygon &&_expolygon) : surface_type(other.surface_type), expolygon(std::move(_expolygon)), thickness(other.thickness), thickness_layers(other.thickness_layers), bridge_angle(other.bridge_angle), extra_perimeters(other.extra_perimeters) {}; #endif operator Polygons() const; double area() const; bool empty() const { return expolygon.empty(); } bool is_solid() const; bool is_external() const; bool is_internal() const; bool is_bottom() const; bool is_bridge() const; }; typedef std::vector Surfaces; typedef std::vector SurfacesPtr; inline Polygons to_polygons(const Surfaces &src) { size_t num = 0; for (Surfaces::const_iterator it = src.begin(); it != src.end(); ++it) num += it->expolygon.holes.size() + 1; Polygons polygons; polygons.reserve(num); for (Surfaces::const_iterator it = src.begin(); it != src.end(); ++it) { polygons.push_back(it->expolygon.contour); for (Polygons::const_iterator ith = it->expolygon.holes.begin(); ith != it->expolygon.holes.end(); ++ith) polygons.push_back(*ith); } return polygons; } inline Polygons to_polygons(const SurfacesPtr &src) { size_t num = 0; for (SurfacesPtr::const_iterator it = src.begin(); it != src.end(); ++it) num += (*it)->expolygon.holes.size() + 1; Polygons polygons; polygons.reserve(num); for (SurfacesPtr::const_iterator it = src.begin(); it != src.end(); ++it) { polygons.push_back((*it)->expolygon.contour); for (Polygons::const_iterator ith = (*it)->expolygon.holes.begin(); ith != (*it)->expolygon.holes.end(); ++ith) polygons.push_back(*ith); } return polygons; } inline ExPolygons to_expolygons(const Surfaces &src) { ExPolygons expolygons; expolygons.reserve(src.size()); for (Surfaces::const_iterator it = src.begin(); it != src.end(); ++it) expolygons.push_back(it->expolygon); return expolygons; } inline ExPolygons to_expolygons(const SurfacesPtr &src) { ExPolygons expolygons; expolygons.reserve(src.size()); for (SurfacesPtr::const_iterator it = src.begin(); it != src.end(); ++it) expolygons.push_back((*it)->expolygon); return expolygons; } // Count a nuber of polygons stored inside the vector of expolygons. // Useful for allocating space for polygons when converting expolygons to polygons. inline size_t number_polygons(const Surfaces &surfaces) { size_t n_polygons = 0; for (Surfaces::const_iterator it = surfaces.begin(); it != surfaces.end(); ++ it) n_polygons += it->expolygon.holes.size() + 1; return n_polygons; } inline size_t number_polygons(const SurfacesPtr &surfaces) { size_t n_polygons = 0; for (SurfacesPtr::const_iterator it = surfaces.begin(); it != surfaces.end(); ++ it) n_polygons += (*it)->expolygon.holes.size() + 1; return n_polygons; } // Append a vector of Surfaces at the end of another vector of polygons. inline void polygons_append(Polygons &dst, const Surfaces &src) { dst.reserve(dst.size() + number_polygons(src)); for (Surfaces::const_iterator it = src.begin(); it != src.end(); ++ it) { dst.push_back(it->expolygon.contour); dst.insert(dst.end(), it->expolygon.holes.begin(), it->expolygon.holes.end()); } } #if SLIC3R_CPPVER >= 11 inline void polygons_append(Polygons &dst, Surfaces &&src) { dst.reserve(dst.size() + number_polygons(src)); for (Surfaces::const_iterator it = src.begin(); it != src.end(); ++ it) { dst.push_back(std::move(it->expolygon.contour)); std::move(std::begin(it->expolygon.holes), std::end(it->expolygon.holes), std::back_inserter(dst)); } } #endif // Append a vector of Surfaces at the end of another vector of polygons. inline void polygons_append(Polygons &dst, const SurfacesPtr &src) { dst.reserve(dst.size() + number_polygons(src)); for (SurfacesPtr::const_iterator it = src.begin(); it != src.end(); ++ it) { dst.push_back((*it)->expolygon.contour); dst.insert(dst.end(), (*it)->expolygon.holes.begin(), (*it)->expolygon.holes.end()); } } #if SLIC3R_CPPVER >= 11 inline void polygons_append(Polygons &dst, SurfacesPtr &&src) { dst.reserve(dst.size() + number_polygons(src)); for (SurfacesPtr::const_iterator it = src.begin(); it != src.end(); ++ it) { dst.push_back(std::move((*it)->expolygon.contour)); std::move(std::begin((*it)->expolygon.holes), std::end((*it)->expolygon.holes), std::back_inserter(dst)); } } #endif // Append a vector of Surfaces at the end of another vector of polygons. inline void surfaces_append(Surfaces &dst, const ExPolygons &src, SurfaceType surfaceType) { dst.reserve(dst.size() + src.size()); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++ it) dst.push_back(Surface(surfaceType, *it)); } inline void surfaces_append(Surfaces &dst, const ExPolygons &src, const Surface &surfaceTempl) { dst.reserve(dst.size() + number_polygons(src)); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++ it) dst.push_back(Surface(surfaceTempl, *it)); } inline void surfaces_append(Surfaces &dst, const Surfaces &src) { dst.insert(dst.end(), src.begin(), src.end()); } #if SLIC3R_CPPVER >= 11 inline void surfaces_append(Surfaces &dst, ExPolygons &&src, SurfaceType surfaceType) { dst.reserve(dst.size() + src.size()); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++ it) dst.push_back(Surface(surfaceType, std::move(*it))); } inline void surfaces_append(Surfaces &dst, ExPolygons &&src, const Surface &surfaceTempl) { dst.reserve(dst.size() + number_polygons(src)); for (ExPolygons::const_iterator it = src.begin(); it != src.end(); ++ it) dst.push_back(Surface(surfaceTempl, std::move(*it))); } inline void surfaces_append(Surfaces &dst, Surfaces &&src) { if (dst.empty()) dst = std::move(src); else std::move(std::begin(src), std::end(src), std::back_inserter(dst)); } #endif extern BoundingBox get_extents(const Surface &surface); extern BoundingBox get_extents(const Surfaces &surfaces); extern BoundingBox get_extents(const SurfacesPtr &surfaces); inline bool surfaces_could_merge(const Surface &s1, const Surface &s2) { return s1.surface_type == s2.surface_type && s1.thickness == s2.thickness && s1.thickness_layers == s2.thickness_layers && s1.bridge_angle == s2.bridge_angle; } class SVG; extern const char* surface_type_to_color_name(const SurfaceType surface_type); extern void export_surface_type_legend_to_svg(SVG &svg, const Point &pos); extern Point export_surface_type_legend_to_svg_box_size(); extern bool export_to_svg(const char *path, const Surfaces &surfaces, const float transparency = 1.f); } #endif �����������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/SurfaceCollection.cpp����������������������������������������0000664�0000000�0000000�00000016274�13014417200�0023727�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#include "SurfaceCollection.hpp" #include "BoundingBox.hpp" #include "SVG.hpp" #include namespace Slic3r { SurfaceCollection::operator Polygons() const { Polygons polygons; for (Surfaces::const_iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { Polygons surface_p = surface->expolygon; polygons.insert(polygons.end(), surface_p.begin(), surface_p.end()); } return polygons; } SurfaceCollection::operator ExPolygons() const { ExPolygons expp; expp.reserve(this->surfaces.size()); for (Surfaces::const_iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { expp.push_back(surface->expolygon); } return expp; } void SurfaceCollection::simplify(double tolerance) { Surfaces ss; for (Surfaces::const_iterator it_s = this->surfaces.begin(); it_s != this->surfaces.end(); ++it_s) { ExPolygons expp; it_s->expolygon.simplify(tolerance, &expp); for (ExPolygons::const_iterator it_e = expp.begin(); it_e != expp.end(); ++it_e) { Surface s = *it_s; s.expolygon = *it_e; ss.push_back(s); } } this->surfaces = ss; } /* group surfaces by common properties */ void SurfaceCollection::group(std::vector *retval) { for (Surfaces::iterator it = this->surfaces.begin(); it != this->surfaces.end(); ++it) { // find a group with the same properties SurfacesPtr* group = NULL; for (std::vector::iterator git = retval->begin(); git != retval->end(); ++git) if (! git->empty() && surfaces_could_merge(*git->front(), *it)) { group = &*git; break; } // if no group with these properties exists, add one if (group == NULL) { retval->resize(retval->size() + 1); group = &retval->back(); } // append surface to group group->push_back(&*it); } } template bool SurfaceCollection::any_internal_contains(const T &item) const { for (Surfaces::const_iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { if (surface->is_internal() && surface->expolygon.contains(item)) return true; } return false; } template bool SurfaceCollection::any_internal_contains(const Polyline &item) const; template bool SurfaceCollection::any_bottom_contains(const T &item) const { for (Surfaces::const_iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { if (surface->is_bottom() && surface->expolygon.contains(item)) return true; } return false; } template bool SurfaceCollection::any_bottom_contains(const Polyline &item) const; SurfacesPtr SurfaceCollection::filter_by_type(const SurfaceType type) { SurfacesPtr ss; for (Surfaces::iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { if (surface->surface_type == type) ss.push_back(&*surface); } return ss; } SurfacesPtr SurfaceCollection::filter_by_types(const SurfaceType *types, int ntypes) { SurfacesPtr ss; for (Surfaces::iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { for (int i = 0; i < ntypes; ++ i) { if (surface->surface_type == types[i]) { ss.push_back(&*surface); break; } } } return ss; } void SurfaceCollection::filter_by_type(SurfaceType type, Polygons* polygons) { for (Surfaces::iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { if (surface->surface_type == type) { Polygons pp = surface->expolygon; polygons->insert(polygons->end(), pp.begin(), pp.end()); } } } void SurfaceCollection::keep_type(const SurfaceType type) { size_t j = 0; for (size_t i = 0; i < surfaces.size(); ++ i) { if (surfaces[i].surface_type == type) { if (j < i) std::swap(surfaces[i], surfaces[j]); ++ j; } } if (j < surfaces.size()) surfaces.erase(surfaces.begin() + j, surfaces.end()); } void SurfaceCollection::keep_types(const SurfaceType *types, int ntypes) { size_t j = 0; for (size_t i = 0; i < surfaces.size(); ++ i) { bool keep = false; for (int k = 0; k < ntypes; ++ k) { if (surfaces[i].surface_type == types[k]) { keep = true; break; } } if (keep) { if (j < i) std::swap(surfaces[i], surfaces[j]); ++ j; } } if (j < surfaces.size()) surfaces.erase(surfaces.begin() + j, surfaces.end()); } void SurfaceCollection::remove_type(const SurfaceType type) { size_t j = 0; for (size_t i = 0; i < surfaces.size(); ++ i) { if (surfaces[i].surface_type != type) { if (j < i) std::swap(surfaces[i], surfaces[j]); ++ j; } } if (j < surfaces.size()) surfaces.erase(surfaces.begin() + j, surfaces.end()); } void SurfaceCollection::remove_types(const SurfaceType *types, int ntypes) { size_t j = 0; for (size_t i = 0; i < surfaces.size(); ++ i) { bool remove = false; for (int k = 0; k < ntypes; ++ k) { if (surfaces[i].surface_type == types[k]) { remove = true; break; } } if (! remove) { if (j < i) std::swap(surfaces[i], surfaces[j]); ++ j; } } if (j < surfaces.size()) surfaces.erase(surfaces.begin() + j, surfaces.end()); } void SurfaceCollection::append(const SurfaceCollection &coll) { this->surfaces.insert(this->surfaces.end(), coll.surfaces.begin(), coll.surfaces.end()); } void SurfaceCollection::append(const SurfaceType surfaceType, const Slic3r::ExPolygons &expoly) { for (Slic3r::ExPolygons::const_iterator it = expoly.begin(); it != expoly.end(); ++ it) this->surfaces.push_back(Slic3r::Surface(surfaceType, *it)); } void SurfaceCollection::export_to_svg(const char *path, bool show_labels) { BoundingBox bbox; for (Surfaces::const_iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) bbox.merge(get_extents(surface->expolygon)); Point legend_size = export_surface_type_legend_to_svg_box_size(); Point legend_pos(bbox.min.x, bbox.max.y); bbox.merge(Point(std::max(bbox.min.x + legend_size.x, bbox.max.x), bbox.max.y + legend_size.y)); SVG svg(path, bbox); const float transparency = 0.5f; for (Surfaces::const_iterator surface = this->surfaces.begin(); surface != this->surfaces.end(); ++surface) { svg.draw(surface->expolygon, surface_type_to_color_name(surface->surface_type), transparency); if (show_labels) { int idx = int(surface - this->surfaces.begin()); char label[64]; sprintf(label, "%d", idx); svg.draw_text(surface->expolygon.contour.points.front(), label, "black"); } } export_surface_type_legend_to_svg(svg, legend_pos); svg.Close(); } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/SurfaceCollection.hpp����������������������������������������0000664�0000000�0000000�00000002354�13014417200�0023726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef slic3r_SurfaceCollection_hpp_ #define slic3r_SurfaceCollection_hpp_ #include "libslic3r.h" #include "Surface.hpp" #include namespace Slic3r { class SurfaceCollection { public: Surfaces surfaces; SurfaceCollection() {}; SurfaceCollection(const Surfaces &_surfaces) : surfaces(_surfaces) {}; operator Polygons() const; operator ExPolygons() const; void simplify(double tolerance); void group(std::vector *retval); template bool any_internal_contains(const T &item) const; template bool any_bottom_contains(const T &item) const; SurfacesPtr filter_by_type(const SurfaceType type); SurfacesPtr filter_by_types(const SurfaceType *types, int ntypes); void keep_type(const SurfaceType type); void keep_types(const SurfaceType *types, int ntypes); void remove_type(const SurfaceType type); void remove_types(const SurfaceType *types, int ntypes); void filter_by_type(SurfaceType type, Polygons* polygons); void append(const SurfaceCollection &coll); void append(const SurfaceType surfaceType, const ExPolygons &expoly); // For debugging purposes: void export_to_svg(const char *path, bool show_labels); }; } #endif ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/TriangleMesh.cpp���������������������������������������������0000664�0000000�0000000�00000117754�13014417200�0022712�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#include "TriangleMesh.hpp" #include "ClipperUtils.hpp" #include "Geometry.hpp" #include #include #include #include #include #include #include #include #include #include #ifdef SLIC3R_DEBUG // #define SLIC3R_TRIANGLEMESH_DEBUG #include "SVG.hpp" #endif namespace Slic3r { TriangleMesh::TriangleMesh() : repaired(false) { stl_initialize(&this->stl); } TriangleMesh::TriangleMesh(const TriangleMesh &other) : stl(other.stl), repaired(other.repaired) { this->stl.heads = NULL; this->stl.tail = NULL; this->stl.error = other.stl.error; if (other.stl.facet_start != NULL) { this->stl.facet_start = (stl_facet*)calloc(other.stl.stats.number_of_facets, sizeof(stl_facet)); std::copy(other.stl.facet_start, other.stl.facet_start + other.stl.stats.number_of_facets, this->stl.facet_start); } if (other.stl.neighbors_start != NULL) { this->stl.neighbors_start = (stl_neighbors*)calloc(other.stl.stats.number_of_facets, sizeof(stl_neighbors)); std::copy(other.stl.neighbors_start, other.stl.neighbors_start + other.stl.stats.number_of_facets, this->stl.neighbors_start); } if (other.stl.v_indices != NULL) { this->stl.v_indices = (v_indices_struct*)calloc(other.stl.stats.number_of_facets, sizeof(v_indices_struct)); std::copy(other.stl.v_indices, other.stl.v_indices + other.stl.stats.number_of_facets, this->stl.v_indices); } if (other.stl.v_shared != NULL) { this->stl.v_shared = (stl_vertex*)calloc(other.stl.stats.shared_vertices, sizeof(stl_vertex)); std::copy(other.stl.v_shared, other.stl.v_shared + other.stl.stats.shared_vertices, this->stl.v_shared); } } TriangleMesh& TriangleMesh::operator= (TriangleMesh other) { this->swap(other); return *this; } void TriangleMesh::swap(TriangleMesh &other) { std::swap(this->stl, other.stl); std::swap(this->repaired, other.repaired); } TriangleMesh::~TriangleMesh() { stl_close(&this->stl); } void TriangleMesh::ReadSTLFile(char* input_file) { stl_open(&stl, input_file); } void TriangleMesh::write_ascii(char* output_file) { stl_write_ascii(&this->stl, output_file, ""); } void TriangleMesh::write_binary(char* output_file) { stl_write_binary(&this->stl, output_file, ""); } void TriangleMesh::repair() { if (this->repaired) return; // admesh fails when repairing empty meshes if (this->stl.stats.number_of_facets == 0) return; // checking exact stl_check_facets_exact(&stl); stl.stats.facets_w_1_bad_edge = (stl.stats.connected_facets_2_edge - stl.stats.connected_facets_3_edge); stl.stats.facets_w_2_bad_edge = (stl.stats.connected_facets_1_edge - stl.stats.connected_facets_2_edge); stl.stats.facets_w_3_bad_edge = (stl.stats.number_of_facets - stl.stats.connected_facets_1_edge); // checking nearby //int last_edges_fixed = 0; float tolerance = stl.stats.shortest_edge; float increment = stl.stats.bounding_diameter / 10000.0; int iterations = 2; if (stl.stats.connected_facets_3_edge < stl.stats.number_of_facets) { for (int i = 0; i < iterations; i++) { if (stl.stats.connected_facets_3_edge < stl.stats.number_of_facets) { //printf("Checking nearby. Tolerance= %f Iteration=%d of %d...", tolerance, i + 1, iterations); stl_check_facets_nearby(&stl, tolerance); //printf(" Fixed %d edges.\n", stl.stats.edges_fixed - last_edges_fixed); //last_edges_fixed = stl.stats.edges_fixed; tolerance += increment; } else { break; } } } // remove_unconnected if (stl.stats.connected_facets_3_edge < stl.stats.number_of_facets) { stl_remove_unconnected_facets(&stl); } // fill_holes if (stl.stats.connected_facets_3_edge < stl.stats.number_of_facets) { stl_fill_holes(&stl); stl_clear_error(&stl); } // normal_directions stl_fix_normal_directions(&stl); // normal_values stl_fix_normal_values(&stl); // always calculate the volume and reverse all normals if volume is negative stl_calculate_volume(&stl); // neighbors stl_verify_neighbors(&stl); this->repaired = true; } void TriangleMesh::reset_repair_stats() { this->stl.stats.degenerate_facets = 0; this->stl.stats.edges_fixed = 0; this->stl.stats.facets_removed = 0; this->stl.stats.facets_added = 0; this->stl.stats.facets_reversed = 0; this->stl.stats.backwards_edges = 0; this->stl.stats.normals_fixed = 0; } bool TriangleMesh::needed_repair() const { return this->stl.stats.degenerate_facets > 0 || this->stl.stats.edges_fixed > 0 || this->stl.stats.facets_removed > 0 || this->stl.stats.facets_added > 0 || this->stl.stats.facets_reversed > 0 || this->stl.stats.backwards_edges > 0; } size_t TriangleMesh::facets_count() const { return this->stl.stats.number_of_facets; } void TriangleMesh::WriteOBJFile(char* output_file) { stl_generate_shared_vertices(&stl); stl_write_obj(&stl, output_file); } void TriangleMesh::scale(float factor) { stl_scale(&(this->stl), factor); stl_invalidate_shared_vertices(&this->stl); } void TriangleMesh::scale(const Pointf3 &versor) { float fversor[3]; fversor[0] = versor.x; fversor[1] = versor.y; fversor[2] = versor.z; stl_scale_versor(&this->stl, fversor); stl_invalidate_shared_vertices(&this->stl); } void TriangleMesh::translate(float x, float y, float z) { stl_translate_relative(&(this->stl), x, y, z); stl_invalidate_shared_vertices(&this->stl); } void TriangleMesh::rotate(float angle, const Axis &axis) { // admesh uses degrees angle = Slic3r::Geometry::rad2deg(angle); if (axis == X) { stl_rotate_x(&(this->stl), angle); } else if (axis == Y) { stl_rotate_y(&(this->stl), angle); } else if (axis == Z) { stl_rotate_z(&(this->stl), angle); } stl_invalidate_shared_vertices(&this->stl); } void TriangleMesh::rotate_x(float angle) { this->rotate(angle, X); } void TriangleMesh::rotate_y(float angle) { this->rotate(angle, Y); } void TriangleMesh::rotate_z(float angle) { this->rotate(angle, Z); } void TriangleMesh::mirror(const Axis &axis) { if (axis == X) { stl_mirror_yz(&this->stl); } else if (axis == Y) { stl_mirror_xz(&this->stl); } else if (axis == Z) { stl_mirror_xy(&this->stl); } stl_invalidate_shared_vertices(&this->stl); } void TriangleMesh::mirror_x() { this->mirror(X); } void TriangleMesh::mirror_y() { this->mirror(Y); } void TriangleMesh::mirror_z() { this->mirror(Z); } void TriangleMesh::align_to_origin() { this->translate( -(this->stl.stats.min.x), -(this->stl.stats.min.y), -(this->stl.stats.min.z) ); } void TriangleMesh::rotate(double angle, Point* center) { this->translate(-center->x, -center->y, 0); stl_rotate_z(&(this->stl), (float)angle); this->translate(+center->x, +center->y, 0); } TriangleMeshPtrs TriangleMesh::split() const { TriangleMeshPtrs meshes; std::set seen_facets; // we need neighbors if (!this->repaired) CONFESS("split() requires repair()"); // loop while we have remaining facets while (1) { // get the first facet std::queue facet_queue; std::deque facets; for (int facet_idx = 0; facet_idx < this->stl.stats.number_of_facets; facet_idx++) { if (seen_facets.find(facet_idx) == seen_facets.end()) { // if facet was not seen put it into queue and start searching facet_queue.push(facet_idx); break; } } if (facet_queue.empty()) break; while (!facet_queue.empty()) { int facet_idx = facet_queue.front(); facet_queue.pop(); if (seen_facets.find(facet_idx) != seen_facets.end()) continue; facets.push_back(facet_idx); for (int j = 0; j <= 2; j++) { facet_queue.push(this->stl.neighbors_start[facet_idx].neighbor[j]); } seen_facets.insert(facet_idx); } TriangleMesh* mesh = new TriangleMesh; meshes.push_back(mesh); mesh->stl.stats.type = inmemory; mesh->stl.stats.number_of_facets = facets.size(); mesh->stl.stats.original_num_facets = mesh->stl.stats.number_of_facets; stl_clear_error(&mesh->stl); stl_allocate(&mesh->stl); int first = 1; for (std::deque::const_iterator facet = facets.begin(); facet != facets.end(); ++facet) { mesh->stl.facet_start[facet - facets.begin()] = this->stl.facet_start[*facet]; stl_facet_stats(&mesh->stl, this->stl.facet_start[*facet], first); first = 0; } } return meshes; } void TriangleMesh::merge(const TriangleMesh &mesh) { // reset stats and metadata int number_of_facets = this->stl.stats.number_of_facets; stl_invalidate_shared_vertices(&this->stl); this->repaired = false; // update facet count and allocate more memory this->stl.stats.number_of_facets = number_of_facets + mesh.stl.stats.number_of_facets; this->stl.stats.original_num_facets = this->stl.stats.number_of_facets; stl_reallocate(&this->stl); // copy facets for (int i = 0; i < mesh.stl.stats.number_of_facets; i++) { this->stl.facet_start[number_of_facets + i] = mesh.stl.facet_start[i]; } // update size stl_get_size(&this->stl); } /* this will return scaled ExPolygons */ ExPolygons TriangleMesh::horizontal_projection() const { Polygons pp; pp.reserve(this->stl.stats.number_of_facets); for (int i = 0; i < this->stl.stats.number_of_facets; i++) { stl_facet* facet = &this->stl.facet_start[i]; Polygon p; p.points.resize(3); p.points[0] = Point(facet->vertex[0].x / SCALING_FACTOR, facet->vertex[0].y / SCALING_FACTOR); p.points[1] = Point(facet->vertex[1].x / SCALING_FACTOR, facet->vertex[1].y / SCALING_FACTOR); p.points[2] = Point(facet->vertex[2].x / SCALING_FACTOR, facet->vertex[2].y / SCALING_FACTOR); p.make_counter_clockwise(); // do this after scaling, as winding order might change while doing that pp.push_back(p); } // the offset factor was tuned using groovemount.stl offset(pp, &pp, 0.01 / SCALING_FACTOR); ExPolygons retval; union_(pp, &retval, true); return retval; } Polygon TriangleMesh::convex_hull() { this->require_shared_vertices(); Points pp; pp.reserve(this->stl.stats.shared_vertices); for (int i = 0; i < this->stl.stats.shared_vertices; i++) { stl_vertex* v = &this->stl.v_shared[i]; pp.push_back(Point(v->x / SCALING_FACTOR, v->y / SCALING_FACTOR)); } return Slic3r::Geometry::convex_hull(pp); } BoundingBoxf3 TriangleMesh::bounding_box() const { BoundingBoxf3 bb; bb.min.x = this->stl.stats.min.x; bb.min.y = this->stl.stats.min.y; bb.min.z = this->stl.stats.min.z; bb.max.x = this->stl.stats.max.x; bb.max.y = this->stl.stats.max.y; bb.max.z = this->stl.stats.max.z; return bb; } void TriangleMesh::require_shared_vertices() { if (!this->repaired) this->repair(); if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl)); } void TriangleMeshSlicer::slice(const std::vector &z, std::vector* layers) { /* This method gets called with a list of unscaled Z coordinates and outputs a vector pointer having the same number of items as the original list. Each item is a vector of polygons created by slicing our mesh at the given heights. This method should basically combine the behavior of the existing Perl methods defined in lib/Slic3r/TriangleMesh.pm: - analyze(): this creates the 'facets_edges' and the 'edges_facets' tables (we don't need the 'edges' table) - slice_facet(): this has to be done for each facet. It generates intersection lines with each plane identified by the Z list. The get_layer_range() binary search used to identify the Z range of the facet is already ported to C++ (see Object.xsp) - make_loops(): this has to be done for each layer. It creates polygons from the lines generated by the previous step. At the end, we free the tables generated by analyze() as we don't need them anymore. FUTURE: parallelize slice_facet() and make_loops() NOTE: this method accepts a vector of floats because the mesh coordinate type is float. */ std::vector lines(z.size()); for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; facet_idx++) { stl_facet* facet = &this->mesh->stl.facet_start[facet_idx]; // find facet extents float min_z = fminf(facet->vertex[0].z, fminf(facet->vertex[1].z, facet->vertex[2].z)); float max_z = fmaxf(facet->vertex[0].z, fmaxf(facet->vertex[1].z, facet->vertex[2].z)); #ifdef SLIC3R_TRIANGLEMESH_DEBUG printf("\n==> FACET %d (%f,%f,%f - %f,%f,%f - %f,%f,%f):\n", facet_idx, facet->vertex[0].x, facet->vertex[0].y, facet->vertex[0].z, facet->vertex[1].x, facet->vertex[1].y, facet->vertex[1].z, facet->vertex[2].x, facet->vertex[2].y, facet->vertex[2].z); printf("z: min = %.2f, max = %.2f\n", min_z, max_z); #endif // find layer extents std::vector::const_iterator min_layer, max_layer; min_layer = std::lower_bound(z.begin(), z.end(), min_z); // first layer whose slice_z is >= min_z max_layer = std::upper_bound(z.begin() + (min_layer - z.begin()), z.end(), max_z) - 1; // last layer whose slice_z is <= max_z #ifdef SLIC3R_TRIANGLEMESH_DEBUG printf("layers: min = %d, max = %d\n", (int)(min_layer - z.begin()), (int)(max_layer - z.begin())); #endif for (std::vector::const_iterator it = min_layer; it != max_layer + 1; ++it) { std::vector::size_type layer_idx = it - z.begin(); this->slice_facet(*it / SCALING_FACTOR, *facet, facet_idx, min_z, max_z, &lines[layer_idx]); } } // v_scaled_shared could be freed here // build loops layers->resize(z.size()); for (std::vector::iterator it = lines.begin(); it != lines.end(); ++it) { size_t layer_idx = it - lines.begin(); #ifdef SLIC3R_TRIANGLEMESH_DEBUG printf("Layer " PRINTF_ZU ":\n", layer_idx); #endif this->make_loops(*it, &(*layers)[layer_idx]); } } void TriangleMeshSlicer::slice(const std::vector &z, std::vector* layers) { std::vector layers_p; this->slice(z, &layers_p); layers->resize(z.size()); for (std::vector::const_iterator loops = layers_p.begin(); loops != layers_p.end(); ++loops) { #ifdef SLIC3R_TRIANGLEMESH_DEBUG size_t layer_id = loops - layers_p.begin(); printf("Layer " PRINTF_ZU " (slice_z = %.2f):\n", layer_id, z[layer_id]); #endif this->make_expolygons(*loops, &(*layers)[ loops - layers_p.begin() ]); } } void TriangleMeshSlicer::slice_facet(float slice_z, const stl_facet &facet, const int &facet_idx, const float &min_z, const float &max_z, std::vector* lines) const { std::vector points; std::vector< std::vector::size_type > points_on_layer; bool found_horizontal_edge = false; /* reorder vertices so that the first one is the one with lowest Z this is needed to get all intersection lines in a consistent order (external on the right of the line) */ int i = 0; if (facet.vertex[1].z == min_z) { // vertex 1 has lowest Z i = 1; } else if (facet.vertex[2].z == min_z) { // vertex 2 has lowest Z i = 2; } for (int j = i; (j-i) < 3; j++) { // loop through facet edges int edge_id = this->facets_edges[facet_idx][j % 3]; int a_id = this->mesh->stl.v_indices[facet_idx].vertex[j % 3]; int b_id = this->mesh->stl.v_indices[facet_idx].vertex[(j+1) % 3]; stl_vertex* a = &this->v_scaled_shared[a_id]; stl_vertex* b = &this->v_scaled_shared[b_id]; if (a->z == b->z && a->z == slice_z) { // edge is horizontal and belongs to the current layer stl_vertex &v0 = this->v_scaled_shared[ this->mesh->stl.v_indices[facet_idx].vertex[0] ]; stl_vertex &v1 = this->v_scaled_shared[ this->mesh->stl.v_indices[facet_idx].vertex[1] ]; stl_vertex &v2 = this->v_scaled_shared[ this->mesh->stl.v_indices[facet_idx].vertex[2] ]; IntersectionLine line; if (min_z == max_z) { line.edge_type = feHorizontal; if (this->mesh->stl.facet_start[facet_idx].normal.z < 0) { /* if normal points downwards this is a bottom horizontal facet so we reverse its point order */ std::swap(a, b); std::swap(a_id, b_id); } } else if (v0.z < slice_z || v1.z < slice_z || v2.z < slice_z) { line.edge_type = feTop; std::swap(a, b); std::swap(a_id, b_id); } else { line.edge_type = feBottom; } line.a.x = a->x; line.a.y = a->y; line.b.x = b->x; line.b.y = b->y; line.a_id = a_id; line.b_id = b_id; lines->push_back(line); found_horizontal_edge = true; // if this is a top or bottom edge, we can stop looping through edges // because we won't find anything interesting if (line.edge_type != feHorizontal) return; } else if (a->z == slice_z) { IntersectionPoint point; point.x = a->x; point.y = a->y; point.point_id = a_id; points.push_back(point); points_on_layer.push_back(points.size()-1); } else if (b->z == slice_z) { IntersectionPoint point; point.x = b->x; point.y = b->y; point.point_id = b_id; points.push_back(point); points_on_layer.push_back(points.size()-1); } else if ((a->z < slice_z && b->z > slice_z) || (b->z < slice_z && a->z > slice_z)) { // edge intersects the current layer; calculate intersection IntersectionPoint point; point.x = b->x + (a->x - b->x) * (slice_z - b->z) / (a->z - b->z); point.y = b->y + (a->y - b->y) * (slice_z - b->z) / (a->z - b->z); point.edge_id = edge_id; points.push_back(point); } } if (found_horizontal_edge) return; if (!points_on_layer.empty()) { // we can't have only one point on layer because each vertex gets detected // twice (once for each edge), and we can't have three points on layer because // we assume this code is not getting called for horizontal facets assert(points_on_layer.size() == 2); assert( points[ points_on_layer[0] ].point_id == points[ points_on_layer[1] ].point_id ); if (points.size() < 3) return; // no intersection point, this is a V-shaped facet tangent to plane points.erase( points.begin() + points_on_layer[1] ); } if (!points.empty()) { assert(points.size() == 2); // facets must intersect each plane 0 or 2 times IntersectionLine line; line.a = (Point)points[1]; line.b = (Point)points[0]; line.a_id = points[1].point_id; line.b_id = points[0].point_id; line.edge_a_id = points[1].edge_id; line.edge_b_id = points[0].edge_id; lines->push_back(line); return; } } void TriangleMeshSlicer::make_loops(std::vector &lines, Polygons* loops) { /* SVG svg("lines.svg"); svg.draw(lines); svg.Close(); */ // remove tangent edges for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++line) { if (line->skip || line->edge_type == feNone) continue; /* if the line is a facet edge, find another facet edge having the same endpoints but in reverse order */ for (IntersectionLines::iterator line2 = line + 1; line2 != lines.end(); ++line2) { if (line2->skip || line2->edge_type == feNone) continue; // are these facets adjacent? (sharing a common edge on this layer) if (line->a_id == line2->a_id && line->b_id == line2->b_id) { line2->skip = true; /* if they are both oriented upwards or downwards (like a 'V') then we can remove both edges from this layer since it won't affect the sliced shape */ /* if one of them is oriented upwards and the other is oriented downwards, let's only keep one of them (it doesn't matter which one since all 'top' lines were reversed at slicing) */ if (line->edge_type == line2->edge_type) { line->skip = true; break; } } else if (line->a_id == line2->b_id && line->b_id == line2->a_id) { /* if this edge joins two horizontal facets, remove both of them */ if (line->edge_type == feHorizontal && line2->edge_type == feHorizontal) { line->skip = true; line2->skip = true; break; } } } } // build a map of lines by edge_a_id and a_id std::vector by_edge_a_id, by_a_id; by_edge_a_id.resize(this->mesh->stl.stats.number_of_facets * 3); by_a_id.resize(this->mesh->stl.stats.shared_vertices); for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++line) { if (line->skip) continue; if (line->edge_a_id != -1) by_edge_a_id[line->edge_a_id].push_back(&(*line)); if (line->a_id != -1) by_a_id[line->a_id].push_back(&(*line)); } CYCLE: while (1) { // take first spare line and start a new loop IntersectionLine* first_line = NULL; for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++line) { if (line->skip) continue; first_line = &(*line); break; } if (first_line == NULL) break; first_line->skip = true; IntersectionLinePtrs loop; loop.push_back(first_line); /* printf("first_line edge_a_id = %d, edge_b_id = %d, a_id = %d, b_id = %d, a = %d,%d, b = %d,%d\n", first_line->edge_a_id, first_line->edge_b_id, first_line->a_id, first_line->b_id, first_line->a.x, first_line->a.y, first_line->b.x, first_line->b.y); */ while (1) { // find a line starting where last one finishes IntersectionLine* next_line = NULL; if (loop.back()->edge_b_id != -1) { IntersectionLinePtrs &candidates = by_edge_a_id[loop.back()->edge_b_id]; for (IntersectionLinePtrs::iterator lineptr = candidates.begin(); lineptr != candidates.end(); ++lineptr) { if ((*lineptr)->skip) continue; next_line = *lineptr; break; } } if (next_line == NULL && loop.back()->b_id != -1) { IntersectionLinePtrs &candidates = by_a_id[loop.back()->b_id]; for (IntersectionLinePtrs::iterator lineptr = candidates.begin(); lineptr != candidates.end(); ++lineptr) { if ((*lineptr)->skip) continue; next_line = *lineptr; break; } } if (next_line == NULL) { // check whether we closed this loop if ((loop.front()->edge_a_id != -1 && loop.front()->edge_a_id == loop.back()->edge_b_id) || (loop.front()->a_id != -1 && loop.front()->a_id == loop.back()->b_id)) { // loop is complete Polygon p; p.points.reserve(loop.size()); for (IntersectionLinePtrs::const_iterator lineptr = loop.begin(); lineptr != loop.end(); ++lineptr) { p.points.push_back((*lineptr)->a); } loops->push_back(p); #ifdef SLIC3R_TRIANGLEMESH_DEBUG printf(" Discovered %s polygon of %d points\n", (p.is_counter_clockwise() ? "ccw" : "cw"), (int)p.points.size()); #endif goto CYCLE; } // we can't close this loop! //// push @failed_loops, [@loop]; //#ifdef SLIC3R_TRIANGLEMESH_DEBUG printf(" Unable to close this loop having %d points\n", (int)loop.size()); //#endif goto CYCLE; } /* printf("next_line edge_a_id = %d, edge_b_id = %d, a_id = %d, b_id = %d, a = %d,%d, b = %d,%d\n", next_line->edge_a_id, next_line->edge_b_id, next_line->a_id, next_line->b_id, next_line->a.x, next_line->a.y, next_line->b.x, next_line->b.y); */ loop.push_back(next_line); next_line->skip = true; } } } class _area_comp { public: _area_comp(std::vector* _aa) : abs_area(_aa) {}; bool operator() (const size_t &a, const size_t &b) { return (*this->abs_area)[a] > (*this->abs_area)[b]; } private: std::vector* abs_area; }; void TriangleMeshSlicer::make_expolygons_simple(std::vector &lines, ExPolygons* slices) { Polygons loops; this->make_loops(lines, &loops); Polygons cw; for (Polygons::const_iterator loop = loops.begin(); loop != loops.end(); ++loop) { if (loop->area() >= 0) { ExPolygon ex; ex.contour = *loop; slices->push_back(ex); } else { cw.push_back(*loop); } } // assign holes to contours for (Polygons::const_iterator loop = cw.begin(); loop != cw.end(); ++loop) { int slice_idx = -1; double current_contour_area = -1; for (ExPolygons::iterator slice = slices->begin(); slice != slices->end(); ++slice) { if (slice->contour.contains(loop->points.front())) { double area = slice->contour.area(); if (area < current_contour_area || current_contour_area == -1) { slice_idx = slice - slices->begin(); current_contour_area = area; } } } (*slices)[slice_idx].holes.push_back(*loop); } } void TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) { /* Input loops are not suitable for evenodd nor nonzero fill types, as we might get two consecutive concentric loops having the same winding order - and we have to respect such order. In that case, evenodd would create wrong inversions, and nonzero would ignore holes inside two concentric contours. So we're ordering loops and collapse consecutive concentric loops having the same winding order. TODO: find a faster algorithm for this, maybe with some sort of binary search. If we computed a "nesting tree" we could also just remove the consecutive loops having the same winding order, and remove the extra one(s) so that we could just supply everything to offset() instead of performing several union/diff calls. we sort by area assuming that the outermost loops have larger area; the previous sorting method, based on $b->contains($a->[0]), failed to nest loops correctly in some edge cases when original model had overlapping facets */ std::vector area; std::vector abs_area; std::vector sorted_area; // vector of indices for (Polygons::const_iterator loop = loops.begin(); loop != loops.end(); ++loop) { double a = loop->area(); area.push_back(a); abs_area.push_back(std::fabs(a)); sorted_area.push_back(loop - loops.begin()); } std::sort(sorted_area.begin(), sorted_area.end(), _area_comp(&abs_area)); // outer first // we don't perform a safety offset now because it might reverse cw loops Polygons p_slices; for (std::vector::const_iterator loop_idx = sorted_area.begin(); loop_idx != sorted_area.end(); ++loop_idx) { /* we rely on the already computed area to determine the winding order of the loops, since the Orientation() function provided by Clipper would do the same, thus repeating the calculation */ Polygons::const_iterator loop = loops.begin() + *loop_idx; if (area[*loop_idx] > +EPSILON) { p_slices.push_back(*loop); } else if (area[*loop_idx] < -EPSILON) { diff(p_slices, *loop, &p_slices); } } // perform a safety offset to merge very close facets (TODO: find test case for this) double safety_offset = scale_(0.0499); ExPolygons ex_slices; offset2(p_slices, &ex_slices, +safety_offset, -safety_offset); #ifdef SLIC3R_TRIANGLEMESH_DEBUG size_t holes_count = 0; for (ExPolygons::const_iterator e = ex_slices.begin(); e != ex_slices.end(); ++e) { holes_count += e->holes.size(); } printf(PRINTF_ZU " surface(s) having " PRINTF_ZU " holes detected from " PRINTF_ZU " polylines\n", ex_slices.size(), holes_count, loops.size()); #endif // append to the supplied collection slices->insert(slices->end(), ex_slices.begin(), ex_slices.end()); } void TriangleMeshSlicer::make_expolygons(std::vector &lines, ExPolygons* slices) { Polygons pp; this->make_loops(lines, &pp); this->make_expolygons(pp, slices); } void TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower) { IntersectionLines upper_lines, lower_lines; float scaled_z = scale_(z); for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; facet_idx++) { stl_facet* facet = &this->mesh->stl.facet_start[facet_idx]; // find facet extents float min_z = fminf(facet->vertex[0].z, fminf(facet->vertex[1].z, facet->vertex[2].z)); float max_z = fmaxf(facet->vertex[0].z, fmaxf(facet->vertex[1].z, facet->vertex[2].z)); // intersect facet with cutting plane IntersectionLines lines; this->slice_facet(scaled_z, *facet, facet_idx, min_z, max_z, &lines); // save intersection lines for generating correct triangulations for (IntersectionLines::const_iterator it = lines.begin(); it != lines.end(); ++it) { if (it->edge_type == feTop) { lower_lines.push_back(*it); } else if (it->edge_type == feBottom) { upper_lines.push_back(*it); } else if (it->edge_type != feHorizontal) { lower_lines.push_back(*it); upper_lines.push_back(*it); } } if (min_z > z || (min_z == z && max_z > min_z)) { // facet is above the cut plane and does not belong to it if (upper != NULL) stl_add_facet(&upper->stl, facet); } else if (max_z < z || (max_z == z && max_z > min_z)) { // facet is below the cut plane and does not belong to it if (lower != NULL) stl_add_facet(&lower->stl, facet); } else if (min_z < z && max_z > z) { // facet is cut by the slicing plane // look for the vertex on whose side of the slicing plane there are no other vertices int isolated_vertex; if ( (facet->vertex[0].z > z) == (facet->vertex[1].z > z) ) { isolated_vertex = 2; } else if ( (facet->vertex[1].z > z) == (facet->vertex[2].z > z) ) { isolated_vertex = 0; } else { isolated_vertex = 1; } // get vertices starting from the isolated one stl_vertex* v0 = &facet->vertex[isolated_vertex]; stl_vertex* v1 = &facet->vertex[(isolated_vertex+1) % 3]; stl_vertex* v2 = &facet->vertex[(isolated_vertex+2) % 3]; // intersect v0-v1 and v2-v0 with cutting plane and make new vertices stl_vertex v0v1, v2v0; v0v1.x = v1->x + (v0->x - v1->x) * (z - v1->z) / (v0->z - v1->z); v0v1.y = v1->y + (v0->y - v1->y) * (z - v1->z) / (v0->z - v1->z); v0v1.z = z; v2v0.x = v2->x + (v0->x - v2->x) * (z - v2->z) / (v0->z - v2->z); v2v0.y = v2->y + (v0->y - v2->y) * (z - v2->z) / (v0->z - v2->z); v2v0.z = z; // build the triangular facet stl_facet triangle; triangle.normal = facet->normal; triangle.vertex[0] = *v0; triangle.vertex[1] = v0v1; triangle.vertex[2] = v2v0; // build the facets forming a quadrilateral on the other side stl_facet quadrilateral[2]; quadrilateral[0].normal = facet->normal; quadrilateral[0].vertex[0] = *v1; quadrilateral[0].vertex[1] = *v2; quadrilateral[0].vertex[2] = v0v1; quadrilateral[1].normal = facet->normal; quadrilateral[1].vertex[0] = *v2; quadrilateral[1].vertex[1] = v2v0; quadrilateral[1].vertex[2] = v0v1; if (v0->z > z) { if (upper != NULL) stl_add_facet(&upper->stl, &triangle); if (lower != NULL) { stl_add_facet(&lower->stl, &quadrilateral[0]); stl_add_facet(&lower->stl, &quadrilateral[1]); } } else { if (upper != NULL) { stl_add_facet(&upper->stl, &quadrilateral[0]); stl_add_facet(&upper->stl, &quadrilateral[1]); } if (lower != NULL) stl_add_facet(&lower->stl, &triangle); } } } // triangulate holes of upper mesh if (upper != NULL) { // compute shape of section ExPolygons section; this->make_expolygons_simple(upper_lines, §ion); // triangulate section Polygons triangles; for (ExPolygons::const_iterator expolygon = section.begin(); expolygon != section.end(); ++expolygon) expolygon->triangulate_p2t(&triangles); // convert triangles to facets and append them to mesh for (Polygons::const_iterator polygon = triangles.begin(); polygon != triangles.end(); ++polygon) { Polygon p = *polygon; p.reverse(); stl_facet facet; facet.normal.x = 0; facet.normal.y = 0; facet.normal.z = -1; for (size_t i = 0; i <= 2; ++i) { facet.vertex[i].x = unscale(p.points[i].x); facet.vertex[i].y = unscale(p.points[i].y); facet.vertex[i].z = z; } stl_add_facet(&upper->stl, &facet); } } // triangulate holes of lower mesh if (lower != NULL) { // compute shape of section ExPolygons section; this->make_expolygons_simple(lower_lines, §ion); // triangulate section Polygons triangles; for (ExPolygons::const_iterator expolygon = section.begin(); expolygon != section.end(); ++expolygon) expolygon->triangulate_p2t(&triangles); // convert triangles to facets and append them to mesh for (Polygons::const_iterator polygon = triangles.begin(); polygon != triangles.end(); ++polygon) { stl_facet facet; facet.normal.x = 0; facet.normal.y = 0; facet.normal.z = 1; for (size_t i = 0; i <= 2; ++i) { facet.vertex[i].x = unscale(polygon->points[i].x); facet.vertex[i].y = unscale(polygon->points[i].y); facet.vertex[i].z = z; } stl_add_facet(&lower->stl, &facet); } } stl_get_size(&(upper->stl)); stl_get_size(&(lower->stl)); } TriangleMeshSlicer::TriangleMeshSlicer(TriangleMesh* _mesh) : mesh(_mesh), v_scaled_shared(NULL) { // build a table to map a facet_idx to its three edge indices this->mesh->require_shared_vertices(); typedef std::pair t_edge; typedef std::vector t_edges; // edge_idx => a_id,b_id typedef std::map t_edges_map; // a_id,b_id => edge_idx this->facets_edges.resize(this->mesh->stl.stats.number_of_facets); { t_edges edges; // reserve() instad of resize() because otherwise we couldn't read .size() below to assign edge_idx edges.reserve(this->mesh->stl.stats.number_of_facets * 3); // number of edges = number of facets * 3 t_edges_map edges_map; for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; facet_idx++) { this->facets_edges[facet_idx].resize(3); for (int i = 0; i <= 2; i++) { int a_id = this->mesh->stl.v_indices[facet_idx].vertex[i]; int b_id = this->mesh->stl.v_indices[facet_idx].vertex[(i+1) % 3]; int edge_idx; t_edges_map::const_iterator my_edge = edges_map.find(std::make_pair(b_id,a_id)); if (my_edge != edges_map.end()) { edge_idx = my_edge->second; } else { /* admesh can assign the same edge ID to more than two facets (which is still topologically correct), so we have to search for a duplicate of this edge too in case it was already seen in this orientation */ my_edge = edges_map.find(std::make_pair(a_id,b_id)); if (my_edge != edges_map.end()) { edge_idx = my_edge->second; } else { // edge isn't listed in table, so we insert it edge_idx = edges.size(); edges.push_back(std::make_pair(a_id,b_id)); edges_map[ edges[edge_idx] ] = edge_idx; } } this->facets_edges[facet_idx][i] = edge_idx; #ifdef SLIC3R_TRIANGLEMESH_DEBUG printf(" [facet %d, edge %d] a_id = %d, b_id = %d --> edge %d\n", facet_idx, i, a_id, b_id, edge_idx); #endif } } } // clone shared vertices coordinates and scale them this->v_scaled_shared = (stl_vertex*)calloc(this->mesh->stl.stats.shared_vertices, sizeof(stl_vertex)); std::copy(this->mesh->stl.v_shared, this->mesh->stl.v_shared + this->mesh->stl.stats.shared_vertices, this->v_scaled_shared); for (int i = 0; i < this->mesh->stl.stats.shared_vertices; i++) { this->v_scaled_shared[i].x /= SCALING_FACTOR; this->v_scaled_shared[i].y /= SCALING_FACTOR; this->v_scaled_shared[i].z /= SCALING_FACTOR; } } TriangleMeshSlicer::~TriangleMeshSlicer() { if (this->v_scaled_shared != NULL) free(this->v_scaled_shared); } } ��������������������Slic3r-version_1.31.6/xs/src/libslic3r/TriangleMesh.hpp���������������������������������������������0000664�0000000�0000000�00000006311�13014417200�0022701�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef slic3r_TriangleMesh_hpp_ #define slic3r_TriangleMesh_hpp_ #include "libslic3r.h" #include #include #include "BoundingBox.hpp" #include "Line.hpp" #include "Point.hpp" #include "Polygon.hpp" #include "ExPolygon.hpp" namespace Slic3r { class TriangleMesh; class TriangleMeshSlicer; typedef std::vector TriangleMeshPtrs; class TriangleMesh { public: TriangleMesh(); TriangleMesh(const TriangleMesh &other); TriangleMesh& operator= (TriangleMesh other); void swap(TriangleMesh &other); ~TriangleMesh(); void ReadSTLFile(char* input_file); void write_ascii(char* output_file); void write_binary(char* output_file); void repair(); void WriteOBJFile(char* output_file); void scale(float factor); void scale(const Pointf3 &versor); void translate(float x, float y, float z); void rotate(float angle, const Axis &axis); void rotate_x(float angle); void rotate_y(float angle); void rotate_z(float angle); void mirror(const Axis &axis); void mirror_x(); void mirror_y(); void mirror_z(); void align_to_origin(); void rotate(double angle, Point* center); TriangleMeshPtrs split() const; void merge(const TriangleMesh &mesh); ExPolygons horizontal_projection() const; Polygon convex_hull(); BoundingBoxf3 bounding_box() const; void reset_repair_stats(); bool needed_repair() const; size_t facets_count() const; stl_file stl; bool repaired; private: void require_shared_vertices(); friend class TriangleMeshSlicer; }; enum FacetEdgeType { feNone, feTop, feBottom, feHorizontal }; class IntersectionPoint : public Point { public: int point_id; int edge_id; IntersectionPoint() : point_id(-1), edge_id(-1) {}; }; class IntersectionLine : public Line { public: int a_id; int b_id; int edge_a_id; int edge_b_id; FacetEdgeType edge_type; bool skip; IntersectionLine() : a_id(-1), b_id(-1), edge_a_id(-1), edge_b_id(-1), edge_type(feNone), skip(false) {}; }; typedef std::vector IntersectionLines; typedef std::vector IntersectionLinePtrs; class TriangleMeshSlicer { public: TriangleMesh* mesh; TriangleMeshSlicer(TriangleMesh* _mesh); ~TriangleMeshSlicer(); void slice(const std::vector &z, std::vector* layers); void slice(const std::vector &z, std::vector* layers); void slice_facet(float slice_z, const stl_facet &facet, const int &facet_idx, const float &min_z, const float &max_z, std::vector* lines) const; void cut(float z, TriangleMesh* upper, TriangleMesh* lower); private: typedef std::vector< std::vector > t_facets_edges; t_facets_edges facets_edges; stl_vertex* v_scaled_shared; void make_loops(std::vector &lines, Polygons* loops); void make_expolygons(const Polygons &loops, ExPolygons* slices); void make_expolygons_simple(std::vector &lines, ExPolygons* slices); void make_expolygons(std::vector &lines, ExPolygons* slices); }; } #endif �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/libslic3r.h��������������������������������������������������0000664�0000000�0000000�00000006046�13014417200�0021652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef _libslic3r_h_ #define _libslic3r_h_ // this needs to be included early for MSVC (listing it in Build.PL is not enough) #include #include #include #include #include #include #define SLIC3R_FORK_NAME "Slic3r Prusa Edition" #define SLIC3R_VERSION "1.31.6" //FIXME This epsilon value is used for many non-related purposes: // For a threshold of a squared Euclidean distance, // for a trheshold in a difference of radians, // for a threshold of a cross product of two non-normalized vectors etc. #define EPSILON 1e-4 // Scaling factor for a conversion from coord_t to coordf_t: 10e-6 // This scaling generates a following fixed point representation with for a 32bit integer: // 0..4294mm with 1nm resolution // int32_t fits an interval of (-2147.48mm, +2147.48mm) #define SCALING_FACTOR 0.000001 // RESOLUTION, SCALED_RESOLUTION: Used as an error threshold for a Douglas-Peucker polyline simplification algorithm. #define RESOLUTION 0.0125 #define SCALED_RESOLUTION (RESOLUTION / SCALING_FACTOR) #define PI 3.141592653589793238 // When extruding a closed loop, the loop is interrupted and shortened a bit to reduce the seam. #define LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER 0.15 // Maximum perimeter length for the loop to apply the small perimeter speed. #define SMALL_PERIMETER_LENGTH (6.5 / SCALING_FACTOR) * 2 * PI #define INSET_OVERLAP_TOLERANCE 0.4 // 3mm ring around the top / bottom / bridging areas. //FIXME This is quite a lot. #define EXTERNAL_INFILL_MARGIN 3. #define scale_(val) ((val) / SCALING_FACTOR) #define unscale(val) ((val) * SCALING_FACTOR) #define SCALED_EPSILON scale_(EPSILON) typedef long coord_t; typedef double coordf_t; namespace Slic3r { enum Axis { X=0, Y, Z }; } using namespace Slic3r; /* Implementation of CONFESS("foo"): */ #ifdef _MSC_VER #define CONFESS(...) confess_at(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__) #else #define CONFESS(...) confess_at(__FILE__, __LINE__, __func__, __VA_ARGS__) #endif void confess_at(const char *file, int line, const char *func, const char *pat, ...); /* End implementation of CONFESS("foo"): */ // Which C++ version is supported? // For example, could optimized functions with move semantics be used? #if __cplusplus==201402L #define SLIC3R_CPPVER 14 #define STDMOVE(WHAT) std::move(WHAT) #elif __cplusplus==201103L #define SLIC3R_CPPVER 11 #define STDMOVE(WHAT) std::move(WHAT) #else #define SLIC3R_CPPVER 0 #define STDMOVE(WHAT) (WHAT) #endif #define SLIC3R_DEBUG_OUT_PATH_PREFIX "out/" inline std::string debug_out_path(const char *name, ...) { char buffer[2048]; va_list args; va_start(args, name); std::vsprintf(buffer, name, args); va_end(args); return std::string(SLIC3R_DEBUG_OUT_PATH_PREFIX) + std::string(buffer); } #ifdef _MSC_VER // Visual Studio older than 2015 does not support the prinf type specifier %zu. Use %Iu instead. #define PRINTF_ZU "%Iu" #else #define PRINTF_ZU "%zu" #endif // Write slices as SVG images into out directory during the 2D processing of the slices. // #define SLIC3R_DEBUG_SLICE_PROCESSING #endif ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/libslic3r/utils.cpp����������������������������������������������������0000664�0000000�0000000�00000003047�13014417200�0021455�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifdef SLIC3R_HAS_BROKEN_CROAK // Some Strawberry Perl builds (mainly the latest 64bit builds) have a broken mechanism // for emiting Perl exception after handling a C++ exception. Perl interpreter // simply hangs. Better to show a message box in that case and stop the application. #include #include #include #include #ifdef WIN32 #include #endif void confess_at(const char *file, int line, const char *func, const char *format, ...) { char dest[1024*8]; va_list argptr; va_start(argptr, format); vsprintf(dest, format, argptr); va_end(argptr); char filelinefunc[1024*8]; sprintf(filelinefunc, "\r\nin function: %s\r\nfile: %s\r\nline: %d\r\n", func, file, line); strcat(dest, filelinefunc); strcat(dest, "\r\n Closing the application.\r\n"); #ifdef WIN32 ::MessageBoxA(NULL, dest, "Slic3r Prusa Edition", MB_OK | MB_ICONERROR); #endif // Give up. printf(dest); exit(-1); } #else #include void confess_at(const char *file, int line, const char *func, const char *pat, ...) { #ifdef SLIC3RXS va_list args; SV *error_sv = newSVpvf("Error in function %s at %s:%d: ", func, file, line); va_start(args, pat); sv_vcatpvf(error_sv, pat, &args); va_end(args); sv_catpvn(error_sv, "\n\t", 2); dSP; ENTER; SAVETMPS; PUSHMARK(SP); XPUSHs( sv_2mortal(error_sv) ); PUTBACK; call_pv("Carp::confess", G_DISCARD); FREETMPS; LEAVE; #endif } #endif �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/perlglue.cpp�����������������������������������������������������������0000664�0000000�0000000�00000047640�13014417200�0020255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifdef SLIC3RXS #include namespace Slic3r { REGISTER_CLASS(ExPolygon, "ExPolygon"); REGISTER_CLASS(ExPolygonCollection, "ExPolygon::Collection"); REGISTER_CLASS(Extruder, "Extruder"); REGISTER_CLASS(ExtrusionPath, "ExtrusionPath"); REGISTER_CLASS(ExtrusionLoop, "ExtrusionLoop"); // there is no ExtrusionLoop::Collection or ExtrusionEntity::Collection REGISTER_CLASS(ExtrusionEntityCollection, "ExtrusionPath::Collection"); REGISTER_CLASS(ExtrusionSimulator, "ExtrusionSimulator"); REGISTER_CLASS(Filler, "Filler"); REGISTER_CLASS(Flow, "Flow"); REGISTER_CLASS(AvoidCrossingPerimeters, "GCode::AvoidCrossingPerimeters"); REGISTER_CLASS(OozePrevention, "GCode::OozePrevention"); REGISTER_CLASS(Wipe, "GCode::Wipe"); REGISTER_CLASS(GCode, "GCode"); REGISTER_CLASS(GCodeSender, "GCode::Sender"); REGISTER_CLASS(GCodeWriter, "GCode::Writer"); REGISTER_CLASS(GCodePressureEqualizer, "GCode::PressureEqualizer"); REGISTER_CLASS(Layer, "Layer"); REGISTER_CLASS(SupportLayer, "Layer::Support"); REGISTER_CLASS(LayerRegion, "Layer::Region"); REGISTER_CLASS(Line, "Line"); REGISTER_CLASS(Linef3, "Linef3"); REGISTER_CLASS(PerimeterGenerator, "Layer::PerimeterGenerator"); REGISTER_CLASS(PlaceholderParser, "GCode::PlaceholderParser"); REGISTER_CLASS(Polygon, "Polygon"); REGISTER_CLASS(Polyline, "Polyline"); REGISTER_CLASS(PolylineCollection, "Polyline::Collection"); REGISTER_CLASS(Print, "Print"); REGISTER_CLASS(PrintObject, "Print::Object"); REGISTER_CLASS(PrintRegion, "Print::Region"); REGISTER_CLASS(Model, "Model"); REGISTER_CLASS(ModelMaterial, "Model::Material"); REGISTER_CLASS(ModelObject, "Model::Object"); REGISTER_CLASS(ModelVolume, "Model::Volume"); REGISTER_CLASS(ModelInstance, "Model::Instance"); REGISTER_CLASS(MotionPlanner, "MotionPlanner"); REGISTER_CLASS(BoundingBox, "Geometry::BoundingBox"); REGISTER_CLASS(BoundingBoxf, "Geometry::BoundingBoxf"); REGISTER_CLASS(BoundingBoxf3, "Geometry::BoundingBoxf3"); REGISTER_CLASS(BridgeDetector, "BridgeDetector"); REGISTER_CLASS(Point, "Point"); REGISTER_CLASS(Point3, "Point3"); REGISTER_CLASS(Pointf, "Pointf"); REGISTER_CLASS(Pointf3, "Pointf3"); REGISTER_CLASS(DynamicPrintConfig, "Config"); REGISTER_CLASS(StaticPrintConfig, "Config::Static"); REGISTER_CLASS(PrintObjectConfig, "Config::PrintObject"); REGISTER_CLASS(PrintRegionConfig, "Config::PrintRegion"); REGISTER_CLASS(GCodeConfig, "Config::GCode"); REGISTER_CLASS(PrintConfig, "Config::Print"); REGISTER_CLASS(FullPrintConfig, "Config::Full"); REGISTER_CLASS(Surface, "Surface"); REGISTER_CLASS(SurfaceCollection, "Surface::Collection"); REGISTER_CLASS(PrintObjectSupportMaterial, "Print::SupportMaterial2"); REGISTER_CLASS(TriangleMesh, "TriangleMesh"); REGISTER_CLASS(GLVertexArray, "GUI::_3DScene::GLVertexArray"); SV* ConfigBase__as_hash(ConfigBase* THIS) { HV* hv = newHV(); t_config_option_keys opt_keys = THIS->keys(); for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) (void)hv_store( hv, it->c_str(), it->length(), ConfigBase__get(THIS, *it), 0 ); return newRV_noinc((SV*)hv); } SV* ConfigBase__get(ConfigBase* THIS, const t_config_option_key &opt_key) { ConfigOption* opt = THIS->option(opt_key); if (opt == NULL) return &PL_sv_undef; const ConfigOptionDef* def = THIS->def->get(opt_key); return ConfigOption_to_SV(*opt, *def); } SV* ConfigOption_to_SV(const ConfigOption &opt, const ConfigOptionDef &def) { if (def.type == coFloat) { const ConfigOptionFloat* optv = dynamic_cast(&opt); return newSVnv(optv->value); } else if (def.type == coFloats) { const ConfigOptionFloats* optv = dynamic_cast(&opt); AV* av = newAV(); av_fill(av, optv->values.size()-1); for (std::vector::const_iterator it = optv->values.begin(); it != optv->values.end(); ++it) av_store(av, it - optv->values.begin(), newSVnv(*it)); return newRV_noinc((SV*)av); } else if (def.type == coPercent) { const ConfigOptionPercent* optv = dynamic_cast(&opt); return newSVnv(optv->value); } else if (def.type == coInt) { const ConfigOptionInt* optv = dynamic_cast(&opt); return newSViv(optv->value); } else if (def.type == coInts) { const ConfigOptionInts* optv = dynamic_cast(&opt); AV* av = newAV(); av_fill(av, optv->values.size()-1); for (std::vector::const_iterator it = optv->values.begin(); it != optv->values.end(); ++it) av_store(av, it - optv->values.begin(), newSViv(*it)); return newRV_noinc((SV*)av); } else if (def.type == coString) { const ConfigOptionString* optv = dynamic_cast(&opt); // we don't serialize() because that would escape newlines return newSVpvn_utf8(optv->value.c_str(), optv->value.length(), true); } else if (def.type == coStrings) { const ConfigOptionStrings* optv = dynamic_cast(&opt); AV* av = newAV(); av_fill(av, optv->values.size()-1); for (std::vector::const_iterator it = optv->values.begin(); it != optv->values.end(); ++it) av_store(av, it - optv->values.begin(), newSVpvn_utf8(it->c_str(), it->length(), true)); return newRV_noinc((SV*)av); } else if (def.type == coPoint) { const ConfigOptionPoint* optv = dynamic_cast(&opt); return perl_to_SV_clone_ref(optv->value); } else if (def.type == coPoints) { const ConfigOptionPoints* optv = dynamic_cast(&opt); AV* av = newAV(); av_fill(av, optv->values.size()-1); for (Pointfs::const_iterator it = optv->values.begin(); it != optv->values.end(); ++it) av_store(av, it - optv->values.begin(), perl_to_SV_clone_ref(*it)); return newRV_noinc((SV*)av); } else if (def.type == coBool) { const ConfigOptionBool* optv = dynamic_cast(&opt); return newSViv(optv->value ? 1 : 0); } else if (def.type == coBools) { const ConfigOptionBools* optv = dynamic_cast(&opt); AV* av = newAV(); av_fill(av, optv->values.size()-1); for (std::vector::const_iterator it = optv->values.begin(); it != optv->values.end(); ++it) av_store(av, it - optv->values.begin(), newSViv(*it ? 1 : 0)); return newRV_noinc((SV*)av); } else { std::string serialized = opt.serialize(); return newSVpvn_utf8(serialized.c_str(), serialized.length(), true); } } SV* ConfigBase__get_at(ConfigBase* THIS, const t_config_option_key &opt_key, size_t i) { ConfigOption* opt = THIS->option(opt_key); if (opt == NULL) return &PL_sv_undef; const ConfigOptionDef* def = THIS->def->get(opt_key); if (def->type == coFloats) { ConfigOptionFloats* optv = dynamic_cast(opt); return newSVnv(optv->get_at(i)); } else if (def->type == coInts) { ConfigOptionInts* optv = dynamic_cast(opt); return newSViv(optv->get_at(i)); } else if (def->type == coStrings) { ConfigOptionStrings* optv = dynamic_cast(opt); // we don't serialize() because that would escape newlines std::string val = optv->get_at(i); return newSVpvn_utf8(val.c_str(), val.length(), true); } else if (def->type == coPoints) { ConfigOptionPoints* optv = dynamic_cast(opt); return perl_to_SV_clone_ref(optv->get_at(i)); } else if (def->type == coBools) { ConfigOptionBools* optv = dynamic_cast(opt); return newSViv(optv->get_at(i) ? 1 : 0); } else { return &PL_sv_undef; } } bool ConfigBase__set(ConfigBase* THIS, const t_config_option_key &opt_key, SV* value) { ConfigOption* opt = THIS->option(opt_key, true); if (opt == NULL) CONFESS("Trying to set non-existing option"); const ConfigOptionDef* def = THIS->def->get(opt_key); if (def->type == coFloat) { if (!looks_like_number(value)) return false; ConfigOptionFloat* optv = dynamic_cast(opt); optv->value = SvNV(value); } else if (def->type == coFloats) { ConfigOptionFloats* optv = dynamic_cast(opt); std::vector values; AV* av = (AV*)SvRV(value); const size_t len = av_len(av)+1; for (size_t i = 0; i < len; i++) { SV** elem = av_fetch(av, i, 0); if (elem == NULL || !looks_like_number(*elem)) return false; values.push_back(SvNV(*elem)); } optv->values = values; } else if (def->type == coInt) { if (!looks_like_number(value)) return false; ConfigOptionInt* optv = dynamic_cast(opt); optv->value = SvIV(value); } else if (def->type == coInts) { ConfigOptionInts* optv = dynamic_cast(opt); std::vector values; AV* av = (AV*)SvRV(value); const size_t len = av_len(av)+1; for (size_t i = 0; i < len; i++) { SV** elem = av_fetch(av, i, 0); if (elem == NULL || !looks_like_number(*elem)) return false; values.push_back(SvIV(*elem)); } optv->values = values; } else if (def->type == coString) { ConfigOptionString* optv = dynamic_cast(opt); optv->value = std::string(SvPV_nolen(value), SvCUR(value)); } else if (def->type == coStrings) { ConfigOptionStrings* optv = dynamic_cast(opt); optv->values.clear(); AV* av = (AV*)SvRV(value); const size_t len = av_len(av)+1; for (size_t i = 0; i < len; i++) { SV** elem = av_fetch(av, i, 0); if (elem == NULL) return false; optv->values.push_back(std::string(SvPV_nolen(*elem), SvCUR(*elem))); } } else if (def->type == coPoint) { ConfigOptionPoint* optv = dynamic_cast(opt); return from_SV_check(value, &optv->value); } else if (def->type == coPoints) { ConfigOptionPoints* optv = dynamic_cast(opt); std::vector values; AV* av = (AV*)SvRV(value); const size_t len = av_len(av)+1; for (size_t i = 0; i < len; i++) { SV** elem = av_fetch(av, i, 0); Pointf point; if (elem == NULL || !from_SV_check(*elem, &point)) return false; values.push_back(point); } optv->values = values; } else if (def->type == coBool) { ConfigOptionBool* optv = dynamic_cast(opt); optv->value = SvTRUE(value); } else if (def->type == coBools) { ConfigOptionBools* optv = dynamic_cast(opt); optv->values.clear(); AV* av = (AV*)SvRV(value); const size_t len = av_len(av)+1; for (size_t i = 0; i < len; i++) { SV** elem = av_fetch(av, i, 0); if (elem == NULL) return false; optv->values.push_back(SvTRUE(*elem)); } } else { if (!opt->deserialize( std::string(SvPV_nolen(value)) )) return false; } return true; } /* This method is implemented as a workaround for this typemap bug: https://rt.cpan.org/Public/Bug/Display.html?id=94110 */ bool ConfigBase__set_deserialize(ConfigBase* THIS, const t_config_option_key &opt_key, SV* str) { size_t len; const char * c = SvPV(str, len); std::string value(c, len); return THIS->set_deserialize(opt_key, value); } void ConfigBase__set_ifndef(ConfigBase* THIS, const t_config_option_key &opt_key, SV* value, bool deserialize) { if (!THIS->has(opt_key)) { if (deserialize) { ConfigBase__set_deserialize(THIS, opt_key, value); } else { ConfigBase__set(THIS, opt_key, value); } } } bool StaticConfig__set(StaticConfig* THIS, const t_config_option_key &opt_key, SV* value) { const ConfigOptionDef* optdef = THIS->def->get(opt_key); if (!optdef->shortcut.empty()) { for (std::vector::const_iterator it = optdef->shortcut.begin(); it != optdef->shortcut.end(); ++it) { if (!StaticConfig__set(THIS, *it, value)) return false; } return true; } return ConfigBase__set(THIS, opt_key, value); } SV* to_AV(ExPolygon* expolygon) { const unsigned int num_holes = expolygon->holes.size(); AV* av = newAV(); av_extend(av, num_holes); // -1 +1 av_store(av, 0, perl_to_SV_ref(expolygon->contour)); for (unsigned int i = 0; i < num_holes; i++) { av_store(av, i+1, perl_to_SV_ref(expolygon->holes[i])); } return newRV_noinc((SV*)av); } SV* to_SV_pureperl(const ExPolygon* expolygon) { const unsigned int num_holes = expolygon->holes.size(); AV* av = newAV(); av_extend(av, num_holes); // -1 +1 av_store(av, 0, to_SV_pureperl(&expolygon->contour)); for (unsigned int i = 0; i < num_holes; i++) { av_store(av, i+1, to_SV_pureperl(&expolygon->holes[i])); } return newRV_noinc((SV*)av); } void from_SV(SV* expoly_sv, ExPolygon* expolygon) { AV* expoly_av = (AV*)SvRV(expoly_sv); const unsigned int num_polygons = av_len(expoly_av)+1; expolygon->holes.resize(num_polygons-1); SV** polygon_sv = av_fetch(expoly_av, 0, 0); from_SV(*polygon_sv, &expolygon->contour); for (unsigned int i = 0; i < num_polygons-1; i++) { polygon_sv = av_fetch(expoly_av, i+1, 0); from_SV(*polygon_sv, &expolygon->holes[i]); } } void from_SV_check(SV* expoly_sv, ExPolygon* expolygon) { if (sv_isobject(expoly_sv) && (SvTYPE(SvRV(expoly_sv)) == SVt_PVMG)) { if (!sv_isa(expoly_sv, perl_class_name(expolygon)) && !sv_isa(expoly_sv, perl_class_name_ref(expolygon))) CONFESS("Not a valid %s object", perl_class_name(expolygon)); // a XS ExPolygon was supplied *expolygon = *(ExPolygon *)SvIV((SV*)SvRV( expoly_sv )); } else { // a Perl arrayref was supplied from_SV(expoly_sv, expolygon); } } void from_SV(SV* line_sv, Line* THIS) { AV* line_av = (AV*)SvRV(line_sv); from_SV_check(*av_fetch(line_av, 0, 0), &THIS->a); from_SV_check(*av_fetch(line_av, 1, 0), &THIS->b); } void from_SV_check(SV* line_sv, Line* THIS) { if (sv_isobject(line_sv) && (SvTYPE(SvRV(line_sv)) == SVt_PVMG)) { if (!sv_isa(line_sv, perl_class_name(THIS)) && !sv_isa(line_sv, perl_class_name_ref(THIS))) CONFESS("Not a valid %s object", perl_class_name(THIS)); *THIS = *(Line*)SvIV((SV*)SvRV( line_sv )); } else { from_SV(line_sv, THIS); } } SV* to_AV(Line* THIS) { AV* av = newAV(); av_extend(av, 1); av_store(av, 0, perl_to_SV_ref(THIS->a)); av_store(av, 1, perl_to_SV_ref(THIS->b)); return newRV_noinc((SV*)av); } SV* to_SV_pureperl(const Line* THIS) { AV* av = newAV(); av_extend(av, 1); av_store(av, 0, to_SV_pureperl(&THIS->a)); av_store(av, 1, to_SV_pureperl(&THIS->b)); return newRV_noinc((SV*)av); } void from_SV(SV* poly_sv, MultiPoint* THIS) { AV* poly_av = (AV*)SvRV(poly_sv); const unsigned int num_points = av_len(poly_av)+1; THIS->points.resize(num_points); for (unsigned int i = 0; i < num_points; i++) { SV** point_sv = av_fetch(poly_av, i, 0); from_SV_check(*point_sv, &THIS->points[i]); } } void from_SV_check(SV* poly_sv, MultiPoint* THIS) { if (sv_isobject(poly_sv) && (SvTYPE(SvRV(poly_sv)) == SVt_PVMG)) { *THIS = *(MultiPoint*)SvIV((SV*)SvRV( poly_sv )); } else { from_SV(poly_sv, THIS); } } SV* to_AV(MultiPoint* THIS) { const unsigned int num_points = THIS->points.size(); AV* av = newAV(); if (num_points > 0) av_extend(av, num_points-1); for (unsigned int i = 0; i < num_points; i++) { av_store(av, i, perl_to_SV_ref(THIS->points[i])); } return newRV_noinc((SV*)av); } SV* to_SV_pureperl(const MultiPoint* THIS) { const unsigned int num_points = THIS->points.size(); AV* av = newAV(); if (num_points > 0) av_extend(av, num_points-1); for (unsigned int i = 0; i < num_points; i++) { av_store(av, i, to_SV_pureperl(&THIS->points[i])); } return newRV_noinc((SV*)av); } void from_SV_check(SV* poly_sv, Polygon* THIS) { if (sv_isobject(poly_sv) && !sv_isa(poly_sv, perl_class_name(THIS)) && !sv_isa(poly_sv, perl_class_name_ref(THIS))) CONFESS("Not a valid %s object", perl_class_name(THIS)); from_SV_check(poly_sv, (MultiPoint*)THIS); } void from_SV_check(SV* poly_sv, Polyline* THIS) { if (!sv_isa(poly_sv, perl_class_name(THIS)) && !sv_isa(poly_sv, perl_class_name_ref(THIS))) CONFESS("Not a valid %s object", perl_class_name(THIS)); from_SV_check(poly_sv, (MultiPoint*)THIS); } SV* to_SV_pureperl(const Point* THIS) { AV* av = newAV(); av_fill(av, 1); av_store(av, 0, newSViv(THIS->x)); av_store(av, 1, newSViv(THIS->y)); return newRV_noinc((SV*)av); } void from_SV(SV* point_sv, Point* point) { AV* point_av = (AV*)SvRV(point_sv); // get a double from Perl and round it, otherwise // it would get truncated point->x = lrint(SvNV(*av_fetch(point_av, 0, 0))); point->y = lrint(SvNV(*av_fetch(point_av, 1, 0))); } void from_SV_check(SV* point_sv, Point* point) { if (sv_isobject(point_sv) && (SvTYPE(SvRV(point_sv)) == SVt_PVMG)) { if (!sv_isa(point_sv, perl_class_name(point)) && !sv_isa(point_sv, perl_class_name_ref(point))) CONFESS("Not a valid %s object (got %s)", perl_class_name(point), HvNAME(SvSTASH(SvRV(point_sv)))); *point = *(Point*)SvIV((SV*)SvRV( point_sv )); } else { from_SV(point_sv, point); } } SV* to_SV_pureperl(const Pointf* point) { AV* av = newAV(); av_fill(av, 1); av_store(av, 0, newSVnv(point->x)); av_store(av, 1, newSVnv(point->y)); return newRV_noinc((SV*)av); } bool from_SV(SV* point_sv, Pointf* point) { AV* point_av = (AV*)SvRV(point_sv); SV* sv_x = *av_fetch(point_av, 0, 0); SV* sv_y = *av_fetch(point_av, 1, 0); if (!looks_like_number(sv_x) || !looks_like_number(sv_y)) return false; point->x = SvNV(sv_x); point->y = SvNV(sv_y); return true; } bool from_SV_check(SV* point_sv, Pointf* point) { if (sv_isobject(point_sv) && (SvTYPE(SvRV(point_sv)) == SVt_PVMG)) { if (!sv_isa(point_sv, perl_class_name(point)) && !sv_isa(point_sv, perl_class_name_ref(point))) CONFESS("Not a valid %s object (got %s)", perl_class_name(point), HvNAME(SvSTASH(SvRV(point_sv)))); *point = *(Pointf*)SvIV((SV*)SvRV( point_sv )); return true; } else { return from_SV(point_sv, point); } } void from_SV_check(SV* surface_sv, Surface* THIS) { if (!sv_isa(surface_sv, perl_class_name(THIS)) && !sv_isa(surface_sv, perl_class_name_ref(THIS))) CONFESS("Not a valid %s object", perl_class_name(THIS)); // a XS Surface was supplied *THIS = *(Surface *)SvIV((SV*)SvRV( surface_sv )); } SV* to_SV(TriangleMesh* THIS) { SV* sv = newSV(0); sv_setref_pv( sv, perl_class_name(THIS), (void*)THIS ); return sv; } SV* polynode_children_2_perl(const ClipperLib::PolyNode& node) { AV* av = newAV(); const int len = node.ChildCount(); if (len > 0) av_extend(av, len-1); for (int i = 0; i < len; ++i) { av_store(av, i, polynode2perl(*node.Childs[i])); } return (SV*)newRV_noinc((SV*)av); } SV* polynode2perl(const ClipperLib::PolyNode& node) { HV* hv = newHV(); Slic3r::Polygon p; ClipperPath_to_Slic3rMultiPoint(node.Contour, &p); if (node.IsHole()) { (void)hv_stores( hv, "hole", Slic3r::perl_to_SV_clone_ref(p) ); } else { (void)hv_stores( hv, "outer", Slic3r::perl_to_SV_clone_ref(p) ); } (void)hv_stores( hv, "children", polynode_children_2_perl(node) ); return (SV*)newRV_noinc((SV*)hv); } } #endif ������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/poly2tri/��������������������������������������������������������������0000775�0000000�0000000�00000000000�13014417200�0017503�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/poly2tri/common/�������������������������������������������������������0000775�0000000�0000000�00000000000�13014417200�0020773�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Slic3r-version_1.31.6/xs/src/poly2tri/common/shapes.cc����������������������������������������������0000664�0000000�0000000�00000021770�13014417200�0022574�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "shapes.h" #include namespace p2t { Triangle::Triangle(Point& a, Point& b, Point& c) { points_[0] = &a; points_[1] = &b; points_[2] = &c; neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL; constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false; delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false; interior_ = false; } // Update neighbor pointers void Triangle::MarkNeighbor(Point* p1, Point* p2, Triangle* t) { if ((p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2])) neighbors_[0] = t; else if ((p1 == points_[0] && p2 == points_[2]) || (p1 == points_[2] && p2 == points_[0])) neighbors_[1] = t; else if ((p1 == points_[0] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[0])) neighbors_[2] = t; else assert(0); } // Exhaustive search to update neighbor pointers void Triangle::MarkNeighbor(Triangle& t) { if (t.Contains(points_[1], points_[2])) { neighbors_[0] = &t; t.MarkNeighbor(points_[1], points_[2], this); } else if (t.Contains(points_[0], points_[2])) { neighbors_[1] = &t; t.MarkNeighbor(points_[0], points_[2], this); } else if (t.Contains(points_[0], points_[1])) { neighbors_[2] = &t; t.MarkNeighbor(points_[0], points_[1], this); } } /** * Clears all references to all other triangles and points */ void Triangle::Clear() { Triangle *t; for( int i=0; i<3; i++ ) { t = neighbors_[i]; if( t != NULL ) { t->ClearNeighbor( this ); } } ClearNeighbors(); points_[0]=points_[1]=points_[2] = NULL; } void Triangle::ClearNeighbor(const Triangle *triangle ) { if( neighbors_[0] == triangle ) { neighbors_[0] = NULL; } else if( neighbors_[1] == triangle ) { neighbors_[1] = NULL; } else { neighbors_[2] = NULL; } } void Triangle::ClearNeighbors() { neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL; } void Triangle::ClearDelunayEdges() { delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false; } Point* Triangle::OppositePoint(Triangle& t, const Point& p) { Point *cw = t.PointCW(p); return PointCW(*cw); } // Legalized triangle by rotating clockwise around point(0) void Triangle::Legalize(Point& point) { points_[1] = points_[0]; points_[0] = points_[2]; points_[2] = &point; } // Legalize triagnle by rotating clockwise around oPoint void Triangle::Legalize(Point& opoint, Point& npoint) { if (&opoint == points_[0]) { points_[1] = points_[0]; points_[0] = points_[2]; points_[2] = &npoint; } else if (&opoint == points_[1]) { points_[2] = points_[1]; points_[1] = points_[0]; points_[0] = &npoint; } else if (&opoint == points_[2]) { points_[0] = points_[2]; points_[2] = points_[1]; points_[1] = &npoint; } else { assert(0); } } int Triangle::Index(const Point* p) const { if (p == points_[0]) { return 0; } else if (p == points_[1]) { return 1; } else if (p == points_[2]) { return 2; } assert(0); return -1; } int Triangle::EdgeIndex(const Point* p1, const Point* p2) const { if (points_[0] == p1) { if (points_[1] == p2) { return 2; } else if (points_[2] == p2) { return 1; } } else if (points_[1] == p1) { if (points_[2] == p2) { return 0; } else if (points_[0] == p2) { return 2; } } else if (points_[2] == p1) { if (points_[0] == p2) { return 1; } else if (points_[1] == p2) { return 0; } } return -1; } void Triangle::MarkConstrainedEdge(int index) { constrained_edge[index] = true; } void Triangle::MarkConstrainedEdge(Edge& edge) { MarkConstrainedEdge(edge.p, edge.q); } // Mark edge as constrained void Triangle::MarkConstrainedEdge(Point* p, Point* q) { if ((q == points_[0] && p == points_[1]) || (q == points_[1] && p == points_[0])) { constrained_edge[2] = true; } else if ((q == points_[0] && p == points_[2]) || (q == points_[2] && p == points_[0])) { constrained_edge[1] = true; } else if ((q == points_[1] && p == points_[2]) || (q == points_[2] && p == points_[1])) { constrained_edge[0] = true; } } // The point counter-clockwise to given point Point* Triangle::PointCW(const Point& point) { if (&point == points_[0]) { return points_[2]; } else if (&point == points_[1]) { return points_[0]; } else if (&point == points_[2]) { return points_[1]; } assert(0); return NULL; } // The point counter-clockwise to given point Point* Triangle::PointCCW(const Point& point) { if (&point == points_[0]) { return points_[1]; } else if (&point == points_[1]) { return points_[2]; } else if (&point == points_[2]) { return points_[0]; } assert(0); return NULL; } // The neighbor clockwise to given point Triangle* Triangle::NeighborCW(const Point& point) { if (&point == points_[0]) { return neighbors_[1]; } else if (&point == points_[1]) { return neighbors_[2]; } return neighbors_[0]; } // The neighbor counter-clockwise to given point Triangle* Triangle::NeighborCCW(const Point& point) { if (&point == points_[0]) { return neighbors_[2]; } else if (&point == points_[1]) { return neighbors_[0]; } return neighbors_[1]; } bool Triangle::GetConstrainedEdgeCCW(const Point& p) const { if (&p == points_[0]) { return constrained_edge[2]; } else if (&p == points_[1]) { return constrained_edge[0]; } return constrained_edge[1]; } bool Triangle::GetConstrainedEdgeCW(const Point& p) const { if (&p == points_[0]) { return constrained_edge[1]; } else if (&p == points_[1]) { return constrained_edge[2]; } return constrained_edge[0]; } void Triangle::SetConstrainedEdgeCCW(const Point& p, bool ce) { if (&p == points_[0]) { constrained_edge[2] = ce; } else if (&p == points_[1]) { constrained_edge[0] = ce; } else { constrained_edge[1] = ce; } } void Triangle::SetConstrainedEdgeCW(const Point& p, bool ce) { if (&p == points_[0]) { constrained_edge[1] = ce; } else if (&p == points_[1]) { constrained_edge[2] = ce; } else { constrained_edge[0] = ce; } } bool Triangle::GetDelunayEdgeCCW(const Point& p) const { if (&p == points_[0]) { return delaunay_edge[2]; } else if (&p == points_[1]) { return delaunay_edge[0]; } return delaunay_edge[1]; } bool Triangle::GetDelunayEdgeCW(const Point& p) const { if (&p == points_[0]) { return delaunay_edge[1]; } else if (&p == points_[1]) { return delaunay_edge[2]; } return delaunay_edge[0]; } void Triangle::SetDelunayEdgeCCW(const Point& p, bool e) { if (&p == points_[0]) { delaunay_edge[2] = e; } else if (&p == points_[1]) { delaunay_edge[0] = e; } else { delaunay_edge[1] = e; } } void Triangle::SetDelunayEdgeCW(const Point& p, bool e) { if (&p == points_[0]) { delaunay_edge[1] = e; } else if (&p == points_[1]) { delaunay_edge[2] = e; } else { delaunay_edge[0] = e; } } // The neighbor across to given point Triangle& Triangle::NeighborAcross(const Point& opoint) { if (&opoint == points_[0]) { return *neighbors_[0]; } else if (&opoint == points_[1]) { return *neighbors_[1]; } return *neighbors_[2]; } void Triangle::DebugPrint() { using namespace std; cout << points_[0]->x << "," << points_[0]->y << " "; cout << points_[1]->x << "," << points_[1]->y << " "; cout << points_[2]->x << "," << points_[2]->y << endl; } }��������Slic3r-version_1.31.6/xs/src/poly2tri/common/shapes.h�����������������������������������������������0000664�0000000�0000000�00000016722�13014417200�0022437�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ // Include guard #ifndef SHAPES_H #define SHAPES_H #include #include #include #include namespace p2t { struct Edge; struct Point { double x, y; /// Default constructor does nothing (for performance). Point() { x = 0.0; y = 0.0; } /// The edges this point constitutes an upper ending point std::vector edge_list; /// Construct using coordinates. Point(double x, double y) : x(x), y(y) {} /// Set this point to all zeros. void set_zero() { x = 0.0; y = 0.0; } /// Set this point to some specified coordinates. void set(double x_, double y_) { x = x_; y = y_; } /// Negate this point. Point operator -() const { Point v; v.set(-x, -y); return v; } /// Add a point to this point. void operator +=(const Point& v) { x += v.x; y += v.y; } /// Subtract a point from this point. void operator -=(const Point& v) { x -= v.x; y -= v.y; } /// Multiply this point by a scalar. void operator *=(double a) { x *= a; y *= a; } /// Get the length of this point (the norm). double Length() const { return sqrt(x * x + y * y); } /// Convert this point into a unit point. Returns the Length. double Normalize() { const double len = Length(); x /= len; y /= len; return len; } }; // Represents a simple polygon's edge struct Edge { Point* p, *q; /// Constructor Edge(Point& p1, Point& p2) : p(&p1), q(&p2) { if (p1.y > p2.y) { q = &p1; p = &p2; } else if (p1.y == p2.y) { if (p1.x > p2.x) { q = &p1; p = &p2; } else if (p1.x == p2.x) { // Repeat points assert(false); } } q->edge_list.push_back(this); } }; // Triangle-based data structures are know to have better performance than quad-edge structures // See: J. Shewchuk, "Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator" // "Triangulations in CGAL" class Triangle { public: /// Constructor Triangle(Point& a, Point& b, Point& c); /// Flags to determine if an edge is a Constrained edge bool constrained_edge[3]; /// Flags to determine if an edge is a Delauney edge bool delaunay_edge[3]; Point* GetPoint(int index); Point* PointCW(const Point& point); Point* PointCCW(const Point& point); Point* OppositePoint(Triangle& t, const Point& p); Triangle* GetNeighbor(int index); void MarkNeighbor(Point* p1, Point* p2, Triangle* t); void MarkNeighbor(Triangle& t); void MarkConstrainedEdge(int index); void MarkConstrainedEdge(Edge& edge); void MarkConstrainedEdge(Point* p, Point* q); int Index(const Point* p) const; int EdgeIndex(const Point* p1, const Point* p2) const; Triangle* NeighborCW(const Point& point); Triangle* NeighborCCW(const Point& point); bool GetConstrainedEdgeCCW(const Point& p) const; bool GetConstrainedEdgeCW(const Point& p) const; void SetConstrainedEdgeCCW(const Point& p, bool ce); void SetConstrainedEdgeCW(const Point& p, bool ce); bool GetDelunayEdgeCCW(const Point& p) const; bool GetDelunayEdgeCW(const Point& p) const; void SetDelunayEdgeCCW(const Point& p, bool e); void SetDelunayEdgeCW(const Point& p, bool e); bool Contains(const Point* p) const; bool Contains(const Edge& e) const; bool Contains(const Point* p, const Point* q) const; void Legalize(Point& point); void Legalize(Point& opoint, Point& npoint); /** * Clears all references to all other triangles and points */ void Clear(); void ClearNeighbor(const Triangle *triangle); void ClearNeighbors(); void ClearDelunayEdges(); inline bool IsInterior() const; inline void IsInterior(bool b); Triangle& NeighborAcross(const Point& opoint); void DebugPrint(); private: /// Triangle points Point* points_[3]; /// Neighbor list Triangle* neighbors_[3]; /// Has this triangle been marked as an interior triangle? bool interior_; }; inline bool cmp(const Point* a, const Point* b) { if (a->y < b->y) { return true; } else if (a->y == b->y) { // Make sure q is point with greater x value if (a->x < b->x) { return true; } } return false; } /// Add two points_ component-wise. inline Point operator +(const Point& a, const Point& b) { return Point(a.x + b.x, a.y + b.y); } /// Subtract two points_ component-wise. inline Point operator -(const Point& a, const Point& b) { return Point(a.x - b.x, a.y - b.y); } /// Multiply point by scalar inline Point operator *(double s, const Point& a) { return Point(s * a.x, s * a.y); } inline bool operator ==(const Point& a, const Point& b) { return a.x == b.x && a.y == b.y; } inline bool operator !=(const Point& a, const Point& b) { return !(a.x == b.x) && !(a.y == b.y); } /// Peform the dot product on two vectors. inline double Dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; } /// Perform the cross product on two vectors. In 2D this produces a scalar. inline double Cross(const Point& a, const Point& b) { return a.x * b.y - a.y * b.x; } /// Perform the cross product on a point and a scalar. In 2D this produces /// a point. inline Point Cross(const Point& a, double s) { return Point(s * a.y, -s * a.x); } /// Perform the cross product on a scalar and a point. In 2D this produces /// a point. inline Point Cross(double s, const Point& a) { return Point(-s * a.y, s * a.x); } inline Point* Triangle::GetPoint(int index) { return points_[index]; } inline Triangle* Triangle::GetNeighbor(int index) { return neighbors_[index]; } inline bool Triangle::Contains(const Point* p) const { return p == points_[0] || p == points_[1] || p == points_[2]; } inline bool Triangle::Contains(const Edge& e) const { return Contains(e.p) && Contains(e.q); } inline bool Triangle::Contains(const Point* p, const Point* q) const { return Contains(p) && Contains(q); } inline bool Triangle::IsInterior() const { return interior_; } inline void Triangle::IsInterior(bool b) { interior_ = b; } } #endif����������������������������������������������Slic3r-version_1.31.6/xs/src/poly2tri/common/utils.h������������������������������������������������0000664�0000000�0000000�00000006637�13014417200�0022320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY 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 UTILS_H #define UTILS_H // Otherwise #defines like M_PI are undeclared under Visual Studio #define _USE_MATH_DEFINES #include #include namespace p2t { const double PI_3div4 = 3 * M_PI / 4; const double PI_div2 = 1.57079632679489661923; const double EPSILON = 1e-12; enum Orientation { CW, CCW, COLLINEAR }; /** * Forumla to calculate signed area
* Positive if CCW
* Negative if CW
* 0 if collinear
* 
 * A[P1,P2,P3]  =  (x1*y2 - y1*x2) + (x2*y3 - y2*x3) + (x3*y1 - y3*x1)
 *              =  (x1-x3)*(y2-y3) - (y1-y3)*(x2-x3)
 *
*/ Orientation Orient2d(const Point& pa, const Point& pb, const Point& pc) { double detleft = (pa.x - pc.x) * (pb.y - pc.y); double detright = (pa.y - pc.y) * (pb.x - pc.x); double val = detleft - detright; if (val > -EPSILON && val < EPSILON) { return COLLINEAR; } else if (val > 0) { return CCW; } return CW; } /* bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd) { double pdx = pd.x; double pdy = pd.y; double adx = pa.x - pdx; double ady = pa.y - pdy; double bdx = pb.x - pdx; double bdy = pb.y - pdy; double adxbdy = adx * bdy; double bdxady = bdx * ady; double oabd = adxbdy - bdxady; if (oabd <= EPSILON) { return false; } double cdx = pc.x - pdx; double cdy = pc.y - pdy; double cdxady = cdx * ady; double adxcdy = adx * cdy; double ocad = cdxady - adxcdy; if (ocad <= EPSILON) { return false; } return true; } */ bool InScanArea(const Point& pa, const Point& pb, const Point& pc, const Point& pd) { double oadb = (pa.x - pb.x)*(pd.y - pb.y) - (pd.x - pb.x)*(pa.y - pb.y); if (oadb >= -EPSILON) { return false; } double oadc = (pa.x - pc.x)*(pd.y - pc.y) - (pd.x - pc.x)*(pa.y - pc.y); if (oadc <= EPSILON) { return false; } return true; } } #endifSlic3r-version_1.31.6/xs/src/poly2tri/poly2tri.h000066400000000000000000000032661301441720000214470ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY 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 POLY2TRI_H #define POLY2TRI_H #include "common/shapes.h" #include "sweep/cdt.h" #endifSlic3r-version_1.31.6/xs/src/poly2tri/sweep/000077500000000000000000000000001301441720000206265ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/poly2tri/sweep/advancing_front.cc000066400000000000000000000061361301441720000243050ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "advancing_front.h" namespace p2t { AdvancingFront::AdvancingFront(Node& head, Node& tail) { head_ = &head; tail_ = &tail; search_node_ = &head; } Node* AdvancingFront::LocateNode(double x) { Node* node = search_node_; if (x < node->value) { while ((node = node->prev) != NULL) { if (x >= node->value) { search_node_ = node; return node; } } } else { while ((node = node->next) != NULL) { if (x < node->value) { search_node_ = node->prev; return node->prev; } } } return NULL; } Node* AdvancingFront::FindSearchNode(double x) { (void)x; // suppress compiler warnings "unused parameter 'x'" // TODO: implement BST index return search_node_; } Node* AdvancingFront::LocatePoint(const Point* point) { const double px = point->x; Node* node = FindSearchNode(px); const double nx = node->point->x; if (px == nx) { if (point != node->point) { // We might have two nodes with same x value for a short time if (point == node->prev->point) { node = node->prev; } else if (point == node->next->point) { node = node->next; } else { assert(0); } } } else if (px < nx) { while ((node = node->prev) != NULL) { if (point == node->point) { break; } } } else { while ((node = node->next) != NULL) { if (point == node->point) break; } } if(node) search_node_ = node; return node; } AdvancingFront::~AdvancingFront() { } }Slic3r-version_1.31.6/xs/src/poly2tri/sweep/advancing_front.h000066400000000000000000000055411301441720000241460ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY 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 ADVANCED_FRONT_H #define ADVANCED_FRONT_H #include "../common/shapes.h" namespace p2t { struct Node; // Advancing front node struct Node { Point* point; Triangle* triangle; Node* next; Node* prev; double value; Node(Point& p) : point(&p), triangle(NULL), next(NULL), prev(NULL), value(p.x) { } Node(Point& p, Triangle& t) : point(&p), triangle(&t), next(NULL), prev(NULL), value(p.x) { } }; // Advancing front class AdvancingFront { public: AdvancingFront(Node& head, Node& tail); // Destructor ~AdvancingFront(); Node* head(); void set_head(Node* node); Node* tail(); void set_tail(Node* node); Node* search(); void set_search(Node* node); /// Locate insertion point along advancing front Node* LocateNode(double x); Node* LocatePoint(const Point* point); private: Node* head_, *tail_, *search_node_; Node* FindSearchNode(double x); }; inline Node* AdvancingFront::head() { return head_; } inline void AdvancingFront::set_head(Node* node) { head_ = node; } inline Node* AdvancingFront::tail() { return tail_; } inline void AdvancingFront::set_tail(Node* node) { tail_ = node; } inline Node* AdvancingFront::search() { return search_node_; } inline void AdvancingFront::set_search(Node* node) { search_node_ = node; } } #endifSlic3r-version_1.31.6/xs/src/poly2tri/sweep/cdt.cc000066400000000000000000000043111301441720000217060ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "cdt.h" namespace p2t { CDT::CDT(const std::vector& polyline) { sweep_context_ = new SweepContext(polyline); sweep_ = new Sweep; } void CDT::AddHole(const std::vector& polyline) { sweep_context_->AddHole(polyline); } void CDT::AddPoint(Point* point) { sweep_context_->AddPoint(point); } void CDT::Triangulate() { sweep_->Triangulate(*sweep_context_); } std::vector CDT::GetTriangles() { return sweep_context_->GetTriangles(); } std::list CDT::GetMap() { return sweep_context_->GetMap(); } CDT::~CDT() { delete sweep_context_; delete sweep_; } }Slic3r-version_1.31.6/xs/src/poly2tri/sweep/cdt.h000066400000000000000000000050431301441720000215530ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY 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 CDT_H #define CDT_H #include "advancing_front.h" #include "sweep_context.h" #include "sweep.h" /** * * @author Mason Green * */ namespace p2t { class CDT { public: /** * Constructor - add polyline with non repeating points * * @param polyline */ CDT(const std::vector& polyline); /** * Destructor - clean up memory */ ~CDT(); /** * Add a hole * * @param polyline */ void AddHole(const std::vector& polyline); /** * Add a steiner point * * @param point */ void AddPoint(Point* point); /** * Triangulate - do this AFTER you've added the polyline, holes, and Steiner points */ void Triangulate(); /** * Get CDT triangles */ std::vector GetTriangles(); /** * Get triangle map */ std::list GetMap(); private: /** * Internals */ SweepContext* sweep_context_; Sweep* sweep_; }; } #endifSlic3r-version_1.31.6/xs/src/poly2tri/sweep/sweep.cc000066400000000000000000000572201301441720000222660ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include "sweep.h" #include "sweep_context.h" #include "advancing_front.h" #include "../common/utils.h" namespace p2t { // Triangulate simple polygon with holes void Sweep::Triangulate(SweepContext& tcx) { tcx.InitTriangulation(); tcx.CreateAdvancingFront(nodes_); // Sweep points; build mesh SweepPoints(tcx); // Clean up FinalizationPolygon(tcx); } void Sweep::SweepPoints(SweepContext& tcx) { for (size_t i = 1; i < tcx.point_count(); i++) { Point& point = *tcx.GetPoint(i); Node* node = &PointEvent(tcx, point); for (unsigned int i = 0; i < point.edge_list.size(); i++) { EdgeEvent(tcx, point.edge_list[i], node); } } } void Sweep::FinalizationPolygon(SweepContext& tcx) { // Get an Internal triangle to start with Triangle* t = tcx.front()->head()->next->triangle; Point* p = tcx.front()->head()->next->point; while (!t->GetConstrainedEdgeCW(*p)) { t = t->NeighborCCW(*p); } // Collect interior triangles constrained by edges tcx.MeshClean(*t); } Node& Sweep::PointEvent(SweepContext& tcx, Point& point) { Node& node = tcx.LocateNode(point); Node& new_node = NewFrontTriangle(tcx, point, node); // Only need to check +epsilon since point never have smaller // x value than node due to how we fetch nodes from the front if (point.x <= node.point->x + EPSILON) { Fill(tcx, node); } //tcx.AddNode(new_node); FillAdvancingFront(tcx, new_node); return new_node; } void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node* node) { tcx.edge_event.constrained_edge = edge; tcx.edge_event.right = (edge->p->x > edge->q->x); if (IsEdgeSideOfTriangle(*node->triangle, *edge->p, *edge->q)) { return; } // For now we will do all needed filling // TODO: integrate with flip process might give some better performance // but for now this avoid the issue with cases that needs both flips and fills FillEdgeEvent(tcx, edge, node); EdgeEvent(tcx, *edge->p, *edge->q, node->triangle, *edge->q); } void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point) { if (IsEdgeSideOfTriangle(*triangle, ep, eq)) { return; } Point* p1 = triangle->PointCCW(point); Orientation o1 = Orient2d(eq, *p1, ep); if (o1 == COLLINEAR) { if( triangle->Contains(&eq, p1)) { triangle->MarkConstrainedEdge(&eq, p1 ); // We are modifying the constraint maybe it would be better to // not change the given constraint and just keep a variable for the new constraint tcx.edge_event.constrained_edge->q = p1; triangle = &triangle->NeighborAcross(point); EdgeEvent( tcx, ep, *p1, triangle, *p1 ); } else { std::runtime_error("EdgeEvent - collinear points not supported"); assert(0); } return; } Point* p2 = triangle->PointCW(point); Orientation o2 = Orient2d(eq, *p2, ep); if (o2 == COLLINEAR) { if( triangle->Contains(&eq, p2)) { triangle->MarkConstrainedEdge(&eq, p2 ); // We are modifying the constraint maybe it would be better to // not change the given constraint and just keep a variable for the new constraint tcx.edge_event.constrained_edge->q = p2; triangle = &triangle->NeighborAcross(point); EdgeEvent( tcx, ep, *p2, triangle, *p2 ); } else { std::runtime_error("EdgeEvent - collinear points not supported"); assert(0); } return; } if (o1 == o2) { // Need to decide if we are rotating CW or CCW to get to a triangle // that will cross edge if (o1 == CW) { triangle = triangle->NeighborCCW(point); } else{ triangle = triangle->NeighborCW(point); } EdgeEvent(tcx, ep, eq, triangle, point); } else { // This triangle crosses constraint so lets flippin start! FlipEdgeEvent(tcx, ep, eq, triangle, point); } } bool Sweep::IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq) { const int index = triangle.EdgeIndex(&ep, &eq); if (index != -1) { triangle.MarkConstrainedEdge(index); Triangle* t = triangle.GetNeighbor(index); if (t) { t->MarkConstrainedEdge(&ep, &eq); } return true; } return false; } Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node) { Triangle* triangle = new Triangle(point, *node.point, *node.next->point); triangle->MarkNeighbor(*node.triangle); tcx.AddToMap(triangle); Node* new_node = new Node(point); nodes_.push_back(new_node); new_node->next = node.next; new_node->prev = &node; node.next->prev = new_node; node.next = new_node; if (!Legalize(tcx, *triangle)) { tcx.MapTriangleToNodes(*triangle); } return *new_node; } void Sweep::Fill(SweepContext& tcx, Node& node) { Triangle* triangle = new Triangle(*node.prev->point, *node.point, *node.next->point); // TODO: should copy the constrained_edge value from neighbor triangles // for now constrained_edge values are copied during the legalize triangle->MarkNeighbor(*node.prev->triangle); triangle->MarkNeighbor(*node.triangle); tcx.AddToMap(triangle); // Update the advancing front node.prev->next = node.next; node.next->prev = node.prev; // If it was legalized the triangle has already been mapped if (!Legalize(tcx, *triangle)) { tcx.MapTriangleToNodes(*triangle); } } void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n) { // Fill right holes Node* node = n.next; while (node->next) { // if HoleAngle exceeds 90 degrees then break. if (LargeHole_DontFill(node)) break; Fill(tcx, *node); node = node->next; } // Fill left holes node = n.prev; while (node->prev) { // if HoleAngle exceeds 90 degrees then break. if (LargeHole_DontFill(node)) break; Fill(tcx, *node); node = node->prev; } // Fill right basins if (n.next && n.next->next) { const double angle = BasinAngle(n); if (angle < PI_3div4) { FillBasin(tcx, n); } } } // True if HoleAngle exceeds 90 degrees. bool Sweep::LargeHole_DontFill(const Node* node) const { const Node* nextNode = node->next; const Node* prevNode = node->prev; if (!AngleExceeds90Degrees(node->point, nextNode->point, prevNode->point)) return false; // Check additional points on front. const Node* next2Node = nextNode->next; // "..Plus.." because only want angles on same side as point being added. if ((next2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point)) return false; const Node* prev2Node = prevNode->prev; // "..Plus.." because only want angles on same side as point being added. if ((prev2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point)) return false; return true; } bool Sweep::AngleExceeds90Degrees(const Point* origin, const Point* pa, const Point* pb) const { const double angle = Angle(origin, pa, pb); return ((angle > PI_div2) || (angle < -PI_div2)); } bool Sweep::AngleExceedsPlus90DegreesOrIsNegative(const Point* origin, const Point* pa, const Point* pb) const { const double angle = Angle(origin, pa, pb); return (angle > PI_div2) || (angle < 0); } double Sweep::Angle(const Point* origin, const Point* pa, const Point* pb) const { /* Complex plane * ab = cosA +i*sinA * ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx) * atan2(y,x) computes the principal value of the argument function * applied to the complex number x+iy * Where x = ax*bx + ay*by * y = ax*by - ay*bx */ const double px = origin->x; const double py = origin->y; const double ax = pa->x- px; const double ay = pa->y - py; const double bx = pb->x - px; const double by = pb->y - py; const double x = ax * by - ay * bx; const double y = ax * bx + ay * by; return atan2(x, y); } double Sweep::BasinAngle(const Node& node) const { const double ax = node.point->x - node.next->next->point->x; const double ay = node.point->y - node.next->next->point->y; return atan2(ay, ax); } double Sweep::HoleAngle(const Node& node) const { /* Complex plane * ab = cosA +i*sinA * ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx) * atan2(y,x) computes the principal value of the argument function * applied to the complex number x+iy * Where x = ax*bx + ay*by * y = ax*by - ay*bx */ const double ax = node.next->point->x - node.point->x; const double ay = node.next->point->y - node.point->y; const double bx = node.prev->point->x - node.point->x; const double by = node.prev->point->y - node.point->y; return atan2(ax * by - ay * bx, ax * bx + ay * by); } bool Sweep::Legalize(SweepContext& tcx, Triangle& t) { // To legalize a triangle we start by finding if any of the three edges // violate the Delaunay condition for (int i = 0; i < 3; i++) { if (t.delaunay_edge[i]) continue; Triangle* ot = t.GetNeighbor(i); if (ot) { Point* p = t.GetPoint(i); Point* op = ot->OppositePoint(t, *p); int oi = ot->Index(op); // If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization) // then we should not try to legalize if (ot->constrained_edge[oi] || ot->delaunay_edge[oi]) { t.constrained_edge[i] = ot->constrained_edge[oi]; continue; } bool inside = Incircle(*p, *t.PointCCW(*p), *t.PointCW(*p), *op); if (inside) { // Lets mark this shared edge as Delaunay t.delaunay_edge[i] = true; ot->delaunay_edge[oi] = true; // Lets rotate shared edge one vertex CW to legalize it RotateTrianglePair(t, *p, *ot, *op); // We now got one valid Delaunay Edge shared by two triangles // This gives us 4 new edges to check for Delaunay // Make sure that triangle to node mapping is done only one time for a specific triangle bool not_legalized = !Legalize(tcx, t); if (not_legalized) { tcx.MapTriangleToNodes(t); } not_legalized = !Legalize(tcx, *ot); if (not_legalized) tcx.MapTriangleToNodes(*ot); // Reset the Delaunay edges, since they only are valid Delaunay edges // until we add a new triangle or point. // XXX: need to think about this. Can these edges be tried after we // return to previous recursive level? t.delaunay_edge[i] = false; ot->delaunay_edge[oi] = false; // If triangle have been legalized no need to check the other edges since // the recursive legalization will handles those so we can end here. return true; } } } return false; } bool Sweep::Incircle(const Point& pa, const Point& pb, const Point& pc, const Point& pd) const { const double adx = pa.x - pd.x; const double ady = pa.y - pd.y; const double bdx = pb.x - pd.x; const double bdy = pb.y - pd.y; const double adxbdy = adx * bdy; const double bdxady = bdx * ady; const double oabd = adxbdy - bdxady; if (oabd <= 0) return false; const double cdx = pc.x - pd.x; const double cdy = pc.y - pd.y; const double cdxady = cdx * ady; const double adxcdy = adx * cdy; const double ocad = cdxady - adxcdy; if (ocad <= 0) return false; const double bdxcdy = bdx * cdy; const double cdxbdy = cdx * bdy; const double alift = adx * adx + ady * ady; const double blift = bdx * bdx + bdy * bdy; const double clift = cdx * cdx + cdy * cdy; const double det = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd; return det > 0; } void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op) const { Triangle* n1, *n2, *n3, *n4; n1 = t.NeighborCCW(p); n2 = t.NeighborCW(p); n3 = ot.NeighborCCW(op); n4 = ot.NeighborCW(op); bool ce1, ce2, ce3, ce4; ce1 = t.GetConstrainedEdgeCCW(p); ce2 = t.GetConstrainedEdgeCW(p); ce3 = ot.GetConstrainedEdgeCCW(op); ce4 = ot.GetConstrainedEdgeCW(op); bool de1, de2, de3, de4; de1 = t.GetDelunayEdgeCCW(p); de2 = t.GetDelunayEdgeCW(p); de3 = ot.GetDelunayEdgeCCW(op); de4 = ot.GetDelunayEdgeCW(op); t.Legalize(p, op); ot.Legalize(op, p); // Remap delaunay_edge ot.SetDelunayEdgeCCW(p, de1); t.SetDelunayEdgeCW(p, de2); t.SetDelunayEdgeCCW(op, de3); ot.SetDelunayEdgeCW(op, de4); // Remap constrained_edge ot.SetConstrainedEdgeCCW(p, ce1); t.SetConstrainedEdgeCW(p, ce2); t.SetConstrainedEdgeCCW(op, ce3); ot.SetConstrainedEdgeCW(op, ce4); // Remap neighbors // XXX: might optimize the markNeighbor by keeping track of // what side should be assigned to what neighbor after the // rotation. Now mark neighbor does lots of testing to find // the right side. t.ClearNeighbors(); ot.ClearNeighbors(); if (n1) ot.MarkNeighbor(*n1); if (n2) t.MarkNeighbor(*n2); if (n3) t.MarkNeighbor(*n3); if (n4) ot.MarkNeighbor(*n4); t.MarkNeighbor(ot); } void Sweep::FillBasin(SweepContext& tcx, Node& node) { if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) { tcx.basin.left_node = node.next->next; } else { tcx.basin.left_node = node.next; } // Find the bottom and right node tcx.basin.bottom_node = tcx.basin.left_node; while (tcx.basin.bottom_node->next && tcx.basin.bottom_node->point->y >= tcx.basin.bottom_node->next->point->y) { tcx.basin.bottom_node = tcx.basin.bottom_node->next; } if (tcx.basin.bottom_node == tcx.basin.left_node) { // No valid basin return; } tcx.basin.right_node = tcx.basin.bottom_node; while (tcx.basin.right_node->next && tcx.basin.right_node->point->y < tcx.basin.right_node->next->point->y) { tcx.basin.right_node = tcx.basin.right_node->next; } if (tcx.basin.right_node == tcx.basin.bottom_node) { // No valid basins return; } tcx.basin.width = tcx.basin.right_node->point->x - tcx.basin.left_node->point->x; tcx.basin.left_highest = tcx.basin.left_node->point->y > tcx.basin.right_node->point->y; FillBasinReq(tcx, tcx.basin.bottom_node); } void Sweep::FillBasinReq(SweepContext& tcx, Node* node) { // if shallow stop filling if (IsShallow(tcx, *node)) { return; } Fill(tcx, *node); if (node->prev == tcx.basin.left_node && node->next == tcx.basin.right_node) { return; } else if (node->prev == tcx.basin.left_node) { Orientation o = Orient2d(*node->point, *node->next->point, *node->next->next->point); if (o == CW) { return; } node = node->next; } else if (node->next == tcx.basin.right_node) { Orientation o = Orient2d(*node->point, *node->prev->point, *node->prev->prev->point); if (o == CCW) { return; } node = node->prev; } else { // Continue with the neighbor node with lowest Y value if (node->prev->point->y < node->next->point->y) { node = node->prev; } else { node = node->next; } } FillBasinReq(tcx, node); } bool Sweep::IsShallow(SweepContext& tcx, Node& node) { double height; if (tcx.basin.left_highest) { height = tcx.basin.left_node->point->y - node.point->y; } else { height = tcx.basin.right_node->point->y - node.point->y; } // if shallow stop filling if (tcx.basin.width > height) { return true; } return false; } void Sweep::FillEdgeEvent(SweepContext& tcx, Edge* edge, Node* node) { if (tcx.edge_event.right) { FillRightAboveEdgeEvent(tcx, edge, node); } else { FillLeftAboveEdgeEvent(tcx, edge, node); } } void Sweep::FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node) { while (node->next->point->x < edge->p->x) { // Check if next node is below the edge if (Orient2d(*edge->q, *node->next->point, *edge->p) == CCW) { FillRightBelowEdgeEvent(tcx, edge, *node); } else { node = node->next; } } } void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { if (node.point->x < edge->p->x) { if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) { // Concave FillRightConcaveEdgeEvent(tcx, edge, node); } else{ // Convex FillRightConvexEdgeEvent(tcx, edge, node); // Retry this one FillRightBelowEdgeEvent(tcx, edge, node); } } } void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { Fill(tcx, *node.next); if (node.next->point != edge->p) { // Next above or below edge? if (Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) { // Below if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) { // Next is concave FillRightConcaveEdgeEvent(tcx, edge, node); } else { // Next is convex } } } } void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { // Next concave or convex? if (Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point) == CCW) { // Concave FillRightConcaveEdgeEvent(tcx, edge, *node.next); } else{ // Convex // Next above or below edge? if (Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) { // Below FillRightConvexEdgeEvent(tcx, edge, *node.next); } else{ // Above } } } void Sweep::FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node) { while (node->prev->point->x > edge->p->x) { // Check if next node is below the edge if (Orient2d(*edge->q, *node->prev->point, *edge->p) == CW) { FillLeftBelowEdgeEvent(tcx, edge, *node); } else { node = node->prev; } } } void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { if (node.point->x > edge->p->x) { if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) { // Concave FillLeftConcaveEdgeEvent(tcx, edge, node); } else { // Convex FillLeftConvexEdgeEvent(tcx, edge, node); // Retry this one FillLeftBelowEdgeEvent(tcx, edge, node); } } } void Sweep::FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { // Next concave or convex? if (Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) { // Concave FillLeftConcaveEdgeEvent(tcx, edge, *node.prev); } else{ // Convex // Next above or below edge? if (Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) { // Below FillLeftConvexEdgeEvent(tcx, edge, *node.prev); } else{ // Above } } } void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { Fill(tcx, *node.prev); if (node.prev->point != edge->p) { // Next above or below edge? if (Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) { // Below if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) { // Next is concave FillLeftConcaveEdgeEvent(tcx, edge, node); } else{ // Next is convex } } } } void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p) { Triangle& ot = t->NeighborAcross(p); Point& op = *ot.OppositePoint(*t, p); if (&ot == NULL) { // If we want to integrate the fillEdgeEvent do it here // With current implementation we should never get here //throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle"); assert(0); } if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) { // Lets rotate shared edge one vertex CW RotateTrianglePair(*t, p, ot, op); tcx.MapTriangleToNodes(*t); tcx.MapTriangleToNodes(ot); if (p == eq && op == ep) { if (eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) { t->MarkConstrainedEdge(&ep, &eq); ot.MarkConstrainedEdge(&ep, &eq); Legalize(tcx, *t); Legalize(tcx, ot); } else { // XXX: I think one of the triangles should be legalized here? } } else { Orientation o = Orient2d(eq, op, ep); t = &NextFlipTriangle(tcx, (int)o, *t, ot, p, op); FlipEdgeEvent(tcx, ep, eq, t, p); } } else { Point& newP = NextFlipPoint(ep, eq, ot, op); FlipScanEdgeEvent(tcx, ep, eq, *t, ot, newP); EdgeEvent(tcx, ep, eq, t, p); } } Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op) { if (o == CCW) { // ot is not crossing edge after flip int edge_index = ot.EdgeIndex(&p, &op); ot.delaunay_edge[edge_index] = true; Legalize(tcx, ot); ot.ClearDelunayEdges(); return t; } // t is not crossing edge after flip int edge_index = t.EdgeIndex(&p, &op); t.delaunay_edge[edge_index] = true; Legalize(tcx, t); t.ClearDelunayEdges(); return ot; } Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op) { Orientation o2d = Orient2d(eq, op, ep); if (o2d == CW) { // Right return *ot.PointCCW(op); } else if (o2d == CCW) { // Left return *ot.PointCW(op); } throw std::runtime_error("[Unsupported] Opposing point on constrained edge"); } void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, Triangle& t, Point& p) { Triangle& ot = t.NeighborAcross(p); Point& op = *ot.OppositePoint(t, p); if (&t.NeighborAcross(p) == NULL) { // If we want to integrate the fillEdgeEvent do it here // With current implementation we should never get here //throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle"); assert(0); } if (InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW(eq), op)) { // flip with new edge op->eq FlipEdgeEvent(tcx, eq, op, &ot, op); // TODO: Actually I just figured out that it should be possible to // improve this by getting the next ot and op before the the above // flip and continue the flipScanEdgeEvent here // set new ot and op here and loop back to inScanArea test // also need to set a new flip_triangle first // Turns out at first glance that this is somewhat complicated // so it will have to wait. } else{ Point& newP = NextFlipPoint(ep, eq, ot, op); FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP); } } Sweep::~Sweep() { // Clean up memory for(size_t i = 0; i < nodes_.size(); i++) { delete nodes_[i]; } } } Slic3r-version_1.31.6/xs/src/poly2tri/sweep/sweep.h000066400000000000000000000210611301441720000221220ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY 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. */ /** * Sweep-line, Constrained Delauney Triangulation (CDT) See: Domiter, V. and * Zalik, B.(2008)'Sweep-line algorithm for constrained Delaunay triangulation', * International Journal of Geographical Information Science * * "FlipScan" Constrained Edge Algorithm invented by Thomas ?hl?n, thahlen@gmail.com */ #ifndef SWEEP_H #define SWEEP_H #include namespace p2t { class SweepContext; struct Node; struct Point; struct Edge; class Triangle; class Sweep { public: /** * Triangulate * * @param tcx */ void Triangulate(SweepContext& tcx); /** * Destructor - clean up memory */ ~Sweep(); private: /** * Start sweeping the Y-sorted point set from bottom to top * * @param tcx */ void SweepPoints(SweepContext& tcx); /** * Find closes node to the left of the new point and * create a new triangle. If needed new holes and basins * will be filled to. * * @param tcx * @param point * @return */ Node& PointEvent(SweepContext& tcx, Point& point); /** * * * @param tcx * @param edge * @param node */ void EdgeEvent(SweepContext& tcx, Edge* edge, Node* node); void EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point); /** * Creates a new front triangle and legalize it * * @param tcx * @param point * @param node * @return */ Node& NewFrontTriangle(SweepContext& tcx, Point& point, Node& node); /** * Adds a triangle to the advancing front to fill a hole. * @param tcx * @param node - middle node, that is the bottom of the hole */ void Fill(SweepContext& tcx, Node& node); /** * Returns true if triangle was legalized */ bool Legalize(SweepContext& tcx, Triangle& t); /** * Requirement:
* 1. a,b and c form a triangle.
* 2. a and d is know to be on opposite side of bc
* 
   *                a
   *                +
   *               / \
   *              /   \
   *            b/     \c
   *            +-------+
   *           /    d    \
   *          /           \
   *
* Fact: d has to be in area B to have a chance to be inside the circle formed by * a,b and c
* d is outside B if orient2d(a,b,d) or orient2d(c,a,d) is CW
* This preknowledge gives us a way to optimize the incircle test * @param a - triangle point, opposite d * @param b - triangle point * @param c - triangle point * @param d - point opposite a * @return true if d is inside circle, false if on circle edge */ bool Incircle(const Point& pa, const Point& pb, const Point& pc, const Point& pd) const; /** * Rotates a triangle pair one vertex CW *
   *       n2                    n2
   *  P +-----+             P +-----+
   *    | t  /|               |\  t |
   *    |   / |               | \   |
   *  n1|  /  |n3           n1|  \  |n3
   *    | /   |    after CW   |   \ |
   *    |/ oT |               | oT \|
   *    +-----+ oP            +-----+
   *       n4                    n4
   *
*/ void RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op) const; /** * Fills holes in the Advancing Front * * * @param tcx * @param n */ void FillAdvancingFront(SweepContext& tcx, Node& n); // Decision-making about when to Fill hole. // Contributed by ToolmakerSteve2 bool LargeHole_DontFill(const Node* node) const; bool AngleExceeds90Degrees(const Point* origin, const Point* pa, const Point* pb) const; bool AngleExceedsPlus90DegreesOrIsNegative(const Point* origin, const Point* pa, const Point* pb) const; double Angle(const Point* origin, const Point* pa, const Point* pb) const; /** * * @param node - middle node * @return the angle between 3 front nodes */ double HoleAngle(const Node& node) const; /** * The basin angle is decided against the horizontal line [1,0] */ double BasinAngle(const Node& node) const; /** * Fills a basin that has formed on the Advancing Front to the right * of given node.
* First we decide a left,bottom and right node that forms the * boundaries of the basin. Then we do a reqursive fill. * * @param tcx * @param node - starting node, this or next node will be left node */ void FillBasin(SweepContext& tcx, Node& node); /** * Recursive algorithm to fill a Basin with triangles * * @param tcx * @param node - bottom_node * @param cnt - counter used to alternate on even and odd numbers */ void FillBasinReq(SweepContext& tcx, Node* node); bool IsShallow(SweepContext& tcx, Node& node); bool IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq); void FillEdgeEvent(SweepContext& tcx, Edge* edge, Node* node); void FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node); void FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node); void FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p); /** * After a flip we have two triangles and know that only one will still be * intersecting the edge. So decide which to contiune with and legalize the other * * @param tcx * @param o - should be the result of an orient2d( eq, op, ep ) * @param t - triangle 1 * @param ot - triangle 2 * @param p - a point shared by both triangles * @param op - another point shared by both triangles * @return returns the triangle still intersecting the edge */ Triangle& NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op); /** * When we need to traverse from one triangle to the next we need * the point in current triangle that is the opposite point to the next * triangle. * * @param ep * @param eq * @param ot * @param op * @return */ Point& NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op); /** * Scan part of the FlipScan algorithm
* When a triangle pair isn't flippable we will scan for the next * point that is inside the flip triangle scan area. When found * we generate a new flipEdgeEvent * * @param tcx * @param ep - last point on the edge we are traversing * @param eq - first point on the edge we are traversing * @param flipTriangle - the current triangle sharing the point eq with edge * @param t * @param p */ void FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, Triangle& t, Point& p); void FinalizationPolygon(SweepContext& tcx); std::vector nodes_; }; } #endifSlic3r-version_1.31.6/xs/src/poly2tri/sweep/sweep_context.cc000066400000000000000000000125261301441720000240320ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "sweep_context.h" #include #include "advancing_front.h" namespace p2t { SweepContext::SweepContext(const std::vector& polyline) : points_(polyline), front_(0), head_(0), tail_(0), af_head_(0), af_middle_(0), af_tail_(0) { InitEdges(points_); } void SweepContext::AddHole(const std::vector& polyline) { InitEdges(polyline); for(unsigned int i = 0; i < polyline.size(); i++) { points_.push_back(polyline[i]); } } void SweepContext::AddPoint(Point* point) { points_.push_back(point); } std::vector &SweepContext::GetTriangles() { return triangles_; } std::list &SweepContext::GetMap() { return map_; } void SweepContext::InitTriangulation() { double xmax(points_[0]->x), xmin(points_[0]->x); double ymax(points_[0]->y), ymin(points_[0]->y); // Calculate bounds. for (unsigned int i = 0; i < points_.size(); i++) { Point& p = *points_[i]; if (p.x > xmax) xmax = p.x; if (p.x < xmin) xmin = p.x; if (p.y > ymax) ymax = p.y; if (p.y < ymin) ymin = p.y; } double dx = kAlpha * (xmax - xmin); double dy = kAlpha * (ymax - ymin); head_ = new Point(xmax + dx, ymin - dy); tail_ = new Point(xmin - dx, ymin - dy); // Sort points along y-axis std::sort(points_.begin(), points_.end(), cmp); } void SweepContext::InitEdges(const std::vector& polyline) { size_t num_points = polyline.size(); for (size_t i = 0; i < num_points; i++) { size_t j = i < num_points - 1 ? i + 1 : 0; edge_list.push_back(new Edge(*polyline[i], *polyline[j])); } } Point* SweepContext::GetPoint(size_t index) { return points_[index]; } void SweepContext::AddToMap(Triangle* triangle) { map_.push_back(triangle); } Node& SweepContext::LocateNode(const Point& point) { // TODO implement search tree return *front_->LocateNode(point.x); } void SweepContext::CreateAdvancingFront(const std::vector& nodes) { (void) nodes; // Initial triangle Triangle* triangle = new Triangle(*points_[0], *tail_, *head_); map_.push_back(triangle); af_head_ = new Node(*triangle->GetPoint(1), *triangle); af_middle_ = new Node(*triangle->GetPoint(0), *triangle); af_tail_ = new Node(*triangle->GetPoint(2)); front_ = new AdvancingFront(*af_head_, *af_tail_); // TODO: More intuitive if head is middles next and not previous? // so swap head and tail af_head_->next = af_middle_; af_middle_->next = af_tail_; af_middle_->prev = af_head_; af_tail_->prev = af_middle_; } void SweepContext::RemoveNode(Node* node) { delete node; } void SweepContext::MapTriangleToNodes(Triangle& t) { for (int i = 0; i < 3; i++) { if (!t.GetNeighbor(i)) { Node* n = front_->LocatePoint(t.PointCW(*t.GetPoint(i))); if (n) n->triangle = &t; } } } void SweepContext::RemoveFromMap(Triangle* triangle) { map_.remove(triangle); } void SweepContext::MeshClean(Triangle& triangle) { std::vector triangles; triangles.push_back(&triangle); while(!triangles.empty()){ Triangle *t = triangles.back(); triangles.pop_back(); if (t != NULL && !t->IsInterior()) { t->IsInterior(true); triangles_.push_back(t); for (int i = 0; i < 3; i++) { if (!t->constrained_edge[i]) triangles.push_back(t->GetNeighbor(i)); } } } } SweepContext::~SweepContext() { // Clean up memory delete head_; delete tail_; delete front_; delete af_head_; delete af_middle_; delete af_tail_; typedef std::list type_list; for(type_list::iterator iter = map_.begin(); iter != map_.end(); ++iter) { Triangle* ptr = *iter; delete ptr; } for(unsigned int i = 0; i < edge_list.size(); i++) { delete edge_list[i]; } } } Slic3r-version_1.31.6/xs/src/poly2tri/sweep/sweep_context.h000066400000000000000000000101201301441720000236600ustar00rootroot00000000000000/* * Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors * http://code.google.com/p/poly2tri/ * * 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. * * Neither the name of Poly2Tri nor the names of its contributors may be * used to endorse or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY 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 SWEEP_CONTEXT_H #define SWEEP_CONTEXT_H #include #include #include namespace p2t { // Inital triangle factor, seed triangle will extend 30% of // PointSet width to both left and right. const double kAlpha = 0.3; struct Point; class Triangle; struct Node; struct Edge; class AdvancingFront; class SweepContext { public: /// Constructor SweepContext(const std::vector& polyline); /// Destructor ~SweepContext(); void set_head(Point* p1); Point* head() const; void set_tail(Point* p1); Point* tail() const; size_t point_count() const; Node& LocateNode(const Point& point); void RemoveNode(Node* node); void CreateAdvancingFront(const std::vector& nodes); /// Try to map a node to all sides of this triangle that don't have a neighbor void MapTriangleToNodes(Triangle& t); void AddToMap(Triangle* triangle); Point* GetPoint(size_t index); Point* GetPoints(); void RemoveFromMap(Triangle* triangle); void AddHole(const std::vector& polyline); void AddPoint(Point* point); AdvancingFront* front() const; void MeshClean(Triangle& triangle); std::vector &GetTriangles(); std::list &GetMap(); std::vector edge_list; struct Basin { Node* left_node; Node* bottom_node; Node* right_node; double width; bool left_highest; Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL), width(0.0), left_highest(false) { } void Clear() { left_node = NULL; bottom_node = NULL; right_node = NULL; width = 0.0; left_highest = false; } }; struct EdgeEvent { Edge* constrained_edge; bool right; EdgeEvent() : constrained_edge(NULL), right(false) { } }; Basin basin; EdgeEvent edge_event; private: friend class Sweep; std::vector triangles_; std::list map_; std::vector points_; // Advancing front AdvancingFront* front_; // head point used with advancing front Point* head_; // tail point used with advancing front Point* tail_; Node *af_head_, *af_middle_, *af_tail_; void InitTriangulation(); void InitEdges(const std::vector& polyline); }; inline AdvancingFront* SweepContext::front() const { return front_; } inline size_t SweepContext::point_count() const { return points_.size(); } inline void SweepContext::set_head(Point* p1) { head_ = p1; } inline Point* SweepContext::head() const { return head_; } inline void SweepContext::set_tail(Point* p1) { tail_ = p1; } inline Point* SweepContext::tail() const { return tail_; } } #endif Slic3r-version_1.31.6/xs/src/polypartition.cpp000066400000000000000000001263201301441720000213440ustar00rootroot00000000000000//Copyright (C) 2011 by Ivan Fratric // //Permission is hereby granted, free of charge, to any person obtaining a copy //of this software and associated documentation files (the "Software"), to deal //in the Software without restriction, including without limitation the rights //to use, copy, modify, merge, publish, distribute, sublicense, and/or sell //copies of the Software, and to permit persons to whom the Software is //furnished to do so, subject to the following conditions: // //The above copyright notice and this permission notice shall be included in //all copies or substantial portions of the Software. // //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN //THE SOFTWARE. #include #include #include #include #include #include using namespace std; #include "polypartition.h" #define TPPL_VERTEXTYPE_REGULAR 0 #define TPPL_VERTEXTYPE_START 1 #define TPPL_VERTEXTYPE_END 2 #define TPPL_VERTEXTYPE_SPLIT 3 #define TPPL_VERTEXTYPE_MERGE 4 TPPLPoly::TPPLPoly() { hole = false; numpoints = 0; points = NULL; } TPPLPoly::~TPPLPoly() { if(points) delete [] points; } void TPPLPoly::Clear() { if(points) delete [] points; hole = false; numpoints = 0; points = NULL; } void TPPLPoly::Init(long numpoints) { Clear(); this->numpoints = numpoints; points = new TPPLPoint[numpoints]; } void TPPLPoly::Triangle(TPPLPoint &p1, TPPLPoint &p2, TPPLPoint &p3) { Init(3); points[0] = p1; points[1] = p2; points[2] = p3; } TPPLPoly::TPPLPoly(const TPPLPoly &src) { hole = src.hole; numpoints = src.numpoints; points = new TPPLPoint[numpoints]; memcpy(points, src.points, numpoints*sizeof(TPPLPoint)); } TPPLPoly& TPPLPoly::operator=(const TPPLPoly &src) { if(&src != this) { Clear(); hole = src.hole; numpoints = src.numpoints; points = new TPPLPoint[numpoints]; memcpy(points, src.points, numpoints*sizeof(TPPLPoint)); } return *this; } int TPPLPoly::GetOrientation() const { long i1,i2; tppl_float area = 0; for(i1=0; i10) return TPPL_CCW; if(area<0) return TPPL_CW; return 0; } void TPPLPoly::SetOrientation(int orientation) { int polyorientation = GetOrientation(); if(polyorientation&&(polyorientation!=orientation)) { Invert(); } } void TPPLPoly::Invert() { long i; TPPLPoint *invpoints; invpoints = new TPPLPoint[numpoints]; for(i=0;i0) return 0; if(dot21*dot22>0) return 0; return 1; } //removes holes from inpolys by merging them with non-holes int TPPLPartition::RemoveHoles(list *inpolys, list *outpolys) { list polys; list::iterator holeiter,polyiter,iter,iter2; long i,i2,holepointindex,polypointindex = 0; TPPLPoint holepoint,polypoint,bestpolypoint; TPPLPoint linep1,linep2; TPPLPoint v1,v2; TPPLPoly newpoly; bool hasholes; bool pointvisible; bool pointfound; //check for trivial case (no holes) hasholes = false; for(iter = inpolys->begin(); iter!=inpolys->end(); ++iter) { if(iter->IsHole()) { hasholes = true; break; } } if(!hasholes) { for(iter = inpolys->begin(); iter!=inpolys->end(); ++iter) { outpolys->push_back(*iter); } return 1; } polys = *inpolys; while(1) { //find the hole point with the largest x hasholes = false; for(iter = polys.begin(); iter!=polys.end(); ++iter) { if(!iter->IsHole()) continue; if(!hasholes) { hasholes = true; holeiter = iter; holepointindex = 0; } for(i=0; i < iter->GetNumPoints(); i++) { if(iter->GetPoint(i).x > holeiter->GetPoint(holepointindex).x) { holeiter = iter; holepointindex = i; } } } if(!hasholes) break; holepoint = holeiter->GetPoint(holepointindex); pointfound = false; for(iter = polys.begin(); iter!=polys.end(); ++iter) { if(iter->IsHole()) continue; for(i=0; i < iter->GetNumPoints(); i++) { if(iter->GetPoint(i).x <= holepoint.x) continue; if(!InCone(iter->GetPoint((i+iter->GetNumPoints()-1)%(iter->GetNumPoints())), iter->GetPoint(i), iter->GetPoint((i+1)%(iter->GetNumPoints())), holepoint)) continue; polypoint = iter->GetPoint(i); if(pointfound) { v1 = Normalize(polypoint-holepoint); v2 = Normalize(bestpolypoint-holepoint); if(v2.x > v1.x) continue; } pointvisible = true; for(iter2 = polys.begin(); iter2!=polys.end(); ++iter2) { if(iter2->IsHole()) continue; for(i2=0; i2 < iter2->GetNumPoints(); i2++) { linep1 = iter2->GetPoint(i2); linep2 = iter2->GetPoint((i2+1)%(iter2->GetNumPoints())); if(Intersects(holepoint,polypoint,linep1,linep2)) { pointvisible = false; break; } } if(!pointvisible) break; } if(pointvisible) { pointfound = true; bestpolypoint = polypoint; polyiter = iter; polypointindex = i; } } } if(!pointfound) return 0; newpoly.Init(holeiter->GetNumPoints() + polyiter->GetNumPoints() + 2); i2 = 0; for(i=0;i<=polypointindex;i++) { newpoly[i2] = polyiter->GetPoint(i); i2++; } for(i=0;i<=holeiter->GetNumPoints();i++) { newpoly[i2] = holeiter->GetPoint((i+holepointindex)%holeiter->GetNumPoints()); i2++; } for(i=polypointindex;iGetNumPoints();i++) { newpoly[i2] = polyiter->GetPoint(i); i2++; } polys.erase(holeiter); polys.erase(polyiter); polys.push_back(newpoly); } for(iter = polys.begin(); iter!=polys.end(); ++iter) { outpolys->push_back(*iter); } return 1; } bool TPPLPartition::IsConvex(TPPLPoint& p1, TPPLPoint& p2, TPPLPoint& p3) { tppl_float tmp; tmp = (p3.y-p1.y)*(p2.x-p1.x)-(p3.x-p1.x)*(p2.y-p1.y); if(tmp>0) return 1; else return 0; } bool TPPLPartition::IsReflex(TPPLPoint& p1, TPPLPoint& p2, TPPLPoint& p3) { tppl_float tmp; tmp = (p3.y-p1.y)*(p2.x-p1.x)-(p3.x-p1.x)*(p2.y-p1.y); if(tmp<0) return 1; else return 0; } bool TPPLPartition::IsInside(TPPLPoint& p1, TPPLPoint& p2, TPPLPoint& p3, TPPLPoint &p) { if(IsConvex(p1,p,p2)) return false; if(IsConvex(p2,p,p3)) return false; if(IsConvex(p3,p,p1)) return false; return true; } bool TPPLPartition::InCone(TPPLPoint &p1, TPPLPoint &p2, TPPLPoint &p3, TPPLPoint &p) { bool convex; convex = IsConvex(p1,p2,p3); if(convex) { if(!IsConvex(p1,p2,p)) return false; if(!IsConvex(p2,p3,p)) return false; return true; } else { if(IsConvex(p1,p2,p)) return true; if(IsConvex(p2,p3,p)) return true; return false; } } bool TPPLPartition::InCone(PartitionVertex *v, TPPLPoint &p) { TPPLPoint p1,p2,p3; p1 = v->previous->p; p2 = v->p; p3 = v->next->p; return InCone(p1,p2,p3,p); } void TPPLPartition::UpdateVertexReflexity(PartitionVertex *v) { PartitionVertex *v1,*v3; v1 = v->previous; v3 = v->next; v->isConvex = !IsReflex(v1->p,v->p,v3->p); } void TPPLPartition::UpdateVertex(PartitionVertex *v, PartitionVertex *vertices, long numvertices) { long i; PartitionVertex *v1,*v3; TPPLPoint vec1,vec3; v1 = v->previous; v3 = v->next; v->isConvex = IsConvex(v1->p,v->p,v3->p); vec1 = Normalize(v1->p - v->p); vec3 = Normalize(v3->p - v->p); v->angle = vec1.x*vec3.x + vec1.y*vec3.y; if(v->isConvex) { v->isEar = true; for(i=0;ip.x)&&(vertices[i].p.y==v->p.y)) continue; if((vertices[i].p.x==v1->p.x)&&(vertices[i].p.y==v1->p.y)) continue; if((vertices[i].p.x==v3->p.x)&&(vertices[i].p.y==v3->p.y)) continue; if(IsInside(v1->p,v->p,v3->p,vertices[i].p)) { v->isEar = false; break; } } } else { v->isEar = false; } } //triangulation by ear removal int TPPLPartition::Triangulate_EC(TPPLPoly *poly, list *triangles) { long numvertices; PartitionVertex *vertices; PartitionVertex *ear; TPPLPoly triangle; long i,j; bool earfound; if(poly->GetNumPoints() < 3) return 0; if(poly->GetNumPoints() == 3) { triangles->push_back(*poly); return 1; } numvertices = poly->GetNumPoints(); vertices = new PartitionVertex[numvertices]; for(i=0;iGetPoint(i); if(i==(numvertices-1)) vertices[i].next=&(vertices[0]); else vertices[i].next=&(vertices[i+1]); if(i==0) vertices[i].previous = &(vertices[numvertices-1]); else vertices[i].previous = &(vertices[i-1]); } for(i=0;i ear->angle) { ear = &(vertices[j]); } } } if(!earfound) { delete [] vertices; return 0; } triangle.Triangle(ear->previous->p,ear->p,ear->next->p); triangles->push_back(triangle); ear->isActive = false; ear->previous->next = ear->next; ear->next->previous = ear->previous; if(i==numvertices-4) break; UpdateVertex(ear->previous,vertices,numvertices); UpdateVertex(ear->next,vertices,numvertices); } for(i=0;ip,vertices[i].p,vertices[i].next->p); triangles->push_back(triangle); break; } } delete [] vertices; return 1; } int TPPLPartition::Triangulate_EC(list *inpolys, list *triangles) { list outpolys; list::iterator iter; if(!RemoveHoles(inpolys,&outpolys)) return 0; for(iter=outpolys.begin();iter!=outpolys.end();++iter) { if(!Triangulate_EC(&(*iter),triangles)) return 0; } return 1; } int TPPLPartition::ConvexPartition_HM(TPPLPoly *poly, list *parts) { list triangles; list::iterator iter1,iter2; TPPLPoly *poly1,*poly2; TPPLPoly newpoly; TPPLPoint d1,d2,p1,p2,p3; long i11,i12,i21,i22,i13,i23,j,k; bool isdiagonal; long numreflex; //check if the poly is already convex numreflex = 0; for(i11=0;i11GetNumPoints();i11++) { if(i11==0) i12 = poly->GetNumPoints()-1; else i12=i11-1; if(i11==(poly->GetNumPoints()-1)) i13=0; else i13=i11+1; if(IsReflex(poly->GetPoint(i12),poly->GetPoint(i11),poly->GetPoint(i13))) { numreflex = 1; break; } } if(numreflex == 0) { parts->push_back(*poly); return 1; } if(!Triangulate_EC(poly,&triangles)) return 0; for(iter1 = triangles.begin(); iter1 != triangles.end(); ++iter1) { poly1 = &(*iter1); for(i11=0;i11GetNumPoints();i11++) { d1 = poly1->GetPoint(i11); i12 = (i11+1)%(poly1->GetNumPoints()); d2 = poly1->GetPoint(i12); isdiagonal = false; for(iter2 = iter1; iter2 != triangles.end(); ++iter2) { if(iter1 == iter2) continue; poly2 = &(*iter2); for(i21=0;i21GetNumPoints();i21++) { if((d2.x != poly2->GetPoint(i21).x)||(d2.y != poly2->GetPoint(i21).y)) continue; i22 = (i21+1)%(poly2->GetNumPoints()); if((d1.x != poly2->GetPoint(i22).x)||(d1.y != poly2->GetPoint(i22).y)) continue; isdiagonal = true; break; } if(isdiagonal) break; } if(!isdiagonal) continue; p2 = poly1->GetPoint(i11); if(i11 == 0) i13 = poly1->GetNumPoints()-1; else i13 = i11-1; p1 = poly1->GetPoint(i13); if(i22 == (poly2->GetNumPoints()-1)) i23 = 0; else i23 = i22+1; p3 = poly2->GetPoint(i23); if(!IsConvex(p1,p2,p3)) continue; p2 = poly1->GetPoint(i12); if(i12 == (poly1->GetNumPoints()-1)) i13 = 0; else i13 = i12+1; p3 = poly1->GetPoint(i13); if(i21 == 0) i23 = poly2->GetNumPoints()-1; else i23 = i21-1; p1 = poly2->GetPoint(i23); if(!IsConvex(p1,p2,p3)) continue; newpoly.Init(poly1->GetNumPoints()+poly2->GetNumPoints()-2); k = 0; for(j=i12;j!=i11;j=(j+1)%(poly1->GetNumPoints())) { newpoly[k] = poly1->GetPoint(j); k++; } for(j=i22;j!=i21;j=(j+1)%(poly2->GetNumPoints())) { newpoly[k] = poly2->GetPoint(j); k++; } triangles.erase(iter2); *iter1 = newpoly; poly1 = &(*iter1); i11 = -1; continue; } } for(iter1 = triangles.begin(); iter1 != triangles.end(); ++iter1) { parts->push_back(*iter1); } return 1; } int TPPLPartition::ConvexPartition_HM(list *inpolys, list *parts) { list outpolys; list::iterator iter; if(!RemoveHoles(inpolys,&outpolys)) return 0; for(iter=outpolys.begin();iter!=outpolys.end();++iter) { if(!ConvexPartition_HM(&(*iter),parts)) return 0; } return 1; } //minimum-weight polygon triangulation by dynamic programming //O(n^3) time complexity //O(n^2) space complexity int TPPLPartition::Triangulate_OPT(TPPLPoly *poly, list *triangles) { long i,j,k,gap,n; DPState **dpstates; TPPLPoint p1,p2,p3,p4; long bestvertex; tppl_float weight,minweight,d1,d2; Diagonal diagonal,newdiagonal; list diagonals; TPPLPoly triangle; int ret = 1; n = poly->GetNumPoints(); dpstates = new DPState *[n]; for(i=1;iGetPoint(i); for(j=i+1;jGetPoint(j); //visibility check if(i==0) p3 = poly->GetPoint(n-1); else p3 = poly->GetPoint(i-1); if(i==(n-1)) p4 = poly->GetPoint(0); else p4 = poly->GetPoint(i+1); if(!InCone(p3,p1,p4,p2)) { dpstates[j][i].visible = false; continue; } if(j==0) p3 = poly->GetPoint(n-1); else p3 = poly->GetPoint(j-1); if(j==(n-1)) p4 = poly->GetPoint(0); else p4 = poly->GetPoint(j+1); if(!InCone(p3,p2,p4,p1)) { dpstates[j][i].visible = false; continue; } for(k=0;kGetPoint(k); if(k==(n-1)) p4 = poly->GetPoint(0); else p4 = poly->GetPoint(k+1); if(Intersects(p1,p2,p3,p4)) { dpstates[j][i].visible = false; break; } } } } } dpstates[n-1][0].visible = true; dpstates[n-1][0].weight = 0; dpstates[n-1][0].bestvertex = -1; for(gap = 2; gapGetPoint(i),poly->GetPoint(k)); if(j<=(k+1)) d2=0; else d2 = Distance(poly->GetPoint(k),poly->GetPoint(j)); weight = dpstates[k][i].weight + dpstates[j][k].weight + d1 + d2; if((bestvertex == -1)||(weightGetPoint(diagonal.index1),poly->GetPoint(bestvertex),poly->GetPoint(diagonal.index2)); triangles->push_back(triangle); if(bestvertex > (diagonal.index1+1)) { newdiagonal.index1 = diagonal.index1; newdiagonal.index2 = bestvertex; diagonals.push_back(newdiagonal); } if(diagonal.index2 > (bestvertex+1)) { newdiagonal.index1 = bestvertex; newdiagonal.index2 = diagonal.index2; diagonals.push_back(newdiagonal); } } for(i=1;i *pairs; long w2; w2 = dpstates[a][b].weight; if(w>w2) return; pairs = &(dpstates[a][b].pairs); newdiagonal.index1 = i; newdiagonal.index2 = j; if(wclear(); pairs->push_front(newdiagonal); dpstates[a][b].weight = w; } else { if((!pairs->empty())&&(i <= pairs->begin()->index1)) return; while((!pairs->empty())&&(pairs->begin()->index2 >= j)) pairs->pop_front(); pairs->push_front(newdiagonal); } } void TPPLPartition::TypeA(long i, long j, long k, PartitionVertex *vertices, DPState2 **dpstates) { list *pairs; list::iterator iter,lastiter; long top; long w; if(!dpstates[i][j].visible) return; top = j; w = dpstates[i][j].weight; if(k-j > 1) { if (!dpstates[j][k].visible) return; w += dpstates[j][k].weight + 1; } if(j-i > 1) { pairs = &(dpstates[i][j].pairs); iter = pairs->end(); lastiter = pairs->end(); while(iter!=pairs->begin()) { --iter; if(!IsReflex(vertices[iter->index2].p,vertices[j].p,vertices[k].p)) lastiter = iter; else break; } if(lastiter == pairs->end()) w++; else { if(IsReflex(vertices[k].p,vertices[i].p,vertices[lastiter->index1].p)) w++; else top = lastiter->index1; } } UpdateState(i,k,w,top,j,dpstates); } void TPPLPartition::TypeB(long i, long j, long k, PartitionVertex *vertices, DPState2 **dpstates) { list *pairs; list::iterator iter,lastiter; long top; long w; if(!dpstates[j][k].visible) return; top = j; w = dpstates[j][k].weight; if (j-i > 1) { if (!dpstates[i][j].visible) return; w += dpstates[i][j].weight + 1; } if (k-j > 1) { pairs = &(dpstates[j][k].pairs); iter = pairs->begin(); if((!pairs->empty())&&(!IsReflex(vertices[i].p,vertices[j].p,vertices[iter->index1].p))) { lastiter = iter; while(iter!=pairs->end()) { if(!IsReflex(vertices[i].p,vertices[j].p,vertices[iter->index1].p)) { lastiter = iter; ++iter; } else break; } if(IsReflex(vertices[lastiter->index2].p,vertices[k].p,vertices[i].p)) w++; else top = lastiter->index2; } else w++; } UpdateState(i,k,w,j,top,dpstates); } int TPPLPartition::ConvexPartition_OPT(TPPLPoly *poly, list *parts) { TPPLPoint p1,p2,p3,p4; PartitionVertex *vertices; DPState2 **dpstates; long i,j,k,n,gap; list diagonals,diagonals2; Diagonal diagonal,newdiagonal; list *pairs,*pairs2; list::iterator iter,iter2; int ret; TPPLPoly newpoly; list indices; list::iterator iiter; bool ijreal,jkreal; n = poly->GetNumPoints(); vertices = new PartitionVertex[n]; dpstates = new DPState2 *[n]; for(i=0;iGetPoint(i); vertices[i].isActive = true; if(i==0) vertices[i].previous = &(vertices[n-1]); else vertices[i].previous = &(vertices[i-1]); if(i==(poly->GetNumPoints()-1)) vertices[i].next = &(vertices[0]); else vertices[i].next = &(vertices[i+1]); } for(i=1;iGetPoint(i); for(j=i+1;jGetPoint(j); //visibility check if(!InCone(&vertices[i],p2)) { dpstates[i][j].visible = false; continue; } if(!InCone(&vertices[j],p1)) { dpstates[i][j].visible = false; continue; } for(k=0;kGetPoint(k); if(k==(n-1)) p4 = poly->GetPoint(0); else p4 = poly->GetPoint(k+1); if(Intersects(p1,p2,p3,p4)) { dpstates[i][j].visible = false; break; } } } } } for(i=0;i<(n-2);i++) { j = i+2; if(dpstates[i][j].visible) { dpstates[i][j].weight = 0; newdiagonal.index1 = i+1; newdiagonal.index2 = i+1; dpstates[i][j].pairs.push_back(newdiagonal); } } dpstates[0][n-1].visible = true; vertices[0].isConvex = false; //by convention for(gap=3; gapempty()) { ret = 0; break; } if(!vertices[diagonal.index1].isConvex) { iter = pairs->end(); --iter; j = iter->index2; newdiagonal.index1 = j; newdiagonal.index2 = diagonal.index2; diagonals.push_front(newdiagonal); if((j - diagonal.index1)>1) { if(iter->index1 != iter->index2) { pairs2 = &(dpstates[diagonal.index1][j].pairs); while(1) { if(pairs2->empty()) { ret = 0; break; } iter2 = pairs2->end(); --iter2; if(iter->index1 != iter2->index1) pairs2->pop_back(); else break; } if(ret == 0) break; } newdiagonal.index1 = diagonal.index1; newdiagonal.index2 = j; diagonals.push_front(newdiagonal); } } else { iter = pairs->begin(); j = iter->index1; newdiagonal.index1 = diagonal.index1; newdiagonal.index2 = j; diagonals.push_front(newdiagonal); if((diagonal.index2 - j) > 1) { if(iter->index1 != iter->index2) { pairs2 = &(dpstates[j][diagonal.index2].pairs); while(1) { if(pairs2->empty()) { ret = 0; break; } iter2 = pairs2->begin(); if(iter->index2 != iter2->index2) pairs2->pop_front(); else break; } if(ret == 0) break; } newdiagonal.index1 = j; newdiagonal.index2 = diagonal.index2; diagonals.push_front(newdiagonal); } } } if(ret == 0) { for(i=0;iend(); --iter; j = iter->index2; if(iter->index1 != iter->index2) ijreal = false; } else { iter = pairs->begin(); j = iter->index1; if(iter->index1 != iter->index2) jkreal = false; } newdiagonal.index1 = diagonal.index1; newdiagonal.index2 = j; if(ijreal) { diagonals.push_back(newdiagonal); } else { diagonals2.push_back(newdiagonal); } newdiagonal.index1 = j; newdiagonal.index2 = diagonal.index2; if(jkreal) { diagonals.push_back(newdiagonal); } else { diagonals2.push_back(newdiagonal); } indices.push_back(j); } indices.sort(); newpoly.Init((long)indices.size()); k=0; for(iiter = indices.begin();iiter!=indices.end(); ++iiter) { newpoly[k] = vertices[*iiter].p; k++; } parts->push_back(newpoly); } for(i=0;i *inpolys, list *monotonePolys) { list::iterator iter; MonotoneVertex *vertices; long i,numvertices,vindex,vindex2,newnumvertices,maxnumvertices; long polystartindex, polyendindex; TPPLPoly *poly; MonotoneVertex *v,*v2,*vprev,*vnext; ScanLineEdge newedge; bool error = false; numvertices = 0; for(iter = inpolys->begin(); iter != inpolys->end(); ++iter) { numvertices += iter->GetNumPoints(); } maxnumvertices = numvertices*3; vertices = new MonotoneVertex[maxnumvertices]; newnumvertices = numvertices; polystartindex = 0; for(iter = inpolys->begin(); iter != inpolys->end(); ++iter) { poly = &(*iter); polyendindex = polystartindex + poly->GetNumPoints()-1; for(i=0;iGetNumPoints();i++) { vertices[i+polystartindex].p = poly->GetPoint(i); if(i==0) vertices[i+polystartindex].previous = polyendindex; else vertices[i+polystartindex].previous = i+polystartindex-1; if(i==(poly->GetNumPoints()-1)) vertices[i+polystartindex].next = polystartindex; else vertices[i+polystartindex].next = i+polystartindex+1; } polystartindex = polyendindex+1; } //construct the priority queue long *priority = new long [numvertices]; for(i=0;iprevious]); vnext = &(vertices[v->next]); if(Below(vprev->p,v->p)&&Below(vnext->p,v->p)) { if(IsConvex(vnext->p,vprev->p,v->p)) { vertextypes[i] = TPPL_VERTEXTYPE_START; } else { vertextypes[i] = TPPL_VERTEXTYPE_SPLIT; } } else if(Below(v->p,vprev->p)&&Below(v->p,vnext->p)) { if(IsConvex(vnext->p,vprev->p,v->p)) { vertextypes[i] = TPPL_VERTEXTYPE_END; } else { vertextypes[i] = TPPL_VERTEXTYPE_MERGE; } } else { vertextypes[i] = TPPL_VERTEXTYPE_REGULAR; } } //helpers long *helpers = new long[maxnumvertices]; //binary search tree that holds edges intersecting the scanline //note that while set doesn't actually have to be implemented as a tree //complexity requirements for operations are the same as for the balanced binary search tree set edgeTree; //store iterators to the edge tree elements //this makes deleting existing edges much faster set::iterator *edgeTreeIterators,edgeIter; edgeTreeIterators = new set::iterator[maxnumvertices]; pair::iterator,bool> edgeTreeRet; //for each vertex for(i=0;ip; newedge.p2 = vertices[v->next].p; newedge.index = vindex; edgeTreeRet = edgeTree.insert(newedge); edgeTreeIterators[vindex] = edgeTreeRet.first; helpers[vindex] = vindex; break; case TPPL_VERTEXTYPE_END: //if helper(ei-1) is a merge vertex if(vertextypes[helpers[v->previous]]==TPPL_VERTEXTYPE_MERGE) { //Insert the diagonal connecting vi to helper(ei-1) in D. AddDiagonal(vertices,&newnumvertices,vindex,helpers[v->previous]); vertextypes[newnumvertices-2] = vertextypes[vindex]; edgeTreeIterators[newnumvertices-2] = edgeTreeIterators[vindex]; helpers[newnumvertices-2] = helpers[vindex]; vertextypes[newnumvertices-1] = vertextypes[helpers[v->previous]]; edgeTreeIterators[newnumvertices-1] = edgeTreeIterators[helpers[v->previous]]; helpers[newnumvertices-1] = helpers[helpers[v->previous]]; } //Delete ei-1 from T edgeTree.erase(edgeTreeIterators[v->previous]); break; case TPPL_VERTEXTYPE_SPLIT: //Search in T to find the edge e j directly left of vi. newedge.p1 = v->p; newedge.p2 = v->p; edgeIter = edgeTree.lower_bound(newedge); if(edgeIter == edgeTree.begin()) { error = true; break; } --edgeIter; //Insert the diagonal connecting vi to helper(ej) in D. AddDiagonal(vertices,&newnumvertices,vindex,helpers[edgeIter->index]); vertextypes[newnumvertices-2] = vertextypes[vindex]; edgeTreeIterators[newnumvertices-2] = edgeTreeIterators[vindex]; helpers[newnumvertices-2] = helpers[vindex]; vertextypes[newnumvertices-1] = vertextypes[helpers[edgeIter->index]]; edgeTreeIterators[newnumvertices-1] = edgeTreeIterators[helpers[edgeIter->index]]; helpers[newnumvertices-1] = helpers[helpers[edgeIter->index]]; vindex2 = newnumvertices-2; v2 = &(vertices[vindex2]); //helper(e j)�vi helpers[edgeIter->index] = vindex; //Insert ei in T and set helper(ei) to vi. newedge.p1 = v2->p; newedge.p2 = vertices[v2->next].p; newedge.index = vindex2; edgeTreeRet = edgeTree.insert(newedge); edgeTreeIterators[vindex2] = edgeTreeRet.first; helpers[vindex2] = vindex2; break; case TPPL_VERTEXTYPE_MERGE: //if helper(ei-1) is a merge vertex if(vertextypes[helpers[v->previous]]==TPPL_VERTEXTYPE_MERGE) { //Insert the diagonal connecting vi to helper(ei-1) in D. AddDiagonal(vertices,&newnumvertices,vindex,helpers[v->previous]); vertextypes[newnumvertices-2] = vertextypes[vindex]; edgeTreeIterators[newnumvertices-2] = edgeTreeIterators[vindex]; helpers[newnumvertices-2] = helpers[vindex]; vertextypes[newnumvertices-1] = vertextypes[helpers[v->previous]]; edgeTreeIterators[newnumvertices-1] = edgeTreeIterators[helpers[v->previous]]; helpers[newnumvertices-1] = helpers[helpers[v->previous]]; vindex2 = newnumvertices-2; v2 = &(vertices[vindex2]); } //Delete ei-1 from T. edgeTree.erase(edgeTreeIterators[v->previous]); //Search in T to find the edge e j directly left of vi. newedge.p1 = v->p; newedge.p2 = v->p; edgeIter = edgeTree.lower_bound(newedge); if(edgeIter == edgeTree.begin()) { error = true; break; } --edgeIter; //if helper(ej) is a merge vertex if(vertextypes[helpers[edgeIter->index]]==TPPL_VERTEXTYPE_MERGE) { //Insert the diagonal connecting vi to helper(e j) in D. AddDiagonal(vertices,&newnumvertices,vindex2,helpers[edgeIter->index]); vertextypes[newnumvertices-2] = vertextypes[vindex2]; edgeTreeIterators[newnumvertices-2] = edgeTreeIterators[vindex2]; helpers[newnumvertices-2] = helpers[vindex2]; vertextypes[newnumvertices-1] = vertextypes[helpers[edgeIter->index]]; edgeTreeIterators[newnumvertices-1] = edgeTreeIterators[helpers[edgeIter->index]]; helpers[newnumvertices-1] = helpers[helpers[edgeIter->index]]; } //helper(e j)�vi helpers[edgeIter->index] = vindex2; break; case TPPL_VERTEXTYPE_REGULAR: //if the interior of P lies to the right of vi if(Below(v->p,vertices[v->previous].p)) { //if helper(ei-1) is a merge vertex if(vertextypes[helpers[v->previous]]==TPPL_VERTEXTYPE_MERGE) { //Insert the diagonal connecting vi to helper(ei-1) in D. AddDiagonal(vertices,&newnumvertices,vindex,helpers[v->previous]); vertextypes[newnumvertices-2] = vertextypes[vindex]; edgeTreeIterators[newnumvertices-2] = edgeTreeIterators[vindex]; helpers[newnumvertices-2] = helpers[vindex]; vertextypes[newnumvertices-1] = vertextypes[helpers[v->previous]]; edgeTreeIterators[newnumvertices-1] = edgeTreeIterators[helpers[v->previous]]; helpers[newnumvertices-1] = helpers[helpers[v->previous]]; vindex2 = newnumvertices-2; v2 = &(vertices[vindex2]); } //Delete ei-1 from T. edgeTree.erase(edgeTreeIterators[v->previous]); //Insert ei in T and set helper(ei) to vi. newedge.p1 = v2->p; newedge.p2 = vertices[v2->next].p; newedge.index = vindex2; edgeTreeRet = edgeTree.insert(newedge); edgeTreeIterators[vindex2] = edgeTreeRet.first; helpers[vindex2] = vindex; } else { //Search in T to find the edge ej directly left of vi. newedge.p1 = v->p; newedge.p2 = v->p; edgeIter = edgeTree.lower_bound(newedge); if(edgeIter == edgeTree.begin()) { error = true; break; } --edgeIter; //if helper(ej) is a merge vertex if(vertextypes[helpers[edgeIter->index]]==TPPL_VERTEXTYPE_MERGE) { //Insert the diagonal connecting vi to helper(e j) in D. AddDiagonal(vertices,&newnumvertices,vindex,helpers[edgeIter->index]); vertextypes[newnumvertices-2] = vertextypes[vindex]; edgeTreeIterators[newnumvertices-2] = edgeTreeIterators[vindex]; helpers[newnumvertices-2] = helpers[vindex]; vertextypes[newnumvertices-1] = vertextypes[helpers[edgeIter->index]]; edgeTreeIterators[newnumvertices-1] = edgeTreeIterators[helpers[edgeIter->index]]; helpers[newnumvertices-1] = helpers[helpers[edgeIter->index]]; } //helper(e j)�vi helpers[edgeIter->index] = vindex; } break; } if(error) break; } char *used = new char[newnumvertices]; memset(used,0,newnumvertices*sizeof(char)); if(!error) { //return result long size; TPPLPoly mpoly; for(i=0;inext]); size = 1; while(vnext!=v) { vnext = &(vertices[vnext->next]); size++; } mpoly.Init(size); v = &(vertices[i]); mpoly[0] = v->p; vnext = &(vertices[v->next]); size = 1; used[i] = 1; used[v->next] = 1; while(vnext!=v) { mpoly[size] = vnext->p; used[vnext->next] = 1; vnext = &(vertices[vnext->next]); size++; } monotonePolys->push_back(mpoly); } } //cleanup delete [] vertices; delete [] priority; delete [] vertextypes; delete [] edgeTreeIterators; delete [] helpers; delete [] used; if(error) { return 0; } else { return 1; } } //adds a diagonal to the doubly-connected list of vertices void TPPLPartition::AddDiagonal(MonotoneVertex *vertices, long *numvertices, long index1, long index2) { long newindex1,newindex2; newindex1 = *numvertices; (*numvertices)++; newindex2 = *numvertices; (*numvertices)++; vertices[newindex1].p = vertices[index1].p; vertices[newindex2].p = vertices[index2].p; vertices[newindex2].next = vertices[index2].next; vertices[newindex1].next = vertices[index1].next; vertices[vertices[index2].next].previous = newindex2; vertices[vertices[index1].next].previous = newindex1; vertices[index1].next = newindex2; vertices[newindex2].previous = index1; vertices[index2].next = newindex1; vertices[newindex1].previous = index2; } bool TPPLPartition::Below(TPPLPoint &p1, TPPLPoint &p2) { if(p1.y < p2.y) return true; else if(p1.y == p2.y) { if(p1.x < p2.x) return true; } return false; } //sorts in the falling order of y values, if y is equal, x is used instead bool TPPLPartition::VertexSorter::operator() (long index1, long index2) const { if(vertices[index1].p.y > vertices[index2].p.y) return true; else if(vertices[index1].p.y == vertices[index2].p.y) { if(vertices[index1].p.x > vertices[index2].p.x) return true; } return false; } bool TPPLPartition::ScanLineEdge::IsConvex(const TPPLPoint& p1, const TPPLPoint& p2, const TPPLPoint& p3) const { tppl_float tmp; tmp = (p3.y-p1.y)*(p2.x-p1.x)-(p3.x-p1.x)*(p2.y-p1.y); if(tmp>0) return 1; else return 0; } bool TPPLPartition::ScanLineEdge::operator < (const ScanLineEdge & other) const { if(other.p1.y == other.p2.y) { if(p1.y == p2.y) { if(p1.y < other.p1.y) return true; else return false; } if(IsConvex(p1,p2,other.p1)) return true; else return false; } else if(p1.y == p2.y) { if(IsConvex(other.p1,other.p2,p1)) return false; else return true; } else if(p1.y < other.p1.y) { if(IsConvex(other.p1,other.p2,p1)) return false; else return true; } else { if(IsConvex(p1,p2,other.p1)) return true; else return false; } } //triangulates monotone polygon //O(n) time, O(n) space complexity int TPPLPartition::TriangulateMonotone(TPPLPoly *inPoly, list *triangles) { long i,i2,j,topindex,bottomindex,leftindex,rightindex,vindex; TPPLPoint *points; long numpoints; TPPLPoly triangle; numpoints = inPoly->GetNumPoints(); points = inPoly->GetPoints(); //trivial calses if(numpoints < 3) return 0; if(numpoints == 3) { triangles->push_back(*inPoly); } topindex = 0; bottomindex=0; for(i=1;i=numpoints) i2 = 0; if(!Below(points[i2],points[i])) return 0; i = i2; } i = bottomindex; while(i!=topindex) { i2 = i+1; if(i2>=numpoints) i2 = 0; if(!Below(points[i],points[i2])) return 0; i = i2; } char *vertextypes = new char[numpoints]; long *priority = new long[numpoints]; //merge left and right vertex chains priority[0] = topindex; vertextypes[topindex] = 0; leftindex = topindex+1; if(leftindex>=numpoints) leftindex = 0; rightindex = topindex-1; if(rightindex<0) rightindex = numpoints-1; for(i=1;i<(numpoints-1);i++) { if(leftindex==bottomindex) { priority[i] = rightindex; rightindex--; if(rightindex<0) rightindex = numpoints-1; vertextypes[priority[i]] = -1; } else if(rightindex==bottomindex) { priority[i] = leftindex; leftindex++; if(leftindex>=numpoints) leftindex = 0; vertextypes[priority[i]] = 1; } else { if(Below(points[leftindex],points[rightindex])) { priority[i] = rightindex; rightindex--; if(rightindex<0) rightindex = numpoints-1; vertextypes[priority[i]] = -1; } else { priority[i] = leftindex; leftindex++; if(leftindex>=numpoints) leftindex = 0; vertextypes[priority[i]] = 1; } } } priority[i] = bottomindex; vertextypes[bottomindex] = 0; long *stack = new long[numpoints]; long stackptr = 0; stack[0] = priority[0]; stack[1] = priority[1]; stackptr = 2; //for each vertex from top to bottom trim as many triangles as possible for(i=2;i<(numpoints-1);i++) { vindex = priority[i]; if(vertextypes[vindex]!=vertextypes[stack[stackptr-1]]) { for(j=0;j<(stackptr-1);j++) { if(vertextypes[vindex]==1) { triangle.Triangle(points[stack[j+1]],points[stack[j]],points[vindex]); } else { triangle.Triangle(points[stack[j]],points[stack[j+1]],points[vindex]); } triangles->push_back(triangle); } stack[0] = priority[i-1]; stack[1] = priority[i]; stackptr = 2; } else { stackptr--; while(stackptr>0) { if(vertextypes[vindex]==1) { if(IsConvex(points[vindex],points[stack[stackptr-1]],points[stack[stackptr]])) { triangle.Triangle(points[vindex],points[stack[stackptr-1]],points[stack[stackptr]]); triangles->push_back(triangle); stackptr--; } else { break; } } else { if(IsConvex(points[vindex],points[stack[stackptr]],points[stack[stackptr-1]])) { triangle.Triangle(points[vindex],points[stack[stackptr]],points[stack[stackptr-1]]); triangles->push_back(triangle); stackptr--; } else { break; } } } stackptr++; stack[stackptr] = vindex; stackptr++; } } vindex = priority[i]; for(j=0;j<(stackptr-1);j++) { if(vertextypes[stack[j+1]]==1) { triangle.Triangle(points[stack[j]],points[stack[j+1]],points[vindex]); } else { triangle.Triangle(points[stack[j+1]],points[stack[j]],points[vindex]); } triangles->push_back(triangle); } delete [] priority; delete [] vertextypes; delete [] stack; return 1; } int TPPLPartition::Triangulate_MONO(list *inpolys, list *triangles) { list monotone; list::iterator iter; if(!MonotonePartition(inpolys,&monotone)) return 0; for(iter = monotone.begin(); iter!=monotone.end(); ++iter) { if(!TriangulateMonotone(&(*iter),triangles)) return 0; } return 1; } int TPPLPartition::Triangulate_MONO(TPPLPoly *poly, list *triangles) { list polys; polys.push_back(*poly); return Triangulate_MONO(&polys, triangles); } Slic3r-version_1.31.6/xs/src/polypartition.h000066400000000000000000000271271301441720000210160ustar00rootroot00000000000000//Copyright (C) 2011 by Ivan Fratric // //Permission is hereby granted, free of charge, to any person obtaining a copy //of this software and associated documentation files (the "Software"), to deal //in the Software without restriction, including without limitation the rights //to use, copy, modify, merge, publish, distribute, sublicense, and/or sell //copies of the Software, and to permit persons to whom the Software is //furnished to do so, subject to the following conditions: // //The above copyright notice and this permission notice shall be included in //all copies or substantial portions of the Software. // //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN //THE SOFTWARE. #include using namespace std; typedef double tppl_float; #define TPPL_CCW 1 #define TPPL_CW -1 //2D point structure struct TPPLPoint { tppl_float x; tppl_float y; TPPLPoint operator + (const TPPLPoint& p) const { TPPLPoint r; r.x = x + p.x; r.y = y + p.y; return r; } TPPLPoint operator - (const TPPLPoint& p) const { TPPLPoint r; r.x = x - p.x; r.y = y - p.y; return r; } TPPLPoint operator * (const tppl_float f ) const { TPPLPoint r; r.x = x*f; r.y = y*f; return r; } TPPLPoint operator / (const tppl_float f ) const { TPPLPoint r; r.x = x/f; r.y = y/f; return r; } bool operator==(const TPPLPoint& p) const { if((x == p.x)&&(y==p.y)) return true; else return false; } bool operator!=(const TPPLPoint& p) const { if((x == p.x)&&(y==p.y)) return false; else return true; } }; //Polygon implemented as an array of points with a 'hole' flag class TPPLPoly { protected: TPPLPoint *points; long numpoints; bool hole; public: //constructors/destructors TPPLPoly(); ~TPPLPoly(); TPPLPoly(const TPPLPoly &src); TPPLPoly& operator=(const TPPLPoly &src); //getters and setters long GetNumPoints() const { return numpoints; } bool IsHole() const { return hole; } void SetHole(bool hole) { this->hole = hole; } TPPLPoint &GetPoint(long i) { return points[i]; } TPPLPoint *GetPoints() { return points; } TPPLPoint& operator[] (int i) { return points[i]; } //clears the polygon points void Clear(); //inits the polygon with numpoints vertices void Init(long numpoints); //creates a triangle with points p1,p2,p3 void Triangle(TPPLPoint &p1, TPPLPoint &p2, TPPLPoint &p3); //inverts the orfer of vertices void Invert(); //returns the orientation of the polygon //possible values: // TPPL_CCW : polygon vertices are in counter-clockwise order // TPPL_CW : polygon vertices are in clockwise order // 0 : the polygon has no (measurable) area int GetOrientation() const; //sets the polygon orientation //orientation can be // TPPL_CCW : sets vertices in counter-clockwise order // TPPL_CW : sets vertices in clockwise order void SetOrientation(int orientation); }; class TPPLPartition { protected: struct PartitionVertex { bool isActive; bool isConvex; bool isEar; TPPLPoint p; tppl_float angle; PartitionVertex *previous; PartitionVertex *next; }; struct MonotoneVertex { TPPLPoint p; long previous; long next; }; class VertexSorter{ MonotoneVertex *vertices; public: VertexSorter(MonotoneVertex *v) : vertices(v) {} bool operator() (long index1, long index2) const; }; struct Diagonal { long index1; long index2; }; //dynamic programming state for minimum-weight triangulation struct DPState { bool visible; tppl_float weight; long bestvertex; }; //dynamic programming state for convex partitioning struct DPState2 { bool visible; long weight; list pairs; }; //edge that intersects the scanline struct ScanLineEdge { long index; TPPLPoint p1; TPPLPoint p2; //determines if the edge is to the left of another edge bool operator< (const ScanLineEdge & other) const; bool IsConvex(const TPPLPoint& p1, const TPPLPoint& p2, const TPPLPoint& p3) const; }; //standard helper functions bool IsConvex(TPPLPoint& p1, TPPLPoint& p2, TPPLPoint& p3); bool IsReflex(TPPLPoint& p1, TPPLPoint& p2, TPPLPoint& p3); bool IsInside(TPPLPoint& p1, TPPLPoint& p2, TPPLPoint& p3, TPPLPoint &p); bool InCone(TPPLPoint &p1, TPPLPoint &p2, TPPLPoint &p3, TPPLPoint &p); bool InCone(PartitionVertex *v, TPPLPoint &p); int Intersects(TPPLPoint &p11, TPPLPoint &p12, TPPLPoint &p21, TPPLPoint &p22); TPPLPoint Normalize(const TPPLPoint &p); tppl_float Distance(const TPPLPoint &p1, const TPPLPoint &p2); //helper functions for Triangulate_EC void UpdateVertexReflexity(PartitionVertex *v); void UpdateVertex(PartitionVertex *v,PartitionVertex *vertices, long numvertices); //helper functions for ConvexPartition_OPT void UpdateState(long a, long b, long w, long i, long j, DPState2 **dpstates); void TypeA(long i, long j, long k, PartitionVertex *vertices, DPState2 **dpstates); void TypeB(long i, long j, long k, PartitionVertex *vertices, DPState2 **dpstates); //helper functions for MonotonePartition bool Below(TPPLPoint &p1, TPPLPoint &p2); void AddDiagonal(MonotoneVertex *vertices, long *numvertices, long index1, long index2); //triangulates a monotone polygon, used in Triangulate_MONO int TriangulateMonotone(TPPLPoly *inPoly, list *triangles); public: //simple heuristic procedure for removing holes from a list of polygons //works by creating a diagonal from the rightmost hole vertex to some visible vertex //time complexity: O(h*(n^2)), h is the number of holes, n is the number of vertices //space complexity: O(n) //params: // inpolys : a list of polygons that can contain holes // vertices of all non-hole polys have to be in counter-clockwise order // vertices of all hole polys have to be in clockwise order // outpolys : a list of polygons without holes //returns 1 on success, 0 on failure int RemoveHoles(list *inpolys, list *outpolys); //triangulates a polygon by ear clipping //time complexity O(n^2), n is the number of vertices //space complexity: O(n) //params: // poly : an input polygon to be triangulated // vertices have to be in counter-clockwise order // triangles : a list of triangles (result) //returns 1 on success, 0 on failure int Triangulate_EC(TPPLPoly *poly, list *triangles); //triangulates a list of polygons that may contain holes by ear clipping algorithm //first calls RemoveHoles to get rid of the holes, and then Triangulate_EC for each resulting polygon //time complexity: O(h*(n^2)), h is the number of holes, n is the number of vertices //space complexity: O(n) //params: // inpolys : a list of polygons to be triangulated (can contain holes) // vertices of all non-hole polys have to be in counter-clockwise order // vertices of all hole polys have to be in clockwise order // triangles : a list of triangles (result) //returns 1 on success, 0 on failure int Triangulate_EC(list *inpolys, list *triangles); //creates an optimal polygon triangulation in terms of minimal edge length //time complexity: O(n^3), n is the number of vertices //space complexity: O(n^2) //params: // poly : an input polygon to be triangulated // vertices have to be in counter-clockwise order // triangles : a list of triangles (result) //returns 1 on success, 0 on failure int Triangulate_OPT(TPPLPoly *poly, list *triangles); //triangulates a polygons by firstly partitioning it into monotone polygons //time complexity: O(n*log(n)), n is the number of vertices //space complexity: O(n) //params: // poly : an input polygon to be triangulated // vertices have to be in counter-clockwise order // triangles : a list of triangles (result) //returns 1 on success, 0 on failure int Triangulate_MONO(TPPLPoly *poly, list *triangles); //triangulates a list of polygons by firstly partitioning them into monotone polygons //time complexity: O(n*log(n)), n is the number of vertices //space complexity: O(n) //params: // inpolys : a list of polygons to be triangulated (can contain holes) // vertices of all non-hole polys have to be in counter-clockwise order // vertices of all hole polys have to be in clockwise order // triangles : a list of triangles (result) //returns 1 on success, 0 on failure int Triangulate_MONO(list *inpolys, list *triangles); //creates a monotone partition of a list of polygons that can contain holes //time complexity: O(n*log(n)), n is the number of vertices //space complexity: O(n) //params: // inpolys : a list of polygons to be triangulated (can contain holes) // vertices of all non-hole polys have to be in counter-clockwise order // vertices of all hole polys have to be in clockwise order // monotonePolys : a list of monotone polygons (result) //returns 1 on success, 0 on failure int MonotonePartition(list *inpolys, list *monotonePolys); //partitions a polygon into convex polygons by using Hertel-Mehlhorn algorithm //the algorithm gives at most four times the number of parts as the optimal algorithm //however, in practice it works much better than that and often gives optimal partition //uses triangulation obtained by ear clipping as intermediate result //time complexity O(n^2), n is the number of vertices //space complexity: O(n) //params: // poly : an input polygon to be partitioned // vertices have to be in counter-clockwise order // parts : resulting list of convex polygons //returns 1 on success, 0 on failure int ConvexPartition_HM(TPPLPoly *poly, list *parts); //partitions a list of polygons into convex parts by using Hertel-Mehlhorn algorithm //the algorithm gives at most four times the number of parts as the optimal algorithm //however, in practice it works much better than that and often gives optimal partition //uses triangulation obtained by ear clipping as intermediate result //time complexity O(n^2), n is the number of vertices //space complexity: O(n) //params: // inpolys : an input list of polygons to be partitioned // vertices of all non-hole polys have to be in counter-clockwise order // vertices of all hole polys have to be in clockwise order // parts : resulting list of convex polygons //returns 1 on success, 0 on failure int ConvexPartition_HM(list *inpolys, list *parts); //optimal convex partitioning (in terms of number of resulting convex polygons) //using the Keil-Snoeyink algorithm //M. Keil, J. Snoeyink, "On the time bound for convex decomposition of simple polygons", 1998 //time complexity O(n^3), n is the number of vertices //space complexity: O(n^3) // poly : an input polygon to be partitioned // vertices have to be in counter-clockwise order // parts : resulting list of convex polygons //returns 1 on success, 0 on failure int ConvexPartition_OPT(TPPLPoly *poly, list *parts); }; Slic3r-version_1.31.6/xs/src/ppport.h000066400000000000000000005254061301441720000174300ustar00rootroot00000000000000#if 0 <<'SKIP'; #endif /* ---------------------------------------------------------------------- ppport.h -- Perl/Pollution/Portability Version 3.19 Automatically created by Devel::PPPort running under perl 5.010000. Do NOT edit this file directly! -- Edit PPPort_pm.PL and the includes in parts/inc/ instead. Use 'perldoc ppport.h' to view the documentation below. ---------------------------------------------------------------------- SKIP =pod =head1 NAME ppport.h - Perl/Pollution/Portability version 3.19 =head1 SYNOPSIS perl ppport.h [options] [source files] Searches current directory for files if no [source files] are given --help show short help --version show version --patch=file write one patch file with changes --copy=suffix write changed copies with suffix --diff=program use diff program and options --compat-version=version provide compatibility with Perl version --cplusplus accept C++ comments --quiet don't output anything except fatal errors --nodiag don't show diagnostics --nohints don't show hints --nochanges don't suggest changes --nofilter don't filter input files --strip strip all script and doc functionality from ppport.h --list-provided list provided API --list-unsupported list unsupported API --api-info=name show Perl API portability information =head1 COMPATIBILITY This version of F is designed to support operation with Perl installations back to 5.003, and has been tested up to 5.10.0. =head1 OPTIONS =head2 --help Display a brief usage summary. =head2 --version Display the version of F. =head2 --patch=I If this option is given, a single patch file will be created if any changes are suggested. This requires a working diff program to be installed on your system. =head2 --copy=I If this option is given, a copy of each file will be saved with the given suffix that contains the suggested changes. This does not require any external programs. Note that this does not automagially add a dot between the original filename and the suffix. If you want the dot, you have to include it in the option argument. If neither C<--patch> or C<--copy> are given, the default is to simply print the diffs for each file. This requires either C or a C program to be installed. =head2 --diff=I Manually set the diff program and options to use. The default is to use C, when installed, and output unified context diffs. =head2 --compat-version=I Tell F to check for compatibility with the given Perl version. The default is to check for compatibility with Perl version 5.003. You can use this option to reduce the output of F if you intend to be backward compatible only down to a certain Perl version. =head2 --cplusplus Usually, F will detect C++ style comments and replace them with C style comments for portability reasons. Using this option instructs F to leave C++ comments untouched. =head2 --quiet Be quiet. Don't print anything except fatal errors. =head2 --nodiag Don't output any diagnostic messages. Only portability alerts will be printed. =head2 --nohints Don't output any hints. Hints often contain useful portability notes. Warnings will still be displayed. =head2 --nochanges Don't suggest any changes. Only give diagnostic output and hints unless these are also deactivated. =head2 --nofilter Don't filter the list of input files. By default, files not looking like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped. =head2 --strip Strip all script and documentation functionality from F. This reduces the size of F dramatically and may be useful if you want to include F in smaller modules without increasing their distribution size too much. The stripped F will have a C<--unstrip> option that allows you to undo the stripping, but only if an appropriate C module is installed. =head2 --list-provided Lists the API elements for which compatibility is provided by F. Also lists if it must be explicitly requested, if it has dependencies, and if there are hints or warnings for it. =head2 --list-unsupported Lists the API elements that are known not to be supported by F and below which version of Perl they probably won't be available or work. =head2 --api-info=I Show portability information for API elements matching I. If I is surrounded by slashes, it is interpreted as a regular expression. =head1 DESCRIPTION In order for a Perl extension (XS) module to be as portable as possible across differing versions of Perl itself, certain steps need to be taken. =over 4 =item * Including this header is the first major one. This alone will give you access to a large part of the Perl API that hasn't been available in earlier Perl releases. Use perl ppport.h --list-provided to see which API elements are provided by ppport.h. =item * You should avoid using deprecated parts of the API. For example, using global Perl variables without the C prefix is deprecated. Also, some API functions used to have a C prefix. Using this form is also deprecated. You can safely use the supported API, as F will provide wrappers for older Perl versions. =item * If you use one of a few functions or variables that were not present in earlier versions of Perl, and that can't be provided using a macro, you have to explicitly request support for these functions by adding one or more C<#define>s in your source code before the inclusion of F. These functions or variables will be marked C in the list shown by C<--list-provided>. Depending on whether you module has a single or multiple files that use such functions or variables, you want either C or global variants. For a C function or variable (used only in a single source file), use: #define NEED_function #define NEED_variable For a global function or variable (used in multiple source files), use: #define NEED_function_GLOBAL #define NEED_variable_GLOBAL Note that you mustn't have more than one global request for the same function or variable in your project. Function / Variable Static Request Global Request ----------------------------------------------------------------------------------------- PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL grok_number() NEED_grok_number NEED_grok_number_GLOBAL grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL load_module() NEED_load_module NEED_load_module_GLOBAL my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL pv_display() NEED_pv_display NEED_pv_display_GLOBAL pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL vload_module() NEED_vload_module NEED_vload_module_GLOBAL vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL warner() NEED_warner NEED_warner_GLOBAL To avoid namespace conflicts, you can change the namespace of the explicitly exported functions / variables using the C macro. Just C<#define> the macro before including C: #define DPPP_NAMESPACE MyOwnNamespace_ #include "ppport.h" The default namespace is C. =back The good thing is that most of the above can be checked by running F on your source code. See the next section for details. =head1 EXAMPLES To verify whether F is needed for your module, whether you should make any changes to your code, and whether any special defines should be used, F can be run as a Perl script to check your source code. Simply say: perl ppport.h The result will usually be a list of patches suggesting changes that should at least be acceptable, if not necessarily the most efficient solution, or a fix for all possible problems. If you know that your XS module uses features only available in newer Perl releases, if you're aware that it uses C++ comments, and if you want all suggestions as a single patch file, you could use something like this: perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff If you only want your code to be scanned without any suggestions for changes, use: perl ppport.h --nochanges You can specify a different C program or options, using the C<--diff> option: perl ppport.h --diff='diff -C 10' This would output context diffs with 10 lines of context. If you want to create patched copies of your files instead, use: perl ppport.h --copy=.new To display portability information for the C function, use: perl ppport.h --api-info=newSVpvn Since the argument to C<--api-info> can be a regular expression, you can use perl ppport.h --api-info=/_nomg$/ to display portability information for all C<_nomg> functions or perl ppport.h --api-info=/./ to display information for all known API elements. =head1 BUGS If this version of F is causing failure during the compilation of this module, please check if newer versions of either this module or C are available on CPAN before sending a bug report. If F was generated using the latest version of C and is causing failure of this module, please file a bug report using the CPAN Request Tracker at L. Please include the following information: =over 4 =item 1. The complete output from running "perl -V" =item 2. This file. =item 3. The name and version of the module you were trying to build. =item 4. A full log of the build that failed. =item 5. Any other information that you think could be relevant. =back For the latest version of this code, please get the C module from CPAN. =head1 COPYRIGHT Version 3.x, Copyright (c) 2004-2009, Marcus Holland-Moritz. Version 2.x, Copyright (C) 2001, Paul Marquess. Version 1.x, Copyright (C) 1999, Kenneth Albanowski. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO See L. =cut use strict; # Disable broken TRIE-optimization BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 } my $VERSION = 3.19; my %opt = ( quiet => 0, diag => 1, hints => 1, changes => 1, cplusplus => 0, filter => 1, strip => 0, version => 0, ); my($ppport) = $0 =~ /([\w.]+)$/; my $LF = '(?:\r\n|[\r\n])'; # line feed my $HS = "[ \t]"; # horizontal whitespace # Never use C comments in this file! my $ccs = '/'.'*'; my $cce = '*'.'/'; my $rccs = quotemeta $ccs; my $rcce = quotemeta $cce; eval { require Getopt::Long; Getopt::Long::GetOptions(\%opt, qw( help quiet diag! filter! hints! changes! cplusplus strip version patch=s copy=s diff=s compat-version=s list-provided list-unsupported api-info=s )) or usage(); }; if ($@ and grep /^-/, @ARGV) { usage() if "@ARGV" =~ /^--?h(?:elp)?$/; die "Getopt::Long not found. Please don't use any options.\n"; } if ($opt{version}) { print "This is $0 $VERSION.\n"; exit 0; } usage() if $opt{help}; strip() if $opt{strip}; if (exists $opt{'compat-version'}) { my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) }; if ($@) { die "Invalid version number format: '$opt{'compat-version'}'\n"; } die "Only Perl 5 is supported\n" if $r != 5; die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000; $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s; } else { $opt{'compat-version'} = 5; } my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/ ? ( $1 => { ($2 ? ( base => $2 ) : ()), ($3 ? ( todo => $3 ) : ()), (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()), (index($4, 'p') >= 0 ? ( provided => 1 ) : ()), (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()), } ) : die "invalid spec: $_" } qw( AvFILLp|5.004050||p AvFILL||| CLASS|||n CPERLscope|5.005000||p CX_CURPAD_SAVE||| CX_CURPAD_SV||| CopFILEAV|5.006000||p CopFILEGV_set|5.006000||p CopFILEGV|5.006000||p CopFILESV|5.006000||p CopFILE_set|5.006000||p CopFILE|5.006000||p CopSTASHPV_set|5.006000||p CopSTASHPV|5.006000||p CopSTASH_eq|5.006000||p CopSTASH_set|5.006000||p CopSTASH|5.006000||p CopyD|5.009002||p Copy||| CvPADLIST||| CvSTASH||| CvWEAKOUTSIDE||| DEFSV_set|5.011000||p DEFSV|5.004050||p END_EXTERN_C|5.005000||p ENTER||| ERRSV|5.004050||p EXTEND||| EXTERN_C|5.005000||p F0convert|||n FREETMPS||| GIMME_V||5.004000|n GIMME|||n GROK_NUMERIC_RADIX|5.007002||p G_ARRAY||| G_DISCARD||| G_EVAL||| G_METHOD|5.006001||p G_NOARGS||| G_SCALAR||| G_VOID||5.004000| GetVars||| GvSVn|5.009003||p GvSV||| Gv_AMupdate||| HEf_SVKEY||5.004000| HeHASH||5.004000| HeKEY||5.004000| HeKLEN||5.004000| HePV||5.004000| HeSVKEY_force||5.004000| HeSVKEY_set||5.004000| HeSVKEY||5.004000| HeUTF8||5.011000| HeVAL||5.004000| HvNAMELEN_get|5.009003||p HvNAME_get|5.009003||p HvNAME||| INT2PTR|5.006000||p IN_LOCALE_COMPILETIME|5.007002||p IN_LOCALE_RUNTIME|5.007002||p IN_LOCALE|5.007002||p IN_PERL_COMPILETIME|5.008001||p IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p IS_NUMBER_INFINITY|5.007002||p IS_NUMBER_IN_UV|5.007002||p IS_NUMBER_NAN|5.007003||p IS_NUMBER_NEG|5.007002||p IS_NUMBER_NOT_INT|5.007002||p IVSIZE|5.006000||p IVTYPE|5.006000||p IVdf|5.006000||p LEAVE||| LVRET||| MARK||| MULTICALL||5.011000| MY_CXT_CLONE|5.009002||p MY_CXT_INIT|5.007003||p MY_CXT|5.007003||p MoveD|5.009002||p Move||| NOOP|5.005000||p NUM2PTR|5.006000||p NVTYPE|5.006000||p NVef|5.006001||p NVff|5.006001||p NVgf|5.006001||p Newxc|5.009003||p Newxz|5.009003||p Newx|5.009003||p Nullav||| Nullch||| Nullcv||| Nullhv||| Nullsv||| ORIGMARK||| PAD_BASE_SV||| PAD_CLONE_VARS||| PAD_COMPNAME_FLAGS||| PAD_COMPNAME_GEN_set||| PAD_COMPNAME_GEN||| PAD_COMPNAME_OURSTASH||| PAD_COMPNAME_PV||| PAD_COMPNAME_TYPE||| PAD_DUP||| PAD_RESTORE_LOCAL||| PAD_SAVE_LOCAL||| PAD_SAVE_SETNULLPAD||| PAD_SETSV||| PAD_SET_CUR_NOSAVE||| PAD_SET_CUR||| PAD_SVl||| PAD_SV||| PERLIO_FUNCS_CAST|5.009003||p PERLIO_FUNCS_DECL|5.009003||p PERL_ABS|5.008001||p PERL_BCDVERSION|5.011000||p PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p PERL_HASH|5.004000||p PERL_INT_MAX|5.004000||p PERL_INT_MIN|5.004000||p PERL_LONG_MAX|5.004000||p PERL_LONG_MIN|5.004000||p PERL_MAGIC_arylen|5.007002||p PERL_MAGIC_backref|5.007002||p PERL_MAGIC_bm|5.007002||p PERL_MAGIC_collxfrm|5.007002||p PERL_MAGIC_dbfile|5.007002||p PERL_MAGIC_dbline|5.007002||p PERL_MAGIC_defelem|5.007002||p PERL_MAGIC_envelem|5.007002||p PERL_MAGIC_env|5.007002||p PERL_MAGIC_ext|5.007002||p PERL_MAGIC_fm|5.007002||p PERL_MAGIC_glob|5.011000||p PERL_MAGIC_isaelem|5.007002||p PERL_MAGIC_isa|5.007002||p PERL_MAGIC_mutex|5.011000||p PERL_MAGIC_nkeys|5.007002||p PERL_MAGIC_overload_elem|5.007002||p PERL_MAGIC_overload_table|5.007002||p PERL_MAGIC_overload|5.007002||p PERL_MAGIC_pos|5.007002||p PERL_MAGIC_qr|5.007002||p PERL_MAGIC_regdata|5.007002||p PERL_MAGIC_regdatum|5.007002||p PERL_MAGIC_regex_global|5.007002||p PERL_MAGIC_shared_scalar|5.007003||p PERL_MAGIC_shared|5.007003||p PERL_MAGIC_sigelem|5.007002||p PERL_MAGIC_sig|5.007002||p PERL_MAGIC_substr|5.007002||p PERL_MAGIC_sv|5.007002||p PERL_MAGIC_taint|5.007002||p PERL_MAGIC_tiedelem|5.007002||p PERL_MAGIC_tiedscalar|5.007002||p PERL_MAGIC_tied|5.007002||p PERL_MAGIC_utf8|5.008001||p PERL_MAGIC_uvar_elem|5.007003||p PERL_MAGIC_uvar|5.007002||p PERL_MAGIC_vec|5.007002||p PERL_MAGIC_vstring|5.008001||p PERL_PV_ESCAPE_ALL|5.009004||p PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p PERL_PV_ESCAPE_NOCLEAR|5.009004||p PERL_PV_ESCAPE_QUOTE|5.009004||p PERL_PV_ESCAPE_RE|5.009005||p PERL_PV_ESCAPE_UNI_DETECT|5.009004||p PERL_PV_ESCAPE_UNI|5.009004||p PERL_PV_PRETTY_DUMP|5.009004||p PERL_PV_PRETTY_ELLIPSES|5.010000||p PERL_PV_PRETTY_LTGT|5.009004||p PERL_PV_PRETTY_NOCLEAR|5.010000||p PERL_PV_PRETTY_QUOTE|5.009004||p PERL_PV_PRETTY_REGPROP|5.009004||p PERL_QUAD_MAX|5.004000||p PERL_QUAD_MIN|5.004000||p PERL_REVISION|5.006000||p PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p PERL_SCAN_DISALLOW_PREFIX|5.007003||p PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p PERL_SCAN_SILENT_ILLDIGIT|5.008001||p PERL_SHORT_MAX|5.004000||p PERL_SHORT_MIN|5.004000||p PERL_SIGNALS_UNSAFE_FLAG|5.008001||p PERL_SUBVERSION|5.006000||p PERL_SYS_INIT3||5.006000| PERL_SYS_INIT||| PERL_SYS_TERM||5.011000| PERL_UCHAR_MAX|5.004000||p PERL_UCHAR_MIN|5.004000||p PERL_UINT_MAX|5.004000||p PERL_UINT_MIN|5.004000||p PERL_ULONG_MAX|5.004000||p PERL_ULONG_MIN|5.004000||p PERL_UNUSED_ARG|5.009003||p PERL_UNUSED_CONTEXT|5.009004||p PERL_UNUSED_DECL|5.007002||p PERL_UNUSED_VAR|5.007002||p PERL_UQUAD_MAX|5.004000||p PERL_UQUAD_MIN|5.004000||p PERL_USE_GCC_BRACE_GROUPS|5.009004||p PERL_USHORT_MAX|5.004000||p PERL_USHORT_MIN|5.004000||p PERL_VERSION|5.006000||p PL_DBsignal|5.005000||p PL_DBsingle|||pn PL_DBsub|||pn PL_DBtrace|||pn PL_Sv|5.005000||p PL_bufend|5.011000||p PL_bufptr|5.011000||p PL_compiling|5.004050||p PL_copline|5.011000||p PL_curcop|5.004050||p PL_curstash|5.004050||p PL_debstash|5.004050||p PL_defgv|5.004050||p PL_diehook|5.004050||p PL_dirty|5.004050||p PL_dowarn|||pn PL_errgv|5.004050||p PL_error_count|5.011000||p PL_expect|5.011000||p PL_hexdigit|5.005000||p PL_hints|5.005000||p PL_in_my_stash|5.011000||p PL_in_my|5.011000||p PL_last_in_gv|||n PL_laststatval|5.005000||p PL_lex_state|5.011000||p PL_lex_stuff|5.011000||p PL_linestr|5.011000||p PL_modglobal||5.005000|n PL_na|5.004050||pn PL_no_modify|5.006000||p PL_ofsgv|||n PL_parser|5.009005||p PL_perl_destruct_level|5.004050||p PL_perldb|5.004050||p PL_ppaddr|5.006000||p PL_rsfp_filters|5.004050||p PL_rsfp|5.004050||p PL_rs|||n PL_signals|5.008001||p PL_stack_base|5.004050||p PL_stack_sp|5.004050||p PL_statcache|5.005000||p PL_stdingv|5.004050||p PL_sv_arenaroot|5.004050||p PL_sv_no|5.004050||pn PL_sv_undef|5.004050||pn PL_sv_yes|5.004050||pn PL_tainted|5.004050||p PL_tainting|5.004050||p PL_tokenbuf|5.011000||p POP_MULTICALL||5.011000| POPi|||n POPl|||n POPn|||n POPpbytex||5.007001|n POPpx||5.005030|n POPp|||n POPs|||n PTR2IV|5.006000||p PTR2NV|5.006000||p PTR2UV|5.006000||p PTR2nat|5.009003||p PTR2ul|5.007001||p PTRV|5.006000||p PUSHMARK||| PUSH_MULTICALL||5.011000| PUSHi||| PUSHmortal|5.009002||p PUSHn||| PUSHp||| PUSHs||| PUSHu|5.004000||p PUTBACK||| PerlIO_clearerr||5.007003| PerlIO_close||5.007003| PerlIO_context_layers||5.009004| PerlIO_eof||5.007003| PerlIO_error||5.007003| PerlIO_fileno||5.007003| PerlIO_fill||5.007003| PerlIO_flush||5.007003| PerlIO_get_base||5.007003| PerlIO_get_bufsiz||5.007003| PerlIO_get_cnt||5.007003| PerlIO_get_ptr||5.007003| PerlIO_read||5.007003| PerlIO_seek||5.007003| PerlIO_set_cnt||5.007003| PerlIO_set_ptrcnt||5.007003| PerlIO_setlinebuf||5.007003| PerlIO_stderr||5.007003| PerlIO_stdin||5.007003| PerlIO_stdout||5.007003| PerlIO_tell||5.007003| PerlIO_unread||5.007003| PerlIO_write||5.007003| Perl_signbit||5.009005|n PoisonFree|5.009004||p PoisonNew|5.009004||p PoisonWith|5.009004||p Poison|5.008000||p RETVAL|||n Renewc||| Renew||| SAVECLEARSV||| SAVECOMPPAD||| SAVEPADSV||| SAVETMPS||| SAVE_DEFSV|5.004050||p SPAGAIN||| SP||| START_EXTERN_C|5.005000||p START_MY_CXT|5.007003||p STMT_END|||p STMT_START|||p STR_WITH_LEN|5.009003||p ST||| SV_CONST_RETURN|5.009003||p SV_COW_DROP_PV|5.008001||p SV_COW_SHARED_HASH_KEYS|5.009005||p SV_GMAGIC|5.007002||p SV_HAS_TRAILING_NUL|5.009004||p SV_IMMEDIATE_UNREF|5.007001||p SV_MUTABLE_RETURN|5.009003||p SV_NOSTEAL|5.009002||p SV_SMAGIC|5.009003||p SV_UTF8_NO_ENCODING|5.008001||p SVfARG|5.009005||p SVf_UTF8|5.006000||p SVf|5.006000||p SVt_IV||| SVt_NV||| SVt_PVAV||| SVt_PVCV||| SVt_PVHV||| SVt_PVMG||| SVt_PV||| Safefree||| Slab_Alloc||| Slab_Free||| Slab_to_rw||| StructCopy||| SvCUR_set||| SvCUR||| SvEND||| SvGAMAGIC||5.006001| SvGETMAGIC|5.004050||p SvGROW||| SvIOK_UV||5.006000| SvIOK_notUV||5.006000| SvIOK_off||| SvIOK_only_UV||5.006000| SvIOK_only||| SvIOK_on||| SvIOKp||| SvIOK||| SvIVX||| SvIV_nomg|5.009001||p SvIV_set||| SvIVx||| SvIV||| SvIsCOW_shared_hash||5.008003| SvIsCOW||5.008003| SvLEN_set||| SvLEN||| SvLOCK||5.007003| SvMAGIC_set|5.009003||p SvNIOK_off||| SvNIOKp||| SvNIOK||| SvNOK_off||| SvNOK_only||| SvNOK_on||| SvNOKp||| SvNOK||| SvNVX||| SvNV_set||| SvNVx||| SvNV||| SvOK||| SvOOK_offset||5.011000| SvOOK||| SvPOK_off||| SvPOK_only_UTF8||5.006000| SvPOK_only||| SvPOK_on||| SvPOKp||| SvPOK||| SvPVX_const|5.009003||p SvPVX_mutable|5.009003||p SvPVX||| SvPV_const|5.009003||p SvPV_flags_const_nolen|5.009003||p SvPV_flags_const|5.009003||p SvPV_flags_mutable|5.009003||p SvPV_flags|5.007002||p SvPV_force_flags_mutable|5.009003||p SvPV_force_flags_nolen|5.009003||p SvPV_force_flags|5.007002||p SvPV_force_mutable|5.009003||p SvPV_force_nolen|5.009003||p SvPV_force_nomg_nolen|5.009003||p SvPV_force_nomg|5.007002||p SvPV_force|||p SvPV_mutable|5.009003||p SvPV_nolen_const|5.009003||p SvPV_nolen|5.006000||p SvPV_nomg_const_nolen|5.009003||p SvPV_nomg_const|5.009003||p SvPV_nomg|5.007002||p SvPV_renew|5.009003||p SvPV_set||| SvPVbyte_force||5.009002| SvPVbyte_nolen||5.006000| SvPVbytex_force||5.006000| SvPVbytex||5.006000| SvPVbyte|5.006000||p SvPVutf8_force||5.006000| SvPVutf8_nolen||5.006000| SvPVutf8x_force||5.006000| SvPVutf8x||5.006000| SvPVutf8||5.006000| SvPVx||| SvPV||| SvREFCNT_dec||| SvREFCNT_inc_NN|5.009004||p SvREFCNT_inc_simple_NN|5.009004||p SvREFCNT_inc_simple_void_NN|5.009004||p SvREFCNT_inc_simple_void|5.009004||p SvREFCNT_inc_simple|5.009004||p SvREFCNT_inc_void_NN|5.009004||p SvREFCNT_inc_void|5.009004||p SvREFCNT_inc|||p SvREFCNT||| SvROK_off||| SvROK_on||| SvROK||| SvRV_set|5.009003||p SvRV||| SvRXOK||5.009005| SvRX||5.009005| SvSETMAGIC||| SvSHARED_HASH|5.009003||p SvSHARE||5.007003| SvSTASH_set|5.009003||p SvSTASH||| SvSetMagicSV_nosteal||5.004000| SvSetMagicSV||5.004000| SvSetSV_nosteal||5.004000| SvSetSV||| SvTAINTED_off||5.004000| SvTAINTED_on||5.004000| SvTAINTED||5.004000| SvTAINT||| SvTRUE||| SvTYPE||| SvUNLOCK||5.007003| SvUOK|5.007001|5.006000|p SvUPGRADE||| SvUTF8_off||5.006000| SvUTF8_on||5.006000| SvUTF8||5.006000| SvUVXx|5.004000||p SvUVX|5.004000||p SvUV_nomg|5.009001||p SvUV_set|5.009003||p SvUVx|5.004000||p SvUV|5.004000||p SvVOK||5.008001| SvVSTRING_mg|5.009004||p THIS|||n UNDERBAR|5.009002||p UTF8_MAXBYTES|5.009002||p UVSIZE|5.006000||p UVTYPE|5.006000||p UVXf|5.007001||p UVof|5.006000||p UVuf|5.006000||p UVxf|5.006000||p WARN_ALL|5.006000||p WARN_AMBIGUOUS|5.006000||p WARN_ASSERTIONS|5.011000||p WARN_BAREWORD|5.006000||p WARN_CLOSED|5.006000||p WARN_CLOSURE|5.006000||p WARN_DEBUGGING|5.006000||p WARN_DEPRECATED|5.006000||p WARN_DIGIT|5.006000||p WARN_EXEC|5.006000||p WARN_EXITING|5.006000||p WARN_GLOB|5.006000||p WARN_INPLACE|5.006000||p WARN_INTERNAL|5.006000||p WARN_IO|5.006000||p WARN_LAYER|5.008000||p WARN_MALLOC|5.006000||p WARN_MISC|5.006000||p WARN_NEWLINE|5.006000||p WARN_NUMERIC|5.006000||p WARN_ONCE|5.006000||p WARN_OVERFLOW|5.006000||p WARN_PACK|5.006000||p WARN_PARENTHESIS|5.006000||p WARN_PIPE|5.006000||p WARN_PORTABLE|5.006000||p WARN_PRECEDENCE|5.006000||p WARN_PRINTF|5.006000||p WARN_PROTOTYPE|5.006000||p WARN_QW|5.006000||p WARN_RECURSION|5.006000||p WARN_REDEFINE|5.006000||p WARN_REGEXP|5.006000||p WARN_RESERVED|5.006000||p WARN_SEMICOLON|5.006000||p WARN_SEVERE|5.006000||p WARN_SIGNAL|5.006000||p WARN_SUBSTR|5.006000||p WARN_SYNTAX|5.006000||p WARN_TAINT|5.006000||p WARN_THREADS|5.008000||p WARN_UNINITIALIZED|5.006000||p WARN_UNOPENED|5.006000||p WARN_UNPACK|5.006000||p WARN_UNTIE|5.006000||p WARN_UTF8|5.006000||p WARN_VOID|5.006000||p XCPT_CATCH|5.009002||p XCPT_RETHROW|5.009002||p XCPT_TRY_END|5.009002||p XCPT_TRY_START|5.009002||p XPUSHi||| XPUSHmortal|5.009002||p XPUSHn||| XPUSHp||| XPUSHs||| XPUSHu|5.004000||p XSPROTO|5.010000||p XSRETURN_EMPTY||| XSRETURN_IV||| XSRETURN_NO||| XSRETURN_NV||| XSRETURN_PV||| XSRETURN_UNDEF||| XSRETURN_UV|5.008001||p XSRETURN_YES||| XSRETURN|||p XST_mIV||| XST_mNO||| XST_mNV||| XST_mPV||| XST_mUNDEF||| XST_mUV|5.008001||p XST_mYES||| XS_VERSION_BOOTCHECK||| XS_VERSION||| XSprePUSH|5.006000||p XS||| ZeroD|5.009002||p Zero||| _aMY_CXT|5.007003||p _pMY_CXT|5.007003||p aMY_CXT_|5.007003||p aMY_CXT|5.007003||p aTHXR_|5.011000||p aTHXR|5.011000||p aTHX_|5.006000||p aTHX|5.006000||p add_data|||n addmad||| allocmy||| amagic_call||| amagic_cmp_locale||| amagic_cmp||| amagic_i_ncmp||| amagic_ncmp||| any_dup||| ao||| append_elem||| append_list||| append_madprops||| apply_attrs_my||| apply_attrs_string||5.006001| apply_attrs||| apply||| atfork_lock||5.007003|n atfork_unlock||5.007003|n av_arylen_p||5.009003| av_clear||| av_create_and_push||5.009005| av_create_and_unshift_one||5.009005| av_delete||5.006000| av_exists||5.006000| av_extend||| av_fetch||| av_fill||| av_iter_p||5.011000| av_len||| av_make||| av_pop||| av_push||| av_reify||| av_shift||| av_store||| av_undef||| av_unshift||| ax|||n bad_type||| bind_match||| block_end||| block_gimme||5.004000| block_start||| boolSV|5.004000||p boot_core_PerlIO||| boot_core_UNIVERSAL||| boot_core_mro||| bytes_from_utf8||5.007001| bytes_to_uni|||n bytes_to_utf8||5.006001| call_argv|5.006000||p call_atexit||5.006000| call_list||5.004000| call_method|5.006000||p call_pv|5.006000||p call_sv|5.006000||p calloc||5.007002|n cando||| cast_i32||5.006000| cast_iv||5.006000| cast_ulong||5.006000| cast_uv||5.006000| check_type_and_open||| check_uni||| checkcomma||| checkposixcc||| ckWARN|5.006000||p ck_anoncode||| ck_bitop||| ck_concat||| ck_defined||| ck_delete||| ck_die||| ck_each||| ck_eof||| ck_eval||| ck_exec||| ck_exists||| ck_exit||| ck_ftst||| ck_fun||| ck_glob||| ck_grep||| ck_index||| ck_join||| ck_lfun||| ck_listiob||| ck_match||| ck_method||| ck_null||| ck_open||| ck_readline||| ck_repeat||| ck_require||| ck_return||| ck_rfun||| ck_rvconst||| ck_sassign||| ck_select||| ck_shift||| ck_sort||| ck_spair||| ck_split||| ck_subr||| ck_substr||| ck_svconst||| ck_trunc||| ck_unpack||| ckwarn_d||5.009003| ckwarn||5.009003| cl_and|||n cl_anything|||n cl_init_zero|||n cl_init|||n cl_is_anything|||n cl_or|||n clear_placeholders||| closest_cop||| convert||| cop_free||| cr_textfilter||| create_eval_scope||| croak_nocontext|||vn croak_xs_usage||5.011000| croak|||v csighandler||5.009003|n curmad||| custom_op_desc||5.007003| custom_op_name||5.007003| cv_ckproto_len||| cv_clone||| cv_const_sv||5.004000| cv_dump||| cv_undef||| cx_dump||5.005000| cx_dup||| cxinc||| dAXMARK|5.009003||p dAX|5.007002||p dITEMS|5.007002||p dMARK||| dMULTICALL||5.009003| dMY_CXT_SV|5.007003||p dMY_CXT|5.007003||p dNOOP|5.006000||p dORIGMARK||| dSP||| dTHR|5.004050||p dTHXR|5.011000||p dTHXa|5.006000||p dTHXoa|5.006000||p dTHX|5.006000||p dUNDERBAR|5.009002||p dVAR|5.009003||p dXCPT|5.009002||p dXSARGS||| dXSI32||| dXSTARG|5.006000||p deb_curcv||| deb_nocontext|||vn deb_stack_all||| deb_stack_n||| debop||5.005000| debprofdump||5.005000| debprof||| debstackptrs||5.007003| debstack||5.007003| debug_start_match||| deb||5.007003|v del_sv||| delete_eval_scope||| delimcpy||5.004000| deprecate_old||| deprecate||| despatch_signals||5.007001| destroy_matcher||| die_nocontext|||vn die_where||| die|||v dirp_dup||| div128||| djSP||| do_aexec5||| do_aexec||| do_aspawn||| do_binmode||5.004050| do_chomp||| do_chop||| do_close||| do_dump_pad||| do_eof||| do_exec3||| do_execfree||| do_exec||| do_gv_dump||5.006000| do_gvgv_dump||5.006000| do_hv_dump||5.006000| do_ipcctl||| do_ipcget||| do_join||| do_kv||| do_magic_dump||5.006000| do_msgrcv||| do_msgsnd||| do_oddball||| do_op_dump||5.006000| do_op_xmldump||| do_open9||5.006000| do_openn||5.007001| do_open||5.004000| do_pmop_dump||5.006000| do_pmop_xmldump||| do_print||| do_readline||| do_seek||| do_semop||| do_shmio||| do_smartmatch||| do_spawn_nowait||| do_spawn||| do_sprintf||| do_sv_dump||5.006000| do_sysseek||| do_tell||| do_trans_complex_utf8||| do_trans_complex||| do_trans_count_utf8||| do_trans_count||| do_trans_simple_utf8||| do_trans_simple||| do_trans||| do_vecget||| do_vecset||| do_vop||| docatch||| doeval||| dofile||| dofindlabel||| doform||| doing_taint||5.008001|n dooneliner||| doopen_pm||| doparseform||| dopoptoeval||| dopoptogiven||| dopoptolabel||| dopoptoloop||| dopoptosub_at||| dopoptowhen||| doref||5.009003| dounwind||| dowantarray||| dump_all||5.006000| dump_eval||5.006000| dump_exec_pos||| dump_fds||| dump_form||5.006000| dump_indent||5.006000|v dump_mstats||| dump_packsubs||5.006000| dump_sub||5.006000| dump_sv_child||| dump_trie_interim_list||| dump_trie_interim_table||| dump_trie||| dump_vindent||5.006000| dumpuntil||| dup_attrlist||| emulate_cop_io||| eval_pv|5.006000||p eval_sv|5.006000||p exec_failed||| expect_number||| fbm_compile||5.005000| fbm_instr||5.005000| feature_is_enabled||| fetch_cop_label||5.011000| filter_add||| filter_del||| filter_gets||| filter_read||| find_and_forget_pmops||| find_array_subscript||| find_beginning||| find_byclass||| find_hash_subscript||| find_in_my_stash||| find_runcv||5.008001| find_rundefsvoffset||5.009002| find_script||| find_uninit_var||| first_symbol|||n fold_constants||| forbid_setid||| force_ident||| force_list||| force_next||| force_version||| force_word||| forget_pmop||| form_nocontext|||vn form||5.004000|v fp_dup||| fprintf_nocontext|||vn free_global_struct||| free_tied_hv_pool||| free_tmps||| gen_constant_list||| get_arena||| get_aux_mg||| get_av|5.006000||p get_context||5.006000|n get_cvn_flags||5.009005| get_cv|5.006000||p get_db_sub||| get_debug_opts||| get_hash_seed||| get_hv|5.006000||p get_isa_hash||| get_mstats||| get_no_modify||| get_num||| get_op_descs||5.005000| get_op_names||5.005000| get_opargs||| get_ppaddr||5.006000| get_re_arg||| get_sv|5.006000||p get_vtbl||5.005030| getcwd_sv||5.007002| getenv_len||| glob_2number||| glob_assign_glob||| glob_assign_ref||| gp_dup||| gp_free||| gp_ref||| grok_bin|5.007003||p grok_hex|5.007003||p grok_number|5.007002||p grok_numeric_radix|5.007002||p grok_oct|5.007003||p group_end||| gv_AVadd||| gv_HVadd||| gv_IOadd||| gv_SVadd||| gv_autoload4||5.004000| gv_check||| gv_const_sv||5.009003| gv_dump||5.006000| gv_efullname3||5.004000| gv_efullname4||5.006001| gv_efullname||| gv_ename||| gv_fetchfile_flags||5.009005| gv_fetchfile||| gv_fetchmeth_autoload||5.007003| gv_fetchmethod_autoload||5.004000| gv_fetchmethod_flags||5.011000| gv_fetchmethod||| gv_fetchmeth||| gv_fetchpvn_flags|5.009002||p gv_fetchpvs|5.009004||p gv_fetchpv||| gv_fetchsv||5.009002| gv_fullname3||5.004000| gv_fullname4||5.006001| gv_fullname||| gv_get_super_pkg||| gv_handler||5.007001| gv_init_sv||| gv_init||| gv_name_set||5.009004| gv_stashpvn|5.004000||p gv_stashpvs|5.009003||p gv_stashpv||| gv_stashsv||| he_dup||| hek_dup||| hfreeentries||| hsplit||| hv_assert||5.011000| hv_auxinit|||n hv_backreferences_p||| hv_clear_placeholders||5.009001| hv_clear||| hv_common_key_len||5.010000| hv_common||5.010000| hv_copy_hints_hv||| hv_delayfree_ent||5.004000| hv_delete_common||| hv_delete_ent||5.004000| hv_delete||| hv_eiter_p||5.009003| hv_eiter_set||5.009003| hv_exists_ent||5.004000| hv_exists||| hv_fetch_ent||5.004000| hv_fetchs|5.009003||p hv_fetch||| hv_free_ent||5.004000| hv_iterinit||| hv_iterkeysv||5.004000| hv_iterkey||| hv_iternext_flags||5.008000| hv_iternextsv||| hv_iternext||| hv_iterval||| hv_kill_backrefs||| hv_ksplit||5.004000| hv_magic_check|||n hv_magic||| hv_name_set||5.009003| hv_notallowed||| hv_placeholders_get||5.009003| hv_placeholders_p||5.009003| hv_placeholders_set||5.009003| hv_riter_p||5.009003| hv_riter_set||5.009003| hv_scalar||5.009001| hv_store_ent||5.004000| hv_store_flags||5.008000| hv_stores|5.009004||p hv_store||| hv_undef||| ibcmp_locale||5.004000| ibcmp_utf8||5.007003| ibcmp||| incline||| incpush_if_exists||| incpush_use_sep||| incpush||| ingroup||| init_argv_symbols||| init_debugger||| init_global_struct||| init_i18nl10n||5.006000| init_i18nl14n||5.006000| init_ids||| init_interp||| init_main_stash||| init_perllib||| init_postdump_symbols||| init_predump_symbols||| init_stacks||5.005000| init_tm||5.007002| instr||| intro_my||| intuit_method||| intuit_more||| invert||| io_close||| isALNUMC|5.006000||p isALNUM||| isALPHA||| isASCII|5.006000||p isBLANK|5.006001||p isCNTRL|5.006000||p isDIGIT||| isGRAPH|5.006000||p isGV_with_GP|5.009004||p isLOWER||| isPRINT|5.004000||p isPSXSPC|5.006001||p isPUNCT|5.006000||p isSPACE||| isUPPER||| isXDIGIT|5.006000||p is_an_int||| is_gv_magical_sv||| is_handle_constructor|||n is_list_assignment||| is_lvalue_sub||5.007001| is_uni_alnum_lc||5.006000| is_uni_alnumc_lc||5.006000| is_uni_alnumc||5.006000| is_uni_alnum||5.006000| is_uni_alpha_lc||5.006000| is_uni_alpha||5.006000| is_uni_ascii_lc||5.006000| is_uni_ascii||5.006000| is_uni_cntrl_lc||5.006000| is_uni_cntrl||5.006000| is_uni_digit_lc||5.006000| is_uni_digit||5.006000| is_uni_graph_lc||5.006000| is_uni_graph||5.006000| is_uni_idfirst_lc||5.006000| is_uni_idfirst||5.006000| is_uni_lower_lc||5.006000| is_uni_lower||5.006000| is_uni_print_lc||5.006000| is_uni_print||5.006000| is_uni_punct_lc||5.006000| is_uni_punct||5.006000| is_uni_space_lc||5.006000| is_uni_space||5.006000| is_uni_upper_lc||5.006000| is_uni_upper||5.006000| is_uni_xdigit_lc||5.006000| is_uni_xdigit||5.006000| is_utf8_alnumc||5.006000| is_utf8_alnum||5.006000| is_utf8_alpha||5.006000| is_utf8_ascii||5.006000| is_utf8_char_slow|||n is_utf8_char||5.006000| is_utf8_cntrl||5.006000| is_utf8_common||| is_utf8_digit||5.006000| is_utf8_graph||5.006000| is_utf8_idcont||5.008000| is_utf8_idfirst||5.006000| is_utf8_lower||5.006000| is_utf8_mark||5.006000| is_utf8_print||5.006000| is_utf8_punct||5.006000| is_utf8_space||5.006000| is_utf8_string_loclen||5.009003| is_utf8_string_loc||5.008001| is_utf8_string||5.006001| is_utf8_upper||5.006000| is_utf8_xdigit||5.006000| isa_lookup||| items|||n ix|||n jmaybe||| join_exact||| keyword||| leave_scope||| lex_end||| lex_start||| linklist||| listkids||| list||| load_module_nocontext|||vn load_module|5.006000||pv localize||| looks_like_bool||| looks_like_number||| lop||| mPUSHi|5.009002||p mPUSHn|5.009002||p mPUSHp|5.009002||p mPUSHs|5.011000||p mPUSHu|5.009002||p mXPUSHi|5.009002||p mXPUSHn|5.009002||p mXPUSHp|5.009002||p mXPUSHs|5.011000||p mXPUSHu|5.009002||p mad_free||| madlex||| madparse||| magic_clear_all_env||| magic_clearenv||| magic_clearhint||| magic_clearisa||| magic_clearpack||| magic_clearsig||| magic_dump||5.006000| magic_existspack||| magic_freearylen_p||| magic_freeovrld||| magic_getarylen||| magic_getdefelem||| magic_getnkeys||| magic_getpack||| magic_getpos||| magic_getsig||| magic_getsubstr||| magic_gettaint||| magic_getuvar||| magic_getvec||| magic_get||| magic_killbackrefs||| magic_len||| magic_methcall||| magic_methpack||| magic_nextpack||| magic_regdata_cnt||| magic_regdatum_get||| magic_regdatum_set||| magic_scalarpack||| magic_set_all_env||| magic_setamagic||| magic_setarylen||| magic_setcollxfrm||| magic_setdbline||| magic_setdefelem||| magic_setenv||| magic_sethint||| magic_setisa||| magic_setmglob||| magic_setnkeys||| magic_setpack||| magic_setpos||| magic_setregexp||| magic_setsig||| magic_setsubstr||| magic_settaint||| magic_setutf8||| magic_setuvar||| magic_setvec||| magic_set||| magic_sizepack||| magic_wipepack||| make_matcher||| make_trie_failtable||| make_trie||| malloc_good_size|||n malloced_size|||n malloc||5.007002|n markstack_grow||| matcher_matches_sv||| measure_struct||| memEQ|5.004000||p memNE|5.004000||p mem_collxfrm||| mem_log_common|||n mess_alloc||| mess_nocontext|||vn mess||5.006000|v method_common||| mfree||5.007002|n mg_clear||| mg_copy||| mg_dup||| mg_find||| mg_free||| mg_get||| mg_length||5.005000| mg_localize||| mg_magical||| mg_set||| mg_size||5.005000| mini_mktime||5.007002| missingterm||| mode_from_discipline||| modkids||| mod||| more_bodies||| more_sv||| moreswitches||| mro_get_from_name||5.011000| mro_get_linear_isa_dfs||| mro_get_linear_isa||5.009005| mro_get_private_data||5.011000| mro_isa_changed_in||| mro_meta_dup||| mro_meta_init||| mro_method_changed_in||5.009005| mro_register||5.011000| mro_set_mro||5.011000| mro_set_private_data||5.011000| mul128||| mulexp10|||n my_atof2||5.007002| my_atof||5.006000| my_attrs||| my_bcopy|||n my_betoh16|||n my_betoh32|||n my_betoh64|||n my_betohi|||n my_betohl|||n my_betohs|||n my_bzero|||n my_chsize||| my_clearenv||| my_cxt_index||| my_cxt_init||| my_dirfd||5.009005| my_exit_jump||| my_exit||| my_failure_exit||5.004000| my_fflush_all||5.006000| my_fork||5.007003|n my_htobe16|||n my_htobe32|||n my_htobe64|||n my_htobei|||n my_htobel|||n my_htobes|||n my_htole16|||n my_htole32|||n my_htole64|||n my_htolei|||n my_htolel|||n my_htoles|||n my_htonl||| my_kid||| my_letoh16|||n my_letoh32|||n my_letoh64|||n my_letohi|||n my_letohl|||n my_letohs|||n my_lstat||| my_memcmp||5.004000|n my_memset|||n my_ntohl||| my_pclose||5.004000| my_popen_list||5.007001| my_popen||5.004000| my_setenv||| my_snprintf|5.009004||pvn my_socketpair||5.007003|n my_sprintf|5.009003||pvn my_stat||| my_strftime||5.007002| my_strlcat|5.009004||pn my_strlcpy|5.009004||pn my_swabn|||n my_swap||| my_unexec||| my_vsnprintf||5.009004|n need_utf8|||n newANONATTRSUB||5.006000| newANONHASH||| newANONLIST||| newANONSUB||| newASSIGNOP||| newATTRSUB||5.006000| newAVREF||| newAV||| newBINOP||| newCONDOP||| newCONSTSUB|5.004050||p newCVREF||| newDEFSVOP||| newFORM||| newFOROP||| newGIVENOP||5.009003| newGIVWHENOP||| newGP||| newGVOP||| newGVREF||| newGVgen||| newHVREF||| newHVhv||5.005000| newHV||| newIO||| newLISTOP||| newLOGOP||| newLOOPEX||| newLOOPOP||| newMADPROP||| newMADsv||| newMYSUB||| newNULLLIST||| newOP||| newPADOP||| newPMOP||| newPROG||| newPVOP||| newRANGE||| newRV_inc|5.004000||p newRV_noinc|5.004000||p newRV||| newSLICEOP||| newSTATEOP||| newSUB||| newSVOP||| newSVREF||| newSV_type|5.009005||p newSVhek||5.009003| newSViv||| newSVnv||| newSVpvf_nocontext|||vn newSVpvf||5.004000|v newSVpvn_flags|5.011000||p newSVpvn_share|5.007001||p newSVpvn_utf8|5.011000||p newSVpvn|5.004050||p newSVpvs_flags|5.011000||p newSVpvs_share||5.009003| newSVpvs|5.009003||p newSVpv||| newSVrv||| newSVsv||| newSVuv|5.006000||p newSV||| newTOKEN||| newUNOP||| newWHENOP||5.009003| newWHILEOP||5.009003| newXS_flags||5.009004| newXSproto||5.006000| newXS||5.006000| new_collate||5.006000| new_constant||| new_ctype||5.006000| new_he||| new_logop||| new_numeric||5.006000| new_stackinfo||5.005000| new_version||5.009000| new_warnings_bitfield||| next_symbol||| nextargv||| nextchar||| ninstr||| no_bareword_allowed||| no_fh_allowed||| no_op||| not_a_number||| nothreadhook||5.008000| nuke_stacks||| num_overflow|||n offer_nice_chunk||| oopsAV||| oopsHV||| op_clear||| op_const_sv||| op_dump||5.006000| op_free||| op_getmad_weak||| op_getmad||| op_null||5.007002| op_refcnt_dec||| op_refcnt_inc||| op_refcnt_lock||5.009002| op_refcnt_unlock||5.009002| op_xmldump||| open_script||| pMY_CXT_|5.007003||p pMY_CXT|5.007003||p pTHX_|5.006000||p pTHX|5.006000||p packWARN|5.007003||p pack_cat||5.007003| pack_rec||| package||| packlist||5.008001| pad_add_anon||| pad_add_name||| pad_alloc||| pad_block_start||| pad_check_dup||| pad_compname_type||| pad_findlex||| pad_findmy||| pad_fixup_inner_anons||| pad_free||| pad_leavemy||| pad_new||| pad_peg|||n pad_push||| pad_reset||| pad_setsv||| pad_sv||5.011000| pad_swipe||| pad_tidy||| pad_undef||| parse_body||| parse_unicode_opts||| parser_dup||| parser_free||| path_is_absolute|||n peep||| pending_Slabs_to_ro||| perl_alloc_using|||n perl_alloc|||n perl_clone_using|||n perl_clone|||n perl_construct|||n perl_destruct||5.007003|n perl_free|||n perl_parse||5.006000|n perl_run|||n pidgone||| pm_description||| pmflag||| pmop_dump||5.006000| pmop_xmldump||| pmruntime||| pmtrans||| pop_scope||| pregcomp||5.009005| pregexec||| pregfree2||5.011000| pregfree||| prepend_elem||| prepend_madprops||| printbuf||| printf_nocontext|||vn process_special_blocks||| ptr_table_clear||5.009005| ptr_table_fetch||5.009005| ptr_table_find|||n ptr_table_free||5.009005| ptr_table_new||5.009005| ptr_table_split||5.009005| ptr_table_store||5.009005| push_scope||| put_byte||| pv_display|5.006000||p pv_escape|5.009004||p pv_pretty|5.009004||p pv_uni_display||5.007003| qerror||| qsortsvu||| re_compile||5.009005| re_croak2||| re_dup_guts||| re_intuit_start||5.009005| re_intuit_string||5.006000| readpipe_override||| realloc||5.007002|n reentrant_free||| reentrant_init||| reentrant_retry|||vn reentrant_size||| ref_array_or_hash||| refcounted_he_chain_2hv||| refcounted_he_fetch||| refcounted_he_free||| refcounted_he_new_common||| refcounted_he_new||| refcounted_he_value||| refkids||| refto||| ref||5.011000| reg_check_named_buff_matched||| reg_named_buff_all||5.009005| reg_named_buff_exists||5.009005| reg_named_buff_fetch||5.009005| reg_named_buff_firstkey||5.009005| reg_named_buff_iter||| reg_named_buff_nextkey||5.009005| reg_named_buff_scalar||5.009005| reg_named_buff||| reg_namedseq||| reg_node||| reg_numbered_buff_fetch||| reg_numbered_buff_length||| reg_numbered_buff_store||| reg_qr_package||| reg_recode||| reg_scan_name||| reg_skipcomment||| reg_temp_copy||| reganode||| regatom||| regbranch||| regclass_swash||5.009004| regclass||| regcppop||| regcppush||| regcurly|||n regdump_extflags||| regdump||5.005000| regdupe_internal||| regexec_flags||5.005000| regfree_internal||5.009005| reghop3|||n reghop4|||n reghopmaybe3|||n reginclass||| reginitcolors||5.006000| reginsert||| regmatch||| regnext||5.005000| regpiece||| regpposixcc||| regprop||| regrepeat||| regtail_study||| regtail||| regtry||| reguni||| regwhite|||n reg||| repeatcpy||| report_evil_fh||| report_uninit||| require_pv||5.006000| require_tie_mod||| restore_magic||| rninstr||| rsignal_restore||| rsignal_save||| rsignal_state||5.004000| rsignal||5.004000| run_body||| run_user_filter||| runops_debug||5.005000| runops_standard||5.005000| rvpv_dup||| rxres_free||| rxres_restore||| rxres_save||| safesyscalloc||5.006000|n safesysfree||5.006000|n safesysmalloc||5.006000|n safesysrealloc||5.006000|n same_dirent||| save_I16||5.004000| save_I32||| save_I8||5.006000| save_adelete||5.011000| save_aelem||5.004050| save_alloc||5.006000| save_aptr||| save_ary||| save_bool||5.008001| save_clearsv||| save_delete||| save_destructor_x||5.006000| save_destructor||5.006000| save_freeop||| save_freepv||| save_freesv||| save_generic_pvref||5.006001| save_generic_svref||5.005030| save_gp||5.004000| save_hash||| save_hek_flags|||n save_helem_flags||5.011000| save_helem||5.004050| save_hints||| save_hptr||| save_int||| save_item||| save_iv||5.005000| save_lines||| save_list||| save_long||| save_magic||| save_mortalizesv||5.007001| save_nogv||| save_op||| save_padsv_and_mortalize||5.011000| save_pptr||| save_pushi32ptr||| save_pushptri32ptr||| save_pushptrptr||| save_pushptr||5.011000| save_re_context||5.006000| save_scalar_at||| save_scalar||| save_set_svflags||5.009000| save_shared_pvref||5.007003| save_sptr||| save_svref||| save_vptr||5.006000| savepvn||| savepvs||5.009003| savepv||| savesharedpvn||5.009005| savesharedpv||5.007003| savestack_grow_cnt||5.008001| savestack_grow||| savesvpv||5.009002| sawparens||| scalar_mod_type|||n scalarboolean||| scalarkids||| scalarseq||| scalarvoid||| scalar||| scan_bin||5.006000| scan_commit||| scan_const||| scan_formline||| scan_heredoc||| scan_hex||| scan_ident||| scan_inputsymbol||| scan_num||5.007001| scan_oct||| scan_pat||| scan_str||| scan_subst||| scan_trans||| scan_version||5.009001| scan_vstring||5.009005| scan_word||| scope||| screaminstr||5.005000| search_const||| seed||5.008001| sequence_num||| sequence_tail||| sequence||| set_context||5.006000|n set_numeric_local||5.006000| set_numeric_radix||5.006000| set_numeric_standard||5.006000| setdefout||| share_hek_flags||| share_hek||5.004000| si_dup||| sighandler|||n simplify_sort||| skipspace0||| skipspace1||| skipspace2||| skipspace||| softref2xv||| sortcv_stacked||| sortcv_xsub||| sortcv||| sortsv_flags||5.009003| sortsv||5.007003| space_join_names_mortal||| ss_dup||| stack_grow||| start_force||| start_glob||| start_subparse||5.004000| stashpv_hvname_match||5.011000| stdize_locale||| store_cop_label||| strEQ||| strGE||| strGT||| strLE||| strLT||| strNE||| str_to_version||5.006000| strip_return||| strnEQ||| strnNE||| study_chunk||| sub_crush_depth||| sublex_done||| sublex_push||| sublex_start||| sv_2bool||| sv_2cv||| sv_2io||| sv_2iuv_common||| sv_2iuv_non_preserve||| sv_2iv_flags||5.009001| sv_2iv||| sv_2mortal||| sv_2num||| sv_2nv||| sv_2pv_flags|5.007002||p sv_2pv_nolen|5.006000||p sv_2pvbyte_nolen|5.006000||p sv_2pvbyte|5.006000||p sv_2pvutf8_nolen||5.006000| sv_2pvutf8||5.006000| sv_2pv||| sv_2uv_flags||5.009001| sv_2uv|5.004000||p sv_add_arena||| sv_add_backref||| sv_backoff||| sv_bless||| sv_cat_decode||5.008001| sv_catpv_mg|5.004050||p sv_catpvf_mg_nocontext|||pvn sv_catpvf_mg|5.006000|5.004000|pv sv_catpvf_nocontext|||vn sv_catpvf||5.004000|v sv_catpvn_flags||5.007002| sv_catpvn_mg|5.004050||p sv_catpvn_nomg|5.007002||p sv_catpvn||| sv_catpvs|5.009003||p sv_catpv||| sv_catsv_flags||5.007002| sv_catsv_mg|5.004050||p sv_catsv_nomg|5.007002||p sv_catsv||| sv_catxmlpvn||| sv_catxmlsv||| sv_chop||| sv_clean_all||| sv_clean_objs||| sv_clear||| sv_cmp_locale||5.004000| sv_cmp||| sv_collxfrm||| sv_compile_2op||5.008001| sv_copypv||5.007003| sv_dec||| sv_del_backref||| sv_derived_from||5.004000| sv_destroyable||5.010000| sv_does||5.009004| sv_dump||| sv_dup_inc_multiple||| sv_dup||| sv_eq||| sv_exp_grow||| sv_force_normal_flags||5.007001| sv_force_normal||5.006000| sv_free2||| sv_free_arenas||| sv_free||| sv_gets||5.004000| sv_grow||| sv_i_ncmp||| sv_inc||| sv_insert_flags||5.011000| sv_insert||| sv_isa||| sv_isobject||| sv_iv||5.005000| sv_kill_backrefs||| sv_len_utf8||5.006000| sv_len||| sv_magic_portable|5.011000|5.004000|p sv_magicext||5.007003| sv_magic||| sv_mortalcopy||| sv_ncmp||| sv_newmortal||| sv_newref||| sv_nolocking||5.007003| sv_nosharing||5.007003| sv_nounlocking||| sv_nv||5.005000| sv_peek||5.005000| sv_pos_b2u_midway||| sv_pos_b2u||5.006000| sv_pos_u2b_cached||| sv_pos_u2b_forwards|||n sv_pos_u2b_midway|||n sv_pos_u2b||5.006000| sv_pvbyten_force||5.006000| sv_pvbyten||5.006000| sv_pvbyte||5.006000| sv_pvn_force_flags|5.007002||p sv_pvn_force||| sv_pvn_nomg|5.007003|5.005000|p sv_pvn||5.005000| sv_pvutf8n_force||5.006000| sv_pvutf8n||5.006000| sv_pvutf8||5.006000| sv_pv||5.006000| sv_recode_to_utf8||5.007003| sv_reftype||| sv_release_COW||| sv_replace||| sv_report_used||| sv_reset||| sv_rvweaken||5.006000| sv_setiv_mg|5.004050||p sv_setiv||| sv_setnv_mg|5.006000||p sv_setnv||| sv_setpv_mg|5.004050||p sv_setpvf_mg_nocontext|||pvn sv_setpvf_mg|5.006000|5.004000|pv sv_setpvf_nocontext|||vn sv_setpvf||5.004000|v sv_setpviv_mg||5.008001| sv_setpviv||5.008001| sv_setpvn_mg|5.004050||p sv_setpvn||| sv_setpvs|5.009004||p sv_setpv||| sv_setref_iv||| sv_setref_nv||| sv_setref_pvn||| sv_setref_pv||| sv_setref_uv||5.007001| sv_setsv_cow||| sv_setsv_flags||5.007002| sv_setsv_mg|5.004050||p sv_setsv_nomg|5.007002||p sv_setsv||| sv_setuv_mg|5.004050||p sv_setuv|5.004000||p sv_tainted||5.004000| sv_taint||5.004000| sv_true||5.005000| sv_unglob||| sv_uni_display||5.007003| sv_unmagic||| sv_unref_flags||5.007001| sv_unref||| sv_untaint||5.004000| sv_upgrade||| sv_usepvn_flags||5.009004| sv_usepvn_mg|5.004050||p sv_usepvn||| sv_utf8_decode||5.006000| sv_utf8_downgrade||5.006000| sv_utf8_encode||5.006000| sv_utf8_upgrade_flags_grow||5.011000| sv_utf8_upgrade_flags||5.007002| sv_utf8_upgrade_nomg||5.007002| sv_utf8_upgrade||5.007001| sv_uv|5.005000||p sv_vcatpvf_mg|5.006000|5.004000|p sv_vcatpvfn||5.004000| sv_vcatpvf|5.006000|5.004000|p sv_vsetpvf_mg|5.006000|5.004000|p sv_vsetpvfn||5.004000| sv_vsetpvf|5.006000|5.004000|p sv_xmlpeek||| svtype||| swallow_bom||| swap_match_buff||| swash_fetch||5.007002| swash_get||| swash_init||5.006000| sys_init3||5.010000|n sys_init||5.010000|n sys_intern_clear||| sys_intern_dup||| sys_intern_init||| sys_term||5.010000|n taint_env||| taint_proper||| tmps_grow||5.006000| toLOWER||| toUPPER||| to_byte_substr||| to_uni_fold||5.007003| to_uni_lower_lc||5.006000| to_uni_lower||5.007003| to_uni_title_lc||5.006000| to_uni_title||5.007003| to_uni_upper_lc||5.006000| to_uni_upper||5.007003| to_utf8_case||5.007003| to_utf8_fold||5.007003| to_utf8_lower||5.007003| to_utf8_substr||| to_utf8_title||5.007003| to_utf8_upper||5.007003| token_free||| token_getmad||| tokenize_use||| tokeq||| tokereport||| too_few_arguments||| too_many_arguments||| uiv_2buf|||n unlnk||| unpack_rec||| unpack_str||5.007003| unpackstring||5.008001| unshare_hek_or_pvn||| unshare_hek||| unsharepvn||5.004000| unwind_handler_stack||| update_debugger_info||| upg_version||5.009005| usage||| utf16_to_utf8_reversed||5.006001| utf16_to_utf8||5.006001| utf8_distance||5.006000| utf8_hop||5.006000| utf8_length||5.007001| utf8_mg_pos_cache_update||| utf8_to_bytes||5.006001| utf8_to_uvchr||5.007001| utf8_to_uvuni||5.007001| utf8n_to_uvchr||| utf8n_to_uvuni||5.007001| utilize||| uvchr_to_utf8_flags||5.007003| uvchr_to_utf8||| uvuni_to_utf8_flags||5.007003| uvuni_to_utf8||5.007001| validate_suid||| varname||| vcmp||5.009000| vcroak||5.006000| vdeb||5.007003| vdie_common||| vdie_croak_common||| vdie||| vform||5.006000| visit||| vivify_defelem||| vivify_ref||| vload_module|5.006000||p vmess||5.006000| vnewSVpvf|5.006000|5.004000|p vnormal||5.009002| vnumify||5.009000| vstringify||5.009000| vverify||5.009003| vwarner||5.006000| vwarn||5.006000| wait4pid||| warn_nocontext|||vn warner_nocontext|||vn warner|5.006000|5.004000|pv warn|||v watch||| whichsig||| write_no_mem||| write_to_stderr||| xmldump_all||| xmldump_attr||| xmldump_eval||| xmldump_form||| xmldump_indent|||v xmldump_packsubs||| xmldump_sub||| xmldump_vindent||| yyerror||| yylex||| yyparse||| yywarn||| ); if (exists $opt{'list-unsupported'}) { my $f; for $f (sort { lc $a cmp lc $b } keys %API) { next unless $API{$f}{todo}; print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n"; } exit 0; } # Scan for possible replacement candidates my(%replace, %need, %hints, %warnings, %depends); my $replace = 0; my($hint, $define, $function); sub find_api { my $code = shift; $code =~ s{ / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) | "[^"\\]*(?:\\.[^"\\]*)*" | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx; grep { exists $API{$_} } $code =~ /(\w+)/mg; } while () { if ($hint) { my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings; if (m{^\s*\*\s(.*?)\s*$}) { for (@{$hint->[1]}) { $h->{$_} ||= ''; # suppress warning with older perls $h->{$_} .= "$1\n"; } } else { undef $hint } } $hint = [$1, [split /,?\s+/, $2]] if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}; if ($define) { if ($define->[1] =~ /\\$/) { $define->[1] .= $_; } else { if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) { my @n = find_api($define->[1]); push @{$depends{$define->[0]}}, @n if @n } undef $define; } } $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)}; if ($function) { if (/^}/) { if (exists $API{$function->[0]}) { my @n = find_api($function->[1]); push @{$depends{$function->[0]}}, @n if @n } undef $function; } else { $function->[1] .= $_; } } $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)}; $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$}; $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)}; $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce}; $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$}; if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) { my @deps = map { s/\s+//g; $_ } split /,/, $3; my $d; for $d (map { s/\s+//g; $_ } split /,/, $1) { push @{$depends{$d}}, @deps; } } $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)}; } for (values %depends) { my %s; $_ = [sort grep !$s{$_}++, @$_]; } if (exists $opt{'api-info'}) { my $f; my $count = 0; my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$"; for $f (sort { lc $a cmp lc $b } keys %API) { next unless $f =~ /$match/; print "\n=== $f ===\n\n"; my $info = 0; if ($API{$f}{base} || $API{$f}{todo}) { my $base = format_version($API{$f}{base} || $API{$f}{todo}); print "Supported at least starting from perl-$base.\n"; $info++; } if ($API{$f}{provided}) { my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003"; print "Support by $ppport provided back to perl-$todo.\n"; print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f}; print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f}; print "\n$hints{$f}" if exists $hints{$f}; print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f}; $info++; } print "No portability information available.\n" unless $info; $count++; } $count or print "Found no API matching '$opt{'api-info'}'."; print "\n"; exit 0; } if (exists $opt{'list-provided'}) { my $f; for $f (sort { lc $a cmp lc $b } keys %API) { next unless $API{$f}{provided}; my @flags; push @flags, 'explicit' if exists $need{$f}; push @flags, 'depend' if exists $depends{$f}; push @flags, 'hint' if exists $hints{$f}; push @flags, 'warning' if exists $warnings{$f}; my $flags = @flags ? ' ['.join(', ', @flags).']' : ''; print "$f$flags\n"; } exit 0; } my @files; my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc ); my $srcext = join '|', map { quotemeta $_ } @srcext; if (@ARGV) { my %seen; for (@ARGV) { if (-e) { if (-f) { push @files, $_ unless $seen{$_}++; } else { warn "'$_' is not a file.\n" } } else { my @new = grep { -f } glob $_ or warn "'$_' does not exist.\n"; push @files, grep { !$seen{$_}++ } @new; } } } else { eval { require File::Find; File::Find::find(sub { $File::Find::name =~ /($srcext)$/i and push @files, $File::Find::name; }, '.'); }; if ($@) { @files = map { glob "*$_" } @srcext; } } if (!@ARGV || $opt{filter}) { my(@in, @out); my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files; for (@files) { my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i; push @{ $out ? \@out : \@in }, $_; } if (@ARGV && @out) { warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out); } @files = @in; } die "No input files given!\n" unless @files; my(%files, %global, %revreplace); %revreplace = reverse %replace; my $filename; my $patch_opened = 0; for $filename (@files) { unless (open IN, "<$filename") { warn "Unable to read from $filename: $!\n"; next; } info("Scanning $filename ..."); my $c = do { local $/; }; close IN; my %file = (orig => $c, changes => 0); # Temporarily remove C/XS comments and strings from the code my @ccom; $c =~ s{ ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]* | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* ) | ( ^$HS*\#[^\r\n]* | "[^"\\]*(?:\\.[^"\\]*)*" | '[^'\\]*(?:\\.[^'\\]*)*' | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) ) }{ defined $2 and push @ccom, $2; defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex; $file{ccom} = \@ccom; $file{code} = $c; $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m; my $func; for $func (keys %API) { my $match = $func; $match .= "|$revreplace{$func}" if exists $revreplace{$func}; if ($c =~ /\b(?:Perl_)?($match)\b/) { $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func}; $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/; if (exists $API{$func}{provided}) { $file{uses_provided}{$func}++; if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) { $file{uses}{$func}++; my @deps = rec_depend($func); if (@deps) { $file{uses_deps}{$func} = \@deps; for (@deps) { $file{uses}{$_} = 0 unless exists $file{uses}{$_}; } } for ($func, @deps) { $file{needs}{$_} = 'static' if exists $need{$_}; } } } if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) { if ($c =~ /\b$func\b/) { $file{uses_todo}{$func}++; } } } } while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) { if (exists $need{$2}) { $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++; } else { warning("Possibly wrong #define $1 in $filename") } } for (qw(uses needs uses_todo needed_global needed_static)) { for $func (keys %{$file{$_}}) { push @{$global{$_}{$func}}, $filename; } } $files{$filename} = \%file; } # Globally resolve NEED_'s my $need; for $need (keys %{$global{needs}}) { if (@{$global{needs}{$need}} > 1) { my @targets = @{$global{needs}{$need}}; my @t = grep $files{$_}{needed_global}{$need}, @targets; @targets = @t if @t; @t = grep /\.xs$/i, @targets; @targets = @t if @t; my $target = shift @targets; $files{$target}{needs}{$need} = 'global'; for (@{$global{needs}{$need}}) { $files{$_}{needs}{$need} = 'extern' if $_ ne $target; } } } for $filename (@files) { exists $files{$filename} or next; info("=== Analyzing $filename ==="); my %file = %{$files{$filename}}; my $func; my $c = $file{code}; my $warnings = 0; for $func (sort keys %{$file{uses_Perl}}) { if ($API{$func}{varargs}) { unless ($API{$func}{nothxarg}) { my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))} { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge); if ($changes) { warning("Doesn't pass interpreter argument aTHX to Perl_$func"); $file{changes} += $changes; } } } else { warning("Uses Perl_$func instead of $func"); $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*} {$func$1(}g); } } for $func (sort keys %{$file{uses_replace}}) { warning("Uses $func instead of $replace{$func}"); $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); } for $func (sort keys %{$file{uses_provided}}) { if ($file{uses}{$func}) { if (exists $file{uses_deps}{$func}) { diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}})); } else { diag("Uses $func"); } } $warnings += hint($func); } unless ($opt{quiet}) { for $func (sort keys %{$file{uses_todo}}) { print "*** WARNING: Uses $func, which may not be portable below perl ", format_version($API{$func}{todo}), ", even with '$ppport'\n"; $warnings++; } } for $func (sort keys %{$file{needed_static}}) { my $message = ''; if (not exists $file{uses}{$func}) { $message = "No need to define NEED_$func if $func is never used"; } elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') { $message = "No need to define NEED_$func when already needed globally"; } if ($message) { diag($message); $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg); } } for $func (sort keys %{$file{needed_global}}) { my $message = ''; if (not exists $global{uses}{$func}) { $message = "No need to define NEED_${func}_GLOBAL if $func is never used"; } elsif (exists $file{needs}{$func}) { if ($file{needs}{$func} eq 'extern') { $message = "No need to define NEED_${func}_GLOBAL when already needed globally"; } elsif ($file{needs}{$func} eq 'static') { $message = "No need to define NEED_${func}_GLOBAL when only used in this file"; } } if ($message) { diag($message); $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg); } } $file{needs_inc_ppport} = keys %{$file{uses}}; if ($file{needs_inc_ppport}) { my $pp = ''; for $func (sort keys %{$file{needs}}) { my $type = $file{needs}{$func}; next if $type eq 'extern'; my $suffix = $type eq 'global' ? '_GLOBAL' : ''; unless (exists $file{"needed_$type"}{$func}) { if ($type eq 'global') { diag("Files [@{$global{needs}{$func}}] need $func, adding global request"); } else { diag("File needs $func, adding static request"); } $pp .= "#define NEED_$func$suffix\n"; } } if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) { $pp = ''; $file{changes}++; } unless ($file{has_inc_ppport}) { diag("Needs to include '$ppport'"); $pp .= qq(#include "$ppport"\n) } if ($pp) { $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms) || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m) || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m) || ($c =~ s/^/$pp/); } } else { if ($file{has_inc_ppport}) { diag("No need to include '$ppport'"); $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m); } } # put back in our C comments my $ix; my $cppc = 0; my @ccom = @{$file{ccom}}; for $ix (0 .. $#ccom) { if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) { $cppc++; $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/; } else { $c =~ s/$rccs$ix$rcce/$ccom[$ix]/; } } if ($cppc) { my $s = $cppc != 1 ? 's' : ''; warning("Uses $cppc C++ style comment$s, which is not portable"); } my $s = $warnings != 1 ? 's' : ''; my $warn = $warnings ? " ($warnings warning$s)" : ''; info("Analysis completed$warn"); if ($file{changes}) { if (exists $opt{copy}) { my $newfile = "$filename$opt{copy}"; if (-e $newfile) { error("'$newfile' already exists, refusing to write copy of '$filename'"); } else { local *F; if (open F, ">$newfile") { info("Writing copy of '$filename' with changes to '$newfile'"); print F $c; close F; } else { error("Cannot open '$newfile' for writing: $!"); } } } elsif (exists $opt{patch} || $opt{changes}) { if (exists $opt{patch}) { unless ($patch_opened) { if (open PATCH, ">$opt{patch}") { $patch_opened = 1; } else { error("Cannot open '$opt{patch}' for writing: $!"); delete $opt{patch}; $opt{changes} = 1; goto fallback; } } mydiff(\*PATCH, $filename, $c); } else { fallback: info("Suggested changes:"); mydiff(\*STDOUT, $filename, $c); } } else { my $s = $file{changes} == 1 ? '' : 's'; info("$file{changes} potentially required change$s detected"); } } else { info("Looks good"); } } close PATCH if $patch_opened; exit 0; sub try_use { eval "use @_;"; return $@ eq '' } sub mydiff { local *F = shift; my($file, $str) = @_; my $diff; if (exists $opt{diff}) { $diff = run_diff($opt{diff}, $file, $str); } if (!defined $diff and try_use('Text::Diff')) { $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' }); $diff = <
$tmp") { print F $str; close F; if (open F, "$prog $file $tmp |") { while () { s/\Q$tmp\E/$file.patched/; $diff .= $_; } close F; unlink $tmp; return $diff; } unlink $tmp; } else { error("Cannot open '$tmp' for writing: $!"); } return undef; } sub rec_depend { my($func, $seen) = @_; return () unless exists $depends{$func}; $seen = {%{$seen||{}}}; return () if $seen->{$func}++; my %s; grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}}; } sub parse_version { my $ver = shift; if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) { return ($1, $2, $3); } elsif ($ver !~ /^\d+\.[\d_]+$/) { die "cannot parse version '$ver'\n"; } $ver =~ s/_//g; $ver =~ s/$/000000/; my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; $v = int $v; $s = int $s; if ($r < 5 || ($r == 5 && $v < 6)) { if ($s % 10) { die "cannot parse version '$ver'\n"; } } return ($r, $v, $s); } sub format_version { my $ver = shift; $ver =~ s/$/000000/; my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/; $v = int $v; $s = int $s; if ($r < 5 || ($r == 5 && $v < 6)) { if ($s % 10) { die "invalid version '$ver'\n"; } $s /= 10; $ver = sprintf "%d.%03d", $r, $v; $s > 0 and $ver .= sprintf "_%02d", $s; return $ver; } return sprintf "%d.%d.%d", $r, $v, $s; } sub info { $opt{quiet} and return; print @_, "\n"; } sub diag { $opt{quiet} and return; $opt{diag} and print @_, "\n"; } sub warning { $opt{quiet} and return; print "*** ", @_, "\n"; } sub error { print "*** ERROR: ", @_, "\n"; } my %given_hints; my %given_warnings; sub hint { $opt{quiet} and return; my $func = shift; my $rv = 0; if (exists $warnings{$func} && !$given_warnings{$func}++) { my $warn = $warnings{$func}; $warn =~ s!^!*** !mg; print "*** WARNING: $func\n", $warn; $rv++; } if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) { my $hint = $hints{$func}; $hint =~ s/^/ /mg; print " --- hint for $func ---\n", $hint; } $rv; } sub usage { my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms; my %M = ( 'I' => '*' ); $usage =~ s/^\s*perl\s+\S+/$^X $0/; $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g; print < }; my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms; $copy =~ s/^(?=\S+)/ /gms; $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms; $self =~ s/^SKIP.*(?=^__DATA__)/SKIP if (\@ARGV && \$ARGV[0] eq '--unstrip') { eval { require Devel::PPPort }; \$@ and die "Cannot require Devel::PPPort, please install.\\n"; if (eval \$Devel::PPPort::VERSION < $VERSION) { die "$0 was originally generated with Devel::PPPort $VERSION.\\n" . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n" . "Please install a newer version, or --unstrip will not work.\\n"; } Devel::PPPort::WriteFile(\$0); exit 0; } print <$0" or die "cannot strip $0: $!\n"; print OUT "$pl$c\n"; exit 0; } __DATA__ */ #ifndef _P_P_PORTABILITY_H_ #define _P_P_PORTABILITY_H_ #ifndef DPPP_NAMESPACE # define DPPP_NAMESPACE DPPP_ #endif #define DPPP_CAT2(x,y) CAT2(x,y) #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name) #ifndef PERL_REVISION # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION)) # define PERL_PATCHLEVEL_H_IMPLICIT # include # endif # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL))) # include # endif # ifndef PERL_REVISION # define PERL_REVISION (5) /* Replace: 1 */ # define PERL_VERSION PATCHLEVEL # define PERL_SUBVERSION SUBVERSION /* Replace PERL_PATCHLEVEL with PERL_VERSION */ /* Replace: 0 */ # endif #endif #define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10)) #define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION)) /* It is very unlikely that anyone will try to use this with Perl 6 (or greater), but who knows. */ #if PERL_REVISION != 5 # error ppport.h only works with Perl version 5 #endif /* PERL_REVISION != 5 */ #ifndef dTHR # define dTHR dNOOP #endif #ifndef dTHX # define dTHX dNOOP #endif #ifndef dTHXa # define dTHXa(x) dNOOP #endif #ifndef pTHX # define pTHX void #endif #ifndef pTHX_ # define pTHX_ #endif #ifndef aTHX # define aTHX #endif #ifndef aTHX_ # define aTHX_ #endif #if (PERL_BCDVERSION < 0x5006000) # ifdef USE_THREADS # define aTHXR thr # define aTHXR_ thr, # else # define aTHXR # define aTHXR_ # endif # define dTHXR dTHR #else # define aTHXR aTHX # define aTHXR_ aTHX_ # define dTHXR dTHX #endif #ifndef dTHXoa # define dTHXoa(x) dTHXa(x) #endif #ifdef I_LIMITS # include #endif #ifndef PERL_UCHAR_MIN # define PERL_UCHAR_MIN ((unsigned char)0) #endif #ifndef PERL_UCHAR_MAX # ifdef UCHAR_MAX # define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX) # else # ifdef MAXUCHAR # define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR) # else # define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0) # endif # endif #endif #ifndef PERL_USHORT_MIN # define PERL_USHORT_MIN ((unsigned short)0) #endif #ifndef PERL_USHORT_MAX # ifdef USHORT_MAX # define PERL_USHORT_MAX ((unsigned short)USHORT_MAX) # else # ifdef MAXUSHORT # define PERL_USHORT_MAX ((unsigned short)MAXUSHORT) # else # ifdef USHRT_MAX # define PERL_USHORT_MAX ((unsigned short)USHRT_MAX) # else # define PERL_USHORT_MAX ((unsigned short)~(unsigned)0) # endif # endif # endif #endif #ifndef PERL_SHORT_MAX # ifdef SHORT_MAX # define PERL_SHORT_MAX ((short)SHORT_MAX) # else # ifdef MAXSHORT /* Often used in */ # define PERL_SHORT_MAX ((short)MAXSHORT) # else # ifdef SHRT_MAX # define PERL_SHORT_MAX ((short)SHRT_MAX) # else # define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1)) # endif # endif # endif #endif #ifndef PERL_SHORT_MIN # ifdef SHORT_MIN # define PERL_SHORT_MIN ((short)SHORT_MIN) # else # ifdef MINSHORT # define PERL_SHORT_MIN ((short)MINSHORT) # else # ifdef SHRT_MIN # define PERL_SHORT_MIN ((short)SHRT_MIN) # else # define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3)) # endif # endif # endif #endif #ifndef PERL_UINT_MAX # ifdef UINT_MAX # define PERL_UINT_MAX ((unsigned int)UINT_MAX) # else # ifdef MAXUINT # define PERL_UINT_MAX ((unsigned int)MAXUINT) # else # define PERL_UINT_MAX (~(unsigned int)0) # endif # endif #endif #ifndef PERL_UINT_MIN # define PERL_UINT_MIN ((unsigned int)0) #endif #ifndef PERL_INT_MAX # ifdef INT_MAX # define PERL_INT_MAX ((int)INT_MAX) # else # ifdef MAXINT /* Often used in */ # define PERL_INT_MAX ((int)MAXINT) # else # define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1)) # endif # endif #endif #ifndef PERL_INT_MIN # ifdef INT_MIN # define PERL_INT_MIN ((int)INT_MIN) # else # ifdef MININT # define PERL_INT_MIN ((int)MININT) # else # define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3)) # endif # endif #endif #ifndef PERL_ULONG_MAX # ifdef ULONG_MAX # define PERL_ULONG_MAX ((unsigned long)ULONG_MAX) # else # ifdef MAXULONG # define PERL_ULONG_MAX ((unsigned long)MAXULONG) # else # define PERL_ULONG_MAX (~(unsigned long)0) # endif # endif #endif #ifndef PERL_ULONG_MIN # define PERL_ULONG_MIN ((unsigned long)0L) #endif #ifndef PERL_LONG_MAX # ifdef LONG_MAX # define PERL_LONG_MAX ((long)LONG_MAX) # else # ifdef MAXLONG # define PERL_LONG_MAX ((long)MAXLONG) # else # define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1)) # endif # endif #endif #ifndef PERL_LONG_MIN # ifdef LONG_MIN # define PERL_LONG_MIN ((long)LONG_MIN) # else # ifdef MINLONG # define PERL_LONG_MIN ((long)MINLONG) # else # define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3)) # endif # endif #endif #if defined(HAS_QUAD) && (defined(convex) || defined(uts)) # ifndef PERL_UQUAD_MAX # ifdef ULONGLONG_MAX # define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX) # else # ifdef MAXULONGLONG # define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG) # else # define PERL_UQUAD_MAX (~(unsigned long long)0) # endif # endif # endif # ifndef PERL_UQUAD_MIN # define PERL_UQUAD_MIN ((unsigned long long)0L) # endif # ifndef PERL_QUAD_MAX # ifdef LONGLONG_MAX # define PERL_QUAD_MAX ((long long)LONGLONG_MAX) # else # ifdef MAXLONGLONG # define PERL_QUAD_MAX ((long long)MAXLONGLONG) # else # define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1)) # endif # endif # endif # ifndef PERL_QUAD_MIN # ifdef LONGLONG_MIN # define PERL_QUAD_MIN ((long long)LONGLONG_MIN) # else # ifdef MINLONGLONG # define PERL_QUAD_MIN ((long long)MINLONGLONG) # else # define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3)) # endif # endif # endif #endif /* This is based on code from 5.003 perl.h */ #ifdef HAS_QUAD # ifdef cray #ifndef IVTYPE # define IVTYPE int #endif #ifndef IV_MIN # define IV_MIN PERL_INT_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_INT_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_UINT_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_UINT_MAX #endif # ifdef INTSIZE #ifndef IVSIZE # define IVSIZE INTSIZE #endif # endif # else # if defined(convex) || defined(uts) #ifndef IVTYPE # define IVTYPE long long #endif #ifndef IV_MIN # define IV_MIN PERL_QUAD_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_QUAD_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_UQUAD_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_UQUAD_MAX #endif # ifdef LONGLONGSIZE #ifndef IVSIZE # define IVSIZE LONGLONGSIZE #endif # endif # else #ifndef IVTYPE # define IVTYPE long #endif #ifndef IV_MIN # define IV_MIN PERL_LONG_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_LONG_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_ULONG_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_ULONG_MAX #endif # ifdef LONGSIZE #ifndef IVSIZE # define IVSIZE LONGSIZE #endif # endif # endif # endif #ifndef IVSIZE # define IVSIZE 8 #endif #ifndef PERL_QUAD_MIN # define PERL_QUAD_MIN IV_MIN #endif #ifndef PERL_QUAD_MAX # define PERL_QUAD_MAX IV_MAX #endif #ifndef PERL_UQUAD_MIN # define PERL_UQUAD_MIN UV_MIN #endif #ifndef PERL_UQUAD_MAX # define PERL_UQUAD_MAX UV_MAX #endif #else #ifndef IVTYPE # define IVTYPE long #endif #ifndef IV_MIN # define IV_MIN PERL_LONG_MIN #endif #ifndef IV_MAX # define IV_MAX PERL_LONG_MAX #endif #ifndef UV_MIN # define UV_MIN PERL_ULONG_MIN #endif #ifndef UV_MAX # define UV_MAX PERL_ULONG_MAX #endif #endif #ifndef IVSIZE # ifdef LONGSIZE # define IVSIZE LONGSIZE # else # define IVSIZE 4 /* A bold guess, but the best we can make. */ # endif #endif #ifndef UVTYPE # define UVTYPE unsigned IVTYPE #endif #ifndef UVSIZE # define UVSIZE IVSIZE #endif #ifndef sv_setuv # define sv_setuv(sv, uv) \ STMT_START { \ UV TeMpUv = uv; \ if (TeMpUv <= IV_MAX) \ sv_setiv(sv, TeMpUv); \ else \ sv_setnv(sv, (double)TeMpUv); \ } STMT_END #endif #ifndef newSVuv # define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv)) #endif #ifndef sv_2uv # define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv))) #endif #ifndef SvUVX # define SvUVX(sv) ((UV)SvIVX(sv)) #endif #ifndef SvUVXx # define SvUVXx(sv) SvUVX(sv) #endif #ifndef SvUV # define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) #endif #ifndef SvUVx # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) #endif /* Hint: sv_uv * Always use the SvUVx() macro instead of sv_uv(). */ #ifndef sv_uv # define sv_uv(sv) SvUVx(sv) #endif #if !defined(SvUOK) && defined(SvIOK_UV) # define SvUOK(sv) SvIOK_UV(sv) #endif #ifndef XST_mUV # define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) #endif #ifndef XSRETURN_UV # define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END #endif #ifndef PUSHu # define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END #endif #ifndef XPUSHu # define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END #endif #ifdef HAS_MEMCMP #ifndef memNE # define memNE(s1,s2,l) (memcmp(s1,s2,l)) #endif #ifndef memEQ # define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) #endif #else #ifndef memNE # define memNE(s1,s2,l) (bcmp(s1,s2,l)) #endif #ifndef memEQ # define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) #endif #endif #ifndef MoveD # define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t)) #endif #ifndef CopyD # define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) #endif #ifdef HAS_MEMSET #ifndef ZeroD # define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) #endif #else #ifndef ZeroD # define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d) #endif #endif #ifndef PoisonWith # define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t)) #endif #ifndef PoisonNew # define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) #endif #ifndef PoisonFree # define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) #endif #ifndef Poison # define Poison(d,n,t) PoisonFree(d,n,t) #endif #ifndef Newx # define Newx(v,n,t) New(0,v,n,t) #endif #ifndef Newxc # define Newxc(v,n,t,c) Newc(0,v,n,t,c) #endif #ifndef Newxz # define Newxz(v,n,t) Newz(0,v,n,t) #endif #ifndef PERL_UNUSED_DECL # ifdef HASATTRIBUTE # if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER) # define PERL_UNUSED_DECL # else # define PERL_UNUSED_DECL __attribute__((unused)) # endif # else # define PERL_UNUSED_DECL # endif #endif #ifndef PERL_UNUSED_ARG # if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ # include # define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) # else # define PERL_UNUSED_ARG(x) ((void)x) # endif #endif #ifndef PERL_UNUSED_VAR # define PERL_UNUSED_VAR(x) ((void)x) #endif #ifndef PERL_UNUSED_CONTEXT # ifdef USE_ITHREADS # define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl) # else # define PERL_UNUSED_CONTEXT # endif #endif #ifndef NOOP # define NOOP /*EMPTY*/(void)0 #endif #ifndef dNOOP # define dNOOP extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL #endif #ifndef NVTYPE # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) # define NVTYPE long double # else # define NVTYPE double # endif typedef NVTYPE NV; #endif #ifndef INT2PTR # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) # define PTRV UV # define INT2PTR(any,d) (any)(d) # else # if PTRSIZE == LONGSIZE # define PTRV unsigned long # else # define PTRV unsigned # endif # define INT2PTR(any,d) (any)(PTRV)(d) # endif #endif #ifndef PTR2ul # if PTRSIZE == LONGSIZE # define PTR2ul(p) (unsigned long)(p) # else # define PTR2ul(p) INT2PTR(unsigned long,p) # endif #endif #ifndef PTR2nat # define PTR2nat(p) (PTRV)(p) #endif #ifndef NUM2PTR # define NUM2PTR(any,d) (any)PTR2nat(d) #endif #ifndef PTR2IV # define PTR2IV(p) INT2PTR(IV,p) #endif #ifndef PTR2UV # define PTR2UV(p) INT2PTR(UV,p) #endif #ifndef PTR2NV # define PTR2NV(p) NUM2PTR(NV,p) #endif #undef START_EXTERN_C #undef END_EXTERN_C #undef EXTERN_C #ifdef __cplusplus # define START_EXTERN_C extern "C" { # define END_EXTERN_C } # define EXTERN_C extern "C" #else # define START_EXTERN_C # define END_EXTERN_C # define EXTERN_C extern #endif #if defined(PERL_GCC_PEDANTIC) # ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN # define PERL_GCC_BRACE_GROUPS_FORBIDDEN # endif #endif #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus) # ifndef PERL_USE_GCC_BRACE_GROUPS # define PERL_USE_GCC_BRACE_GROUPS # endif #endif #undef STMT_START #undef STMT_END #ifdef PERL_USE_GCC_BRACE_GROUPS # define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */ # define STMT_END ) #else # if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__) # define STMT_START if (1) # define STMT_END else (void)0 # else # define STMT_START do # define STMT_END while (0) # endif #endif #ifndef boolSV # define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) #endif /* DEFSV appears first in 5.004_56 */ #ifndef DEFSV # define DEFSV GvSV(PL_defgv) #endif #ifndef SAVE_DEFSV # define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv)) #endif #ifndef DEFSV_set # define DEFSV_set(sv) (DEFSV = (sv)) #endif /* Older perls (<=5.003) lack AvFILLp */ #ifndef AvFILLp # define AvFILLp AvFILL #endif #ifndef ERRSV # define ERRSV get_sv("@",FALSE) #endif /* Hint: gv_stashpvn * This function's backport doesn't support the length parameter, but * rather ignores it. Portability can only be ensured if the length * parameter is used for speed reasons, but the length can always be * correctly computed from the string argument. */ #ifndef gv_stashpvn # define gv_stashpvn(str,len,create) gv_stashpv(str,create) #endif /* Replace: 1 */ #ifndef get_cv # define get_cv perl_get_cv #endif #ifndef get_sv # define get_sv perl_get_sv #endif #ifndef get_av # define get_av perl_get_av #endif #ifndef get_hv # define get_hv perl_get_hv #endif /* Replace: 0 */ #ifndef dUNDERBAR # define dUNDERBAR dNOOP #endif #ifndef UNDERBAR # define UNDERBAR DEFSV #endif #ifndef dAX # define dAX I32 ax = MARK - PL_stack_base + 1 #endif #ifndef dITEMS # define dITEMS I32 items = SP - MARK #endif #ifndef dXSTARG # define dXSTARG SV * targ = sv_newmortal() #endif #ifndef dAXMARK # define dAXMARK I32 ax = POPMARK; \ register SV ** const mark = PL_stack_base + ax++ #endif #ifndef XSprePUSH # define XSprePUSH (sp = PL_stack_base + ax - 1) #endif #if (PERL_BCDVERSION < 0x5005000) # undef XSRETURN # define XSRETURN(off) \ STMT_START { \ PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ return; \ } STMT_END #endif #ifndef XSPROTO # define XSPROTO(name) void name(pTHX_ CV* cv) #endif #ifndef SVfARG # define SVfARG(p) ((void*)(p)) #endif #ifndef PERL_ABS # define PERL_ABS(x) ((x) < 0 ? -(x) : (x)) #endif #ifndef dVAR # define dVAR dNOOP #endif #ifndef SVf # define SVf "_" #endif #ifndef UTF8_MAXBYTES # define UTF8_MAXBYTES UTF8_MAXLEN #endif #ifndef CPERLscope # define CPERLscope(x) x #endif #ifndef PERL_HASH # define PERL_HASH(hash,str,len) \ STMT_START { \ const char *s_PeRlHaSh = str; \ I32 i_PeRlHaSh = len; \ U32 hash_PeRlHaSh = 0; \ while (i_PeRlHaSh--) \ hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \ (hash) = hash_PeRlHaSh; \ } STMT_END #endif #ifndef PERLIO_FUNCS_DECL # ifdef PERLIO_FUNCS_CONST # define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs # define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs) # else # define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs # define PERLIO_FUNCS_CAST(funcs) (funcs) # endif #endif /* provide these typedefs for older perls */ #if (PERL_BCDVERSION < 0x5009003) # ifdef ARGSproto typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto); # else typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX); # endif typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); #endif #ifndef isPSXSPC # define isPSXSPC(c) (isSPACE(c) || (c) == '\v') #endif #ifndef isBLANK # define isBLANK(c) ((c) == ' ' || (c) == '\t') #endif #ifdef EBCDIC #ifndef isALNUMC # define isALNUMC(c) isalnum(c) #endif #ifndef isASCII # define isASCII(c) isascii(c) #endif #ifndef isCNTRL # define isCNTRL(c) iscntrl(c) #endif #ifndef isGRAPH # define isGRAPH(c) isgraph(c) #endif #ifndef isPRINT # define isPRINT(c) isprint(c) #endif #ifndef isPUNCT # define isPUNCT(c) ispunct(c) #endif #ifndef isXDIGIT # define isXDIGIT(c) isxdigit(c) #endif #else # if (PERL_BCDVERSION < 0x5010000) /* Hint: isPRINT * The implementation in older perl versions includes all of the * isSPACE() characters, which is wrong. The version provided by * Devel::PPPort always overrides a present buggy version. */ # undef isPRINT # endif #ifndef isALNUMC # define isALNUMC(c) (isALPHA(c) || isDIGIT(c)) #endif #ifndef isASCII # define isASCII(c) ((c) <= 127) #endif #ifndef isCNTRL # define isCNTRL(c) ((c) < ' ' || (c) == 127) #endif #ifndef isGRAPH # define isGRAPH(c) (isALNUM(c) || isPUNCT(c)) #endif #ifndef isPRINT # define isPRINT(c) (((c) >= 32 && (c) < 127)) #endif #ifndef isPUNCT # define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) #endif #ifndef isXDIGIT # define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F')) #endif #endif #ifndef PERL_SIGNALS_UNSAFE_FLAG #define PERL_SIGNALS_UNSAFE_FLAG 0x0001 #if (PERL_BCDVERSION < 0x5008000) # define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG #else # define D_PPP_PERL_SIGNALS_INIT 0 #endif #if defined(NEED_PL_signals) static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; #elif defined(NEED_PL_signals_GLOBAL) U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; #else extern U32 DPPP_(my_PL_signals); #endif #define PL_signals DPPP_(my_PL_signals) #endif /* Hint: PL_ppaddr * Calling an op via PL_ppaddr requires passing a context argument * for threaded builds. Since the context argument is different for * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will * automatically be defined as the correct argument. */ #if (PERL_BCDVERSION <= 0x5005005) /* Replace: 1 */ # define PL_ppaddr ppaddr # define PL_no_modify no_modify /* Replace: 0 */ #endif #if (PERL_BCDVERSION <= 0x5004005) /* Replace: 1 */ # define PL_DBsignal DBsignal # define PL_DBsingle DBsingle # define PL_DBsub DBsub # define PL_DBtrace DBtrace # define PL_Sv Sv # define PL_bufend bufend # define PL_bufptr bufptr # define PL_compiling compiling # define PL_copline copline # define PL_curcop curcop # define PL_curstash curstash # define PL_debstash debstash # define PL_defgv defgv # define PL_diehook diehook # define PL_dirty dirty # define PL_dowarn dowarn # define PL_errgv errgv # define PL_error_count error_count # define PL_expect expect # define PL_hexdigit hexdigit # define PL_hints hints # define PL_in_my in_my # define PL_laststatval laststatval # define PL_lex_state lex_state # define PL_lex_stuff lex_stuff # define PL_linestr linestr # define PL_na na # define PL_perl_destruct_level perl_destruct_level # define PL_perldb perldb # define PL_rsfp_filters rsfp_filters # define PL_rsfp rsfp # define PL_stack_base stack_base # define PL_stack_sp stack_sp # define PL_statcache statcache # define PL_stdingv stdingv # define PL_sv_arenaroot sv_arenaroot # define PL_sv_no sv_no # define PL_sv_undef sv_undef # define PL_sv_yes sv_yes # define PL_tainted tainted # define PL_tainting tainting # define PL_tokenbuf tokenbuf /* Replace: 0 */ #endif /* Warning: PL_parser * For perl versions earlier than 5.9.5, this is an always * non-NULL dummy. Also, it cannot be dereferenced. Don't * use it if you can avoid is and unless you absolutely know * what you're doing. * If you always check that PL_parser is non-NULL, you can * define DPPP_PL_parser_NO_DUMMY to avoid the creation of * a dummy parser structure. */ #if (PERL_BCDVERSION >= 0x5009005) # ifdef DPPP_PL_parser_NO_DUMMY # define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ (croak("panic: PL_parser == NULL in %s:%d", \ __FILE__, __LINE__), (yy_parser *) NULL))->var) # else # ifdef DPPP_PL_parser_NO_DUMMY_WARNING # define D_PPP_parser_dummy_warning(var) # else # define D_PPP_parser_dummy_warning(var) \ warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__), # endif # define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var) #if defined(NEED_PL_parser) static yy_parser DPPP_(dummy_PL_parser); #elif defined(NEED_PL_parser_GLOBAL) yy_parser DPPP_(dummy_PL_parser); #else extern yy_parser DPPP_(dummy_PL_parser); #endif # endif /* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */ /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf * Do not use this variable unless you know exactly what you're * doint. It is internal to the perl parser and may change or even * be removed in the future. As of perl 5.9.5, you have to check * for (PL_parser != NULL) for this variable to have any effect. * An always non-NULL PL_parser dummy is provided for earlier * perl versions. * If PL_parser is NULL when you try to access this variable, a * dummy is being accessed instead and a warning is issued unless * you define DPPP_PL_parser_NO_DUMMY_WARNING. * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access * this variable will croak with a panic message. */ # define PL_expect D_PPP_my_PL_parser_var(expect) # define PL_copline D_PPP_my_PL_parser_var(copline) # define PL_rsfp D_PPP_my_PL_parser_var(rsfp) # define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters) # define PL_linestr D_PPP_my_PL_parser_var(linestr) # define PL_bufptr D_PPP_my_PL_parser_var(bufptr) # define PL_bufend D_PPP_my_PL_parser_var(bufend) # define PL_lex_state D_PPP_my_PL_parser_var(lex_state) # define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff) # define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf) # define PL_in_my D_PPP_my_PL_parser_var(in_my) # define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash) # define PL_error_count D_PPP_my_PL_parser_var(error_count) #else /* ensure that PL_parser != NULL and cannot be dereferenced */ # define PL_parser ((void *) 1) #endif #ifndef mPUSHs # define mPUSHs(s) PUSHs(sv_2mortal(s)) #endif #ifndef PUSHmortal # define PUSHmortal PUSHs(sv_newmortal()) #endif #ifndef mPUSHp # define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l)) #endif #ifndef mPUSHn # define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) #endif #ifndef mPUSHi # define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) #endif #ifndef mPUSHu # define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) #endif #ifndef mXPUSHs # define mXPUSHs(s) XPUSHs(sv_2mortal(s)) #endif #ifndef XPUSHmortal # define XPUSHmortal XPUSHs(sv_newmortal()) #endif #ifndef mXPUSHp # define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END #endif #ifndef mXPUSHn # define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END #endif #ifndef mXPUSHi # define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END #endif #ifndef mXPUSHu # define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END #endif /* Replace: 1 */ #ifndef call_sv # define call_sv perl_call_sv #endif #ifndef call_pv # define call_pv perl_call_pv #endif #ifndef call_argv # define call_argv perl_call_argv #endif #ifndef call_method # define call_method perl_call_method #endif #ifndef eval_sv # define eval_sv perl_eval_sv #endif /* Replace: 0 */ #ifndef PERL_LOADMOD_DENY # define PERL_LOADMOD_DENY 0x1 #endif #ifndef PERL_LOADMOD_NOIMPORT # define PERL_LOADMOD_NOIMPORT 0x2 #endif #ifndef PERL_LOADMOD_IMPORT_OPS # define PERL_LOADMOD_IMPORT_OPS 0x4 #endif #ifndef G_METHOD # define G_METHOD 64 # ifdef call_sv # undef call_sv # endif # if (PERL_BCDVERSION < 0x5006000) # define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \ (flags) & ~G_METHOD) : perl_call_sv(sv, flags)) # else # define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \ (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags)) # endif #endif /* Replace perl_eval_pv with eval_pv */ #ifndef eval_pv #if defined(NEED_eval_pv) static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); static #else extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error); #endif #ifdef eval_pv # undef eval_pv #endif #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b) #define Perl_eval_pv DPPP_(my_eval_pv) #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error) { dSP; SV* sv = newSVpv(p, 0); PUSHMARK(sp); eval_sv(sv, G_SCALAR); SvREFCNT_dec(sv); SPAGAIN; sv = POPs; PUTBACK; if (croak_on_error && SvTRUE(GvSV(errgv))) croak(SvPVx(GvSV(errgv), na)); return sv; } #endif #endif #ifndef vload_module #if defined(NEED_vload_module) static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); static #else extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args); #endif #ifdef vload_module # undef vload_module #endif #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d) #define Perl_vload_module DPPP_(my_vload_module) #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args) { dTHR; dVAR; OP *veop, *imop; OP * const modname = newSVOP(OP_CONST, 0, name); /* 5.005 has a somewhat hacky force_normal that doesn't croak on SvREADONLY() if PL_compling is true. Current perls take care in ck_require() to correctly turn off SvREADONLY before calling force_normal_flags(). This seems a better fix than fudging PL_compling */ SvREADONLY_off(((SVOP*)modname)->op_sv); modname->op_private |= OPpCONST_BARE; if (ver) { veop = newSVOP(OP_CONST, 0, ver); } else veop = NULL; if (flags & PERL_LOADMOD_NOIMPORT) { imop = sawparens(newNULLLIST()); } else if (flags & PERL_LOADMOD_IMPORT_OPS) { imop = va_arg(*args, OP*); } else { SV *sv; imop = NULL; sv = va_arg(*args, SV*); while (sv) { imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv)); sv = va_arg(*args, SV*); } } { const line_t ocopline = PL_copline; COP * const ocurcop = PL_curcop; const int oexpect = PL_expect; #if (PERL_BCDVERSION >= 0x5004000) utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0), veop, modname, imop); #else utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(), modname, imop); #endif PL_expect = oexpect; PL_copline = ocopline; PL_curcop = ocurcop; } } #endif #endif #ifndef load_module #if defined(NEED_load_module) static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); static #else extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...); #endif #ifdef load_module # undef load_module #endif #define load_module DPPP_(my_load_module) #define Perl_load_module DPPP_(my_load_module) #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...) { va_list args; va_start(args, ver); vload_module(flags, name, ver, &args); va_end(args); } #endif #endif #ifndef newRV_inc # define newRV_inc(sv) newRV(sv) /* Replace */ #endif #ifndef newRV_noinc #if defined(NEED_newRV_noinc) static SV * DPPP_(my_newRV_noinc)(SV *sv); static #else extern SV * DPPP_(my_newRV_noinc)(SV *sv); #endif #ifdef newRV_noinc # undef newRV_noinc #endif #define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a) #define Perl_newRV_noinc DPPP_(my_newRV_noinc) #if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL) SV * DPPP_(my_newRV_noinc)(SV *sv) { SV *rv = (SV *)newRV(sv); SvREFCNT_dec(sv); return rv; } #endif #endif /* Hint: newCONSTSUB * Returns a CV* as of perl-5.7.1. This return value is not supported * by Devel::PPPort. */ /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */ #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005) #if defined(NEED_newCONSTSUB) static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); static #else extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv); #endif #ifdef newCONSTSUB # undef newCONSTSUB #endif #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) /* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */ /* (There's no PL_parser in perl < 5.005, so this is completely safe) */ #define D_PPP_PL_copline PL_copline void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv) { U32 oldhints = PL_hints; HV *old_cop_stash = PL_curcop->cop_stash; HV *old_curstash = PL_curstash; line_t oldline = PL_curcop->cop_line; PL_curcop->cop_line = D_PPP_PL_copline; PL_hints &= ~HINT_BLOCK_SCOPE; if (stash) PL_curstash = PL_curcop->cop_stash = stash; newSUB( #if (PERL_BCDVERSION < 0x5003022) start_subparse(), #elif (PERL_BCDVERSION == 0x5003022) start_subparse(0), #else /* 5.003_23 onwards */ start_subparse(FALSE, 0), #endif newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)), newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */ newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv)) ); PL_hints = oldhints; PL_curcop->cop_stash = old_cop_stash; PL_curstash = old_curstash; PL_curcop->cop_line = oldline; } #endif #endif /* * Boilerplate macros for initializing and accessing interpreter-local * data from C. All statics in extensions should be reworked to use * this, if you want to make the extension thread-safe. See ext/re/re.xs * for an example of the use of these macros. * * Code that uses these macros is responsible for the following: * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts" * 2. Declare a typedef named my_cxt_t that is a structure that contains * all the data that needs to be interpreter-local. * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t. * 4. Use the MY_CXT_INIT macro such that it is called exactly once * (typically put in the BOOT: section). * 5. Use the members of the my_cxt_t structure everywhere as * MY_CXT.member. * 6. Use the dMY_CXT macro (a declaration) in all the functions that * access MY_CXT. */ #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) #ifndef START_MY_CXT /* This must appear in all extensions that define a my_cxt_t structure, * right after the definition (i.e. at file scope). The non-threads * case below uses it to declare the data as static. */ #define START_MY_CXT #if (PERL_BCDVERSION < 0x5004068) /* Fetches the SV that keeps the per-interpreter data. */ #define dMY_CXT_SV \ SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE) #else /* >= perl5.004_68 */ #define dMY_CXT_SV \ SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \ sizeof(MY_CXT_KEY)-1, TRUE) #endif /* < perl5.004_68 */ /* This declaration should be used within all functions that use the * interpreter-local data. */ #define dMY_CXT \ dMY_CXT_SV; \ my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv)) /* Creates and zeroes the per-interpreter data. * (We allocate my_cxtp in a Perl SV so that it will be released when * the interpreter goes away.) */ #define MY_CXT_INIT \ dMY_CXT_SV; \ /* newSV() allocates one more than needed */ \ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ Zero(my_cxtp, 1, my_cxt_t); \ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) /* This macro must be used to access members of the my_cxt_t structure. * e.g. MYCXT.some_data */ #define MY_CXT (*my_cxtp) /* Judicious use of these macros can reduce the number of times dMY_CXT * is used. Use is similar to pTHX, aTHX etc. */ #define pMY_CXT my_cxt_t *my_cxtp #define pMY_CXT_ pMY_CXT, #define _pMY_CXT ,pMY_CXT #define aMY_CXT my_cxtp #define aMY_CXT_ aMY_CXT, #define _aMY_CXT ,aMY_CXT #endif /* START_MY_CXT */ #ifndef MY_CXT_CLONE /* Clones the per-interpreter data. */ #define MY_CXT_CLONE \ dMY_CXT_SV; \ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\ sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) #endif #else /* single interpreter */ #ifndef START_MY_CXT #define START_MY_CXT static my_cxt_t my_cxt; #define dMY_CXT_SV dNOOP #define dMY_CXT dNOOP #define MY_CXT_INIT NOOP #define MY_CXT my_cxt #define pMY_CXT void #define pMY_CXT_ #define _pMY_CXT #define aMY_CXT #define aMY_CXT_ #define _aMY_CXT #endif /* START_MY_CXT */ #ifndef MY_CXT_CLONE #define MY_CXT_CLONE NOOP #endif #endif #ifndef IVdf # if IVSIZE == LONGSIZE # define IVdf "ld" # define UVuf "lu" # define UVof "lo" # define UVxf "lx" # define UVXf "lX" # else # if IVSIZE == INTSIZE # define IVdf "d" # define UVuf "u" # define UVof "o" # define UVxf "x" # define UVXf "X" # endif # endif #endif #ifndef NVef # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \ defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000) /* Not very likely, but let's try anyway. */ # define NVef PERL_PRIeldbl # define NVff PERL_PRIfldbl # define NVgf PERL_PRIgldbl # else # define NVef "e" # define NVff "f" # define NVgf "g" # endif #endif #ifndef SvREFCNT_inc # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc(sv) \ ({ \ SV * const _sv = (SV*)(sv); \ if (_sv) \ (SvREFCNT(_sv))++; \ _sv; \ }) # else # define SvREFCNT_inc(sv) \ ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) # endif #endif #ifndef SvREFCNT_inc_simple # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc_simple(sv) \ ({ \ if (sv) \ (SvREFCNT(sv))++; \ (SV *)(sv); \ }) # else # define SvREFCNT_inc_simple(sv) \ ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL) # endif #endif #ifndef SvREFCNT_inc_NN # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc_NN(sv) \ ({ \ SV * const _sv = (SV*)(sv); \ SvREFCNT(_sv)++; \ _sv; \ }) # else # define SvREFCNT_inc_NN(sv) \ (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv) # endif #endif #ifndef SvREFCNT_inc_void # ifdef PERL_USE_GCC_BRACE_GROUPS # define SvREFCNT_inc_void(sv) \ ({ \ SV * const _sv = (SV*)(sv); \ if (_sv) \ (void)(SvREFCNT(_sv)++); \ }) # else # define SvREFCNT_inc_void(sv) \ (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) # endif #endif #ifndef SvREFCNT_inc_simple_void # define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END #endif #ifndef SvREFCNT_inc_simple_NN # define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) #endif #ifndef SvREFCNT_inc_void_NN # define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) #endif #ifndef SvREFCNT_inc_simple_void_NN # define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) #endif #ifndef newSV_type #if defined(NEED_newSV_type) static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); static #else extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t); #endif #ifdef newSV_type # undef newSV_type #endif #define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a) #define Perl_newSV_type DPPP_(my_newSV_type) #if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL) SV* DPPP_(my_newSV_type)(pTHX_ svtype const t) { SV* const sv = newSV(0); sv_upgrade(sv, t); return sv; } #endif #endif #if (PERL_BCDVERSION < 0x5006000) # define D_PPP_CONSTPV_ARG(x) ((char *) (x)) #else # define D_PPP_CONSTPV_ARG(x) (x) #endif #ifndef newSVpvn # define newSVpvn(data,len) ((data) \ ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \ : newSV(0)) #endif #ifndef newSVpvn_utf8 # define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) #endif #ifndef SVf_UTF8 # define SVf_UTF8 0 #endif #ifndef newSVpvn_flags #if defined(NEED_newSVpvn_flags) static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); static #else extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags); #endif #ifdef newSVpvn_flags # undef newSVpvn_flags #endif #define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c) #define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags) #if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL) SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags) { SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len); SvFLAGS(sv) |= (flags & SVf_UTF8); return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv; } #endif #endif /* Backwards compatibility stuff... :-( */ #if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen) # define NEED_sv_2pv_flags #endif #if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL) # define NEED_sv_2pv_flags_GLOBAL #endif /* Hint: sv_2pv_nolen * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen(). */ #ifndef sv_2pv_nolen # define sv_2pv_nolen(sv) SvPV_nolen(sv) #endif #ifdef SvPVbyte /* Hint: SvPVbyte * Does not work in perl-5.6.1, ppport.h implements a version * borrowed from perl-5.7.3. */ #if (PERL_BCDVERSION < 0x5007000) #if defined(NEED_sv_2pvbyte) static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); static #else extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp); #endif #ifdef sv_2pvbyte # undef sv_2pvbyte #endif #define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b) #define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte) #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL) char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp) { sv_utf8_downgrade(sv,0); return SvPV(sv,*lp); } #endif /* Hint: sv_2pvbyte * Use the SvPVbyte() macro instead of sv_2pvbyte(). */ #undef SvPVbyte #define SvPVbyte(sv, lp) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) #endif #else # define SvPVbyte SvPV # define sv_2pvbyte sv_2pv #endif #ifndef sv_2pvbyte_nolen # define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv) #endif /* Hint: sv_pvn * Always use the SvPV() macro instead of sv_pvn(). */ /* Hint: sv_pvn_force * Always use the SvPV_force() macro instead of sv_pvn_force(). */ /* If these are undefined, they're not handled by the core anyway */ #ifndef SV_IMMEDIATE_UNREF # define SV_IMMEDIATE_UNREF 0 #endif #ifndef SV_GMAGIC # define SV_GMAGIC 0 #endif #ifndef SV_COW_DROP_PV # define SV_COW_DROP_PV 0 #endif #ifndef SV_UTF8_NO_ENCODING # define SV_UTF8_NO_ENCODING 0 #endif #ifndef SV_NOSTEAL # define SV_NOSTEAL 0 #endif #ifndef SV_CONST_RETURN # define SV_CONST_RETURN 0 #endif #ifndef SV_MUTABLE_RETURN # define SV_MUTABLE_RETURN 0 #endif #ifndef SV_SMAGIC # define SV_SMAGIC 0 #endif #ifndef SV_HAS_TRAILING_NUL # define SV_HAS_TRAILING_NUL 0 #endif #ifndef SV_COW_SHARED_HASH_KEYS # define SV_COW_SHARED_HASH_KEYS 0 #endif #if (PERL_BCDVERSION < 0x5007002) #if defined(NEED_sv_2pv_flags) static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); static #else extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); #endif #ifdef sv_2pv_flags # undef sv_2pv_flags #endif #define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c) #define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags) #if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL) char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) { STRLEN n_a = (STRLEN) flags; return sv_2pv(sv, lp ? lp : &n_a); } #endif #if defined(NEED_sv_pvn_force_flags) static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); static #else extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags); #endif #ifdef sv_pvn_force_flags # undef sv_pvn_force_flags #endif #define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c) #define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags) #if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL) char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags) { STRLEN n_a = (STRLEN) flags; return sv_pvn_force(sv, lp ? lp : &n_a); } #endif #endif #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) # define DPPP_SVPV_NOLEN_LP_ARG &PL_na #else # define DPPP_SVPV_NOLEN_LP_ARG 0 #endif #ifndef SvPV_const # define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_mutable # define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_flags # define SvPV_flags(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) #endif #ifndef SvPV_flags_const # define SvPV_flags_const(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) #endif #ifndef SvPV_flags_const_nolen # define SvPV_flags_const_nolen(sv, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX_const(sv) : \ (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN)) #endif #ifndef SvPV_flags_mutable # define SvPV_flags_mutable(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #endif #ifndef SvPV_force # define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_force_nolen # define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) #endif #ifndef SvPV_force_mutable # define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) #endif #ifndef SvPV_force_nomg # define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) #endif #ifndef SvPV_force_nomg_nolen # define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) #endif #ifndef SvPV_force_flags # define SvPV_force_flags(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) #endif #ifndef SvPV_force_flags_nolen # define SvPV_force_flags_nolen(sv, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags)) #endif #ifndef SvPV_force_flags_mutable # define SvPV_force_flags_mutable(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #endif #ifndef SvPV_nolen # define SvPV_nolen(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC)) #endif #ifndef SvPV_nolen_const # define SvPV_nolen_const(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN)) #endif #ifndef SvPV_nomg # define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) #endif #ifndef SvPV_nomg_const # define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) #endif #ifndef SvPV_nomg_const_nolen # define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) #endif #ifndef SvPV_renew # define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \ SvPV_set((sv), (char *) saferealloc( \ (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \ } STMT_END #endif #ifndef SvMAGIC_set # define SvMAGIC_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END #endif #if (PERL_BCDVERSION < 0x5009003) #ifndef SvPVX_const # define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) #endif #ifndef SvPVX_mutable # define SvPVX_mutable(sv) (0 + SvPVX(sv)) #endif #ifndef SvRV_set # define SvRV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END #endif #else #ifndef SvPVX_const # define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) #endif #ifndef SvPVX_mutable # define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) #endif #ifndef SvRV_set # define SvRV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ ((sv)->sv_u.svu_rv = (val)); } STMT_END #endif #endif #ifndef SvSTASH_set # define SvSTASH_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END #endif #if (PERL_BCDVERSION < 0x5004000) #ifndef SvUV_set # define SvUV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END #endif #else #ifndef SvUV_set # define SvUV_set(sv, val) \ STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END #endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) #if defined(NEED_vnewSVpvf) static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); static #else extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args); #endif #ifdef vnewSVpvf # undef vnewSVpvf #endif #define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b) #define Perl_vnewSVpvf DPPP_(my_vnewSVpvf) #if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL) SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args) { register SV *sv = newSV(0); sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); return sv; } #endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf) # define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf) # define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg) #if defined(NEED_sv_catpvf_mg) static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...); #endif #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...) { va_list args; va_start(args, pat); sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #ifdef PERL_IMPLICIT_CONTEXT #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext) #if defined(NEED_sv_catpvf_mg_nocontext) static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...); #endif #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...) { dTHX; va_list args; va_start(args, pat); sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #endif /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */ #ifndef sv_catpvf_mg # ifdef PERL_IMPLICIT_CONTEXT # define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext # else # define sv_catpvf_mg Perl_sv_catpvf_mg # endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg) # define sv_vcatpvf_mg(sv, pat, args) \ STMT_START { \ sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ SvSETMAGIC(sv); \ } STMT_END #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg) #if defined(NEED_sv_setpvf_mg) static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...); #endif #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...) { va_list args; va_start(args, pat); sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #ifdef PERL_IMPLICIT_CONTEXT #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext) #if defined(NEED_sv_setpvf_mg_nocontext) static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); static #else extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...); #endif #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...) { dTHX; va_list args; va_start(args, pat); sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); SvSETMAGIC(sv); va_end(args); } #endif #endif #endif /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */ #ifndef sv_setpvf_mg # ifdef PERL_IMPLICIT_CONTEXT # define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext # else # define sv_setpvf_mg Perl_sv_setpvf_mg # endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg) # define sv_vsetpvf_mg(sv, pat, args) \ STMT_START { \ sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ SvSETMAGIC(sv); \ } STMT_END #endif #ifndef newSVpvn_share #if defined(NEED_newSVpvn_share) static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); static #else extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash); #endif #ifdef newSVpvn_share # undef newSVpvn_share #endif #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c) #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share) #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash) { SV *sv; if (len < 0) len = -len; if (!hash) PERL_HASH(hash, (char*) src, len); sv = newSVpvn((char *) src, len); sv_upgrade(sv, SVt_PVIV); SvIVX(sv) = hash; SvREADONLY_on(sv); SvPOK_on(sv); return sv; } #endif #endif #ifndef SvSHARED_HASH # define SvSHARED_HASH(sv) (0 + SvUVX(sv)) #endif #ifndef HvNAME_get # define HvNAME_get(hv) HvNAME(hv) #endif #ifndef HvNAMELEN_get # define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0) #endif #ifndef GvSVn # define GvSVn(gv) GvSV(gv) #endif #ifndef isGV_with_GP # define isGV_with_GP(gv) isGV(gv) #endif #ifndef WARN_ALL # define WARN_ALL 0 #endif #ifndef WARN_CLOSURE # define WARN_CLOSURE 1 #endif #ifndef WARN_DEPRECATED # define WARN_DEPRECATED 2 #endif #ifndef WARN_EXITING # define WARN_EXITING 3 #endif #ifndef WARN_GLOB # define WARN_GLOB 4 #endif #ifndef WARN_IO # define WARN_IO 5 #endif #ifndef WARN_CLOSED # define WARN_CLOSED 6 #endif #ifndef WARN_EXEC # define WARN_EXEC 7 #endif #ifndef WARN_LAYER # define WARN_LAYER 8 #endif #ifndef WARN_NEWLINE # define WARN_NEWLINE 9 #endif #ifndef WARN_PIPE # define WARN_PIPE 10 #endif #ifndef WARN_UNOPENED # define WARN_UNOPENED 11 #endif #ifndef WARN_MISC # define WARN_MISC 12 #endif #ifndef WARN_NUMERIC # define WARN_NUMERIC 13 #endif #ifndef WARN_ONCE # define WARN_ONCE 14 #endif #ifndef WARN_OVERFLOW # define WARN_OVERFLOW 15 #endif #ifndef WARN_PACK # define WARN_PACK 16 #endif #ifndef WARN_PORTABLE # define WARN_PORTABLE 17 #endif #ifndef WARN_RECURSION # define WARN_RECURSION 18 #endif #ifndef WARN_REDEFINE # define WARN_REDEFINE 19 #endif #ifndef WARN_REGEXP # define WARN_REGEXP 20 #endif #ifndef WARN_SEVERE # define WARN_SEVERE 21 #endif #ifndef WARN_DEBUGGING # define WARN_DEBUGGING 22 #endif #ifndef WARN_INPLACE # define WARN_INPLACE 23 #endif #ifndef WARN_INTERNAL # define WARN_INTERNAL 24 #endif #ifndef WARN_MALLOC # define WARN_MALLOC 25 #endif #ifndef WARN_SIGNAL # define WARN_SIGNAL 26 #endif #ifndef WARN_SUBSTR # define WARN_SUBSTR 27 #endif #ifndef WARN_SYNTAX # define WARN_SYNTAX 28 #endif #ifndef WARN_AMBIGUOUS # define WARN_AMBIGUOUS 29 #endif #ifndef WARN_BAREWORD # define WARN_BAREWORD 30 #endif #ifndef WARN_DIGIT # define WARN_DIGIT 31 #endif #ifndef WARN_PARENTHESIS # define WARN_PARENTHESIS 32 #endif #ifndef WARN_PRECEDENCE # define WARN_PRECEDENCE 33 #endif #ifndef WARN_PRINTF # define WARN_PRINTF 34 #endif #ifndef WARN_PROTOTYPE # define WARN_PROTOTYPE 35 #endif #ifndef WARN_QW # define WARN_QW 36 #endif #ifndef WARN_RESERVED # define WARN_RESERVED 37 #endif #ifndef WARN_SEMICOLON # define WARN_SEMICOLON 38 #endif #ifndef WARN_TAINT # define WARN_TAINT 39 #endif #ifndef WARN_THREADS # define WARN_THREADS 40 #endif #ifndef WARN_UNINITIALIZED # define WARN_UNINITIALIZED 41 #endif #ifndef WARN_UNPACK # define WARN_UNPACK 42 #endif #ifndef WARN_UNTIE # define WARN_UNTIE 43 #endif #ifndef WARN_UTF8 # define WARN_UTF8 44 #endif #ifndef WARN_VOID # define WARN_VOID 45 #endif #ifndef WARN_ASSERTIONS # define WARN_ASSERTIONS 46 #endif #ifndef packWARN # define packWARN(a) (a) #endif #ifndef ckWARN # ifdef G_WARN_ON # define ckWARN(a) (PL_dowarn & G_WARN_ON) # else # define ckWARN(a) PL_dowarn # endif #endif #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner) #if defined(NEED_warner) static void DPPP_(my_warner)(U32 err, const char *pat, ...); static #else extern void DPPP_(my_warner)(U32 err, const char *pat, ...); #endif #define Perl_warner DPPP_(my_warner) #if defined(NEED_warner) || defined(NEED_warner_GLOBAL) void DPPP_(my_warner)(U32 err, const char *pat, ...) { SV *sv; va_list args; PERL_UNUSED_ARG(err); va_start(args, pat); sv = vnewSVpvf(pat, &args); va_end(args); sv_2mortal(sv); warn("%s", SvPV_nolen(sv)); } #define warner Perl_warner #define Perl_warner_nocontext Perl_warner #endif #endif /* concatenating with "" ensures that only literal strings are accepted as argument * note that STR_WITH_LEN() can't be used as argument to macros or functions that * under some configurations might be macros */ #ifndef STR_WITH_LEN # define STR_WITH_LEN(s) (s ""), (sizeof(s)-1) #endif #ifndef newSVpvs # define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1) #endif #ifndef newSVpvs_flags # define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags) #endif #ifndef sv_catpvs # define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) #endif #ifndef sv_setpvs # define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) #endif #ifndef hv_fetchs # define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) #endif #ifndef hv_stores # define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0) #endif #ifndef gv_fetchpvn_flags # define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt) #endif #ifndef gv_fetchpvs # define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt) #endif #ifndef gv_stashpvs # define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags) #endif #ifndef SvGETMAGIC # define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END #endif #ifndef PERL_MAGIC_sv # define PERL_MAGIC_sv '\0' #endif #ifndef PERL_MAGIC_overload # define PERL_MAGIC_overload 'A' #endif #ifndef PERL_MAGIC_overload_elem # define PERL_MAGIC_overload_elem 'a' #endif #ifndef PERL_MAGIC_overload_table # define PERL_MAGIC_overload_table 'c' #endif #ifndef PERL_MAGIC_bm # define PERL_MAGIC_bm 'B' #endif #ifndef PERL_MAGIC_regdata # define PERL_MAGIC_regdata 'D' #endif #ifndef PERL_MAGIC_regdatum # define PERL_MAGIC_regdatum 'd' #endif #ifndef PERL_MAGIC_env # define PERL_MAGIC_env 'E' #endif #ifndef PERL_MAGIC_envelem # define PERL_MAGIC_envelem 'e' #endif #ifndef PERL_MAGIC_fm # define PERL_MAGIC_fm 'f' #endif #ifndef PERL_MAGIC_regex_global # define PERL_MAGIC_regex_global 'g' #endif #ifndef PERL_MAGIC_isa # define PERL_MAGIC_isa 'I' #endif #ifndef PERL_MAGIC_isaelem # define PERL_MAGIC_isaelem 'i' #endif #ifndef PERL_MAGIC_nkeys # define PERL_MAGIC_nkeys 'k' #endif #ifndef PERL_MAGIC_dbfile # define PERL_MAGIC_dbfile 'L' #endif #ifndef PERL_MAGIC_dbline # define PERL_MAGIC_dbline 'l' #endif #ifndef PERL_MAGIC_mutex # define PERL_MAGIC_mutex 'm' #endif #ifndef PERL_MAGIC_shared # define PERL_MAGIC_shared 'N' #endif #ifndef PERL_MAGIC_shared_scalar # define PERL_MAGIC_shared_scalar 'n' #endif #ifndef PERL_MAGIC_collxfrm # define PERL_MAGIC_collxfrm 'o' #endif #ifndef PERL_MAGIC_tied # define PERL_MAGIC_tied 'P' #endif #ifndef PERL_MAGIC_tiedelem # define PERL_MAGIC_tiedelem 'p' #endif #ifndef PERL_MAGIC_tiedscalar # define PERL_MAGIC_tiedscalar 'q' #endif #ifndef PERL_MAGIC_qr # define PERL_MAGIC_qr 'r' #endif #ifndef PERL_MAGIC_sig # define PERL_MAGIC_sig 'S' #endif #ifndef PERL_MAGIC_sigelem # define PERL_MAGIC_sigelem 's' #endif #ifndef PERL_MAGIC_taint # define PERL_MAGIC_taint 't' #endif #ifndef PERL_MAGIC_uvar # define PERL_MAGIC_uvar 'U' #endif #ifndef PERL_MAGIC_uvar_elem # define PERL_MAGIC_uvar_elem 'u' #endif #ifndef PERL_MAGIC_vstring # define PERL_MAGIC_vstring 'V' #endif #ifndef PERL_MAGIC_vec # define PERL_MAGIC_vec 'v' #endif #ifndef PERL_MAGIC_utf8 # define PERL_MAGIC_utf8 'w' #endif #ifndef PERL_MAGIC_substr # define PERL_MAGIC_substr 'x' #endif #ifndef PERL_MAGIC_defelem # define PERL_MAGIC_defelem 'y' #endif #ifndef PERL_MAGIC_glob # define PERL_MAGIC_glob '*' #endif #ifndef PERL_MAGIC_arylen # define PERL_MAGIC_arylen '#' #endif #ifndef PERL_MAGIC_pos # define PERL_MAGIC_pos '.' #endif #ifndef PERL_MAGIC_backref # define PERL_MAGIC_backref '<' #endif #ifndef PERL_MAGIC_ext # define PERL_MAGIC_ext '~' #endif /* That's the best we can do... */ #ifndef sv_catpvn_nomg # define sv_catpvn_nomg sv_catpvn #endif #ifndef sv_catsv_nomg # define sv_catsv_nomg sv_catsv #endif #ifndef sv_setsv_nomg # define sv_setsv_nomg sv_setsv #endif #ifndef sv_pvn_nomg # define sv_pvn_nomg sv_pvn #endif #ifndef SvIV_nomg # define SvIV_nomg SvIV #endif #ifndef SvUV_nomg # define SvUV_nomg SvUV #endif #ifndef sv_catpv_mg # define sv_catpv_mg(sv, ptr) \ STMT_START { \ SV *TeMpSv = sv; \ sv_catpv(TeMpSv,ptr); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_catpvn_mg # define sv_catpvn_mg(sv, ptr, len) \ STMT_START { \ SV *TeMpSv = sv; \ sv_catpvn(TeMpSv,ptr,len); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_catsv_mg # define sv_catsv_mg(dsv, ssv) \ STMT_START { \ SV *TeMpSv = dsv; \ sv_catsv(TeMpSv,ssv); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setiv_mg # define sv_setiv_mg(sv, i) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setiv(TeMpSv,i); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setnv_mg # define sv_setnv_mg(sv, num) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setnv(TeMpSv,num); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setpv_mg # define sv_setpv_mg(sv, ptr) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setpv(TeMpSv,ptr); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setpvn_mg # define sv_setpvn_mg(sv, ptr, len) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setpvn(TeMpSv,ptr,len); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setsv_mg # define sv_setsv_mg(dsv, ssv) \ STMT_START { \ SV *TeMpSv = dsv; \ sv_setsv(TeMpSv,ssv); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_setuv_mg # define sv_setuv_mg(sv, i) \ STMT_START { \ SV *TeMpSv = sv; \ sv_setuv(TeMpSv,i); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef sv_usepvn_mg # define sv_usepvn_mg(sv, ptr, len) \ STMT_START { \ SV *TeMpSv = sv; \ sv_usepvn(TeMpSv,ptr,len); \ SvSETMAGIC(TeMpSv); \ } STMT_END #endif #ifndef SvVSTRING_mg # define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL) #endif /* Hint: sv_magic_portable * This is a compatibility function that is only available with * Devel::PPPort. It is NOT in the perl core. * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when * it is being passed a name pointer with namlen == 0. In that * case, perl 5.8.0 and later store the pointer, not a copy of it. * The compatibility can be provided back to perl 5.004. With * earlier versions, the code will not compile. */ #if (PERL_BCDVERSION < 0x5004000) /* code that uses sv_magic_portable will not compile */ #elif (PERL_BCDVERSION < 0x5008000) # define sv_magic_portable(sv, obj, how, name, namlen) \ STMT_START { \ SV *SvMp_sv = (sv); \ char *SvMp_name = (char *) (name); \ I32 SvMp_namlen = (namlen); \ if (SvMp_name && SvMp_namlen == 0) \ { \ MAGIC *mg; \ sv_magic(SvMp_sv, obj, how, 0, 0); \ mg = SvMAGIC(SvMp_sv); \ mg->mg_len = -42; /* XXX: this is the tricky part */ \ mg->mg_ptr = SvMp_name; \ } \ else \ { \ sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \ } \ } STMT_END #else # define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e) #endif #ifdef USE_ITHREADS #ifndef CopFILE # define CopFILE(c) ((c)->cop_file) #endif #ifndef CopFILEGV # define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv) #endif #ifndef CopFILE_set # define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv)) #endif #ifndef CopFILESV # define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv) #endif #ifndef CopFILEAV # define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav) #endif #ifndef CopSTASHPV # define CopSTASHPV(c) ((c)->cop_stashpv) #endif #ifndef CopSTASHPV_set # define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch)) #endif #ifndef CopSTASH # define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv) #endif #ifndef CopSTASH_set # define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch) #endif #ifndef CopSTASH_eq # define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \ || (CopSTASHPV(c) && HvNAME(hv) \ && strEQ(CopSTASHPV(c), HvNAME(hv))))) #endif #else #ifndef CopFILEGV # define CopFILEGV(c) ((c)->cop_filegv) #endif #ifndef CopFILEGV_set # define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv)) #endif #ifndef CopFILE_set # define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv)) #endif #ifndef CopFILESV # define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv) #endif #ifndef CopFILEAV # define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav) #endif #ifndef CopFILE # define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch) #endif #ifndef CopSTASH # define CopSTASH(c) ((c)->cop_stash) #endif #ifndef CopSTASH_set # define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) #endif #ifndef CopSTASHPV # define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch) #endif #ifndef CopSTASHPV_set # define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) #endif #ifndef CopSTASH_eq # define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) #endif #endif /* USE_ITHREADS */ #ifndef IN_PERL_COMPILETIME # define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling) #endif #ifndef IN_LOCALE_RUNTIME # define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE) #endif #ifndef IN_LOCALE_COMPILETIME # define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE) #endif #ifndef IN_LOCALE # define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME) #endif #ifndef IS_NUMBER_IN_UV # define IS_NUMBER_IN_UV 0x01 #endif #ifndef IS_NUMBER_GREATER_THAN_UV_MAX # define IS_NUMBER_GREATER_THAN_UV_MAX 0x02 #endif #ifndef IS_NUMBER_NOT_INT # define IS_NUMBER_NOT_INT 0x04 #endif #ifndef IS_NUMBER_NEG # define IS_NUMBER_NEG 0x08 #endif #ifndef IS_NUMBER_INFINITY # define IS_NUMBER_INFINITY 0x10 #endif #ifndef IS_NUMBER_NAN # define IS_NUMBER_NAN 0x20 #endif #ifndef GROK_NUMERIC_RADIX # define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send) #endif #ifndef PERL_SCAN_GREATER_THAN_UV_MAX # define PERL_SCAN_GREATER_THAN_UV_MAX 0x02 #endif #ifndef PERL_SCAN_SILENT_ILLDIGIT # define PERL_SCAN_SILENT_ILLDIGIT 0x04 #endif #ifndef PERL_SCAN_ALLOW_UNDERSCORES # define PERL_SCAN_ALLOW_UNDERSCORES 0x01 #endif #ifndef PERL_SCAN_DISALLOW_PREFIX # define PERL_SCAN_DISALLOW_PREFIX 0x02 #endif #ifndef grok_numeric_radix #if defined(NEED_grok_numeric_radix) static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); static #else extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send); #endif #ifdef grok_numeric_radix # undef grok_numeric_radix #endif #define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b) #define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix) #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL) bool DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send) { #ifdef USE_LOCALE_NUMERIC #ifdef PL_numeric_radix_sv if (PL_numeric_radix_sv && IN_LOCALE) { STRLEN len; char* radix = SvPV(PL_numeric_radix_sv, len); if (*sp + len <= send && memEQ(*sp, radix, len)) { *sp += len; return TRUE; } } #else /* older perls don't have PL_numeric_radix_sv so the radix * must manually be requested from locale.h */ #include dTHR; /* needed for older threaded perls */ struct lconv *lc = localeconv(); char *radix = lc->decimal_point; if (radix && IN_LOCALE) { STRLEN len = strlen(radix); if (*sp + len <= send && memEQ(*sp, radix, len)) { *sp += len; return TRUE; } } #endif #endif /* USE_LOCALE_NUMERIC */ /* always try "." if numeric radix didn't match because * we may have data from different locales mixed */ if (*sp < send && **sp == '.') { ++*sp; return TRUE; } return FALSE; } #endif #endif #ifndef grok_number #if defined(NEED_grok_number) static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); static #else extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); #endif #ifdef grok_number # undef grok_number #endif #define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c) #define Perl_grok_number DPPP_(my_grok_number) #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL) int DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep) { const char *s = pv; const char *send = pv + len; const UV max_div_10 = UV_MAX / 10; const char max_mod_10 = UV_MAX % 10; int numtype = 0; int sawinf = 0; int sawnan = 0; while (s < send && isSPACE(*s)) s++; if (s == send) { return 0; } else if (*s == '-') { s++; numtype = IS_NUMBER_NEG; } else if (*s == '+') s++; if (s == send) return 0; /* next must be digit or the radix separator or beginning of infinity */ if (isDIGIT(*s)) { /* UVs are at least 32 bits, so the first 9 decimal digits cannot overflow. */ UV value = *s - '0'; /* This construction seems to be more optimiser friendly. (without it gcc does the isDIGIT test and the *s - '0' separately) With it gcc on arm is managing 6 instructions (6 cycles) per digit. In theory the optimiser could deduce how far to unroll the loop before checking for overflow. */ if (++s < send) { int digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { digit = *s - '0'; if (digit >= 0 && digit <= 9) { value = value * 10 + digit; if (++s < send) { /* Now got 9 digits, so need to check each time for overflow. */ digit = *s - '0'; while (digit >= 0 && digit <= 9 && (value < max_div_10 || (value == max_div_10 && digit <= max_mod_10))) { value = value * 10 + digit; if (++s < send) digit = *s - '0'; else break; } if (digit >= 0 && digit <= 9 && (s < send)) { /* value overflowed. skip the remaining digits, don't worry about setting *valuep. */ do { s++; } while (s < send && isDIGIT(*s)); numtype |= IS_NUMBER_GREATER_THAN_UV_MAX; goto skip_value; } } } } } } } } } } } } } } } } } } numtype |= IS_NUMBER_IN_UV; if (valuep) *valuep = value; skip_value: if (GROK_NUMERIC_RADIX(&s, send)) { numtype |= IS_NUMBER_NOT_INT; while (s < send && isDIGIT(*s)) /* optional digits after the radix */ s++; } } else if (GROK_NUMERIC_RADIX(&s, send)) { numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */ /* no digits before the radix means we need digits after it */ if (s < send && isDIGIT(*s)) { do { s++; } while (s < send && isDIGIT(*s)); if (valuep) { /* integer approximation is valid - it's 0. */ *valuep = 0; } } else return 0; } else if (*s == 'I' || *s == 'i') { s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; s++; if (s == send || (*s != 'F' && *s != 'f')) return 0; s++; if (s < send && (*s == 'I' || *s == 'i')) { s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; s++; if (s == send || (*s != 'I' && *s != 'i')) return 0; s++; if (s == send || (*s != 'T' && *s != 't')) return 0; s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0; s++; } sawinf = 1; } else if (*s == 'N' || *s == 'n') { /* XXX TODO: There are signaling NaNs and quiet NaNs. */ s++; if (s == send || (*s != 'A' && *s != 'a')) return 0; s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; s++; sawnan = 1; } else return 0; if (sawinf) { numtype &= IS_NUMBER_NEG; /* Keep track of sign */ numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT; } else if (sawnan) { numtype &= IS_NUMBER_NEG; /* Keep track of sign */ numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT; } else if (s < send) { /* we can have an optional exponent part */ if (*s == 'e' || *s == 'E') { /* The only flag we keep is sign. Blow away any "it's UV" */ numtype &= IS_NUMBER_NEG; numtype |= IS_NUMBER_NOT_INT; s++; if (s < send && (*s == '-' || *s == '+')) s++; if (s < send && isDIGIT(*s)) { do { s++; } while (s < send && isDIGIT(*s)); } else return 0; } } while (s < send && isSPACE(*s)) s++; if (s >= send) return numtype; if (len == 10 && memEQ(pv, "0 but true", 10)) { if (valuep) *valuep = 0; return IS_NUMBER_IN_UV; } return 0; } #endif #endif /* * The grok_* routines have been modified to use warn() instead of * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit, * which is why the stack variable has been renamed to 'xdigit'. */ #ifndef grok_bin #if defined(NEED_grok_bin) static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); static #else extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); #endif #ifdef grok_bin # undef grok_bin #endif #define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d) #define Perl_grok_bin DPPP_(my_grok_bin) #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL) UV DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_2 = UV_MAX / 2; bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; bool overflowed = FALSE; if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { /* strip off leading b or 0b. for compatibility silently suffer "b" and "0b" as valid binary numbers. */ if (len >= 1) { if (s[0] == 'b') { s++; len--; } else if (len >= 2 && s[0] == '0' && s[1] == 'b') { s+=2; len-=2; } } } for (; len-- && *s; s++) { char bit = *s; if (bit == '0' || bit == '1') { /* Write it in this wonky order with a goto to attempt to get the compiler to make the common case integer-only loop pretty tight. With gcc seems to be much straighter code than old scan_bin. */ redo: if (!overflowed) { if (value <= max_div_2) { value = (value << 1) | (bit - '0'); continue; } /* Bah. We're just overflowed. */ warn("Integer overflow in binary number"); overflowed = TRUE; value_nv = (NV) value; } value_nv *= 2.0; /* If an NV has not enough bits in its mantissa to * represent a UV this summing of small low-order numbers * is a waste of time (because the NV cannot preserve * the low-order bits anyway): we could just remember when * did we overflow and in the end just multiply value_nv by the * right amount. */ value_nv += (NV)(bit - '0'); continue; } if (bit == '_' && len && allow_underscores && (bit = s[1]) && (bit == '0' || bit == '1')) { --len; ++s; goto redo; } if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) warn("Illegal binary digit '%c' ignored", *s); break; } if ( ( overflowed && value_nv > 4294967295.0) #if UVSIZE > 4 || (!overflowed && value > 0xffffffff ) #endif ) { warn("Binary number > 0b11111111111111111111111111111111 non-portable"); } *len_p = s - start; if (!overflowed) { *flags = 0; return value; } *flags = PERL_SCAN_GREATER_THAN_UV_MAX; if (result) *result = value_nv; return UV_MAX; } #endif #endif #ifndef grok_hex #if defined(NEED_grok_hex) static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); static #else extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); #endif #ifdef grok_hex # undef grok_hex #endif #define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d) #define Perl_grok_hex DPPP_(my_grok_hex) #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL) UV DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_16 = UV_MAX / 16; bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; bool overflowed = FALSE; const char *xdigit; if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { /* strip off leading x or 0x. for compatibility silently suffer "x" and "0x" as valid hex numbers. */ if (len >= 1) { if (s[0] == 'x') { s++; len--; } else if (len >= 2 && s[0] == '0' && s[1] == 'x') { s+=2; len-=2; } } } for (; len-- && *s; s++) { xdigit = strchr((char *) PL_hexdigit, *s); if (xdigit) { /* Write it in this wonky order with a goto to attempt to get the compiler to make the common case integer-only loop pretty tight. With gcc seems to be much straighter code than old scan_hex. */ redo: if (!overflowed) { if (value <= max_div_16) { value = (value << 4) | ((xdigit - PL_hexdigit) & 15); continue; } warn("Integer overflow in hexadecimal number"); overflowed = TRUE; value_nv = (NV) value; } value_nv *= 16.0; /* If an NV has not enough bits in its mantissa to * represent a UV this summing of small low-order numbers * is a waste of time (because the NV cannot preserve * the low-order bits anyway): we could just remember when * did we overflow and in the end just multiply value_nv by the * right amount of 16-tuples. */ value_nv += (NV)((xdigit - PL_hexdigit) & 15); continue; } if (*s == '_' && len && allow_underscores && s[1] && (xdigit = strchr((char *) PL_hexdigit, s[1]))) { --len; ++s; goto redo; } if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) warn("Illegal hexadecimal digit '%c' ignored", *s); break; } if ( ( overflowed && value_nv > 4294967295.0) #if UVSIZE > 4 || (!overflowed && value > 0xffffffff ) #endif ) { warn("Hexadecimal number > 0xffffffff non-portable"); } *len_p = s - start; if (!overflowed) { *flags = 0; return value; } *flags = PERL_SCAN_GREATER_THAN_UV_MAX; if (result) *result = value_nv; return UV_MAX; } #endif #endif #ifndef grok_oct #if defined(NEED_grok_oct) static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); static #else extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); #endif #ifdef grok_oct # undef grok_oct #endif #define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d) #define Perl_grok_oct DPPP_(my_grok_oct) #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL) UV DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) { const char *s = start; STRLEN len = *len_p; UV value = 0; NV value_nv = 0; const UV max_div_8 = UV_MAX / 8; bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; bool overflowed = FALSE; for (; len-- && *s; s++) { /* gcc 2.95 optimiser not smart enough to figure that this subtraction out front allows slicker code. */ int digit = *s - '0'; if (digit >= 0 && digit <= 7) { /* Write it in this wonky order with a goto to attempt to get the compiler to make the common case integer-only loop pretty tight. */ redo: if (!overflowed) { if (value <= max_div_8) { value = (value << 3) | digit; continue; } /* Bah. We're just overflowed. */ warn("Integer overflow in octal number"); overflowed = TRUE; value_nv = (NV) value; } value_nv *= 8.0; /* If an NV has not enough bits in its mantissa to * represent a UV this summing of small low-order numbers * is a waste of time (because the NV cannot preserve * the low-order bits anyway): we could just remember when * did we overflow and in the end just multiply value_nv by the * right amount of 8-tuples. */ value_nv += (NV)digit; continue; } if (digit == ('_' - '0') && len && allow_underscores && (digit = s[1] - '0') && (digit >= 0 && digit <= 7)) { --len; ++s; goto redo; } /* Allow \octal to work the DWIM way (that is, stop scanning * as soon as non-octal characters are seen, complain only iff * someone seems to want to use the digits eight and nine). */ if (digit == 8 || digit == 9) { if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) warn("Illegal octal digit '%c' ignored", *s); } break; } if ( ( overflowed && value_nv > 4294967295.0) #if UVSIZE > 4 || (!overflowed && value > 0xffffffff ) #endif ) { warn("Octal number > 037777777777 non-portable"); } *len_p = s - start; if (!overflowed) { *flags = 0; return value; } *flags = PERL_SCAN_GREATER_THAN_UV_MAX; if (result) *result = value_nv; return UV_MAX; } #endif #endif #if !defined(my_snprintf) #if defined(NEED_my_snprintf) static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); static #else extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); #endif #define my_snprintf DPPP_(my_my_snprintf) #define Perl_my_snprintf DPPP_(my_my_snprintf) #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL) int DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...) { dTHX; int retval; va_list ap; va_start(ap, format); #ifdef HAS_VSNPRINTF retval = vsnprintf(buffer, len, format, ap); #else retval = vsprintf(buffer, format, ap); #endif va_end(ap); if (retval < 0 || (len > 0 && (Size_t)retval >= len)) Perl_croak(aTHX_ "panic: my_snprintf buffer overflow"); return retval; } #endif #endif #if !defined(my_sprintf) #if defined(NEED_my_sprintf) static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); static #else extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); #endif #define my_sprintf DPPP_(my_my_sprintf) #define Perl_my_sprintf DPPP_(my_my_sprintf) #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL) int DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...) { va_list args; va_start(args, pat); vsprintf(buffer, pat, args); va_end(args); return strlen(buffer); } #endif #endif #ifdef NO_XSLOCKS # ifdef dJMPENV # define dXCPT dJMPENV; int rEtV = 0 # define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0) # define XCPT_TRY_END JMPENV_POP; # define XCPT_CATCH if (rEtV != 0) # define XCPT_RETHROW JMPENV_JUMP(rEtV) # else # define dXCPT Sigjmp_buf oldTOP; int rEtV = 0 # define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0) # define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf); # define XCPT_CATCH if (rEtV != 0) # define XCPT_RETHROW Siglongjmp(top_env, rEtV) # endif #endif #if !defined(my_strlcat) #if defined(NEED_my_strlcat) static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); static #else extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); #endif #define my_strlcat DPPP_(my_my_strlcat) #define Perl_my_strlcat DPPP_(my_my_strlcat) #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL) Size_t DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size) { Size_t used, length, copy; used = strlen(dst); length = strlen(src); if (size > 0 && used < size - 1) { copy = (length >= size - used) ? size - used - 1 : length; memcpy(dst + used, src, copy); dst[used + copy] = '\0'; } return used + length; } #endif #endif #if !defined(my_strlcpy) #if defined(NEED_my_strlcpy) static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); static #else extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); #endif #define my_strlcpy DPPP_(my_my_strlcpy) #define Perl_my_strlcpy DPPP_(my_my_strlcpy) #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL) Size_t DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size) { Size_t length, copy; length = strlen(src); if (size > 0) { copy = (length >= size) ? size - 1 : length; memcpy(dst, src, copy); dst[copy] = '\0'; } return length; } #endif #endif #ifndef PERL_PV_ESCAPE_QUOTE # define PERL_PV_ESCAPE_QUOTE 0x0001 #endif #ifndef PERL_PV_PRETTY_QUOTE # define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE #endif #ifndef PERL_PV_PRETTY_ELLIPSES # define PERL_PV_PRETTY_ELLIPSES 0x0002 #endif #ifndef PERL_PV_PRETTY_LTGT # define PERL_PV_PRETTY_LTGT 0x0004 #endif #ifndef PERL_PV_ESCAPE_FIRSTCHAR # define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 #endif #ifndef PERL_PV_ESCAPE_UNI # define PERL_PV_ESCAPE_UNI 0x0100 #endif #ifndef PERL_PV_ESCAPE_UNI_DETECT # define PERL_PV_ESCAPE_UNI_DETECT 0x0200 #endif #ifndef PERL_PV_ESCAPE_ALL # define PERL_PV_ESCAPE_ALL 0x1000 #endif #ifndef PERL_PV_ESCAPE_NOBACKSLASH # define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 #endif #ifndef PERL_PV_ESCAPE_NOCLEAR # define PERL_PV_ESCAPE_NOCLEAR 0x4000 #endif #ifndef PERL_PV_ESCAPE_RE # define PERL_PV_ESCAPE_RE 0x8000 #endif #ifndef PERL_PV_PRETTY_NOCLEAR # define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR #endif #ifndef PERL_PV_PRETTY_DUMP # define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE #endif #ifndef PERL_PV_PRETTY_REGPROP # define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE #endif /* Hint: pv_escape * Note that unicode functionality is only backported to * those perl versions that support it. For older perl * versions, the implementation will fall back to bytes. */ #ifndef pv_escape #if defined(NEED_pv_escape) static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); static #else extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); #endif #ifdef pv_escape # undef pv_escape #endif #define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f) #define Perl_pv_escape DPPP_(my_pv_escape) #if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL) char * DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags) { const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\'; const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc; char octbuf[32] = "%123456789ABCDF"; STRLEN wrote = 0; STRLEN chsize = 0; STRLEN readsize = 1; #if defined(is_utf8_string) && defined(utf8_to_uvchr) bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0; #endif const char *pv = str; const char * const end = pv + count; octbuf[0] = esc; if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) sv_setpvs(dsv, ""); #if defined(is_utf8_string) && defined(utf8_to_uvchr) if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count)) isuni = 1; #endif for (; pv < end && (!max || wrote < max) ; pv += readsize) { const UV u = #if defined(is_utf8_string) && defined(utf8_to_uvchr) isuni ? utf8_to_uvchr((U8*)pv, &readsize) : #endif (U8)*pv; const U8 c = (U8)u & 0xFF; if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) { if (flags & PERL_PV_ESCAPE_FIRSTCHAR) chsize = my_snprintf(octbuf, sizeof octbuf, "%"UVxf, u); else chsize = my_snprintf(octbuf, sizeof octbuf, "%cx{%"UVxf"}", esc, u); } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) { chsize = 1; } else { if (c == dq || c == esc || !isPRINT(c)) { chsize = 2; switch (c) { case '\\' : /* fallthrough */ case '%' : if (c == esc) octbuf[1] = esc; else chsize = 1; break; case '\v' : octbuf[1] = 'v'; break; case '\t' : octbuf[1] = 't'; break; case '\r' : octbuf[1] = 'r'; break; case '\n' : octbuf[1] = 'n'; break; case '\f' : octbuf[1] = 'f'; break; case '"' : if (dq == '"') octbuf[1] = '"'; else chsize = 1; break; default: chsize = my_snprintf(octbuf, sizeof octbuf, pv < end && isDIGIT((U8)*(pv+readsize)) ? "%c%03o" : "%c%o", esc, c); } } else { chsize = 1; } } if (max && wrote + chsize > max) { break; } else if (chsize > 1) { sv_catpvn(dsv, octbuf, chsize); wrote += chsize; } else { char tmp[2]; my_snprintf(tmp, sizeof tmp, "%c", c); sv_catpvn(dsv, tmp, 1); wrote++; } if (flags & PERL_PV_ESCAPE_FIRSTCHAR) break; } if (escaped != NULL) *escaped= pv - str; return SvPVX(dsv); } #endif #endif #ifndef pv_pretty #if defined(NEED_pv_pretty) static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); static #else extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); #endif #ifdef pv_pretty # undef pv_pretty #endif #define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g) #define Perl_pv_pretty DPPP_(my_pv_pretty) #if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL) char * DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) { const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%'; STRLEN escaped; if (!(flags & PERL_PV_PRETTY_NOCLEAR)) sv_setpvs(dsv, ""); if (dq == '"') sv_catpvs(dsv, "\""); else if (flags & PERL_PV_PRETTY_LTGT) sv_catpvs(dsv, "<"); if (start_color != NULL) sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color)); pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR); if (end_color != NULL) sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color)); if (dq == '"') sv_catpvs(dsv, "\""); else if (flags & PERL_PV_PRETTY_LTGT) sv_catpvs(dsv, ">"); if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count) sv_catpvs(dsv, "..."); return SvPVX(dsv); } #endif #endif #ifndef pv_display #if defined(NEED_pv_display) static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); static #else extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); #endif #ifdef pv_display # undef pv_display #endif #define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e) #define Perl_pv_display DPPP_(my_pv_display) #if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL) char * DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) { pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP); if (len > cur && pv[cur] == '\0') sv_catpvs(dsv, "\\0"); return SvPVX(dsv); } #endif #endif #endif /* _P_P_PORTABILITY_H_ */ /* End of File ppport.h */ Slic3r-version_1.31.6/xs/src/slic3r/000077500000000000000000000000001301441720000171165ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/slic3r/GUI/000077500000000000000000000000001301441720000175425ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/src/slic3r/GUI/3DScene.cpp000066400000000000000000000224331301441720000214760ustar00rootroot00000000000000#include "3DScene.hpp" #include namespace Slic3r { // caller is responsible for supplying NO lines with zero length void _3DScene::_extrusionentity_to_verts_do(const Lines &lines, const std::vector &widths, const std::vector &heights, bool closed, double top_z, const Point ©, GLVertexArray* qverts, GLVertexArray* tverts) { /* It looks like it's faster without reserving capacity... // each segment has 4 quads, thus 16 vertices; + 2 caps qverts->reserve_more(3 * 4 * (4 * lines.size() + 2)); // two triangles for each corner tverts->reserve_more(3 * 3 * 2 * (lines.size() + 1)); */ assert(! lines.empty()); if (lines.empty()) return; Line prev_line; Pointf prev_b1, prev_b2; Vectorf3 prev_xy_left_normal, prev_xy_right_normal; // loop once more in case of closed loops bool first_done = false; for (size_t i = 0; i <= lines.size(); ++i) { if (i == lines.size()) i = 0; const Line &line = lines.at(i); if (i == 0 && first_done && !closed) break; double len = line.length(); double unscaled_len = unscale(len); double bottom_z = top_z - heights.at(i); double middle_z = (top_z + bottom_z) / 2; double dist = widths.at(i)/2; // scaled Vectorf v = Vectorf::new_unscale(line.vector()); v.scale(1/unscaled_len); Pointf a = Pointf::new_unscale(line.a); Pointf b = Pointf::new_unscale(line.b); Pointf a1 = a; Pointf a2 = a; a1.translate(+dist*v.y, -dist*v.x); a2.translate(-dist*v.y, +dist*v.x); Pointf b1 = b; Pointf b2 = b; b1.translate(+dist*v.y, -dist*v.x); b2.translate(-dist*v.y, +dist*v.x); // calculate new XY normals Vector n = line.normal(); Vectorf3 xy_right_normal = Vectorf3::new_unscale(n.x, n.y, 0); xy_right_normal.scale(1/unscaled_len); Vectorf3 xy_left_normal = xy_right_normal; xy_left_normal.scale(-1); if (first_done) { // if we're making a ccw turn, draw the triangles on the right side, otherwise draw them on the left side double ccw = line.b.ccw(prev_line); if (ccw > EPSILON) { // top-right vertex triangle between previous line and this one { // use the normal going to the right calculated for the previous line tverts->push_norm(prev_xy_right_normal); tverts->push_vert(prev_b1.x, prev_b1.y, middle_z); // use the normal going to the right calculated for this line tverts->push_norm(xy_right_normal); tverts->push_vert(a1.x, a1.y, middle_z); // normal going upwards tverts->push_norm(0,0,1); tverts->push_vert(a.x, a.y, top_z); } // bottom-right vertex triangle between previous line and this one { // use the normal going to the right calculated for the previous line tverts->push_norm(prev_xy_right_normal); tverts->push_vert(prev_b1.x, prev_b1.y, middle_z); // normal going downwards tverts->push_norm(0,0,-1); tverts->push_vert(a.x, a.y, bottom_z); // use the normal going to the right calculated for this line tverts->push_norm(xy_right_normal); tverts->push_vert(a1.x, a1.y, middle_z); } } else if (ccw < -EPSILON) { // top-left vertex triangle between previous line and this one { // use the normal going to the left calculated for the previous line tverts->push_norm(prev_xy_left_normal); tverts->push_vert(prev_b2.x, prev_b2.y, middle_z); // normal going upwards tverts->push_norm(0,0,1); tverts->push_vert(a.x, a.y, top_z); // use the normal going to the right calculated for this line tverts->push_norm(xy_left_normal); tverts->push_vert(a2.x, a2.y, middle_z); } // bottom-left vertex triangle between previous line and this one { // use the normal going to the left calculated for the previous line tverts->push_norm(prev_xy_left_normal); tverts->push_vert(prev_b2.x, prev_b2.y, middle_z); // use the normal going to the right calculated for this line tverts->push_norm(xy_left_normal); tverts->push_vert(a2.x, a2.y, middle_z); // normal going downwards tverts->push_norm(0,0,-1); tverts->push_vert(a.x, a.y, bottom_z); } } } // if this was the extra iteration we were only interested in the triangles if (first_done && i == 0) break; prev_line = line; prev_b1 = b1; prev_b2 = b2; prev_xy_right_normal = xy_right_normal; prev_xy_left_normal = xy_left_normal; if (!closed) { // terminate open paths with caps if (i == 0) { // normal pointing downwards qverts->push_norm(0,0,-1); qverts->push_vert(a.x, a.y, bottom_z); // normal pointing to the right qverts->push_norm(xy_right_normal); qverts->push_vert(a1.x, a1.y, middle_z); // normal pointing upwards qverts->push_norm(0,0,1); qverts->push_vert(a.x, a.y, top_z); // normal pointing to the left qverts->push_norm(xy_left_normal); qverts->push_vert(a2.x, a2.y, middle_z); } // we don't use 'else' because both cases are true if we have only one line if (i == lines.size()-1) { // normal pointing downwards qverts->push_norm(0,0,-1); qverts->push_vert(b.x, b.y, bottom_z); // normal pointing to the left qverts->push_norm(xy_left_normal); qverts->push_vert(b2.x, b2.y, middle_z); // normal pointing upwards qverts->push_norm(0,0,1); qverts->push_vert(b.x, b.y, top_z); // normal pointing to the right qverts->push_norm(xy_right_normal); qverts->push_vert(b1.x, b1.y, middle_z); } } // bottom-right face { // normal going downwards qverts->push_norm(0,0,-1); qverts->push_norm(0,0,-1); qverts->push_vert(a.x, a.y, bottom_z); qverts->push_vert(b.x, b.y, bottom_z); qverts->push_norm(xy_right_normal); qverts->push_norm(xy_right_normal); qverts->push_vert(b1.x, b1.y, middle_z); qverts->push_vert(a1.x, a1.y, middle_z); } // top-right face { qverts->push_norm(xy_right_normal); qverts->push_norm(xy_right_normal); qverts->push_vert(a1.x, a1.y, middle_z); qverts->push_vert(b1.x, b1.y, middle_z); // normal going upwards qverts->push_norm(0,0,1); qverts->push_norm(0,0,1); qverts->push_vert(b.x, b.y, top_z); qverts->push_vert(a.x, a.y, top_z); } // top-left face { qverts->push_norm(0,0,1); qverts->push_norm(0,0,1); qverts->push_vert(a.x, a.y, top_z); qverts->push_vert(b.x, b.y, top_z); qverts->push_norm(xy_left_normal); qverts->push_norm(xy_left_normal); qverts->push_vert(b2.x, b2.y, middle_z); qverts->push_vert(a2.x, a2.y, middle_z); } // bottom-left face { qverts->push_norm(xy_left_normal); qverts->push_norm(xy_left_normal); qverts->push_vert(a2.x, a2.y, middle_z); qverts->push_vert(b2.x, b2.y, middle_z); // normal going downwards qverts->push_norm(0,0,-1); qverts->push_norm(0,0,-1); qverts->push_vert(b.x, b.y, bottom_z); qverts->push_vert(a.x, a.y, bottom_z); } first_done = true; } } void GLVertexArray::load_mesh(const TriangleMesh &mesh) { this->reserve_more(3 * 3 * mesh.facets_count()); for (int i = 0; i < mesh.stl.stats.number_of_facets; ++i) { stl_facet &facet = mesh.stl.facet_start[i]; for (int j = 0; j <= 2; ++j) { this->push_norm(facet.normal.x, facet.normal.y, facet.normal.z); this->push_vert(facet.vertex[j].x, facet.vertex[j].y, facet.vertex[j].z); } } } } Slic3r-version_1.31.6/xs/src/slic3r/GUI/3DScene.hpp000066400000000000000000000027521301441720000215050ustar00rootroot00000000000000#ifndef slic3r_3DScene_hpp_ #define slic3r_3DScene_hpp_ #include "../../libslic3r/libslic3r.h" #include "../../libslic3r/Point.hpp" #include "../../libslic3r/Line.hpp" #include "../../libslic3r/TriangleMesh.hpp" namespace Slic3r { class GLVertexArray { public: std::vector verts, norms; void reserve(size_t len) { this->verts.reserve(len); this->norms.reserve(len); }; void reserve_more(size_t len) { len += this->verts.size(); this->reserve(len); }; void push_vert(const Pointf3 &point) { this->verts.push_back(point.x); this->verts.push_back(point.y); this->verts.push_back(point.z); }; void push_vert(float x, float y, float z) { this->verts.push_back(x); this->verts.push_back(y); this->verts.push_back(z); }; void push_norm(const Pointf3 &point) { this->norms.push_back(point.x); this->norms.push_back(point.y); this->norms.push_back(point.z); }; void push_norm(float x, float y, float z) { this->norms.push_back(x); this->norms.push_back(y); this->norms.push_back(z); }; void load_mesh(const TriangleMesh &mesh); }; class _3DScene { public: static void _extrusionentity_to_verts_do(const Lines &lines, const std::vector &widths, const std::vector &heights, bool closed, double top_z, const Point ©, GLVertexArray* qverts, GLVertexArray* tverts); }; } #endif Slic3r-version_1.31.6/xs/src/slic3r/GUI/GUI.cpp000066400000000000000000000020371301441720000206740ustar00rootroot00000000000000#include "GUI.hpp" #if __APPLE__ #import #elif _WIN32 #include #pragma comment(lib, "user32.lib") #endif namespace Slic3r { namespace GUI { #if __APPLE__ IOPMAssertionID assertionID; #endif void disable_screensaver() { #if __APPLE__ CFStringRef reasonForActivity = CFSTR("Slic3r"); IOReturn success = IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep, kIOPMAssertionLevelOn, reasonForActivity, &assertionID); // ignore result: success == kIOReturnSuccess #elif _WIN32 SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_CONTINUOUS); #endif } void enable_screensaver() { #if __APPLE__ IOReturn success = IOPMAssertionRelease(assertionID); #elif _WIN32 SetThreadExecutionState(ES_CONTINUOUS); #endif } bool debugged() { #ifdef _WIN32 return IsDebuggerPresent(); #else return false; #endif /* _WIN32 */ } void break_to_debugger() { #ifdef _WIN32 if (IsDebuggerPresent()) DebugBreak(); #endif /* _WIN32 */ } } } Slic3r-version_1.31.6/xs/src/slic3r/GUI/GUI.hpp000066400000000000000000000003041301441720000206740ustar00rootroot00000000000000#ifndef slic3r_GUI_hpp_ #define slic3r_GUI_hpp_ namespace Slic3r { namespace GUI { void disable_screensaver(); void enable_screensaver(); bool debugged(); void break_to_debugger(); } } #endif Slic3r-version_1.31.6/xs/src/xsinit.h000066400000000000000000000114011301441720000174030ustar00rootroot00000000000000#ifndef _xsinit_h_ #define _xsinit_h_ // undef some macros set by Perl which cause compilation errors on Win32 #undef read #undef seekdir #undef bind #undef send #undef connect #undef wait #undef accept #undef close #undef open #undef write #undef socket #undef listen #undef shutdown #undef ioctl #undef getpeername #undef rect #undef setsockopt #undef getsockopt #undef getsockname #undef gethostname #undef select #undef socketpair #undef recvfrom #undef sendto // these need to be included early for Win32 (listing it in Build.PL is not enough) #include #include #include #ifdef SLIC3RXS extern "C" { #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #include "ppport.h" #undef do_open #undef do_close #undef bind #undef seed #ifdef _MSC_VER // Undef some of the macros set by Perl , which cause compilation errors on Win32 #undef send #undef connect #endif /* _MSC_VER */ } #endif #include #include #include #include #include #include #include #include #include namespace Slic3r { template struct ClassTraits { static const char* name; static const char* name_ref; }; // use this for typedefs for which the forward prototype // in REGISTER_CLASS won't work #define __REGISTER_CLASS(cname, perlname) \ template <>const char* ClassTraits::name = "Slic3r::" perlname; \ template <>const char* ClassTraits::name_ref = "Slic3r::" perlname "::Ref"; #define REGISTER_CLASS(cname,perlname) \ class cname; \ __REGISTER_CLASS(cname, perlname); template const char* perl_class_name(const T*) { return ClassTraits::name; } template const char* perl_class_name_ref(const T*) { return ClassTraits::name_ref; } template SV* perl_to_SV_ref(T &t) { SV* sv = newSV(0); sv_setref_pv( sv, perl_class_name_ref(&t), &t ); return sv; } template SV* perl_to_SV_clone_ref(const T &t) { SV* sv = newSV(0); sv_setref_pv( sv, perl_class_name(&t), new T(t) ); return sv; } template class Ref { T* val; public: Ref() : val(NULL) {} Ref(T* t) : val(t) {} Ref(const T* t) : val(const_cast(t)) {} operator T*() const { return val; } static const char* CLASS() { return ClassTraits::name_ref; } }; template class Clone { T* val; public: Clone() : val(NULL) {} Clone(T* t) : val(new T(*t)) {} Clone(const T& t) : val(new T(t)) {} operator T*() const { return val; } static const char* CLASS() { return ClassTraits::name; } }; SV* ConfigBase__as_hash(ConfigBase* THIS); SV* ConfigOption_to_SV(const ConfigOption &opt, const ConfigOptionDef &def); SV* ConfigBase__get(ConfigBase* THIS, const t_config_option_key &opt_key); SV* ConfigBase__get_at(ConfigBase* THIS, const t_config_option_key &opt_key, size_t i); bool ConfigBase__set(ConfigBase* THIS, const t_config_option_key &opt_key, SV* value); bool ConfigBase__set_deserialize(ConfigBase* THIS, const t_config_option_key &opt_key, SV* str); void ConfigBase__set_ifndef(ConfigBase* THIS, const t_config_option_key &opt_key, SV* value, bool deserialize = false); bool StaticConfig__set(StaticConfig* THIS, const t_config_option_key &opt_key, SV* value); SV* to_AV(ExPolygon* expolygon); SV* to_SV_pureperl(const ExPolygon* expolygon); void from_SV(SV* expoly_sv, ExPolygon* expolygon); void from_SV_check(SV* expoly_sv, ExPolygon* expolygon); void from_SV(SV* line_sv, Line* THIS); void from_SV_check(SV* line_sv, Line* THIS); SV* to_AV(Line* THIS); SV* to_SV_pureperl(const Line* THIS); void from_SV(SV* poly_sv, MultiPoint* THIS); void from_SV_check(SV* poly_sv, MultiPoint* THIS); SV* to_AV(MultiPoint* THIS); SV* to_SV_pureperl(const MultiPoint* THIS); void from_SV_check(SV* poly_sv, Polygon* THIS); void from_SV_check(SV* poly_sv, Polyline* THIS); SV* to_SV_pureperl(const Point* THIS); void from_SV(SV* point_sv, Point* point); void from_SV_check(SV* point_sv, Point* point); SV* to_SV_pureperl(const Pointf* point); bool from_SV(SV* point_sv, Pointf* point); bool from_SV_check(SV* point_sv, Pointf* point); void from_SV_check(SV* surface_sv, Surface* THIS); SV* to_SV(TriangleMesh* THIS); SV* polynode_children_2_perl(const ClipperLib::PolyNode& node); SV* polynode2perl(const ClipperLib::PolyNode& node); } #ifdef SLIC3R_HAS_BROKEN_CROAK #undef croak #ifdef _MSC_VER #define croak(...) confess_at(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__) #else #define croak(...) confess_at(__FILE__, __LINE__, __func__, __VA_ARGS__) #endif #endif #endif Slic3r-version_1.31.6/xs/t/000077500000000000000000000000001301441720000153735ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/t/01_trianglemesh.t000066400000000000000000000117461301441720000205530ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 49; is Slic3r::TriangleMesh::hello_world(), 'Hello world!', 'hello world'; my $cube = { vertices => [ [20,20,0], [20,0,0], [0,0,0], [0,20,0], [20,20,20], [0,20,20], [0,0,20], [20,0,20] ], facets => [ [0,1,2], [0,2,3], [4,5,6], [4,6,7], [0,4,7], [0,7,1], [1,7,6], [1,6,2], [2,6,5], [2,5,3], [4,0,3], [4,3,5] ], }; { my $m = Slic3r::TriangleMesh->new; $m->ReadFromPerl($cube->{vertices}, $cube->{facets}); $m->repair; my ($vertices, $facets) = ($m->vertices, $m->facets); is_deeply $vertices, $cube->{vertices}, 'vertices arrayref roundtrip'; is_deeply $facets, $cube->{facets}, 'facets arrayref roundtrip'; is scalar(@{$m->normals}), scalar(@$facets), 'normals returns the right number of items'; { my $m2 = $m->clone; is_deeply $m2->vertices, $cube->{vertices}, 'cloned vertices arrayref roundtrip'; is_deeply $m2->facets, $cube->{facets}, 'cloned facets arrayref roundtrip'; $m2->scale(3); # check that it does not affect $m } { my $stats = $m->stats; is $stats->{number_of_facets}, scalar(@{ $cube->{facets} }), 'stats.number_of_facets'; ok abs($stats->{volume} - 20*20*20) < 1E-2, 'stats.volume'; } $m->scale(2); ok abs($m->stats->{volume} - 40*40*40) < 1E-2, 'scale'; $m->scale_xyz(Slic3r::Pointf3->new(2,1,1)); ok abs($m->stats->{volume} - 2*40*40*40) < 1E-2, 'scale_xyz'; $m->translate(5,10,0); is_deeply $m->vertices->[0], [85,50,0], 'translate'; $m->align_to_origin; is_deeply $m->vertices->[2], [0,0,0], 'align_to_origin'; is_deeply $m->size, [80,40,40], 'size'; $m->scale_xyz(Slic3r::Pointf3->new(0.5,1,1)); $m->rotate(45, Slic3r::Point->new(20,20)); ok abs($m->size->[0] - sqrt(2)*40) < 1E-4, 'rotate'; { my $meshes = $m->split; is scalar(@$meshes), 1, 'split'; isa_ok $meshes->[0], 'Slic3r::TriangleMesh', 'split'; is_deeply $m->bb3, $meshes->[0]->bb3, 'split populates stats'; } my $m2 = Slic3r::TriangleMesh->new; $m2->ReadFromPerl($cube->{vertices}, $cube->{facets}); $m2->repair; $m->merge($m2); $m->repair; is $m->stats->{number_of_facets}, 2 * $m2->stats->{number_of_facets}, 'merge'; { my $meshes = $m->split; is scalar(@$meshes), 2, 'split'; } } { my $m = Slic3r::TriangleMesh->new; $m->ReadFromPerl($cube->{vertices}, $cube->{facets}); $m->repair; my @z = (0,2,4,8,6,8,10,12,14,16,18,20); my $result = $m->slice(\@z); my $SCALING_FACTOR = 0.000001; for my $i (0..$#z) { is scalar(@{$result->[$i]}), 1, "number of returned polygons per layer (z = " . $z[$i] . ")"; is $result->[$i][0]->area, 20*20/($SCALING_FACTOR**2), 'size of returned polygon'; } } { my $m = Slic3r::TriangleMesh->new; $m->ReadFromPerl( [ [0,0,0],[0,0,20],[0,5,0],[0,5,20],[50,0,0],[50,0,20],[15,5,0],[35,5,0],[15,20,0],[50,5,0],[35,20,0],[15,5,10],[50,5,20],[35,5,10],[35,20,10],[15,20,10] ], [ [0,1,2],[2,1,3],[1,0,4],[5,1,4],[0,2,4],[4,2,6],[7,6,8],[4,6,7],[9,4,7],[7,8,10],[2,3,6],[11,3,12],[7,12,9],[13,12,7],[6,3,11],[11,12,13],[3,1,5],[12,3,5],[5,4,9],[12,5,9],[13,7,10],[14,13,10],[8,15,10],[10,15,14],[6,11,8],[8,11,15],[15,11,13],[14,15,13] ], ); $m->repair; { # at Z = 10 we have a top horizontal surface my $slices = $m->slice([ 5, 10 ]); is $slices->[0][0]->area, $slices->[1][0]->area, 'slicing a top tangent plane includes its area'; } $m->mirror_z; { # this second test also checks that performing a second slice on a mesh after # a transformation works properly (shared_vertices is correctly invalidated); # at Z = -10 we have a bottom horizontal surface my $slices = $m->slice([ -5, -10 ]); is $slices->[0][0]->area, $slices->[1][0]->area, 'slicing a bottom tangent plane includes its area'; } } { my $m = Slic3r::TriangleMesh->new; $m->ReadFromPerl($cube->{vertices}, $cube->{facets}); $m->repair; { my $upper = Slic3r::TriangleMesh->new; my $lower = Slic3r::TriangleMesh->new; $m->cut(0, $upper, $lower); $upper->repair; $lower->repair; is $upper->facets_count, 12, 'upper mesh has all facets except those belonging to the slicing plane'; is $lower->facets_count, 0, 'lower mesh has no facets'; } { my $upper = Slic3r::TriangleMesh->new; my $lower = Slic3r::TriangleMesh->new; $m->cut(10, $upper, $lower); #$upper->repair; $lower->repair; # we expect: # 2 facets on external horizontal surfaces # 3 facets on each side = 12 facets # 6 facets on the triangulated side (8 vertices) is $upper->facets_count, 2+12+6, 'upper mesh has the expected number of facets'; is $lower->facets_count, 2+12+6, 'lower mesh has the expected number of facets'; } } __END__ Slic3r-version_1.31.6/xs/t/03_point.t000066400000000000000000000054651301441720000172250ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 24; my $point = Slic3r::Point->new(10, 15); is_deeply [ @$point ], [10, 15], 'point roundtrip'; my $point2 = $point->clone; $point2->scale(2); is_deeply [ @$point2 ], [20, 30], 'scale'; $point2->translate(10, -15); is_deeply [ @$point2 ], [30, 15], 'translate'; ok $point->coincides_with($point->clone), 'coincides_with'; ok !$point->coincides_with($point2), 'coincides_with'; { my $point3 = Slic3r::Point->new(4300000, -9880845); is $point->[0], $point->x, 'x accessor'; is $point->[1], $point->y, 'y accessor'; #,, } { my $nearest = $point->nearest_point([ $point2, Slic3r::Point->new(100, 200) ]); ok $nearest->coincides_with($point2), 'nearest_point'; } { my $line = Slic3r::Line->new([0,0], [100,0]); is +Slic3r::Point->new(0,0) ->distance_to_line($line), 0, 'distance_to_line()'; is +Slic3r::Point->new(100,0)->distance_to_line($line), 0, 'distance_to_line()'; is +Slic3r::Point->new(50,0) ->distance_to_line($line), 0, 'distance_to_line()'; is +Slic3r::Point->new(150,0)->distance_to_line($line), 50, 'distance_to_line()'; is +Slic3r::Point->new(0,50) ->distance_to_line($line), 50, 'distance_to_line()'; is +Slic3r::Point->new(50,50)->distance_to_line($line), 50, 'distance_to_line()'; is +Slic3r::Point->new(50,50) ->perp_distance_to_line($line), 50, 'perp_distance_to_line()'; is +Slic3r::Point->new(150,50)->perp_distance_to_line($line), 50, 'perp_distance_to_line()'; } { my $line = Slic3r::Line->new([50,50], [125,-25]); is +Slic3r::Point->new(100,0)->distance_to_line($line), 0, 'distance_to_line()'; } { my $line = Slic3r::Line->new( [18335846,18335845], [18335846,1664160], ); $point = Slic3r::Point->new(1664161,18335848); is $point->perp_distance_to_line($line), 16671685, 'perp_distance_to_line() does not overflow'; } { my $p0 = Slic3r::Point->new(76975850,89989996); my $p1 = Slic3r::Point->new(76989990,109989991); my $p2 = Slic3r::Point->new(76989987,89989994); ok $p0->ccw($p1, $p2) < 0, 'ccw() does not overflow'; } { my $point = Slic3r::Point->new(15,15); my $line = Slic3r::Line->new([10,10], [20,10]); is_deeply $point->projection_onto_line($line)->pp, [15,10], 'project_onto_line'; $point = Slic3r::Point->new(0, 15); is_deeply $point->projection_onto_line($line)->pp, [10,10], 'project_onto_line'; $point = Slic3r::Point->new(25, 15); is_deeply $point->projection_onto_line($line)->pp, [20,10], 'project_onto_line'; $point = Slic3r::Point->new(10,10); is_deeply $point->projection_onto_line($line)->pp, [10,10], 'project_onto_line'; $point = Slic3r::Point->new(12, 10); is_deeply $point->projection_onto_line($line)->pp, [12,10], 'project_onto_line'; } __END__ Slic3r-version_1.31.6/xs/t/04_expolygon.t000066400000000000000000000111041301441720000201040ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use List::Util qw(first sum); use Slic3r::XS; use Test::More tests => 33; use constant PI => 4 * atan2(1, 1); my $square = [ # ccw [100, 100], [200, 100], [200, 200], [100, 200], ]; my $hole_in_square = [ # cw [140, 140], [140, 160], [160, 160], [160, 140], ]; my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square); ok $expolygon->is_valid, 'is_valid'; is ref($expolygon->pp), 'ARRAY', 'expolygon pp is unblessed'; is_deeply $expolygon->pp, [$square, $hole_in_square], 'expolygon roundtrip'; is ref($expolygon->arrayref), 'ARRAY', 'expolygon arrayref is unblessed'; isa_ok $expolygon->[0], 'Slic3r::Polygon::Ref', 'expolygon polygon is blessed'; isa_ok $expolygon->contour, 'Slic3r::Polygon::Ref', 'expolygon contour is blessed'; isa_ok $expolygon->holes->[0], 'Slic3r::Polygon::Ref', 'expolygon hole is blessed'; isa_ok $expolygon->[0][0], 'Slic3r::Point::Ref', 'expolygon point is blessed'; { my $expolygon2 = $expolygon->clone; my $polygon = $expolygon2->[0]; $polygon->scale(2); is $expolygon2->[0][0][0], $polygon->[0][0], 'polygons are returned by reference'; } is_deeply $expolygon->clone->pp, [$square, $hole_in_square], 'clone'; is $expolygon->area, 100*100-20*20, 'area'; { my $expolygon2 = $expolygon->clone; $expolygon2->scale(2.5); is_deeply $expolygon2->pp, [ [map [ 2.5*$_->[0], 2.5*$_->[1] ], @$square], [map [ 2.5*$_->[0], 2.5*$_->[1] ], @$hole_in_square] ], 'scale'; } { my $expolygon2 = $expolygon->clone; $expolygon2->translate(10, -5); is_deeply $expolygon2->pp, [ [map [ $_->[0]+10, $_->[1]-5 ], @$square], [map [ $_->[0]+10, $_->[1]-5 ], @$hole_in_square] ], 'translate'; } { my $expolygon2 = $expolygon->clone; $expolygon2->rotate(PI/2, Slic3r::Point->new(150,150)); is_deeply $expolygon2->pp, [ [ @$square[1,2,3,0] ], [ @$hole_in_square[3,0,1,2] ] ], 'rotate around Point'; } { my $expolygon2 = $expolygon->clone; $expolygon2->rotate(PI/2, [150,150]); is_deeply $expolygon2->pp, [ [ @$square[1,2,3,0] ], [ @$hole_in_square[3,0,1,2] ] ], 'rotate around pure-Perl Point'; } { my $expolygon2 = $expolygon->clone; $expolygon2->scale(2); my $collection = Slic3r::ExPolygon::Collection->new($expolygon->pp, $expolygon2->pp); is_deeply $collection->pp, [ $expolygon->pp, $expolygon2->pp ], 'expolygon collection (pure Perl) roundtrip'; my $collection2 = Slic3r::ExPolygon::Collection->new($expolygon, $expolygon2); is_deeply $collection->pp, $collection2->pp, 'expolygon collection (XS) roundtrip'; $collection->clear; is scalar(@$collection), 0, 'clear collection'; $collection->append($expolygon); is scalar(@$collection), 1, 'append to collection'; my $exp = $collection->[0]; $exp->scale(3); is $collection->[0][0][0][0], $exp->[0][0][0], 'collection items are returned by reference'; is_deeply $collection->[0]->clone->pp, $collection->[0]->pp, 'clone collection item'; } { my $expolygon = Slic3r::ExPolygon->new($square); my $polygons = $expolygon->get_trapezoids2(PI/2); is scalar(@$polygons), 1, 'correct number of trapezoids returned'; is scalar(@{$polygons->[0]}), 4, 'trapezoid has 4 points'; is $polygons->[0]->area, $expolygon->area, 'trapezoid has correct area'; } { my $polygons = $expolygon->get_trapezoids2(PI/2); is scalar(@$polygons), 4, 'correct number of trapezoids returned'; # trapezoid polygons might have more than 4 points in case of collinear segments $polygons = [ map @{$_->simplify(1)}, @$polygons ]; ok !defined(first { @$_ != 4 } @$polygons), 'all trapezoids have 4 points'; is scalar(grep { $_->area == 40*100 } @$polygons), 2, 'trapezoids have expected area'; is scalar(grep { $_->area == 20*40 } @$polygons), 2, 'trapezoids have expected area'; } { my $expolygon = Slic3r::ExPolygon->new([ [0,100],[100,0],[200,0],[300,100],[200,200],[100,200] ]); my $polygons = $expolygon->get_trapezoids2(PI/2); is scalar(@$polygons), 3, 'correct number of trapezoids returned'; is scalar(grep { $_->area == 100*200/2 } @$polygons), 2, 'trapezoids have expected area'; is scalar(grep { $_->area == 100*200 } @$polygons), 1, 'trapezoids have expected area'; } { my $triangles = $expolygon->triangulate_pp; is scalar(@$triangles), 8, 'expected number of triangles'; is sum(map $_->area, @$triangles), $expolygon->area, 'sum of triangles area equals original expolygon area'; } __END__ Slic3r-version_1.31.6/xs/t/05_surface.t000066400000000000000000000046671301441720000175310ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 15; my $square = [ # ccw [100, 100], [200, 100], [200, 200], [100, 200], ]; my $hole_in_square = [ # cw [140, 140], [140, 160], [160, 160], [160, 140], ]; my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square); my $surface = Slic3r::Surface->new( expolygon => $expolygon, surface_type => Slic3r::Surface::S_TYPE_INTERNAL, ); $surface = $surface->clone; isa_ok $surface->expolygon, 'Slic3r::ExPolygon::Ref', 'expolygon'; is_deeply [ @{$surface->expolygon->pp} ], [$square, $hole_in_square], 'expolygon roundtrip'; is scalar(@{$surface->polygons}), 2, 'polygons roundtrip'; is $surface->surface_type, Slic3r::Surface::S_TYPE_INTERNAL, 'surface_type'; $surface->surface_type(Slic3r::Surface::S_TYPE_BOTTOM); is $surface->surface_type, Slic3r::Surface::S_TYPE_BOTTOM, 'modify surface_type'; $surface->bridge_angle(30); is $surface->bridge_angle, 30, 'bridge_angle'; $surface->extra_perimeters(2); is $surface->extra_perimeters, 2, 'extra_perimeters'; { my $surface2 = $surface->clone; $surface2->expolygon->scale(2); isnt $surface2->expolygon->area, $expolygon->area, 'expolygon is returned by reference'; } { my $collection = Slic3r::Surface::Collection->new; $collection->append($_) for $surface, $surface->clone; is scalar(@$collection), 2, 'collection has the right number of items'; is_deeply $collection->[0]->expolygon->pp, [$square, $hole_in_square], 'collection returns a correct surface expolygon'; $collection->clear; is scalar(@$collection), 0, 'clear collection'; $collection->append($surface); is scalar(@$collection), 1, 'append to collection'; my $item = $collection->[0]; isa_ok $item, 'Slic3r::Surface::Ref'; $item->surface_type(Slic3r::Surface::S_TYPE_INTERNAL); is $item->surface_type, $collection->[0]->surface_type, 'collection returns items by reference'; } { my $collection = Slic3r::Surface::Collection->new; $collection->append($_) for Slic3r::Surface->new(expolygon => $expolygon, surface_type => Slic3r::Surface::S_TYPE_BOTTOM), Slic3r::Surface->new(expolygon => $expolygon, surface_type => Slic3r::Surface::S_TYPE_BOTTOM), Slic3r::Surface->new(expolygon => $expolygon, surface_type => Slic3r::Surface::S_TYPE_TOP); is scalar(@{$collection->group}), 2, 'group() returns correct number of groups'; } __END__ Slic3r-version_1.31.6/xs/t/06_polygon.t000066400000000000000000000055611301441720000175630ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use List::Util qw(first); use Slic3r::XS; use Test::More tests => 21; use constant PI => 4 * atan2(1, 1); my $square = [ # ccw [100, 100], [200, 100], [200, 200], [100, 200], ]; my $polygon = Slic3r::Polygon->new(@$square); my $cw_polygon = $polygon->clone; $cw_polygon->reverse; ok $polygon->is_valid, 'is_valid'; is_deeply $polygon->pp, $square, 'polygon roundtrip'; is ref($polygon->arrayref), 'ARRAY', 'polygon arrayref is unblessed'; isa_ok $polygon->[0], 'Slic3r::Point::Ref', 'polygon point is blessed'; my $lines = $polygon->lines; is_deeply [ map $_->pp, @$lines ], [ [ [100, 100], [200, 100] ], [ [200, 100], [200, 200] ], [ [200, 200], [100, 200] ], [ [100, 200], [100, 100] ], ], 'polygon lines'; is_deeply $polygon->split_at_first_point->pp, [ @$square[0,1,2,3,0] ], 'split_at_first_point'; is_deeply $polygon->split_at_index(2)->pp, [ @$square[2,3,0,1,2] ], 'split_at_index'; is_deeply $polygon->split_at_vertex(Slic3r::Point->new(@{$square->[2]}))->pp, [ @$square[2,3,0,1,2] ], 'split_at'; is $polygon->area, 100*100, 'area'; ok $polygon->is_counter_clockwise, 'is_counter_clockwise'; ok !$cw_polygon->is_counter_clockwise, 'is_counter_clockwise'; { my $clone = $polygon->clone; $clone->reverse; ok !$clone->is_counter_clockwise, 'is_counter_clockwise'; $clone->make_counter_clockwise; ok $clone->is_counter_clockwise, 'make_counter_clockwise'; $clone->make_counter_clockwise; ok $clone->is_counter_clockwise, 'make_counter_clockwise'; } ok ref($polygon->first_point) eq 'Slic3r::Point', 'first_point'; ok $polygon->contains_point(Slic3r::Point->new(150,150)), 'ccw contains_point'; ok $cw_polygon->contains_point(Slic3r::Point->new(150,150)), 'cw contains_point'; { my @points = (Slic3r::Point->new(100,0)); foreach my $i (1..5) { my $point = $points[0]->clone; $point->rotate(PI/3*$i, [0,0]); push @points, $point; } my $hexagon = Slic3r::Polygon->new(@points); my $triangles = $hexagon->triangulate_convex; is scalar(@$triangles), 4, 'right number of triangles'; ok !(defined first { $_->is_clockwise } @$triangles), 'all triangles are ccw'; } { is_deeply $polygon->centroid->pp, [150,150], 'centroid'; } { my $polygon = Slic3r::Polygon->new( [50000000, 100000000], [300000000, 102000000], [50000000, 104000000], ); my $line = Slic3r::Line->new([175992032,102000000], [47983964,102000000]); my $intersection = $polygon->intersection($line); is_deeply $intersection->pp, [50000000, 102000000], 'polygon-line intersection'; } # this is not a test: this just demonstrates bad usage, where $polygon->clone gets # DESTROY'ed before the derived object ($point), causing bad memory access if (0) { my $point; { $point = $polygon->clone->[0]; } $point->scale(2); } __END__ Slic3r-version_1.31.6/xs/t/07_extrusionpath.t000066400000000000000000000017421301441720000210070ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 8; my $points = [ [100, 100], [200, 100], [200, 200], ]; my $path = Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new(@$points), role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1, ); isa_ok $path->polyline, 'Slic3r::Polyline::Ref', 'path polyline'; is_deeply $path->polyline->pp, $points, 'path points roundtrip'; $path->reverse; is_deeply $path->polyline->pp, [ reverse @$points ], 'reverse path'; $path->append([ 150, 150 ]); is scalar(@$path), 4, 'append to path'; $path->pop_back; is scalar(@$path), 3, 'pop_back from path'; ok $path->first_point->coincides_with($path->polyline->[0]), 'first_point'; $path = $path->clone; is $path->role, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, 'role'; $path->role(Slic3r::ExtrusionPath::EXTR_ROLE_FILL); is $path->role, Slic3r::ExtrusionPath::EXTR_ROLE_FILL, 'modify role'; __END__ Slic3r-version_1.31.6/xs/t/08_extrusionloop.t000066400000000000000000000175621301441720000210340ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use List::Util qw(sum); use Slic3r::XS; use Test::More tests => 48; { my $square = [ [100, 100], [200, 100], [200, 200], [100, 200], ]; my $square_p = Slic3r::Polygon->new(@$square); my $loop = Slic3r::ExtrusionLoop->new; $loop->append(Slic3r::ExtrusionPath->new( polyline => $square_p->split_at_first_point, role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1, )); isa_ok $loop, 'Slic3r::ExtrusionLoop'; isa_ok $loop->polygon, 'Slic3r::Polygon', 'loop polygon'; is $loop->polygon->area, $square_p->area, 'polygon area'; is $loop->length, $square_p->length(), 'loop length'; $loop = $loop->clone; is scalar(@$loop), 1, 'loop contains one path'; { my $path = $loop->[0]; isa_ok $path, 'Slic3r::ExtrusionPath::Ref'; is $path->role, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, 'role'; $path->role(Slic3r::ExtrusionPath::EXTR_ROLE_FILL); is $path->role, Slic3r::ExtrusionPath::EXTR_ROLE_FILL, 'modify role'; } $loop->split_at_vertex($square_p->[2]); is scalar(@$loop), 1, 'splitting a single-path loop results in a single path'; is scalar(@{$loop->[0]->polyline}), 5, 'path has correct number of points'; ok $loop->[0]->polyline->[0]->coincides_with($square_p->[2]), 'expected point order'; ok $loop->[0]->polyline->[1]->coincides_with($square_p->[3]), 'expected point order'; ok $loop->[0]->polyline->[2]->coincides_with($square_p->[0]), 'expected point order'; ok $loop->[0]->polyline->[3]->coincides_with($square_p->[1]), 'expected point order'; ok $loop->[0]->polyline->[4]->coincides_with($square_p->[2]), 'expected point order'; } { my $polyline1 = Slic3r::Polyline->new([100,100], [200,100], [200,200]); my $polyline2 = Slic3r::Polyline->new([200,200], [100,200], [100,100]); my $loop = Slic3r::ExtrusionLoop->new_from_paths( Slic3r::ExtrusionPath->new( polyline => $polyline1, role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1, ), Slic3r::ExtrusionPath->new( polyline => $polyline2, role => Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, mm3_per_mm => 1, ), ); my $tot_len = sum($polyline1->length, $polyline2->length); is $loop->length, $tot_len, 'length'; is scalar(@$loop), 2, 'loop contains two paths'; { # check splitting at intermediate point my $loop2 = $loop->clone; isa_ok $loop2, 'Slic3r::ExtrusionLoop'; $loop2->split_at_vertex($polyline1->[1]); is $loop2->length, $tot_len, 'length after splitting is unchanged'; is scalar(@$loop2), 3, 'loop contains three paths after splitting'; ok $loop2->[0]->polyline->[0]->coincides_with($polyline1->[1]), 'expected starting point'; ok $loop2->[-1]->polyline->[-1]->coincides_with($polyline1->[1]), 'expected ending point'; ok $loop2->[0]->polyline->[-1]->coincides_with($loop2->[1]->polyline->[0]), 'paths have common point'; ok $loop2->[1]->polyline->[-1]->coincides_with($loop2->[2]->polyline->[0]), 'paths have common point'; is $loop2->[0]->role, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, 'expected order after splitting'; is $loop2->[1]->role, Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, 'expected order after splitting'; is $loop2->[2]->role, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, 'expected order after splitting'; is scalar(@{$loop2->[0]->polyline}), 2, 'path has correct number of points'; is scalar(@{$loop2->[1]->polyline}), 3, 'path has correct number of points'; is scalar(@{$loop2->[2]->polyline}), 2, 'path has correct number of points'; my @paths = @{$loop2->clip_end(3)}; is sum(map $_->length, @paths), $loop2->length - 3, 'returned paths have expected length'; } { # check splitting at endpoint my $loop2 = $loop->clone; $loop2->split_at_vertex($polyline2->[0]); is $loop2->length, $tot_len, 'length after splitting is unchanged'; is scalar(@$loop2), 2, 'loop contains two paths after splitting'; ok $loop2->[0]->polyline->[0]->coincides_with($polyline2->[0]), 'expected starting point'; ok $loop2->[-1]->polyline->[-1]->coincides_with($polyline2->[0]), 'expected ending point'; ok $loop2->[0]->polyline->[-1]->coincides_with($loop2->[1]->polyline->[0]), 'paths have common point'; ok $loop2->[1]->polyline->[-1]->coincides_with($loop2->[0]->polyline->[0]), 'paths have common point'; is $loop2->[0]->role, Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, 'expected order after splitting'; is $loop2->[1]->role, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, 'expected order after splitting'; is scalar(@{$loop2->[0]->polyline}), 3, 'path has correct number of points'; is scalar(@{$loop2->[1]->polyline}), 3, 'path has correct number of points'; } { my $loop2 = $loop->clone; my $point = Slic3r::Point->new(250,150); $loop2->split_at($point); is $loop2->length, $tot_len, 'length after splitting is unchanged'; is scalar(@$loop2), 3, 'loop contains three paths after splitting'; my $expected_start_point = Slic3r::Point->new(200,150); ok $loop2->[0]->polyline->[0]->coincides_with($expected_start_point), 'expected starting point'; ok $loop2->[-1]->polyline->[-1]->coincides_with($expected_start_point), 'expected ending point'; } } { my @polylines = ( Slic3r::Polyline->new([59312736,4821067],[64321068,4821067],[64321068,4821067],[64321068,9321068],[59312736,9321068]), Slic3r::Polyline->new([59312736,9321068],[9829401,9321068]), Slic3r::Polyline->new([9829401,9321068],[4821067,9321068],[4821067,4821067],[9829401,4821067]), Slic3r::Polyline->new([9829401,4821067],[59312736,4821067]), ); my $loop = Slic3r::ExtrusionLoop->new; $loop->append($_) for ( Slic3r::ExtrusionPath->new(polyline => $polylines[0], role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1), Slic3r::ExtrusionPath->new(polyline => $polylines[1], role => Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, mm3_per_mm => 1), Slic3r::ExtrusionPath->new(polyline => $polylines[2], role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1), Slic3r::ExtrusionPath->new(polyline => $polylines[3], role => Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, mm3_per_mm => 1), ); my $len = $loop->length; my $point = Slic3r::Point->new(4821067,9321068); $loop->split_at_vertex($point) or $loop->split_at($point); is $loop->length, $len, 'total length is preserved after splitting'; is_deeply [ map $_->role, @$loop ], [ Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, Slic3r::ExtrusionPath::EXTR_ROLE_OVERHANG_PERIMETER, Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, ], 'order is correctly preserved after splitting'; } { my $loop = Slic3r::ExtrusionLoop->new; $loop->append(Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new([15896783,15868739],[24842049,12117558],[33853238,15801279],[37591780,24780128],[37591780,24844970],[33853231,33825297],[24842049,37509013],[15896798,33757841],[12211841,24812544],[15896783,15868739]), role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1 )); my $len = $loop->length; $loop->split_at(Slic3r::Point->new(15896783,15868739)); is $loop->length, $len, 'split_at() preserves total length'; } __END__ Slic3r-version_1.31.6/xs/t/09_polyline.t000066400000000000000000000070421301441720000177260ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 18; my $points = [ [100, 100], [200, 100], [200, 200], ]; my $polyline = Slic3r::Polyline->new(@$points); is_deeply $polyline->pp, $points, 'polyline roundtrip'; is ref($polyline->arrayref), 'ARRAY', 'polyline arrayref is unblessed'; isa_ok $polyline->[0], 'Slic3r::Point::Ref', 'polyline point is blessed'; my $lines = $polyline->lines; is_deeply [ map $_->pp, @$lines ], [ [ [100, 100], [200, 100] ], [ [200, 100], [200, 200] ], ], 'polyline lines'; $polyline->append_polyline($polyline->clone); is_deeply $polyline->pp, [ @$points, @$points ], 'append_polyline'; { my $len = $polyline->length; $polyline->clip_end($len/3); ok abs($polyline->length - ($len-($len/3))) < 1, 'clip_end'; } { my $polyline = Slic3r::Polyline->new( [0,0], [20,0], [50,0], [80,0], [100,0], ); $polyline->simplify(2); is_deeply $polyline->pp, [ [0,0], [100,0] ], 'Douglas-Peucker'; } { my $polyline = Slic3r::Polyline->new( [0,0], [50,50], [100,0], [125,-25], [150,50], ); $polyline->simplify(25); is_deeply $polyline->pp, [ [0, 0], [50, 50], [125, -25], [150, 50] ], 'Douglas-Peucker'; } { my $polyline = Slic3r::Polyline->new( [0,0], [100,0], [50,10], ); $polyline->simplify(25); is_deeply $polyline->pp, [ [0,0], [100,0], [50,10] ], 'Douglas-Peucker uses shortest distance instead of perpendicular distance'; } { my $polyline = Slic3r::Polyline->new(@$points); is $polyline->length, 100*2, 'length'; $polyline->extend_end(50); is $polyline->length, 100*2 + 50, 'extend_end'; $polyline->extend_start(50); is $polyline->length, 100*2 + 50 + 50, 'extend_start'; } { my $polyline = Slic3r::Polyline->new(@$points); my $p1 = Slic3r::Polyline->new; my $p2 = Slic3r::Polyline->new; my $point = Slic3r::Point->new(150, 100); $polyline->split_at($point, $p1, $p2); is scalar(@$p1), 2, 'split_at'; is scalar(@$p2), 3, 'split_at'; ok $p1->last_point->coincides_with($point), 'split_at'; ok $p2->first_point->coincides_with($point), 'split_at'; } { my $polyline = Slic3r::Polyline->new(@$points[0,1,2,0]); my $p1 = Slic3r::Polyline->new; my $p2 = Slic3r::Polyline->new; $polyline->split_at($polyline->first_point, $p1, $p2); is scalar(@$p1), 1, 'split_at'; is scalar(@$p2), 4, 'split_at'; } # disabled because we now use a more efficient but incomplete algorithm if (0) { my $polyline = Slic3r::Polyline->new( map [$_,10], (0,10,20,30,40,50,60) ); { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new( [25,0], [55,0], [55,30], [25,30], )); my $p = $polyline->clone; $p->simplify_by_visibility($expolygon); is_deeply $p->pp, [ map [$_,10], (0,10,20,30,50,60) ], 'simplify_by_visibility()'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new( [-15,0], [75,0], [75,30], [-15,30], )); my $p = $polyline->clone; $p->simplify_by_visibility($expolygon); is_deeply $p->pp, [ map [$_,10], (0,60) ], 'simplify_by_visibility()'; } { my $expolygon = Slic3r::ExPolygon->new(Slic3r::Polygon->new( [-15,0], [25,0], [25,30], [-15,30], )); my $p = $polyline->clone; $p->simplify_by_visibility($expolygon); is_deeply $p->pp, [ map [$_,10], (0,20,30,40,50,60) ], 'simplify_by_visibility()'; } } __END__ Slic3r-version_1.31.6/xs/t/10_line.t000066400000000000000000000043421301441720000170120ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 40; use constant PI => 4 * atan2(1, 1); use constant EPSILON => 1E-4; my $points = [ [100, 100], [200, 100], ]; my $line = Slic3r::Line->new(@$points); is_deeply $line->pp, $points, 'line roundtrip'; is ref($line->arrayref), 'ARRAY', 'line arrayref is unblessed'; isa_ok $line->[0], 'Slic3r::Point::Ref', 'line point is blessed'; { my $clone = $line->clone; $clone->reverse; is_deeply $clone->pp, [ reverse @$points ], 'reverse'; } { my $line2 = Slic3r::Line->new($line->a->clone, $line->b->clone); is_deeply $line2->pp, $points, 'line roundtrip with cloned points'; } { my $clone = $line->clone; $clone->translate(10, -5); is_deeply $clone->pp, [ [110, 95], [210, 95], ], 'translate'; } { ok +Slic3r::Line->new([0,0],[200,0])->parallel_to_line(Slic3r::Line->new([200,200],[0,200])), 'parallel_to'; } foreach my $base_angle (0, PI/4, PI/2, PI) { my $line = Slic3r::Line->new([0,0], [100,0]); $line->rotate($base_angle, [0,0]); my $clone = $line->clone; ok $line->parallel_to_line($clone), 'line is parallel to self'; $clone->reverse; ok $line->parallel_to_line($clone), 'line is parallel to self + PI'; ok $line->parallel_to($line->direction), 'line is parallel to its direction'; ok $line->parallel_to($line->direction + PI), 'line is parallel to its direction + PI'; ok $line->parallel_to($line->direction - PI), 'line is parallel to its direction - PI'; { my $line2 = $line->clone; $line2->reverse; ok $line->parallel_to_line($line2), 'line is parallel to its opposite'; } { my $line2 = $line->clone; $line2->rotate(+(EPSILON)/2, [0,0]); ok $line->parallel_to_line($line2), 'line is parallel within epsilon'; } { my $line2 = $line->clone; $line2->rotate(-(EPSILON)/2, [0,0]); ok $line->parallel_to_line($line2), 'line is parallel within epsilon'; } } { my $a = Slic3r::Line->new([100, 0], [200, 0]); my $b = Slic3r::Line->new([300, 300], [300, 100]); my $r = $a->intersection_infinite($b); is_deeply $r->pp, [300, 0], 'intersection_infinite'; } __END__ Slic3r-version_1.31.6/xs/t/11_clipper.t000066400000000000000000000245621301441720000175300ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use List::Util qw(sum); use Slic3r::XS; use Test::More tests => 23; my $square = Slic3r::Polygon->new( # ccw [200, 100], [200, 200], [100, 200], [100, 100], ); my $hole_in_square = Slic3r::Polygon->new( # cw [160, 140], [140, 140], [140, 160], [160, 160], ); my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square); { my $result = Slic3r::Geometry::Clipper::offset([ $square, $hole_in_square ], 5); is_deeply [ map $_->pp, @$result ], [ [ [205, 205], [95, 205], [95, 95], [205, 95], ], [ [145, 145], [145, 155], [155, 155], [155, 145], ] ], 'offset'; } { my $result = Slic3r::Geometry::Clipper::offset_ex([ @$expolygon ], 5); is_deeply $result->[0]->pp, [ [ [205, 205], [95, 205], [95, 95], [205, 95], ], [ [145, 145], [145, 155], [155, 155], [155, 145], ] ], 'offset_ex'; } { my $result = Slic3r::Geometry::Clipper::offset2_ex([ @$expolygon ], 5, -2); is_deeply $result->[0]->pp, [ [ [203, 203], [97, 203], [97, 97], [203, 97], ], [ [143, 143], [143, 157], [157, 157], [157, 143], ] ], 'offset2_ex'; } { my $expolygon2 = Slic3r::ExPolygon->new([ [20000000, 20000000], [0, 20000000], [0, 0], [20000000, 0], ], [ [5000000, 15000000], [15000000, 15000000], [15000000, 5000000], [5000000, 5000000], ]); my $result = Slic3r::Geometry::Clipper::offset2_ex([ @$expolygon2 ], -1, +1); is $result->[0]->area, $expolygon2->area, 'offset2_ex'; } { my $polygon1 = Slic3r::Polygon->new(@$square); my $polygon2 = Slic3r::Polygon->new(reverse @$hole_in_square); my $result = Slic3r::Geometry::Clipper::diff_ex([$polygon1], [$polygon2]); is $result->[0]->area, $expolygon->area, 'diff_ex'; } { my $polyline = Slic3r::Polyline->new([50,150], [300,150]); { my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square, $hole_in_square]); is scalar(@$result), 2, 'intersection_pl - correct number of result lines'; # results are in no particular order is scalar(grep $_->length == 40, @$result), 2, 'intersection_pl - result lines have correct length'; } { my $result = Slic3r::Geometry::Clipper::diff_pl([$polyline], [$square, $hole_in_square]); is scalar(@$result), 3, 'diff_pl - correct number of result lines'; # results are in no particular order is scalar(grep $_->length == 50, @$result), 1, 'diff_pl - the left result line has correct length'; is scalar(grep $_->length == 100, @$result), 1, 'diff_pl - two right result line has correct length'; is scalar(grep $_->length == 20, @$result), 1, 'diff_pl - the central result line has correct length'; } } if (0) { # Clipper does not preserve polyline orientation my $polyline = Slic3r::Polyline->new([50,150], [300,150]); my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]); is scalar(@$result), 1, 'intersection_pl - correct number of result lines'; is_deeply $result->[0]->pp, [[100,150], [200,150]], 'clipped line orientation is preserved'; } if (0) { # Clipper does not preserve polyline orientation my $polyline = Slic3r::Polyline->new([300,150], [50,150]); my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]); is scalar(@$result), 1, 'intersection_pl - correct number of result lines'; is_deeply $result->[0]->pp, [[200,150], [100,150]], 'clipped line orientation is preserved'; } if (0) { # Clipper does not preserve polyline orientation my $result = Slic3r::Geometry::Clipper::intersection_ppl([$hole_in_square], [$square]); is_deeply $result->[0]->pp, $hole_in_square->split_at_first_point->pp, 'intersection_ppl - clipping cw polygon as polyline preserves winding order'; } { my $square2 = $square->clone; $square2->translate(50,50); { my $result = Slic3r::Geometry::Clipper::intersection_ppl([$square2], [$square]); is scalar(@$result), 1, 'intersection_ppl - result contains a single line'; is scalar(@{$result->[0]}), 3, 'intersection_ppl - result contains expected number of points'; # Clipper does not preserve polyline orientation so we only check the middle point ###ok $result->[0][0]->coincides_with(Slic3r::Point->new(150,200)), 'intersection_ppl - expected point order'; ok $result->[0][1]->coincides_with(Slic3r::Point->new(150,150)), 'intersection_ppl - expected point order'; ###ok $result->[0][2]->coincides_with(Slic3r::Point->new(200,150)), 'intersection_ppl - expected point order'; } } { my $square2 = $square->clone; $square2->reverse; $square2->translate(50,50); { my $result = Slic3r::Geometry::Clipper::intersection_ppl([$square2], [$square]); is scalar(@$result), 1, 'intersection_ppl - result contains a single line'; is scalar(@{$result->[0]}), 3, 'intersection_ppl - result contains expected number of points'; # Clipper does not preserve polyline orientation so we only check the middle point ###ok $result->[0][0]->coincides_with(Slic3r::Point->new(200,150)), 'intersection_ppl - expected point order'; ok $result->[0][1]->coincides_with(Slic3r::Point->new(150,150)), 'intersection_ppl - expected point order'; ###ok $result->[0][2]->coincides_with(Slic3r::Point->new(150,200)), 'intersection_ppl - expected point order'; } } { # Clipper bug #96 (our issue #2028) my $subject = Slic3r::Polyline->new( [44735000,31936670],[55270000,31936670],[55270000,25270000],[74730000,25270000],[74730000,44730000],[68063296,44730000],[68063296,55270000],[74730000,55270000],[74730000,74730000],[55270000,74730000],[55270000,68063296],[44730000,68063296],[44730000,74730000],[25270000,74730000],[25270000,55270000],[31936670,55270000],[31936670,44730000],[25270000,44730000],[25270000,25270000],[44730000,25270000],[44730000,31936670] ); my $clip = [ Slic3r::Polygon->new([75200000,45200000],[54800000,45200000],[54800000,24800000],[75200000,24800000]), ]; my $result = Slic3r::Geometry::Clipper::intersection_pl([$subject], $clip); is scalar(@$result), 1, 'intersection_pl - result is not empty'; } { my $subject = Slic3r::Polygon->new( [44730000,31936670],[55270000,31936670],[55270000,25270000],[74730000,25270000],[74730000,44730000],[68063296,44730000],[68063296,55270000],[74730000,55270000],[74730000,74730000],[55270000,74730000],[55270000,68063296],[44730000,68063296],[44730000,74730000],[25270000,74730000],[25270000,55270000],[31936670,55270000],[31936670,44730000],[25270000,44730000],[25270000,25270000],[44730000,25270000] ); my $clip = [ Slic3r::Polygon->new([75200000,45200000],[54800000,45200000],[54800000,24800000],[75200000,24800000]), ]; my $result = Slic3r::Geometry::Clipper::intersection_ppl([$subject], $clip); is scalar(@$result), 1, 'intersection_ppl - result is not empty'; } { # Clipper bug #122 my $subject = [ Slic3r::Polyline->new([1975,1975],[25,1975],[25,25],[1975,25],[1975,1975]), ]; my $clip = [ Slic3r::Polygon->new([2025,2025],[-25,2025],[-25,-25],[2025,-25]), Slic3r::Polygon->new([525,525],[525,1475],[1475,1475],[1475,525]), ]; my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, $clip); is scalar(@$result), 1, 'intersection_pl - result is not empty'; is scalar(@{$result->[0]}), 5, 'intersection_pl - result is not empty'; } { # Clipper bug #126 my $subject = Slic3r::Polyline->new( [200000,19799999],[200000,200000],[24304692,200000],[15102879,17506106],[13883200,19799999],[200000,19799999], ); my $clip = [ Slic3r::Polygon->new([15257205,18493894],[14350057,20200000],[-200000,20200000],[-200000,-200000],[25196917,-200000]), ]; my $result = Slic3r::Geometry::Clipper::intersection_pl([$subject], $clip); is scalar(@$result), 1, 'intersection_pl - result is not empty'; is $result->[0]->length, $subject->length, 'intersection_pl - result has same length as subject polyline'; } if (0) { # Disabled until Clipper bug #127 is fixed my $subject = [ Slic3r::Polyline->new([-90000000,-100000000],[-90000000,100000000]), # vertical Slic3r::Polyline->new([-100000000,-10000000],[100000000,-10000000]), # horizontal Slic3r::Polyline->new([-100000000,0],[100000000,0]), # horizontal Slic3r::Polyline->new([-100000000,10000000],[100000000,10000000]), # horizontal ]; my $clip = Slic3r::Polygon->new( # a circular, convex, polygon [99452190,10452846],[97814760,20791169],[95105652,30901699],[91354546,40673664],[86602540,50000000], [80901699,58778525],[74314483,66913061],[66913061,74314483],[58778525,80901699],[50000000,86602540], [40673664,91354546],[30901699,95105652],[20791169,97814760],[10452846,99452190],[0,100000000], [-10452846,99452190],[-20791169,97814760],[-30901699,95105652],[-40673664,91354546], [-50000000,86602540],[-58778525,80901699],[-66913061,74314483],[-74314483,66913061], [-80901699,58778525],[-86602540,50000000],[-91354546,40673664],[-95105652,30901699], [-97814760,20791169],[-99452190,10452846],[-100000000,0],[-99452190,-10452846], [-97814760,-20791169],[-95105652,-30901699],[-91354546,-40673664],[-86602540,-50000000], [-80901699,-58778525],[-74314483,-66913061],[-66913061,-74314483],[-58778525,-80901699], [-50000000,-86602540],[-40673664,-91354546],[-30901699,-95105652],[-20791169,-97814760], [-10452846,-99452190],[0,-100000000],[10452846,-99452190],[20791169,-97814760], [30901699,-95105652],[40673664,-91354546],[50000000,-86602540],[58778525,-80901699], [66913061,-74314483],[74314483,-66913061],[80901699,-58778525],[86602540,-50000000], [91354546,-40673664],[95105652,-30901699],[97814760,-20791169],[99452190,-10452846],[100000000,0] ); my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]); is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines'; is sum(map scalar(@$_), @$result), scalar(@$subject)*2, 'intersection_pl - expected number of points in polylines'; } __END__ Slic3r-version_1.31.6/xs/t/12_extrusionpathcollection.t000066400000000000000000000062321301441720000230560ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 18; my $points = [ [100, 100], [200, 100], [200, 200], ]; my $path = Slic3r::ExtrusionPath->new( polyline => Slic3r::Polyline->new(@$points), role => Slic3r::ExtrusionPath::EXTR_ROLE_EXTERNAL_PERIMETER, mm3_per_mm => 1, ); my $loop = Slic3r::ExtrusionLoop->new_from_paths( Slic3r::ExtrusionPath->new( polyline => Slic3r::Polygon->new(@$points)->split_at_first_point, role => Slic3r::ExtrusionPath::EXTR_ROLE_FILL, mm3_per_mm => 1, ), ); my $collection = Slic3r::ExtrusionPath::Collection->new( $path, ); isa_ok $collection, 'Slic3r::ExtrusionPath::Collection', 'collection object with items in constructor'; ok !$collection->no_sort, 'no_sort is false by default'; $collection->append($collection); is scalar(@$collection), 2, 'append ExtrusionPath::Collection'; $collection->append($path); is scalar(@$collection), 3, 'append ExtrusionPath'; $collection->append($loop); is scalar(@$collection), 4, 'append ExtrusionLoop'; isa_ok $collection->[1], 'Slic3r::ExtrusionPath::Collection::Ref', 'correct object returned for collection'; isa_ok $collection->[2], 'Slic3r::ExtrusionPath::Ref', 'correct object returned for path'; isa_ok $collection->[3], 'Slic3r::ExtrusionLoop::Ref', 'correct object returned for loop'; is ref($collection->[2]->clone), 'Slic3r::ExtrusionPath', 'correct object returned for cloned path'; is ref($collection->[3]->clone), 'Slic3r::ExtrusionLoop', 'correct object returned for cloned loop'; is scalar(@{$collection->[1]}), 1, 'appended collection was duplicated'; { my $collection_loop = $collection->[3]; $collection_loop->polygon->scale(2); is_deeply $collection->[3]->polygon->pp, $collection_loop->polygon->pp, 'items are returned by reference'; } { my $collection = Slic3r::ExtrusionPath::Collection->new( map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1), Slic3r::Polyline->new([0,15], [0,18], [0,20]), Slic3r::Polyline->new([0,10], [0,8], [0,5]), ); is_deeply [ map $_->y, map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ], [20, 18, 15, 10, 8, 5], 'chained_path_from'; is_deeply [ map $_->y, map @{$_->polyline}, @{$collection->chained_path(0)} ], [15, 18, 20, 10, 8, 5], 'chained_path'; } { my $collection = Slic3r::ExtrusionPath::Collection->new( map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1), Slic3r::Polyline->new([15,0], [10,0], [4,0]), Slic3r::Polyline->new([10,5], [15,5], [20,5]), ); is_deeply [ map $_->x, map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ], [reverse 4, 10, 15, 10, 15, 20], 'chained_path_from'; $collection->no_sort(1); my @foo = @{$collection->chained_path(0)}; pass 'chained_path with no_sort'; } { my $coll2 = $collection->clone; ok !$coll2->no_sort, 'expected no_sort value'; $coll2->no_sort(1); ok $coll2->clone->no_sort, 'no_sort is kept after clone'; } __END__ Slic3r-version_1.31.6/xs/t/13_polylinecollection.t000066400000000000000000000016471301441720000220020ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 3; { my $collection = Slic3r::Polyline::Collection->new( Slic3r::Polyline->new([0,15], [0,18], [0,20]), Slic3r::Polyline->new([0,10], [0,8], [0,5]), ); is_deeply [ map $_->y, map @$_, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ], [20, 18, 15, 10, 8, 5], 'chained_path_from'; is_deeply [ map $_->y, map @$_, @{$collection->chained_path(0)} ], [15, 18, 20, 10, 8, 5], 'chained_path'; } { my $collection = Slic3r::Polyline::Collection->new( Slic3r::Polyline->new([15,0], [10,0], [4,0]), Slic3r::Polyline->new([10,5], [15,5], [20,5]), ); is_deeply [ map $_->x, map @$_, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ], [reverse 4, 10, 15, 10, 15, 20], 'chained_path_from'; } __END__ Slic3r-version_1.31.6/xs/t/14_geometry.t000066400000000000000000000026301301441720000177200ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 9; use constant PI => 4 * atan2(1, 1); { my @points = ( Slic3r::Point->new(100,100), Slic3r::Point->new(100,200), Slic3r::Point->new(200,200), Slic3r::Point->new(200,100), Slic3r::Point->new(150,150), ); my $hull = Slic3r::Geometry::convex_hull(\@points); isa_ok $hull, 'Slic3r::Polygon', 'convex_hull returns a Polygon'; is scalar(@$hull), 4, 'convex_hull returns the correct number of points'; } # directions_parallel() and directions_parallel_within() are tested # also with Slic3r::Line::parallel_to() tests in 10_line.t { ok Slic3r::Geometry::directions_parallel_within(0, 0, 0), 'directions_parallel_within'; ok Slic3r::Geometry::directions_parallel_within(0, PI, 0), 'directions_parallel_within'; ok Slic3r::Geometry::directions_parallel_within(0, 0, PI/180), 'directions_parallel_within'; ok Slic3r::Geometry::directions_parallel_within(0, PI, PI/180), 'directions_parallel_within'; ok !Slic3r::Geometry::directions_parallel_within(PI/2, PI, 0), 'directions_parallel_within'; ok !Slic3r::Geometry::directions_parallel_within(PI/2, PI, PI/180), 'directions_parallel_within'; } { my $positions = Slic3r::Geometry::arrange(4, Slic3r::Pointf->new(20, 20), 5); is scalar(@$positions), 4, 'arrange() returns expected number of positions'; } __END__ Slic3r-version_1.31.6/xs/t/15_config.t000066400000000000000000000257231301441720000173430ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 146; foreach my $config (Slic3r::Config->new, Slic3r::Config::Static::new_FullPrintConfig) { $config->set('layer_height', 0.3); ok abs($config->get('layer_height') - 0.3) < 1e-4, 'set/get float'; is $config->serialize('layer_height'), '0.3', 'serialize float'; $config->set('perimeters', 2); is $config->get('perimeters'), 2, 'set/get int'; is $config->serialize('perimeters'), '2', 'serialize int'; $config->set('extrusion_axis', 'A'); is $config->get('extrusion_axis'), 'A', 'set/get string'; is $config->serialize('extrusion_axis'), 'A', 'serialize string'; $config->set('notes', "foo\nbar"); is $config->get('notes'), "foo\nbar", 'set/get string with newline'; is $config->serialize('notes'), 'foo\nbar', 'serialize string with newline'; $config->set_deserialize('notes', 'bar\nbaz'); is $config->get('notes'), "bar\nbaz", 'deserialize string with newline'; foreach my $test_data ( { name => 'empty', values => [], serialized => '' }, { name => 'single empty', values => [''], serialized => '""' }, { name => 'single noempty, simple', values => ['RGB'], serialized => 'RGB' }, { name => 'multiple noempty, simple', values => ['ABC', 'DEF', '09182745@!#$*(&'], serialized => 'ABC;DEF;09182745@!#$*(&' }, { name => 'multiple, simple, some empty', values => ['ABC', 'DEF', '', '09182745@!#$*(&', ''], serialized => 'ABC;DEF;;09182745@!#$*(&;' }, { name => 'complex', values => ['some "quoted" notes', "yet\n some notes", "whatever \n notes", ''], serialized => '"some \"quoted\" notes";"yet\n some notes";"whatever \n notes";' } ) { $config->set('filament_notes', $test_data->{values}); is $config->serialize('filament_notes'), $test_data->{serialized}, 'serialize multi-string value ' . $test_data->{name}; $config->set_deserialize('filament_notes', ''); is_deeply $config->get('filament_notes'), [], 'deserialize multi-string value - empty ' . $test_data->{name}; $config->set_deserialize('filament_notes', $test_data->{serialized}); is_deeply $config->get('filament_notes'), $test_data->{values}, 'deserialize complex multi-string value ' . $test_data->{name}; } $config->set('first_layer_height', 0.3); ok abs($config->get('first_layer_height') - 0.3) < 1e-4, 'set/get absolute floatOrPercent'; is $config->serialize('first_layer_height'), '0.3', 'serialize absolute floatOrPercent'; $config->set('first_layer_height', '50%'); $config->get_abs_value('first_layer_height'); ok abs($config->get_abs_value('first_layer_height') - 0.15) < 1e-4, 'set/get relative floatOrPercent'; is $config->serialize('first_layer_height'), '50%', 'serialize relative floatOrPercent'; # Uh-oh, we have no point option to test at the moment #ok $config->set('print_center', [50,80]), 'valid point coordinates'; #is_deeply $config->get('print_center'), [50,80], 'set/get point'; #is $config->serialize('print_center'), '50,80', 'serialize point'; #$config->set_deserialize('print_center', '20,10'); #is_deeply $config->get('print_center'), [20,10], 'deserialize point'; #ok !$config->set('print_center', ['t',80]), 'invalid point X'; #ok !$config->set('print_center', [50,'t']), 'invalid point Y'; $config->set('use_relative_e_distances', 1); is $config->get('use_relative_e_distances'), 1, 'set/get bool'; is $config->serialize('use_relative_e_distances'), '1', 'serialize bool'; $config->set('gcode_flavor', 'teacup'); is $config->get('gcode_flavor'), 'teacup', 'set/get enum'; is $config->serialize('gcode_flavor'), 'teacup', 'serialize enum'; $config->set_deserialize('gcode_flavor', 'mach3'); is $config->get('gcode_flavor'), 'mach3', 'deserialize enum (gcode_flavor)'; $config->set_deserialize('gcode_flavor', 'machinekit'); is $config->get('gcode_flavor'), 'machinekit', 'deserialize enum (gcode_flavor)'; $config->set_deserialize('fill_pattern', 'line'); is $config->get('fill_pattern'), 'line', 'deserialize enum (fill_pattern)'; $config->set_deserialize('support_material_pattern', 'pillars'); is $config->get('support_material_pattern'), 'pillars', 'deserialize enum (support_material_pattern)'; $config->set('extruder_offset', [[10,20],[30,45]]); is_deeply [ map $_->pp, @{$config->get('extruder_offset')} ], [[10,20],[30,45]], 'set/get points'; $config->set('extruder_offset', [Slic3r::Pointf->new(10,20),Slic3r::Pointf->new(30,45)]); is_deeply [ map $_->pp, @{$config->get('extruder_offset')} ], [[10,20],[30,45]], 'set/get points'; is $config->serialize('extruder_offset'), '10x20,30x45', 'serialize points'; $config->set_deserialize('extruder_offset', '20x10'); is_deeply [ map $_->pp, @{$config->get('extruder_offset')} ], [[20,10]], 'deserialize points'; $config->set_deserialize('extruder_offset', '0x0'); is_deeply [ map $_->pp, @{$config->get('extruder_offset')} ], [[0,0]], 'deserialize points'; { my @values = ([10,20]); $values[2] = [10,20]; # implicitely extend array; this is not the same as explicitely assigning undef to second item ok !$config->set('extruder_offset', \@values), 'reject undef points'; } # truncate ->get() to first decimal digit $config->set('nozzle_diameter', [0.2,3]); is_deeply [ map int($_*10)/10, @{$config->get('nozzle_diameter')} ], [0.2,3], 'set/get floats'; is $config->serialize('nozzle_diameter'), '0.2,3', 'serialize floats'; $config->set_deserialize('nozzle_diameter', '0.1,0.4'); is_deeply [ map int($_*10)/10, @{$config->get('nozzle_diameter')} ], [0.1,0.4], 'deserialize floats'; $config->set_deserialize('nozzle_diameter', '3'); is_deeply [ map int($_*10)/10, @{$config->get('nozzle_diameter')} ], [3], 'deserialize a single float'; { my @values = (0.4); $values[2] = 2; # implicitely extend array; this is not the same as explicitely assigning undef to second item ok !$config->set('nozzle_diameter', \@values), 'reject undef floats'; } $config->set('temperature', [180,210]); is_deeply $config->get('temperature'), [180,210], 'set/get ints'; is $config->serialize('temperature'), '180,210', 'serialize ints'; $config->set_deserialize('temperature', '195,220'); is_deeply $config->get('temperature'), [195,220], 'deserialize ints'; { my @values = (180); $values[2] = 200; # implicitely extend array; this is not the same as explicitely assigning undef to second item ok !$config->set('temperature', \@values), 'reject undef ints'; } $config->set('wipe', [1,0]); is_deeply $config->get('wipe'), [1,0], 'set/get bools'; is $config->get_at('wipe', 0), 1, 'get_at bools'; is $config->get_at('wipe', 1), 0, 'get_at bools'; is $config->get_at('wipe', 9), 1, 'get_at bools'; is $config->serialize('wipe'), '1,0', 'serialize bools'; $config->set_deserialize('wipe', '0,1,1'); is_deeply $config->get('wipe'), [0,1,1], 'deserialize bools'; $config->set_deserialize('wipe', ''); is_deeply $config->get('wipe'), [], 'deserialize bools from empty string'; $config->set_deserialize('retract_layer_change', 0); is_deeply $config->get('retract_layer_change'), [0], 'deserialize bools from non-string value'; { my @values = (1); $values[2] = 1; # implicitely extend array; this is not the same as explicitely assigning undef to second item ok !$config->set('wipe', \@values), 'reject undef bools'; } $config->set('post_process', ['foo','bar']); is_deeply $config->get('post_process'), ['foo','bar'], 'set/get strings'; is $config->serialize('post_process'), 'foo;bar', 'serialize strings'; $config->set_deserialize('post_process', 'bar;baz'); is_deeply $config->get('post_process'), ['bar','baz'], 'deserialize strings'; { my @values = ('foo'); $values[2] = 'bar'; # implicitely extend array; this is not the same as explicitely assigning undef to second item ok !$config->set('post_process', \@values), 'reject undef strings'; } is_deeply [ sort @{$config->get_keys} ], [ sort keys %{$config->as_hash} ], 'get_keys and as_hash'; } { my $config = Slic3r::Config->new; $config->set('perimeters', 2); # test that no crash happens when using set_deserialize() with a key that hasn't been set() yet $config->set_deserialize('filament_diameter', '3'); my $config2 = Slic3r::Config::Static::new_FullPrintConfig; $config2->apply_dynamic($config); is $config2->get('perimeters'), 2, 'apply_dynamic'; } { my $config = Slic3r::Config::Static::new_FullPrintConfig; my $config2 = Slic3r::Config->new; $config2->apply_static($config); is $config2->get('perimeters'), Slic3r::Config::print_config_def()->{perimeters}{default}, 'apply_static and print_config_def'; $config->set('top_solid_infill_speed', 70); is $config->get_abs_value('top_solid_infill_speed'), 70, 'get_abs_value() works when ratio_over references a floatOrPercent option'; } { my $config = Slic3r::Config->new; $config->set('fill_pattern', 'line'); my $config2 = Slic3r::Config->new; $config2->set('fill_pattern', 'hilbertcurve'); is $config->get('fill_pattern'), 'line', 'no interferences between DynamicConfig objects'; } { my $config = Slic3r::Config->new; # the pair [0,0] is part of the test, since it checks whether the 0x0 serialized value is correctly parsed $config->set('extruder_offset', [ [0,0], [20,0], [0,20] ]); my $config2 = Slic3r::Config->new; $config2->apply($config); is_deeply [ map $_->pp, @{$config->get('extruder_offset')} ], [ map $_->pp, @{$config2->get('extruder_offset')} ], 'apply dynamic over dynamic'; } { my $config = Slic3r::Config->new; $config->set('extruder', 2); $config->set('perimeter_extruder', 3); $config->normalize; ok !$config->has('extruder'), 'extruder option is removed after normalize()'; is $config->get('infill_extruder'), 2, 'undefined extruder is populated with default extruder'; is $config->get('perimeter_extruder'), 3, 'defined extruder is not overwritten by default extruder'; } { my $config = Slic3r::Config->new; $config->set('infill_extruder', 2); $config->normalize; is $config->get('solid_infill_extruder'), 2, 'undefined solid infill extruder is populated with infill extruder'; } { my $config = Slic3r::Config->new; $config->set('spiral_vase', 1); $config->set('retract_layer_change', [1,0]); $config->normalize; is_deeply $config->get('retract_layer_change'), [0,0], 'retract_layer_change is disabled with spiral_vase'; } __END__ Slic3r-version_1.31.6/xs/t/16_flow.t000066400000000000000000000011201301441720000170270ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 2; { my $flow = Slic3r::Flow->new_from_width( role => Slic3r::Flow::FLOW_ROLE_PERIMETER, width => '1', nozzle_diameter => 0.5, layer_height => 0.3, bridge_flow_ratio => 1, ); isa_ok $flow, 'Slic3r::Flow', 'new_from_width'; } { my $flow = Slic3r::Flow->new( width => 1, height => 0.4, nozzle_diameter => 0.5, ); isa_ok $flow, 'Slic3r::Flow', 'new'; } __END__ Slic3r-version_1.31.6/xs/t/17_boundingbox.t000066400000000000000000000013461301441720000204110ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 5; { my @points = ( Slic3r::Point->new(100, 200), Slic3r::Point->new(500, -600), ); my $bb = Slic3r::Geometry::BoundingBox->new_from_points(\@points); isa_ok $bb, 'Slic3r::Geometry::BoundingBox', 'new_from_points'; is_deeply $bb->min_point->pp, [100,-600], 'min_point'; is_deeply $bb->max_point->pp, [500,200], 'max_point'; } { my $bb = Slic3r::Geometry::BoundingBox->new; $bb->merge_point(Slic3r::Point->new(10, 10)); is_deeply $bb->min_point->pp, [10,10], 'min_point equals to the only defined point'; is_deeply $bb->max_point->pp, [10,10], 'max_point equals to the only defined point'; } __END__ Slic3r-version_1.31.6/xs/t/18_motionplanner.t000066400000000000000000000072211301441720000207570ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; BEGIN { use FindBin; use lib "$FindBin::Bin/../../lib"; } use Slic3r::XS; use Test::More tests => 20; my $square = Slic3r::Polygon->new( # ccw [100, 100], [200, 100], [200, 200], [100, 200], ); my $hole_in_square = Slic3r::Polygon->new( # cw [140, 140], [140, 160], [160, 160], [160, 140], ); $_->scale(1/0.000001) for $square, $hole_in_square; my $expolygon = Slic3r::ExPolygon->new($square, $hole_in_square); { my $mp = Slic3r::MotionPlanner->new([ $expolygon ]); isa_ok $mp, 'Slic3r::MotionPlanner'; my $from = Slic3r::Point->new(120, 120); my $to = Slic3r::Point->new(180,180); $_->scale(1/0.000001) for $from, $to; my $path = $mp->shortest_path($from, $to); ok $path->is_valid(), 'return path is valid'; ok $path->length > Slic3r::Line->new($from, $to)->length, 'path length is greater than straight line'; ok $path->first_point->coincides_with($from), 'first path point coincides with initial point'; ok $path->last_point->coincides_with($to), 'last path point coincides with destination point'; ok $expolygon->contains_polyline($path), 'path is fully contained in expolygon'; } { my $mp = Slic3r::MotionPlanner->new([ $expolygon ]); isa_ok $mp, 'Slic3r::MotionPlanner'; my $from = Slic3r::Point->new(80, 100); my $to = Slic3r::Point->new(220,200); $_->scale(1/0.000001) for $from, $to; my $path = $mp->shortest_path($from, $to); ok $path->is_valid(), 'return path is valid'; ok $path->length > Slic3r::Line->new($from, $to)->length, 'path length is greater than straight line'; ok $path->first_point->coincides_with($from), 'first path point coincides with initial point'; ok $path->last_point->coincides_with($to), 'last path point coincides with destination point'; is scalar(@{ Slic3r::Geometry::Clipper::intersection_pl([$path], [@$expolygon]) }), 0, 'path has no intersection with expolygon'; } { my $expolygon2 = $expolygon->clone; $expolygon2->translate(300/0.000001, 0); my $mp = Slic3r::MotionPlanner->new([ $expolygon, $expolygon2 ]); isa_ok $mp, 'Slic3r::MotionPlanner'; my $from = Slic3r::Point->new(120, 120); my $to = Slic3r::Point->new(120 + 300, 120); $_->scale(1/0.000001) for $from, $to; ok $expolygon->contains_point($from), 'start point is contained in first expolygon'; ok $expolygon2->contains_point($to), 'end point is contained in second expolygon'; my $path = $mp->shortest_path($from, $to); ok $path->is_valid(), 'return path is valid'; } { my $expolygons = [ Slic3r::ExPolygon->new([[123800962,89330311],[123959159,89699438],[124000004,89898430],[124000012,110116427],[123946510,110343065],[123767391,110701303],[123284087,111000001],[102585791,111000009],[102000004,110414223],[102000004,89585787],[102585790,89000000],[123300022,88999993]]), Slic3r::ExPolygon->new([[97800954,89330311],[97959151,89699438],[97999996,89898430],[98000004,110116427],[97946502,110343065],[97767383,110701303],[97284079,111000001],[76585783,111000009],[75999996,110414223],[75999996,89585787],[76585782,89000000],[97300014,88999993]]), ]; my $mp = Slic3r::MotionPlanner->new($expolygons); isa_ok $mp, 'Slic3r::MotionPlanner'; my $from = Slic3r::Point->new(79120520, 107839491); my $to = Slic3r::Point->new(104664164, 108335852); ok $expolygons->[1]->contains_point($from), 'start point is contained in second expolygon'; ok $expolygons->[0]->contains_point($to), 'end point is contained in first expolygon'; my $path = $mp->shortest_path($from, $to); ok $path->is_valid(), 'return path is valid'; } __END__ Slic3r-version_1.31.6/xs/t/19_model.t000066400000000000000000000011351301441720000171710ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 4; { my $model = Slic3r::Model->new; my $object = $model->_add_object; isa_ok $object, 'Slic3r::Model::Object::Ref'; isa_ok $object->origin_translation, 'Slic3r::Pointf3::Ref'; $object->origin_translation->translate(10,0,0); is_deeply \@{$object->origin_translation}, [10,0,0], 'origin_translation is modified by ref'; my $lhr = [ [ 5, 10, 0.1 ] ]; $object->set_layer_height_ranges($lhr); is_deeply $object->layer_height_ranges, $lhr, 'layer_height_ranges roundtrip'; } __END__ Slic3r-version_1.31.6/xs/t/20_print.t000066400000000000000000000007111301441720000172140ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 5; { my $print = Slic3r::Print->new; isa_ok $print, 'Slic3r::Print'; isa_ok $print->config, 'Slic3r::Config::Static::Ref'; isa_ok $print->default_object_config, 'Slic3r::Config::Static::Ref'; isa_ok $print->default_region_config, 'Slic3r::Config::Static::Ref'; isa_ok $print->placeholder_parser, 'Slic3r::GCode::PlaceholderParser::Ref'; } __END__ Slic3r-version_1.31.6/xs/t/21_gcode.t000066400000000000000000000005661301441720000171520ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 2; { my $gcodegen = Slic3r::GCode->new; $gcodegen->set_origin(Slic3r::Pointf->new(10,0)); is_deeply $gcodegen->origin->pp, [10,0], 'set_origin'; $gcodegen->origin->translate(5,5); is_deeply $gcodegen->origin->pp, [15,5], 'origin returns reference to point'; } __END__ Slic3r-version_1.31.6/xs/t/22_exception.t000066400000000000000000000007021301441720000200600ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use Slic3r::XS; use Test::More tests => 1; if ($ENV{SLIC3R_HAS_BROKEN_CROAK}) { ok 1, 'SLIC3R_HAS_BROKEN_CROAK set, croaks and confesses from a C++ code will lead to an application exit!'; } else { eval { Slic3r::xspp_test_croak_hangs_on_strawberry(); }; is $@, "xspp_test_croak_hangs_on_strawberry: exception catched\n", 'croak from inside a C++ exception delivered'; } __END__ Slic3r-version_1.31.6/xs/xsp/000077500000000000000000000000001301441720000157425ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/xsp/BoundingBox.xsp000066400000000000000000000077171301441720000207300ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/BoundingBox.hpp" #include "libslic3r/Point.hpp" %} %name{Slic3r::Geometry::BoundingBox} class BoundingBox { BoundingBox(); ~BoundingBox(); Clone clone() %code{% RETVAL = THIS; %}; void merge(BoundingBox* bb) %code{% THIS->merge(*bb); %}; void merge_point(Point* point) %code{% THIS->merge(*point); %}; void scale(double factor); void translate(double x, double y); void offset(double delta); bool contains_point(Point* point) %code{% RETVAL = THIS->contains(*point); %}; bool overlap(BoundingBox* bbox) %code{% RETVAL = THIS->overlap(*bbox); %}; Clone polygon(); Clone size(); Clone center(); bool empty() %code{% RETVAL = empty(*THIS); %}; double radius(); Clone min_point() %code{% RETVAL = THIS->min; %}; Clone max_point() %code{% RETVAL = THIS->max; %}; long x_min() %code{% RETVAL = THIS->min.x; %}; long x_max() %code{% RETVAL = THIS->max.x; %}; long y_min() %code{% RETVAL = THIS->min.y; %}; long y_max() %code{% RETVAL = THIS->max.y; %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%ld,%ld;%ld,%ld", THIS->min.x, THIS->min.y, THIS->max.x, THIS->max.y); RETVAL = buf; %}; %{ BoundingBox* new_from_points(CLASS, points) char* CLASS Points points CODE: RETVAL = new BoundingBox(points); OUTPUT: RETVAL %} }; %name{Slic3r::Geometry::BoundingBoxf} class BoundingBoxf { BoundingBoxf(); ~BoundingBoxf(); Clone clone() %code{% RETVAL = THIS; %}; void merge(BoundingBoxf* bb) %code{% THIS->merge(*bb); %}; void merge_point(Pointf* point) %code{% THIS->merge(*point); %}; void scale(double factor); void translate(double x, double y); Clone size(); Clone center(); double radius(); bool empty() %code{% RETVAL = empty(*THIS); %}; Clone min_point() %code{% RETVAL = THIS->min; %}; Clone max_point() %code{% RETVAL = THIS->max; %}; double x_min() %code{% RETVAL = THIS->min.x; %}; double x_max() %code{% RETVAL = THIS->max.x; %}; double y_min() %code{% RETVAL = THIS->min.y; %}; double y_max() %code{% RETVAL = THIS->max.y; %}; void set_x_min(double val) %code{% THIS->min.x = val; %}; void set_x_max(double val) %code{% THIS->max.x = val; %}; void set_y_min(double val) %code{% THIS->min.y = val; %}; void set_y_max(double val) %code{% THIS->max.y = val; %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%lf,%lf;%lf,%lf", THIS->min.x, THIS->min.y, THIS->max.x, THIS->max.y); RETVAL = buf; %}; %{ BoundingBoxf* new_from_points(CLASS, points) char* CLASS Pointfs points CODE: RETVAL = new BoundingBoxf(points); OUTPUT: RETVAL %} }; %name{Slic3r::Geometry::BoundingBoxf3} class BoundingBoxf3 { BoundingBoxf3(); ~BoundingBoxf3(); Clone clone() %code{% RETVAL = THIS; %}; void merge(BoundingBoxf3* bb) %code{% THIS->merge(*bb); %}; void merge_point(Pointf3* point) %code{% THIS->merge(*point); %}; void scale(double factor); void translate(double x, double y, double z); Clone size(); Clone center(); double radius(); bool empty() %code{% RETVAL = empty(*THIS); %}; Clone min_point() %code{% RETVAL = THIS->min; %}; Clone max_point() %code{% RETVAL = THIS->max; %}; double x_min() %code{% RETVAL = THIS->min.x; %}; double x_max() %code{% RETVAL = THIS->max.x; %}; double y_min() %code{% RETVAL = THIS->min.y; %}; double y_max() %code{% RETVAL = THIS->max.y; %}; double z_min() %code{% RETVAL = THIS->min.z; %}; double z_max() %code{% RETVAL = THIS->max.z; %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%lf,%lf,%lf;%lf,%lf,%lf", THIS->min.x, THIS->min.y, THIS->min.z, THIS->max.x, THIS->max.y, THIS->max.z); RETVAL = buf; %}; }; Slic3r-version_1.31.6/xs/xsp/BridgeDetector.xsp000066400000000000000000000022731301441720000213700ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/BridgeDetector.hpp" %} %name{Slic3r::BridgeDetector} class BridgeDetector { ~BridgeDetector(); bool detect_angle(); Polygons coverage(); %name{coverage_by_angle} Polygons coverage(double angle); Polylines unsupported_edges(); %name{unsupported_edges_by_angle} Polylines unsupported_edges(double angle); double angle() %code{% RETVAL = THIS->angle; %}; double resolution() %code{% RETVAL = THIS->resolution; %}; %{ BridgeDetector* BridgeDetector::new(expolygon, lower_slices, extrusion_width) ExPolygon* expolygon; ExPolygonCollection* lower_slices; long extrusion_width; CODE: RETVAL = new BridgeDetector(*expolygon, *lower_slices, extrusion_width); OUTPUT: RETVAL BridgeDetector* BridgeDetector::new_expolygons(expolygons, lower_slices, extrusion_width) ExPolygonCollection* expolygons; ExPolygonCollection* lower_slices; long extrusion_width; CODE: RETVAL = new BridgeDetector(expolygons->expolygons, *lower_slices, extrusion_width); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/Clipper.xsp000066400000000000000000000121761301441720000201030ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "clipper.hpp" #include "libslic3r/ClipperUtils.hpp" %} %package{Slic3r::Geometry::Clipper}; %{ IV _constant() ALIAS: JT_MITER = jtMiter JT_ROUND = jtRound JT_SQUARE = jtSquare CLIPPER_OFFSET_SCALE = CLIPPER_OFFSET_SCALE CODE: RETVAL = ix; OUTPUT: RETVAL Polygons offset(polygons, delta, scale = CLIPPER_OFFSET_SCALE, joinType = ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta double scale ClipperLib::JoinType joinType double miterLimit CODE: offset(polygons, &RETVAL, delta, scale, joinType, miterLimit); OUTPUT: RETVAL ExPolygons offset_ex(polygons, delta, scale = CLIPPER_OFFSET_SCALE, joinType = ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta double scale ClipperLib::JoinType joinType double miterLimit CODE: offset(polygons, &RETVAL, delta, scale, joinType, miterLimit); OUTPUT: RETVAL Polygons offset2(polygons, delta1, delta2, scale = CLIPPER_OFFSET_SCALE, joinType = ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta1 const float delta2 double scale ClipperLib::JoinType joinType double miterLimit CODE: offset2(polygons, &RETVAL, delta1, delta2, scale, joinType, miterLimit); OUTPUT: RETVAL ExPolygons offset2_ex(polygons, delta1, delta2, scale = CLIPPER_OFFSET_SCALE, joinType = ClipperLib::jtMiter, miterLimit = 3) Polygons polygons const float delta1 const float delta2 double scale ClipperLib::JoinType joinType double miterLimit CODE: offset2(polygons, &RETVAL, delta1, delta2, scale, joinType, miterLimit); OUTPUT: RETVAL Polygons diff(subject, clip, safety_offset = false) Polygons subject Polygons clip bool safety_offset CODE: diff(subject, clip, &RETVAL, safety_offset); OUTPUT: RETVAL ExPolygons diff_ex(subject, clip, safety_offset = false) Polygons subject Polygons clip bool safety_offset CODE: diff(subject, clip, &RETVAL, safety_offset); OUTPUT: RETVAL Polylines diff_pl(subject, clip) Polylines subject Polygons clip CODE: diff(subject, clip, &RETVAL); OUTPUT: RETVAL Polylines diff_ppl(subject, clip) Polygons subject Polygons clip CODE: diff(subject, clip, &RETVAL); OUTPUT: RETVAL Polygons intersection(subject, clip, safety_offset = false) Polygons subject Polygons clip bool safety_offset CODE: intersection(subject, clip, &RETVAL, safety_offset); OUTPUT: RETVAL ExPolygons intersection_ex(subject, clip, safety_offset = false) Polygons subject Polygons clip bool safety_offset CODE: intersection(subject, clip, &RETVAL, safety_offset); OUTPUT: RETVAL Polylines intersection_pl(subject, clip) Polylines subject Polygons clip CODE: intersection(subject, clip, &RETVAL); OUTPUT: RETVAL Polylines intersection_ppl(subject, clip) Polygons subject Polygons clip CODE: intersection(subject, clip, &RETVAL); OUTPUT: RETVAL ExPolygons xor_ex(subject, clip, safety_offset = false) Polygons subject Polygons clip bool safety_offset CODE: xor_(subject, clip, &RETVAL, safety_offset); OUTPUT: RETVAL Polygons union(subject, safety_offset = false) Polygons subject bool safety_offset CODE: union_(subject, &RETVAL, safety_offset); OUTPUT: RETVAL ExPolygons union_ex(subject, safety_offset = false) Polygons subject bool safety_offset CODE: union_(subject, &RETVAL, safety_offset); OUTPUT: RETVAL SV* union_pt(subject, safety_offset = false) Polygons subject bool safety_offset CODE: // perform operation ClipperLib::PolyTree polytree; union_pt(subject, &polytree, safety_offset); RETVAL = polynode_children_2_perl(polytree); OUTPUT: RETVAL Polygons union_pt_chained(subject, safety_offset = false) Polygons subject bool safety_offset CODE: union_pt_chained(subject, &RETVAL, safety_offset); OUTPUT: RETVAL Polygons simplify_polygons(subject) Polygons subject CODE: simplify_polygons(subject, &RETVAL); OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/Config.xsp000066400000000000000000000223111301441720000177020ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/PrintConfig.hpp" %} %name{Slic3r::Config} class DynamicPrintConfig { DynamicPrintConfig(); ~DynamicPrintConfig(); bool has(t_config_option_key opt_key); SV* as_hash() %code{% RETVAL = ConfigBase__as_hash(THIS); %}; SV* get(t_config_option_key opt_key) %code{% RETVAL = ConfigBase__get(THIS, opt_key); %}; SV* get_at(t_config_option_key opt_key, int i) %code{% RETVAL = ConfigBase__get_at(THIS, opt_key, i); %}; bool set(t_config_option_key opt_key, SV* value) %code{% RETVAL = ConfigBase__set(THIS, opt_key, value); %}; bool set_deserialize(t_config_option_key opt_key, SV* str) %code{% RETVAL = ConfigBase__set_deserialize(THIS, opt_key, str); %}; void set_ifndef(t_config_option_key opt_key, SV* value, bool deserialize = false) %code{% ConfigBase__set_ifndef(THIS, opt_key, value, deserialize); %}; std::string serialize(t_config_option_key opt_key); double get_abs_value(t_config_option_key opt_key); %name{get_abs_value_over} double get_abs_value(t_config_option_key opt_key, double ratio_over); void apply(DynamicPrintConfig* other) %code{% THIS->apply(*other, true); %}; std::vector diff(DynamicPrintConfig* other) %code{% RETVAL = THIS->diff(*other); %}; bool equals(DynamicPrintConfig* other) %code{% RETVAL = THIS->equals(*other); %}; void apply_static(StaticPrintConfig* other) %code{% THIS->apply(*other, true); %}; %name{get_keys} std::vector keys(); void erase(t_config_option_key opt_key); void normalize(); %name{setenv} void setenv_(); double min_object_distance(); }; %name{Slic3r::Config::Static} class StaticPrintConfig { static StaticPrintConfig* new_GCodeConfig() %code{% RETVAL = new GCodeConfig (); %}; static StaticPrintConfig* new_PrintConfig() %code{% RETVAL = new PrintConfig (); %}; static StaticPrintConfig* new_PrintObjectConfig() %code{% RETVAL = new PrintObjectConfig (); %}; static StaticPrintConfig* new_PrintRegionConfig() %code{% RETVAL = new PrintRegionConfig (); %}; static StaticPrintConfig* new_FullPrintConfig() %code{% RETVAL = new FullPrintConfig (); %}; ~StaticPrintConfig(); bool has(t_config_option_key opt_key); SV* as_hash() %code{% RETVAL = ConfigBase__as_hash(THIS); %}; SV* get(t_config_option_key opt_key) %code{% RETVAL = ConfigBase__get(THIS, opt_key); %}; SV* get_at(t_config_option_key opt_key, int i) %code{% RETVAL = ConfigBase__get_at(THIS, opt_key, i); %}; bool set(t_config_option_key opt_key, SV* value) %code{% RETVAL = StaticConfig__set(THIS, opt_key, value); %}; bool set_deserialize(t_config_option_key opt_key, SV* str) %code{% RETVAL = ConfigBase__set_deserialize(THIS, opt_key, str); %}; void set_ifndef(t_config_option_key opt_key, SV* value, bool deserialize = false) %code{% ConfigBase__set_ifndef(THIS, opt_key, value, deserialize); %}; std::string serialize(t_config_option_key opt_key); double get_abs_value(t_config_option_key opt_key); %name{get_abs_value_over} double get_abs_value(t_config_option_key opt_key, double ratio_over); void apply_static(StaticPrintConfig* other) %code{% THIS->apply(*other, true); %}; void apply_dynamic(DynamicPrintConfig* other) %code{% THIS->apply(*other, true); %}; %name{get_keys} std::vector keys(); std::string get_extrusion_axis() %code{% if (GCodeConfig* config = dynamic_cast(THIS)) { RETVAL = config->get_extrusion_axis(); } else { CONFESS("This StaticConfig object does not provide get_extrusion_axis()"); } %}; %name{setenv} void setenv_(); double min_object_distance(); }; %package{Slic3r::Config}; %{ PROTOTYPES: DISABLE SV* print_config_def() CODE: t_optiondef_map &def = Slic3r::print_config_def.options; HV* options_hv = newHV(); for (t_optiondef_map::iterator oit = def.begin(); oit != def.end(); ++oit) { HV* hv = newHV(); t_config_option_key opt_key = oit->first; ConfigOptionDef* optdef = &oit->second; const char* opt_type; if (optdef->type == coFloat || optdef->type == coFloats || optdef->type == coFloatOrPercent) { opt_type = "f"; } else if (optdef->type == coPercent) { opt_type = "percent"; } else if (optdef->type == coInt || optdef->type == coInts) { opt_type = "i"; } else if (optdef->type == coString) { opt_type = "s"; } else if (optdef->type == coStrings) { opt_type = "s@"; } else if (optdef->type == coPoint || optdef->type == coPoints) { opt_type = "point"; } else if (optdef->type == coBool || optdef->type == coBools) { opt_type = "bool"; } else if (optdef->type == coEnum) { opt_type = "select"; } else { throw "Unknown option type"; } (void)hv_stores( hv, "type", newSVpv(opt_type, 0) ); (void)hv_stores( hv, "gui_type", newSVpvn(optdef->gui_type.c_str(), optdef->gui_type.length()) ); (void)hv_stores( hv, "gui_flags", newSVpvn(optdef->gui_flags.c_str(), optdef->gui_flags.length()) ); (void)hv_stores( hv, "label", newSVpvn_utf8(optdef->label.c_str(), optdef->label.length(), true) ); if (!optdef->full_label.empty()) (void)hv_stores( hv, "full_label", newSVpvn_utf8(optdef->full_label.c_str(), optdef->full_label.length(), true) ); (void)hv_stores( hv, "category", newSVpvn(optdef->category.c_str(), optdef->category.length()) ); (void)hv_stores( hv, "tooltip", newSVpvn_utf8(optdef->tooltip.c_str(), optdef->tooltip.length(), true) ); (void)hv_stores( hv, "sidetext", newSVpvn_utf8(optdef->sidetext.c_str(), optdef->sidetext.length(), true) ); (void)hv_stores( hv, "cli", newSVpvn(optdef->cli.c_str(), optdef->cli.length()) ); (void)hv_stores( hv, "ratio_over", newSVpvn(optdef->ratio_over.c_str(), optdef->ratio_over.length()) ); (void)hv_stores( hv, "multiline", newSViv(optdef->multiline ? 1 : 0) ); (void)hv_stores( hv, "full_width", newSViv(optdef->full_width ? 1 : 0) ); (void)hv_stores( hv, "readonly", newSViv(optdef->readonly ? 1 : 0) ); (void)hv_stores( hv, "height", newSViv(optdef->height) ); (void)hv_stores( hv, "width", newSViv(optdef->width) ); (void)hv_stores( hv, "min", newSViv(optdef->min) ); (void)hv_stores( hv, "max", newSViv(optdef->max) ); // aliases if (!optdef->aliases.empty()) { AV* av = newAV(); av_fill(av, optdef->aliases.size()-1); for (std::vector::iterator it = optdef->aliases.begin(); it != optdef->aliases.end(); ++it) av_store(av, it - optdef->aliases.begin(), newSVpvn(it->c_str(), it->length())); (void)hv_stores( hv, "aliases", newRV_noinc((SV*)av) ); } // shortcut if (!optdef->shortcut.empty()) { AV* av = newAV(); av_fill(av, optdef->shortcut.size()-1); for (std::vector::iterator it = optdef->shortcut.begin(); it != optdef->shortcut.end(); ++it) av_store(av, it - optdef->shortcut.begin(), newSVpvn(it->c_str(), it->length())); (void)hv_stores( hv, "shortcut", newRV_noinc((SV*)av) ); } // enum_values if (!optdef->enum_values.empty()) { AV* av = newAV(); av_fill(av, optdef->enum_values.size()-1); for (std::vector::iterator it = optdef->enum_values.begin(); it != optdef->enum_values.end(); ++it) av_store(av, it - optdef->enum_values.begin(), newSVpvn(it->c_str(), it->length())); (void)hv_stores( hv, "values", newRV_noinc((SV*)av) ); } // enum_labels if (!optdef->enum_labels.empty()) { AV* av = newAV(); av_fill(av, optdef->enum_labels.size()-1); for (std::vector::iterator it = optdef->enum_labels.begin(); it != optdef->enum_labels.end(); ++it) av_store(av, it - optdef->enum_labels.begin(), newSVpvn_utf8(it->c_str(), it->length(), true)); (void)hv_stores( hv, "labels", newRV_noinc((SV*)av) ); } if (optdef->default_value != NULL) (void)hv_stores( hv, "default", ConfigOption_to_SV(*optdef->default_value, *optdef) ); (void)hv_store( options_hv, opt_key.c_str(), opt_key.length(), newRV_noinc((SV*)hv), 0 ); } RETVAL = newRV_noinc((SV*)options_hv); OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/ExPolygon.xsp000066400000000000000000000037521301441720000204310ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/ExPolygon.hpp" %} %name{Slic3r::ExPolygon} class ExPolygon { ~ExPolygon(); Clone clone() %code{% RETVAL = THIS; %}; SV* arrayref() %code{% RETVAL = to_AV(THIS); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(THIS); %}; Ref contour() %code{% RETVAL = &(THIS->contour); %}; Polygons* holes() %code{% RETVAL = &(THIS->holes); %}; void scale(double factor); void translate(double x, double y); double area(); bool is_valid(); bool contains_line(Line* line) %code{% RETVAL = THIS->contains(*line); %}; bool contains_polyline(Polyline* polyline) %code{% RETVAL = THIS->contains(*polyline); %}; bool contains_point(Point* point) %code{% RETVAL = THIS->contains(*point); %}; ExPolygons simplify(double tolerance); Polygons simplify_p(double tolerance); Polylines medial_axis(double max_width, double min_width) %code{% THIS->medial_axis(max_width, min_width, &RETVAL); %}; Polygons get_trapezoids(double angle) %code{% THIS->get_trapezoids(&RETVAL, angle); %}; Polygons get_trapezoids2(double angle) %code{% THIS->get_trapezoids2(&RETVAL, angle); %}; Polygons triangulate() %code{% THIS->triangulate(&RETVAL); %}; Polygons triangulate_pp() %code{% THIS->triangulate_pp(&RETVAL); %}; %{ ExPolygon* ExPolygon::new(...) CODE: RETVAL = new ExPolygon (); // ST(0) is class name, ST(1) is contour and others are holes from_SV_check(ST(1), &RETVAL->contour); RETVAL->holes.resize(items-2); for (unsigned int i = 2; i < items; i++) { from_SV_check(ST(i), &RETVAL->holes[i-2]); } OUTPUT: RETVAL void ExPolygon::rotate(angle, center_sv) double angle; SV* center_sv; CODE: Point center; from_SV_check(center_sv, ¢er); THIS->rotate(angle, center); %} }; Slic3r-version_1.31.6/xs/xsp/ExPolygonCollection.xsp000066400000000000000000000044741301441720000224470ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/ExPolygonCollection.hpp" %} %name{Slic3r::ExPolygon::Collection} class ExPolygonCollection { ~ExPolygonCollection(); Clone clone() %code{% RETVAL = THIS; %}; void clear() %code{% THIS->expolygons.clear(); %}; void scale(double factor); void translate(double x, double y); void rotate(double angle, Point* center) %code{% THIS->rotate(angle, *center); %}; int count() %code{% RETVAL = THIS->expolygons.size(); %}; bool contains_point(Point* point) %code{% RETVAL = THIS->contains(*point); %}; bool contains_line(Line* line) %code{% RETVAL = THIS->contains(*line); %}; bool contains_polyline(Polyline* polyline) %code{% RETVAL = THIS->contains(*polyline); %}; void simplify(double tolerance); Polygons polygons() %code{% RETVAL = *THIS; %}; Clone convex_hull(); %{ ExPolygonCollection* ExPolygonCollection::new(...) CODE: RETVAL = new ExPolygonCollection (); // ST(0) is class name, others are expolygons RETVAL->expolygons.resize(items-1); for (unsigned int i = 1; i < items; i++) { // Note: a COPY of the input is stored from_SV_check(ST(i), &RETVAL->expolygons[i-1]); } OUTPUT: RETVAL SV* ExPolygonCollection::arrayref() CODE: AV* av = newAV(); av_fill(av, THIS->expolygons.size()-1); int i = 0; for (ExPolygons::iterator it = THIS->expolygons.begin(); it != THIS->expolygons.end(); ++it) { av_store(av, i++, perl_to_SV_ref(*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL SV* ExPolygonCollection::pp() CODE: AV* av = newAV(); av_fill(av, THIS->expolygons.size()-1); int i = 0; for (ExPolygons::iterator it = THIS->expolygons.begin(); it != THIS->expolygons.end(); ++it) { av_store(av, i++, to_SV_pureperl(&*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL void ExPolygonCollection::append(...) CODE: for (unsigned int i = 1; i < items; i++) { ExPolygon expolygon; from_SV_check(ST(i), &expolygon); THIS->expolygons.push_back(expolygon); } %} }; Slic3r-version_1.31.6/xs/xsp/Extruder.xsp000066400000000000000000000031501301441720000202770ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Extruder.hpp" %} %name{Slic3r::Extruder} class Extruder { Extruder(unsigned int id, StaticPrintConfig* config) %code%{ RETVAL = new Extruder (id, dynamic_cast(config)); %}; ~Extruder(); void reset(); double extrude(double dE); double retract(double length, double restart_extra); double unretract(); double e_per_mm(double mm3_per_mm); double extruded_volume(); double used_filament(); unsigned int id() %code%{ RETVAL = THIS->id; %}; double E() %code%{ RETVAL = THIS->E; %}; double set_E(double val) %code%{ RETVAL = THIS->E = val; %}; double absolute_E() %code%{ RETVAL = THIS->absolute_E; %}; double set_absolute_E(double val) %code%{ RETVAL = THIS->absolute_E = val; %}; double retracted() %code%{ RETVAL = THIS->retracted; %}; double set_retracted(double val) %code%{ RETVAL = THIS->retracted = val; %}; double restart_extra() %code%{ RETVAL = THIS->restart_extra; %}; double set_restart_extra(double val) %code%{ RETVAL = THIS->restart_extra = val; %}; double e_per_mm3() %code%{ RETVAL = THIS->e_per_mm3; %}; double retract_speed_mm_min() %code%{ RETVAL = THIS->retract_speed_mm_min; %}; double filament_diameter(); double extrusion_multiplier(); double retract_length(); double retract_lift(); int retract_speed(); double retract_restart_extra(); double retract_length_toolchange(); double retract_restart_extra_toolchange(); }; Slic3r-version_1.31.6/xs/xsp/ExtrusionEntityCollection.xsp000066400000000000000000000074571301441720000237240ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/ExtrusionEntityCollection.hpp" %} %name{Slic3r::ExtrusionPath::Collection} class ExtrusionEntityCollection { %name{_new} ExtrusionEntityCollection(); ~ExtrusionEntityCollection(); Clone clone() %code{% RETVAL = THIS->clone(); %}; void reverse(); void clear(); ExtrusionEntityCollection* chained_path(bool no_reverse) %code{% RETVAL = new ExtrusionEntityCollection(); THIS->chained_path(RETVAL, no_reverse); %}; ExtrusionEntityCollection* chained_path_from(Point* start_near, bool no_reverse) %code{% RETVAL = new ExtrusionEntityCollection(); THIS->chained_path_from(*start_near, RETVAL, no_reverse); %}; Clone first_point(); Clone last_point(); int count() %code{% RETVAL = THIS->entities.size(); %}; int items_count() %code{% RETVAL = THIS->items_count(); %}; ExtrusionEntityCollection* flatten() %code{% RETVAL = new ExtrusionEntityCollection(); THIS->flatten(RETVAL); %}; double min_mm3_per_mm(); bool empty() %code{% RETVAL = THIS->entities.empty(); %}; std::vector orig_indices() %code{% RETVAL = THIS->orig_indices; %}; Polygons polygons_covered_by_width(); Polygons polygons_covered_by_spacing(); %{ SV* ExtrusionEntityCollection::arrayref() CODE: AV* av = newAV(); av_fill(av, THIS->entities.size()-1); int i = 0; for (ExtrusionEntitiesPtr::iterator it = THIS->entities.begin(); it != THIS->entities.end(); ++it) { SV* sv = newSV(0); // return our item by reference if (ExtrusionPath* path = dynamic_cast(*it)) { sv_setref_pv( sv, perl_class_name_ref(path), path ); } else if (ExtrusionLoop* loop = dynamic_cast(*it)) { sv_setref_pv( sv, perl_class_name_ref(loop), loop ); } else if (ExtrusionEntityCollection* collection = dynamic_cast(*it)) { sv_setref_pv( sv, perl_class_name_ref(collection), collection ); } else { croak("Unexpected type in ExtrusionEntityCollection"); } av_store(av, i++, sv); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL void ExtrusionEntityCollection::append(...) CODE: for (unsigned int i = 1; i < items; i++) { if(!sv_isobject( ST(i) ) || (SvTYPE(SvRV( ST(i) )) != SVt_PVMG)) { croak("Argument %d is not object", i); } ExtrusionEntity* entity = (ExtrusionEntity *)SvIV((SV*)SvRV( ST(i) )); // append COPIES if (ExtrusionPath* path = dynamic_cast(entity)) { THIS->entities.push_back( new ExtrusionPath(*path) ); } else if (ExtrusionLoop* loop = dynamic_cast(entity)) { THIS->entities.push_back( new ExtrusionLoop(*loop) ); } else if(ExtrusionEntityCollection* collection = dynamic_cast(entity)) { THIS->entities.push_back( collection->clone() ); } else { croak("Argument %d is of unknown type", i); } } bool ExtrusionEntityCollection::no_sort(...) CODE: if (items > 1) { THIS->no_sort = SvTRUE(ST(1)); } RETVAL = THIS->no_sort; OUTPUT: RETVAL ExtrusionEntityCollection* ExtrusionEntityCollection::chained_path_indices(bool no_reverse) CODE: RETVAL = new ExtrusionEntityCollection(); THIS->chained_path(RETVAL, no_reverse, &RETVAL->orig_indices); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/ExtrusionLoop.xsp000066400000000000000000000036371301441720000213410ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/ExtrusionEntity.hpp" %} %name{Slic3r::ExtrusionLoop} class ExtrusionLoop { ExtrusionLoop(); ~ExtrusionLoop(); Clone clone() %code{% RETVAL = THIS; %}; void reverse(); bool make_clockwise(); bool make_counter_clockwise(); Clone first_point(); Clone last_point(); Clone polygon(); void append(ExtrusionPath* path) %code{% THIS->paths.push_back(*path); %}; double length(); bool split_at_vertex(Point* point) %code{% RETVAL = THIS->split_at_vertex(*point); %}; void split_at(Point* point) %code{% THIS->split_at(*point); %}; ExtrusionPaths clip_end(double distance) %code{% THIS->clip_end(distance, &RETVAL); %}; bool has_overhang_point(Point* point) %code{% RETVAL = THIS->has_overhang_point(*point); %}; bool is_perimeter(); bool is_infill(); bool is_solid_infill(); Polygons polygons_covered_by_width(); Polygons polygons_covered_by_spacing(); %{ SV* ExtrusionLoop::arrayref() CODE: AV* av = newAV(); av_fill(av, THIS->paths.size()-1); for (ExtrusionPaths::iterator it = THIS->paths.begin(); it != THIS->paths.end(); ++it) { av_store(av, it - THIS->paths.begin(), perl_to_SV_ref(*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL ExtrusionLoopRole ExtrusionLoop::role(...) CODE: if (items > 1) { THIS->role = (ExtrusionLoopRole)SvUV(ST(1)); } RETVAL = THIS->role; OUTPUT: RETVAL %} }; %package{Slic3r::ExtrusionLoop}; %{ IV _constant() ALIAS: EXTRL_ROLE_DEFAULT = elrDefault EXTRL_ROLE_CONTOUR_INTERNAL_PERIMETER = elrContourInternalPerimeter EXTRL_ROLE_SKIRT = elrSkirt PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/ExtrusionPath.xsp000066400000000000000000000074571301441720000213300ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/ExtrusionEntity.hpp" #include "libslic3r/ExtrusionEntityCollection.hpp" %} %name{Slic3r::ExtrusionPath} class ExtrusionPath { ~ExtrusionPath(); SV* arrayref() %code{% RETVAL = to_AV(&THIS->polyline); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(&THIS->polyline); %}; void pop_back() %code{% THIS->polyline.points.pop_back(); %}; void reverse(); Lines lines() %code{% RETVAL = THIS->polyline.lines(); %}; Clone first_point(); Clone last_point(); void clip_end(double distance); void simplify(double tolerance); double length(); bool is_perimeter(); bool is_infill(); bool is_solid_infill(); bool is_bridge(); Polygons polygons_covered_by_width(); Polygons polygons_covered_by_spacing(); %{ ExtrusionPath* _new(CLASS, polyline_sv, role, mm3_per_mm, width, height) char* CLASS; SV* polyline_sv; ExtrusionRole role; double mm3_per_mm; float width; float height; CODE: RETVAL = new ExtrusionPath (role); from_SV_check(polyline_sv, &RETVAL->polyline); RETVAL->mm3_per_mm = mm3_per_mm; RETVAL->width = width; RETVAL->height = height; OUTPUT: RETVAL Ref ExtrusionPath::polyline(...) CODE: if (items > 1) { from_SV_check(ST(1), &THIS->polyline); } RETVAL = &(THIS->polyline); OUTPUT: RETVAL ExtrusionRole ExtrusionPath::role(...) CODE: if (items > 1) { THIS->role = (ExtrusionRole)SvUV(ST(1)); } RETVAL = THIS->role; OUTPUT: RETVAL double ExtrusionPath::mm3_per_mm(...) CODE: if (items > 1) { THIS->mm3_per_mm = (double)SvNV(ST(1)); } RETVAL = THIS->mm3_per_mm; OUTPUT: RETVAL float ExtrusionPath::width(...) CODE: if (items > 1) { THIS->width = (float)SvNV(ST(1)); } RETVAL = THIS->width; OUTPUT: RETVAL float ExtrusionPath::height(...) CODE: if (items > 1) { THIS->height = (float)SvNV(ST(1)); } RETVAL = THIS->height; OUTPUT: RETVAL void ExtrusionPath::append(...) CODE: for (unsigned int i = 1; i < items; i++) { Point p; from_SV_check(ST(i), &p); THIS->polyline.points.push_back(p); } ExtrusionEntityCollection* ExtrusionPath::intersect_expolygons(ExPolygonCollection* collection) CODE: RETVAL = new ExtrusionEntityCollection (); THIS->intersect_expolygons(*collection, RETVAL); OUTPUT: RETVAL ExtrusionEntityCollection* ExtrusionPath::subtract_expolygons(ExPolygonCollection* collection) CODE: RETVAL = new ExtrusionEntityCollection (); THIS->subtract_expolygons(*collection, RETVAL); OUTPUT: RETVAL %} }; %package{Slic3r::ExtrusionPath}; %{ IV _constant() ALIAS: EXTR_ROLE_NONE = erNone EXTR_ROLE_PERIMETER = erPerimeter EXTR_ROLE_EXTERNAL_PERIMETER = erExternalPerimeter EXTR_ROLE_OVERHANG_PERIMETER = erOverhangPerimeter EXTR_ROLE_FILL = erInternalInfill EXTR_ROLE_SOLIDFILL = erSolidInfill EXTR_ROLE_TOPSOLIDFILL = erTopSolidInfill EXTR_ROLE_BRIDGE = erBridgeInfill EXTR_ROLE_GAPFILL = erGapFill EXTR_ROLE_SKIRT = erSkirt EXTR_ROLE_SUPPORTMATERIAL = erSupportMaterial EXTR_ROLE_SUPPORTMATERIAL_INTERFACE = erSupportMaterialInterface PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/ExtrusionSimulator.xsp000066400000000000000000000026631301441720000224050ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/ExtrusionSimulator.hpp" %} %name{Slic3r::ExtrusionSimulator} class ExtrusionSimulator { ~ExtrusionSimulator(); %name{_new} ExtrusionSimulator(); Clone clone() %code{% RETVAL = THIS; %}; void set_image_size(Point *image_size) %code{% THIS->set_image_size(*image_size); %}; void set_viewport(BoundingBox *viewport) %code{% THIS->set_viewport(*viewport); %}; void set_bounding_box(BoundingBox *bbox) %code{% THIS->set_bounding_box(*bbox); %}; void reset_accumulator(); void extrude_to_accumulator(ExtrusionPath *path, Point *shift, ExtrusionSimulationType simulationType) %code{% THIS->extrude_to_accumulator(*path, *shift, simulationType); %}; void evaluate_accumulator(ExtrusionSimulationType simulationType); void* image_ptr() %code{% RETVAL = const_cast(const_cast(THIS)->image_ptr()); %}; %{ %} }; %package{Slic3r::ExtrusionSimulator}; %{ IV _constant() ALIAS: EXTRSIM_SIMPLE = ExtrusionSimulationSimple EXTRSIM_DONT_SPREAD = ExtrusionSimulationDontSpread EXTRSIM_SPREAD_NFULL = ExtrisopmSimulationSpreadNotOverfilled EXTRSIM_SPREAD_FULL = ExtrusionSimulationSpreadFull EXTRSIM_SPREAD_EXCESS = ExtrusionSimulationSpreadExcess PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/Filler.xsp000066400000000000000000000044631301441720000177220ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Fill/Fill.hpp" #include "libslic3r/PolylineCollection.hpp" #include "libslic3r/ExtrusionEntity.hpp" #include "libslic3r/ExtrusionEntityCollection.hpp" %} %name{Slic3r::Filler} class Filler { ~Filler(); void set_bounding_box(BoundingBox *bbox) %code{% THIS->fill->set_bounding_box(*bbox); %}; void set_spacing(coordf_t spacing) %code{% THIS->fill->spacing = spacing; %}; coordf_t spacing() %code{% RETVAL = THIS->fill->spacing; %}; void set_layer_id(size_t layer_id) %code{% THIS->fill->layer_id = layer_id; %}; void set_z(coordf_t z) %code{% THIS->fill->z = z; %}; void set_angle(float angle) %code{% THIS->fill->angle = angle; %}; void set_link_max_length(coordf_t len) %code{% THIS->fill->link_max_length = len; %}; void set_loop_clipping(coordf_t clipping) %code{% THIS->fill->loop_clipping = clipping; %}; bool use_bridge_flow() %code{% RETVAL = THIS->fill->use_bridge_flow(); %}; bool no_sort() %code{% RETVAL = THIS->fill->no_sort(); %}; void set_density(float density) %code{% THIS->params.density = density; %}; void set_dont_connect(bool dont_connect) %code{% THIS->params.dont_connect = dont_connect; %}; void set_dont_adjust(bool dont_adjust) %code{% THIS->params.dont_adjust = dont_adjust; %}; void set_complete(bool complete) %code{% THIS->params.complete = complete; %}; PolylineCollection* _fill_surface(Surface *surface) %code{% PolylineCollection *pc = NULL; if (THIS->fill != NULL) { pc = new PolylineCollection(); pc->polylines = THIS->fill->fill_surface(surface, THIS->params); } RETVAL = pc; %}; %{ Filler* new_from_type(CLASS, type) char* CLASS; std::string type; CODE: Filler *filler = new Filler(); filler->fill = Fill::new_from_type(type); RETVAL = filler; OUTPUT: RETVAL void make_fill(CLASS, layer_region, out_append) char* CLASS; LayerRegion* layer_region; ExtrusionEntityCollection* out_append; CODE: make_fill(*layer_region, *out_append); %} }; Slic3r-version_1.31.6/xs/xsp/Flow.xsp000066400000000000000000000043521301441720000174110ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Flow.hpp" %} %name{Slic3r::Flow} class Flow { ~Flow(); %name{_new} Flow(float width, float height, float nozzle_diameter); void set_height(float height) %code{% THIS->height = height; %}; void set_bridge(bool bridge) %code{% THIS->bridge = bridge; %}; Clone clone() %code{% RETVAL = THIS; %}; float width() %code{% RETVAL = THIS->width; %}; float height() %code{% RETVAL = THIS->height; %}; float nozzle_diameter() %code{% RETVAL = THIS->nozzle_diameter; %}; bool bridge() %code{% RETVAL = THIS->bridge; %}; float spacing(); float spacing_to(Flow* other) %code{% RETVAL = THIS->spacing(*other); %}; long scaled_width(); long scaled_spacing(); double mm3_per_mm(); %{ Flow* _new_from_width(CLASS, role, width, nozzle_diameter, height, bridge_flow_ratio) char* CLASS; FlowRole role; std::string width; float nozzle_diameter; float height; float bridge_flow_ratio; CODE: ConfigOptionFloatOrPercent optwidth; optwidth.deserialize(width); RETVAL = new Flow(Flow::new_from_config_width(role, optwidth, nozzle_diameter, height, bridge_flow_ratio)); OUTPUT: RETVAL Flow* _new_from_spacing(CLASS, spacing, nozzle_diameter, height, bridge) char* CLASS; float spacing; float nozzle_diameter; float height; bool bridge; CODE: RETVAL = new Flow(Flow::new_from_spacing(spacing, nozzle_diameter, height, bridge)); OUTPUT: RETVAL %} }; %package{Slic3r::Flow}; %{ IV _constant() ALIAS: FLOW_ROLE_EXTERNAL_PERIMETER = frExternalPerimeter FLOW_ROLE_PERIMETER = frPerimeter FLOW_ROLE_INFILL = frInfill FLOW_ROLE_SOLID_INFILL = frSolidInfill FLOW_ROLE_TOP_SOLID_INFILL = frTopSolidInfill FLOW_ROLE_SUPPORT_MATERIAL = frSupportMaterial FLOW_ROLE_SUPPORT_MATERIAL_INTERFACE = frSupportMaterialInterface PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/GCode.xsp000066400000000000000000000150421301441720000174610ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/GCode.hpp" %} %name{Slic3r::GCode::AvoidCrossingPerimeters} class AvoidCrossingPerimeters { AvoidCrossingPerimeters(); ~AvoidCrossingPerimeters(); void init_external_mp(ExPolygons islands); void init_layer_mp(ExPolygons islands); Clone travel_to(GCode* gcode, Point* point) %code{% RETVAL = THIS->travel_to(*gcode, *point); %}; bool use_external_mp() %code{% RETVAL = THIS->use_external_mp; %}; void set_use_external_mp(bool value) %code{% THIS->use_external_mp = value; %}; bool use_external_mp_once() %code{% RETVAL = THIS->use_external_mp_once; %}; void set_use_external_mp_once(bool value) %code{% THIS->use_external_mp_once = value; %}; bool disable_once() %code{% RETVAL = THIS->disable_once; %}; void set_disable_once(bool value) %code{% THIS->disable_once = value; %}; }; %name{Slic3r::GCode::OozePrevention} class OozePrevention { OozePrevention(); ~OozePrevention(); bool enable() %code{% RETVAL = THIS->enable; %}; void set_enable(bool value) %code{% THIS->enable = value; %}; Points standby_points() %code{% RETVAL = THIS->standby_points; %}; void set_standby_points(Points points) %code{% THIS->standby_points = points; %}; std::string pre_toolchange(GCode* gcodegen) %code{% RETVAL = THIS->pre_toolchange(*gcodegen); %}; std::string post_toolchange(GCode* gcodegen) %code{% RETVAL = THIS->post_toolchange(*gcodegen); %}; }; %name{Slic3r::GCode::Wipe} class Wipe { Wipe(); ~Wipe(); bool has_path(); void reset_path(); std::string wipe(GCode* gcodegen, bool toolchange = false) %code{% RETVAL = THIS->wipe(*gcodegen, toolchange); %}; bool enable() %code{% RETVAL = THIS->enable; %}; void set_enable(bool value) %code{% THIS->enable = value; %}; Ref path() %code{% RETVAL = &(THIS->path); %}; void set_path(Polyline* value) %code{% THIS->path = *value; %}; }; %name{Slic3r::GCode} class GCode { GCode(); ~GCode(); Ref origin() %code{% RETVAL = &(THIS->origin); %}; Ref config() %code{% RETVAL = &(THIS->config); %}; Ref writer() %code{% RETVAL = &(THIS->writer); %}; Ref placeholder_parser() %code{% RETVAL = THIS->placeholder_parser; %}; void set_placeholder_parser(PlaceholderParser* ptr) %code{% THIS->placeholder_parser = ptr; %}; Ref ooze_prevention() %code{% RETVAL = &(THIS->ooze_prevention); %}; Ref wipe() %code{% RETVAL = &(THIS->wipe); %}; Ref avoid_crossing_perimeters() %code{% RETVAL = &(THIS->avoid_crossing_perimeters); %}; bool enable_loop_clipping() %code{% RETVAL = THIS->enable_loop_clipping; %}; void set_enable_loop_clipping(bool value) %code{% THIS->enable_loop_clipping = value; %}; bool enable_cooling_markers() %code{% RETVAL = THIS->enable_cooling_markers; %}; void set_enable_cooling_markers(bool value) %code{% THIS->enable_cooling_markers = value; %}; bool enable_extrusion_role_markers() %code{% RETVAL = THIS->enable_extrusion_role_markers; %}; void set_enable_extrusion_role_markers(bool value) %code{% THIS->enable_extrusion_role_markers = value; %}; int layer_count() %code{% RETVAL = THIS->layer_count; %}; void set_layer_count(int value) %code{% THIS->layer_count = value; %}; int layer_index() %code{% RETVAL = THIS->layer_index; %}; void set_layer_index(int value) %code{% THIS->layer_index = value; %}; bool has_layer() %code{% RETVAL = THIS->layer != NULL; %}; Ref layer() %code{% RETVAL = THIS->layer; %}; void set_layer(Layer* ptr) %code{% THIS->layer = ptr; %}; bool first_layer() %code{% RETVAL = THIS->first_layer; %}; void set_first_layer(bool value) %code{% THIS->first_layer = value; %}; float elapsed_time() %code{% RETVAL = THIS->elapsed_time; %}; void set_elapsed_time(float value) %code{% THIS->elapsed_time = value; %}; bool last_pos_defined(); Ref last_pos() %code{% RETVAL = &(THIS->last_pos()); %}; void set_last_pos(Point* pos) %code{% THIS->set_last_pos(*pos); %}; double volumetric_speed() %code{% RETVAL = THIS->volumetric_speed; %}; void set_volumetric_speed(double value) %code{% THIS->volumetric_speed = value; %}; void apply_print_config(StaticPrintConfig* print_config) %code{% if (const PrintConfig* config = dynamic_cast(print_config)) { THIS->apply_print_config(*config); } else { CONFESS("A PrintConfig object was not supplied to apply_print_config()"); } %}; void set_extruders(std::vector extruder_ids); void set_origin(Pointf* pointf) %code{% THIS->set_origin(*pointf); %}; std::string preamble(); std::string change_layer(Layer* layer) %code{% RETVAL = THIS->change_layer(*layer); %}; %name{extrude_loop} std::string extrude(ExtrusionLoop* loop, std::string description = "", double speed = -1) %code{% RETVAL = THIS->extrude(*loop, description, speed); %}; %name{extrude_path} std::string extrude(ExtrusionPath* path, std::string description = "", double speed = -1) %code{% RETVAL = THIS->extrude(*path, description, speed); %}; std::string travel_to(Point* point, ExtrusionRole role, std::string comment) %code{% RETVAL = THIS->travel_to(*point, role, comment); %}; bool needs_retraction(Polyline* travel, ExtrusionRole role = erNone) %code{% RETVAL = THIS->needs_retraction(*travel, role); %}; std::string retract(bool toolchange = false); std::string unretract(); std::string set_extruder(unsigned int extruder_id); Clone point_to_gcode(Point* point) %code{% RETVAL = THIS->point_to_gcode(*point); %}; %{ std::string GCode::extrude(entity, description, speed) SV* entity std::string description; double speed; CODE: ExtrusionEntity* e = (ExtrusionEntity *)SvIV((SV*)SvRV( entity )); RETVAL = THIS->extrude(*e, description, speed); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/GCodePressureEqualizer.xsp000066400000000000000000000016501301441720000230740ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/GCode/PressureEqualizer.hpp" %} %name{Slic3r::GCode::PressureEqualizer} class GCodePressureEqualizer { GCodePressureEqualizer(StaticPrintConfig* config) %code%{ RETVAL = new GCodePressureEqualizer(dynamic_cast(config)); %}; ~GCodePressureEqualizer(); void reset(); // Process a next batch of G-code lines. Flush the internal buffers if asked for. // const char* process(const char *szGCode, bool flush); // std::string process(const char *szGCode, bool flush) // %code{% const char *out = THIS->process(szGCode, flush); RETVAL = (out == NULL) ? "" : std::string(out); %}; %{ SV* GCodePressureEqualizer::process(const char *szGCode, bool flush) CODE: const char *out = THIS->process(szGCode, flush); RETVAL = newSVpv(out, THIS->get_output_buffer_length()); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/GCodeSender.xsp000066400000000000000000000011631301441720000206210ustar00rootroot00000000000000%module{Slic3r::XS}; #ifdef BOOST_LIBS %{ #include #include "libslic3r/GCodeSender.hpp" %} %name{Slic3r::GCode::Sender} class GCodeSender { GCodeSender(); ~GCodeSender(); bool connect(std::string port, unsigned int baud_rate); void disconnect(); bool is_connected(); bool wait_connected(unsigned int timeout = 3); int queue_size(); void send(std::string s, bool priority = false); void pause_queue(); void resume_queue(); void purge_queue(bool priority = false); std::vector purge_log(); std::string getT(); std::string getB(); }; #endif Slic3r-version_1.31.6/xs/xsp/GCodeWriter.xsp000066400000000000000000000051301301441720000206530ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/GCodeWriter.hpp" %} %name{Slic3r::GCode::Writer} class GCodeWriter { GCodeWriter(); ~GCodeWriter(); Ref config() %code%{ RETVAL = &THIS->config; %}; bool multiple_extruders() %code{% RETVAL = THIS->multiple_extruders; %}; Ref extruder(); std::string extrusion_axis(); void apply_print_config(PrintConfig* print_config) %code{% THIS->apply_print_config(*print_config); %}; void set_extruders(std::vector extruder_ids); std::string preamble(); std::string postamble(); std::string set_temperature(unsigned int temperature, bool wait = false, int tool = -1); std::string set_bed_temperature(unsigned int temperature, bool wait = false); std::string set_fan(unsigned int speed, bool dont_save = false); std::string set_acceleration(unsigned int acceleration); std::string reset_e(bool force = false); std::string update_progress(unsigned int num, unsigned int tot, bool allow_100 = false); bool need_toolchange(unsigned int extruder_id); std::string set_extruder(unsigned int extruder_id); std::string toolchange(unsigned int extruder_id); std::string set_speed(double F, std::string comment = std::string()); std::string travel_to_xy(Pointf* point, std::string comment = std::string()) %code{% RETVAL = THIS->travel_to_xy(*point, comment); %}; std::string travel_to_xyz(Pointf3* point, std::string comment = std::string()) %code{% RETVAL = THIS->travel_to_xyz(*point, comment); %}; std::string travel_to_z(double z, std::string comment = std::string()); bool will_move_z(double z); std::string extrude_to_xy(Pointf* point, double dE, std::string comment = std::string()) %code{% RETVAL = THIS->extrude_to_xy(*point, dE, comment); %}; std::string extrude_to_xyz(Pointf3* point, double dE, std::string comment = std::string()) %code{% RETVAL = THIS->extrude_to_xyz(*point, dE, comment); %}; std::string retract(); std::string retract_for_toolchange(); std::string unretract(); std::string lift(); std::string unlift(); Clone get_position() const; %{ SV* GCodeWriter::extruders() CODE: AV* av = newAV(); av_fill(av, THIS->extruders.size()-1); int i = 0; for (std::map::iterator it = THIS->extruders.begin(); it != THIS->extruders.end(); ++it) { av_store(av, i++, perl_to_SV_ref(it->second)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/GUI.xsp000066400000000000000000000006221301441720000171220ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "slic3r/GUI/GUI.hpp" %} %package{Slic3r::GUI}; void disable_screensaver() %code{% Slic3r::GUI::disable_screensaver(); %}; void enable_screensaver() %code{% Slic3r::GUI::enable_screensaver(); %}; bool debugged() %code{% RETVAL=Slic3r::GUI::debugged(); %}; void break_to_debugger() %code{% Slic3r::GUI::break_to_debugger(); %}; Slic3r-version_1.31.6/xs/xsp/GUI_3DScene.xsp000066400000000000000000000016341301441720000204320ustar00rootroot00000000000000%module{Slic3r::XS}; #include #include "slic3r/GUI/3DScene.hpp" %name{Slic3r::GUI::_3DScene::GLVertexArray} class GLVertexArray { GLVertexArray(); ~GLVertexArray(); void load_mesh(TriangleMesh* mesh) const %code%{ THIS->load_mesh(*mesh); %}; size_t size() const %code%{ RETVAL = THIS->verts.size(); %}; void* verts_ptr() const %code%{ RETVAL = THIS->verts.empty() ? 0 : &THIS->verts.front(); %}; void* norms_ptr() const %code%{ RETVAL = THIS->verts.empty() ? 0 : &THIS->norms.front(); %}; }; %package{Slic3r::GUI::_3DScene}; %{ void _extrusionentity_to_verts_do(Lines lines, std::vector widths, std::vector heights, bool closed, double top_z, Point* copy, GLVertexArray* qverts, GLVertexArray* tverts) CODE: _3DScene::_extrusionentity_to_verts_do(lines, widths, heights, closed, top_z, *copy, qverts, tverts); %}Slic3r-version_1.31.6/xs/xsp/Geometry.xsp000066400000000000000000000042301301441720000202700ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Geometry.hpp" %} %package{Slic3r::Geometry}; Pointfs arrange(size_t total_parts, Pointf* part, coordf_t dist, BoundingBoxf* bb = NULL) %code{% Pointfs points; if (! Slic3r::Geometry::arrange(total_parts, *part, dist, bb, points)) CONFESS(PRINTF_ZU " parts won't fit in your print area!\n", total_parts); RETVAL = points; %}; %{ bool directions_parallel(angle1, angle2) double angle1 double angle2 CODE: RETVAL = Slic3r::Geometry::directions_parallel(angle1, angle2); OUTPUT: RETVAL bool directions_parallel_within(angle1, angle2, max_diff) double angle1 double angle2 double max_diff CODE: RETVAL = Slic3r::Geometry::directions_parallel(angle1, angle2, max_diff); OUTPUT: RETVAL Clone convex_hull(points) Points points CODE: RETVAL = Slic3r::Geometry::convex_hull(points); OUTPUT: RETVAL std::vector chained_path(points) Points points CODE: Slic3r::Geometry::chained_path(points, RETVAL); OUTPUT: RETVAL std::vector chained_path_from(points, start_from) Points points Point* start_from CODE: Slic3r::Geometry::chained_path(points, RETVAL, *start_from); OUTPUT: RETVAL double rad2deg(angle) double angle CODE: RETVAL = Slic3r::Geometry::rad2deg(angle); OUTPUT: RETVAL double rad2deg_dir(angle) double angle CODE: RETVAL = Slic3r::Geometry::rad2deg_dir(angle); OUTPUT: RETVAL double deg2rad(angle) double angle CODE: RETVAL = Slic3r::Geometry::deg2rad(angle); OUTPUT: RETVAL Polygons simplify_polygons(polygons, tolerance) Polygons polygons double tolerance CODE: Slic3r::Geometry::simplify_polygons(polygons, tolerance, &RETVAL); OUTPUT: RETVAL IV _constant() ALIAS: X = X Y = Y Z = Z PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/Layer.xsp000066400000000000000000000130501301441720000175510ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Layer.hpp" %} %name{Slic3r::Layer::Region} class LayerRegion { // owned by Layer, no constructor/destructor Ref layer(); Ref region(); Ref slices() %code%{ RETVAL = &THIS->slices; %}; Ref thin_fills() %code%{ RETVAL = &THIS->thin_fills; %}; Ref fill_surfaces() %code%{ RETVAL = &THIS->fill_surfaces; %}; Ref perimeter_surfaces() %code%{ RETVAL = &THIS->perimeter_surfaces; %}; Polygons bridged() %code%{ RETVAL = THIS->bridged; %}; Ref unsupported_bridge_edges() %code%{ RETVAL = &THIS->unsupported_bridge_edges; %}; Ref perimeters() %code%{ RETVAL = &THIS->perimeters; %}; Ref fills() %code%{ RETVAL = &THIS->fills; %}; Clone flow(FlowRole role, bool bridge = false, double width = -1) %code%{ RETVAL = THIS->flow(role, bridge, width); %}; void prepare_fill_surfaces(); void make_perimeters(SurfaceCollection* slices, SurfaceCollection* fill_surfaces) %code%{ THIS->make_perimeters(*slices, fill_surfaces); %}; double infill_area_threshold(); void export_region_slices_to_svg(const char *path); void export_region_fill_surfaces_to_svg(const char *path); void export_region_slices_to_svg_debug(const char *name); void export_region_fill_surfaces_to_svg_debug(const char *name); }; %name{Slic3r::Layer} class Layer { // owned by PrintObject, no constructor/destructor Ref as_layer() %code%{ RETVAL = THIS; %}; int id(); void set_id(int id); Ref object(); Ref upper_layer() %code%{ RETVAL = THIS->upper_layer; %}; Ref lower_layer() %code%{ RETVAL = THIS->lower_layer; %}; bool slicing_errors() %code%{ RETVAL = THIS->slicing_errors; %}; coordf_t slice_z() %code%{ RETVAL = THIS->slice_z; %}; coordf_t print_z() %code%{ RETVAL = THIS->print_z; %}; coordf_t height() %code%{ RETVAL = THIS->height; %}; void set_upper_layer(Layer *layer) %code%{ THIS->upper_layer = layer; %}; void set_lower_layer(Layer *layer) %code%{ THIS->lower_layer = layer; %}; bool has_upper_layer() %code%{ RETVAL = (THIS->upper_layer != NULL); %}; bool has_lower_layer() %code%{ RETVAL = (THIS->lower_layer != NULL); %}; size_t region_count(); Ref get_region(int idx); Ref add_region(PrintRegion* print_region); Ref slices() %code%{ RETVAL = &THIS->slices; %}; int ptr() %code%{ RETVAL = (int)(intptr_t)THIS; %}; Ref as_support_layer() %code%{ RETVAL = dynamic_cast(THIS); %}; void make_slices(); void merge_slices(); bool any_internal_region_slice_contains_polyline(Polyline* polyline) %code%{ RETVAL = THIS->any_internal_region_slice_contains(*polyline); %}; bool any_bottom_region_slice_contains_polyline(Polyline* polyline) %code%{ RETVAL = THIS->any_bottom_region_slice_contains(*polyline); %}; void make_perimeters(); void make_fills(); void export_region_slices_to_svg(const char *path); void export_region_fill_surfaces_to_svg(const char *path); void export_region_slices_to_svg_debug(const char *name); void export_region_fill_surfaces_to_svg_debug(const char *name); }; %name{Slic3r::Layer::Support} class SupportLayer { // owned by PrintObject, no constructor/destructor Ref as_layer() %code%{ RETVAL = THIS; %}; Ref support_islands() %code%{ RETVAL = &THIS->support_islands; %}; Ref support_fills() %code%{ RETVAL = &THIS->support_fills; %}; Ref support_interface_fills() %code%{ RETVAL = &THIS->support_interface_fills; %}; // copies of some Layer methods, because the parameter wrapper code // gets confused about getting a Layer::Support instead of a Layer int id(); void set_id(int id); Ref object(); Ref upper_layer() %code%{ RETVAL = (SupportLayer*)THIS->upper_layer; %}; Ref lower_layer() %code%{ RETVAL = (SupportLayer*)THIS->lower_layer; %}; bool slicing_errors() %code%{ RETVAL = THIS->slicing_errors; %}; coordf_t slice_z() %code%{ RETVAL = THIS->slice_z; %}; coordf_t print_z() %code%{ RETVAL = THIS->print_z; %}; coordf_t height() %code%{ RETVAL = THIS->height; %}; void set_upper_layer(SupportLayer *layer) %code%{ THIS->upper_layer = layer; %}; void set_lower_layer(SupportLayer *layer) %code%{ THIS->lower_layer = layer; %}; bool has_upper_layer() %code%{ RETVAL = (THIS->upper_layer != NULL); %}; bool has_lower_layer() %code%{ RETVAL = (THIS->lower_layer != NULL); %}; size_t region_count(); Ref get_region(int idx); Ref add_region(PrintRegion* print_region); Ref slices() %code%{ RETVAL = &THIS->slices; %}; void export_region_slices_to_svg(const char *path); void export_region_fill_surfaces_to_svg(const char *path); void export_region_slices_to_svg_debug(const char *name); void export_region_fill_surfaces_to_svg_debug(const char *name); }; Slic3r-version_1.31.6/xs/xsp/Line.xsp000066400000000000000000000044261301441720000173730ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Line.hpp" #include "libslic3r/Polyline.hpp" %} %name{Slic3r::Line} class Line { ~Line(); Clone clone() %code{% RETVAL = THIS; %}; SV* arrayref() %code{% RETVAL = to_AV(THIS); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(THIS); %}; Ref a() %code{% RETVAL=&THIS->a; %}; Ref b() %code{% RETVAL=&THIS->b; %}; void reverse(); void scale(double factor); void translate(double x, double y); double length(); double atan2_(); double orientation(); double direction(); bool parallel_to(double angle); bool parallel_to_line(Line* line) %code{% RETVAL = THIS->parallel_to(*line); %}; Clone midpoint(); Clone point_at(double distance); Clone intersection_infinite(Line* other) %code{% Point p; bool res = THIS->intersection_infinite(*other, &p); if (!res) CONFESS("Intersection failed"); RETVAL = p; %}; Clone as_polyline() %code{% RETVAL = Polyline(*THIS); %}; Clone normal(); Clone vector(); double ccw(Point* point) %code{% RETVAL = THIS->ccw(*point); %}; %{ Line* Line::new(...) CODE: RETVAL = new Line (); // ST(0) is class name, ST(1) and ST(2) are endpoints from_SV_check(ST(1), &RETVAL->a); from_SV_check(ST(2), &RETVAL->b); OUTPUT: RETVAL void Line::rotate(angle, center_sv) double angle; SV* center_sv; CODE: Point center; from_SV_check(center_sv, ¢er); THIS->rotate(angle, center); bool Line::coincides_with(line_sv) SV* line_sv; CODE: Line line; from_SV_check(line_sv, &line); RETVAL = THIS->coincides_with(line); OUTPUT: RETVAL %} }; %name{Slic3r::Linef3} class Linef3 { Linef3(Pointf3* a, Pointf3* b) %code{% RETVAL = new Linef3(*a, *b); %}; ~Linef3(); Clone clone() %code{% RETVAL = THIS; %}; Ref a() %code{% RETVAL = &THIS->a; %}; Ref b() %code{% RETVAL = &THIS->b; %}; Clone intersect_plane(double z); void scale(double factor); }; Slic3r-version_1.31.6/xs/xsp/Model.xsp000066400000000000000000000176771301441720000175600ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Model.hpp" #include "libslic3r/PrintConfig.hpp" %} %name{Slic3r::Model} class Model { Model(); ~Model(); Clone clone() %code%{ RETVAL = THIS; %}; %name{_add_object} Ref add_object(); Ref _add_object_clone(ModelObject* other, bool copy_volumes = true) %code%{ RETVAL = THIS->add_object(*other, copy_volumes); %}; void delete_object(size_t idx); void clear_objects(); size_t objects_count() %code%{ RETVAL = THIS->objects.size(); %}; Ref get_object(int idx) %code%{ RETVAL = THIS->objects.at(idx); %}; Ref get_material(t_model_material_id material_id) %code%{ RETVAL = THIS->get_material(material_id); if (RETVAL == NULL) { XSRETURN_UNDEF; } %}; %name{add_material} Ref add_material(t_model_material_id material_id); Ref add_material_clone(t_model_material_id material_id, ModelMaterial* other) %code%{ RETVAL = THIS->add_material(material_id, *other); %}; bool has_material(t_model_material_id material_id) const %code%{ RETVAL = (THIS->get_material(material_id) != NULL); %}; void delete_material(t_model_material_id material_id); void clear_materials(); std::vector material_names() const %code%{ for (ModelMaterialMap::iterator i = THIS->materials.begin(); i != THIS->materials.end(); ++i) { RETVAL.push_back(i->first); } %}; size_t material_count() const %code%{ RETVAL = THIS->materials.size(); %}; bool has_objects_with_no_instances(); bool add_default_instances(); Clone bounding_box(); void center_instances_around_point(Pointf* point) %code%{ THIS->center_instances_around_point(*point); %}; void align_instances_to_origin(); void translate(double x, double y, double z); Clone mesh(); Clone raw_mesh(); ModelObjectPtrs* objects() %code%{ RETVAL = &THIS->objects; %}; bool arrange_objects(double dist, BoundingBoxf* bb = NULL); void duplicate(unsigned int copies_num, double dist, BoundingBoxf* bb = NULL); void duplicate_objects(unsigned int copies_num, double dist, BoundingBoxf* bb = NULL); void duplicate_objects_grid(unsigned int x, unsigned int y, double dist); }; %name{Slic3r::Model::Material} class ModelMaterial { Ref model() %code%{ RETVAL = THIS->get_model(); %}; Ref config() %code%{ RETVAL = &THIS->config; %}; std::string get_attribute(std::string name) %code%{ if (THIS->attributes.find(name) != THIS->attributes.end()) RETVAL = THIS->attributes[name]; %}; void set_attribute(std::string name, std::string value) %code%{ THIS->attributes[name] = value; %}; %{ SV* ModelMaterial::attributes() CODE: HV* hv = newHV(); for (t_model_material_attributes::const_iterator attr = THIS->attributes.begin(); attr != THIS->attributes.end(); ++attr) { (void)hv_store( hv, attr->first.c_str(), attr->first.length(), newSVpv(attr->second.c_str(), attr->second.length()), 0 ); } RETVAL = (SV*)newRV_noinc((SV*)hv); OUTPUT: RETVAL %} }; %name{Slic3r::Model::Object} class ModelObject { ModelVolumePtrs* volumes() %code%{ RETVAL = &THIS->volumes; %}; ModelInstancePtrs* instances() %code%{ RETVAL = &THIS->instances; %}; void invalidate_bounding_box(); void update_bounding_box(); Clone mesh(); Clone raw_mesh(); Clone raw_bounding_box(); Clone instance_bounding_box(int idx); Ref _bounding_box(BoundingBoxf3* new_bbox = NULL) %code{% if (NULL != new_bbox) { THIS->_bounding_box = *new_bbox; THIS->_bounding_box_valid = true; } if (!THIS->_bounding_box_valid) { XSRETURN_UNDEF; } RETVAL = &THIS->_bounding_box; %}; Clone bounding_box(); %name{_add_volume} Ref add_volume(TriangleMesh* mesh) %code%{ RETVAL = THIS->add_volume(*mesh); %}; Ref _add_volume_clone(ModelVolume* other) %code%{ RETVAL = THIS->add_volume(*other); %}; void delete_volume(size_t idx); void clear_volumes(); int volumes_count() %code%{ RETVAL = THIS->volumes.size(); %}; %name{_add_instance} Ref add_instance(); Ref _add_instance_clone(ModelInstance* other) %code%{ RETVAL = THIS->add_instance(*other); %}; void delete_last_instance(); void clear_instances(); int instances_count() %code%{ RETVAL = THIS->instances.size(); %}; std::string name() %code%{ RETVAL = THIS->name; %}; void set_name(std::string value) %code%{ THIS->name = value; %}; std::string input_file() %code%{ RETVAL = THIS->input_file; %}; void set_input_file(std::string value) %code%{ THIS->input_file = value; %}; Ref config() %code%{ RETVAL = &THIS->config; %}; Ref model() %code%{ RETVAL = THIS->get_model(); %}; t_layer_height_ranges layer_height_ranges() %code%{ RETVAL = THIS->layer_height_ranges; %}; void set_layer_height_ranges(t_layer_height_ranges ranges) %code%{ THIS->layer_height_ranges = ranges; %}; Ref origin_translation() %code%{ RETVAL = &THIS->origin_translation; %}; void set_origin_translation(Pointf3* point) %code%{ THIS->origin_translation = *point; %}; bool needed_repair() const; int materials_count() const; int facets_count(); void center_around_origin(); void translate(double x, double y, double z); void scale_xyz(Pointf3* versor) %code{% THIS->scale(*versor); %}; void rotate(float angle, Axis axis); void mirror(Axis axis); Model* cut(double z) %code%{ RETVAL = new Model(); THIS->cut(z, RETVAL); %}; ModelObjectPtrs* split_object() %code%{ RETVAL = new ModelObjectPtrs(); // leak? THIS->split(RETVAL); %}; }; %name{Slic3r::Model::Volume} class ModelVolume { Ref object() %code%{ RETVAL = THIS->get_object(); %}; std::string name() %code%{ RETVAL = THIS->name; %}; void set_name(std::string value) %code%{ THIS->name = value; %}; t_model_material_id material_id(); void set_material_id(t_model_material_id material_id) %code%{ THIS->material_id(material_id); %}; Ref material(); Ref config() %code%{ RETVAL = &THIS->config; %}; Ref mesh() %code%{ RETVAL = &THIS->mesh; %}; bool modifier() %code%{ RETVAL = THIS->modifier; %}; void set_modifier(bool modifier) %code%{ THIS->modifier = modifier; %}; ModelMaterial* assign_unique_material(); }; %name{Slic3r::Model::Instance} class ModelInstance { Ref object() %code%{ RETVAL = THIS->get_object(); %}; double rotation() %code%{ RETVAL = THIS->rotation; %}; double scaling_factor() %code%{ RETVAL = THIS->scaling_factor; %}; Ref offset() %code%{ RETVAL = &THIS->offset; %}; void set_rotation(double val) %code%{ THIS->rotation = val; %}; void set_scaling_factor(double val) %code%{ THIS->scaling_factor = val; %}; void set_offset(Pointf *offset) %code%{ THIS->offset = *offset; %}; void transform_mesh(TriangleMesh* mesh, bool dont_translate = false) const; void transform_polygon(Polygon* polygon) const; }; Slic3r-version_1.31.6/xs/xsp/MotionPlanner.xsp000066400000000000000000000005411301441720000212630ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/MotionPlanner.hpp" %} %name{Slic3r::MotionPlanner} class MotionPlanner { MotionPlanner(ExPolygons islands); ~MotionPlanner(); int islands_count(); Clone shortest_path(Point* from, Point* to) %code%{ RETVAL = THIS->shortest_path(*from, *to); %}; }; Slic3r-version_1.31.6/xs/xsp/PerimeterGenerator.xsp000066400000000000000000000027361301441720000223110ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/PerimeterGenerator.hpp" %} %name{Slic3r::Layer::PerimeterGenerator} class PerimeterGenerator { PerimeterGenerator(SurfaceCollection* slices, double layer_height, Flow* flow, StaticPrintConfig* region_config, StaticPrintConfig* object_config, StaticPrintConfig* print_config, ExtrusionEntityCollection* loops, ExtrusionEntityCollection* gap_fill, SurfaceCollection* fill_surfaces) %code{% RETVAL = new PerimeterGenerator(slices, layer_height, *flow, dynamic_cast(region_config), dynamic_cast(object_config), dynamic_cast(print_config), loops, gap_fill, fill_surfaces); %}; ~PerimeterGenerator(); void set_lower_slices(ExPolygonCollection* lower_slices) %code{% THIS->lower_slices = lower_slices; %}; void set_layer_id(int layer_id) %code{% THIS->layer_id = layer_id; %}; void set_perimeter_flow(Flow* flow) %code{% THIS->perimeter_flow = *flow; %}; void set_ext_perimeter_flow(Flow* flow) %code{% THIS->ext_perimeter_flow = *flow; %}; void set_overhang_flow(Flow* flow) %code{% THIS->overhang_flow = *flow; %}; void set_solid_infill_flow(Flow* flow) %code{% THIS->solid_infill_flow = *flow; %}; Ref config() %code{% RETVAL = THIS->config; %}; void process(); }; Slic3r-version_1.31.6/xs/xsp/PlaceholderParser.xsp000066400000000000000000000012111301441720000220700ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include #include "libslic3r/PlaceholderParser.hpp" %} %name{Slic3r::GCode::PlaceholderParser} class PlaceholderParser { PlaceholderParser(); ~PlaceholderParser(); Clone clone() %code{% RETVAL = THIS; %}; void update_timestamp(); void apply_env_variables(); void apply_config(DynamicPrintConfig *config) %code%{ THIS->apply_config(*config); %}; void set(std::string key, std::string value); %name{set_multiple} void set(std::string key, std::vector values); std::string process(std::string str) const; }; Slic3r-version_1.31.6/xs/xsp/Point.xsp000066400000000000000000000114401301441720000175670ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Point.hpp" #include "libslic3r/Polygon.hpp" #include "libslic3r/Polyline.hpp" %} %name{Slic3r::Point} class Point { Point(long _x = 0, long _y = 0); ~Point(); Clone clone() %code{% RETVAL=THIS; %}; void scale(double factor); void translate(double x, double y); SV* arrayref() %code{% RETVAL = to_SV_pureperl(THIS); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(THIS); %}; long x() %code{% RETVAL = THIS->x; %}; long y() %code{% RETVAL = THIS->y; %}; void set_x(long val) %code{% THIS->x = val; %}; void set_y(long val) %code{% THIS->y = val; %}; int nearest_point_index(Points points); Clone nearest_point(Points points) %code{% Point p; THIS->nearest_point(points, &p); RETVAL = p; %}; double distance_to(Point* point) %code{% RETVAL = THIS->distance_to(*point); %}; double distance_to_line(Line* line) %code{% RETVAL = THIS->distance_to(*line); %}; double perp_distance_to_line(Line* line) %code{% RETVAL = THIS->perp_distance_to(*line); %}; double ccw(Point* p1, Point* p2) %code{% RETVAL = THIS->ccw(*p1, *p2); %}; double ccw_angle(Point* p1, Point* p2) %code{% RETVAL = THIS->ccw_angle(*p1, *p2); %}; Clone projection_onto_polygon(Polygon* polygon) %code{% RETVAL = new Point(THIS->projection_onto(*polygon)); %}; Clone projection_onto_polyline(Polyline* polyline) %code{% RETVAL = new Point(THIS->projection_onto(*polyline)); %}; Clone projection_onto_line(Line* line) %code{% RETVAL = new Point(THIS->projection_onto(*line)); %}; Clone negative() %code{% RETVAL = new Point(THIS->negative()); %}; bool coincides_with_epsilon(Point* point) %code{% RETVAL = THIS->coincides_with_epsilon(*point); %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%ld,%ld", THIS->x, THIS->y); RETVAL = buf; %}; %{ void Point::rotate(angle, center_sv) double angle; SV* center_sv; CODE: Point center; from_SV_check(center_sv, ¢er); THIS->rotate(angle, center); bool Point::coincides_with(point_sv) SV* point_sv; CODE: Point point; from_SV_check(point_sv, &point); RETVAL = THIS->coincides_with(point); OUTPUT: RETVAL %} }; %name{Slic3r::Point3} class Point3 { Point3(long _x = 0, long _y = 0, long _z = 0); ~Point3(); Clone clone() %code{% RETVAL = THIS; %}; long x() %code{% RETVAL = THIS->x; %}; long y() %code{% RETVAL = THIS->y; %}; long z() %code{% RETVAL = THIS->z; %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%ld,%ld,%ld", THIS->x, THIS->y, THIS->z); RETVAL = buf; %}; }; %name{Slic3r::Pointf} class Pointf { Pointf(double _x = 0, double _y = 0); ~Pointf(); Clone clone() %code{% RETVAL = THIS; %}; SV* arrayref() %code{% RETVAL = to_SV_pureperl(THIS); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(THIS); %}; double x() %code{% RETVAL = THIS->x; %}; double y() %code{% RETVAL = THIS->y; %}; void set_x(double val) %code{% THIS->x = val; %}; void set_y(double val) %code{% THIS->y = val; %}; void translate(double x, double y); void scale(double factor); void rotate(double angle, Pointf* center) %code{% THIS->rotate(angle, *center); %}; Clone negative() %code{% RETVAL = THIS->negative(); %}; Clone vector_to(Pointf* point) %code{% RETVAL = THIS->vector_to(*point); %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%lf,%lf", THIS->x, THIS->y); RETVAL = buf; %}; }; %name{Slic3r::Pointf3} class Pointf3 { Pointf3(double _x = 0, double _y = 0, double _z = 0); ~Pointf3(); Clone clone() %code{% RETVAL = THIS; %}; double x() %code{% RETVAL = THIS->x; %}; double y() %code{% RETVAL = THIS->y; %}; double z() %code{% RETVAL = THIS->z; %}; void set_x(double val) %code{% THIS->x = val; %}; void set_y(double val) %code{% THIS->y = val; %}; void set_z(double val) %code{% THIS->z = val; %}; void translate(double x, double y, double z); void scale(double factor); double distance_to(Pointf3* point) %code{% RETVAL = THIS->distance_to(*point); %}; Clone negative() %code{% RETVAL = THIS->negative(); %}; Clone vector_to(Pointf3* point) %code{% RETVAL = THIS->vector_to(*point); %}; std::string serialize() %code{% char buf[2048]; sprintf(buf, "%lf,%lf,%lf", THIS->x, THIS->y, THIS->z); RETVAL = buf; %}; }; Slic3r-version_1.31.6/xs/xsp/Polygon.xsp000066400000000000000000000037721301441720000201360ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/BoundingBox.hpp" #include "libslic3r/Polygon.hpp" #include "libslic3r/BoundingBox.hpp" %} %name{Slic3r::Polygon} class Polygon { ~Polygon(); Clone clone() %code{% RETVAL = THIS; %}; SV* arrayref() %code{% RETVAL = to_AV(THIS); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(THIS); %}; void scale(double factor); void translate(double x, double y); void reverse(); Lines lines(); Clone split_at_vertex(Point* point) %code{% RETVAL = THIS->split_at_vertex(*point); %}; Clone split_at_index(int index); Clone split_at_first_point(); Points equally_spaced_points(double distance); double length(); double area(); bool is_counter_clockwise(); bool is_clockwise(); bool make_counter_clockwise(); bool make_clockwise(); bool is_valid(); Clone first_point(); bool contains_point(Point* point) %code{% RETVAL = THIS->contains(*point); %}; Polygons simplify(double tolerance); Polygons triangulate_convex() %code{% THIS->triangulate_convex(&RETVAL); %}; Clone centroid(); Clone bounding_box(); std::string wkt(); Points concave_points(double angle); Points convex_points(double angle); Clone intersection(Line* line) %code{% Point p; (void)THIS->intersection(*line, &p); RETVAL = p; %}; %{ Polygon* Polygon::new(...) CODE: RETVAL = new Polygon (); // ST(0) is class name, ST(1) is first point RETVAL->points.resize(items-1); for (unsigned int i = 1; i < items; i++) { from_SV_check(ST(i), &RETVAL->points[i-1]); } OUTPUT: RETVAL void Polygon::rotate(angle, center_sv) double angle; SV* center_sv; CODE: Point center; from_SV_check(center_sv, ¢er); THIS->rotate(angle, center); %} }; Slic3r-version_1.31.6/xs/xsp/Polyline.xsp000066400000000000000000000050251301441720000202730ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/BoundingBox.hpp" #include "libslic3r/ClipperUtils.hpp" #include "libslic3r/Polyline.hpp" %} %name{Slic3r::Polyline} class Polyline { ~Polyline(); Clone clone() %code{% RETVAL = THIS; %}; SV* arrayref() %code{% RETVAL = to_AV(THIS); %}; SV* pp() %code{% RETVAL = to_SV_pureperl(THIS); %}; void scale(double factor); void translate(double x, double y); void pop_back() %code{% THIS->points.pop_back(); %}; void reverse(); Lines lines(); Clone first_point(); Clone last_point(); Points equally_spaced_points(double distance); double length(); bool is_valid(); void clip_end(double distance); void clip_start(double distance); void extend_end(double distance); void extend_start(double distance); void simplify(double tolerance); void simplify_by_visibility(ExPolygon* expolygon) %code{% THIS->simplify_by_visibility(*expolygon); %}; void split_at(Point* point, Polyline* p1, Polyline* p2) %code{% THIS->split_at(*point, p1, p2); %}; bool is_straight(); Clone bounding_box(); void remove_duplicate_points(); std::string wkt(); %{ Polyline* Polyline::new(...) CODE: RETVAL = new Polyline (); // ST(0) is class name, ST(1) is first point RETVAL->points.resize(items-1); for (unsigned int i = 1; i < items; i++) { from_SV_check(ST(i), &RETVAL->points[i-1]); } OUTPUT: RETVAL void Polyline::append(...) CODE: for (unsigned int i = 1; i < items; i++) { Point p; from_SV_check(ST(i), &p); THIS->points.push_back(p); } void Polyline::append_polyline(polyline) Polyline* polyline; CODE: for (Points::const_iterator it = polyline->points.begin(); it != polyline->points.end(); ++it) { THIS->points.push_back((*it)); } void Polyline::rotate(angle, center_sv) double angle; SV* center_sv; CODE: Point center; from_SV_check(center_sv, ¢er); THIS->rotate(angle, center); Polygons Polyline::grow(delta, scale = CLIPPER_OFFSET_SCALE, joinType = ClipperLib::jtSquare, miterLimit = 3) const float delta double scale ClipperLib::JoinType joinType double miterLimit CODE: offset(*THIS, &RETVAL, delta, scale, joinType, miterLimit); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/PolylineCollection.xsp000066400000000000000000000042231301441720000223060ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/PolylineCollection.hpp" %} %name{Slic3r::Polyline::Collection} class PolylineCollection { ~PolylineCollection(); Clone clone() %code{% RETVAL = THIS; %}; void clear() %code{% THIS->polylines.clear(); %}; PolylineCollection* chained_path(bool no_reverse) %code{% RETVAL = new PolylineCollection(); THIS->chained_path(RETVAL, no_reverse); %}; PolylineCollection* chained_path_from(Point* start_near, bool no_reverse) %code{% RETVAL = new PolylineCollection(); THIS->chained_path_from(*start_near, RETVAL, no_reverse); %}; int count() %code{% RETVAL = THIS->polylines.size(); %}; Clone leftmost_point(); %{ PolylineCollection* PolylineCollection::new(...) CODE: RETVAL = new PolylineCollection (); // ST(0) is class name, others are Polylines RETVAL->polylines.resize(items-1); for (unsigned int i = 1; i < items; i++) { // Note: a COPY of the input is stored from_SV_check(ST(i), &RETVAL->polylines[i-1]); } OUTPUT: RETVAL SV* PolylineCollection::arrayref() CODE: AV* av = newAV(); av_fill(av, THIS->polylines.size()-1); int i = 0; for (Polylines::iterator it = THIS->polylines.begin(); it != THIS->polylines.end(); ++it) { av_store(av, i++, perl_to_SV_ref(*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL SV* PolylineCollection::pp() CODE: AV* av = newAV(); av_fill(av, THIS->polylines.size()-1); int i = 0; for (Polylines::iterator it = THIS->polylines.begin(); it != THIS->polylines.end(); ++it) { av_store(av, i++, to_SV_pureperl(&*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL void PolylineCollection::append(...) CODE: for (unsigned int i = 1; i < items; i++) { Polyline polyline; from_SV_check(ST(i), &polyline); THIS->polylines.push_back(polyline); } %} }; Slic3r-version_1.31.6/xs/xsp/Print.xsp000066400000000000000000000204701301441720000175750ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Print.hpp" #include "libslic3r/PlaceholderParser.hpp" %} %package{Slic3r::Print::State}; %{ IV _constant() ALIAS: STEP_SLICE = posSlice STEP_PERIMETERS = posPerimeters STEP_PREPARE_INFILL = posPrepareInfill STEP_INFILL = posInfill STEP_SUPPORTMATERIAL = posSupportMaterial STEP_SKIRT = psSkirt STEP_BRIM = psBrim PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} %name{Slic3r::Print::Region} class PrintRegion { // owned by Print, no constructor/destructor Ref config() %code%{ RETVAL = &THIS->config; %}; Ref print(); Clone flow(FlowRole role, double layer_height, bool bridge, bool first_layer, double width, PrintObject* object) %code%{ RETVAL = THIS->flow(role, layer_height, bridge, first_layer, width, *object); %}; }; %name{Slic3r::Print::Object} class PrintObject { // owned by Print, no constructor/destructor void add_region_volume(int region_id, int volume_id); std::vector get_region_volumes(int region_id) %code%{ if (0 <= region_id && region_id < THIS->region_volumes.size()) RETVAL = THIS->region_volumes[region_id]; %}; int region_count() %code%{ RETVAL = THIS->print()->regions.size(); %}; Ref print(); Ref model_object(); Ref config() %code%{ RETVAL = &THIS->config; %}; Points copies(); t_layer_height_ranges layer_height_ranges() %code%{ RETVAL = THIS->layer_height_ranges; %}; Ref size() %code%{ RETVAL = &THIS->size; %}; Clone bounding_box(); Ref _copies_shift() %code%{ RETVAL = &THIS->_copies_shift; %}; bool typed_slices() %code%{ RETVAL = THIS->typed_slices; %}; void set_typed_slices(bool value) %code%{ THIS->typed_slices = value; %}; Points _shifted_copies() %code%{ RETVAL = THIS->_shifted_copies; %}; void set_shifted_copies(Points value) %code%{ THIS->_shifted_copies = value; %}; bool add_copy(Pointf* point) %code%{ RETVAL = THIS->add_copy(*point); %}; bool delete_last_copy(); bool delete_all_copies(); bool set_copies(Points copies); bool reload_model_instances(); void set_layer_height_ranges(t_layer_height_ranges layer_height_ranges) %code%{ THIS->layer_height_ranges = layer_height_ranges; %}; size_t total_layer_count(); size_t layer_count(); void clear_layers(); Ref get_layer(int idx); Ref add_layer(int id, coordf_t height, coordf_t print_z, coordf_t slice_z); void delete_layer(int idx); size_t support_layer_count(); void clear_support_layers(); Ref get_support_layer(int idx); Ref add_support_layer(int id, coordf_t height, coordf_t print_z); void delete_support_layer(int idx); bool invalidate_state_by_config_options(std::vector opt_keys); bool invalidate_step(PrintObjectStep step); bool invalidate_all_steps(); bool step_done(PrintObjectStep step) %code%{ RETVAL = THIS->state.is_done(step); %}; void set_step_done(PrintObjectStep step) %code%{ THIS->state.set_done(step); %}; void set_step_started(PrintObjectStep step) %code%{ THIS->state.set_started(step); %}; void detect_surfaces_type(); void process_external_surfaces(); void discover_vertical_shells(); void bridge_over_infill(); int ptr() %code%{ RETVAL = (int)(intptr_t)THIS; %}; }; %name{Slic3r::Print} class Print { Print(); ~Print(); Ref config() %code%{ RETVAL = &THIS->config; %}; Ref default_object_config() %code%{ RETVAL = &THIS->default_object_config; %}; Ref default_region_config() %code%{ RETVAL = &THIS->default_region_config; %}; Ref placeholder_parser() %code%{ RETVAL = &THIS->placeholder_parser; %}; // TODO: status_cb Ref skirt() %code%{ RETVAL = &THIS->skirt; %}; Ref brim() %code%{ RETVAL = &THIS->brim; %}; PrintObjectPtrs* objects() %code%{ RETVAL = &THIS->objects; %}; void clear_objects(); Ref get_object(int idx); void delete_object(int idx); void reload_object(int idx); bool reload_model_instances(); size_t object_count() %code%{ RETVAL = THIS->objects.size(); %}; PrintRegionPtrs* regions() %code%{ RETVAL = &THIS->regions; %}; Ref get_region(int idx); Ref add_region(); size_t region_count() %code%{ RETVAL = THIS->regions.size(); %}; bool invalidate_state_by_config_options(std::vector opt_keys); bool invalidate_step(PrintStep step); bool invalidate_all_steps(); bool step_done(PrintStep step) %code%{ RETVAL = THIS->state.is_done(step); %}; bool object_step_done(PrintObjectStep step) %code%{ RETVAL = THIS->step_done(step); %}; void set_step_done(PrintStep step) %code%{ THIS->state.set_done(step); %}; void set_step_started(PrintStep step) %code%{ THIS->state.set_started(step); %}; std::vector object_extruders() %code%{ std::set extruders = THIS->object_extruders(); RETVAL.reserve(extruders.size()); for (std::set::const_iterator e = extruders.begin(); e != extruders.end(); ++e) { RETVAL.push_back(*e); } %}; std::vector support_material_extruders() %code%{ std::set extruders = THIS->support_material_extruders(); RETVAL.reserve(extruders.size()); for (std::set::const_iterator e = extruders.begin(); e != extruders.end(); ++e) { RETVAL.push_back(*e); } %}; std::vector extruders() %code%{ std::set extruders = THIS->extruders(); RETVAL.reserve(extruders.size()); for (std::set::const_iterator e = extruders.begin(); e != extruders.end(); ++e) { RETVAL.push_back(*e); } %}; void clear_filament_stats() %code%{ THIS->filament_stats.clear(); %}; void set_filament_stats(int extruder_id, float length) %code%{ THIS->filament_stats.insert(std::pair(extruder_id, 0)); THIS->filament_stats[extruder_id] += length; %}; SV* filament_stats() %code%{ HV* hv = newHV(); for (std::map::const_iterator it = THIS->filament_stats.begin(); it != THIS->filament_stats.end(); ++it) { // stringify extruder_id std::ostringstream ss; ss << it->first; std::string str = ss.str(); (void)hv_store( hv, str.c_str(), str.length(), newSViv(it->second), 0 ); RETVAL = newRV_noinc((SV*)hv); } %}; void _simplify_slices(double distance); double max_allowed_layer_height() const; bool has_support_material() const; void auto_assign_extruders(ModelObject* model_object); void add_model_object(ModelObject* model_object, int idx = -1); bool apply_config(DynamicPrintConfig* config) %code%{ RETVAL = THIS->apply_config(*config); %}; bool has_infinite_skirt(); bool has_skirt(); std::string _validate() %code%{ RETVAL = THIS->validate(); %}; Clone bounding_box(); Clone total_bounding_box(); double skirt_first_layer_height(); Clone brim_flow(); Clone skirt_flow(); %{ double Print::total_used_filament(...) CODE: if (items > 1) { THIS->total_used_filament = (double)SvNV(ST(1)); } RETVAL = THIS->total_used_filament; OUTPUT: RETVAL double Print::total_extruded_volume(...) CODE: if (items > 1) { THIS->total_extruded_volume = (double)SvNV(ST(1)); } RETVAL = THIS->total_extruded_volume; OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/SupportMaterial.xsp000066400000000000000000000007711301441720000216360ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/SupportMaterial.hpp" %} %name{Slic3r::Print::SupportMaterial2} class PrintObjectSupportMaterial { PrintObjectSupportMaterial(PrintObject *print_object); ~PrintObjectSupportMaterial(); void generate(PrintObject *object) %code{% THIS->generate(*object); %}; }; %package{Slic3r::Print::SupportMaterial}; %{ SV* MARGIN() PROTOTYPE: CODE: RETVAL = newSVnv(SUPPORT_MATERIAL_MARGIN); OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/Surface.xsp000066400000000000000000000060161301441720000200710ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/Surface.hpp" #include "libslic3r/ClipperUtils.hpp" %} %name{Slic3r::Surface} class Surface { ~Surface(); Ref expolygon() %code{% RETVAL = &(THIS->expolygon); %}; double thickness() %code{% RETVAL = THIS->thickness; %}; unsigned short thickness_layers() %code{% RETVAL = THIS->thickness_layers; %}; double area(); bool is_solid() const; bool is_external() const; bool is_internal() const; bool is_bottom() const; bool is_bridge() const; %{ Surface* _new(CLASS, expolygon, surface_type, thickness, thickness_layers, bridge_angle, extra_perimeters) char* CLASS; ExPolygon* expolygon; SurfaceType surface_type; double thickness; unsigned short thickness_layers; double bridge_angle; unsigned short extra_perimeters; CODE: RETVAL = new Surface (surface_type, *expolygon); RETVAL->thickness = thickness; RETVAL->thickness_layers = thickness_layers; RETVAL->bridge_angle = bridge_angle; RETVAL->extra_perimeters = extra_perimeters; // we don't delete expolygon here because it's referenced by a Perl SV // whose DESTROY will take care of destruction OUTPUT: RETVAL SurfaceType Surface::surface_type(...) CODE: if (items > 1) { THIS->surface_type = (SurfaceType)SvUV(ST(1)); } RETVAL = THIS->surface_type; OUTPUT: RETVAL double Surface::bridge_angle(...) CODE: if (items > 1) { THIS->bridge_angle = (double)SvNV(ST(1)); } RETVAL = THIS->bridge_angle; OUTPUT: RETVAL unsigned short Surface::extra_perimeters(...) CODE: if (items > 1) { THIS->extra_perimeters = (double)SvUV(ST(1)); } RETVAL = THIS->extra_perimeters; OUTPUT: RETVAL Polygons Surface::polygons() CODE: RETVAL.push_back(THIS->expolygon.contour); for (Polygons::iterator it = THIS->expolygon.holes.begin(); it != THIS->expolygon.holes.end(); ++it) { RETVAL.push_back((*it)); } OUTPUT: RETVAL Surfaces Surface::offset(delta, scale = CLIPPER_OFFSET_SCALE, joinType = ClipperLib::jtMiter, miterLimit = 3) const float delta double scale ClipperLib::JoinType joinType double miterLimit CODE: offset(*THIS, &RETVAL, delta, scale, joinType, miterLimit); OUTPUT: RETVAL %} }; %package{Slic3r::Surface}; %{ IV _constant() ALIAS: S_TYPE_TOP = stTop S_TYPE_BOTTOM = stBottom S_TYPE_BOTTOMBRIDGE = stBottomBridge S_TYPE_INTERNAL = stInternal S_TYPE_INTERNALSOLID = stInternalSolid S_TYPE_INTERNALBRIDGE = stInternalBridge S_TYPE_INTERNALVOID = stInternalVoid S_TYPW_PERIMETER = stPerimeter PROTOTYPE: CODE: RETVAL = ix; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/SurfaceCollection.xsp000066400000000000000000000044451301441720000221110ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/SurfaceCollection.hpp" %} %name{Slic3r::Surface::Collection} class SurfaceCollection { %name{_new} SurfaceCollection(); ~SurfaceCollection(); void clear() %code{% THIS->surfaces.clear(); %}; void append(Surface* surface) %code{% THIS->surfaces.push_back(*surface); %}; int count() %code{% RETVAL = THIS->surfaces.size(); %}; void simplify(double tolerance); %{ SV* SurfaceCollection::arrayref() CODE: AV* av = newAV(); av_fill(av, THIS->surfaces.size()-1); int i = 0; for (Surfaces::iterator it = THIS->surfaces.begin(); it != THIS->surfaces.end(); ++it) { av_store(av, i++, perl_to_SV_ref(*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL SV* SurfaceCollection::filter_by_type(surface_type) SurfaceType surface_type; CODE: AV* av = newAV(); for (Surfaces::iterator it = THIS->surfaces.begin(); it != THIS->surfaces.end(); ++it) { if ((*it).surface_type == surface_type) av_push(av, perl_to_SV_ref(*it)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL void SurfaceCollection::replace(index, surface) int index Surface* surface CODE: THIS->surfaces[index] = *surface; void SurfaceCollection::set_surface_type(index, surface_type) int index SurfaceType surface_type; CODE: THIS->surfaces[index].surface_type = surface_type; SV* SurfaceCollection::group() CODE: // perform grouping std::vector groups; THIS->group(&groups); // build return arrayref AV* av = newAV(); av_fill(av, groups.size()-1); size_t i = 0; for (std::vector::iterator it = groups.begin(); it != groups.end(); ++it) { AV* innerav = newAV(); av_fill(innerav, it->size()-1); size_t j = 0; for (SurfacesPtr::iterator it_s = it->begin(); it_s != it->end(); ++it_s) { av_store(innerav, j++, perl_to_SV_clone_ref(**it_s)); } av_store(av, i++, newRV_noinc((SV*)innerav)); } RETVAL = newRV_noinc((SV*)av); OUTPUT: RETVAL %} }; Slic3r-version_1.31.6/xs/xsp/TriangleMesh.xsp000066400000000000000000000175061301441720000210710ustar00rootroot00000000000000%module{Slic3r::XS}; %{ #include #include "libslic3r/TriangleMesh.hpp" %} %name{Slic3r::TriangleMesh} class TriangleMesh { TriangleMesh(); ~TriangleMesh(); Clone clone() %code{% RETVAL = THIS; %}; void ReadSTLFile(char* input_file); void write_ascii(char* output_file); void write_binary(char* output_file); void repair(); void WriteOBJFile(char* output_file); void scale(float factor); void scale_xyz(Pointf3* versor) %code{% THIS->scale(*versor); %}; void translate(float x, float y, float z); void rotate_x(float angle); void rotate_y(float angle); void rotate_z(float angle); void mirror_x(); void mirror_y(); void mirror_z(); void align_to_origin(); void rotate(double angle, Point* center); TriangleMeshPtrs split(); void merge(TriangleMesh* mesh) %code{% THIS->merge(*mesh); %}; ExPolygons horizontal_projection(); Clone convex_hull(); Clone bounding_box(); Clone center() %code{% RETVAL = THIS->bounding_box().center(); %}; int facets_count(); void reset_repair_stats(); %{ void TriangleMesh::ReadFromPerl(vertices, facets) SV* vertices SV* facets CODE: stl_file &stl = THIS->stl; stl.error = 0; stl.stats.type = inmemory; // count facets and allocate memory AV* facets_av = (AV*)SvRV(facets); stl.stats.number_of_facets = av_len(facets_av)+1; stl.stats.original_num_facets = stl.stats.number_of_facets; stl_allocate(&stl); // read geometry AV* vertices_av = (AV*)SvRV(vertices); for (int i = 0; i < stl.stats.number_of_facets; i++) { AV* facet_av = (AV*)SvRV(*av_fetch(facets_av, i, 0)); stl_facet facet; facet.normal.x = 0; facet.normal.y = 0; facet.normal.z = 0; for (unsigned int v = 0; v <= 2; v++) { AV* vertex_av = (AV*)SvRV(*av_fetch(vertices_av, SvIV(*av_fetch(facet_av, v, 0)), 0)); facet.vertex[v].x = SvNV(*av_fetch(vertex_av, 0, 0)); facet.vertex[v].y = SvNV(*av_fetch(vertex_av, 1, 0)); facet.vertex[v].z = SvNV(*av_fetch(vertex_av, 2, 0)); } facet.extra[0] = 0; facet.extra[1] = 0; stl.facet_start[i] = facet; } stl_get_size(&stl); SV* TriangleMesh::stats() CODE: HV* hv = newHV(); (void)hv_stores( hv, "number_of_facets", newSViv(THIS->stl.stats.number_of_facets) ); (void)hv_stores( hv, "number_of_parts", newSViv(THIS->stl.stats.number_of_parts) ); (void)hv_stores( hv, "volume", newSVnv(THIS->stl.stats.volume) ); (void)hv_stores( hv, "degenerate_facets", newSViv(THIS->stl.stats.degenerate_facets) ); (void)hv_stores( hv, "edges_fixed", newSViv(THIS->stl.stats.edges_fixed) ); (void)hv_stores( hv, "facets_removed", newSViv(THIS->stl.stats.facets_removed) ); (void)hv_stores( hv, "facets_added", newSViv(THIS->stl.stats.facets_added) ); (void)hv_stores( hv, "facets_reversed", newSViv(THIS->stl.stats.facets_reversed) ); (void)hv_stores( hv, "backwards_edges", newSViv(THIS->stl.stats.backwards_edges) ); (void)hv_stores( hv, "normals_fixed", newSViv(THIS->stl.stats.normals_fixed) ); RETVAL = (SV*)newRV_noinc((SV*)hv); OUTPUT: RETVAL SV* TriangleMesh::vertices() CODE: if (!THIS->repaired) CONFESS("vertices() requires repair()"); if (THIS->stl.v_shared == NULL) stl_generate_shared_vertices(&(THIS->stl)); // vertices AV* vertices = newAV(); av_extend(vertices, THIS->stl.stats.shared_vertices); for (int i = 0; i < THIS->stl.stats.shared_vertices; i++) { AV* vertex = newAV(); av_store(vertices, i, newRV_noinc((SV*)vertex)); av_extend(vertex, 2); av_store(vertex, 0, newSVnv(THIS->stl.v_shared[i].x)); av_store(vertex, 1, newSVnv(THIS->stl.v_shared[i].y)); av_store(vertex, 2, newSVnv(THIS->stl.v_shared[i].z)); } RETVAL = newRV_noinc((SV*)vertices); OUTPUT: RETVAL SV* TriangleMesh::facets() CODE: if (!THIS->repaired) CONFESS("facets() requires repair()"); if (THIS->stl.v_shared == NULL) stl_generate_shared_vertices(&(THIS->stl)); // facets AV* facets = newAV(); av_extend(facets, THIS->stl.stats.number_of_facets); for (int i = 0; i < THIS->stl.stats.number_of_facets; i++) { AV* facet = newAV(); av_store(facets, i, newRV_noinc((SV*)facet)); av_extend(facet, 2); av_store(facet, 0, newSVnv(THIS->stl.v_indices[i].vertex[0])); av_store(facet, 1, newSVnv(THIS->stl.v_indices[i].vertex[1])); av_store(facet, 2, newSVnv(THIS->stl.v_indices[i].vertex[2])); } RETVAL = newRV_noinc((SV*)facets); OUTPUT: RETVAL SV* TriangleMesh::normals() CODE: if (!THIS->repaired) CONFESS("normals() requires repair()"); // normals AV* normals = newAV(); av_extend(normals, THIS->stl.stats.number_of_facets); for (int i = 0; i < THIS->stl.stats.number_of_facets; i++) { AV* facet = newAV(); av_store(normals, i, newRV_noinc((SV*)facet)); av_extend(facet, 2); av_store(facet, 0, newSVnv(THIS->stl.facet_start[i].normal.x)); av_store(facet, 1, newSVnv(THIS->stl.facet_start[i].normal.y)); av_store(facet, 2, newSVnv(THIS->stl.facet_start[i].normal.z)); } RETVAL = newRV_noinc((SV*)normals); OUTPUT: RETVAL SV* TriangleMesh::size() CODE: AV* size = newAV(); av_extend(size, 2); av_store(size, 0, newSVnv(THIS->stl.stats.size.x)); av_store(size, 1, newSVnv(THIS->stl.stats.size.y)); av_store(size, 2, newSVnv(THIS->stl.stats.size.z)); RETVAL = newRV_noinc((SV*)size); OUTPUT: RETVAL SV* TriangleMesh::slice(z) std::vector z CODE: // convert doubles to floats std::vector z_f(z.begin(), z.end()); std::vector layers; TriangleMeshSlicer mslicer(THIS); mslicer.slice(z_f, &layers); AV* layers_av = newAV(); size_t len = layers.size(); if (len > 0) av_extend(layers_av, len-1); for (unsigned int i = 0; i < layers.size(); i++) { AV* expolygons_av = newAV(); len = layers[i].size(); if (len > 0) av_extend(expolygons_av, len-1); unsigned int j = 0; for (ExPolygons::iterator it = layers[i].begin(); it != layers[i].end(); ++it) { av_store(expolygons_av, j++, perl_to_SV_clone_ref(*it)); } av_store(layers_av, i, newRV_noinc((SV*)expolygons_av)); } RETVAL = (SV*)newRV_noinc((SV*)layers_av); OUTPUT: RETVAL void TriangleMesh::cut(z, upper, lower) float z; TriangleMesh* upper; TriangleMesh* lower; CODE: TriangleMeshSlicer mslicer(THIS); mslicer.cut(z, upper, lower); std::vector TriangleMesh::bb3() CODE: RETVAL.push_back(THIS->stl.stats.min.x); RETVAL.push_back(THIS->stl.stats.min.y); RETVAL.push_back(THIS->stl.stats.max.x); RETVAL.push_back(THIS->stl.stats.max.y); RETVAL.push_back(THIS->stl.stats.min.z); RETVAL.push_back(THIS->stl.stats.max.z); OUTPUT: RETVAL %} }; %package{Slic3r::TriangleMesh}; %{ PROTOTYPES: DISABLE std::string hello_world() CODE: RETVAL = "Hello world!"; OUTPUT: RETVAL %} Slic3r-version_1.31.6/xs/xsp/XS.xsp000066400000000000000000000011001301441720000170200ustar00rootroot00000000000000%module{Slic3r::XS}; %package{Slic3r::XS}; #include %{ %} %package{Slic3r}; %{ SV* VERSION() CODE: RETVAL = newSVpv(SLIC3R_VERSION, 0); OUTPUT: RETVAL SV* DEBUG_OUT_PATH_PREFIX() CODE: RETVAL = newSVpv(SLIC3R_DEBUG_OUT_PATH_PREFIX, 0); OUTPUT: RETVAL SV* FORK_NAME() CODE: RETVAL = newSVpv(SLIC3R_FORK_NAME, 0); OUTPUT: RETVAL void xspp_test_croak_hangs_on_strawberry() CODE: try { throw 1; } catch (...) { croak("xspp_test_croak_hangs_on_strawberry: exception catched\n"); } %}Slic3r-version_1.31.6/xs/xsp/my.map000066400000000000000000000416571301441720000171030ustar00rootroot00000000000000coordf_t T_NV std::string T_STD_STRING t_config_option_key T_STD_STRING t_model_material_id T_STD_STRING std::vector T_STD_VECTOR_STD_STRING std::vector T_STD_VECTOR_INT std::vector T_STD_VECTOR_INT std::vector T_STD_VECTOR_INT std::vector T_STD_VECTOR_UINT std::vector T_STD_VECTOR_DOUBLE t_layer_height_ranges T_LAYER_HEIGHT_RANGES BoundingBox* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T BoundingBoxf* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T BoundingBoxf3* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T DynamicPrintConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T StaticPrintConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T PrintObjectConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T PrintRegionConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T GCodeConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T PrintConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T FullPrintConfig* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T ZTable* O_OBJECT TriangleMesh* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Point* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Point3* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Pointf* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Pointf3* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Line* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Linef3* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Polyline* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T PolylineCollection* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Polygon* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ExPolygon* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ExPolygonCollection* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ExtrusionEntityCollection* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ExtrusionPath* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ExtrusionLoop* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ExtrusionSimulator* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Filler* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Flow* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T PrintState* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Surface* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T SurfaceCollection* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Extruder* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Model* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ModelMaterial* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ModelObject* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ModelVolume* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T ModelInstance* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T PrintRegion* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T PrintObject* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Print* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T LayerRegion* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Layer* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T SupportLayer* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T PlaceholderParser* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T AvoidCrossingPerimeters* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T Wipe* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T OozePrevention* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T GCode* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T MotionPlanner* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T GCodeSender* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T GCodeWriter* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T GCodePressureEqualizer* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T BridgeDetector* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T PerimeterGenerator* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T PrintObjectSupportMaterial* O_OBJECT_SLIC3R Ref O_OBJECT_SLIC3R_T Clone O_OBJECT_SLIC3R_T GLVertexArray* O_OBJECT_SLIC3R Axis T_UV ExtrusionLoopRole T_UV ExtrusionRole T_UV ExtrusionSimulationType T_UV FlowRole T_UV PrintStep T_UV PrintObjectStep T_UV SurfaceType T_UV ClipperLib::JoinType T_UV ClipperLib::PolyFillType T_UV # we return these types whenever we want the items to be cloned Points T_ARRAYREF Pointfs T_ARRAYREF Lines T_ARRAYREF Polygons T_ARRAYREF Polylines T_ARRAYREF ExPolygons T_ARRAYREF ExtrusionPaths T_ARRAYREF Surfaces T_ARRAYREF # we return these types whenever we want the items to be returned # by reference and marked ::Ref because they're contained in another # Perl object Polygons* T_ARRAYREF_PTR ModelObjectPtrs* T_PTR_ARRAYREF_PTR ModelVolumePtrs* T_PTR_ARRAYREF_PTR ModelInstancePtrs* T_PTR_ARRAYREF_PTR PrintRegionPtrs* T_PTR_ARRAYREF_PTR PrintObjectPtrs* T_PTR_ARRAYREF_PTR LayerPtrs* T_PTR_ARRAYREF_PTR SupportLayerPtrs* T_PTR_ARRAYREF_PTR # we return these types whenever we want the items to be returned # by reference and not marked ::Ref because they're newly allocated # and not referenced by any Perl object TriangleMeshPtrs T_PTR_ARRAYREF INPUT T_STD_STRING { size_t len; // const char * c = SvPV($arg, len); // Always convert strings to UTF-8 before passing them to XS const char * c = SvPVutf8($arg, len); $var = std::string(c, len); } T_STD_VECTOR_STD_STRING if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVAV) { AV* av = (AV*)SvRV($arg); const unsigned int alen = av_len(av)+1; $var = std::vector(alen); STRLEN len; char* tmp; SV** elem; for (unsigned int i = 0; i < alen; i++) { elem = av_fetch(av, i, 0); if (elem != NULL) { tmp = SvPV(*elem, len); ${var}[i] = std::string(tmp, len); } else ${var}[i] = std::string(\"\"); } } else Perl_croak(aTHX_ \"%s: %s is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); T_STD_VECTOR_INT if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVAV) { AV* av = (AV*)SvRV($arg); const unsigned int len = av_len(av)+1; $var = std::vector(len); SV** elem; for (unsigned int i = 0; i < len; i++) { elem = av_fetch(av, i, 0); if (elem != NULL) ${var}[i] = SvIV(*elem); else ${var}[i] = 0; } } else Perl_croak(aTHX_ \"%s: %s is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); T_STD_VECTOR_UINT if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVAV) { AV* av = (AV*)SvRV($arg); const unsigned int len = av_len(av)+1; $var = std::vector(len); SV** elem; for (unsigned int i = 0; i < len; i++) { elem = av_fetch(av, i, 0); if (elem != NULL) ${var}[i] = SvUV(*elem); else ${var}[i] = 0; } } else Perl_croak(aTHX_ \"%s: %s is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); T_STD_VECTOR_DOUBLE if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVAV) { AV* av = (AV*)SvRV($arg); const unsigned int len = av_len(av)+1; $var = std::vector(len); SV** elem; for (unsigned int i = 0; i < len; i++) { elem = av_fetch(av, i, 0); if (elem != NULL) ${var}[i] = SvNV(*elem); else ${var}[i] = 0.; } } else Perl_croak(aTHX_ \"%s: %s is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); O_OBJECT_SLIC3R if( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) ) { if ( sv_isa($arg, Slic3r::perl_class_name($var) ) || sv_isa($arg, Slic3r::perl_class_name_ref($var) )) { $var = ($type)SvIV((SV*)SvRV( $arg )); } else { croak(\"$var is not of type %s (got %s)\", Slic3r::perl_class_name($var), HvNAME(SvSTASH(SvRV($arg)))); XSRETURN_UNDEF; } } else { warn( \"${Package}::$func_name() -- $var is not a blessed SV reference\" ); XSRETURN_UNDEF; } T_ARRAYREF if (SvROK($arg) && SvTYPE(SvRV($arg)) == SVt_PVAV) { AV* av = (AV*)SvRV($arg); const unsigned int len = av_len(av)+1; $var.resize(len); for (unsigned int i = 0; i < len; i++) { SV** elem = av_fetch(av, i, 0); from_SV_check(*elem, &$var\[i]); } } else Perl_croak(aTHX_ \"%s: %s is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); T_LAYER_HEIGHT_RANGES { if (!SvROK($arg) || SvTYPE(SvRV($arg)) != SVt_PVAV) { Perl_croak(aTHX_ \"%s: %s is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); } AV* av = (AV*)SvRV($arg); const unsigned int len = av_len(av)+1; t_layer_height_ranges tmp_ranges; for (unsigned int i = 0; i < len; i++) { SV* elem = *av_fetch(av, i, 0); if (!SvROK(elem) || SvTYPE(SvRV(elem)) != SVt_PVAV) { Perl_croak( aTHX_ \"%s: %s contains something that is not an array reference\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); } AV* elemAV = (AV*)SvRV(elem); if (av_len(elemAV) + 1 != 3) { Perl_croak( aTHX_ \"%s: %s contains an array that isn't 3 elements long\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, \"$var\"); } coordf_t vals[3]; for (unsigned int j = 0; j < 3; ++j) { SV *elem_elem = *av_fetch(elemAV, j, 0); if (!looks_like_number(elem_elem)) { Perl_croak( aTHX_ \"%s: layer ranges and heights must be numbers\", ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}); } vals[j] = SvNV(elem_elem); } tmp_ranges[t_layer_height_range(vals[0], vals[1])] = vals[2]; } $var = tmp_ranges; } OUTPUT T_STD_STRING $arg = newSVpvn_utf8( $var.c_str(), $var.length(), true ); T_STD_VECTOR_STD_STRING AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len) av_extend(av, len-1); for (unsigned int i = 0; i < len; i++) { const std::string& str = ${var}[i]; STRLEN len = str.length(); av_store(av, i, newSVpvn_utf8(str.c_str(), len, true)); } T_STD_VECTOR_INT AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len) av_extend(av, len-1); for (unsigned int i = 0; i < len; i++) { av_store(av, i, newSViv(${var}[i])); } T_STD_VECTOR_UINT AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len) av_extend(av, len-1); for (unsigned int i = 0; i < len; i++) { av_store(av, i, newSVuv(${var}[i])); } T_STD_VECTOR_DOUBLE AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len) av_extend(av, len-1); for (unsigned int i = 0; i < len; i++) { av_store(av, i, newSVnv(${var}[i])); } # return object from pointer O_OBJECT_SLIC3R if ($var == NULL) XSRETURN_UNDEF; sv_setref_pv( $arg, Slic3r::perl_class_name($var), (void*)$var ); # return value handled by template class O_OBJECT_SLIC3R_T if ($var == NULL) XSRETURN_UNDEF; sv_setref_pv( $arg, $type\::CLASS(), (void*)$var ); T_ARRAYREF AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len > 0) av_extend(av, len-1); int i = 0; for (${type}::const_iterator it = $var.begin(); it != $var.end(); ++it) { av_store(av, i++, perl_to_SV_clone_ref(*it)); } T_ARRAYREF_PTR AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var->size(); if (len > 0) av_extend(av, len-1); int i = 0; for (${ my $t = $type; $t =~ s/\*$//; \$t }::iterator it = $var->begin(); it != $var->end(); ++it) { av_store(av, i++, perl_to_SV_ref(*it)); } T_PTR_ARRAYREF_PTR AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var->size(); if (len > 0) av_extend(av, len-1); int i = 0; for (${ my $t = $type; $t =~ s/\*$//; \$t }::iterator it = $var->begin(); it != $var->end(); ++it) { av_store(av, i++, perl_to_SV_ref(**it)); } T_PTR_ARRAYREF AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len > 0) av_extend(av, len-1); int i = 0; for (${type}::iterator it = $var.begin(); it != $var.end(); ++it) { av_store(av, i++, to_SV(*it)); } T_LAYER_HEIGHT_RANGES AV* av = newAV(); $arg = newRV_noinc((SV*)av); sv_2mortal($arg); const unsigned int len = $var.size(); if (len > 0) av_extend(av, len-1); // map is sorted, so we can just copy it in order int i = 0; for (${type}::iterator it = $var.begin(); it != $var.end(); ++it) { const coordf_t range_values[] = { it->first.first, // key's first = minz it->first.second, // key's second = maxz it->second, // value = height }; AV *rangeAV = newAV(); av_extend(rangeAV, 2); for (int j = 0; j < 3; ++j) { av_store(rangeAV, j, newSVnv(range_values[j])); } av_store(av, i++, (SV*)newRV_noinc((SV*)rangeAV)); } Slic3r-version_1.31.6/xs/xsp/mytype.map000066400000000000000000000000001301441720000177560ustar00rootroot00000000000000Slic3r-version_1.31.6/xs/xsp/typemap.xspt000066400000000000000000000162051301441720000203450ustar00rootroot00000000000000%typemap{bool}{simple}; %typemap{size_t}{simple}; %typemap{coordf_t}{simple}; %typemap{std::string}; %typemap{t_config_option_key}; %typemap{t_model_material_id}; %typemap{std::vector}; %typemap{std::vector}; %typemap{std::vector*}; %typemap{std::vector}; %typemap{std::vector*}; %typemap{std::vector}; %typemap{std::vector*}; %typemap{std::vector}; %typemap{t_layer_height_ranges}; %typemap{void*}; %typemap{SV*}; %typemap{AV*}; %typemap{Point*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Point3*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Pointf*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Pointf3*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{BoundingBox*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{BoundingBoxf*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{BoundingBoxf3*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{DynamicPrintConfig*}; %typemap{Ref}{simple}; %typemap{StaticPrintConfig*}; %typemap{Ref}{simple}; %typemap{PrintObjectConfig*}; %typemap{Ref}{simple}; %typemap{PrintRegionConfig*}; %typemap{Ref}{simple}; %typemap{GCodeConfig*}; %typemap{Ref}{simple}; %typemap{PrintConfig*}; %typemap{Ref}{simple}; %typemap{FullPrintConfig*}; %typemap{Ref}{simple}; %typemap{ExPolygon*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ExPolygonCollection*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Filler*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Flow*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Line*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Linef3*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Polyline*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Polygon*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ExtrusionEntityCollection*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ExtrusionPath*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ExtrusionLoop*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ExtrusionSimulator*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{TriangleMesh*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{PolylineCollection*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{MotionPlanner*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{GCodeWriter*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{GCodeSender*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{GCodePressureEqualizer*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{BridgeDetector*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{SurfaceCollection*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{PerimeterGenerator*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Surface*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{PrintState*}; %typemap{Ref}{simple}; %typemap{PrintRegion*}; %typemap{Ref}{simple}; %typemap{PrintObject*}; %typemap{Ref}{simple}; %typemap{Print*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{LayerRegion*}; %typemap{Ref}{simple}; %typemap{Layer*}; %typemap{Ref}{simple}; %typemap{SupportLayer*}; %typemap{Ref}{simple}; %typemap{PrintObjectSupportMaterial*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{PlaceholderParser*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{AvoidCrossingPerimeters*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Wipe*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{OozePrevention*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{GCode*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Points}; %typemap{Pointfs}; %typemap{Lines}; %typemap{Polygons}; %typemap{Polylines}; %typemap{ExPolygons}; %typemap{ExtrusionPaths}; %typemap{Surfaces}; %typemap{Polygons*}; %typemap{TriangleMesh*}; %typemap{TriangleMeshPtrs}; %typemap{Extruder*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{Model*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelMaterial*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelObject*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelObjectPtrs*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelVolume*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelVolumePtrs*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelInstance*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{ModelInstancePtrs*}; %typemap{Ref}{simple}; %typemap{Clone}{simple}; %typemap{GLVertexArray*}; %typemap{PrintRegionPtrs*}; %typemap{PrintObjectPtrs*}; %typemap{LayerPtrs*}; %typemap{SupportLayerPtrs*}; %typemap{Axis}{parsed}{ %cpp_type{Axis}; %precall_code{% $CVar = (Axis)SvUV($PerlVar); %}; }; %typemap{SurfaceType}{parsed}{ %cpp_type{SurfaceType}; %precall_code{% $CVar = (SurfaceType)SvUV($PerlVar); %}; }; %typemap{ExtrusionLoopRole}{parsed}{ %cpp_type{ExtrusionLoopRole}; %precall_code{% $CVar = (ExtrusionLoopRole)SvUV($PerlVar); %}; }; %typemap{ExtrusionRole}{parsed}{ %cpp_type{ExtrusionRole}; %precall_code{% $CVar = (ExtrusionRole)SvUV($PerlVar); %}; }; %typemap{ExtrusionSimulationType}{parsed}{ %cpp_type{ExtrusionSimulationType}; %precall_code{% $CVar = (ExtrusionSimulationType)SvUV($PerlVar); %}; }; %typemap{FlowRole}{parsed}{ %cpp_type{FlowRole}; %precall_code{% $CVar = (FlowRole)SvUV($PerlVar); %}; }; %typemap{PrintStep}{parsed}{ %cpp_type{PrintStep}; %precall_code{% $CVar = (PrintStep)SvUV($PerlVar); %}; }; %typemap{PrintObjectStep}{parsed}{ %cpp_type{PrintObjectStep}; %precall_code{% $CVar = (PrintObjectStep)SvUV($PerlVar); %}; };