From a2a43570f5a449bfe6bdab4893fe00ec952ce3f2 Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:25:05 +0800
Subject: [PATCH 1/9] Create How to get compiled third-party dependency of OSG
and compile OSG.md
2022.6.21 The author jing_zhong teach you how to compile the third-party dependency of OSG and OSG successfully!
---
...party dependency of OSG and compile OSG.md | 244 ++++++++++++++++++
1 file changed, 244 insertions(+)
create mode 100644 osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md
diff --git a/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md b/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md
new file mode 100644
index 00000000000..303ab4f910b
--- /dev/null
+++ b/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md
@@ -0,0 +1,244 @@
+
How to build and compile the third-party libraries for OSG and OSG?
+
+ **The author called jing_zhong will introduce for you!**
+
+ If you want to compile the OSG on Windows platform, please ensure you have the compiled third-party dependency. Because I have compiled the third-party library for OpenScenegraph many times, write this tutorial and hope to help developers and engineers!
+
+# 1、Two general compiling methods
+
+In general , we use three compiled methods to compile the source code for obtaining the compiled .lib、.dll files (etc).
+
+## 1.1 MinGW---gcc--g++ for linux、unix-like、windows
+
+ configure->make->make install
+
+## 1.2 Visual Studio---MSVC---VC++ for Windows
+
+## ### 2.1 nmake
+
+## ### 2.2 CMake->configure->generate->open project->ALLBUILD->INSTALL
+
+
+
+## 2、The compiled third-party libraries includes
+
+ **Here indrocues 8 libraries:** curl、zlib、libpng、jpeg、freetype、glut、tiffand giflib.
+
+## 3、My compiled environment is following:
+
+### 3.1 **Operation System**
+
+### Windows 11(x64)
+
+### 3.2**Installed Software**
+
+ CMake、Microsoft Visual Studio 20015、MSYS2
+
+## 4、**Download the source code of third-party libraries and unzip them**
+
+
+ The download_url for the source code of third-party libraries!
+
+
+ curl-7.83.1.tar.gz
+ |
+
+ https://curl.se/download/curl-7.83.1.tar.gz
+ |
+
+
+
+ zlib-1.2.12.tar.gz
+ |
+
+ http://www.zlib.net/zlib-1.2.12.tar.gz
+ |
+
+
+
+ libpng-1.6.37.tar.gz
+ |
+
+ https://download.sourceforge.net/libpng/libpng-1.6.37.tar.gz
+ |
+
+
+
+ jpegsr9e.zip
+ |
+
+ http://www.ijg.org/files/jpegsr9e.zip
+ |
+
+
+
+ freetype-2.12.1.tar.gz
+ |
+
+ https://download.savannah.gnu.org/releases/freetype/freetype-2.12.1.tar.gz
+ |
+
+
+
+ glut37.zip
+ |
+
+ https://www.opengl.org/resources/libraries/glut/glut37.zip
+ |
+
+
+
+ tiff-4.4.0.tar.gz
+ |
+
+ http://download.osgeo.org/libtiff/tiff-4.4.0.tar.gz
+ |
+
+
+
+ giflib-5.2.1.tar.gz
+ |
+
+ https://sourceforge.net/projects/giflib/files/giflib-5.2.1.tar.gz
+ |
+
+
+
+
+
+
+## 5、Compile the third-party libraries for OSG(x64、Debug and Release)
+
+### 5.1 **The compiled order of third-party libraries for OSG**
+
+ curl > zlib > libpng > freetype > jpeg > glut > tiff > giflib
+
+### 5.2 **The compiled method of third-party libraries for OSG**
+
+
+ - curl (CMake---VS2015---ALLBUILD---INSTALL)
+
+ -
+ zlib (CMake---VS2015---ALLBUILD---INSTALL)
+
+ - libpng (CMake---VS2015---ALLBUILD---INSTALL)
+
+ -
+ freetype (VS2015---builds/win/2010---build)
+
+ - jpeg (configure->make->make install)
+
+ -
+ glut (VS2015---nmake---glutmake)
+
+ - tiff (CMake---VS2015---ALLBUILD---INSTALL)
+
+ -
+ giflib (VS2015---New Project---build)
+
+
+
+
+## 6、Notes(Must read)
+
+## 6.1 Attention for compiling libpng(x64、Debug and Release)
+
+ When compiling the libpng, you would better compile dependent libraries(**bzip2**、**brotli**、**harfbuzz**).
+
+(1) **Download the source code of three dependent libraries** **for libpng**.
+
+
+
+
+ bzip2-latest.tar.gz
+ |
+
+ http://sourceware.org/pub/bzip2/bzip2-latest.tar.gz
+ |
+
+
+
+ brotli
+ |
+
+ git clone https://github.com/google/brotli.git
+ |
+
+
+
+ harfbuzz-4.3.0.tar.xz
+ |
+
+ https://github.com/harfbuzz/harfbuzz/releases/download/4.3.0/harfbuzz-4.3.0.tar.xz
+ |
+
+
+
+
+(2) **The compiled method for three dependent libraries for libpng**.
+
+
+ -
+ bzip2 (CMake---VS2015---ALLBUILD---INSTALL)
+
+ -
+ brotli (CMake---VS2015---ALLBUILD---INSTALL)
+
+ -
+ harfbuzz (configure->make->make install)
+
+
+
+
+## 6.2 Attention for compiling glut(x64、Debug and Release)
+
+(1) Replace glutwin32.mak and edit it.
+(2) Copy the file->(C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Include\Win32.Mak) to the directory->(D:\Program Files (x86)\Microsoft Visual Studio 2015\VC\include) and rename this file as win32.mak.
+
+(3) Replace the file->(..\glut37\glut-3.7\lib\glut\Makefile.win)
+
+(4) Replace the file->(..\glut37\glut-3.7\progs\demos\particle\particle.c\)
+
+(5) Open the VS2015 developer command prompt and enter the directory of glut
+
+ type the command:
+
+```bash
+glutmake
+```
+
+## 6.3 Attention for compiling giflib(x64、Debug and Release)
+
+(1) Open VS 2015, New->Visual C++->Win32 Program->Select the static lib, do not include precompiled header
+
+(2) Open the file **gif_hash.h** and edit, comment the line:
+
+```c++
+// #include
+```
+
+(3) Open the file **gif_lib.h** and edit, in front of the line:
+
+```c++
+#ifdef __cplusplus
+```
+
+ add this code:
+
+```c++
+#pragma warning( disable : 4996 )
+```
+
+(4) Open the file **getopt.c** and edit, replace **#include** as **#include**
+
+(5) After build the program, mannually copy the **.lib** and **.h** to the installed giflib directory(**the folder lib、the folder include**)
+
+
+
+Finally, congratulations!!!
+
+# 7、Compile the OSG
+
+Download the source code of OSG.
+
+CMake->VS2015->ALLBUILD->INSTALL
From 683879f3c2c173426f3646ad13e5479dfb5e7290 Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:26:20 +0800
Subject: [PATCH 2/9] Update How to get compiled third-party dependency of OSG
and compile OSG.md
---
... compiled third-party dependency of OSG and compile OSG.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md b/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md
index 303ab4f910b..414fe2892a0 100644
--- a/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md
+++ b/osg-install-jing_zhong/How to get compiled third-party dependency of OSG and compile OSG.md
@@ -14,9 +14,9 @@ In general , we use three compiled methods to compile the source code for obtain
## 1.2 Visual Studio---MSVC---VC++ for Windows
-## ### 2.1 nmake
+### 1.2.1 nmake
-## ### 2.2 CMake->configure->generate->open project->ALLBUILD->INSTALL
+### 1.2.2 CMake->configure->generate->open project->ALLBUILD->INSTALL
From 98a98e8c78a2a13d4aa112bc35c1434508b9642a Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:29:20 +0800
Subject: [PATCH 3/9] Create ReadMe.md
---
osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/ReadMe.md | 1 +
1 file changed, 1 insertion(+)
create mode 100644 osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/ReadMe.md
diff --git a/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/ReadMe.md b/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/ReadMe.md
new file mode 100644
index 00000000000..075059be599
--- /dev/null
+++ b/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/ReadMe.md
@@ -0,0 +1 @@
+Needed files for compiling giflib! 2022.6.21 By jing_zhong
From 5e9469ef64987e8e7924122fcb67bedb9a282029 Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:29:52 +0800
Subject: [PATCH 4/9] Add files via upload
---
.../giflib-VS2015-build-NeedFiles/getopt.c | 1228 +++++++++++++++++
.../giflib-VS2015-build-NeedFiles/getopt.h | 173 +++
2 files changed, 1401 insertions(+)
create mode 100644 osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.c
create mode 100644 osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.h
diff --git a/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.c b/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.c
new file mode 100644
index 00000000000..8f9caa89f48
--- /dev/null
+++ b/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.c
@@ -0,0 +1,1228 @@
+/* Getopt for GNU.
+NOTE: getopt is now part of the C library, so if you don't know what
+"Keep this file name-space clean" means, talk to drepper@gnu.org
+before changing it!
+Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001
+Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+The GNU C Library 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
+Lesser General Public License for more details.
+You should have received a copy of the GNU Lesser General Public
+License along with the GNU C Library; if not, write to the Free
+Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA. */
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in .
+Ditto for AIX 3.2 and . */
+#ifndef _NO_PROTO
+# define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+# include
+#endif
+
+#if !defined __STDC__ || !__STDC__
+/* This is a separate conditional since some stdc systems
+reject `defined (const)'. */
+# ifndef const
+# define const
+# endif
+#endif
+
+#include
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+actually compiling the library itself. This code is part of the GNU C
+Library, but also included in many other GNU distributions. Compiling
+and linking in this code is a waste when using the GNU C library
+(especially if it is a shared library). Rather than having every GNU
+program understand `configure --with-gnu-libc' and omit the object files,
+it is simpler to just do this in the source for each such file. */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+# include
+# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+# define ELIDE_CODE
+# endif
+#endif
+
+#ifndef ELIDE_CODE
+
+
+/* This needs to come after some library #include
+to get __GNU_LIBRARY__ defined. */
+#ifdef __GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+contain conflicting prototypes for getopt. */
+# include
+# include
+#endif /* GNU C library. */
+
+#ifdef VMS
+# include
+# if HAVE_STRING_H - 0
+# include
+# endif
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages. */
+# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
+# include
+# ifndef _
+# define _(msgid) gettext (msgid)
+# endif
+# else
+# define _(msgid) (msgid)
+# endif
+# if defined _LIBC && defined USE_IN_LIBIO
+# include
+# endif
+#endif
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+but it behaves differently for the user, since it allows the user
+to intersperse the options with the other arguments.
+As `getopt' works, it permutes the elements of ARGV so that,
+when it is done, all the options precede everything else. Thus
+all application programs are extended to handle flexible argument order.
+Setting the environment variable POSIXLY_CORRECT disables permutation.
+Then the behavior is completely standard.
+GNU application programs can use a third alternative mode in which
+they can distinguish the relative order of options and other arguments. */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+When `getopt' finds an option that takes an argument,
+the argument value is returned here.
+Also, when `ordering' is RETURN_IN_ORDER,
+each non-option ARGV-element is returned here. */
+
+char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+This is used for communication to and from the caller
+and for communication between successive calls to `getopt'.
+On entry to `getopt', zero means this is the first call; initialize.
+When `getopt' returns -1, this is the index of the first of the
+non-option elements that the caller should itself scan.
+Otherwise, `optind' communicates from one call to the next
+how much of ARGV has been scanned so far. */
+
+/* 1003.2 says this must be 1 before any call. */
+int optind = 1;
+
+/* Formerly, initialization of getopt depended on optind==0, which
+causes problems with re-calling getopt as programs generally don't
+know that. */
+
+int __getopt_initialized;
+
+/* The next char to be scanned in the option-element
+in which the last option character we returned was found.
+This allows us to pick up the scan where we left off.
+If this is zero, or a null string, it means resume the scan
+by advancing to the next ARGV-element. */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+for unrecognized options. */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+This must be initialized on some systems to avoid linking in the
+system's own getopt implementation. */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+If the caller did not specify anything,
+the default is REQUIRE_ORDER if the environment variable
+POSIXLY_CORRECT is defined, PERMUTE otherwise.
+REQUIRE_ORDER means don't recognize them as options;
+stop option processing when the first non-option is seen.
+This is what Unix does.
+This mode of operation is selected by either setting the environment
+variable POSIXLY_CORRECT, or using `+' as the first character
+of the list of option characters.
+PERMUTE is the default. We permute the contents of ARGV as we scan,
+so that eventually all the non-options are at the end. This allows options
+to be given in any order, even with programs that were not written to
+expect this.
+RETURN_IN_ORDER is an option available to programs that were written
+to expect options and other ARGV-elements in any order and that care about
+the ordering of the two. We describe each non-option ARGV-element
+as if it were the argument of an option with character code 1.
+Using `-' as the first character of the list of option characters
+selects this mode of operation.
+The special argument `--' forces an end of option-scanning regardless
+of the value of `ordering'. In the case of RETURN_IN_ORDER, only
+`--' can cause `getopt' to return -1 with `optind' != ARGC. */
+
+static enum
+{
+ REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable. */
+static char *posixly_correct;
+
+#ifdef __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+because there are many ways it can cause trouble.
+On some systems, it contains special magic macros that don't work
+in GCC. */
+# include
+# define my_index strchr
+#else
+
+# if HAVE_STRING_H || WIN32 /* Pete Wilson mod 7/28/02 */
+# include
+# else
+# include
+# endif
+
+/* Avoid depending on library functions or files
+whose names are inconsistent. */
+
+#ifndef getenv
+extern char *getenv();
+#endif
+
+static char *
+my_index(str, chr)
+const char *str;
+int chr;
+{
+ while (*str)
+ {
+ if (*str == chr)
+ return (char *)str;
+ str++;
+ }
+ return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+If not using GCC, it is ok not to declare it. */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+That was relevant to code that was here before. */
+# if (!defined __STDC__ || !__STDC__) && !defined strlen
+/* gcc with -traditional declares the built-in strlen to return int,
+and has done so at least since version 2.4.5. -- rms. */
+extern int strlen(const char *);
+# endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments. */
+
+/* Describe the part of ARGV that contains non-options that have
+been skipped. `first_nonopt' is the index in ARGV of the first of them;
+`last_nonopt' is the index after the last of them. */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Stored original parameters.
+XXX This is no good solution. We should rather copy the args so
+that we can compare them later. But we must not use malloc(3). */
+extern int __libc_argc;
+extern char **__libc_argv;
+
+/* Bash 2.0 gives us an environment variable containing flags
+indicating ARGV elements that should not be considered arguments. */
+
+# ifdef USE_NONOPTION_FLAGS
+/* Defined in getopt_init.c */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+# endif
+
+# ifdef USE_NONOPTION_FLAGS
+# define SWAP_FLAGS(ch1, ch2) \
+ if (nonoption_flags_len > 0) \
+ { \
+ char __tmp = __getopt_nonoption_flags[ch1]; \
+ __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
+ __getopt_nonoption_flags[ch2] = __tmp; \
+ }
+# else
+# define SWAP_FLAGS(ch1, ch2)
+# endif
+#else /* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif /* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+One subsequence is elements [first_nonopt,last_nonopt)
+which contains all the non-options that have been skipped so far.
+The other is elements [last_nonopt,optind), which contains all
+the options processed since those non-options were skipped.
+`first_nonopt' and `last_nonopt' are relocated so that they describe
+the new indices of the non-options in ARGV after they are moved. */
+
+#if defined __STDC__ && __STDC__
+static void exchange(char **);
+#endif
+
+static void
+exchange(argv)
+char **argv;
+{
+ int bottom = first_nonopt;
+ int middle = last_nonopt;
+ int top = optind;
+ char *tem;
+
+ /* Exchange the shorter segment with the far end of the longer segment.
+ That puts the shorter segment into the right place.
+ It leaves the longer segment in the right place overall,
+ but it consists of two parts that need to be swapped next. */
+
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+ /* First make sure the handling of the `__getopt_nonoption_flags'
+ string can work normally. Our top argument must be in the range
+ of the string. */
+ if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+ {
+ /* We must extend the array. The user plays games with us and
+ presents new arguments. */
+ char *new_str = malloc(top + 1);
+ if (new_str == NULL)
+ nonoption_flags_len = nonoption_flags_max_len = 0;
+ else
+ {
+ memset(__mempcpy(new_str, __getopt_nonoption_flags,
+ nonoption_flags_max_len),
+ '\0', top + 1 - nonoption_flags_max_len);
+ nonoption_flags_max_len = top + 1;
+ __getopt_nonoption_flags = new_str;
+ }
+ }
+#endif
+
+ while (top > middle && middle > bottom)
+ {
+ if (top - middle > middle - bottom)
+ {
+ /* Bottom segment is the short one. */
+ int len = middle - bottom;
+ register int i;
+
+ /* Swap it with the top part of the top segment. */
+ for (i = 0; i < len; i++)
+ {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[top - (middle - bottom) + i];
+ argv[top - (middle - bottom) + i] = tem;
+ SWAP_FLAGS(bottom + i, top - (middle - bottom) + i);
+ }
+ /* Exclude the moved bottom segment from further swapping. */
+ top -= len;
+ }
+ else
+ {
+ /* Top segment is the short one. */
+ int len = top - middle;
+ register int i;
+
+ /* Swap it with the bottom part of the bottom segment. */
+ for (i = 0; i < len; i++)
+ {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[middle + i];
+ argv[middle + i] = tem;
+ SWAP_FLAGS(bottom + i, middle + i);
+ }
+ /* Exclude the moved top segment from further swapping. */
+ bottom += len;
+ }
+ }
+
+ /* Update records for the slots the non-options now occupy. */
+
+ first_nonopt += (optind - last_nonopt);
+ last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made. */
+
+#if defined __STDC__ && __STDC__
+static const char *_getopt_initialize(int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize(argc, argv, optstring)
+int argc;
+char *const *argv;
+const char *optstring;
+{
+ /* Start processing options with ARGV-element 1 (since ARGV-element 0
+ is the program name); the sequence of previously skipped
+ non-option ARGV-elements is empty. */
+
+ first_nonopt = last_nonopt = optind;
+
+ nextchar = NULL;
+
+ posixly_correct = getenv("POSIXLY_CORRECT");
+
+ /* Determine how to handle the ordering of options and nonoptions. */
+
+ if (optstring[0] == '-')
+ {
+ ordering = RETURN_IN_ORDER;
+ ++optstring;
+ }
+ else if (optstring[0] == '+')
+ {
+ ordering = REQUIRE_ORDER;
+ ++optstring;
+ }
+ else if (posixly_correct != NULL)
+ ordering = REQUIRE_ORDER;
+ else
+ ordering = PERMUTE;
+
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+ if (posixly_correct == NULL
+ && argc == __libc_argc && argv == __libc_argv)
+ {
+ if (nonoption_flags_max_len == 0)
+ {
+ if (__getopt_nonoption_flags == NULL
+ || __getopt_nonoption_flags[0] == '\0')
+ nonoption_flags_max_len = -1;
+ else
+ {
+ const char *orig_str = __getopt_nonoption_flags;
+ int len = nonoption_flags_max_len = strlen(orig_str);
+ if (nonoption_flags_max_len < argc)
+ nonoption_flags_max_len = argc;
+ __getopt_nonoption_flags =
+ (char *)malloc(nonoption_flags_max_len);
+ if (__getopt_nonoption_flags == NULL)
+ nonoption_flags_max_len = -1;
+ else
+ memset(__mempcpy(__getopt_nonoption_flags, orig_str, len),
+ '\0', nonoption_flags_max_len - len);
+ }
+ }
+ nonoption_flags_len = nonoption_flags_max_len;
+ }
+ else
+ nonoption_flags_len = 0;
+#endif
+
+ return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+given in OPTSTRING.
+If an element of ARGV starts with '-', and is not exactly "-" or "--",
+then it is an option element. The characters of this element
+(aside from the initial '-') are option characters. If `getopt'
+is called repeatedly, it returns successively each of the option characters
+from each of the option elements.
+If `getopt' finds another option character, it returns that character,
+updating `optind' and `nextchar' so that the next call to `getopt' can
+resume the scan with the following option character or ARGV-element.
+If there are no more option characters, `getopt' returns -1.
+Then `optind' is the index in ARGV of the first ARGV-element
+that is not an option. (The ARGV-elements have been permuted
+so that those that are not options now come last.)
+OPTSTRING is a string containing the legitimate option characters.
+If an option character is seen that is not listed in OPTSTRING,
+return '?' after printing an error message. If you set `opterr' to
+zero, the error message is suppressed but we still return '?'.
+If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+so the following text in the same ARGV-element, or the text of the following
+ARGV-element, is returned in `optarg'. Two colons mean an option that
+wants an optional arg; if there is text in the current ARGV-element,
+it is returned in `optarg', otherwise `optarg' is set to zero.
+If OPTSTRING starts with `-' or `+', it requests different methods of
+handling the non-option ARGV-elements.
+See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+Long-named options begin with `--' instead of `-'.
+Their names may be abbreviated as long as the abbreviation is unique
+or is an exact match for some defined option. If they have an
+argument, it follows the option name in the same ARGV-element, separated
+from the option name by a `=', or else the in next ARGV-element.
+When `getopt' finds a long-named option, it returns 0 if that option's
+`flag' field is nonzero, the value of the option's `val' field
+if the `flag' field is zero.
+The elements of ARGV aren't really const, because we permute them.
+But we pretend they're const in the prototype to be compatible
+with other systems.
+LONGOPTS is a vector of `struct option' terminated by an
+element containing a name which is zero.
+LONGIND returns the index in LONGOPT of the long-named option found.
+It is only valid when a long-named option has been found by the most
+recent call.
+If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+long-named options. */
+
+int
+_getopt_internal(argc, argv, optstring, longopts, longind, long_only)
+int argc;
+char *const *argv;
+const char *optstring;
+const struct option *longopts;
+int *longind;
+int long_only;
+{
+ int print_errors = opterr;
+ if (optstring[0] == ':')
+ print_errors = 0;
+
+ if (argc < 1)
+ return -1;
+
+ optarg = NULL;
+
+ if (optind == 0 || !__getopt_initialized)
+ {
+ if (optind == 0)
+ optind = 1; /* Don't scan ARGV[0], the program name. */
+ optstring = _getopt_initialize(argc, argv, optstring);
+ __getopt_initialized = 1;
+ }
+
+ /* Test whether ARGV[optind] points to a non-option argument.
+ Either it does not have option syntax, or there is an environment flag
+ from the shell indicating it is not an option. The later information
+ is only used when the used in the GNU libc. */
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
+ || (optind < nonoption_flags_len \
+ && __getopt_nonoption_flags[optind] == '1'))
+#else
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#endif
+
+ if (nextchar == NULL || *nextchar == '\0')
+ {
+ /* Advance to the next ARGV-element. */
+
+ /* Give FIRST_NONOPT and LAST_NONOPT rational values if OPTIND has been
+ moved back by the user (who may also have changed the arguments). */
+ if (last_nonopt > optind)
+ last_nonopt = optind;
+ if (first_nonopt > optind)
+ first_nonopt = optind;
+
+ if (ordering == PERMUTE)
+ {
+ /* If we have just processed some options following some non-options,
+ exchange them so that the options come first. */
+
+ if (first_nonopt != last_nonopt && last_nonopt != optind)
+ exchange((char **)argv);
+ else if (last_nonopt != optind)
+ first_nonopt = optind;
+
+ /* Skip any additional non-options
+ and extend the range of non-options previously skipped. */
+
+ while (optind < argc && NONOPTION_P)
+ optind++;
+ last_nonopt = optind;
+ }
+
+ /* The special ARGV-element `--' means premature end of options.
+ Skip it like a null option,
+ then exchange with previous non-options as if it were an option,
+ then skip everything else like a non-option. */
+
+ if (optind != argc && !strcmp(argv[optind], "--"))
+ {
+ optind++;
+
+ if (first_nonopt != last_nonopt && last_nonopt != optind)
+ exchange((char **)argv);
+ else if (first_nonopt == last_nonopt)
+ first_nonopt = optind;
+ last_nonopt = argc;
+
+ optind = argc;
+ }
+
+ /* If we have done all the ARGV-elements, stop the scan
+ and back over any non-options that we skipped and permuted. */
+
+ if (optind == argc)
+ {
+ /* Set the next-arg-index to point at the non-options
+ that we previously skipped, so the caller will digest them. */
+ if (first_nonopt != last_nonopt)
+ optind = first_nonopt;
+ return -1;
+ }
+
+ /* If we have come to a non-option and did not permute it,
+ either stop the scan or describe it to the caller and pass it by. */
+
+ if (NONOPTION_P)
+ {
+ if (ordering == REQUIRE_ORDER)
+ return -1;
+ optarg = argv[optind++];
+ return 1;
+ }
+
+ /* We have found another option-ARGV-element.
+ Skip the initial punctuation. */
+
+ nextchar = (argv[optind] + 1
+ + (longopts != NULL && argv[optind][1] == '-'));
+ }
+
+ /* Decode the current option-ARGV-element. */
+
+ /* Check whether the ARGV-element is a long option.
+ If long_only and the ARGV-element has the form "-f", where f is
+ a valid short option, don't consider it an abbreviated form of
+ a long option that starts with f. Otherwise there would be no
+ way to give the -f short option.
+ On the other hand, if there's a long option "fubar" and
+ the ARGV-element is "-fu", do consider that an abbreviation of
+ the long option, just like "--fu", and not "-f" with arg "u".
+ This distinction seems to be the most useful approach. */
+
+ if (longopts != NULL
+ && (argv[optind][1] == '-'
+ || (long_only && (argv[optind][2] || !my_index(optstring, argv[optind][1])))))
+ {
+ char *nameend;
+ const struct option *p;
+ const struct option *pfound = NULL;
+ int exact = 0;
+ int ambig = 0;
+ int indfound = -1;
+ int option_index;
+
+ for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+ /* Do nothing. */;
+
+ /* Test all long options for either exact match
+ or abbreviated matches. */
+ for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ if (!strncmp(p->name, nextchar, nameend - nextchar))
+ {
+ if ((unsigned int)(nameend - nextchar)
+ == (unsigned int)strlen(p->name))
+ {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ }
+ else if (pfound == NULL)
+ {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ }
+ else if (long_only
+ || pfound->has_arg != p->has_arg
+ || pfound->flag != p->flag
+ || pfound->val != p->val)
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
+
+ if (ambig && !exact)
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf, _("%s: option `%s' is ambiguous\n"),
+ argv[0], argv[optind]);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr, _("%s: option `%s' is ambiguous\n"),
+ argv[0], argv[optind]);
+#endif
+ }
+ nextchar += strlen(nextchar);
+ optind++;
+ optopt = 0;
+ return '?';
+ }
+
+ if (pfound != NULL)
+ {
+ option_index = indfound;
+ optind++;
+ if (*nameend)
+ {
+ /* Don't test has_arg with >, because some C compilers don't
+ allow it to be used on enums. */
+ if (pfound->has_arg)
+ optarg = nameend + 1;
+ else
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+#endif
+
+ if (argv[optind - 1][1] == '-')
+ {
+ /* --option */
+#if defined _LIBC && defined USE_IN_LIBIO
+ __asprintf(&buf, _("\
+%s: option `--%s' doesn't allow an argument\n"),
+argv[0], pfound->name);
+#else
+ fprintf(stderr, _("\
+%s: option `--%s' doesn't allow an argument\n"),
+argv[0], pfound->name);
+#endif
+ }
+ else
+ {
+ /* +option or -option */
+#if defined _LIBC && defined USE_IN_LIBIO
+ __asprintf(&buf, _("\
+%s: option `%c%s' doesn't allow an argument\n"),
+argv[0], argv[optind - 1][0],
+pfound->name);
+#else
+ fprintf(stderr, _("\
+%s: option `%c%s' doesn't allow an argument\n"),
+argv[0], argv[optind - 1][0], pfound->name);
+#endif
+ }
+
+#if defined _LIBC && defined USE_IN_LIBIO
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#endif
+ }
+
+ nextchar += strlen(nextchar);
+
+ optopt = pfound->val;
+ return '?';
+ }
+ }
+ else if (pfound->has_arg == 1)
+ {
+ if (optind < argc)
+ optarg = argv[optind++];
+ else
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+#endif
+ }
+ nextchar += strlen(nextchar);
+ optopt = pfound->val;
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ nextchar += strlen(nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag)
+ {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
+
+ /* Can't find it as a long option. If this is not getopt_long_only,
+ or the option starts with '--' or is not a valid short
+ option, then it's an error.
+ Otherwise interpret it as a short option. */
+ if (!long_only || argv[optind][1] == '-'
+ || my_index(optstring, *nextchar) == NULL)
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+#endif
+
+ if (argv[optind][1] == '-')
+ {
+ /* --option */
+#if defined _LIBC && defined USE_IN_LIBIO
+ __asprintf(&buf, _("%s: unrecognized option `--%s'\n"),
+ argv[0], nextchar);
+#else
+ fprintf(stderr, _("%s: unrecognized option `--%s'\n"),
+ argv[0], nextchar);
+#endif
+ }
+ else
+ {
+ /* +option or -option */
+#if defined _LIBC && defined USE_IN_LIBIO
+ __asprintf(&buf, _("%s: unrecognized option `%c%s'\n"),
+ argv[0], argv[optind][0], nextchar);
+#else
+ fprintf(stderr, _("%s: unrecognized option `%c%s'\n"),
+ argv[0], argv[optind][0], nextchar);
+#endif
+ }
+
+#if defined _LIBC && defined USE_IN_LIBIO
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#endif
+ }
+ nextchar = (char *) "";
+ optind++;
+ optopt = 0;
+ return '?';
+ }
+ }
+
+ /* Look at and handle the next short option-character. */
+
+ {
+ char c = *nextchar++;
+ char *temp = my_index(optstring, c);
+
+ /* Increment `optind' when we start to process its last character. */
+ if (*nextchar == '\0')
+ ++optind;
+
+ if (temp == NULL || c == ':')
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+#endif
+
+ if (posixly_correct)
+ {
+ /* 1003.2 specifies the format of this message. */
+#if defined _LIBC && defined USE_IN_LIBIO
+ __asprintf(&buf, _("%s: illegal option -- %c\n"),
+ argv[0], c);
+#else
+ fprintf(stderr, _("%s: illegal option -- %c\n"), argv[0], c);
+#endif
+ }
+ else
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ __asprintf(&buf, _("%s: invalid option -- %c\n"),
+ argv[0], c);
+#else
+ fprintf(stderr, _("%s: invalid option -- %c\n"), argv[0], c);
+#endif
+ }
+
+#if defined _LIBC && defined USE_IN_LIBIO
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#endif
+ }
+ optopt = c;
+ return '?';
+ }
+ /* Convenience. Treat POSIX -W foo same as long option --foo */
+ if (temp[0] == 'W' && temp[1] == ';')
+ {
+ char *nameend;
+ const struct option *p;
+ const struct option *pfound = NULL;
+ int exact = 0;
+ int ambig = 0;
+ int indfound = 0;
+ int option_index;
+
+ /* This is an option that requires an argument. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ optind++;
+ }
+ else if (optind == argc)
+ {
+ if (print_errors)
+ {
+ /* 1003.2 specifies the format of this message. */
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf, _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr, _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+#endif
+ }
+ optopt = c;
+ if (optstring[0] == ':')
+ c = ':';
+ else
+ c = '?';
+ return c;
+ }
+ else
+ /* We already incremented `optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ optarg = argv[optind++];
+
+ /* optarg is now the argument, see if it's in the
+ table of longopts. */
+
+ for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+ /* Do nothing. */;
+
+ /* Test all long options for either exact match
+ or abbreviated matches. */
+ for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ if (!strncmp(p->name, nextchar, nameend - nextchar))
+ {
+ if ((unsigned int)(nameend - nextchar) == strlen(p->name))
+ {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ }
+ else if (pfound == NULL)
+ {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ }
+ else
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
+ if (ambig && !exact)
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf, _("%s: option `-W %s' is ambiguous\n"),
+ argv[0], argv[optind]);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr, _("%s: option `-W %s' is ambiguous\n"),
+ argv[0], argv[optind]);
+#endif
+ }
+ nextchar += strlen(nextchar);
+ optind++;
+ return '?';
+ }
+ if (pfound != NULL)
+ {
+ option_index = indfound;
+ if (*nameend)
+ {
+ /* Don't test has_arg with >, because some C compilers don't
+ allow it to be used on enums. */
+ if (pfound->has_arg)
+ optarg = nameend + 1;
+ else
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+argv[0], pfound->name);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+argv[0], pfound->name);
+#endif
+ }
+
+ nextchar += strlen(nextchar);
+ return '?';
+ }
+ }
+ else if (pfound->has_arg == 1)
+ {
+ if (optind < argc)
+ optarg = argv[optind++];
+ else
+ {
+ if (print_errors)
+ {
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf, _("\
+%s: option `%s' requires an argument\n"),
+argv[0], argv[optind - 1]);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+#endif
+ }
+ nextchar += strlen(nextchar);
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ nextchar += strlen(nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag)
+ {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
+ nextchar = NULL;
+ return 'W'; /* Let the application handle it. */
+ }
+ if (temp[1] == ':')
+ {
+ if (temp[2] == ':')
+ {
+ /* This is an option that accepts an argument optionally. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ optind++;
+ }
+ else
+ optarg = NULL;
+ nextchar = NULL;
+ }
+ else
+ {
+ /* This is an option that requires an argument. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ optind++;
+ }
+ else if (optind == argc)
+ {
+ if (print_errors)
+ {
+ /* 1003.2 specifies the format of this message. */
+#if defined _LIBC && defined USE_IN_LIBIO
+ char *buf;
+
+ __asprintf(&buf,
+ _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+
+ if (_IO_fwide(stderr, 0) > 0)
+ __fwprintf(stderr, L"%s", buf);
+ else
+ fputs(buf, stderr);
+
+ free(buf);
+#else
+ fprintf(stderr,
+ _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+#endif
+ }
+ optopt = c;
+ if (optstring[0] == ':')
+ c = ':';
+ else
+ c = '?';
+ }
+ else
+ /* We already incremented `optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ optarg = argv[optind++];
+ nextchar = NULL;
+ }
+ }
+ return c;
+ }
+}
+
+int
+getopt(argc, argv, optstring)
+int argc;
+char *const *argv;
+const char *optstring;
+{
+ return _getopt_internal(argc, argv, optstring,
+ (const struct option *) 0,
+ (int *)0,
+ 0);
+}
+
+#endif /* Not ELIDE_CODE. */
+
+
+/* Compile with -DTEST to make an executable for use in testing
+the above definition of `getopt'. */
+
+/* #define TEST */ /* Pete Wilson mod 7/28/02 */
+#ifdef TEST
+
+#ifndef exit /* Pete Wilson mod 7/28/02 */
+int exit(int); /* Pete Wilson mod 7/28/02 */
+#endif /* Pete Wilson mod 7/28/02 */
+
+int
+main(argc, argv)
+int argc;
+char **argv;
+{
+ int c;
+ int digit_optind = 0;
+
+ while (1)
+ {
+ int this_option_optind = optind ? optind : 1;
+
+ c = getopt(argc, argv, "abc:d:0123456789");
+ if (c == -1)
+ break;
+
+ switch (c)
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (digit_optind != 0 && digit_optind != this_option_optind)
+ printf("digits occur in two different argv-elements.\n");
+ digit_optind = this_option_optind;
+ printf("option %c\n", c);
+ break;
+
+ case 'a':
+ printf("option a\n");
+ break;
+
+ case 'b':
+ printf("option b\n");
+ break;
+
+ case 'c':
+ printf("option c with value `%s'\n", optarg);
+ break;
+
+ case '?':
+ break;
+
+ default:
+ printf("?? getopt returned character code 0%o ??\n", c);
+ }
+ }
+
+ if (optind < argc)
+ {
+ printf("non-option ARGV-elements: ");
+ while (optind < argc)
+ printf("%s ", argv[optind++]);
+ printf("\n");
+ }
+
+ exit(0);
+}
+
+#endif /* TEST */
\ No newline at end of file
diff --git a/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.h b/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.h
new file mode 100644
index 00000000000..235ddcf20d4
--- /dev/null
+++ b/osg-install-jing_zhong/giflib-VS2015-build-NeedFiles/getopt.h
@@ -0,0 +1,173 @@
+/* getopt.h */
+/* Declarations for getopt.
+Copyright (C) 1989-1994, 1996-1999, 2001 Free Software
+Foundation, Inc. This file is part of the GNU C Library.
+The GNU C Library is free software; you can redistribute
+it and/or modify it under the terms of the GNU Lesser
+General Public License as published by the Free Software
+Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+The GNU C Library 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 Lesser General Public
+License for more details.
+You should have received a copy of the GNU Lesser General
+Public License along with the GNU C Library; if not, write
+to the Free Software Foundation, Inc., 59 Temple Place,
+Suite 330, Boston, MA 02111-1307 USA. */
+
+
+
+
+#ifndef _GETOPT_H
+
+#ifndef __need_getopt
+# define _GETOPT_H 1
+#endif
+
+/* If __GNU_LIBRARY__ is not already defined, either we are being used
+standalone, or this is the first header included in the source file.
+If we are being used with glibc, we need to include , but
+that does not exist if we are standalone. So: if __GNU_LIBRARY__ is
+not defined, include , which will pull in for us
+if it's from glibc. (Why ctype.h? It's guaranteed to exist and it
+doesn't flood the namespace with stuff the way some other headers do.) */
+#if !defined __GNU_LIBRARY__
+# include
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ /* For communication from `getopt' to the caller.
+ When `getopt' finds an option that takes an argument,
+ the argument value is returned here.
+ Also, when `ordering' is RETURN_IN_ORDER,
+ each non-option ARGV-element is returned here. */
+
+ extern char *optarg;
+
+ /* Index in ARGV of the next element to be scanned.
+ This is used for communication to and from the caller
+ and for communication between successive calls to `getopt'.
+ On entry to `getopt', zero means this is the first call; initialize.
+ When `getopt' returns -1, this is the index of the first of the
+ non-option elements that the caller should itself scan.
+ Otherwise, `optind' communicates from one call to the next
+ how much of ARGV has been scanned so far. */
+
+ extern int optind;
+
+ /* Callers store zero here to inhibit the error message `getopt' prints
+ for unrecognized options. */
+
+ extern int opterr;
+
+ /* Set to an option character which was unrecognized. */
+
+ extern int optopt;
+
+#ifndef __need_getopt
+ /* Describe the long-named options requested by the application.
+ The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+ of `struct option' terminated by an element containing a name which is
+ zero.
+ The field `has_arg' is:
+ no_argument (or 0) if the option does not take an argument,
+ required_argument (or 1) if the option requires an argument,
+ optional_argument (or 2) if the option takes an optional argument.
+ If the field `flag' is not NULL, it points to a variable that is set
+ to the value given in the field `val' when the option is found, but
+ left unchanged if the option is not found.
+ To have a long-named option do something other than set an `int' to
+ a compiled-in constant, such as set a value from `optarg', set the
+ option's `flag' field to zero and its `val' field to a nonzero
+ value (the equivalent single-letter option character, if there is
+ one). For long options that have a zero `flag' field, `getopt'
+ returns the contents of the `val' field. */
+
+ struct option
+ {
+# if (defined __STDC__ && __STDC__) || defined __cplusplus
+ const char *name;
+# else
+ char *name;
+# endif
+ /* has_arg can't be an enum because some compilers complain about
+ type mismatches in all the code that assumes it is an int. */
+ int has_arg;
+ int *flag;
+ int val;
+ };
+
+ /* Names for the values of the `has_arg' field of `struct option'. */
+
+# define no_argument 0
+# define required_argument 1
+# define optional_argument 2
+#endif /* need getopt */
+
+
+ /* Get definitions and prototypes for functions to process the
+ arguments in ARGV (ARGC of them, minus the program name) for
+ options given in OPTS.
+ Return the option character from OPTS just read. Return -1 when
+ there are no more options. For unrecognized options, or options
+ missing arguments, `optopt' is set to the option letter, and '?' is
+ returned.
+ The OPTS string is a list of characters which are recognized option
+ letters, optionally followed by colons, specifying that that letter
+ takes an argument, to be placed in `optarg'.
+ If a letter in OPTS is followed by two colons, its argument is
+ optional. This behavior is specific to the GNU `getopt'.
+ The argument `--' causes premature termination of argument
+ scanning, explicitly telling `getopt' that there are no more
+ options.
+ If OPTS begins with `--', then non-option arguments are treated as
+ arguments to the option '\0'. This behavior is specific to the GNU
+ `getopt'. */
+
+#if (defined __STDC__ && __STDC__) || defined __cplusplus
+# ifdef __GNU_LIBRARY__
+ /* Many other libraries have conflicting prototypes for getopt, with
+ differences in the consts, in stdlib.h. To avoid compilation
+ errors, only prototype getopt for the GNU C library. */
+ extern int getopt(int ___argc, char *const *___argv, const char *__shortopts);
+# else /* not __GNU_LIBRARY__ */
+ extern int getopt();
+# endif /* __GNU_LIBRARY__ */
+
+# ifndef __need_getopt
+ extern int getopt_long(int ___argc, char *const *___argv,
+ const char *__shortopts,
+ const struct option *__longopts, int *__longind);
+ extern int getopt_long_only(int ___argc, char *const *___argv,
+ const char *__shortopts,
+ const struct option *__longopts, int *__longind);
+
+ /* Internal only. Users should not call this directly. */
+ extern int _getopt_internal(int ___argc, char *const *___argv,
+ const char *__shortopts,
+ const struct option *__longopts, int *__longind,
+ int __long_only);
+# endif
+#else /* not __STDC__ */
+ extern int getopt();
+# ifndef __need_getopt
+ extern int getopt_long();
+ extern int getopt_long_only();
+
+ extern int _getopt_internal();
+# endif
+#endif /* __STDC__ */
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Make sure we later can get all the definitions and declarations. */
+#undef __need_getopt
+
+#endif /* getopt.h */
\ No newline at end of file
From 32af9592e0206e90cad4f3026c9470c4f1f87827 Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:30:53 +0800
Subject: [PATCH 5/9] Create ReadMe.md
---
osg-install-jing_zhong/glut-nmake-compile-NeedFiles/ReadMe.md | 1 +
1 file changed, 1 insertion(+)
create mode 100644 osg-install-jing_zhong/glut-nmake-compile-NeedFiles/ReadMe.md
diff --git a/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/ReadMe.md b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/ReadMe.md
new file mode 100644
index 00000000000..c30e1a3e4eb
--- /dev/null
+++ b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/ReadMe.md
@@ -0,0 +1 @@
+Needef files for compiling glut!
From ddfc718022adbca1a1ed8b45dc627eb99e72f257 Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:31:23 +0800
Subject: [PATCH 6/9] Add files via upload
---
.../glut-nmake-compile-NeedFiles/Makefile.win | 87 +++
.../glutwin32.mak | 79 +++
.../glut-nmake-compile-NeedFiles/particle.c | 638 +++++++++++++++++
.../glut-nmake-compile-NeedFiles/win32.Mak | 671 ++++++++++++++++++
4 files changed, 1475 insertions(+)
create mode 100644 osg-install-jing_zhong/glut-nmake-compile-NeedFiles/Makefile.win
create mode 100644 osg-install-jing_zhong/glut-nmake-compile-NeedFiles/glutwin32.mak
create mode 100644 osg-install-jing_zhong/glut-nmake-compile-NeedFiles/particle.c
create mode 100644 osg-install-jing_zhong/glut-nmake-compile-NeedFiles/win32.Mak
diff --git a/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/Makefile.win b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/Makefile.win
new file mode 100644
index 00000000000..4ea56804c09
--- /dev/null
+++ b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/Makefile.win
@@ -0,0 +1,87 @@
+# Makefile for Win32
+
+!include
+
+TOP = ../..
+
+# NOTE: glut_menu.c and glut_glxext.c are NOT compiled into Win32 GLUT
+
+SRCS = glut_8x13.c glut_9x15.c glut_bitmap.c glut_bwidth.c glut_cindex.c glut_cmap.c glut_cursor.c glut_dials.c glut_dstr.c glut_event.c glut_ext.c glut_fullscrn.c glut_gamemode.c glut_get.c glut_hel10.c glut_hel12.c glut_hel18.c glut_init.c glut_input.c glut_joy.c glut_key.c glut_keyctrl.c glut_keyup.c glut_mesa.c glut_modifier.c glut_mroman.c glut_overlay.c glut_roman.c glut_shapes.c glut_space.c glut_stroke.c glut_swap.c glut_swidth.c glut_tablet.c glut_teapot.c glut_tr10.c glut_tr24.c glut_util.c glut_vidresize.c glut_warp.c glut_win.c glut_winmisc.c win32_glx.c win32_menu.c win32_util.c win32_winproc.c win32_x11.c
+
+all : glutdll install
+
+!include "$(TOP)/glutwin32.mak"
+
+glutdll : $(GLUTDLL)
+
+CFLAGS = $(cvarsdll) $(CFLAGS)
+LFLAGS = $(dlllflags) $(LFLAGS)
+
+OBJS = $(SRCS:.c=.obj)
+LIBS = $(OPENGL) $(GLU) winmm.lib $(guilibsdll)
+
+$(GLUTDLL) : $(OBJS) glut.def
+ $(link) $(LFLAGS) -out:$(GLUTDLL) -def:glut.def $(OBJS) $(LIBS) -NODEFAULTLIB:$(GLUTLIB)
+
+install : $(GLUTDLL)
+ @echo "copying GLUT dynamic link library to system directory..."
+ -copy $(GLUTDLL) $(DLLINSTALL)
+ @echo "copying GLUT header file to include directory..."
+ -copy ..\..\include\GL\glut.h $(INCLUDEINSTALL)
+ @echo "copying GLUT import library to library directory..."
+ -copy $(GLUTLIB) $(LIBINSTALL)
+
+.c.obj :
+ $(cc) $(CFLAGS) -I . $*.c
+
+# explicit object dependencies for all source files
+
+win32_glx.obj: win32_glx.c win32_glx.h
+win32_x11.obj: win32_x11.c win32_x11.h
+win32_menu.obj: win32_menu.c glutint.h ..\..\include\GL\glut.h
+win32_util.obj: win32_util.c glutint.h
+win32_winproc.obj: win32_winproc.c glutint.h
+
+glut_mroman.obj: glut_mroman.c glutstroke.h glutint.h
+glut_roman.obj: glut_roman.c glutstroke.h glutint.h
+glut_hel12.obj: glut_hel12.c glutbitmap.h glutint.h
+glut_8x13.obj: glut_8x13.c glutbitmap.h glutint.h
+glut_hel18.obj: glut_hel18.c glutbitmap.h glutint.h
+glut_9x15.obj: glut_9x15.c glutbitmap.h glutint.h
+glut_tr10.obj: glut_tr10.c glutbitmap.h glutint.h
+glut_hel10.obj: glut_hel10.c glutbitmap.h glutint.h
+glut_tr24.obj: glut_tr24.c glutbitmap.h glutint.h
+
+glut_bitmap.obj: glut_bitmap.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_bwidth.obj: glut_bwidth.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_cindex.obj: glut_cindex.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_cmap.obj: glut_cmap.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_cursor.obj: glut_cursor.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_dials.obj: glut_dials.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_dstr.obj: glut_dstr.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_event.obj: glut_event.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_ext.obj: glut_ext.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_fullscrn.obj: glut_fullscrn.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_gamemode.obj: glut_gamemode.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_get.obj: glut_get.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_init.obj: glut_init.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_input.obj: glut_input.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_joy.obj: glut_joy.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_key.obj: glut_key.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_keyctrl.obj: glut_keyctrl.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_keyup.obj: glut_keyup.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_mesa.obj: glut_mesa.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_modifier.obj: glut_modifier.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_overlay.obj: glut_overlay.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_shapes.obj: glut_shapes.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_space.obj: glut_space.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_swap.obj: glut_swap.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_swidth.obj: glut_swidth.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_tablet.obj: glut_tablet.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_teapot.obj: glut_teapot.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_util.obj: glut_util.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_vidresize.obj: glut_vidresize.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_warp.obj: glut_warp.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+glut_win.obj: glut_win.c glutint.h ..\..\include\GL\glut.h glutwin32.h
+glut_winmisc.obj: glut_winmisc.c glutint.h ..\..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
+
diff --git a/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/glutwin32.mak b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/glutwin32.mak
new file mode 100644
index 00000000000..8f4252a8e4e
--- /dev/null
+++ b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/glutwin32.mak
@@ -0,0 +1,79 @@
+
+# Be sure to modify the definitions in this file to agree with your
+# systems installation.
+# NOTE: be sure that the install directories use '\' not '/' for paths.
+
+
+# MSVC install directories
+LIBINSTALL = "F:\\workspace\\osg-3rdParty-install\\glut\\lib"
+INCLUDEINSTALL = "F:\\workspace\\osg-3rdParty-install\\glut\\include\\GL"
+
+# Win95 dll directory
+#DLLINSTALL = "F:\\workspace\\osg-3rdParty-install\\glut\\bin"
+
+# WinNT dll directory
+DLLINSTALL = "F:\\workspace\\osg-3rdParty-install\\glut\\bin"
+
+# Microsoft OpenGL libraries
+#
+GLU = glu32.lib
+OPENGL = opengl32.lib
+GLUT = $(TOP)/lib/glut/glut.lib
+GLUTLIB = glut.lib
+GLUTDLL = glut.dll
+
+# SGI OpenGL for Windows libraries (formerly Cosmo OpenGL)
+# >> To use, uncomment lines below and comment out the similiar
+# >> lines above. You can download SGI OpenGL for Windows for
+# >> free from http://www.meer.net/~gold/OpenGL/opengl2.exe
+#
+#GLU = \oglsdk\lib\glu.lib
+#OPENGL = \oglsdk\lib\opengl.lib
+#GLUT = $(TOP)/lib/glut/glut.lib
+#GLUTLIB = glut.lib
+#GLUTDLL = glut.dll
+
+# The Micro UI lib
+MUI = $(TOP)/lib/mui/mui.lib
+
+# The OpenGL Extrusion and Tubing lib
+GLE = $(TOP)/lib/gle/gle.lib
+
+# The OpenGL Sphere Mapping lib
+GLSMAP = $(TOP)/lib/glsmap/glsmap.lib
+
+# common definitions used by all makefiles
+CFLAGS = $(cflags) $(cdebug) $(EXTRACFLAGS) -DWIN32 -I$(TOP)/include
+LIBS = $(lflags) $(ldebug) $(EXTRALIBS) $(GLUT) $(GLU) $(OPENGL) $(guilibs)
+EXES = $(SRCS:.c=.exe) $(CPPSRCS:.cpp=.exe)
+
+!IFNDEF NODEBUG
+lcommon = /NODEFAULTLIB /INCREMENTAL:NO /DEBUG /NOLOGO
+!ENDIF
+
+# default rule
+default : $(EXES)
+
+# cleanup rules
+clean ::
+ @del /f *.obj
+ @del /f *.pdb
+ @del /f *.ilk
+ @del /f *.ncb
+ @del /f *~
+ @del /f *.exp
+
+clobber :: clean
+ @del /f *.exe
+ @del /f *.dll
+ @del /f *.lib
+ -@del /f $(LDIRT)
+
+# inference rules
+$(EXES) : $*.obj $(DEPLIBS)
+ echo $@
+ $(link) -out:$@ $** $(LIBS)
+.c.obj :
+ $(CC) $(CFLAGS) $<
+.cpp.obj :
+ $(CC) $(CFLAGS) $<
diff --git a/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/particle.c b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/particle.c
new file mode 100644
index 00000000000..153ebf29561
--- /dev/null
+++ b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/particle.c
@@ -0,0 +1,638 @@
+/*
+ particle.c
+ Nate Robins, 1997
+
+ An example of a simple particle system.
+
+ */
+
+
+#include
+#include
+#include
+#include
+#include
+
+
+#ifdef _WIN32
+#define drand48() ((float)rand()/RAND_MAX)
+#endif
+
+
+/* #define SCREEN_SAVER_MODE */
+
+#define PS_GRAVITY -9.8
+#define PS_WATERFALL 0
+#define PS_FOUNTAIN 1
+
+
+typedef struct {
+ float x, y, z;
+ float radius;
+} PSsphere;
+
+typedef struct {
+ float position[3]; /* current position */
+ float previous[3]; /* previous position */
+ float velocity[3]; /* velocity (magnitude & direction) */
+ float dampening; /* % of energy lost on collision */
+ int alive; /* is this particle alive? */
+} PSparticle;
+
+
+PSparticle* particles = NULL;
+PSsphere sphere = { 0, 1, 0, 0.25 };
+int num_particles = 5000;
+int type = PS_WATERFALL;
+int points = 1;
+int do_sphere = 0;
+int frame_rate = 1;
+float frame_time = 0;
+float flow = 500;
+float slow_down = 1;
+
+float spin_x = 0;
+float spin_y = 0;
+int point_size = 3;
+
+#if defined(_WIN32)
+#include
+#else
+#include
+#include
+#include
+#include
+#endif
+
+/* timedelta: returns the number of seconds that have elapsed since
+ the previous call to the function. */
+float
+timedelta(void)
+{
+ static long begin = 0;
+ static long finish, difference;
+
+#if defined(_WIN32)
+ static struct timeb tb;
+
+ ftime(&tb);
+ finish = tb.time*1000+tb.millitm;
+#else
+ static struct tms tb;
+
+ finish = times(&tb);
+#endif
+
+ difference = finish - begin;
+ begin = finish;
+
+ return (float)difference/(float)1000; /* CLK_TCK=1000 */
+}
+
+
+/* text: draws a string of text with an 18 point helvetica bitmap font
+ at position (x,y) in window space (bottom left corner is (0,0). */
+void
+text(int x, int y, char* s)
+{
+ int lines;
+ char* p;
+
+ glDisable(GL_DEPTH_TEST);
+ glMatrixMode(GL_PROJECTION);
+ glPushMatrix();
+ glLoadIdentity();
+ glOrtho(0, glutGet(GLUT_WINDOW_WIDTH),
+ 0, glutGet(GLUT_WINDOW_HEIGHT), -1, 1);
+ glMatrixMode(GL_MODELVIEW);
+ glPushMatrix();
+ glLoadIdentity();
+ glColor3ub(0, 0, 0);
+ glRasterPos2i(x+1, y-1);
+ for(p = s, lines = 0; *p; p++) {
+ if (*p == '\n') {
+ lines++;
+ glRasterPos2i(x+1, y-1-(lines*18));
+ }
+ glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, *p);
+ }
+ glColor3ub(128, 0, 255);
+ glRasterPos2i(x, y);
+ for(p = s, lines = 0; *p; p++) {
+ if (*p == '\n') {
+ lines++;
+ glRasterPos2i(x, y-(lines*18));
+ }
+ glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, *p);
+ }
+ glMatrixMode(GL_PROJECTION);
+ glPopMatrix();
+ glMatrixMode(GL_MODELVIEW);
+ glPopMatrix();
+ glEnable(GL_DEPTH_TEST);
+}
+
+
+int
+fequal(float a, float b)
+{
+ float epsilon = 0.1;
+ float f = a - b;
+
+ if (f < epsilon && f > -epsilon)
+ return 1;
+ else
+ return 0;
+}
+
+
+void
+psTimeStep(PSparticle* p, float dt)
+{
+ if (p->alive == 0)
+ return;
+
+ p->velocity[0] += 0;
+ p->velocity[1] += PS_GRAVITY*dt;
+ p->velocity[2] += 0;
+
+ p->previous[0] = p->position[0];
+ p->previous[1] = p->position[1];
+ p->previous[2] = p->position[2];
+
+ p->position[0] += p->velocity[0]*dt;
+ p->position[1] += p->velocity[1]*dt;
+ p->position[2] += p->velocity[2]*dt;
+}
+
+
+void
+psNewParticle(PSparticle* p, float dt)
+{
+ if (type == PS_WATERFALL) {
+ p->velocity[0] = 1*(drand48()-0.5);
+ p->velocity[1] = 0;
+ p->velocity[2] = 0.5*(drand48()-0.0);
+ p->position[0] = 0;
+ p->position[1] = 2;
+ p->position[2] = 0;
+ p->previous[0] = p->position[0];
+ p->previous[1] = p->position[1];
+ p->previous[2] = p->position[2];
+ p->dampening = 0.45*drand48();
+ p->alive = 1;
+ } else if (type == PS_FOUNTAIN) {
+ p->velocity[0] = 2*(drand48()-0.5);
+ p->velocity[1] = 6;
+ p->velocity[2] = 2*(drand48()-0.5);
+ p->position[0] = 0;
+ p->position[1] = 0;
+ p->position[2] = 0;
+ p->previous[0] = p->position[0];
+ p->previous[1] = p->position[1];
+ p->previous[2] = p->position[2];
+ p->dampening = 0.35*drand48();
+ p->alive = 1;
+ }
+
+ psTimeStep(p, 2*dt*drand48());
+}
+
+
+/* psBounce: the particle has gone past (or exactly hit) the ground
+ plane, so calculate the time at which the particle actually
+ intersected the ground plane (s). essentially, this just rolls
+ back time to when the particle hit the ground plane, then starts
+ time again from then.
+
+ - - o A (previous position)
+ | | \
+ | s \ o (position it _should_ be at) -
+ t | \ / | t - s
+ | - ------X-------- -
+ | \
+ - o B (new position)
+
+ A + V*s = 0 or s = -A/V
+
+ to calculate where the particle should be:
+
+ A + V*t + V*(t-s)*d
+
+ where d is a damping factor which accounts for the loss
+ of energy due to the bounce. */
+void
+psBounce(PSparticle* p, float dt)
+{
+ float s;
+
+ if (p->alive == 0)
+ return;
+
+ /* since we know it is the ground plane, we only need to
+ calculate s for a single dimension. */
+ s = -p->previous[1]/p->velocity[1];
+
+ p->position[0] = (p->previous[0] + p->velocity[0] * s +
+ p->velocity[0] * (dt-s) * p->dampening);
+ p->position[1] = -p->velocity[1] * (dt-s) * p->dampening; /* reflect */
+ p->position[2] = (p->previous[2] + p->velocity[2] * s +
+ p->velocity[2] * (dt-s) * p->dampening);
+
+ /* damp the reflected velocity (since the particle hit something,
+ it lost some energy) */
+ p->velocity[0] *= p->dampening;
+ p->velocity[1] *= -p->dampening; /* reflect */
+ p->velocity[2] *= p->dampening;
+}
+
+void
+psCollide(PSparticle* p)
+{
+ float vx = p->position[0] - sphere.x;
+ float vy = p->position[1] - sphere.y;
+ float vz = p->position[2] - sphere.z;
+ float distance;
+
+ if (p->alive == 0)
+ return;
+
+ distance = sqrt(vx*vx + vy*vy + vz*vz);
+
+ if (distance < sphere.radius) {
+#if 0
+ vx /= distance; vy /= distance; vz /= distance;
+ d = 2*(-vx*p->velocity[0] + -vy*p->velocity[1] + -vz*p->velocity[2]);
+ p->velocity[0] += vx*d*2;
+ p->velocity[1] += vy*d*2;
+ p->velocity[2] += vz*d*2;
+ d = sqrt(p->velocity[0]*p->velocity[0] +
+ p->velocity[1]*p->velocity[1] +
+ p->velocity[2]*p->velocity[2]);
+ p->velocity[0] /= d;
+ p->velocity[1] /= d;
+ p->velocity[2] /= d;
+#else
+ p->position[0] = sphere.x+(vx/distance)*sphere.radius;
+ p->position[1] = sphere.y+(vy/distance)*sphere.radius;
+ p->position[2] = sphere.z+(vz/distance)*sphere.radius;
+ p->previous[0] = p->position[0];
+ p->previous[1] = p->position[1];
+ p->previous[2] = p->position[2];
+ p->velocity[0] = vx/distance;
+ p->velocity[1] = vy/distance;
+ p->velocity[2] = vz/distance;
+#endif
+ }
+}
+
+
+void
+reshape(int width, int height)
+{
+ float black[] = { 0, 0, 0, 0 };
+
+ glViewport(0, 0, width, height);
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ gluPerspective(60, 1, 0.1, 1000);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ gluLookAt(0, 1, 3, 0, 1, 0, 0, 1, 0);
+ glFogfv(GL_FOG_COLOR, black);
+ glFogf(GL_FOG_START, 2.5);
+ glFogf(GL_FOG_END, 4);
+ glEnable(GL_FOG);
+ glFogi(GL_FOG_MODE, GL_LINEAR);
+ glPointSize(point_size);
+ glEnable(GL_POINT_SMOOTH);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glEnable(GL_COLOR_MATERIAL);
+ glEnable(GL_DEPTH_TEST);
+ glEnable(GL_LIGHT0);
+
+ timedelta();
+}
+
+
+void
+display(void)
+{
+ static int i;
+ static float c;
+ static char s[32];
+ static int frames = 0;
+
+ glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+ glPushMatrix();
+
+ glRotatef(spin_y, 1, 0, 0);
+ glRotatef(spin_x, 0, 1, 0);
+
+ glEnable(GL_LIGHTING);
+ if (do_sphere) {
+ glPushMatrix();
+ glTranslatef(sphere.x, sphere.y, sphere.z);
+ glColor3ub(0, 255, 128);
+ glutSolidSphere(sphere.radius, 16, 16);
+ glPopMatrix();
+ }
+ glDisable(GL_LIGHTING);
+
+ glBegin(GL_QUADS);
+ glColor3ub(0, 128, 255);
+ glVertex3f(-2, 0, -2);
+ glVertex3f(-2, 0, 2);
+ glVertex3f(2, 0, 2);
+ glVertex3f(2, 0, -2);
+ glEnd();
+
+ if (points) {
+ glBegin(GL_POINTS);
+
+ for (i = 0; i < num_particles; i++) {
+ if (particles[i].alive == 0)
+ continue;
+ c = particles[i].position[1]/2.1*255;
+ glColor3ub((GLubyte) c, (GLubyte) (128+c*0.5), 255);
+ glVertex3fv(particles[i].position);
+ }
+ glEnd();
+ } else {
+ glBegin(GL_LINES);
+ for (i = 0; i < num_particles; i++) {
+ if (particles[i].alive == 0)
+ continue;
+ c = particles[i].previous[1]/2.1*255;
+ glColor3ub((GLubyte) c, (GLubyte) (128+c*0.5), 255);
+ glVertex3fv(particles[i].previous);
+ c = particles[i].position[1]/2.1*255;
+ glColor3ub((GLubyte) c, (GLubyte) (128+c*0.5), 255);
+ glVertex3fv(particles[i].position);
+ }
+ glEnd();
+ }
+
+ /* spit out frame rate. */
+ if (frame_rate) {
+ frames++;
+ if (frames > 7) {
+ sprintf(s, "%g fps", (float)7/frame_time);
+ frame_time = 0;
+ frames = 0;
+ }
+ text(5, 5, s);
+ }
+
+ glPopMatrix();
+ glutSwapBuffers();
+}
+
+void
+idleFunc(void)
+{
+ static int i;
+ static int living = 0; /* index to end of live particles */
+ static float dt;
+
+ dt = timedelta();
+ frame_time += dt;
+
+#if 1
+ /* slow the simulation if we can't keep the frame rate up around
+ 10 fps */
+ if (dt > 0.1) {
+ slow_down = 0.75;
+ } else if (dt < 0.1) {
+ slow_down = 1;
+ }
+#endif
+
+ dt *= slow_down;
+
+ /* resurrect a few particles */
+ for (i = 0; i < flow*dt; i++) {
+ psNewParticle(&particles[living], dt);
+ living++;
+ if (living >= num_particles)
+ living = 0;
+ }
+
+ for (i = 0; i < num_particles; i++) {
+ psTimeStep(&particles[i], dt);
+
+ /* collision with sphere? */
+ if (do_sphere) {
+ psCollide(&particles[i]);
+ }
+
+ /* collision with ground? */
+ if (particles[i].position[1] <= 0) {
+ psBounce(&particles[i], dt);
+ }
+
+ /* dead particle? */
+ if (particles[i].position[1] < 0.1 &&
+ fequal(particles[i].velocity[1], 0)) {
+ particles[i].alive = 0;
+ }
+ }
+
+ glutPostRedisplay();
+}
+
+void
+visible(int state)
+{
+ if (state == GLUT_VISIBLE) {
+ timedelta();
+ glutIdleFunc(idleFunc);
+ } else {
+ glutIdleFunc(NULL);
+ }
+}
+
+void
+bail(int code)
+{
+ free(particles);
+ exit(code);
+}
+
+#ifdef SCREEN_SAVER_MODE
+/* ARGSUSED */
+void
+ss_keyboard(char key, int x, int y)
+{
+ bail(0);
+}
+
+/* ARGSUSED */
+void
+ss_mouse(int button, int state, int x, int y)
+{
+ bail(0);
+}
+
+/* ARGSUSED */
+void
+ss_passive(int x, int y)
+{
+ static int been_here = 0;
+
+ /* for some reason, GLUT sends an initial passive motion callback
+ when a window is initialized, so this would immediately
+ terminate the program. to get around this, see if we've been
+ here before. (actually if we've been here twice.) */
+
+ if (been_here > 1)
+ bail(0);
+ been_here++;
+}
+
+#else
+
+/* ARGSUSED1 */
+void
+keyboard(unsigned char key, int x, int y)
+{
+ static int fullscreen = 0;
+ static int old_x = 50;
+ static int old_y = 50;
+ static int old_width = 320;
+ static int old_height = 320;
+
+ switch (key) {
+ case 27:
+ bail(0);
+ break;
+
+ case 'w':
+ type = PS_WATERFALL;
+ break;
+
+ case 'f':
+ type = PS_FOUNTAIN;
+ break;
+
+ case 's':
+ do_sphere = !do_sphere;
+ break;
+
+ case 'l':
+ points = !points;
+ break;
+
+ case 'P':
+ point_size++;
+ glPointSize(point_size);
+ break;
+
+ case 'p':
+ point_size--;
+ if (point_size < 1)
+ point_size = 1;
+ glPointSize(point_size);
+ break;
+
+ case '+':
+ flow += 100;
+ if (flow > num_particles)
+ flow = num_particles;
+ printf("%g particles/second\n", flow);
+ break;
+
+ case '-':
+ flow -= 100;
+ if (flow < 0)
+ flow = 0;
+ printf("%g particles/second\n", flow);
+ break;
+
+ case '~':
+ fullscreen = !fullscreen;
+ if (fullscreen) {
+ old_x = glutGet(GLUT_WINDOW_X);
+ old_y = glutGet(GLUT_WINDOW_Y);
+ old_width = glutGet(GLUT_WINDOW_WIDTH);
+ old_height = glutGet(GLUT_WINDOW_HEIGHT);
+ glutFullScreen();
+ } else {
+ glutReshapeWindow(old_width, old_height);
+ glutPositionWindow(old_x, old_y);
+ }
+ break;
+ }
+}
+
+#endif
+
+int old_x, old_y;
+
+/* ARGSUSED */
+void
+mouse(int button, int state, int x, int y)
+{
+ old_x = x;
+ old_y = y;
+
+ glutPostRedisplay();
+}
+
+void
+motion(int x, int y)
+{
+ spin_x = x - old_x;
+ spin_y = y - old_y;
+
+ glutPostRedisplay();
+}
+
+int
+main(int argc, char** argv)
+{
+ glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
+ glutInitWindowPosition(50, 50);
+ glutInitWindowSize(320, 320);
+ glutInit(&argc, argv);
+
+ if (argc > 1 && !strcmp(argv[1], "-fullscreen")) {
+ glutGameModeString("640x480:16@60");
+ glutEnterGameMode();
+ } else {
+ glutCreateWindow("Particles");
+ }
+
+ glutDisplayFunc(display);
+ glutReshapeFunc(reshape);
+#ifdef SCREEN_SAVER_MODE
+ glutPassiveMotionFunc(ss_passive);
+ glutKeyboardFunc(ss_keyboard);
+ glutMouseFunc(ss_mouse);
+ glutSetCursor(GLUT_CURSOR_NONE);
+ glutFullScreen();
+#else
+ glutMotionFunc(motion);
+ glutMouseFunc(mouse);
+ glutKeyboardFunc(keyboard);
+#endif
+
+ if (argc > 1) {
+ if (strcmp(argv[1], "-h") == 0) {
+ fprintf(stderr, "%s [particles] [flow] [speed%%]\n", argv[0]);
+ exit(0);
+ }
+ sscanf(argv[1], "%d", &num_particles);
+ if (argc > 2)
+ sscanf(argv[2], "%f", &flow);
+ if (argc > 3)
+ sscanf(argv[3], "%f", &slow_down);
+ }
+
+ particles = (PSparticle*)malloc(sizeof(PSparticle) * num_particles);
+
+ glutVisibilityFunc(visible);
+ glutMainLoop();
+ return 0;
+}
diff --git a/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/win32.Mak b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/win32.Mak
new file mode 100644
index 00000000000..2b47becdc40
--- /dev/null
+++ b/osg-install-jing_zhong/glut-nmake-compile-NeedFiles/win32.Mak
@@ -0,0 +1,671 @@
+# Win32.Mak - Win32 application master NMAKE definitions file for the
+# Microsoft Windows SDK programming samples
+# Copyright (C) Microsoft Corporation
+# -------------------------------------------------------------------------
+# This files should be included at the top of all MAKEFILEs as follows:
+# !include
+# -------------------------------------------------------------------------
+#
+# Define APPVER = [ 4.0 | 5.0 | 5.01 | 5.02 | 6.0 | 6.1] prior to including win32.mak to get
+# build time checking for version dependencies and to mark the executable
+# with version information.
+#
+# Define TARGETOS = [ WIN95 | WINNT | BOTH ] prior to including win32.mak
+# to get some build time checking for platform dependencies.
+#
+# Define TARGETLANG = [ LANG_JAPANESE | LANG_CHINESE | LANG_KOREAN ] prior
+# to including win32.mak to getcompile & link flags for building
+# applications to run on Far-East Windows. (This is an optional parameter.
+# The system locale is the default.)
+#
+# Define _WIN32_IE = [ 0x0300 | 0x0400 | 0x0500 | 0x0600 | 0x0700 | 0x0800] prior to including win32.mak to
+# get compile and link flags for building applications and components to
+# run on Internet Explorer. (This is an optional parameter. IE 4.0 is
+# the default.)
+#
+# -------------------------------------------------------------------------
+# NMAKE Options
+#
+# Use the table below to determine the additional options for NMAKE to
+# generate various application debugging, profiling and performance tuning
+# information.
+#
+# Application Information Type Invoke NMAKE
+# ---------------------------- ------------
+# For No Debugging Info nmake nodebug=1
+# For Working Set Tuner Info nmake tune=1
+# For Call Attributed Profiling Info nmake profile=1
+#
+# Note: The three options above are mutually exclusive (you may use only
+# one to compile/link the application).
+#
+# Note: creating the environment variables NODEBUG, TUNE, and PROFILE is an
+# alternate method to setting these options via the nmake command line.
+#
+# Note: TUNE and PROFILE do nothing for 64bit compilation
+#
+# Additional NMAKE Options Invoke NMAKE
+# ---------------------------- ------------
+# For No ANSI NULL Compliance nmake no_ansi=1
+# (ANSI NULL is defined as PVOID 0)
+#
+# =========================================================================
+# Build Rules Quick Start
+#
+# To build one of the following types of executables, use the specified
+# compiler and linker command-line options.
+#
+# ---------------------------------------------------------------------------
+# To build: | Compiler Options | Linker options (pick one
+# | | line. con = console,
+# | | gui = GUI, ole = GUI OLE)
+# ---------------------------------------------------------------------------
+# Single threaded | cdebug cflags cvars | ldebug guilflags guilibs
+# app with static | | ldebug conlflags conlibs
+# CRT | | ldebug guilflags olelibs
+# ---------------------------------------------------------------------------
+# Multithreaded app | cdebug cflags cvarsmt | ldebug guilflags guilibsmt
+# with static CRT | | ldebug conlflags conlibsmt
+# | | ldebug guilflags olelibsmt
+# ---------------------------------------------------------------------------
+# Single or multi- | cdebug cflags cvarsdll | ldebug guilflags guilibsdll
+# threaded app with | | ldebug conlflags conlibsdll
+# DLL version of CRT | | ldebug guilflags olelibsdll
+# (MSVCRT.DLL) | |
+# ---------------------------------------------------------------------------
+# DLL with static | cdebug cflags cvarsmt | ldebug dlllflags guilibsmt
+# CRT* | | ldebug dlllflags conlibsmt
+# | | ldebug dlllflags olelibsmt
+# ---------------------------------------------------------------------------
+# DLL with DLL | cdebug cflags cvarsdll | ldebug dlllflags guilibsdll
+# version of CRT | | ldebug dlllflags conlibsdll
+# (MSVCRT.DLL) | | ldebug dlllflags olelibsdll
+# ---------------------------------------------------------------------------
+#
+# * Always make DLLs multithreaded because a DLL has no way to know whether
+# the calling application has multiple threads, and has no way to prevent
+# multithreaded apps from loading it.
+#
+# To specify an Intel x86 build that defaults to stdcall, add scall to the
+# list of compiler options.
+#
+# =========================================================================
+
+!IFNDEF _WIN32_MAK_
+_WIN32_MAK_ = 1
+
+# -------------------------------------------------------------------------
+# Get CPU Type - exit if CPU environment variable is not defined
+# -------------------------------------------------------------------------
+
+# Win95 does not define PROCESSOR_ARCHITECTURE - default to i386
+
+!IF "$(PROCESSOR_ARCHITECTURE)" == ""
+CPU=i386
+PROCESSOR_ARCHITECTURE=x86
+!endif
+
+!IF !DEFINED(CPU) || "$(CPU)" == ""
+CPU = $(PROCESSOR_ARCHITECTURE)
+!ENDIF # CPU
+
+# if PROCESSOR_ARCHITECTURE was x86 or X86 change CPU to i386
+
+!IF ( "$(CPU)" == "X86" ) || ( "$(CPU)" == "x86" )
+CPU = i386
+!ENDIF # CPU == X86
+
+!IF "$(CPU)" != "i386"
+!IF "$(CPU)" != "IA64"
+!IF "$(CPU)" != "AMD64"
+!ERROR Must specify CPU environment variable ( CPU=i386, CPU=IA64, CPU=AMD64)
+!ENDIF
+!ENDIF
+!ENDIF
+
+
+# -------------------------------------------------------------------------
+# Get Target Operating System - Default to WINNT
+# -------------------------------------------------------------------------
+!IFNDEF TARGETOS
+TARGETOS = WINNT
+!ENDIF
+
+!IF "$(TARGETOS)" != "WINNT"
+!IF "$(TARGETOS)" != "WIN95"
+!IF "$(TARGETOS)" != "BOTH"
+!ERROR Must specify TARGETOS environment variable (BOTH, WIN95, WINNT)
+!ENDIF
+!ENDIF
+!ENDIF
+
+# default to APPVER of 5.0
+
+!IFNDEF APPVER
+APPVER = 5.0
+!ENDIF
+
+!IF "$(APPVER)" != "6.1"
+!IF "$(APPVER)" != "6.0"
+!IF "$(APPVER)" != "5.02"
+!IF "$(APPVER)" != "5.01"
+!IF "$(APPVER)" != "5.0"
+!IF "$(APPVER)" != "4.0"
+!ERROR Must specify APPVER environment variable (4.0, 5.0, 5.01, 5.02, 6.0, 6.1)
+!ENDIF
+!ENDIF
+!ENDIF
+!ENDIF
+!ENDIF
+!ENDIF
+
+!IF "$(APPVER)" =="6.1"
+!IFNDEF _WIN32_IE
+_WIN32_IE = 0x0800
+!ENDIF # _WIN32_IE
+!ENDIF # APPVER == 6.1
+
+!IF "$(APPVER)" =="6.0"
+!IFNDEF _WIN32_IE
+_WIN32_IE = 0x0700
+!ENDIF # _WIN32_IE
+!ENDIF # APPVER == 6.0
+
+!IF "$(APPVER)" =="5.0"
+!IFNDEF _WIN32_IE
+_WIN32_IE = 0x0500
+!ENDIF # _WIN32_IE
+!ENDIF # APPVER == 5.0
+
+!IF "$(APPVER)" =="5.01"
+!IFNDEF _WIN32_IE
+_WIN32_IE = 0x0600
+!ENDIF # _WIN32_IE
+!ENDIF # APPVER == 5.01
+
+!IF "$(APPVER)" =="5.02"
+!IFNDEF _WIN32_IE
+_WIN32_IE = 0x0600
+!ENDIF # _WIN32_IE
+!ENDIF # APPVER == 5.02
+
+!IFNDEF _WIN32_IE
+_WIN32_IE = 0x0400
+!ENDIF
+
+# -------------------------------------------------------------------------
+# Build tool declarations common to all platforms
+# Check to see if Cole Porter is used, otherwise use C/C++ compiler
+# -------------------------------------------------------------------------
+
+cc = cl
+link = link
+implib = lib
+
+midl = midl
+rc = Rc
+hc = Start /Wait Hcrtf
+mc = Mc
+
+hcvars = -xn
+
+# -------------------------------------------------------------------------
+# Platform Dependent Compile Flags - must be specified after $(cc)
+#
+# Note: Debug switches are on by default for current release
+#
+# These switches set code generation and debugging options for the compiler.
+# They also set macros used for conditional compilation.
+#
+# The debugging switches allow for source level debugging with WinDebug or
+# Microsoft Visual C++.
+#
+# Common compiler flags:
+# -c - compile without linking
+# -W3 - Set warning level to level 3 (-W4 for 64-bit compilations)
+# -Zi - generate debugging information
+# -Od - disable all optimizations
+# -Ox - use maximum optimizations
+# -Zd - generate only public symbols and line numbers for debugging
+# -GS - enable security checks
+#
+# i386 specific compiler flags:
+# -Gz - stdcall (only if scall is added to makefile's compiler build rules)
+#
+# -------------------------------------------------------------------------
+
+# declarations common to all compiler options
+ccommon = -c -DCRTAPI1=_cdecl -DCRTAPI2=_cdecl -nologo -GS
+
+# for compatibility with old source code, map {try, except, leave, finally}
+# to their proper names (i.e. prefaced by "__")
+!IFDEF SEHMAP
+ccommon = $(ccommon) -FIsehmap.h
+!ENDIF
+
+!IF "$(TARGETLANG)" == "LANG_JAPANESE"
+ccommon = $(ccommon) -DJAPAN -DDBCS -DFE_IME
+!ENDIF
+
+!IF "$(TARGETLANG)" == "LANG_CHINESE"
+ccommon = $(ccommon) -DDBCS -DFE_IME
+!ENDIF
+
+!IF "$(TARGETLANG)" == "LANG_KOREAN"
+ccommon = $(ccommon) -DDBCS -DFE_IME
+!ENDIF
+
+!IF "$(CPU)" == "i386"
+cflags = $(ccommon) -D_X86_=1 -DWIN32 -D_WIN32 -W3
+scall = -Gz
+
+!ELSEIF "$(CPU)" == "IA64"
+cflags = $(ccommon) -D_IA64_=1 -DWIN64 -D_WIN64 -DWIN32 -D_WIN32
+cflags = $(cflags) -W4
+scall =
+
+!ELSEIF "$(CPU)" == "AMD64"
+cflags = $(ccommon) -D_AMD64_=1 -DWIN64 -D_WIN64 -DWIN32 -D_WIN32
+cflags = $(cflags) -W4
+scall =
+
+!ENDIF
+
+
+!IF "$(APPVER)" == "4.0"
+NMAKE_WINVER = 0x0400
+!ELSEIF "$(APPVER)" == "5.0"
+NMAKE_WINVER = 0x0500
+!ELSEIF "$(APPVER)" == "5.01"
+NMAKE_WINVER = 0x0501
+!ELSEIF "$(APPVER)" == "5.02"
+NMAKE_WINVER = 0x0502
+!ELSEIF "$(APPVER)" == "6.0"
+NMAKE_WINVER = 0x0600
+!ELSEIF "$(APPVER)" == "6.1"
+NMAKE_WINVER = 0x0601
+!ENDIF
+
+!IF "$(TARGETOS)" == "WINNT"
+cflags = $(cflags) -D_WINNT -D_WIN32_WINNT=$(NMAKE_WINVER) -DNTDDI_VERSION=$(NMAKE_WINVER)0000
+!ENDIF
+
+!IF "$(TARGETOS)" == "WIN95"
+cflags = $(cflags) -D_WIN95 -D_WIN32_WINDOWS=$(NMAKE_WINVER) /D_WIN32_DCOM
+!ENDIF
+
+# regardless of the TARGET OS, define compile time WINVER to match APPVER macro
+cflags = $(cflags) -D_WIN32_IE=$(_WIN32_IE) -DWINVER=$(NMAKE_WINVER)
+
+
+# Set debugging options
+
+!IF "$(CPU)" != "IA64"
+!IFDEF NODEBUG
+cdebug = -Ox -DNDEBUG
+!ELSE IFDEF PROFILE
+cdebug = -Gh -Ox -DNDEBUG
+!ELSE IFDEF TUNE
+cdebug = -Gh -Ox -DNDEBUG
+!ELSE
+cdebug = -Zi -Od -DDEBUG
+!ENDIF
+
+!ELSE
+
+!IFDEF NODEBUG
+cdebug = -Ox -DNDEBUG
+!ELSE
+cdebug = -Zi -Od -DDEBUG
+!ENDIF
+
+!ENDIF
+
+# -------------------------------------------------------------------------
+# Target Module & Subsystem Dependent Compile Defined Variables - must be
+# specified after $(cc)
+#
+# The following table indicates the various acceptable combinations of
+# the C Run-Time libraries LIBC, LIBCMT, and MSVCRT respect to the creation
+# of a EXE and/or DLL target object. The appropriate compiler flag macros
+# that should be used for each combination are also listed.
+#
+# Executable Type C Runtime Lib Compiler switch
+# -------------------------------------------------------------
+# Single threaded app static CRT CVARS *
+# Single-threaded app DLL CRT CVARSDLL
+# Multi-threaded app static CRT CVARSMT *
+# Multi-threaded app DLL CRT CVARSDLL *
+#
+# Single threaded DLL static CRT CVARS
+# Single-threaded DLL DLL CRT CVARSDLL
+# Multi-threaded DLL static CRT CVARSMT *
+# Multi-threaded DLL DLL CRT CVARSDLL *
+#
+# * - Denotes the Recommended Configuration
+#
+# When building single-threaded applications you can link your executable
+# with either LIBC, LIBCMT, or MSVCRT, although LIBC will provide the best
+# performance.
+#
+# When building multi-threaded applications, either LIBCMT or MSVCRT can
+# be used as the C-Runtime library, as both are multi-thread safe.
+#
+# Note: Any executable which accesses a DLL linked with MSVCRT.LIB must
+# also link with MSVCRT.LIB instead of LIBC.LIB or LIBCMT.LIB.
+# When using DLLs, it is recommended that all of the modules be
+# linked with MSVCRT.LIB.
+#
+# Note: The macros of the form xDLL are used when linking the object with
+# the DLL version of the C Run-Time (that is, MSVCRT.LIB). They are
+# not used when the target object is itself a DLL.
+#
+# -------------------------------------------------------------------------
+
+!IFDEF NO_ANSI
+noansi = -DNULL=0
+!ENDIF
+
+
+# for Windows applications that use the C Run-Time libraries
+!IFDEF NODEBUG
+cvarsmt = $(noansi) -D_MT -MT
+cvars = $(cvarsmt)
+cvarsdll = $(noansi) -D_MT -D_DLL -MD
+!ELSE
+cvarsmt = $(noansi) -D_MT -MTd
+cvars = $(cvarsmt)
+cvarsdll = $(noansi) -D_MT -D_DLL -MDd
+!ENDIF
+
+
+# for compatibility with older-style makefiles
+cvarsmtdll = $(cvarsdll)
+
+# for POSIX applications
+psxvars = -D_POSIX_
+
+# resource compiler
+rcflags = /r
+!ifdef NODEBUG
+rcvars = -DWIN32 -D_WIN32 -DWINVER=$(NMAKE_WINVER) $(noansi)
+!else
+rcvars = -DWIN32 -D_WIN32 -DWINVER=$(NMAKE_WINVER) -DDEBUG -D_DEBUG $(noansi)
+!endif
+
+
+!IF "$(TARGETLANG)" == "LANG_JAPANESE"
+rcflags = $(rcflags) /c932
+rcvars = $(rcvars) -DJAPAN -DDBCS -DFE_IME
+!ENDIF
+
+!IF "$(TARGETLANG)" == "LANG_CHINESE"
+rcvars = $(rcvars) -DDBCS -DFE_IME
+!ENDIF
+
+!IF "$(TARGETLANG)" == "LANG_KOREAN"
+rcvars = $(rcvars) -DDBCS -DFE_IME
+!ENDIF
+
+
+# -------------------------------------------------------------------------
+# Platform Dependent MIDL Flags - must be specified after midl
+#
+#
+# -------------------------------------------------------------------------
+!IF "$(TARGETOS)" == "WIN95"
+MIDL_OPTIMIZATION=-target NT40
+!ELSEIF "$(TARGETOS)" == "WINNT"
+!IF "$(APPVER)" == "5.0"
+MIDL_OPTIMIZATION=-target NT50
+!ELSEIF "$(APPVER)" == "6.0"
+MIDL_OPTIMIZATION=-target NT60
+!ELSEIF "$(APPVER)" == "6.1"
+MIDL_OPTIMIZATION=-target NT61
+!ELSEIF "$(APPVER)" == "5.01"
+MIDL_OPTIMIZATION=-target NT51
+!ELSEIF "$(APPVER)" == "5.02"
+MIDL_OPTIMIZATION=-target NT51
+!ELSEIF "$(APPVER)" == "4.0"
+MIDL_OPTIMIZATION=-target NT40
+!ENDIF
+!ENDIF
+
+!IF "$(CPU)" == "IA64"
+MIDL_OPTIMIZATION = $(MIDL_OPTIMIZATION) /ia64
+!ELSEIF "$(CPU)" == "AMD64"
+MIDL_OPTIMIZATION = $(MIDL_OPTIMIZATION) /x64
+!ELSE
+MIDL_OPTIMIZATION = $(MIDL_OPTIMIZATION) /win32
+!ENDIF
+
+!IF ("$(TARGETOS)" == "WINNT" ) && ("$(APPVER)" != "4.0")
+MIDL_OPTIMIZATION = $(MIDL_OPTIMIZATION) /robust
+!ENDIF
+
+
+
+# -------------------------------------------------------------------------
+# Platform Dependent Link Flags - must be specified after $(link)
+#
+# Note: $(DLLENTRY) should be appended to each -entry: flag on the link
+# line.
+#
+# Note: When creating a DLL that uses C Run-Time functions it is
+# recommended to include the entry point function of the name DllMain
+# in the DLL's source code. Also, the MAKEFILE should include the
+# -entry:_DllMainCRTStartup$(DLLENTRY) option for the creation of
+# this DLL. (The C Run-Time entry point _DllMainCRTStartup in turn
+# calls the DLL defined DllMain entry point.)
+#
+# -------------------------------------------------------------------------
+
+# declarations common to all linker options
+lflags = $(lflags) /INCREMENTAL:NO /NOLOGO
+
+# declarations for use on Intel x86 systems
+!IF "$(CPU)" == "i386"
+DLLENTRY = @12
+!ENDIF
+
+# declarations for use on Intel Architecture 64-bit systems
+!IF "$(CPU)" == "IA64"
+DLLENTRY =
+!ENDIF
+
+# declarations for use on AMD64 systems
+!IF "$(CPU)" == "AMD64"
+DLLENTRY =
+!ENDIF
+
+
+# -------------------------------------------------------------------------
+# Target Module Dependent Link Debug Flags - must be specified after $(link)
+#
+# These switches allow the inclusion of the necessary symbolic information
+# for source level debugging with WinDebug, profiling and/or performance
+# tuning.
+#
+# Note: Debug switches are on by default.
+# -------------------------------------------------------------------------
+
+!IF "$(CPU)" == "i386"
+
+!IFDEF NODEBUG
+ldebug = /RELEASE
+!ELSE
+ldebug = /DEBUG /DEBUGTYPE:cv
+!ENDIF
+
+!ELSE
+
+!IFDEF NODEBUG
+ldebug = /RELEASE
+!ELSE IFDEF PROFILE
+ldebug = /DEBUG:mapped,partial /DEBUGTYPE:coff
+!ELSE IFDEF TUNE
+ldebug = /DEBUG:mapped,partial /DEBUGTYPE:coff
+!ELSE
+ldebug = /DEBUG /DEBUGTYPE:cv
+!ENDIF
+
+!ENDIF
+
+# for compatibility with older-style makefiles
+linkdebug = $(ldebug)
+
+
+# -------------------------------------------------------------------------
+# Subsystem Dependent Link Flags - must be specified after $(link)
+#
+# These switches allow for source level debugging with WinDebug for local
+# and global variables. They also provide the standard application type and
+# entry point declarations.
+#
+# Note that on x86 screensavers have a WinMain entrypoint, but on RISC
+# platforms it is main. This is a Win95 compatibility issue.
+#
+# -------------------------------------------------------------------------
+
+# Windows 98 needs subsystem version set to 4.10 for version 5.0 features.
+!IF ("$(APPVER)" == "5.0") && (("$(TARGETOS)" == "BOTH") || ("$(TARGETOS)" == "WIN95"))
+EXEVER = 4.10
+!ELSE
+EXEVER = $(APPVER)
+!ENDIF
+
+
+# ---------------------------------------------
+
+# for Windows applications
+conlflags = $(lflags) -subsystem:console,$(EXEVER)
+guilflags = $(lflags) -subsystem:windows,$(EXEVER)
+dlllflags = $(lflags) -entry:_DllMainCRTStartup$(DLLENTRY) -dll
+
+# For screen savers
+!IF "$(CPU)" == "i386"
+savlflags = $(lflags) -subsystem:windows,$(EXEVER) -entry:WinMainCRTStartup
+!ELSE
+savlflags = $(lflags) -subsystem:windows,$(EXEVER) -entry:mainCRTStartup
+!ENDIF
+
+# for POSIX applications
+psxlflags = $(lflags) -subsystem:posix -entry:__PosixProcessStartup
+
+# for compatibility with older-style makefiles
+conflags = $(conlflags)
+guiflags = $(guilflags)
+psxflags = $(psxlflags)
+
+# -------------------------------------------------------------------------
+# C Run-Time Target Module Dependent Link Libraries
+#
+# Note: For POSIX applications, link with $(psxlibs).
+# -------------------------------------------------------------------------
+
+# for POSIX applications
+psxlibs = libcpsx.lib psxdll.lib psxrtl.lib oldnames.lib
+
+
+# optional profiling and tuning libraries
+!IF "$(CPU)" != "IA64"
+
+!IFDEF PROFILE
+optlibs = cap.lib
+!ELSE IFDEF TUNE
+optlibs = wst.lib
+!ELSE
+optlibs =
+!ENDIF
+
+!ELSE
+optlibs =
+!ENDIF
+
+# if building for basic Windows 95, use WinSock1, else use WinSock2
+!IF "$(TARGETOS)" == "WIN95"
+!IF "$(APPVER)" == "4.0"
+winsocklibs = wsock32.lib
+!ELSE
+winsocklibs = ws2_32.lib mswsock.lib
+!ENDIF
+!ELSE
+winsocklibs = ws2_32.lib mswsock.lib
+!ENDIF
+
+
+# basic subsystem specific libraries, less the C Run-Time
+baselibs = kernel32.lib $(optlibs) $(winsocklibs) advapi32.lib
+winlibs = $(baselibs) user32.lib gdi32.lib comdlg32.lib winspool.lib
+
+# for Windows applications that use the C Run-Time libraries
+conlibs = $(baselibs)
+guilibs = $(winlibs)
+
+# for OLE applications
+olelibs = ole32.lib uuid.lib oleaut32.lib $(guilibs)
+
+#for backwards compatibility
+conlibsmt = $(conlibs)
+conlibsdll = $(conlibs)
+guilibsmt = $(guilibs)
+guilibsdll = $(guilibs)
+olelibsmt = $(olelibs)
+olelibsdll = $(olelibs)
+
+# for backward compatibility
+ole2libs = $(olelibs)
+ole2libsmt = $(olelibsmt)
+ole2libsdll = $(olelibsdll)
+
+# Visual Basic
+bc = vb6
+bc_exe = /Make
+bc_dll = /Makedll
+
+# Set the Output Directory
+!IF ("$(APPVER)" == "6.1")
+OUTDIR=WIN7
+!ELSEIF ("$(APPVER)" == "6.0")
+OUTDIR=Vista
+!ELSEIF "$(APPVER)" == "5.0"
+OUTDIR=WIN2000
+!ELSEIF "$(APPVER)" == "5.01"
+OUTDIR=XP32
+!ELSEIF "$(APPVER)" == "5.02"
+OUTDIR=SRV2003
+!ELSEIF "$(APPVER)" == "4.0"
+OUTDIR=NT4
+!ENDIF
+
+!IF "$(CPU)" == "AMD64"
+OUTDIR=$(OUTDIR)_X64
+!ELSEIF "$(CPU)" == "IA64"
+OUTDIR=$(OUTDIR)_64
+!ENDIF
+
+#set Prerelease Out directories
+!IF "$(SDKPRERELEASE)" == "1"
+OUTDIR=PRE_$(OUTDIR)
+!ENDIF
+
+#Set DEBUG
+!IF "$(NODEBUG)" == ""
+OUTDIR=$(OUTDIR)_DEBUG
+!ELSE
+OUTDIR=$(OUTDIR)_RETAIL
+!ENDIF
+
+!IF "$(OS)" == "Windows_NT"
+CLEANUP=if exist $(OUTDIR)/$(NULL) rd /s /q $(OUTDIR)
+!ELSE
+CLEANUP=deltree /y $(OUTDIR)
+!ENDIF
+
+VC6MSG=This sample only compiles with Microsoft Visual C++ 6.0. \
+ To compile this run vcvars32.bat for Visual C++ 6.0, and setenv.bat in $(MSSDK).
+
+WIN64MSG=This sample is currently not supported on the 64 bit platform.
+
+#ENDIF _WIN32_MAK_
+!ENDIF
From ca1e31bfdfd27530096939862d2f109aa9765e7b Mon Sep 17 00:00:00 2001
From: jing_zhong <49520956+jingguotaiduo@users.noreply.github.com>
Date: Tue, 21 Jun 2022 15:35:04 +0800
Subject: [PATCH 7/9] Add files via upload
Build and install OSG screenshots.
---
.../OSG-CMake-VS 2015-2022-06-20_151930.png | Bin 0 -> 496319 bytes
...VS-ALLBUILD_QQScreenShots20220620193713.jpg | Bin 0 -> 197961 bytes
...-VS-INSTALL_QQScreenShots20220620211417.jpg | Bin 0 -> 256168 bytes
3 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 osg-install-jing_zhong/OSG-CMake-VS 2015-2022-06-20_151930.png
create mode 100644 osg-install-jing_zhong/OSG-VS-ALLBUILD_QQScreenShots20220620193713.jpg
create mode 100644 osg-install-jing_zhong/OSG-VS-INSTALL_QQScreenShots20220620211417.jpg
diff --git a/osg-install-jing_zhong/OSG-CMake-VS 2015-2022-06-20_151930.png b/osg-install-jing_zhong/OSG-CMake-VS 2015-2022-06-20_151930.png
new file mode 100644
index 0000000000000000000000000000000000000000..c81118de7b368228adf52400577ab35b1e25cdbe
GIT binary patch
literal 496319
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 E46|tr;A+R9z*3ebO
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 |