Compare commits

...
638 Commits
Author SHA1 Message Date
David Eberly d29e7758ae Update ContPointInPolyhedron3.h
Defect reported by Claude Sonnet5/Fable5. The std::vector member
mProjVertices occurs in a loop over all faces. It stores the projections
onto a plane which are later processed. The member is resized each time the current faceIndices has a larger number of elements that mProjVertices. There is no clear call, so if the number of current faceIndices is smaller than that of mProjVertices, the ensuing code accesses elements of mProjVertices that were set for the previous triangles. I removed the mProjVertices member and now have local storage for the projection vertices that is created for each incoming face. While I was in there, I refactored the code in an attempt to simply
the class interface. There is only one face data structure used for triangles, convex polygons, and simple polygons. Consequently, the class has a single constructor to which you pass a parameter specifying the type of face to be processed. I factored out shared code for ContainsC1C2 and ContainsS1 into SharedContains.
2026-08-13 21:46:47 -07:00
David Eberly 3e43b79905 Modified project for deprecation of source code.
Removed ApprConvexQuadByRect.h.
2026-08-12 08:27:29 -07:00
David Eberly 03126b7b52 Delete ApprConvexQuadByRect.h
Claude Sonnet 5 reported a defect in  ApprConvexQuadByRect.h. It
appeared to be a false positive. However, I analyzed the code and re-read the PDF for the fitting algorithm (Fit a Convex Quadrilateral by a Rectangle). The second equality in equation (5) of the PDF is horribly wrong. Moreover, the PDF is nearly impossible to read and understand. I removed the header file from the GTE source code and I removed the PDF from the documentation database. The motivation for the algorithm was based on user request, to approximate a nearly
rectangular quadrilateral by a rectangle. It is simpler to use the
minimum-area bounding rectangle code (\Code{MininumAreaBox2.h}).
2026-08-12 08:21:44 -07:00
David Eberly 8275bbb490 Update RootsPolynomial.h
Defect reported by Claude Sonnet5/Fable5. In the Find function that
uses bisection, if the loop involving maxIterations is encountered and
maxIterations is zero, root is unassigned and the return value is true. The caller believes a root is found but accesses uninitialized memory. I added a trap for maxIterations being zero before the loop is reached; if zero, the function exits. In all the conditions where there is no
root computed, root is assigned zero to avoid uninitialized memory.
2026-08-11 14:11:44 -07:00
David Eberly ac8277a9f8 Update SurfaceExtractorTetrahedra.h
Defect reported by Claude Sonnet5/Fable5. The AddTriangle function
tests whether a triangle is in a set. If it is not, the function has nothing
to do and exits. If it is, a test is applied to see whether the to-be-inserted triangle has a duplicate in the set; this triangle has opposite winding order, so the function swaps the last two vertices of the input triangle. If there is no duplicate, the triangle is added to the set. However, the last two vertices had been swapped. They need to be swapped back to the original order of the input triangle.
2026-08-11 13:51:42 -07:00
David Eberly 3f30cf6d72 Update MinimumSpanningTree.h
Defect reported by Claude Sonnet5/Fable5. There is no defect. The minimum spanning tree data structure contains a sentinel followed by the tree. The sentinel is {nil,vertexIndex}, where vertexIndex is the
index into the vertex array corresponding to the first vertex visited by
the tree construction. I added comments about this in hopes later Claude runs will not flag this as a defect.
2026-08-11 10:44:32 -07:00
David Eberly db8560d62c Update RotationEstimate.h
Defect found by Claude Sonnet5/Fable5. The degree-16 constants in
C_ROTC4_EST_COEFF} have an entry +2.505210838484547384e-08 which is missing a terminating constant. The compiler adds the next constant to it, in which case the last constant of the array is implicitly zero. I added the comma.
2026-08-10 16:20:43 -07:00
David Eberly 980e680e76 Update Hyperellipsoid.h
Defect found by Claude Sonnet5/Fable5. This is actually a warning about potential numerical issues in ToCoefficients, the variation accepting an array of numbers. The warning was about skipping a loop index when trying to determine a number to divide all the coefficients to transform them to a range containing floating-point 1. I redesigned this to divide by the maximum-magnitude coefficient of the quadratic terms. I also removed some comments about Microsoft Visual Studio 2019 code analysis generating incorrect warnings.
2026-08-10 15:59:30 -07:00
David Eberly d55b847edc Update NURBSSphere.h
Defect found by Claude Sonnet5/Fable5. In the second derivative computations of NURBSEighthSphereDegree4, the tempDuu, tempDuv, and tempDvv equations had a leading multiplication by D. This is incorrect, so the leading D multiplications were removed. I found a second bug that Claude did not detect. In the first derivative computations, Bu[1][3] was computed as (Real)4 * vv. This should be
(Real)4 * v * vv. After fixing the bugs, I implemented the NURBS code
using Mathematica 15.0.1.0 and verified that the GTE/GTL C++ code produces correct results.
2026-08-10 12:05:17 -07:00
David Eberly 89f024c114 Update NURBSCircle.h
Defect found by Claude Sonnet5/Fable5. When I added the class
NURBSCircularArcDegree2, I introduced a regression in the class
NURBSQuarterCircleDegree2. For some unknown reason, the control points of NURBSQuarterCircleDegree2 were modified from {(1,0), (1,1), (0,1)} to {(1,1),(1,1),(1,1)}. Probably a copy-and-forgot-to-modify error.
2026-08-09 12:40:01 -07:00
David Eberly 79054919bc Fixed return value of approximator.
Defect found by Claude Sonnet5/Fable5. FitUsingSquaredLengths has a loop that terminates if the number of iterations exceeds maxIterations specified by the caller. The old return value is ++iteration, which is maxIterations+1 on non-convergence. I now return iteration.
2026-08-09 11:47:06 -07:00
David Eberly 11621154ff Update BVTree.h
I had fixed a bug in the bounding volume tree code for GTE; see the August 1, 2026 update notes. Unfortunately, I had not fixed the bug in the GTL code. A regression was introduced when I backported the GTL code to GTE. I fixed this.
2026-08-09 10:45:04 -07:00
David Eberly 1064fe61b4 Updated mathematics project files.
Added the new files and removed old files for the bounding volume tree code that was backported from GTL to GTE.
2026-08-08 16:58:51 -07:00
David Eberly 50d261ed0f Backported bounding volume tree code from GTL to GTE.
I backported the bounding volume tree code from GTL to GTE. GTE now supports trees for points, segments, or triangles. Part of the backport involved refactoring the classes to share more code, making the derived tree classes simpler to write. The file ApprCone3EllipseAndPoints.h was modified to support the new oriented box tree code. In the process of testing with the sample application, I encountered an exception: press key `3' followed by `b'.
An array of shared pointers of meshes is created in  CreateScene with a reserve call followed by multiple push_back calls. However, CreateScene is called multiple times (pressing keys to change the
test mesh). The array winds up having several null pointers, which causes the graphics engine Draw call to throw an exception. The fix was to add a clear call after the reserve call.
2026-08-08 16:50:15 -07:00
David Eberly f538a76e8d Update ReparameterizeByArclength.h
Defect found by Claude Sonnet5/Fable5. The function BisectionConverged compared fMin <= fMax. It needs to compare std::fabs(fMin) <= std::fabs(fMax); otherwise, the result is the same endpoint regardless of which is actually closer to the root. This can lead to a 1 ULP error in nearest floating-point number.
2026-08-08 13:05:48 -07:00
David Eberly c0b9db0234 Update DistPoint3Cylinder3.h
The file uses LogAssert. For some reason previous compiles allowed
access to this even though there is no include of Logger.h. Now the
compiler does complain (perhaps a difference in MSVS 2022 and MSVS 2026). I added the include.
2026-08-08 09:43:09 -07:00
David Eberly adee6124f9 Removed std::isfinite calls.
Removed the std::isfinite calls to allow compilation using GTE's
rational arithmetic classes. The GTL code already has these removed.
2026-08-08 09:25:51 -07:00
David Eberly f82380ae19 Update HermiteQuintic.h
Defect found by Claude Sonnet5/Fable5. The function P2D5 called P3D4 but should call P3D5. Modified the code and verified the
correctness using Mathematica.
2026-08-07 22:34:29 -07:00
David Eberly 419224b114 Fixed compile breaks.
My instantiation test failed to run. Got it running and fixed the compile breaks.
2026-08-07 15:35:57 -07:00
David Eberly 02a7f4807b Update AdaptiveSkeletonClimbing3.h
Defect found by Claude Sonnet5/Fable5. In GetGradient, the gradient[2] term uses (oneMinusY,OneMinusY) for the weights. These should be (oneMinusY,fy).
2026-08-07 15:19:58 -07:00
David Eberly aae5c85bf8 Revised the image utility header files.
Defect found by Claude Sonnet5/Fable5. Function ImageUtility3::Dilate has a design different from that of  ImageUtility2::Dilate. The 3D version failed to set boundary voxels to 1 when a neighboring voxel is 1. I rewrote ImageUtility3::Dilate to match the design of the 2D version. While I was in there, I added the 3D morphology functions for Erode, Open, and Close. I also moved the 2D and 3D component labelers to public scope because they might be useful in some applications. Finally, I reformatted both the 2D and 3D files to match the interface designs.
2026-08-07 15:07:42 -07:00
David Eberly 54c03f78d0 Update Cone.h
Defect found by Claude Sonnet5/Fable5. In the CreateMesh function, the line of code for tNumExtra has a division by rMin. For a finite cone with hMin of zero, there is a division by zero which leads to tNumExtra of positive infinity. I modified rMax/rMin to (1+rMax)/(1+rMin) to avoid the division by zero. I also added a TODO about determining how I derived the tNumExtra equation.
2026-08-06 22:11:15 -07:00
David Eberly 2456ff19e1 Fixed crash bug in Execute functions.
Defect found by Claude Sonnet5/Fable5. The Execute functions of
BVTreeOfTriangles and OBBTreeOfTriangles create
std::vector<size_t> indexStack(2 * this->mHeight)}. If the input tree has height of zero, the index stack is empty, so the code indexStack[0] = 0 crashes. The number of index stack elements must be 2 * this->mHeight + 1.
2026-08-01 11:36:55 -07:00
David Eberly 8e3baa93dc Update StringUtility.h
Defect found by Claude Sonnet5/Fable5. The GetTextTokens function has a loop with upper bound i < 255. This should be i <= 255.
2026-08-01 11:00:46 -07:00
David Eberly 93b8acda69 Update Constants.h
Defect found by Claude Sonnet5/Fable5. The following constants differ from the correctly rounded IEEE floating-point numbers: GTE_C_INV_TWO_PI differs by 2 ULP, GTE_C_INV_HALF_PI} differs by 1 ULP, and GTE_C_DEG_TO_RAD differs by 1 ULP. I computed the correctly rounded numbers using rational arithmetic and Machin's formula [pi = 16 atan(1/5) - 4 atan(1/239)]. The power series terms were partially summed until the rounded double-precision values between two consecutive partial sums were equal.
2026-08-01 10:54:43 -07:00
David Eberly 3f72a78d15 Fixed division by zero for degenerate line segments.
Defect found by Claude Sonnet5/Fable5. The find-intersection query has a division by segExtent. If the segment is degenerate, representing a single point (p[0] and p[1] are the same point), the segment extent is zero whereby the query has a division by zero. Additionally, the parameter value is zero, so result.parameter[i] / segExtent is
indeterminate (0/0). I added a guard against this case which calls a point-in-box query when the segment is degenerate. Claude's analysis did not report a second problem. The DoQuery method does not fill in the result members for index 1. When the projection intervals touch in a single point (numIntersections is 1), I increment this to 2 in case the caller references those values (undefined behavior without this).
The same division-by-zero problem occurs in the segment-oriented-box code. I also added a guard against this case.
2026-07-31 17:36:57 -07:00
David Eberly 43a484e503 Update DistPoint3Cylinder3.h
Defect found by Claude Sonnet5/Fable5. DoQueryInfiniteCylinder has a division by distance, which leads to an indeterminate form when
cylinder.radius is zero. Exception handling was added to throw when
the radius is not positive. Also, DoQueryFiniteCylinder now throws an exception when the height is not positive.
2026-07-30 21:41:18 -07:00
David Eberly bb27d5e54c Update IntrTetrahedron3Tetrahedron3.h
Defect found by Claude Sonnet5/Fable5. The edge-edge double loop had P1=tetra0.v[edge1Indices[0]]. The wrong tetrahedron is accessed. It
should be tetra1.
2026-07-30 16:07:11 -07:00
David Eberly e00988def9 Update SingularValueDecomposition.h
Defect found by Claude Sonnet5/Fable5. ComputeVOrthogonal has a loop with upper bound mNumCols-3. This works for matrices with 3 or more columns, but it fails when the number of columns is 2. The `col' index wraps to SIZE_MAX and the result is a crash when trying to reference an empty matrix. I added code to execute the loop only when mNumCols is 3 or larger.
2026-07-30 14:56:32 -07:00
David Eberly 636c156c02 Update BSNumber.h
I thought the negations of unsigned integers in the constructors with input 'number' were fixed. Running my instantiation tests showed that there is still a bug. The negative has to occur before the static cast, not after.
2026-06-08 12:08:16 -07:00
David Eberly e095b84018 Changes to CMakeLists.txt files.
Changes to CMakeLists.txt files. Based on CMake warnings, increased the minimum required cmake version to 3.10 from 3.8. Modified the GTE_MINOR_VERSION to 2.
2026-03-14 11:06:37 -07:00
David Eberly 36dd7961a9 Tests not included in GTE.
These appear to be part of the Claude Code analysis for bugs and defects.
2026-02-27 16:33:21 -08:00
David Eberly 389f187f8c Merge pull request #137 from CodeReclaimers/fix/natural-spline-2point-segfault
Require numPoints >= 3 for NaturalCubicSpline and NaturalQuinticSpline
2026-02-27 16:16:48 -08:00
David Eberly 0f2a8eef82 Merge branch 'master' into fix/natural-spline-2point-segfault 2026-02-27 16:16:40 -08:00
David Eberly c10318c4a7 Merge pull request #167 from CodeReclaimers/fix/trivial-comment-typo-fixes
Fix trivial typos in MathematicsGPU shader/header files
2026-02-27 16:14:40 -08:00
David Eberly 684c943f49 Merge pull request #166 from CodeReclaimers/fix/primal-query3-precision-table
Fix precision table typo in PrimalQuery3.h
2026-02-27 16:14:02 -08:00
David Eberly 2b23ac74e9 Merge pull request #165 from CodeReclaimers/fix/arc2-default-constructor
Fix Arc2 default constructor endpoints
2026-02-27 16:13:30 -08:00
David Eberly 11337ddc70 Merge pull request #164 from CodeReclaimers/fix/intr-line2-circle2-documentation
Add unit-length direction documentation to IntrLine2Circle2.h
2026-02-27 16:12:16 -08:00
David Eberly 33d306c35b Merge pull request #163 from CodeReclaimers/fix/dist-line2-triangle2-bugs
Fix NoCommonPoints bugs in DistLine2Triangle2.h
2026-02-27 16:11:48 -08:00
David Eberly 569f31f01e Merge pull request #162 from CodeReclaimers/fix/dist-point3-tet-barycentric
Fix barycentric coordinates not stored in DistPoint3Tetrahedron3
2026-02-27 16:11:13 -08:00
David Eberly b3da538a14 Merge pull request #161 from CodeReclaimers/fix/intr-line3-torus3-comment
Fix reversed radius inequality in IntrLine3Torus3.h comment
2026-02-27 16:09:48 -08:00
David Eberly 66732363b4 Merge pull request #160 from CodeReclaimers/fix/transform-inverse-vec-mat
Fix Transform::Inverse() for GTE_USE_VEC_MAT convention
2026-02-27 16:09:15 -08:00
David Eberly 0b5ae8f2a6 Merge pull request #159 from CodeReclaimers/fix/roots-bisection-misleading-return
Fix RootsBisection::Find misleading return when maxIterations < 2
2026-02-27 16:08:15 -08:00
David Eberly 1915e872b3 Merge pull request #158 from CodeReclaimers/fix/timer-getseconds-precision
Fix Timer::GetSeconds() precision truncation
2026-02-27 16:06:31 -08:00
David Eberly 7360d5f89d Merge pull request #157 from CodeReclaimers/fix/thread-safe-lock-guard
Use std::lock_guard for exception safety in ThreadSafeMap and ThreadSafeQueue
2026-02-27 16:06:05 -08:00
David Eberly 93aad85140 Merge pull request #156 from CodeReclaimers/fix/appr-query-negative-indices
Add negative index check in ApprQuery::ValidIndices
2026-02-27 16:05:35 -08:00
David Eberly 85848353e2 Merge pull request #155 from CodeReclaimers/fix/appr-3d-isfinite-mean2
Add missing std::isfinite check for mean[2] in 3D approximation classes
2026-02-27 16:05:09 -08:00
David Eberly 20bfd2bfe7 Merge pull request #154 from CodeReclaimers/fix/appr-torus3-jacobian
Fix Jacobian computation errors in ApprTorus3 torus fitting
2026-02-27 16:04:03 -08:00
David Eberly fbe9caa796 Merge pull request #153 from CodeReclaimers/fix/appr-polynomial-special-overallocation
Fix mParameters overallocation in ApprPolynomialSpecial3 and ApprPolynomialSpecial4
2026-02-27 16:03:27 -08:00
David Eberly e85264eec0 Merge branch 'master' into fix/appr-polynomial-special-overallocation 2026-02-27 16:03:19 -08:00
David Eberly 5871524150 Merge pull request #152 from CodeReclaimers/fix/terrain-interpolation
Fix wrong bilinear interpolation in Terrain::GetHeight
2026-02-27 16:00:56 -08:00
David Eberly 268c4b548d Merge pull request #151 from CodeReclaimers/fix/bumpmap-copypaste
Fix copy-paste bug in BumpMapEffect::ComputeTangent
2026-02-27 15:59:36 -08:00
David Eberly 63d3d22355 Merge pull request #150 from CodeReclaimers/fix/integration-shift-overflow
Fix signed integer overflow UB in Integration quadrature
2026-02-27 15:59:06 -08:00
David Eberly 036eb9ff5e Merge pull request #149 from CodeReclaimers/fix/rootsbisection2-flag-overwrite
Fix RootsBisection2 y-bisection failure flag overwritten
2026-02-27 15:58:43 -08:00
David Eberly da7611c827 Merge pull request #148 from CodeReclaimers/fix/polynomialroot-const-ref
Fix PolynomialRoot comparison operators taking non-const refs
2026-02-27 15:58:22 -08:00
David Eberly 1a86b9cb4c Merge pull request #147 from CodeReclaimers/fix/array-ownership-check
Fix Array2/3/4 ownership check in SetPointers
2026-02-27 15:57:22 -08:00
David Eberly 2de83d4fef Merge pull request #146 from CodeReclaimers/fix/bsnumber-sign-on-zero
Fix BSNumber string constructor setting nonzero sign on zero
2026-02-27 15:56:45 -08:00
David Eberly 4cdcb895f7 Merge branch 'master' into fix/bsnumber-sign-on-zero 2026-02-27 15:56:38 -08:00
David Eberly 2dcd3de541 Merge pull request #145 from CodeReclaimers/fix/bsrational-frexp-zero
Fix BSRational frexp not handling zero input
2026-02-27 15:55:47 -08:00
David Eberly ec334844bd Merge branch 'master' into fix/bsrational-frexp-zero 2026-02-27 15:55:38 -08:00
David Eberly 98fdfcb5fc Merge pull request #144 from CodeReclaimers/fix/minheap-isvalid
Fix MinHeap::IsValid() skipping root's children
2026-02-27 15:53:49 -08:00
David Eberly 763ef2ca20 Merge pull request #143 from CodeReclaimers/fix/uintegerfp32-pragma-number
Fix mismatched pragma warning number in UIntegerFP32.h
2026-02-27 15:53:18 -08:00
David Eberly d7eb5af070 Merge pull request #142 from CodeReclaimers/fix/bsnumber-string-single-digit
Fix string constructor rejecting single-digit signed numbers
2026-02-27 15:52:58 -08:00
David Eberly e78b823d2c Merge branch 'master' into fix/bsnumber-string-single-digit 2026-02-27 15:52:46 -08:00
David Eberly e5ef28cd59 Merge pull request #141 from CodeReclaimers/fix/ieee-binary-isquietnan
Fix IsQuietNaN() rejecting standard quiet NaN in IEEEBinary.h
2026-02-27 15:49:14 -08:00
David Eberly a53fc4a181 Merge pull request #140 from CodeReclaimers/fix/image-move-assignment
Add missing std::move in Image2/Image3 move assignment operators
2026-02-27 15:48:43 -08:00
David Eberly efe04a832c Merge pull request #139 from CodeReclaimers/fix/cholesky-solvelower-blocksize
Fix SolveLower loop bounds in runtime BlockCholeskyDecomposition
2026-02-27 15:47:39 -08:00
David Eberly 6251e50e89 Merge pull request #138 from CodeReclaimers/fix/ldlt-assertion-checks
Fix assertion bugs in LDLTDecomposition.h
2026-02-27 15:47:11 -08:00
David Eberly ae06fcc403 Merge pull request #136 from CodeReclaimers/fix/wicfileio-16bit-rgb
Fix 16-bit RGB PNG loaded with 8-bit texture format in WICFileIO
2026-02-27 15:46:43 -08:00
David Eberly e7808df75f Merge pull request #135 from CodeReclaimers/fix/command-argv-bounds
Fix out-of-bounds access in Command option parsing
2026-02-27 15:46:12 -08:00
David Eberly 649f882d6b Merge pull request #134 from CodeReclaimers/fix/camerarig-erase-key
Fix CameraRig::Register erasing by wrong key
2026-02-27 15:45:37 -08:00
David Eberly 49bb11a03b Merge pull request #133 from CodeReclaimers/fix/ambientlight-uniform-name
Fix GLSL uniform block name mismatch in AmbientLightEffect
2026-02-27 15:45:19 -08:00
David Eberly 59f591f989 Merge pull request #132 from CodeReclaimers/fix/dx11engine-share-return
Fix DX11Engine::Share returning wrong object
2026-02-27 15:44:08 -08:00
David Eberly 0733228871 Merge pull request #131 from CodeReclaimers/fix/glslreflection-wrong-resize
Fix wrong vector resized in GLSLReflection
2026-02-27 15:43:51 -08:00
David Eberly 04276b9750 Merge pull request #130 from CodeReclaimers/fix/gl46texturearray-assert
Fix inverted assertion in GL46TextureArray::Update
2026-02-27 15:43:16 -08:00
David Eberly 6498734b3e Merge pull request #129 from CodeReclaimers/fix/gl46engine-linkmap-unit
Fix mLinkMap using wrong variable in GL46Engine
2026-02-27 15:42:58 -08:00
David Eberly e835053294 Merge pull request #127 from CodeReclaimers/fix/viewvolume-ortho-macro
Fix wrong preprocessor macro in orthographic projection
2026-02-27 15:37:20 -08:00
David Eberly 29ef1b0141 Merge pull request #126 from CodeReclaimers/fix/picker-closest-nonpositive
Fix inverted comparison in Picker::GetClosestNonpositive
2026-02-27 15:36:56 -08:00
David Eberly 20a1dee79f Merge pull request #125 from CodeReclaimers/fix/interp-grid-max-precedence
Fix operator precedence bug in interpolation grid max
2026-02-27 15:36:23 -08:00
David Eberly 58a6f08075 Merge pull request #124 from CodeReclaimers/fix/onidletimer-seconds-per-frame
Fix OnIdleTimer::GetSecondsPerFrame returning wrong units
2026-02-27 15:35:38 -08:00
David Eberly 318cd26208 Merge pull request #123 from CodeReclaimers/fix/gpufluid3-wrong-include
Fix wrong include in GPUFluid3ComputeDivergence.h
2026-02-27 15:35:05 -08:00
David Eberly a7e401f395 Merge pull request #122 from CodeReclaimers/fix/bsnumber-signed-overflow
Fix signed integer overflow UB in BSNumber and BitHacks for INT_MIN
2026-02-27 15:34:40 -08:00
David Eberly 96dfb0994a Merge pull request #121 from CodeReclaimers/fix/functions-robustdop-semicolon
Fix syntax error in RobustDOP (period instead of semicolon)
2026-02-27 15:33:35 -08:00
David Eberly caa87e46c4 Merge pull request #120 from CodeReclaimers/fix/svd-getv-size
Fix buffer overrun in SingularValueDecomposition::GetV
2026-02-27 15:33:05 -08:00
David Eberly ce94409c23 Merge pull request #119 from CodeReclaimers/fix/natural-quintic-spline-derivatives
Fix 4th/5th derivative coefficients in NaturalQuinticSpline::Evaluate
2026-02-27 15:32:43 -08:00
David Eberly 2def217e82 Merge pull request #118 from CodeReclaimers/fix/cont-capsule3-merge-radius
Fix missing negEnd0 radius comparison in ContCapsule3 MergeContainers
2026-02-27 15:30:57 -08:00
David Eberly a3d1212ab3 Merge pull request #117 from CodeReclaimers/fix/appr-polynomial4-evaluate
Fix two bugs in ApprPolynomial4::Evaluate
2026-02-27 15:30:32 -08:00
David Eberly cd4fd0b19e Merge pull request #116 from CodeReclaimers/fix/appr-polynomial-special4-zpowers
Fix mYPowers/mZPowers typo in ApprPolynomialSpecial4::Evaluate
2026-02-27 15:29:21 -08:00
David Eberly f0f0a65a8e Merge pull request #115 from CodeReclaimers/fix/gmatrix-operator-ne-different-dimensions
Fix GMatrix::operator!= returning false for different dimensions
2026-02-27 15:28:48 -08:00
David Eberly f745e55986 Merge pull request #114 from CodeReclaimers/fix/matrix4x4-oblique-projection-typo
Fix typo in MakeObliqueProjection: M(0,2) should be M(0,3)
2026-02-27 15:28:02 -08:00
David Eberly 5fc279d2c3 Merge pull request #113 from CodeReclaimers/fix/vector-initializer-list-oob
Fix out-of-bounds write in Vector initializer_list constructor
2026-02-27 15:25:36 -08:00
CodeReclaimersandClaude Opus 4.6 2c9ef40c4a Fix trivial typos in MathematicsGPU shader/header files
- Remove spurious unary plus in HLSL shader string (+ +viscosityZ → + viscosityZ)
  in GPUFluid3UpdateState.cpp
- Remove duplicate #include <Graphics/ProgramFactory.h> in GPUFluid2AdjustVelocity.h

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-27 15:37:39 -05:00
CodeReclaimersandClaude Opus 4.6 80e3a85423 Fix precision table typo in PrimalQuery3.h ToCircumsphere
The third row of the UIntegerFP32<N> precision table for
ToCircumsphere says BSNumber but should say BSRational (float
input with BSRational compute type requires N=262).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 19:07:10 -05:00
CodeReclaimersandClaude Opus 4.6 55695c63c4 Fix Arc2 default constructor to match documented defaults
The comment says end0=(1,0) and end1=(0,1) but the code set both
endpoints to Zero(), which are not on the unit circle. Changed to
use Unit(0) and Unit(1) to match the documentation and produce a
valid quarter-circle arc.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 19:04:45 -05:00
CodeReclaimersandClaude Opus 4.6 358294d730 Add unit-length direction documentation to IntrLine2Circle2.h
The FIQuery::DoQuery method assumes unit-length line direction for
correct intersection parameters, but this requirement was only noted
in an internal comment. Add file-level documentation to make the
requirement visible to callers.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 18:38:52 -05:00
CodeReclaimersandClaude Opus 4.6 602ed5dd4e Fix NoCommonPoints bugs in DistLine2Triangle2.h
In NoCommonPoints(), fix two bugs: (1) use minDistance instead of the
local variable distance (which holds fabs(ncomp[2])) for the result
distance and sqrDistance, and (2) set the barycentric coordinates for
the closest vertex.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 18:29:07 -05:00
CodeReclaimersandClaude Opus 4.6 d5c9b624fb Fix barycentric coordinates not stored in DistPoint3Tetrahedron3 result
A local variable `barycentric` shadowed the result struct's field,
so the computed barycentric coordinates were discarded.  Callers
received all-zero barycentrics.  Write directly to result.barycentric.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 18:22:26 -05:00
CodeReclaimersandClaude Opus 4.6 aac24040e5 Fix reversed radius inequality in IntrLine3Torus3.h comment
The comment said "inner radius r1 > r0" but for a ring torus the
major radius must exceed the tube radius, i.e. r0 > r1.  This
matches the definition in Torus3.h which correctly states r0 >= r1.

Documentation-only change; no code logic is affected.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 18:18:39 -05:00
CodeReclaimersandClaude Opus 4.6 e65ecbd429 Fix Transform::Inverse() for GTE_USE_VEC_MAT convention
Two bugs in Inverse() when compiled with GTE_USE_VEC_MAT:

1. RS + uniform-scale case: the translation was computed as
   R^T * T (matrix * column-vector) instead of T * R^T
   (row-vector * matrix), producing an incorrect inverse.

2. Non-RS case: translation was extracted from column 3 of the
   inverse matrix, but under VEC_MAT the translation lives in
   row 3.  This returned a zero translation for the inverse.

Also guard the translation overwrite in GetHInverse() so that
it only runs for RS matrices.  For non-RS matrices, gte::Inverse
already produces the correct full 4x4 inverse; the overwrite was
redundant.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-26 18:08:25 -05:00
CodeReclaimersandClaude Opus 4.6 89bdd3e2a4 Fix misleading return value in RootsBisection::Find when maxIterations < 2
The for-loop starts at i=2, so when maxIterations is 0 or 1 the loop
never executes.  The old code returned i=2, falsely indicating
bisections were performed, and left root at t0 instead of the midpoint.

Compute the midpoint before the loop so root always gets a reasonable
value, and return maxIterations+1 (the documented "no convergence"
sentinel) when the loop completes without breaking.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-21 10:00:19 -05:00
CodeReclaimersandClaude Opus 4.6 b56cb33830 Fix Timer::GetSeconds() precision truncation to sub-millisecond
GetSeconds() converted through GetMilliseconds() first, truncating to
whole millisecond precision and losing sub-millisecond timing. Changed
to convert from GetNanoseconds() directly for full precision.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-21 09:49:30 -05:00
CodeReclaimersandClaude Opus 4.6 ec55665f90 Use std::lock_guard for exception safety in ThreadSafeMap and ThreadSafeQueue
All methods used manual mMutex.lock()/mMutex.unlock() instead of RAII.
If any operation between lock and unlock throws (e.g., copy constructor,
map insertion), the mutex would never be unlocked, causing deadlock.

Replaced all manual lock/unlock pairs with std::lock_guard<std::mutex>.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-21 09:41:42 -05:00
CodeReclaimersandClaude Opus 4.6 f3c46201b3 Add negative index check in ApprQuery::ValidIndices
ValidIndices only checked for indices >= numObservations but not for
negative indices. Since indices are int32_t, a negative value would
pass the upper-bound check but cause out-of-bounds access when used
to index the observations array.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-21 09:29:43 -05:00
CodeReclaimersandClaude Opus 4.6 b8d0938b62 Add missing std::isfinite check for mean[2] in 3D approximation classes
ApprOrthogonalLine3, ApprGaussian3, and ApprHeightPlane3 checked
std::isfinite for mean[0] and mean[1] but not mean[2]. When z-coordinates
produce a non-finite mean (e.g. NaN from inf + (-inf)), the fitting
functions could return true with NaN in the output parameters.

The corresponding 2D classes (ApprOrthogonalLine2, ApprGaussian2) correctly
check all components.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-21 07:39:48 -05:00
CodeReclaimersandClaude Opus 4.6 62ca57fd07 Fix Jacobian computation errors in ApprTorus3 torus fitting
Three errors in the Gauss-Newton Jacobian for torus fitting:
- dF/dTheta and dF/dPhi were missing the NdotD (Dot(N,D)) factor
- dF/du had an erroneous multiplication by u

The correct partial derivatives for F = (|D|^2+v)^2 - 4u(|D|^2-(N·D)^2):
- dF/dTheta = 8*u*NdotD*Dot(dN/dTheta, D)
- dF/dPhi = 8*u*NdotD*Dot(dN/dPhi, D)
- dF/du = -4*(|D|^2 - (N·D)^2)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 11:17:56 -05:00
CodeReclaimersandClaude Opus 4.6 9bc72b2115 Fix mParameters overallocation in ApprPolynomialSpecial3 and ApprPolynomialSpecial4
ApprPolynomialSpecial3 allocated N*N elements for mParameters instead of N,
and ApprPolynomialSpecial4 allocated N*N*N instead of N. Only N elements
(one per polynomial term) are ever used. This also caused GetMinimumRequired()
to return an inflated value, requiring more observations than necessary.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 11:05:31 -05:00
CodeReclaimersandClaude Opus 4.6 9dae8d3fe3 Fix wrong bilinear interpolation in Terrain::GetHeight
h11 = GetHeight(row + 1, col) should be GetHeight(row + 1, col + 1).
The height at the (row+1, col+1) corner was never sampled, producing
incorrect terrain heights near cell diagonals.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 10:45:04 -05:00
CodeReclaimersandClaude Opus 4.6 233336e2de Fix copy-paste bug in BumpMapEffect::ComputeTangent
Length(deltaPos1) is tested twice on line 168; second check should
test Length(deltaPos2). Without this, a zero-length deltaPos2 is
not detected and the function proceeds with a degenerate tangent frame.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 10:43:30 -05:00
CodeReclaimersandClaude Opus 4.6 eae04379b3 Fix signed integer overflow UB in Integration quadrature
1 << (n-1) uses signed int shift which is UB when n > 31.
Changed to 1u << for unsigned shift.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 10:34:19 -05:00
CodeReclaimersandClaude Opus 4.6 7dde356325 Fix RootsBisection2 y-bisection failure flag overwritten by x-bisection
mNoGuaranteeForRootBound is set from y-bisection, then unconditionally
overwritten by x-bisection. If y-bisection fails but x-bisection
succeeds, the failure is silently lost. Changed = to |=.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 10:13:48 -05:00
CodeReclaimersandClaude Opus 4.6 007fc2fa89 Fix PolynomialRoot comparison operators taking non-const references
operator== and operator< take `PolynomialRoot&` instead of
`PolynomialRoot const&`, preventing use with const objects or
in standard algorithms like std::sort.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 08:47:25 -05:00
CodeReclaimersandClaude Opus 4.6 97c8d2dc72 Fix Array2/3/4 ownership check in SetPointers
SetPointers checks `mBound0 > 0` to distinguish owning from non-owning
arrays, but mBound0 is always positive for any valid array. Changed to
check `mObjects.size() > 0`. Copying a non-owning array previously took
the owned branch and dereferenced mObjects.data() on an empty vector.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 08:25:49 -05:00
CodeReclaimersandClaude Opus 4.6 5ff294add9 Fix BSNumber string constructor setting nonzero sign on zero
ConvertToInteger("0") returns a zero BSNumber (mSign=0), but the
constructor unconditionally overwrites mSign=sign (+1), violating
the invariant that zero has mSign=0.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 08:10:19 -05:00
CodeReclaimersandClaude Opus 4.6 70244ed572 Fix BSRational frexp not handling zero input
When x is zero, GetExponent() returns -1 (meaningless) and the function
corrupts the zero value. Add early return for zero matching the BSNumber
frexp implementation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 08:05:23 -05:00
CodeReclaimersandClaude Opus 4.6 6a14f53e1c Fix MinHeap::IsValid() skipping validation of root's children
IsValid() used `if (parent > 0)` but should use `if (child > 0)`.
When child is 1 or 2, parent is 0, so `parent > 0` is false and
the root's children are never checked against the root.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 07:41:54 -05:00
CodeReclaimersandClaude Opus 4.6 7e1fca65aa Fix mismatched pragma warning number in UIntegerFP32.h
Line 65 disables warning 26495 but line 144 restored warning 28020
instead, leaving 26495 permanently suppressed for the rest of the
translation unit.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 07:36:11 -05:00
CodeReclaimersandClaude Opus 4.6 28cb8a049b Fix string constructor rejecting single-digit signed numbers
BSNumber and BSRational string constructors checked
`substr.size() > 1` after stripping the sign character. This rejected
valid single-digit inputs like "+5" or "-3" (size 1 after stripping).
Changed to `> 0`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 07:34:16 -05:00
CodeReclaimersandClaude Opus 4.6 01a98c8d21 Fix IsQuietNaN() rejecting standard quiet NaN in IEEEBinary.h
The extra NAN_PAYLOAD_MASK check required a nonzero payload, but the
standard quiet NaN (e.g. 0x7FC00000 for float) has the quiet bit set
with zero payload. This made IsQuietNaN() inconsistent with
GetClassification(), which correctly checks only the quiet bit.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-19 07:28:50 -05:00
CodeReclaimersandClaude Opus 4.6 704eae0477 Add missing std::move in Image2/Image3 move assignment operators
Both move assignment operators passed the rvalue reference parameter
as an lvalue to the base class, invoking copy assignment instead of
move assignment.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-18 18:30:26 -05:00
CodeReclaimersandClaude Opus 4.6 46dffa6152 Fix SolveLower loop bounds in runtime BlockCholeskyDecomposition
The inner loops in SolveLower iterated up to NumBlocks instead of
BlockSize, accessing out-of-bounds block elements when the two values
differ. The compile-time specialization correctly uses BlockSize.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-18 18:13:32 -05:00
CodeReclaimersandClaude Opus 4.6 d3cc4fef31 Fix assertion bugs in LDLTDecomposition.h
- Solve(): D.GetNumCols() was missing the `== N` comparison, evaluating
  as boolean (true for any nonzero column count) instead of validating
  the expected dimension.
- Block LDLT: validated block matrices against NumBlocks instead of
  BlockSize, accepting incorrectly-sized blocks.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-18 18:11:21 -05:00
CodeReclaimersandClaude Opus 4.6 1921d023d1 Require numPoints >= 3 for NaturalQuinticSpline and NaturalCubicSpline
With 2 points, RowReduce accesses mDelta[1] which is out of bounds
(mDelta has only 1 element), causing a heap-buffer-overflow. The
multi-segment solver requires at least 2 segments (3 points) for
its row reduction to work correctly.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-18 13:48:35 -05:00
CodeReclaimersandClaude Opus 4.6 db5e53543b Fix 16-bit RGB PNG loaded with 8-bit texture format in WICFileIO::Load
In the bit_depth==16 / PNG_COLOR_TYPE_RGB branch, the texture was
allocated with DF_R8G8B8A8_UNORM instead of DF_R16G16B16A16_UNORM,
causing a buffer overrun when writing uint16_t data.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:51:51 -05:00
CodeReclaimersandClaude Opus 4.6 743f3484dc Fix out-of-bounds access in Command when option is last argument
GetInteger, GetFloat, GetDouble, and GetString all access
mArguments[i+1] without checking bounds. When a flag like --option
is the last argument, this reads past the end of the vector.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:48:32 -05:00
CodeReclaimersandClaude Opus 4.6 a0f87bf2cf Fix CameraRig::Register erasing by wrong key
When unregistering (negative trigger), erases by the trigger value which
is never a key in the map. Should erase by element.first (the actual key
found matching the function).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:45:35 -05:00
CodeReclaimersandClaude Opus 4.6 4041cf72ae Fix GLSL uniform block name mismatch in AmbientLightEffect
The GLSL shader declares the block as "Light" but C++ binds to "Lighting".
The constant buffer never binds on the GL46 backend, leaving ambient light
parameters at zero.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:44:47 -05:00
CodeReclaimersandClaude Opus 4.6 284959c440 Fix DX11Engine::Share returning wrong object
Returns dxTexture (source engine's object) instead of dxShared.get()
(the newly created shared copy for this engine).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:43:53 -05:00
CodeReclaimersandClaude Opus 4.6 4549fbb712 Fix wrong vector resized in ReflectTransformFeedbackVaryings
mInputs.resize() corrupts the shader inputs array. Should be
mTransformFeedbackVaryings.resize().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:43:28 -05:00
CodeReclaimersandClaude Opus 4.6 ab38cfa81c Fix inverted assertion in GL46TextureArray::Update
The assertion rejects valid DYNAMIC_UPDATE usage instead of requiring it.
Changed != to ==.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:43:01 -05:00
CodeReclaimersandClaude Opus 4.6 ab2510e4c1 Fix mLinkMap using wrong variable in GetUnitProgramIndex
mLinkMap[index] uses the output parameter instead of the input 'unit',
causing wrong shader resource lookup.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:42:34 -05:00
CodeReclaimersandClaude Opus 4.6 8bafdac2a4 Fix wrong preprocessor macro in orthographic projection
The orthographic section checked GTE_USE_MAT_VEC while every other
usage in the codebase checks GTE_USE_VEC_MAT. In the default build
(neither macro defined), this caused the orthographic projection to
use VEC_MAT convention while perspective used MAT_VEC. Fixed by
changing to GTE_USE_VEC_MAT and swapping the branch bodies. Also
fixed missing 2.0f factor in VEC_MAT depth [-1,1] branch.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 17:27:00 -05:00
CodeReclaimersandClaude Opus 4.6 03e94af588 Fix inverted comparison in Picker::GetClosestNonpositive
The comparison `closest < record.distanceToLinePoint` finds the farthest
record instead of the closest. Fixed to match GetClosestNonnegative pattern.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:59:50 -05:00
CodeReclaimersandClaude Opus 4.6 bbb75a093d Fix operator precedence bug in interpolation grid max computation
mXMax = xMin + xSpacing * xBound - 1 evaluates as (xMin + xSpacing*xBound) - 1
instead of xMin + xSpacing*(xBound - 1). Affects IntpBilinear2, IntpBicubic2,
IntpTrilinear3, and IntpTricubic3.

Test: tests/issue_6_2_3_4_interp_grid_max/

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:57:22 -05:00
CodeReclaimersandClaude Opus 4.6 2ad4e902a0 Fix GetSecondsPerFrame returning wrong units (1000000x too large)
Formula was `1000.0 * numMilliseconds / numFrames` instead of
`numMilliseconds / (1000.0 * numFrames)`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:41:50 -05:00
CodeReclaimersandClaude Opus 4.6 3c5919e802 Fix wrong include in GPUFluid3ComputeDivergence.h
Includes GPUFluid2Parameters.h instead of GPUFluid3Parameters.h.
All other GPUFluid3 files correctly include the 3D version.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:29:37 -05:00
CodeReclaimersandClaude Opus 4.6 8b9067babc Fix signed integer overflow UB in BSNumber and BitHacks for INT_MIN values
BSNumber(int32_t) and BSNumber(int64_t) negated negative inputs via
`number = -number`, which is undefined behavior for INT32_MIN/INT64_MIN.
Fix: use unsigned arithmetic for the magnitude.

BitHacks::GetTrailingBit(int32_t) used `value & -value` which also
overflows for INT32_MIN, and the uint32_t overload delegated to it.
Fix: reverse delegation so uint32_t does the work using ~value + 1u.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:26:26 -05:00
CodeReclaimersandClaude Opus 4.6 3cfe31f019 Fix syntax error in RobustDOP: period instead of semicolon
Lines 113 and 216 end with '.' instead of ';' inside #if defined(GTE_DISCARD_FMA),
causing a compilation failure when that macro is defined.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:22:03 -05:00
CodeReclaimersandClaude Opus 4.6 9678eef47a Fix buffer overrun in SingularValueDecomposition::GetV
GetV looped over mUMatrix.size() (M*M) instead of mVMatrix.size() (N*N),
reading past the end of mVMatrix when M > N.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:17:03 -05:00
CodeReclaimersandClaude Opus 4.6 7fbbf978a5 Fix 4th and 5th derivative coefficients in NaturalQuinticSpline::Evaluate
Lines 219 and 225 used factor 60 (correct for 3rd derivative: 5*4*3)
where 120 (= 5*4*3*2 = 5!) is needed for the 4th and 5th derivatives.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 16:11:50 -05:00
CodeReclaimersandClaude Opus 4.6 e4186a5811 Fix missing radius comparison for negEnd0 in MergeContainers
The negEnd0 distance+radius was computed but never compared against
the running maximum, so the merged capsule could be too narrow.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 15:57:04 -05:00
CodeReclaimersandClaude Opus 4.6 c7e8a4cd1b Fix two bugs in ApprPolynomial4::Evaluate Horner evaluation
Line 249: wrong stride (mYDegree instead of mYDegreeP1) when writing
to mYZCoefficient, causing z-slice overlap.

Line 259: reads from mParameters instead of mYZCoefficient in the
y-Horner loop, discarding the x-evaluation from stage 1.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 14:32:37 -05:00
CodeReclaimersandClaude Opus 4.6 41d34f2f64 Fix mYPowers/mZPowers typo in ApprPolynomialSpecial4::Evaluate
Line 199: z-power lookup read from mYPowers instead of mZPowers,
making evaluation correct only when y == z.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 10:28:51 -05:00
CodeReclaimersandClaude Opus 4.6 c8f2dcf75d Fix GMatrix::operator!= returning false for different dimensions
operator!= required dimensions to match AND elements to differ, so
two matrices of different sizes were considered "equal." Fix by
defining it as !operator==.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 05:09:51 -05:00
CodeReclaimersandClaude Opus 4.6 ab50e30c0f Fix typo in MakeObliqueProjection under GTE_USE_VEC_MAT
Line 234 writes M(0,2) instead of M(0,3), overwriting the correct
M(0,2) value with zero and corrupting the projection matrix.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 05:04:14 -05:00
CodeReclaimersandClaude Opus 4.6 ef551913fc Fix out-of-bounds write in Vector initializer_list constructor
The initializer_list constructor (enabled for N >= 5) has a second
loop intended to zero-fill elements beyond those provided. The loop
condition was `i < numValues` but should be `i < N`:

- When numValues > N, the loop writes past the end of the fixed-size
  mTuple array (buffer overflow).
- When numValues < N, the loop never executes, leaving elements
  [numValues..N-1] uninitialized instead of zeroed as documented.

Changing the bound to N fixes both problems.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-15 09:54:32 -05:00
David Eberly 87e5d39242 Fixed major and minor version numbers.
The GTE_MAJOR_VERSION and GTE_MINOR_VERSION values are out of date. They were set to 7 and 3, respectively, when they should be 8 and 1, respectively.
2026-02-03 11:59:06 -08:00
David Eberly 2339413089 Remove special tools.
Removed tools that were specific to development, testing, and code maintenance.
2026-01-12 17:40:23 -08:00
David Eberly a1551db717 BitmapFontCreator update
Added solution, project, and filter files for Microsoft Visual Studio 2026.
Made some minor formatting adjustments to the source file.
2026-01-12 17:39:54 -08:00
David Eberly aeb614e435 Added support for Microsoft Visual Studio 2026.
I added Microsoft Visual Studio 2026 files for solutions, projects, and
filters. There are nearly 400 such triples of files (.v18.sln, .v18.vcxproj,
.v18.vcxproj.filters).
2026-01-11 23:13:19 -08:00
David Eberly 4971cbfa36 Modified copyright notices to include 2026.
Modified copyright notice to include 2026. All source files were modified. The file version numbers remain the same.
2026-01-11 14:00:48 -08:00
David Eberly 85be455409 Added 3D test-intersection queries for triangles and canonical boxes or aligned boxes.
Added intersection queries for a triangle and a canonical box or a triangle and an aligned box. The code for a triangle and an oriented box already existed. Modified the sizes and positions of the triangle and oriented box in the sample application; the previous triangle was too small and the previous box was too large.
2026-01-10 11:52:56 -08:00
David Eberly a9a2b14948 Update IntrCanonicalBox3Cylinder3.h
Despite using Mathematica to verify the mathematical equations and updating the PDF for box-cylinder intersection, I still failed to fix the bug mentioned in the December 26, 2025 report. In fact, the previous report broke the case for (U2,-D). The case for (D,-U2) had an incorrect divisor. These have now been fixed.

[From December 26] Fixed the lower and upper calculations for case (U2,-D). Thanks to
OttoX at github for reporting associated bugs.
2025-12-31 12:06:22 -08:00
David Eberly 6e050689a8 Update IntrCanonicalBox3Cylinder3.h
Fixed the lower and upper calculations for case (U2,-D).
2025-12-26 15:36:23 -08:00
David Eberly 40705105e6 Posting GTE 8.1.
GaussianElimination.h: The private Set function had an if-else statement that was designed to provide fast copying for floating-point Real and object copying for rational Real. The if-else statement  provides flow control at run time. However, the separation must occur at compile time. The Ubuntu g++ 13.3.0 compiler generated an error for the separation. I modified the code to use std::enable_if and  provided a Set for each case, the other case ignored by SFINAE (Substitution Failure Is Not An Error).

MinimumVolumeBox3*.h: The g++ compiler warned about the use of a pragma that is supported by the Microsoft Visual Studio compiler. With treat-warnings-as-errors, the files do not compile. I removed the pragma statements. The g++ compiler also complained about the Edge.T and Triangle.T members shadowing the class template parameter T. I renamed the members of Edge and Triangle to use lower-case v, e, and t.

MinimumVolumeBox3DWindow3.cpp: The modifications to the minimum volume box code required an update to the sample application. The new template parameter list is different from the old one.
2025-11-24 23:20:03 -08:00
David Eberly cad5fdbbf5 Merge pull request #103 from BasketsAlaaf/add-cmake-install-target
Added install targets for Mathematics Header Only library
2025-11-24 14:02:06 -08:00
David Eberly d7b95fb25e Fixed hill-climbing performance and redesign of classes.
The GetExtreme function is a hill-climbing algorithm that visits the vertices of a convex hull. A user reported failure of the minimum volume box code, which I tracked down to failure of GetExtreme. I posted a fix on July 24, 2024. Another dataset showed this did not solve the original problem. I added another fix on August 31, 2024. This also did not solve the original problem. The final fix was to skip hill climbing and search all vertices, posted on September 5, 2024. Over 1 year later, another user of the code reported that the performance degraded significantly. The original datasets that showed failure had a very small number of points. The other user had datasets with thousands of points.

I spent quite a bit of time doing a deep dive of the code. It turns out the actual problem was that a convex hull can have triangular faces where some of the faces are coplanar (or nearly coplanar). Failure can occur when a vertex interior to a union of coplanar faces is visited. The algorithm terminated prematurely. My BSP-based extreme point code failed for the same reason. The minimum volume box code maintains a vertex-adjacency data structure built directly from the convex hull. The solution to the original problem was to remove edges from this data structure that are shared by two coplanar triangles. After such removal, there can be some vertices remaining that have only 2 neighbors. These also had to be removed. Effectively, the data structure represents a wireframe of the convex hull where some of the faces
are convex polygons with 4 or more vertices.

I redesigned the class interface slightly, separating out the version that uses floating-point computations and the version that uses rational arithmetic. Both versions must use rational arithmetic to build the convex hull for an exact representation. Without this, the hill climbing can fail. Fortunately, the rational convex hull is not expensive to compute given that the dot products in GetExtreme are the main bottleneck in the computations.
2025-11-23 20:20:10 -08:00
David Eberly bbf3fece17 Fixed assertion in ExtremalQuery sample application when BSP queries are used.
I had claimed previously that the ExtremalQuery3BSP code was broken. It turns out that the code works as before. The problem was that I had modified the ConvexHull3 code whereby the old code function GetUnorderedHull returned an array of triangles but the new code function GetHull returned an array of indices. The application code was not modified accordingly, so when the application was set to use the BSP query, it would trigger an assert. (I need the BSP query to fix a performance problem I introduced in a bug fix to MinimumVolumeBox3.) The query header was modified to avoid the Visual Studio code analysis warnings that the SphericalArc objects were possibly uninitialized, even though the default constructor initializes all member functions. The application now uses the BSP query by default.
2025-11-01 18:08:00 -07:00
David Eberly 7cac1e1799 Update TriangulateEC.h
The function ComputeNearestOuterPolygonIntersection had an assertion that v0min and v1min were nonnegative. However, they are of type std::size_t, so the assertion is never triggered. This problem was introduced in version 6.0.2023.12.16 when I converted from type
std::int32_t to std::size_t. Thanks to Aaron Barany for diagnosing and reporting the problem. I am working on modifications to trap more problems when the input outer and inner polygons are invalid.
2025-10-05 17:25:50 -07:00
David Eberly 5fc175e57c Update README.md
The current update history was for version 7, but the actual version now is 8.
2025-09-22 14:10:25 -07:00
David Eberly fbba8a975b Removed specialization of std::is_signed.
Embarcadero 13 uses Clang 15, where std::is_signed<T> is now a compiler intrinsic rather than a template class. As such, a specialization of std::is_signed<T> is not allowed. I removed the specializations.
2025-09-22 08:16:41 -07:00
David Eberly 1ed0582d30 Implemented occlusion query for OpenGL engine.
Implemented the occlusion query for the OpenGL graphics engine.
2025-08-20 22:10:13 -07:00
David Eberly 979d94e786 Update GL46.cpp
The function OpenGLReportListener was incorrect regarding throwing exceptions. The throw occurred inside the 'default' case of the switch statement. It had to be outside the switch statement and inside the code block for when 'code' is not zero. After making this change, the Intel Graphics driver on my laptop threw an exception in the GLSL reflection code when checking for a GL error in glProgramInterfaceiv for programInterface is GL_TRANFORM_BUFFER. I have seen this behavior over the years. I thought that the OpenGL specification required this to be handled. I added a block of code to trap this special case and not call \textsf{ReportGLError}. I also commented out the preprocessor definition GTE_GL46_THROW_ON_REPORT_LISTENER_WARNING}
in case other such GL errors are unexpectedly generated.
2025-08-08 17:33:12 -07:00
David Eberly f78dd0b65b Modified GLSL version number from 430 to 460.
Modified the default version of OpenGL from #version 430 to #version 460. Modified comments to reference OpenGL 4.6 instead of OpenGL 4.5.
2025-07-17 15:23:21 -07:00
David Eberly 9daf4fc61b Update MultipleRenderTargetsWindow3.h
Removed two unused class members.
2025-07-14 14:53:59 -07:00
David Eberly 710370f174 Merge pull request #107 from CodeReclaimers/patch-1
Typo in DistAlignedBoxAlignedBox.h
2025-06-26 09:15:26 -07:00
CodeReclaimers 242fa55bd0 Update version 2025-06-26 12:01:14 -04:00
CodeReclaimers e0ceff7b10 Typo in DistAlignedBoxAlignedBox.h 2025-06-26 09:38:29 -04:00
David Eberly 3f9ad5a867 Update to OpenGL support, fix to GenerateProject.
After removing support for MSVS 2019, some files in the GenerateProject tools were deleted. However, I had failed to remove the project references to those files, and the project failed to compile.

For the OpenGL trace system, I added wrappers to hide the Microsoft OpenGL 1.0 and 1.1 DLL functions. This is a hack for now which uses the gte namespace. Fighting the gl* names for the DLL functions when the remaining extensions have wrappers around them with gl* names was painful. A later modification of GTE OpenGL will rename all the wrappers Gl* to avoid the hack.
2025-06-24 10:28:56 -07:00
David Eberly 2807e3d292 Modified read-me. Added GTE8.0 release notes.
Modified read-me. Added GTE8.0 release notes.
2025-05-12 18:51:38 -07:00
David Eberly 8fd9c1cdea Posted Geometric Tools Engine 8.0.
The change log is https://www.geometrictools.com/Downloads/Gte8UpdateHistory.pdf
2025-05-12 16:14:42 -07:00
David Eberly 8fdc0b6ea4 Added visualization of Marching Cubes.
Added a new sample to visualize Marching Cubes for a single voxel (8 corners). This will be ported to GTL for visual testing.
2025-03-24 18:10:46 -07:00
David Eberly 088ffc4252 Update IntpBSplineUniform.h
When porting the unit tests from GTE to GTL, I noticed the GetCacheMode function was missing.
2025-03-23 16:47:24 -07:00
David Eberly 1f7d051a90 Updates to paraboloid fitting.
I revisited the code for ApprParaboloid3.h. The  6x6 linear system solver is the one based on GaussianElimination. I replaced this with the linear solver of LDLTDecomposition, which avoids dynamic memory allocation. The Solve functions of LDLTDecomposition returned void and ignored the Boolean outputs of Factor. I modified the solvers to factor first, but only solve the system if the factorization was successful. Now Solve functions return a bool. When the template type T is BSRational<*> exact rational arithmetic), the LDLTDecomposition::Solve has so many operations that the compute time was much too long (I had to abort the unit test program after 1.5 hours). As it turns out, the Gaussian elimination code performs much faster. Therefore, I added some template metaprogramming to GaussianElimination when T is rational and to use
LDLTDecomposition when T is a floating-point type. The mean-squared error computations were incorrect. I added some more comments and made some formatting changes, mainly replacing int32_t by std::int32_t.
2025-03-12 13:47:24 -07:00
David Eberly 7ef3b1dbcf Update ApprParabola2.h
I revisited the code for ApprParabola2.h. I replaced the linear system solver that uses the GaussianElimination class by the specialized inversion of a Matrix3x3-based linear system solver. The latter has better performance (speed-up about 1.15) and avoids dynamic memory allocation and deallocation. The mean-squared error computations were incorrect. I added some more comments and made some formatting changes, mainly replacing int32_t by std::int32_t.
2025-03-12 13:43:00 -07:00
David Eberly 11fbdaecd6 Update ApprParabola2.h
If meanSquareError is null in the call to Fit, the local vecU is not copied to the output u. Thanks to Julien Maille for reporting and fixing the bug. The same bug occurs in FitRobust and needed to be fixed. The latest code has both fixes. The previous code uses a linear system solver specialized for 3x3 matrix systems. The fixes use a linear system solver with general purpose Gaussian elimination. This will result in lightly slower performance, but could be costly if you call the fitter a large number of times. The ApprParaboloid3 class has similar logic and uses the general purpose Gaussian elimination solely because GTE does not contain a specialization for 6x6 matrix systems. (I have added to my TODO list to use only specialized matrix system solvers for the
fitting.)
2025-03-07 21:18:11 -08:00
David Eberly 30b66e35b9 Merge pull request #104 from JulienMaille/patch-1
FIX: #102 Update ApprParabola2.h
2025-03-07 20:44:22 -08:00
Julien 8fe80ccad1 Update ApprParabola2.h
updated version and fixed a typo
2025-03-08 00:02:19 +01:00
Julien 219ef744ae FIX: #102 Update ApprParabola2.h 2025-03-06 09:23:22 +01:00
Matthias Schoepfer bf2db0181f Added install targets for Mathematics Header Only library
This wraps the Mathematics Header Only part of the library as a proper
cmake package and installs the headers into include prefix and
gtmathematics subdirectory. This can be found using proper
find_package(gtmathematics).

Upstream-Status: Pending

Signed-off-by: Matthias Schoepfer <msc@fp-robotics.com>
2025-03-06 08:07:32 +01:00
David Eberly 768c731ebc Update IntpBSplineUniform.h
During porting/refactoring from GTE to GTL, I needed ComputePowers to be static. Modifying the GTE version for consistency. The GetKey function had static_cast<float> which needed to be static_cast<Real>.
2025-03-03 11:38:50 -08:00
David Eberly b6bd0c8118 Back-ported sampling of circular arcs represented by NURBS curves.
Back-ported file and sample application from GTL to GTE. This code is for
sampling NURBS curves that represent circular arcs.
2025-02-26 12:04:43 -08:00
David Eberly 7a4580b533 Added new code, fixed minor version in CMakeLists.txt files
Added a new class PolygonWindingOrder that determines whether a 2D polygon is counterclockwise or clockwise ordered in O(n) time. Added a new class for computing the convex hull of a simple polygon in O(n) time. Added a sample application as a unit test. I had forgotten to update the minor version to 3 (GTE is now 7.3) in the CMakeLists.txt.
2025-02-24 15:57:06 -08:00
David Eberly 1a185528a0 Update README.md
Added section about modifying the file version when you generate a pull request for a bug fix.
2025-02-20 15:49:15 -08:00
David Eberly 197988160a Update TriangulateCDT.h
Incremented the file version to 6.0.2025.02.20. I have added to ReadMe.md a section about modifying the file version on any pull request.
2025-02-20 15:48:34 -08:00
David Eberly 38dc892479 Merge pull request #101 from tomabailey/fix-dangling-reference-triangulate-cdt
Prevent undefined behavior resulting from dangling reference in TriangulateCDT
2025-02-20 14:38:24 -08:00
Tom Bailey 97f6dd12d7 FIX: Prevent undefined behavior resulting from dangling reference in TriangulateCDT.h 2025-02-20 20:25:58 +00:00
David Eberly 92fec14163 Modified copyright notice on all source files.
Modified the notice to include 2025.
2025-02-16 14:07:58 -08:00
David Eberly 89d3b2eb12 Fixed compiler complaints for non-MSVS compilers.
On Linux, gcc complained about unused DPerp in the function LineContainsVertex in DistLine2Triangle2.h.

On Linux, gcc complained about the declaration std::atomic in the function TestForSeparationMultithreaded in IntrCylinder3Cylinder3. The declaration must be a constructor call, but I had an implicit copy constructor call.

LLVM (clang-cl) complained about unused mNumLines in IntersectCylindersWindow3.{h,cpp}. The member has been removed.
2025-02-16 13:29:12 -08:00
David Eberly 3d6a2a9b02 Added specialized constuctors to Vector.
I added specialized constructions via a std::enable_if mechanism for dimensions 2, 3, and 4. This reduces constructor time for those dimensions
by half compared to the std::initializer_list constructor. The latter constructor is now specialized for dimensions larger than 4. In doing so, I also added a constructor that takes a single value and assigns it to all components. Implicitly, Vector<N,T> zero{(T)0} sets the vector to the zero vector. Fixed compile breaks for code that used the std::initializer_list constructor but did not provide a full list of components. (I noticed the performance problem when profiling find-intersection code with a large number of calls, causing member initialization of the Result struct to be a bottleneck.)
2025-02-13 10:14:41 -08:00
David Eberly 438a139a85 Update Delaunay3.h
The member mIRQueryPoint is a 3-tuple but only the first 2 components were set.
2025-02-13 10:10:30 -08:00
David Eberly c89c5abb1c Update NURBSCircle.h
The constant zero was not used.
2025-02-13 10:09:45 -08:00
David Eberly 245284b94b Removed unused variables.
Removed unused member variables mVNormal, mENormal, and mFNormal.
2025-02-13 10:09:19 -08:00
David Eberly 5e438ef543 Update NURBSCircle.h
Implemented an algorithm for representing an acute circular arc by a NURBS curve of degree 2.
2025-02-05 12:17:56 -08:00
David Eberly 883e53fdfc Update README.md
Separated out the GTL comments and moved to README.md for repository GeometricToolsLibrary.
2025-01-19 12:10:09 -08:00
David Eberly ffc88a862e Removing the 2-year-old GTL
Removing the old distribution to update with the current distribution.
2025-01-12 16:04:39 -08:00
David Eberly 44ade73ee9 Update README.md 2025-01-12 16:02:10 -08:00
deberly 4999b2eac4 Update DistLine2Triangle2.h
Not a good day for the home team. For some reason unknown to me, I had an include of distance query for line-segment. All that is needed is the primary template DCPQuery and definition of Line.
2024-12-29 17:04:11 -08:00
deberly cba04c154e Modified header file paths to follow GTE convention.
After unit testing, I forgot to use #include <Mathematics/*.h> convention.
2024-12-29 16:54:51 -08:00
deberly 90ab9b1a1d New files for distance between linear components and triangles in 2D.
New files for computing the distance between a line, ray, or segment and a
triangle in 2D. The triangle is considered to be solid (triangular boundary
plus interior).
2024-12-29 16:40:37 -08:00
deberly 09d2bdb61a Update DistCircle3Circle3.h
The inverse transform of the closest points had a bug. The point for circle1 was not inverted. I had also added code to order the circles internally so that query(circle0,circle1) and query(circle1,circle0) return the same value. I had fixed the
bug in GTL and added the swap in GTL but failed to backport the code to GTE. Thanks to zhou xun for reporting the errors.
2024-12-28 09:23:58 -08:00
deberly c0b9067add Revised Section 1.3 about matrix preprocessor symbols.
Revised Section 1.3 about matrix preprocessor symbols.
2024-12-26 22:14:11 -08:00
deberly c39b5027e6 Matrix preprocessor blocks of code reorganized.
The installation notes mentioned specifying project preprocessor symbols
GTE_ROW_MAJOR or GTE_COL_MAJOR and GTE_USE_MAT_VEC or GTE_USE_VEC_MAT. If a user forgets to define matrix storage order or matrix-vector multiplication convention, some GTE code can have incorrect behavior. This is a result of inconsistently choosing a preprocessor symbol to control the branching of conditionally compiled code. GTE by default uses row-major order and matrix-vector products using the vector-on-the-right convention. I modified the files so that branching is based only on GTE_COL_MAJOR and GTE_USE_VEC_MAT. If the matrix storage order and multiplication conventions are not defined using
the preprocessor symbols, the code will compile for row-major order and
vector-on-the-right convention.
2024-12-26 22:13:10 -08:00
deberly 9c775248e7 Update IntrCylinder3Cylinder3.h
Removed unnecessary includes of some header files. These supported the
previous version of the cylinder-cylinder test-intersection query.
2024-12-26 22:09:20 -08:00
deberly 782f3581ce Update IntrCylinder3Cylinder3.h
After revising the PDF, I noticed that the multithreading code process j = 0, which corresponds to phi = 0. This is the north pole N of the hemisphere, so numTheta separation tests occur for N. I modified jmin.first() to be 1, not 0. I also noticed the phi values were sampled on [0,pi]. For a hemisphere, they only need to be
sampled on [0,pi/2]. The revised PDF is now uploaded to the Geometric Tools
website documentation folder.
2024-12-24 12:10:53 -08:00
deberly 2ce0af797b Rewrite to fix bugs in the intersection of cylinders.
Equation (16) in IntersectionOfCylinders.pdf has term |Delta|, but it should be |Dot(D(x,y), Delta|$. The implementation used the incorrect term. I removed the complicated argument for selecting potential separating directions from the pole plane, replacing it with selecting potential separating directions directly from the hemisphere. The TIQuery constructor now requires specifying the number of theta and phi angles for spherical coordinates on the hemisphere. It also has an input for selecting the number of threads to use for the separation tests. If the input is 0 or 1, the selection is performed in the main thread of the application. If the input is positive, the application runs multithreaded. The threading is designed so that if a separation axis is found by one of the threads, all the threads terminate. Thanks to github's Gerhard Wesp for reporting the bug.
2024-12-23 17:14:38 -08:00
deberly ceb3047a48 Updated file version numbers.
I need to remember to tell folks issuing a pull request to ensure the file version is updated. The file version needs the date on which the pull request was made.
2024-12-07 12:25:30 -08:00
David Eberly bebb608bfc Merge pull request #97 from CodeReclaimers/master
Just some comment typos
2024-12-07 12:14:38 -08:00
CodeReclaimers aa15a5fa45 Merge branch 'davideberly:master' into master 2024-12-05 18:03:16 -05:00
CodeReclaimers 9b810c8e2e Typo fixes. 2024-12-05 18:01:38 -05:00
deberly 93e6e2a574 Update DistPoint3Parallelepiped3.h
The include path to the parallelepiped class used quotations. To be consistent,
the path was modified to use angle brackets.
2024-11-17 06:54:25 -08:00
deberly 3801456514 Posted Geometric Tools Engine 7.2.
Posted Geometric Tools Engine 7.2.
2024-11-14 22:03:33 -08:00
deberly ef58f86c08 Modification of ChangePlatformToolset.
Modified the ChangePlatformToolset tool to support selection of all compilers allowed by GTE on MIcrosoft WIndows: MSVS 2019/2022, ClangCL, Intel C++ Compiler 2024/2025.
2024-11-14 22:02:44 -08:00
deberly c5c96162e4 Update WGLExtensions.cpp
The Intel C++ Compiler 2025 complained about the static cast of the function pointer returned from wglGetProcAddress. I removed the static cast and used the already existing reinterpret_cast in GetOpenGLFunctionPointer from the return pointer to a void* followed by a reinterpret_cast} to the appropriate function pointer type. The compiler also warns that GetOpenGLFunctionPointer can be made
static, but that is incorrect. This function is implemented and exposed via extern in the WGL engine and in the GLX engine.
2024-11-14 10:26:34 -08:00
deberly 8be5c065a8 Update DX11.cpp
The Intel C++ Compiler 2024 complained about td::wstring_convert being deprecated. GTE supports C++ 14, where the function is still valid. Intel supports C++ 17 where it is deprecated. However, the Intel compiler ignores the setting in the GTE projects that specifies to use C++ 14. Moreover, Intel ignores the settings that disable specific warnings in the GTE code that are activated by pragma statements.
2024-11-13 21:46:17 -08:00
deberly d88c188e61 Update ApproximateBezierCurveByArcsWindow2.h
The Intel C++ Compiler 2024 complained about missing override modifiers.
2024-11-13 21:29:47 -08:00
deberly e9b442f3ee Update UIntegerFP32.h
The Microsoft Visual Studio 2022 (version 17.12.0) code analysis tool complained about not initializing mBit in the constructor initialization list. I had added a note to the file that initialization leads to a severe performance penalty (setting large numbers of array elements to 0). I added a pragma to disable the warning for the constructors.
2024-11-13 14:08:39 -08:00
deberly 8560f105a5 Update IntrCircle2Arc2.h
The Microsoft Visual Studio 2022 (version 17.11.5) code analysis tool complained that an index is out-of-range. It is not, so I added a pragma to disable the warning for that block of code.
2024-11-12 10:52:02 -08:00
deberly 7e9d63b223 Fixed a minor typographical error.
I had MS2019 as v143 when it should have been MS2022 as v143. Removing old installation file.
2024-11-11 14:55:48 -08:00
deberly b6b93089bf Update HelmertTransformation7.h
The relationship between B and T$ needed an adjustment to compensate for the translation of the point sets by the average of one of the point sets. A 3D visualization shows that the alignment of point sets is working correctly. The PDF at the website has been modified accordingly.
2024-11-11 14:55:01 -08:00
deberly 63072fe1e0 Added implementation of the Helmert transformation.
The algorithm determines the best-fit rotation, translation, and uniform scale to map one 3D point set to another 3D point set. The point-point correspondences are known.
2024-11-09 16:05:03 -08:00
deberly 41c7d01c4f Added hyperlinks to online documentation.
Added hyperlinks to the online PDFs describing the algorithms.
2024-11-04 14:15:13 -08:00
deberly 208f8d24f4 Added code for point-parallelepiped distance/closest-point queries.
Added a distance and closest-point query for a 3D point and a 3D parallelepiped.
A PDF was added to the documentation page at the Geometric Tools website
(DistancePointParallelepiped.pdf). The 2D code was refactored to expose a
function GetMinimizer that is used by both the point-parallelogram and
point-parallelepiped queries.
2024-11-02 12:06:43 -07:00
deberly f82cd7455d Update IntrCircle2Arc2.h
The line result.numIntersections = 0 was inside the last loop of the query but needed to be outside the loop. Thanks to github's owai for reporting this bug.
2024-10-25 09:05:59 -07:00
deberly 23ecfe3f3b Modifications for parallelogram2 and distance query.
GTE/Mathematics/DistPoint2Parallelogram2.h: The inclusion of the header file for Parallelogram2.h was exposed via quotes but needed to be <Mathematics/Parallelogram2.h>. I also added includes of C++ Standard Library headers whose symbols are accessed in the distance query header.

GTE/Mathematics/Parallelogram2.h: Modified the order of vertices returned by GetVertices so that the ordering is consistent with that of OrientedBox2.
2024-10-21 09:54:51 -07:00
deberly 86fd60d2ca New code for distance and closest-point query (2D point, parallelogram)
Added a distance and closest-point query for a 2D point and a 2D parallelogram.
A PDF was added to the documentation page at the Geometric Tools website
(DistancePointParallelogram.pdf).
2024-10-15 12:52:15 -07:00
deberly 7adae93f85 Added minimum spanning tree implementation.
Added an implementation for computing the minimum spanning tree of a vertex-edge graph. The implementation also computes the back edges for the graph relative to the minimum spanning tree.
2024-09-18 14:25:09 -07:00
deberly 7b84abe458 Added new samples to illustrate least-squares algorithms for ellipses and ellipsoids..
Added new samples for approximating 2D point sets by an ellipse and 3D point
sets by an ellipsoid. These were backported from GTL end-to-end testing.
2024-09-06 19:14:07 -07:00
deberly 3bb196fe4e Fixed typographical error in comments.
Fixed typographical errors that mentioned incorrect Boolean values for the inputs useEllipseForInitialGuess and useEllipsoidForInitialGuess to the operator() functions.
2024-09-06 10:17:23 -07:00
deberly 126c878b26 Another fix for GetExtreme in MinimumVolumeBox3.h.
One more time. The GetExtreme function still failed. The essence of the function is a hill-climbing algorithm using a queue. My poorly written queue-like code, and in particular the visited[] management, was still not correct. Thanks to github's AnsonInTheAstroworld for reporting the bug once again, and for providing a dataset for which the implementation failed. Although a modification was suggested using queues (with storage std::vector), I used the simplest algorithm, which is to iterate over all the vertices and compute the maximum height. I used Intel oneAPI VTune for profiling. It turns out that the bottleneck in computing are the memset calls in the constructors for mBits of UIntegerFP32<2561>}.
MinimumVolumeBox3 has a significantly large number of constructor calls; the initialization was approximately 80% of CPU time (the latter number on the order of  1 minute). I removed the initializations. On my Intel i9-10900 CPU which has 20 logical processors, the profiling showed that with a
single-threaded execution (in the main thread), the queue-based approach used 4638 milliseconds for the provided dataset. My simple algorithm used 3121 milliseconds. Using 8 threads, the queue-based implementation used 1028 milliseconds and my simple algorithm used 722 milliseconds. The numbers are
sufficiently small enough that the simple algorithm should suffice.
2024-09-05 15:55:45 -07:00
deberly 4f8493da60 Update MinimumVolumeBox3.h
The GetExtreme function still did not work correctly after the July 24, 2024 modification. The initial value of dMax for vertex mVertices[0] is computed before the loop over the vertices to find potentially larger dMax values. An example showed that the initial dMax is 0. The adjacent vertices to mVertices[0] all have zero-valued d-values. The adjacent vertices to mVertices[1] all have zero-valued d-values, and one of those vertices is mVertices[0]. This causes vMax to be assigned to 0 again, which invalidates the search for maximum dMax. I added another line before the loop that marks mVertices[0] as visited. Thanks to github's AnsonInTheAstroworld for reporting the bug and providing an example that caused failure.
2024-08-31 11:47:21 -07:00
deberly 036c5c895f Accidentally deleted cmake files.
These are required by the cmake build.
2024-08-26 14:28:37 -07:00
deberly 26e289493e New/modified code for line-circle, ray-circle, and segment-circle distance queries in 3D
Major rewrite of the DistanceCircle3.pdf file. Modified DistLine3Circle3.h accordingly. Added implementations of ray-circle distance queries (DistRay3Circle3.h) and segment-circle distance queries (DistSegment3Circle3.h).
2024-08-26 13:34:08 -07:00
deberly 7c6ac4017e Update PrecisionCalculator.cpp
Added some new word-counting function calls.
2024-08-26 13:32:36 -07:00
deberly 0a9bcb68cb Update SeparatePoints2.h
Somehow this file slipped through the instantiation tests. The calls to ConvexHull2 still had the last parameter (an epsilon value for fuzzy arithmetic), but that should have been removed with the August 3, 2024 entry.
2024-08-26 13:32:12 -07:00
deberly 4d081485ff Fixed compile break for incorrect use of auto.
The use of auto in IntpQuadraticNonuniform2 to obtain maximum loop counters and then also to initialize loop counters worked with the Microsoft compiler but not g++ on Linux. Removed unused variables and types in the sample application.
2024-08-26 13:31:36 -07:00
deberly 7ab077a959 Incremented minor version.
I forgot to increment the minor version from 0 to 1 in the CMakeLists.txt files.
2024-08-26 13:30:00 -07:00
deberly 2cc6ea322f Update to convex hull 2D and dependent code.
Removed the obsolete mEpsilon member, which changes the signature to the operator() functions. Added an operator() function whose input is a std::vector<Vector2<T>>. Back-ported (most of) the GTL ConvexHull2 code to GTE. Fixed compiler breaks that resulted from the signature change. As is the case with other reworked GTE files, I replaced the template parameter Real with T as a signal that I have revisited the code (usually for GTL and back-porting to GTE).
2024-08-02 15:23:07 -07:00
deberly 262eb19adc Update ConvexHull2.h
The convex hull is computed using rational arithmetic. The class IntrinsicsVector2 is first used to determine the intrinsic dimension of the input points, but these computations use floating-point arithmetic. The direction between the extreme points is obtained as a normalized difference of points. The floating-point rounding errors can lead to the incorrect conclusion that the hull is 2-dimensional, but the hull (using rational arithmetic) is actually 1-dimensional. The dataset that exposed the bug was passed to the minimum-area box code, and the misclassification of the
intrinsic dimension leads to a crash caused by an out-of-range index into a std::vector. The dataset has more than 3 double-precision points that happened to be exactly on a line; rational arithmetic verified this. If exactly 3 double-precision and colinear points are passed to the hull finder, there is no crash. I removed the IntrinsicsVector2 code and set mDimension based on the rational computation of the hull. As it turns out, I had already done the same in the GTL code but for some reason did not back-port that code to GTE. Thanks to Richard Bouwman for reporting the bug.
2024-08-02 08:22:20 -07:00
deberly 610dd49c14 Removed files not supposed to be in the Mathematics folder.
I found these Visual Code files that must have been in the Mathematics folder for a very long time (file dates were from 2020).
2024-08-02 08:20:04 -07:00
deberly 435934dd27 Update ImageUtility2.h
When drawing a 2D disk using ImageUtility2::DrawCircle with a Boolean solid of true, for each x-value the callbacks are executed for a range of y-values. For a callback as simple as drawing only the pixel, this leads to many cache misses because of the row-major ordering for the image. The code has been modified to select y-values and execute the callbacks for a range of x-values.
2024-07-27 10:58:16 -07:00
deberly 78aa0ca1cd Update MinimumVolumeBox3.h
The GetExtreme function was incorrect when all the adjacent vertices of the initial vertex have the same projection in the specified direction. Geometrically, the convex hull has a collection of coplanar triangles sharing the initial vertex. GetExtreme bails after examining the adjacent vertices and incorrectly concludes that the initial vertex is the extreme. The comparison (dCandidate > dMax) must instead be (dCandidate >= dMax) to allow the hill climbing to continue away from the flat region of the initial vertex. And it is now necessary to use visited flags to ensure the hill climbing does not oscillate between two vertices of the same projection value. The visited flag array must be local to GetExtreme because in the multithreaded case, a class member array is no longer protected from concurrent access. Thanks to github's AnsonInTheAstroworld for reporting the bug.
2024-07-24 17:21:34 -07:00
deberly 46271f93cc Fixed subtle bug in BSNumber debugging code.
Unit testing of TriangulateCDT in the GTL development track exposed a subtle bug in BSNumber when GTE_BINARY_SCIENTIFIC_SHOW_DOUBLE is defined. The functions BSNumber::SetSign, BSNumber::SetBiasedExponent, and BSNumber::SetExponent each recompute mValue. The problem is that if the source object represents 0 and SetSign is called with a nonzero value, the target object is not yet a valid BSNumber because SetBiasedExponent and bit copies have not yet occurred. This leads to failure in the mValue recomputing of SetSign. The GTE version of TriangulateCDT does not fail because 0 is never the source of the
incremental construction, whereas the GTL version has a case where the source is 0. GTE has several blocks of code that incrementally create a BSNumber object using SetSign, SetBiasedExponent, and a copy of the integer bits from the source object. I added updates of mValue after those blocks.
2024-07-17 19:04:27 -07:00
deberly f2d66cef2c Update IntpAkimaUniform3.h
Fixed bugs in the interpolator. The original Akima code was in Wild Magic 5, and it was ported correctly to GTE 1.0. The incorrectly repeated FX calls were introduced in GTE 2.2 (2/2/2016). The lack of parentheses for (bound-1) expressions was introduced in GTE 5.14 (11/11/2021). The Akima uniform 3D interpolator had been unit tested in Wild Magic, but I dropped the ball on testing it during the evolution of the GTE code. Thanks to Russel Wenzel for reporting the errors.
2024-07-15 11:30:43 -07:00
deberly ef50e8c7c6 Modifications for the last pull request.
The merge of a pull request added a second pragma-once statement to ContTetrahedron3.h, which I removed. The pull request also fixed typographical errors in the comments, and a Python script was added to removed files from the GTE directory tree. The TrackObject class was given setters for x-size and y-size that are used if the application window is resized. I updated the file version numbers for these modifications.
2024-07-14 20:58:55 -07:00
deberly feffd6a7f8 Update ContTetrahedron3.h 2024-07-14 20:33:54 -07:00
David Eberly 7843f574b5 Merge pull request #91 from CodeReclaimers/master
Nitpicks and a cleanup script
2024-07-14 22:30:00 -05:00
CodeReclaimers bbdc1085a0 Merge branch 'master' of https://github.com/CodeReclaimers/GeometricTools 2024-07-14 11:50:48 -04:00
CodeReclaimers 70e1897060 Fix comment typo. 2024-07-14 11:50:15 -04:00
CodeReclaimers 0907882283 Added setters for x/y size of TrackObject, and call them in Window3::OnResize. 2024-07-14 11:49:57 -04:00
CodeReclaimers 7e0505259f Merge branch 'davideberly:master' into master 2024-07-14 11:47:45 -04:00
deberly e61c95fce0 Removed SetParallaxProjection.
Removed SetParallaxProjection based on the revised document
PerspectiveMappings.pdf. Such a perspective projection matrix cannot be constructed when the view frustum viewport is a non-parallelogram convex quadrilateral.
2024-06-24 18:07:34 -07:00
deberly c75665b6e1 Update LieGroupsAlgebras.h
Added a new PDF (LieGroupsAlgebras.pdf) that describe the mathematics and implementation of LieGroupsAlgebras.h. The minimax approximations had to be adjusted for the cases when |theta| > pi. Also, the adjoint representations were those of Ethan Eade's document (mentioned in the bibliography of the PDF), but they were based on his choice for the order of the generators. My implementation uses a different order, which leads to adjoint representations that are permutations of his.
2024-05-21 11:19:33 -07:00
CodeReclaimers 91be44768d Merge branch 'davideberly:master' into master 2024-05-04 22:07:59 -04:00
deberly 921fa8c361 New file for Lie groups and Lie algebras. Added minimax approximation for (x-sin(x))/x^3.
Added a new file for computing using Lie groups and Lie algebras. For now, the supported groups are SO(2), SE(2), SO(3), and SE(3). Minimax approximations are used for rotation-related functions to avoid the removable singularities at angle zero.
2024-04-27 15:17:09 -07:00
deberly a7e69d623c Update NearestNeighborQuery.h
Modified the FindNeighbors member function to use a priority queue to improve the speed of queries. Thanks to CodeReclaimers for providing the speed-up.
2024-03-25 12:36:53 -07:00
deberly e9619bfd91 Bug fix to Interpolation2D sample application.
The classes IntpQuadraticNonuniform2 for GTE and GTL pass the same unit tests, and those results were verified by Mathematica for the GTL class. The rendering in the interpolation sample application clearly showed the derivatives did not match at the boundaries of the center triangle of the 4 triangles. It turns out that the sample code itself had a bug. The SampleMesh class initializes mAdjacencies to have the triangle indices for neighbors. For the triangle V1,V4,V3, the adjacencies were assigned as 0, 1, 2. The assignment needed to be 1, 2, 0. After this modification, the rendered surface is visually smooth. The window client size was 512x512, but I made it larger for a better view of the renderings. It is now 768x768.
2024-03-24 11:39:04 -07:00
deberly 0c3df4bcd9 Fixed template instantiation problems.
My template instantiation system needed serious modification for when I deprecated a class and provided a new implementation. The system failed to instantiate the new implementations. I discovered this when attempting to backport the IntpQuadraticNonuniform2 class (the Cendes-Wong algorithm) from GTL to GTE. The GTL code has been thoroughly unit tested and verified with Mathematica. There are no sample applications that exercise those new implementations, which was clear when the code would not compile---a serious oversight on my part. I have made changes to various classes to get the template instantiation to compile the new code. I will post the backported GTL code for IntpQuadraticNonuniform2 after I unit test the derived classes IntpSphere2 and IntpVectorField2.
2024-03-23 14:39:01 -07:00
deberly beebbe66f7 Updated the Hermite interpolation code.
Ported the Hermite interpolations from GTE to GTL. Verified the systems of equations and solutions that produce the coefficients of the polynomials, both using code that generates code for the system and by using Mathematica to solve symbolically the numerous cases. Unit tests for the GTL code are more rigorous than those for GTE, so the GTL code and unit tests were back-ported to GTE. The SmoothLatticeInterpolation.pdf document has been updated significantly to describe the coefficient construction.
2024-03-13 21:15:56 -07:00
CodeReclaimers 2b60cb1e52 Typos and missing pragma. 2024-03-07 20:18:21 -05:00
CodeReclaimers 3e9f39ae15 Merge branch 'davideberly:master' into master 2024-03-07 19:39:49 -05:00
deberly a3ae9d1278 Create ApprParabola2.h
Added a new file for fitting a parabola to points (x,f(x)). The document
https://www.geometrictools.com/Documentation/LeastSquaresFitting.pdf has been
updated with a section describing the algorithm.
2024-02-25 15:19:42 -08:00
deberly 2f846a2b72 Update InscribedFixedAspectRectInQuad.h
Fixed minor issues after porting the code and unit tests to GTL: Removed test code. The isUnique variable was set to false when the intersection of intervals is a nondegenerate interval. Instead, isUnique must be set to true when the w-values are the same at the interval endpoints, false otherwise.
2024-02-25 07:54:21 -08:00
deberly 1cdbbd1adb Create InscribedFixedAspectRectInQuad.h
Implemented the maximum-area, fixed-aspect-ratio, axis-aligned rectangle inscribed in a convex quadrilateral. See the document https://www.geometrictools.com/Documentation/MaximumAreaAspectRectangle.pdf
2024-02-24 15:58:38 -08:00
deberly c8b754eb5f Update README.md
NVIDIA driver version 551.52 released 13 February 2024 no longer has the Poco::NotFoundException exceptions.
2024-02-21 09:32:13 -08:00
deberly 711856fca4 Update ExtractRidgesConsole.cpp
Modified the code based on Lev A. Melnikovsky's mathematical formulation to avoid computing eigenvectors until needed and to avoid numerical discontinuities when computing eigenvectors.
2024-02-19 13:15:32 -08:00
deberly 420eca3dfc Added new files to the MSVS 2019 project and filter files.
I had added the new files BVTree.h, BVTreeOfTriangles.h, and AABBBVTreeOfTriangles.h to the MSVS 2022 project and filter files. The MSVS 2019 project and filter files needed the new files added to them.
2024-02-01 10:57:12 -08:00
deberly 1984a68f49 Update Matrix.h
The GTE LInfinityNorm function was missing a std::fabs applied to M[0]. The GTL version of this function is correct.
2024-01-31 07:26:15 -08:00
deberly 9a74426641 Update HermiteTriquintic.h
The function operator() was missing the test for zOrder being 5 or smaller. The inner-most loop had k bounded by 4 when it should have been 6.
2024-01-29 14:39:38 -08:00
deberly 3cc85e8165 New files for general bounding volume trees.
Added abstract classes and derived class for constructing a bounding volume tree for geometric primitives. These will eventually replace the current OBB tree classes. The class ABBBVTreeOfTriangles was needed for a contracting project.
2024-01-20 15:32:49 -08:00
deberly 78f8fa1417 Update ExtractRidgesConsole.cpp
The finite-difference approximation to the second-order derivative f_yy had a typographical error. Also, to avoid sign changes artificially generated because the numerical eigensolver can be inconsistent in returning eigenvectors: At one point an eigenvector U is returned but at a nearby point an eigenvector is return that is approximately -U. Thanks to Lev A. Melnikovsky for reporting the problems and fixing them.

My changes include updating the file version in the header comments and modifying the new code to use my coding standards.
2024-01-18 09:54:59 -08:00
David Eberly ff0881e76f Merge pull request #83 from melnikovsky/evec-jumps-fix
Fix for the Hessian eigenvectors sign jumps
2024-01-18 09:22:36 -08:00
David Eberly e59bba7400 Merge pull request #82 from melnikovsky/development
Fix a typo in Hessian calculation for the ridge detection
2024-01-18 09:22:07 -08:00
deberly 07f60e3038 Update README.md
I incorrectly tested using NVIDIA GeForce driver 546.65. In fact the Poco::NoFoundException-s still occur and propagate the exceptions to the application code, in my case D3D11CreateDevice.
2024-01-18 09:09:59 -08:00
Lev A. Melnikovsky 3be39e5cd1 Track the eigenvector sign-jumps 2024-01-18 15:19:04 +02:00
Lev A. Melnikovsky e20b6249ed Fix typo in dyy calculation 2024-01-18 14:48:50 +02:00
deberly f8a6a16f59 Update README.md
NVIDIA driver 546.65 fixes the Poco::NotFoundException.  The exceptions still appear in the Visual Studio output window, but they are not propagated to the application code.
2024-01-17 16:36:57 -08:00
deberly 52d8143800 Update Gte7p0InstallationRelease.pdf
Added comment that openSUSE Leap 15.5 is now supported.
2024-01-08 21:55:22 -08:00
deberly 16c19fd4a3 Update README.md
Added formal support and testing for openSUSE Leap.
2024-01-08 16:16:56 -08:00
deberly ca3a7643f3 Update README.md
Fixed an incorrect link.
2024-01-07 17:28:21 -08:00
deberly dfa40e02fa Posting GTE 7.0.
The README.md has a link to the full update history which contains the changes made to post version 7.0. I have modified the copyright notices for all the source files, but the file version numbers remain the same.

The Ubuntu and Fedora tools were updated to latest (gcc/g++, CMake, Visual Studio Code) and the sample applications were all compiled and executed to ensure they work.
2024-01-07 17:16:52 -08:00
deberly d6189e654d Updates for latest changes.
Added entries for January 6, 2024.
2024-01-06 09:56:52 -08:00
deberly 4a4f809db7 Update RoughPlaneParticle1Window2.cpp
The application class member mContinueSolving was uninitialized. The debug build worked for me but not the release build. Added class member initialization to the application constructor. When SINGLE_STEP is enabled, the code does not compile because of a porting error. It had a Wild Magic Vector2d exposed but needed to be a GTE Vector2<double>.
2024-01-06 09:56:31 -08:00
deberly 4e22a75784 Minor fix, added preprocessor symbol.
The preprocessor symbol declaration SINGLE_STEP was missing from the files. By enabling this, you can single step through the simulation by pressing the 'g' key.
2024-01-06 09:55:18 -08:00
deberly a50a997743 Modifications based on MSVS 2022 code analysis.
Modifications based on Microsoft Visual Studio 2022 code analysis warnings about not initializing native class members in the constructor initializer list. (The code analyzer needs improvement, checking whether those members are set appropriately in the body of the constructor.)
2024-01-05 13:48:13 -08:00
deberly 89ca1fd966 Updated history files
For the modification to the sample IntersectLineRectangle.
2024-01-04 14:25:41 -08:00
deberly cb358128bb Update IntersectLineRectangleWindow3.cpp
On Fedora 38, gcc 13.12.1 warned about unused 'stophere' which I had added for debugging. I had added '(void)stophere' after assignment to avoid the warning on Visual Studio and earlier versions of gcc. I replaced this variable by a LogAssert.
2024-01-04 14:23:27 -08:00
deberly 912f6ccdba Latest updates.
For ApprParaboloid3.h and MinimalCycleBasis.h.
2024-01-03 20:43:49 -08:00
deberly 524eeb6860 Another revision of MinimalCycleBasis.h.
The new implementation had multiple problems. The code was complicated enough that more care was needed to get it right. My previous attempts were a poorly handed response to a request for a new feature. I stepped through the code for the latest version using a debugger, specifically for SimpleGraph0.txt of the sample application. The code coverage hits all the relevant blocks. The unit tests for the simpler configurations pass.
2024-01-03 20:43:24 -08:00
deberly 16649b7c49 Update ApprParaboloid3.h
Running my instantiation tool on Linux distributions, there were warnings about signed/unsigned comparisons.
2024-01-03 20:42:19 -08:00
deberly 6d3d0f9b27 Latest updates.
Added update about paraboloid fitting.
2024-01-01 14:42:39 -08:00
deberly 981e854291 Update ApprParaboloid3.h
Restored the old paraboloid fitting algorithm so that you can choose between
that one and the new robust one. I removed the mathematical comments and
provided a web link to the least-squares fitting PDF at the Geometric Tools
website. The PDF has been modified to describe both algorithms.
2024-01-01 14:42:19 -08:00
deberly 2abe1b63d6 Updates to history.
Changes to ApprParaboloid3.h for robustness.
2023-12-30 15:58:45 -08:00
deberly 193cad2b1e Update ApprParaboloid3.h
Subtracting out the mean from the inputs for a robust floating-point algorithm.
2023-12-30 15:58:15 -08:00
deberly 37840876b4 Updated history files.
Updated for the TriangulateEC and MinimalCycleBasis changes.
2023-12-30 14:06:48 -08:00
deberly dea568e43e Update MinimalCycleBasis.h
Revised the implementation of MinimalCycleBasis. The code now computes isolated vertices, filaments, and basis cycles. It also uses exact arithmetic internally to guarantee correctness of the computations. I added more unit tests for the revision than for the previous code version.
2023-12-30 14:06:21 -08:00
deberly 6549ab7c4b Update TriangulateEC.h
Fixed bugs that were discovered when triangulating a polygon tree. The Vertex objects of the VertexList had state information from the previous triangulation that affected DoEarClipping. The state is now reset to the constructor values in the Vertex constructor. The polygon-tree triangulation also was not accumulating the triangles for the multiple DoEarClipping calls.
2023-12-30 14:05:55 -08:00
deberly 1637874a5f Updated history files.
Updated history files with the recent change to MinimalCycleBasis.h.
2023-12-26 15:55:48 -08:00
David Eberly 46a7bdd346 Update MinimalCycleBasis.h
The test in Extract for adding a tree to the forest needed another Boolean condition.
2023-12-24 11:36:51 -06:00
deberly cbf2cea526 Added ability to extract filaments.
The comments indicated that the filaments are extracted by the code. They are removed from the graph but not made available to the user. I added the ability to extract the filaments in case the caller wants them. The file is relatively old, so I took the opportunity to upgrade it to my current design goals. The constructor is a simple one, no longer mimicking a function object. The Extract function does the cycle and filament extraction. I also added a new template parameter which is the type of the vertex indices. The type was int32_t but now can be any signed or unsigned integer type of size at least 2 bytes. Thanks to Scott Johnson for (once again) reporting problems such as these.
2023-12-22 14:22:40 -08:00
deberly b8ba2c707f Update of triangulation by ear clipping.
This is a major rewrite of the previous version. The code is easier to read. I addressed a several technical support items. The duplicate-vertex map has been removed. The PDF
https://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf
 is a major rewrite and explains why the algorithm is self-sorting regarding bridges that share the same outer-polygon vertex. Various unit tests appear to show that the algorithm is performing correctly.
2023-12-16 15:11:59 -08:00
deberly 1cbdf6db34 Update README.md
The NVIDIA Poco exceptions still occur as of driver 546.33 release 12 December 2023.
2023-12-12 22:00:23 -08:00
deberly 2f961d07bc Fixed a bug in the nonmanifold test in the Insert function.
The nonmanifold test for a shared edge having opposite orderings for the two triangles sharing the edge was flawed. The 'edge' object comes from an EdgeKey<false> object so that the edge is <v0, v1> with v0 < v1. The actual ordering depends on the specified triangle vertex order. Instead, the comparison has to be made for the shared edge of the already existing triangle edge->T[0] because the vertices for that triangle are ordered.
2023-12-04 16:45:04 -08:00
deber f4ed00e608 Update DistPlane3CanonicalBox3.h
In operator(), the array 'reflect' is declared to have 3 Boolean elements but only the first 2 are explicitly initialized. According to the C++ standard, the unspecified element is zero-initialized, set to false in this case. I added the third initializer to make it clear that is what was intended.
2023-12-03 13:18:35 -08:00
deber d37a60e7b8 Added new intersection query files and sample.
Added test/find intersection queries for rectangle and line/ray/segment. Added a new sample to illustrate.
2023-12-02 16:14:12 -08:00
deber 900b183a51 Updated CMakeLists.txt
The minor version should have been updated to 8 (version 6.8).
2023-12-02 16:13:18 -08:00
deber becac8ba27 Update README.md
NVIDIA driver 546.17, release on 14 November 2023, still throws the Poco exceptions.
2023-11-28 11:23:55 -08:00
deber 1bbb269936 Update history for latest changes.
Update history for latest changes.
2023-11-27 16:14:32 -08:00
deber 97d96913a3 Update DistCircle3Circle3.h
Reimplemented the query for distance between two circles in 3D. The previous version used only floating-point arithmetic. The rounding errors when computing derivatives of the degree-8 polynomial were causing extreme inaccuracy in the results. The new code now uses a mixture of floating-point arithmetic and rational arithmetic. The degree-8 polynomial and its derivatives are created using rational arithmetic. Bisection is performed using floating-point arithmetic, but with some initial rational arithmetic to determine sign changes in a polynomial at the endpoints of a potential root-bounding interval.
2023-11-27 16:14:08 -08:00
deber 930310cb3f Update RootsGeneralPolynomial.h
Added multithreading to the general-degree polynomial root estimator to improve the performance.
2023-11-27 16:13:36 -08:00
deber be50bb8fe8 Reordering of inputs to FastComputeOrthogonalComplement.
Based on reader feedback for FastOrthogonalComplement.pdf, I reordered the vectors in the signatures of the functions listed in the pseudocode and in the actual code in Vector3.h. This is the usual convention I have for writing code (inputs first, outputs last). I also modified the actual code function name to FastComputeOrthogonalComplement.
2023-11-26 07:29:48 -08:00
deber f2ca41fecf Update of new Vector3 ComputeOrthogonalComplement.
After thinking harder about the new Vector3 function ComputeOrthogonalComplement, I was able to avoid the square root operation. Given a unit-length vector, you can compute the orthogonal complement with only arithmetic operations. A new PDF has been posted to the website: FastOrthogonalComplement.pdf.
2023-11-21 14:04:00 -08:00
deber 007a174468 Updated the GTE6 history files.
Updated the history files.
2023-11-20 21:25:57 -08:00
deber 1d681d4a7e Removed unused variables from intersection code.
LLVM - clang-cl warning. The \Code{operator()} function declared and initialized numZero. Even though it is incremented in the code, the value is not used anywhere
else and is flagged as such. They have been removed.
2023-11-20 21:25:33 -08:00
deber 6909eb52ed Update TriangulateCDT.h
LLVM - clang-cl warning. Function ConstrainedTriangulate had a declaration of counter that was used for debugging. Even though it is incremented in the code, the value is not used anywhere else and is flagged as such. It has been removed.
2023-11-20 21:24:39 -08:00
deber 909a70e852 Update DistLine3Circle3.h
LLVM - clang-cl warning. Two declarations of Vector3<T> delta occurred in the code, but the variables are unused. They have been removed.
2023-11-20 21:23:39 -08:00
deber f2820f495e Update IEEEBinary16.h
LLVM - clang-cl error. An include of Functions.h is required; otherwise, the block of functions starting with atandivpi become infinitely recursive. The definition of atandivpi whose input is IEEEBinary16 makes a call to atandivpi whose argument is typecast to float. This works as long as the definition of atandivpi in Functions.h is accessible. Without it, an implicit IEEEBinary16 constructor call is made from the float input, thus the infinite recursion. The constructor with input of type double has variable temp that is tagged as not initialized. It is on the next line, but I moved that code into the union initialization.
2023-11-20 21:23:03 -08:00
deber c3ce7f7727 Interpolators missing include file.
Fedora gcc complained about undefined int32_t (but Ubuntu gcc did not). Added an include of cstdint.h.
2023-11-20 21:20:25 -08:00
deber 68f97a09bf Update SurfaceExtractorMC.h
The GetGradient function had a typecast of a float to a size_t and then assigned it to an int32_t. The typecast was changed to an int32_t. Fixed Ubuntu gcc compiler warnings/errors: missing typename when the member topology, 3 loop variables were size_t but needed to be IndexType.
2023-11-20 21:19:42 -08:00
deber c41a917656 Update ETManifoldMesh.h
Added an exception to the Insert function that detects whether the vertex ordering for two edges is opposite for the two triangles sharing the edge. If the ordering is not opposite, the mesh is not manifold. The test is exposed by default (mThrowOnNonmanifoldInsertion is initially true), but you can disable the test by setting the aforementioned Boolean to false.
2023-11-20 21:18:20 -08:00
deber f98b00dc6d Update Polynomial1.h
Added a member accessor to get a const reference to the polynomial coefficients.
2023-11-20 21:17:21 -08:00
deber af2e3f9519 Update Quaternion.h
The Rotate function for a 4-tuple vector did not compile because it uses a Vector3-based cross product function. The Vector3 quantities were replaced by  Vector4 quantities, but the header file Vector3.h still needs to be included to access the cross product of two 4-tuple vectors.
2023-11-20 21:17:08 -08:00
deber 95680f53e6 Update Vector3.h
Added a new function ComputeOrthogonalComplement with a signature different from the other same-named function. The new function computes the basis by computing a unit-length quaternion for a rotation matrix whose last column is a user-specified unit-length vector. The other two columns are extracted from the rotation matrix.
2023-11-20 21:16:00 -08:00
deber 769d7d0af6 Replacement for RootsPolynomial::Find.
The replacement for RootsPolynomial<T>::Find is RootsGeneralPolynomial<T>::Solve. The algorithm is effectively the same as the deprecated Find, but it uses a mixture of floating-point arithmetic and rational arithmetic. The coefficients of the polynomial derivatives are computed using rational arithmetic to avoid the rounding errors that plagued the deprecated code. When the bisection code consumes these polynomials, rational evaluation is used to determine sign information at the endpoints of an interval. If bisection must occur, the rational coefficients are converted to floating-point, and the resulting rounding errors are significantly smaller than that of the deprecated code. The floating-point-based bisection is fast, so the performance is reasonable in order to get increased accuracy of the root estimates.
2023-11-20 21:15:25 -08:00
deber a786472f2d Deprecated RootsPolynomial.
The RootsPolynomial<T>::Find function suffered from significant floating-point rounding errors in the computation of the coefficients of the polynomial derivatives. The class allows for type T to be rational, but the bisection effectively does not converge because the number of bits per rational number is excessively large. This class is now deprecated. The low-degree root finders are now in RootsLinear.h, RootsQuadratic.h, RootsCubic.h, and RootsQuartic.h. Three of these files are listed here because a comment mentioned using Cauchy's bound when in fact the code
uses Lagrange's bound.
2023-11-20 21:13:44 -08:00
deber 5f623cd123 Update README.md
I had previously reported that the Poco exceptions did not occur with the NVIDIA Studio drivers. In fact they do as of driver version 546.01.
2023-11-03 15:53:14 -07:00
deber 81452c644f Update README.md
The POCO exceptions still occur in NVIDIA driver version 546.01.
2023-11-02 07:28:47 -07:00
deber 8c6e1890d8 Modified STLBinaryFile.h.
Added code to save a binary STL file.
2023-10-21 17:05:52 -07:00
deber a000073fcf Added STLBinaryFile.h
A file reader for binary STL files.
2023-10-20 15:47:22 -07:00
deber b536815be3 Reimplementation of Quaternion<T>::Rotate functions.
Reimplemented the Quaternion<T>::Rotate functions to use fewer arithmetic operations. Thanks to Robert Eisele for sending me a link to his webpage about the algorithm; the link is provided in the header file.
2023-10-11 22:44:36 -07:00
deber 03bded3d5e Added preprocessor define to PolygonBooleanOperations.
Toggling between 'double' and 'BSRational<UIntegerAP32>' required commenting and uncommenting some code. I added a preprocessor define so that you can toggle by exposing or hiding this define.
2023-09-29 20:48:44 -07:00
deber bd5db637c5 Modified PolygonBooleanOperations to allow rational arithmetic.
Modified the sample application to use exact rational arithmetic if so desired. BSPPolygon2<T> already compiles when T is BSRational<UIntegerAP32>.
2023-09-28 13:34:04 -07:00
deber 26d78d6c2f Fixed a bug in IntrLine2Circle2.h, removed comment in Arc2.h
Fixed a problem with segment-arc and ray-arc find-intersection queries that were caused by the line-circle find-intersection query setting only one of the result.parameter values when the line and circle are tangent. It is necessary to set both parameter values to the same number, effectively a degenerate interval that is used in interval-interval find-intersection queries used in segment-arc and ray-arc. Thanks to owai on github for reporting the problem, diagnosing it, and fixing it.

Removed the deprecation comment about the Arc2 Contains function without the epsilon argument. This function is still useful when you know the point is on the arc so that you do not need the epsilon value.
2023-09-28 09:13:48 -07:00
deber f361ecb3f2 Fixed a bug in Hyperplane.h less-than comparison operator.
The operator< comparison had an incorrect comparison in it, using 'origin' instead of the correct 'normal'.
2023-09-25 08:54:34 -07:00
deber 33b831eb0e More modifications to surface extraction.
Yet more modifications to surface extraction. The index type for the indices array were hard-coded as int32_t. Some applications have different types for the indices. The MarchingCubes and SurfaceExtractionMC classes now have template parameters IndexType to allow the user to choose whatever type is natural to the application. I back-ported changes made to the GTL version of MarchingCubes; for example, "int32_t index[8]" is now "std::array<IndexType, 8> index".
2023-09-24 14:12:23 -07:00
deber d4f6c04639 Additional modifications to SurfaceExtractorMC.h.
In SurfaceExtractorMC.h, the test code used only a positive perturbation and the output is correct. When the perturbation is negative, the order of sign testing needed to be modified to ensure the output is correct. The BouncingBall physics sample uses
SurfaceExtractorMC.h, so it needed a modification to add the perturbation parameter.
2023-09-23 21:01:01 -07:00
deber 3d97d20043 Fixed problems in SurfaceExtractorMC.h
When the single-voxel Extract returns false, the full-image extraction was supposed to ignore the voxel. Instead it deleted the entire mesh, which is a disastrous bug. The unit tests verified only that the Marching Cubes 256 triangle-lookup table entries are correct, and none of these provided code coverage that would have found the bug. Also, floating-point rounding errors in mesh vertex construction led to small sets of vertices, each set containing vertices that are nearly the same but should have been the same without the rounding errors. MakeUnique is unable to identify these as duplicates. I modified the single-voxel Extract function to generate the same vertex on an edge shared by multiple voxels, using a consistent ordering of the voxel corners to ensure that the all constructions of the vertex have the same rounding errors. Finally, the interfaces were modified to have a new parameter 'perturb'
that allows you to avoid the ignoring of voxels for which at least one corner of the voxel is exactly the input 'level' value. Thanks to Scott Johnson for reporting these problems.
2023-09-23 14:09:14 -07:00
deber 2dfbd18579 NVIDIA GeForce driver 537.42 still throws Poco exceptions.
I wish I could understand why something that seems easy to fix still remains unfixed.
2023-09-22 10:15:50 -07:00
deber 0a9cebd065 Update ETManifoldMesh.h
If the mesh is not orientable, GetBoundaryPolygons had an infinite loop when trying to traverse a triangle strip the connects two consecutive boundary edges. When not orientable, two adjacent triangles are repeatedly visited. I added a trap for this and throw an exception.
2023-09-17 16:35:58 -07:00
deber b284bd8c0b Update Multiarray.h
The operator< function had both lattice tests using operator<. The unit tests did not trap this because they involved pairs of Multiarray objects of the same lattice sizes.
2023-09-17 10:40:23 -07:00
deber 66137d3cf6 NVIDIA GeForce driver 537.34 still throws Poco exception
I wish I could understand why something that seems easy to fix still remains unfixed.
2023-09-17 09:47:40 -07:00
deber 3f53eb0636 Added 2D circle-circle distance query. Updated linearComponent-arc headers.
Added new file for distance queries between 2 circles in 2D. Added includes of C++ Standard Library headers to the linearComponent-arc2 headers to ensure they are always exposed to the file.
2023-09-10 18:26:41 -07:00
CodeReclaimers bcf60b6a01 Merge branch 'davideberly:master' into master 2023-08-31 06:26:18 -04:00
David Eberly dbf5bd6c48 Finished some 2D distance queries.
Revised comments. Fixed bugs that were exposed when unit testing ray-arc and segment-arc distance queries. Feature request: Added new distance queries. Sorry for the delay. I struggle with 2-dimensional mathematics. I know I have problems with 3-dimensional mathematics because I get lost walking around my neighborhood. I seem to be most comfortable in 7-dimensional space.
2023-08-28 19:31:53 -07:00
David Eberly c27d75605f Fixed bugs in point-line and point-ray queries.
The comments in these files indicate the direction vectors do not have to be unit length. This was not true in earlier versions of GTE; that is, the directions had to be unit length. I had modified the comments at one time because I was removing the unit-length constraint. Unfortunately, the code was not modified, so only unit-length vectors worked. My unit tests passed anyway because they all used unit-length directions. The constraint is now removed. The direction vectors do not have to be unit length, the code was corrected, and the unit tests were updated to handle non-unit-length vectors. The line-segment distance query in DistPointSegment.h is correct.
2023-08-27 14:49:44 -07:00
David Eberly 673fc17b6b Updated history files.
Latest changes (DistLine2Circle2.h, DistSegment2Circle2.h).
2023-08-26 15:01:43 -07:00
David Eberly e4c6462105 Create DistSegment2Circle2.h
Added a distance query for segment-circle in 2D.
2023-08-26 15:01:13 -07:00
David Eberly d9696ef373 Update DistLine2Circle2.h
When the line intersects the circle in two distinct points, the parameter members of result must be increasingly ordered. They were not always, so a test-and-swap had to be added. I also fixed old comments about the Result struct.
2023-08-26 15:01:05 -07:00
David Eberly ac4968e61c Update README.md
The Poco exception is still not fixed as of NVIDIA driver 537.13 (August 22, 2023).
2023-08-26 09:20:24 -07:00
David Eberly 463e30c740 Updated history files.
Latest code fixes.
2023-08-24 16:39:59 -07:00
David Eberly aa6a82f285 Removed MSVS 2022 warnings.
Removed MSVS 2022 warnings about uninitialized arrays (which clearly are initialized in the code).
2023-08-24 16:32:13 -07:00
David Eberly 541fcdcc3c Modified GUID for GTMathematicsGPU.v16 and dependent files.
The GTMathematicsGPU solutions and projects duplicated the GUID in MSVS 2019 and MSVS 2022. The MSVS 2019 GUID was modified. The GenerateMesh v17 projects were missing references to the GTMathematicsGPU projects (which did not affect the compilation).
2023-08-24 16:20:18 -07:00
David Eberly 28b719860e New file, reparameterize by arclength.
This code is based on the revised PDF https://www.geometrictools.com/Documentation/MovingAlongCurveConstantSpeed.pdf.
2023-08-20 21:32:13 -07:00
David Eberly 191bdf67d3 Update README.md
Fixed the link to the current installation and release notes (version 6.8).
2023-08-15 08:32:09 -07:00
David Eberly 412a68f5b1 Update README.md
NVIDIA GeForce driver 536.99 still throws the Poco exceptions.
2023-08-14 20:53:01 -07:00
David Eberly 961c680d18 Restructuring header files.
A large number of files have been modified in order to ensure that each header file includes any C++ Standard Library headers it references. This avoids breaking the compile when GTE headers are refactored. I also unified the commenting so that top-level comments occur after the pragma-once statement but before any header file includes. (All of this had already been done in GTL and ensures that the instantiation tool behaves correctly.) See Gte6UpdateHistory.pdf for the details of all the changes.
2023-08-08 23:54:19 -07:00
David Eberly d8637e160b Bug fix in SegmentMesh.h
The index i1 was compared to the upper-bound loop counter for contiguous-open segment meshes. It needed to be i0. (Off-by-one error.)
2023-07-29 12:32:33 -07:00
David Eberly 26a6b62c80 Update the history for the recent modifications.
Updated the PDF history files for July 28, 2023.
2023-07-28 23:31:50 -07:00
David Eberly 799c712130 Modified interface to support bisection or closed-form equations.
Modified the interfaces to allow selection between using bisection or using the closed-form equations for root estimation. Updated the unit tests for code coverage of either selection.
2023-07-28 23:29:32 -07:00
David Eberly 40dfa08b45 Update UIntegerAP32.h
Minor changes to avoid Visual Studio 2022 code analysis warnings.
2023-07-28 23:28:50 -07:00
David Eberly 65222a5270 Update DistLine3Circle3.h
This file is cursed. Last check-in, I merged a line from GTL to GTE. The query result is stored in a struct Output in GTL but the GTE query result is stored in a struct Result. I then failed to run my instantiation tools which would have trapped the error.
2023-07-28 23:28:35 -07:00
David Eberly 4f47cd85ae Update DistLine3Circle3.h
Let's try this again. The bug required 2 lines added, but I had added only the first. I added the second line of code that was missing.
2023-07-23 13:22:27 -07:00
David Eberly ada0e20fd3 Fixed bug in DistLine3Circle3.
The code ported to GTL had a unit-test failure for the Robust() function in the case that the circle center was not the origin. The GTE unit tests did not contain such a case. One block of Robust() was missing the translation of the closest line point to the original coordinate system.
2023-07-23 13:12:38 -07:00
CodeReclaimers c3f146329d Merge branch 'davideberly:master' into master 2023-07-19 17:25:07 -04:00
David Eberly e96462ec6a Updated PDFs for GTE 6.7.
Added history items for polynomial root estimation code. Posting GTE 6.7.
2023-07-18 08:49:04 -07:00
David Eberly 7eb665471c New files for robust estimation of roots of polynomials of low degree.
Added new files for robust root estimation for polynomials of degree 1, 2, 3, and 4. These use exact rational arithmetic for theoretically correct root classification, just as RootsPolynomial does. Rather than call standard mathematics library functions for the closed-form root equations, bisection is used to avoid magnification of rounding errors inherent in power functions. The document LowDegreePolynomialRoots.pdf has a major revision to be more clear about the root estimation. This includes avoiding some of the logic tests mentioned at the Wikipedia page for quartic polynomials. The code has been unit tested for 100 percent coverage.
2023-07-18 08:47:37 -07:00
David Eberly 4a8f9d6803 Update README.md
Fixed spelling error.
2023-07-10 11:26:49 -07:00
David Eberly a6bc7a7383 Update the history documents.
Added entries for recent bug fixes.
2023-07-10 11:09:43 -07:00
David Eberly 5afb79c5d0 Update README.md
Added a 3rd-party issue. Intel(R) Iris(R) Xe Graphics driver version 31.0.101.4146 throws two C++ exceptions (in igc64.dll) when the DX11 is shutdown in an application.
2023-07-10 11:09:12 -07:00
David Eberly a1b3ba64e3 Update DistPoint3Cylinder3.h
Fixed a bug. The clamping of the infinite-cylinder closest point to the finite-cylinder closest point used height h instead of h/2. The unit tests associated with these cases were also fixed.
2023-07-10 11:07:42 -07:00
David Eberly 1e6e5fc78f Choose DX11 discrete adapter before Intel Integrated Graphics
Running a ConsoleApplication-derived object on a laptop with Intel Integrated Graphics (Iris Xe/UHD) and an NVIDIA GeForce RTX 3050, the Intel graphics is identified  as the most powerful adapter because that adapter is associated with the primary display. I had added code to WindowApplication-derived objects some time ago to choose a discrete adapter (if available) before choosing the Intel driver. That same code has now been added to the console-based application layer.
2023-07-10 11:07:11 -07:00
David Eberly e42d5cfa63 Update README.md
The Poco exceptions still occur in GeForce driver 536.40.
2023-07-02 19:26:00 -07:00
David Eberly 3e3bcdb3bc Fixed a bug for intersection of canonical box and finite cylinder.
Fixed a bug in DoQueryOneZero where sMin was set incorrectly in the case tHat > h/2. Unit tests in GTL had found the problem, and I fixed it there, but failed to back-port it to GTE.
2023-06-17 11:52:14 -07:00
David Eberly 79e64ee882 Update to ellipse-ellipse intersection.
Modified the ellipse-ellipse find-intersection query code to be more robust when using floating-point arithmetic. The code still executes with rational arithmetic. Added a sample program for testing the code. The interface for FIQuery<T,Ellipse2<T>,Ellipse2<T>} changed, so the area-of-intersection code had an obsolete interface removed. Added support for fused-multiply-add instructions.
2023-06-16 18:51:39 -07:00
David Eberly dd545a2693 Update RootsQuadratic.h
Revised the implemention to be provide a better estimation of the roots.
2023-06-16 18:49:58 -07:00
David Eberly dc452f2850 Replaced initial cone estimation by simpler algorithm.
Modified the code to initial cone parameters when the caller requests initialization. The previous initialization was an implementation of an algorithm described in the LeastSquaresFitting.pdf file but the mathematics of the file was incorrect. Fixing the mathematics leads to having to compute roots of a degree 10 polynomial. Instead, a simpler method is provided that uses a line-fitting algorithm to determine the relationship between height h and radial distance r. The PDF itself has been modified.
2023-06-11 19:10:38 -07:00
David Eberly bf87590eae Update README.md
The Poco::NoFoundException problem still occurs as of NVIDIA driver version 535.98.
2023-06-04 19:55:28 -07:00
David Eberly 0a528c6370 Added new file RootsQuadratic.h and modified rational number files.
Added a new class RootsQuadratic for robust estimation of roots to quadratic polynomials. The robust versions for cubic and quartic polynomials use this; the work is in progress. The older code in RootsPolynomial will remain in GTE for now but will be deprecated in GTL.

Added number.Negate() member functions BSNumber and BSRational to avoid the verbose number.SetSign(-number.GetSign(). BSRational.SetSign had an mValue block with GTL_BINARY_SCIENTIFIC_SHOW_DOUBLE instead of GTE_BINARY_SCIENTIFIC_SHOW_DOUBLE. This affected only the visualizer display of mValue; the rational number itself is correct.
2023-05-25 11:14:46 -07:00
David Eberly 595bf1c26b Update README.md
Enough of the Poco exceptions. Added instructions for the MSVS debugger to ignore the Poco::NotFoundException.
2023-05-24 08:40:02 -07:00
David Eberly d606e5593f Update README.md
NVIDIA driver 532.03 still throws Poco::NotFoundException during DX11 device creation and destruction.
2023-05-24 08:00:27 -07:00
CodeReclaimers a81d0d44f3 Added cleanup Python script.
Removed user files from version control.
2023-05-23 05:15:01 -04:00
David Eberly 4e60922532 Fixes to line-distance query in 3D
DistLine3Circle3.h: The line-circle distance code had flawed logic for the case of a line not perpendicular to the plane of the circle and containing the origin. However, the block is entered when the line origin is on the normal line to the plane containing the circle center.

RootsPolynomial.h: Two std::sqrt calls have arguments that are theoretically nonnegative, but floating-point rounding errors can lead to negative arguments. I added guards against this (clamp to nonnegative). The other \Code{std::sqrt} calls already have the guard. The errant calls were in SolveDepressedQuartic. The problem was discovered during the line-circle distance query investigation.

Update the history PDFs.
2023-05-22 18:27:12 -07:00
David Eberly 50e122d298 Update README.md
Updated the read-me file to show that Fedora 38 with gcc 13.1.1 is now supported.
2023-05-08 10:26:54 -07:00
David Eberly ee5d6252a2 Updated the history files and installation/release notes.
These files are modified for GTE 6.6.
2023-05-08 10:24:44 -07:00
David Eberly 75e0bfe0bd Added code and sample for fitting a curve by circular arcs.
Feature request for code to approximate continuous parametric curves with circular arcs. This includes a sample application. A PDF describing the algorithm is at the Geometric Tools website (ApproximateCurveByArcs.pdf).
2023-05-08 10:21:53 -07:00
David Eberly 5c6e544758 Update BSRational.h
Added a re-computation of mValue (when writing the value is enabled) when using the functions frexp and ldexp specialized to BSRational. Without this, the value was incorrect. (mValue is useful only for debugging/visualizer)
2023-05-08 10:20:14 -07:00
David Eberly 68af554830 Update ApprCone3EllipseAndPoints.h
The code for approximating and ellipse and points used the old OBB tree code. Modified it to use the new OBB tree code.
2023-05-08 10:18:25 -07:00
David Eberly 7849bd12b1 Factored area code from ellipse-ellipse intersection file.
Factored out the area computations from IntrEllipse2Ellipse2.h for separation of concerns.
2023-05-08 10:18:08 -07:00
David Eberly 323c6c6a33 Update RootsPolynomial.h
Rewrote the biquadratic implementation. The old code had a problem in one computation where subtractive cancellation caused many significant bits to be eliminated. This was the problem in the github issue about intersection of two ellipses, one rotated by pi/4+epsilon for a small epsilon. An algebraic identity was used to avoid the subtractive cancellation, and the ellipse-ellipse intersection problem was eliminated. The problem with ellipse-ellipse intersection for rotation epsilon still exists when you are using floating-point arithmetic. It does not occur with rational arithmetic, but I am rewriting that code to fix the floating-point problems).
2023-05-08 10:17:28 -07:00
David Eberly 1a5b861ab3 Update MinimalCycleBasis.h
Fedora 38 with gcc 13.1.1 compiler complained about potentially uninitialized variables. Add initialization even though in fact they are initialized before use (metaknowledge about the algorithm).
2023-05-08 10:16:08 -07:00
David Eberly a2631e95e7 Update DisjointIntervals.h
Fedora 38 with gcc 13.1.1 compiler complained about std::move whose argument is a temporary object.
2023-05-08 10:15:35 -07:00
David Eberly 729f47eee3 Merge pull request #61 from erebel55/exceptions
Add support for environments where exceptions are disabled
2023-05-07 17:14:16 -07:00
Ethan c3e8f158f2 Update Logger.h 2023-05-07 18:33:21 -04:00
Ethan b6ea4cad54 Add support for environments where exceptions are disabled 2023-05-07 18:13:59 -04:00
David Eberly 494af9f87a Update README.md
NVIDIA GeForce driver version 531.79 still throws the Poco exceptions when creating and destroying a D3D11 device.
2023-05-06 17:39:26 -07:00
David Eberly b56eeea1c0 Update README.md
NVIDIA driver 531.68 also throws the Poco exceptions.
2023-04-18 19:36:09 -07:00
David Eberly be5efa0f00 Update README.md
NVIDIA driver 531.61 also throws Poco exceptions when creating and destroying the ID3D11Device object.
2023-04-13 08:58:31 -07:00
David Eberly c131655716 New OBB tree code (tree for points or segments or triangles).
Redesigned the OBB tree of points, factoring out the tree construction to
\Code{OBBTree.h}. I also fixed an incorrect sizing of the nodes of the tree.
A feature request was made of an OBB tree of triangles, which was easy to
implement by derivation from \Code{OBBTree}. The \Code{OBBTreeOfTriangles}
class has additional support for computing the intersection of linear
component (line, ray, segment) with a triangle mesh. I also added code for
computing an OBB of segments.
2023-04-11 21:28:34 -07:00
David Eberly 361a541dfb Update README.md
The NVIDIA driver version 531.41 has the same Poco exception problem.
2023-04-07 08:54:46 -07:00
David Eberly dc7e98388c Modified DX11Engine::EnableTextures
Modified the function to bind multiple UAVs in a pixel shader in the same bind call. Before this change, any pixel shader with multiple UAVs would not work correctly (internally in the DX11 runtime not all UAVs were bound to u-registers).
2023-03-27 14:27:49 -07:00
David Eberly 38a0e59d46 Fixed regression in Delaunay2.
Fixed a regression when switching from <set> to <unordered_set>; the hash function and equality operator incorrectly included in these functions the ProcessedVertex location member. Also, when the input dataset has duplicated vertices, the InsertEdge function needs to replace the vertex indices by the equivalence-class representatives (via mDuplicates) before processing the edge. The sample application has another small test dataset, this one with a duplicated vertex. (The GTL code for Delaunay2 and ConstrainedDelaunay2 work correctly--no regression.)
2023-03-20 11:04:02 -07:00
David Eberly fbbab14eb3 Update README.md
The Poco exceptions that occur with NVIDIA driver 531.18 also occur with 531.29.
2023-03-14 15:59:51 -07:00
David Eberly ae839e7d15 Update README.md
Note about NVIDIA driver 531.18 throws exceptions on D3D11CreateDevice.
2023-03-11 20:28:20 -08:00
David Eberly 54eb7c08e4 Fixed Fedora gcc 12.2.1 compiler warnings.
I have a template instantiation tool that was running debug (-g) builds. I added the ability to run release (-O2) builds. The Fedora gcc compiler warned about potentially uninitialized variables in the FastMarch* files. It also warned about an out-of-range index in the C++ std::sort code in the DistLine3Circle3 file for the line
std::sort(candidates.begin(), candidates.begin() + numRoots). The numRoots is known not to exceed 4, but the compiler cannot determine this. I added the line numRoots = std::min(numRoots, static_cast<size_t>(4)) before the call to std::sort to avoid the warning.
2023-02-25 19:23:54 -08:00
David Eberly 4699effdf2 Sorting points in a circular manner about a center point.
New file for sorting points in a circular manner about a center point. The website has a PDF describing the algorithm (SortPointsOnCircle.pdf).
2023-02-25 19:21:31 -08:00
David Eberly 4b74d19923 Update README.md
Removed an errant period in the last modification.
2023-02-25 08:17:34 -08:00
David Eberly dc432c57cb Update README.md
Added a hyperlink to the Installation and Release Notes.
2023-02-25 08:15:19 -08:00
David Eberly 2ff7b76b30 Eliminated the Fedora 37 gcc 12.{1,2}.1 warnings about std_function.h.
Eliminated the Fedora gcc 12.{1,2}.1 release-build warnings about uninitialized members in std_function.h, probably due to incorrect optimization by the compiler. The warnings occurred in release builds of PVWUpdater.cpp where the member default constructors were called in the class constructors followed by a Set call to assign the members. I removed the Set calls and initialize the members directly in the
constructor initializer list.
2023-02-20 09:41:24 -08:00
David Eberly 7769c47903 Update README.md 2023-02-16 17:30:58 -08:00
David Eberly 198d797a63 Posted numerical integrators.
The Romberg integration is used by ParametricCurve.
2023-02-14 07:36:51 -08:00
David Eberly 82720198c3 Clean up after the previous merge.
Modified the "File Version" numbers to 2023.02.02. The default constructor for Window::Parameters in Window.cpp needed to set the new member 'parent' to nullptr. The new callback OnCopyData in WindowApplication.{h,cpp} exposes Win32 data types. The new code needed to be in conditional blocks enabled when GTE_USE_MSWINDOWS is defined to avoid breaking the Linux build. Modified the update PDFs with information about the changes.
2023-02-02 15:37:39 -08:00
David Eberly 263b0263ed Merge pull request #51 from CodeReclaimers/master
Added WM_COPYDATA and parent window support.
2023-02-02 11:44:34 -08:00
CodeReclaimers dd0699f768 Merge branch 'master' of https://github.com/CodeReclaimers/GeometricTools 2023-02-02 13:39:59 -05:00
CodeReclaimers f7d598a7dc Added parent window member to Window::Parameters.
Implement WM_COPYDATA handling stub.
Added missing pragma.
Fix linter complaint (use .empty() in place of .size() == 0).
2023-02-02 13:39:06 -05:00
David Eberly 51dfbc0584 Added a new class ApprConvexQuadByRect.
Fit a rectangle to a convex quadrilateral that is nearly a rectangle. The algorithm uses a least-squares formulation.
2023-01-24 12:44:43 -08:00
David Eberly dfafe0e90e Modifications and new files for 2-manifold and 3-manifold meshes.
For detailed notes, see the update PDFs whose links are at the repository home page. GetBoundaryPolygons for 2-manifold meshes was flawed if the mesh is not strictly manifold, having bow-tie configurations. I reimplemented the function with a simpler approach. Add vertex-triangle-tetrahedron mesh support (VTSManifoldMesh) that adds vertex management on top of TSManifoldMesh, similar to ETManifoldMesh and VETManifoldMesh. Added new static manifold mesh classes, MeshStaticManifold{2,3} that perform better than StaticVETManifoldMesh2 and StaticVTSManifoldMesh3. Deprecated/removed VETManifoldMeshNR (use MeshStaticManifold2 instead).
2023-01-17 13:20:12 -08:00
David Eberly 16f5a247d8 Update README.md
The URLS to the update files were missing the GTE folder.
2023-01-11 15:53:51 -08:00
David Eberly 44eb1befa6 Posting update history.
The update history files will be modified immediately for any relevant code changes. The markdown file has links to these files.
2023-01-11 15:49:42 -08:00
David Eberly 291c5b2d97 Delete Gte6p4InstallationRelease.pdf
Replaced by the installation and release notes for GTE 6.5.
2023-01-11 15:48:47 -08:00
David Eberly 585c90ec3c Update ApprOrthogonalPlane3.h
The Error function and the comment in the file about the error formula were incorrect. They appear to have been copied-and-pasted from the ApprOrthogonalLine3.h implementation. The error code was introduced in the port from WM5 to GTE1. Thanks to Scott Johnson for informing me about the mistakes.
2023-01-11 15:48:23 -08:00
David Eberly 7ba1b489fb Update StaticVETManifoldMesh2.h
The posted file StaticVETManifoldMesh2.h was out of sync with the development version and was missing the initialization of the members of mAdjacents to invalid (-1). I also modified some comments and added some \Code{const} modifiers where necessary.
2023-01-04 13:00:19 -08:00
David Eberly b84154d8ff Updated copyright notices for 2023.
Updating the copyright to 2023 but keeping the current file version numbers.
2023-01-01 14:52:23 -08:00
David Eberly 9d8d67c6ba Fast static 2-manifold mesh construction.
New file that provides an additional speed-up to VETManifoldMeshNR for constructing static vertex-edge-triangle manifold meshes from collections of triangles.
2023-01-01 14:19:58 -08:00
David Eberly 8a636eaa6a Feature request for polyline/polygon offset
The new file is PolylineOffset.h. A sample application to illustrate is GeometricTools/GTE/Samples/Geometrics/PolylineOffset.
2022-12-24 15:53:39 -08:00
David Eberly bd44331bcd Update README.md
The supported Linux versions are now Ubuntu 22.04.1 and Fedora 37. The code compiles also with Intel C++ Compiler 2023. I removed the PDF for the technical support queue because it is not useful information.
2022-12-24 08:05:25 -08:00
David Eberly bd9d53ff2c Posting GTE 6.5.
Posting the current state of all changes made to GTE 6.4.
2022-12-15 09:58:02 -08:00
David Eberly 7561f4b3f5 Update ChangePlatformToolset.cpp
Part of the change made to the platform toolset tool.
2022-12-15 09:57:08 -08:00
David Eberly 030db722ad Added a function to determine max words for barycentric coordinates.
Updated the calculator for barycentric coordinates.
2022-12-15 09:56:36 -08:00
David Eberly 164c0ce74e Modified the platform-toolset tool to change toolsets for MSVS 2022 projects.
Removed support for MSVS 2019 projects, although it is easy to modify the current code to replace the toolset for these projects.
2022-12-15 09:55:40 -08:00
David Eberly 35131649b8 New code for line-segmentMesh intersection, with sample application.
Added the primitive SegmentMesh<N,T> that represents a collection of order line segments in dimension N with coordinates of type T. Added intersection queries between line/ray/segment and a segment mesh. Added a sample application to illustrate (ray casting a simple polygon).
2022-12-15 09:53:35 -08:00
David Eberly 09c34fb68a Added missing header file.
The project was missing ConvexPolyhedron.h, a file specific to the sample application.
2022-12-15 09:50:52 -08:00
David Eberly 52d17f236e Update MinimumAreaBox2DWindow2.h
Added missing 'override' modifier to DrawScreenOverlay (ClangCL complained).
2022-12-15 09:50:02 -08:00
David Eberly 0f7e2c96c3 Modifications for ClangCL.
ClangCL is one of the compilers MSVS 2022 supports. Removed unused variables that the compiler complained about.
2022-12-15 09:49:20 -08:00
David Eberly 9d2b286bef Update DistPoint2Arc2.h
Added an optimization to avoid a sqrt operation.
2022-12-01 16:45:56 -08:00
David Eberly d4dbd40864 New 2D distance queries (point-circle, point-arc)
Added new 2D distance queries for point-circle and point-arc. Also fixed some
missing header file references in the GTMathematics.v16 project.
2022-12-01 09:53:51 -08:00
David Eberly 0b7805f202 Update DX11Engine.cpp
The CopyBackBuffer call mapped mBackBufferStaging but failed to unmap it after the copy.
2022-11-27 07:12:53 -08:00
David Eberly 1669749279 Update IntrEllipse2Ellipse2.h
Rolling back the changes from the 4 November 2002 update. The code is faster but the rounding errors cause misclassification of the number of points of intersection. Welcome to the trade-off of floating-point versus rational arithmetic. At some point I need to implement rational arithmetic classes using the GNU Multiprecision Library to take advantage of the better performance for arbitrary precision multiplication. At a later date, I can implement a similar speed-up for BSNumber and BSRational.
2022-11-11 10:52:53 -08:00
David Eberly 74c961f4e0 Update Arc2.h
Re-ported Arc2 from GTE for new Contains function.
2022-11-06 09:43:41 -08:00
David Eberly f6b53f7e1e Update IntrEllipse2Ellipse2.h
When using BSRational<UIntegerAP32> for template type T, the number of words used in the SolveQuartic root finder can be extremely large---on the order of 100000. This leads to poor performance. The root finder has numerical rounding errors whether T is a floating-point type or a rational type, so to avoid the poor performance, the rational-valued quartic coefficients are converted to double precision and then reconverted to T. This introduces a small amount of rounding
error, but performance is significantly better. I also added initialization of Result members in the constructor to avoid compiler warnings.
2022-11-04 08:41:37 -07:00
David Eberly d97082964d Update Arc2.h
Added a fuzzy containment that tests whether a point is on a circular arc. The non-fuzzy containment requires the point to be on the circle of the arc or nearly on the circle within floating-point rounding errors.
2022-11-02 15:09:02 -07:00
David Eberly d06a2a440a Update QuadricSurface.h
Back-ported QuadricSurface from GTL to GTE, both versions unit tested.
2022-10-17 19:29:14 -07:00
David Eberly 383b9e6b26 Posting the GTE-to-GTL port for Curves and Surfaces.
The files are for curves and surface, now in separate folders in GTL. GTE had them all in CurvesSurfacesVolumes. All files have been unit tested.
2022-10-17 15:11:17 -07:00
David Eberly cfc8c8a81c Update IntrCanonicalBox3Cylinder3.h
Fixed a bug in ComputeSqrDistance on line 247 (incorrect sign on s). Thanks to Tom Foster for reporting the bug. This check-in updates the file version number.
2022-09-23 18:02:20 -07:00
David Eberly ad9a6290e0 Merge pull request #44 from tvf/master
Fix calculation of closest point to origin on 2D segment in canonical box/cylinder intersection test.
2022-09-23 17:54:06 -07:00
Thomas Foster b2cc5d9a0e fix calculation of closest point to origin on segment 2022-09-20 16:51:29 +01:00
David Eberly 111716cac8 Updated project files for new files.
I missed pushing these files with the new file ContAlignedBox2Arc2.h and VETManifoldMeshNR.h.
2022-08-25 21:29:21 -07:00
David Eberly 5ec5812770 Update TCBSplineCurve.h
Reimplemented the TCB spline code based on the rewrite of my PDF document
"Kochanek-Bartels Cubic Splines (TCB Splines)". I removed the tangent adjustments suggested by Kochanek and Bartels (based on discrete variables), replacing them with adjustments based on continuous variables. I added support for specifying the boundary tangents explicitly rather than duplicating the endpoints of the keyframes and computing the boundary tangents internally. Finally, I added a parameter (lambda) per key frame position to control the speed at those positions and ensure continuity of speed.
2022-08-25 17:27:21 -07:00
David Eberly 122ff9e970 Create ContAlignedBox2Arc2.h
Feature request for code to compute the minimum-area aligned box that contains a circular arc.
2022-08-23 09:03:05 -07:00
David Eberly f34c7844fc Update MinimumVolumeBox3.h
Modified the file version/date.
2022-08-16 12:06:12 -07:00
David Eberly da31299047 Merge pull request #43 from Leopard20/master
MinimumVolumeBox3: Adjust class data to make it reusable for multiple data sets
2022-08-16 11:55:40 -07:00
Leopard20 26d2fb555f Add a read-only member accessor for mConvexHull3 2022-08-16 23:04:15 +04:30
Leopard20 fef2defa90 Adjust class data to make it reusable for multiple data sets 2022-08-09 21:06:49 +04:30
David Eberly 69fd6cb99e Added header path to managed library sample.
The managed library project compiles with the directory structure of GTE, but if folders are moved elsewhere, the managed library needed $(GTE_PATH) for the header search path. GTE_PATH is an environment variable that stores the path to the top-level folder GeometricTools/GTE (see the installation and release notes).
2022-07-13 12:01:20 -07:00
David Eberly 1c35f3a5f7 Minor updates to the C#/CLI code.
Updated the copyright date in the assembly file. Modified the comments in the program file.
2022-07-12 17:59:58 -07:00
David Eberly ff866a1474 Modifications to the C#/CLI sample projects.
Removed the file ManagedObject.h, consolidating the contents with the managed files MinimumVolumeBox.{h,cpp}. Small reorganization of the solutions.
2022-07-12 17:45:36 -07:00
David Eberly 742d707356 Allow Window2-derived applications to resize the window.
The Window2 class was implemented not to allow window resizing. I removed this constraint and added comments in the header file about the responsibilities of an application class derived from Window2. The 2D fluid simulation sample application was modified to illustrate the resizing.
2022-07-04 12:58:27 -07:00
David Eberly ae77ed2d4f Modified some comments.
Modified comments that referred to the old file names GteSOMEFILE.h, replacing them by SOMEFILE.h.
2022-07-04 12:20:34 -07:00
David Eberly d79972e546 Update ImplicitSurface3.h
Greatly simplified the implementation based on a revision of the document PrincipleCurvature.pdf.
2022-06-29 17:39:40 -07:00
David Eberly 8644fba229 Update ImplicitCurve2.h
The IsOnSurface function name is a copy-and-paste error from the implicit
curve file. I modified the name to IsOnCurve. I also set the output curvature on early exit in order not to leave output uninitialized.
2022-06-29 17:39:10 -07:00
David Eberly 16489e6ffd Added new comments.
Added comments to indicate that VETManifoldMeshNR might be a better choice for your application if it meets the preconditions. I also made minor modifications to avoid MSVS code analysis warnings.
2022-06-26 18:19:04 -07:00
David Eberly d5b52ebc34 Create VETManifoldMeshNR.h
Added a new class VETManifoldMeshNR which represents a vertex-edge-triangle manifold mesh for which triangles are provided as a single batch and NO REMOVE operations are going to be performed on the mesh. VETManifoldMeshNR significantly outperforms VETManifoldMesh. VETManifoldMesh is general purpose, allowing triangle insertions and triangle removals. The underlying C++ container classes lead to significant memory allocation/deallocation costs and are also expensive for find operations. It turns out that the design of VETManifoldMeshNR automatically gives you vertex adjacency information, so there is no ETManifoldMeshNR implementation. It is a requirement that the input triangles form a manifold mesh with consistently ordered triangles. In most applications, this
requirement is already satisfied.

The VETManifoldMeshNR class is designed to minimize the allocations. For example, using this class for a collection of 1131652 positions and 2242293 triangles, the CPU times on an Intel (R) Core (TM) i9-10900 are as follows. For ETManifoldMesh, graph creation used 2234 milliseconds, connected component finding used 2169 milliseconds, and finding the boundary polygons used 232 milliseconds. For VETManifoldMesh, graph creation used 118 milliseconds, connected component finding used 40 milliseconds, and finding the boundary polygons used 25 milliseconds.
2022-06-26 18:02:45 -07:00
David Eberly bd7a27d18a Update README.md
Now supporting Fedora 36 and gcc 12.1.1.
2022-06-08 18:15:17 -07:00
David Eberly 35628ad600 Posting GTE 6.4.
Updated the minor version numbers for CMake. Updated the installation and release notes.
2022-06-08 17:59:56 -07:00
David Eberly 5f69792094 New classes for natural spline interpolation.
Added new files that contain an efficient implementation of natural cubic splines and natural quintic splines. The PDF documentation has been revised accordingly,
https://www.geometrictools.com/Documentation/NaturalSplines.pdf . The class NaturalSplineCurve will be deprecated in favor of the new classes.
2022-06-08 17:58:38 -07:00
David Eberly af93d77e9e Update NaturalSplineCurve.h
Fixed gcc 12.1.1 compiler warnings (signed/unsigned integer comparisons).
2022-06-08 17:57:32 -07:00
David Eberly 9d09ef9199 Fixed gcc 12.1.1 warning about potential index-out-of-range.
Fedora 36 with gcc 12.1.1 complains about potential index-out-of-range because
Evaluate references all possible elements, but the compiler is unaware that the logic of Evaluate is designed to assign only those elements that are valid. For now, I am passing in an array of 3-tuples knowing that only one will be filled in. Added arrays of  N-tuples to avoid the warnings.
2022-06-08 17:56:56 -07:00
David Eberly d0f85b1b5c Fixed gcc 12.1.1 potentially uninitialized warning.
Modified code to avoid a potentially uninitialized variable warning from
gcc 12.1.1 on Fedora 36.
2022-06-08 17:55:44 -07:00
David Eberly 29b08a5e3a Update UniqueVerticesTriangles.h
Fixed an error in the deprecated file for UniqueVerticesTriangles; the <array> header is not explicitly included. This occurred with gcc 12.1.1 on Fedora 36 even though my instantiation tool did not include explicit instantiation for that class. The error did not occur with gcc 9.3.0 on Ubuntu 20.04.1 LTS or Microsoft compilers when running the tool.
2022-06-08 17:54:51 -07:00
David Eberly 1e90543cea Fixed gcc 12.1.1 error about missing template keyword.
Fixed gcc errors about the keyword template required before the dependent typenames involving the Degree* function calls. The errors occurred with gcc 12.1.1 on Fedora 36 but not with gcc 9.3.0 on Ubuntu or with Microsoft compilers.
2022-06-08 17:54:09 -07:00
David Eberly e17d9f7dec Update GLSLReflection.cpp
Fixed bugs in a block of code that is not exercised by the ShaderReflection sample application. This problem was caught by gcc 12.1.1 on Fedora 36.
2022-06-08 17:53:09 -07:00
David Eberly c2f39b100b Update NaturalSplineCurve.h
The constructor for free or closed splines allocated more than enough elements for mCoefficients and the GetNumPoints() function returned the number of points based on the size of mCoefficients. The constructor for clamped splines allocated exactly the correct number of elements for mCoefficients, but then GetNumPoints() returned the incorrect number of points. This caused too few points to be processed in clamped splines. This occurred when the optimization was added to minimize memory allocations and deallocations for free splines. The optimization code has been reworked and the same memory optimization was added for closed and clamped splines. The unit tests pass for all 3 flavors of splines.
2022-06-04 16:05:23 -07:00
David Eberly 9b6ce14b60 Update BitHacks.h
Incremented the file version to 2022.05.30.
2022-05-30 09:27:06 -07:00
David Eberly 523751c21f Merge pull request #38 from tdeslandes/master
Fixed infinite recursion issue when compiling with clang
2022-05-30 09:19:12 -07:00
Titouan Deslandes e510f19843 Fixed infinite recursion issue when compiling with clang 2022-05-30 10:55:48 -04:00
David Eberly 3ac9d35fb3 Finished port/test from GTE to GTL of the distance queries.
Ported, formatted and unit tested.
2022-05-22 19:27:46 -07:00
David Eberly 6238789eaf Finished port/test from GTE to GTL of the root finders.
Ported, formatted and unit tested.
2022-05-20 14:44:28 -07:00
David Eberly ffc2375558 Finished port/test from GTE to GTL of the geometric primitives.
Ported, formatted and unit tested.
2022-05-19 12:07:33 -07:00
David Eberly 087675c697 Port of ODE solvers from GTE to GTL
Ported and unit tested.
2022-05-17 08:29:51 -07:00
David Eberly cb9bbd3bd5 Fixed a bug in Transform::Inverse.
In the GTL development, fixed a bug in the Inverse function for Transform<T> objects. The unit tests were incomplete in that they tested the inverse directly using queries to the internal matrices of Transform<T> rather than verifying the correctness of the output of Inverse. The corrections were backported to GTE.
2022-05-16 14:44:27 -07:00
David Eberly 3d64fce4f5 Fixed code comments and changed a non-const to a const reference.
The RectangleManager code was copied, pasted and modified to produce the BoxManager code. The comments were part of this and the BoxManager code referred to rectangles rather than boxes. Also, non-const references in both classes were modified to const references.
2022-05-16 14:43:03 -07:00
David Eberly aea672f205 Utility library updates, first batch for Mathematics library
The unit-testing framework and template instantiation framework is now working for Windows and Linux. Utility updates are based on ensuring code compiles on Ubuntu and Fedora. Unit tests pass for all the posted files. Utility documentation PDF update and Mathematics documentation PDF (for this batch) to occur next.
2022-05-02 19:07:50 -07:00
David Eberly f95ae66ac3 Create RawPtrCompare.h
Added comparison operators for raw pointers to complement those already in the code for shared pointers and weak pointers.
2022-04-19 08:02:33 -07:00
David Eberly 4dd7861e2a Update Lattice.h
g++ on Ubuntu complained that the declarations "std::array<*,*> sizes;" in the template metaprogramming were invalid because std::array does not have a default constructor. Modified the declarations to "std::array<*,*> sizes{};".
2022-04-19 08:02:03 -07:00
David Eberly d5e1354efd Update README.md
Fixed copy-and-paste error that included https twice.
2022-04-14 14:56:23 -07:00
David Eberly c1b11f4223 Update README.md
Added links to repositories that use GTE.
2022-04-14 14:55:01 -07:00
David Eberly 776dc7e07d Update MultiarrayAdapter.h
The unit tests for MultiarrayAdapter had passed previously, but when I moved them to a new project in order to test GTL chunks before posting, a comparison test failed intermittently. On inspection, the less-than comparison operator involved a pointer comparison. Updated the comparison operators to use object comparisons.
2022-04-07 10:00:59 -07:00
David Eberly afdda21574 Posting the GTL utility file and documentation.
This is the first batch of code posted for GTL. I will be posting additional batches as they are finalized.
2022-04-06 16:29:39 -07:00
David Eberly aa09f9ca52 Posting GTE 6.3.
Updated the minor version numbers for CMake. Updated the installation and release notes.
2022-04-03 15:28:22 -07:00
David Eberly 777e20a320 Modification for MS Windows to support third-party UI package.
By user request, on Microsoft Windows I added virtual OnWindowsMessage to WindowApplication and called by WindowSystem::WindowProcedure. This allows the application to use a third-party UI package, processing windows messages intended for that package. A return value of true tells the window procedure not to pass the message to the application window.
2022-04-03 11:27:56 -07:00
David Eberly b1c443a4c1 Ported WM5 ShadowMaps to GTE6.
Ported the Wild Magic 5 graphics sample ShadowMaps to GTE6. This is the last of the Wild Magic code I had planned on porting. GTE6 has effectively everything that WM5 had.
2022-04-02 13:03:38 -07:00
David Eberly da3d89fcf9 Added MeshSmoother.h to the projects.
These files should have been pushed with the port of MeshSmoother.h.
2022-03-31 09:18:27 -07:00
David Eberly 326077e931 Create MeshSmoother.h
Ported the Wild Magic 5 MeshSmoother class to GTE6.
2022-03-29 10:18:00 -07:00
David Eberly 528486cf6c Update WindowSystem.cpp
I finally trapped the problem with Windows OpenGL (WGL) where the first-drawn frame is not correct. I added a swap-buffers call immediately after creating the WGLEngine object in the application layer, which eliminated the problem.
2022-03-28 21:02:02 -07:00
David Eberly 947fe9ddb3 Ported WM5 skinning sample to GTE6.
Ported the Wild Magic 5 skinning sample to GTE6.
2022-03-28 21:01:33 -07:00
David Eberly d31b5303fa Added new constructors to MeshFactory.
Added new constructors to avoid the repeated pattern of default construction of
\Code{MeshFactory} followed by the \Code{SetVertexFormat} call.
2022-03-28 18:12:47 -07:00
David Eberly 6fbf9523c9 Ported line-torus intersection from WM5 to GTE6.
Ported the line-torus find-intersection query from Wild Magic5 to GTE6 (at user
request). Added a sample application to show that the code is working correctly.
Internal unit tests have also been added.
2022-03-28 17:51:45 -07:00
David Eberly dc6d3a6957 Update IntrSegment2Segment2.h
The current 2D segment-segment queries use the find-intersection query for two lines, but the segments are converted to center-direction-extent form. The two-point representation has endpoints p0 and p1 and the parameterization is p0 + t  (p1 - p0) for t in [0,1]. The center-direction-extent form is c + s d for |s| <= e. The center is c = (p0+p1)/2, the direction is d = (p1-p0)/|p1-p0| and the extent is e = |p1-p0|/2. The computation of d involves a normalization which generally cannot be computed exactly with rational arithmetic. The computation of e is also not exact. The segment parameters returned from the queries are relative to s, not to t. The old queries are operator() functions and still exist. To allow for exact rational computation, I added new queries named Exact which use the two-point form for segments. [In GTL development, I have been eliminating the use of the segment center-direction-extent form.]
2022-03-25 20:58:43 -07:00
David Eberly 6013f9919e Updated to use static_cast<T> rather than (T).
Replace parenthesized casts by static_cast.
2022-03-25 17:46:03 -07:00
David Eberly 23e3c53405 Update IntrLine2Line2.h
The code had a call Normalize(diff) that is not necessary because the sign tests dependent on diff are theoretically independent of the length of diff. Removing the normalize call now allows the code to produce theoretically correct results when type T is a rational type.
2022-03-25 17:42:24 -07:00
David Eberly 7f5e30557c Update GMatrix.h
The SetRow function was missing a return statement.
2022-03-23 07:49:56 -07:00
David Eberly 3551aad54e Added abstract base classes for implicit curves and implicit surfaces.
Added abstract base classes for implicit curves in 2D, class ImplicitCurve2, and implicit surface in 3D, class ImplicitSurface3. The latter is a port of ImplicitSurface from Wild Magic 5. These classes support computation of coordinate frames and curvature information. For parametric curves and surfaces, see FrenetFrame and DarbouxFrame.
2022-03-22 12:20:16 -07:00
David Eberly f2bb945b6a Ported WM5 VolumeFog to GTE 6
Ported the Wild Magic 5 graphics sample VolumeFog to GTE6.
2022-03-22 11:10:04 -07:00
David Eberly 394e2af77f Fixed minor version in file versions.
Fixed the minor number in file versions. Looks like versioning is the bane of the month.
2022-03-22 11:09:30 -07:00
David Eberly 0da7ed6cac Ported WM5 CollisionsMovingSphereTriangle to GTE6.
Ported the Wild Magic 5 sample CollisionsMovingSphereTriangle to GTE6. This is the final physics sample to be ported from WM5.
2022-03-21 16:20:20 -07:00
David Eberly 50215bb6a4 Ported WM5 CollisionsMovingSpheres to GTE6
Ported the Wild Magic 5 sample \Code{CollisionsMovingSpheres} to GTE6. The
\Code{CollisionsBoundTree} sample should have been in the Physics folder.
2022-03-20 15:46:30 -07:00
David Eberly 828a0e44e9 Ported WM5 collision detection to GTE6.
Ported the Wild Magic 5 collision detection code to GTE6: BoundTree, CollisionGroup and CollisionRecord. Added a wrapper class, CollisionMesh, that provides the interface to a Visual-based triangle mesh to be used at a template parameter for the collision detection code. Added test-intersection and find-intersection queries for moving triangles. Ported the WM5 sample CollisionsBoundTree to illustrate use of the collision detection.
2022-03-20 13:20:18 -07:00
David Eberly fd7d474088 Updated minor version number to 2.
I forgot to update the minor version from 1 to 2 when I posted GTE6.2. Time to automate this step.
2022-03-20 13:18:48 -07:00
David Eberly 175ffbfa2a Update IntrTriangle3Triangle3.h
Fixed a bug in ContainsPoint. Modified the internal unit tests to include the test that exposes the bug.
2022-03-18 23:30:36 -07:00
David Eberly 73418aa560 Updated the sample for C#/managed/C++ projects.
Removed the MSVS 2015 and MSVS 2017 versions of the C#/managed/C++ projects because I no longer support these compilers. The MSVS 2019 projects still exist. I added projects for MSVS 2022. Fixed the path problem in the MSVS 2019 version
(modified environment variable from GTE4_PATH to GTE\_PATH).
2022-03-18 16:52:41 -07:00
David Eberly 4397024652 Added missing header files.
The Math.h file generated compiler errors when I used one of the inline non-templated functions (needed <cstdint>). The UniqueVerticesTriangles.h file generated compiler errors when I tried to use it (needed <set>). This file is deprecated, but until it is removed it needs to compile. I updated my internal instantiation tool to handle these files appropriately.
2022-03-13 22:18:08 -07:00
David Eberly eecf1ab568 Update CMakeLists.txt
The CMake list of source files needed to be updated for PlanarShadowEffect.cpp, SwitchNode.cpp, CLODMesh.cpp and DLODNode.cpp.
2022-03-07 16:13:45 -08:00
David Eberly 6609ad6b32 Update SwitchNode.cpp
The gcc compiler complained about the compound Boolean expression in the GTE_ASSERT statement in SwitchNode::SetActiveChild. It wanted parentheses around the "&&" expression.
2022-03-07 16:11:25 -08:00
David Eberly 93b97245f8 Update DLODNodesWindow3.cpp
An unreferenced variable for the camera position needed to be accessed in two lines of code rather than re-lookup the variable.
2022-03-07 16:10:40 -08:00
David Eberly 55c90ac969 Update CLODMeshCreator.h
Removed unused lines of code (old iterator code that was replaced by range-based iteration and fixeds a sign mismatch in a loop. Removed the declaration for "static constexpr maxFloat = std::numeric\_limits<float>::max()" and now use the max() value itself in the code. I must be missing something about declaring class-member constexpr values; the loader for gcc complained that maxFloat is undefined. The Microsoft compilers (2019/2022) never complain about such a declaration.
2022-03-07 16:10:07 -08:00
David Eberly 9fd3211978 Update MinimumWidthPoints2.h
The MinimumWidthPoints2 class is templated with class T. It contained a line "using RotatingCalipers = typename RotatingCalipers<T>" which Microsoft compilers allowed. The gcc compilers complained about the "typename", so I removed it. I removed two unused variables. There was a sign mismatch in a loop counter.
2022-03-07 16:08:22 -08:00
David Eberly fe1bb97ee6 Update BouncingBall physics sample
The change to the interface for PlanarReflectionEffect required changes to the bouncing ball sample application.
2022-03-07 16:07:14 -08:00
David Eberly 007719794e Update PlanarReflectionEffect.cpp
The planar reflection constructor had out-of-order initialization of members, and gcc on Linux complained about this. The Microsoft compilers (2019/2022) did not complain. I also removed a block of code in the constructor (unexposed in a conditional compilation block) that was moved to a class member function.
2022-03-07 16:06:31 -08:00
David Eberly 078206e766 Ported WM5 planar shadows.
I wrote a GTE6 sample application for planar shadows that is similar to the
one for Wild Magic 5. I revised the planar reflections code so that the
two effects have essentially the same design.
2022-03-06 19:45:08 -08:00
David Eberly 0549ffb34b Ported WM5 planar reflection sample to GTE6.
I wrote a GTE6 sample application for planar reflections that is similar to the one for Wild Magic 5. The PlanarReflectionEffect drawing function had a bug. It needed to set the back-face stencil parameters in addition to the front-face stencil parameters. Without the back-face parameters, the reflection caster was drawn on both sides of the reflection plane.
2022-03-04 19:07:18 -08:00
David Eberly 3ae05ee2a7 Modified the return value for minimum width of points.
After looking at the requirements for the feature request, I modified the return value of MinimumWidthPoints2::operator() to be OrientedBox2<T> to be consistent with the minimum-area box code. The sample application now draws the minimum-area box and the minimum-width box for comparison.
2022-03-03 21:34:53 -08:00
David Eberly 70cf07434c Feature request: Modifications related to rotating calipers.
Added an implementation of the rotating calipers algorithm, class RotatingCalipers. The goal was to refactor MinimumAreaBox2 to pull out the rotating calipers. However, this does not work because the minimum-area algorithm uses a pair of rotating calipers that work together. Added a new class MinimumWidthPoints2 that uses the rotating calipers algorithm to compute the width of a 2D point set. For now I have modified the MinimumAreaBox2D sample application to show also the results from computing the width of a point set. I also cleaned up the comments to use current formatting rules. And I added functions to allow passing std::vector inputs rather than raw pointers.
2022-03-03 15:25:26 -08:00
David Eberly 548265fb45 Update ConvexHull2.h
The ConvexHull2 class was supposed to have switched from FPInterval to SWInterval, but I apparently overlooked this. The FPInterval class uses floating-point hardware operations to support interval arithmetic; however, the GCC compiles ignores the changes to the floating-point environment (it does not support modifying the rounding mode of the FPU). The SWInterval class implements interval arithmetic and rounds using software operations.
2022-03-03 15:23:04 -08:00
David Eberly 1aa8ce0786 Update DLODNode.cpp
Two class members were not initialized by the constructor.
2022-03-03 15:21:13 -08:00
David Eberly bcdad4b02e Feature request: Fit cone to ellipse cross section and additional points.
Feature request to fit a cone to known elliptical cross sections and some
additional points (\Code{ApprCone3EllipseAndPoints}). If the cross sections
are provided as point samples approximately on the ellipses, the new code also
includes a class to extract points for each ellipse because the points might
be stored in a file in some unknown order (\Code{ApprCone3ExtractEllipses}).
3D ellipses are then fit to each subset of points in order to obtain the
ellipse input to \Code{ApprCone3EllipseAndPoints}. A PDF has been added to
the documentation to describe the fitting algorithm,
\Code{FitConeToEllipseAndPoints.pdf}.
2022-02-25 10:09:25 -08:00
David Eberly adc96356ef Ported continuous level of detail classes and sample from WM5 to GTE6.
Ported the WM5 classes ClodMesh, CreateClodMesh and CollapseRecord to GTE6 classes CLODMesh, CLODMeshCreator and CLODCollapseRecord. Ported the WM5 sample ClodMeshes to the GTE6 sample CLODMeshes.
2022-02-24 19:26:28 -08:00
David Eberly 7d7b482974 Ported WM5 DLODNode to GTE6.
Ported the DLODNode (dynamic level of detail node) class and DLODNodes sample application from Wild Magic 5 to Geometric Tools Engine 6.
2022-02-11 19:06:02 -08:00
David Eberly 72d12e3125 Ported WM5 SwitchNode to GTE6.
Ported the SwitchNode class and SwitchNodes sample application from Wild Magic 5 to Geometric Tools Engine 6.
2022-02-11 16:20:11 -08:00
David Eberly 8449cff4bc Added missing files
The recently ported physics samples were missing the *.code-workspace files which are needed if you open a single sample application explicitly.
2022-02-11 13:11:47 -08:00
David Eberly 3045d06fbf Modified GenerateProject for Visual Studio Code file generation
The tool only generated Microsoft Visual Studio project/solution files (for MSVS 2019, MSVS 2022). Added support for generating Visual Studio Code workspace files.
2022-02-11 13:10:36 -08:00
David Eberly 3e63d95d62 Posting GTE 6.1.
Updated minor versions in CMakeLists.txt. New files added to GTMathematics. Fixed an incorrect library name in GTMathematicsGPU.
2022-02-07 15:10:15 -08:00
David Eberly 48a954846e Added missing CMake files
These are necessary for the CMake build to succeed :)
2022-02-07 15:08:56 -08:00
David Eberly 9fd7ae0fd4 Create IntrTetrahedron3Tetrahedron3.h
Added a new file for the test-intersection query between tetrahedra using the method of separating axes. This allowed for better performance in BouncingTetrahedra compared to using distance between tetrahedra.
2022-02-07 15:07:15 -08:00
David Eberly 396fc0da83 Update DistTetrahedron3Tetrahedron3.h
The algorithm I implemented for distance between tetrahedra was not robust because of testing for containment of vertices of one tetrahedron in another. I modified it to test centroids instead.
2022-02-07 15:06:51 -08:00
David Eberly c3966d36c7 Modified the Tetrahedron3 class.
The Tetrahedron3 class has additional framework to support computing normals at features (vertices, edges, faces). The DistPoint3Tetrahedron3 query was modified because of an interface change in Tetrahedron3.
2022-02-07 15:06:24 -08:00
David Eberly 061910539f Update RigidBody.h
I factored out the impulse computations from the physics samples and moved them to RigidBody. The code now can be shared by the applications.
2022-02-07 15:05:26 -08:00
David Eberly 5f781c0c15 Ported WM5 BouncingTetrahedra to GTE, updated BouncingSpheres to have consistent framework
Ported the Wild Magic 5 physics sample BouncingTetrahedra to GTE. The port of BouncingSpheres was modified so that the two samples have the same conceptual framework.
2022-02-07 15:05:02 -08:00
David Eberly 500fc05b2a Update WrigglingSnakeWindow3.h
Fixed a compiler error on Linux for a mismatch in size_t and int32_t. Changed the type of mNumCtrlPoints and mDegree to size_t.
2022-02-07 15:02:21 -08:00
David Eberly 66abc3e993 Update IntrOrientedBox3OrientedBox3.h
Fixed comments in the file.
2022-02-07 15:01:07 -08:00
David Eberly 31f3e1102d Update of build-all solutions.
Added missing projects from the MSVS 2019 build-all solutions. Added new build-all solutions for MSVS 2022.
2022-02-07 15:00:38 -08:00
David Eberly 8838f069df Update of build-all solutions for Microsoft Visual Studio.
Added missing projects from the MSVS 2019 build-all solutions. Added new
build-all solutions for MSVS 2022.
2022-02-03 14:59:42 -08:00
David Eberly 6cad0fe77a Modified files that use ComputeBarycentrics.
The change in interface for ComputeBarycentrics required other files to be updated.
2022-02-01 11:17:10 -08:00
David Eberly 1cdc2e496f Update README.md
Modified to indicate the supported Microsoft Visual Studio versions, and supporting LLVM clang-cl and Intel C++ Compiler 2022.
2022-02-01 11:00:15 -08:00
David Eberly 5f92892abc Updated GTMathematics project files.
Updated project files that reference the newly added mathematics header files.
2022-02-01 10:51:33 -08:00
David Eberly b8740090ce Update DistTriangle3Triangle3.h
Updated a comment to be consistent with other distance-query comments.
2022-02-01 10:45:25 -08:00
David Eberly fd91d04952 Update Tetrahedron3.h
Added a function for computing the centroid of a tetrahedron.
2022-02-01 10:41:35 -08:00
David Eberly dbbbe70001 Modified ComputeBarycentric interfaces.
Modified the interfaces for computing barycentric coordinates. The raw arrays
bary[] were replaced by std::array objects. Replaced other raw arrays with std::array objects.
2022-02-01 10:40:02 -08:00
David Eberly cab7800cf6 Create DistTetrahedron3Tetrahedron3.h
Added new file that implements tetrahedron-tetrahedron query. This is needed for the port of BouncingTetrahedra from Wild Magic 5 to Geometric Tools Engine.
2022-02-01 10:33:29 -08:00
David Eberly e7d13ddc35 Create ContTetrahedron3.h
Added new file that implements point-in-tetrahedron query. This is needed for the port
of BouncingTetrahedra from Wild Magic 5 to Geometric Tools Engine.
2022-01-31 14:10:55 -08:00
David Eberly 1e34639442 Update DistPoint3Tetrahedron3.h
The point-tetrahedron distance query code failed to compile because of a mismatch in index type. (Reorganization of my internal tools caused the template instantiation tool not to launch when Tetrahedron3 was modified.
2022-01-30 19:14:29 -08:00
David Eberly c4b44b02de Modified BouncingSpheres physics sample.
I modified the sample application to allow the spheres to spin based on angular momentum, taking into account transfer of momentum during colliding contact. This required a different algorithm for impulsive function construction than what is in "Game Physics, 2nd edition" (Section 6.2.2). The algorithm details are in a new document at my website, ComputingImpulsiveForces.pdf. I also added friction to stop eventually the spheres from sliding and spinning when they are on the floor. Eliminated the texture seam by hacking it to a toroidal texture. Modified the RigidBody interface for simpler presentation of the Runge-Kutta solver steps and to make it clear the dependency between physics parameters and quantities derived from them (to support synchronizing the state).
2022-01-26 11:26:22 -08:00
David Eberly 2ae235e358 Update ApprOrthogonalPlane3.h
The function FitIndexed has tests for the components of mean being finite floating-point numbers. The test for mean[2] was missing.
2022-01-17 19:53:55 -08:00
David Eberly 52faae0dc0 Update Tetrahedron3.h
Converted the GetFaceIndices function to static because the indices for the triangular faces are the same no matter which tetrahedron. Added also the static function GetAllFaceIndices to access the entire array of indices as a single object; this is useful for index buffers associated with tetrahedra.
2022-01-17 19:53:29 -08:00
David Eberly a963056d40 Minor changes to the BouncingSpheres sample.
I replaced the hard-coded physics time steps by a physics clock that requires the simulation to run at 60 frames per second. I also added comments that the physics implementation is based on Section 6.6 of my Game Physics book (2nd edition).
2022-01-16 09:32:42 -08:00
David Eberly 6d7ce0d2c9 Update RigidBody.h
The SetMass function had type 'float' rather than the template parameter 'Real'. (This should have been checked in with the previous push for BouncingSpheres.)
2022-01-15 11:45:49 -08:00
David Eberly 3f506fe31a Ported the WM5 sample BouncingSpheres to GTE6.
I ported the Wild Magic 5 physics sample BouncingSpheres to GTE 6. The sample illustrates impulse-based physics for a collection of spheres. I refactored the code so  that the physics portion is isolated to the PhysicsModule.* files. Update the CMake list of projects for physics.
2022-01-14 21:09:53 -08:00
David Eberly 10272a085d Ported WaterDropFormation from WM5 to GTE6.
I ported the Wild Magic 5 physics sample WaterDropFormation to GTE 6. Updated the CMake list of projects for physics.
2022-01-12 12:12:29 -08:00
David Eberly 8422715a38 Fixed file versions, added hyperlinks to PDF
Fixed the file versions to show 6.1 instead of 6.0 to be consistent with my versioning rules. Added hyperlinks to the website PDF that describes some simple friction-based algorithms.
2022-01-12 12:11:24 -08:00
David Eberly e0bfeb7d2d Ported a Wild Magic 5 sample application to GTE 6.
I ported the Wild Magic 5 physics sample WrigglingSnake to GTE 6. Updated the CMake list of projects for physics.
2022-01-11 11:34:53 -08:00
David Eberly a23a729150 Ported friction-based physics samples from WM5 to GTE6.
I ported the Wild Magic 5 physics samples to GTE 6, the ones involving friction.
2022-01-10 18:42:13 -08:00
David Eberly b1e0867bb8 Removed post-build copy of executables.
I removed the post-build copies of the executables to the folder GeometricTools/GTE/Executable. The tools are used infrequently enough that I now run them from their _Output folders. Naturally, you can manually copy the executables to where you want them.
2022-01-10 18:41:29 -08:00
David Eberly 19cd0885d2 Restored commented-out code.
I had commented out code while generating the MSVS 2022 projects. Removed the comments to generate MSVS 2019 and MSVS 2022 projects with source files.
2022-01-09 23:25:09 -08:00
David Eberly b4708998d3 Oops, accidentally uploaded my internal folder.
Removing folder that should not be under source control.
2022-01-09 22:26:43 -08:00
David Eberly a1fa45f533 Added and removed MSVS projects and solutions.
I added projects and solutions for Microsoft Visual Studio 2022. I removed the Microsoft Visual Studio 2015 projects and solutions because that version of the IDE reached mainstream end date on October 13, 2020. Microsoft Visual Studio 2017 reaches its mainstream end date on April 12, 2022. However, I have also removed the Microsoft Visual Studio 2017 projects and solutions because I do not have enough time to maintain so many versions of the compiler. From now on, I will support two versions of MSVS, the current one (whatever that is) and the previous one.

The Tools folder has various projects that were expanded to include projects and solutions for MSVS 2022. The \Code{GenerateProject} tool has been modified to generate only MSVS 2019 and MSVS 2022 projects and solutions.
2022-01-09 22:22:17 -08:00
David Eberly bf87faf8b0 Update README.md
Modified to indicate that Microsoft Windows 11 is also supported.
2022-01-07 23:30:44 -08:00
David Eberly cceb9c0c87 Update README.md
Removed the citation block.
2022-01-06 14:18:27 -08:00
David Eberly 0cbd458d45 Posting Geometric Tools Engine 6.0
The major revision is based on running the code analysis tools for Microsoft Visual Studio 2019 16.11.8 and for ClangCL. The reported issues were addressed with the exception of some incorrect warnings from MSVS 2019. For now, the incorrect warnings are encapsulated by pragma commands and will be removed in the GTL development track.

The MSVS code analysis tool is not robust. Sometimes warnings occur in both the Output and Error List windows. Sometimes they occur in only one or the other window but not both. And sometimes they do not occur in either window, but the 3-dot markers show up in source files that are opened after which the warnings show up in the Error List window. As I discover source files where the warnings show up only when the source file is opened, I will fix the issues. I believe most of these will be warnings about potentially uninitialized variables, typically for class objects whose default constructors should be called but MSVS seems to believe the class members are not initialized. This is the case for the Vector classes, but in the code using these classes, the members are set soon after the declaration. I was hoping the tool would figure out that the member initialization was deferred. If I were to allocate a  td::vector of Vector with a very large number of elements, and the code fills them in by loading data from a file, it would be a shame to waste all that time having the constructor initialize the members only to fill them in again from the loaded data.

Another tool issue occurred with SymmetricEigensolver.h, in the GetEigenvector function. I have comments in that file about why the tool report is incorrect. For a long time I have been able to ignore the warning because code using it compiles fine, even with "treat warnings as errors". The warnings occurred as part of a regular source-code build. For the first time I ran the code analyzer explicitly from the MSVS IDE menu on a source file that contains only the include of the aforementioned header file. The report now includes more warnings that appear to be based on the same incorrect diagnosis. The original warning was about a potential out-of-range index, and the Error List window allows you to drop-down a list of steps and assumptions to support the diagnosis. The new warning is about the same issue but for some reason displays a list of line numbers that show up in the drop-down list. After these new warnings occurred, I can no longer successfully build code using the eigensolver. I had to add pragma commands to prevent the warnings. After that, a couple of other files generated similar warnings that had to be disabled using pragma commands.

I had also spent a lot of time eliminating the warning about preferring scoped enumerations over unscoped ones. The unscoped ones typically defined enumerants that were used as array indices in the DX11 and GL45 engine code. This is not allowed with scoped enumerations. I replaced the unscoped enumerations with nested structs, each structure containing constant expressions of the form "static uint32_t constexpr someName = someValue;". MSVS 2019 and ClangCL provided with MSVS 2019 allowed this modification, but unfortunately gcc on my Linux boxes did not. Searching stackoverflow, it appears that C++ considers such structs to be "incomplete". I actually got linker errors about the various constants referenced by the sample applications but not found in the libraries linked to the applications. I restored the unscoped enumerations and disabled the code analysis warning number
in the project settings.

A couple of the sample applications use BSRational<UIntegerFP<N>> where N is large. These lead to code analysis warnings about "/analyze:stacksize numKBs" indicating that numKBs is larger than the maximum stack size and the you should consider moving data from the stack to the heap. The samples have run correctly without stack overflow errors, so it is not clear to me what the problem is. Regardless, I modified the project settings and specified numKBs large enough to avoid the warnings. When I switched to using ClangCL, the compiler complains it cannot find files named "/analyze:stacksize". It appears that ClangCL does not understand this analysis tool option. Unfortunately, with "treat warnings as errors", those sample applications will not compile. So I removed the setting of numKBs and then disabled the code analysis warning number in the project settings.
2022-01-06 14:12:43 -08:00
David Eberly 66666575cb Update Delaunay3.h
Improved the performance of Delaunay3 by using the newly modified TSManifoldMesh and by including interval arithmetic with the rational arithmetic in ToPlane and ToCircumsphere to amortize the cost of the computations. In many cases, interval arithmetic can determine the signs of determinants using only floating-point arithmetic which avoids the more expensive rational-only arithmetic. For a user-supplied dataset of over 3066 points and executing on an Intel i9-10900 processor, the following measurements were made for float with compute type BSNumber<UIntegerFP32<44>> and for double with compute type BSNumber<UIntegerFP32<330>>. The old code Delaunay3<InputType,ComputeType> required 3611 milliseconds for float input and 3858 milliseconds for double. The new code Delaunay3<T> required 1274 milliseconds for float and 1280 milliseconds for double. The old code is deprecated, to be removed in GTL, but the current file still contains it in addition to the new code.
2021-12-28 15:03:08 -08:00
David Eberly ad1272fe8a Update TSManifoldMesh.h
Improved the performance of TSManifoldMesh, replacing std::map by std::unordered_map, replacing std::shared_ptr by std::unique_ptr and replacing std::weak_ptr by raw pointers.
2021-12-28 14:59:52 -08:00
David Eberly 16ee9e75bf Update Delaunay2.h
Updated some comments. The maximum values of N listed for UIntegerFP32<N> with double input were incorrect (much too large).
2021-12-28 14:58:40 -08:00
David Eberly d99f2cd446 Posting GTE-version-5.15
The latest code updates, bug fixes and documentation.
2021-12-21 21:35:08 -08:00
David Eberly 528815aeb4 New code and document for box-cylinder test-intersection query.
Removed the LCP solver approach for the test-intersection query between a box and a finite cylinder. The approach turned out to work correctly when using exact arithmetic but in some configurations had significant rounding errors when using floating-point arithmetic. The code has been modified using the third algorithm described in https://www.geometrictools.com/Documentation/IntersectionBoxCylinder.pdf
2021-12-21 21:34:35 -08:00
David Eberly 5b88fa73db Clang-based modifications, tested with MSVS 2019 16.11.8 using C++ clang tools for Windows (12.0.0).
I updated the file versions on the previous push of source code.

The DX11Engine.h file needed the "override" modifier.

GL45Engine.cpp has "(char*)0+offset", which I modified to use reinterpret_cast.

GL45InputLayout constructor has an unused parameter, removed it.

Added braces to initialize subobjects in MarchingCubes.h.

In RootsBisection2.h, the YFunction lambda had a 'this' parameter but did not use it, removed the parameter.

WICFileIONative.cpp uses PROPBAG2 and VARIANT which clang complained about in multiple ways. I made enough changes to get the file to compile. The code probably needs to use the CCom* wrapper to encapsulate VARIANT. Better yet is for Microsoft to rewrite the Windows SDK header files to eliminate the code analysis complaints.

Cylinder3.h has a mechanism similar to Cone3.h to distinguish between finite and infinite cylinders.

I clarified a comment in AlignedBox.h about vertex extraction.
2021-12-20 21:15:53 -08:00
David Eberly 75cfcec1a0 Merge pull request #35 from tbridel/hotfix/error_unused_variables
Fix some unused variables triggering an error during compilation
2021-12-20 09:49:01 -08:00
David Eberly 348d4aeee3 Merge pull request #34 from tbridel/hotfix/missing_override_keyword
Fix missing 'override' keyword in BaseEngine daughter classes
2021-12-20 09:43:52 -08:00
tbridel 1bb5fcdf16 One more unused variable. 2021-12-20 17:57:59 +01:00
tbridel 4076e93236 Fix some unused variables triggering an error during compilation 2021-12-20 17:53:38 +01:00
tbridel 45da511328 Fix missing 'override' keyword in BaseEngine daughter classes 2021-12-20 14:22:14 +01:00
David Eberly 92d14e79f5 Merge pull request #32 from tbridel/hotfix/cmake_options
Fix CMake options
2021-12-19 10:37:01 -08:00
tbridel a403c3d506 Fix CMake options everywhere (BUILD_SHARED_LIB & BUILD_RELEASE_LIB had commas) 2021-12-19 14:25:30 +01:00
tbridel 46aaf929bf Fix CMake options in MathematicsGPU 2021-12-19 14:21:58 +01:00
tbridel b42921d496 Fix CMake options in Graphics 2021-12-19 14:21:27 +01:00
tbridel 87ae029fd4 Fix CMake options for Applications 2021-12-19 14:20:56 +01:00
David Eberly 21e3c12fbe Update README.md
LaTeX habits are burned into my brain. Fixing the URL.
2021-12-03 16:32:30 -08:00
David Eberly 8b624cf9d7 Update README.md
The support queue will change frequently enough that I moved the queue items to a PDF at my website. This avoids constantly modifying the README.md file.
2021-12-03 16:29:51 -08:00
David Eberly 4e8672c98a Update Hyperplane.h
Added a comment that you cannot set the plane.origin and plane.constant independently (with an example of why not).
2021-12-01 12:34:00 -08:00
David Eberly d995587f6c Fixed code for the intersection of a plane and a cylinder.
The source code failed when the plane normal and cylinder axis direction were parallel. The mathematical derivation in the document IntersectionPlaneCylinder.pdf was incorrect because it overlooked the singularity when computing the major axis of the ellipse of intersection. The PDF was rewritten and describes a different major axis construction. The new source code implements this. Moreover, it also now supports both finite and infinite cylinders (test-intersection and find-intersection queries).
2021-12-01 12:26:59 -08:00
David Eberly ce1e9f8b25 Update README.md
Update to show that GTE now runs on Fedora 35 with gcc 11.2.1.
2021-11-28 16:56:33 -08:00
David Eberly a382e73650 Update README.md
One of these days I will learn to spell better (replaced "never ending" by "neverending".
2021-11-28 15:58:04 -08:00
David Eberly 6840c2b091 Update README.md
I added a section on the current technical support queue.
2021-11-28 15:26:13 -08:00
David Eberly ea207c54f1 Added implementations for Sections 8.6 and 8.7 of the "Geometric Tools for Computer Graphics" book.
Added implementations of two algorithms in "Geometric Tools for Computer Graphics" (Sections 8.6 and 8.7) at user request. The implementation for the algorithm of Section 8.6 differs from that of the book--a simpler approach is used, described in the file comments. The book has pseudocode for the algorithm in Section 8.7, but there are numerous errors. I have added the corrections to the book correction page at the website. The approach I used is described in the file comments.
2021-11-28 15:25:48 -08:00
David Eberly 27ecbb8c15 Update SingularValueDecomposition.h
MSVS 2015 complained that std::greater was undefined. I added the include of header <functional> to access the definition. MSVS 2015 also complained about unchecked iterators when using std::copy. I replaced the std::copy calls by C++ loops. I will be quite happy when MSVS 2015 reaches end-of-life.
2021-11-28 15:24:02 -08:00
David Eberly 28d75abe58 Redesign of Logger system, initialization of class members
This is a major update. I removed the logging aspect of the "logger" system. Now all that Logger.h exposes are macros for assertions and errors that throw exceptions. This avoids duplicate symbol error messages from a linker when the Logger.h constructor is not inlined in all modules that are linked together. Also, I started the process of ensuring constructors initialize all members (using MSVS 2019 code analysis to find such issues). Many files have been modified as a result of the changes, although the LogAssert and LogError statements still exist (but only throw exceptions). To see a full list of changes, visit my Geometric Tools downloads page and click on the GteUpdateHistory.pdf file.
2021-11-19 20:45:30 -08:00
David Eberly 7355b247c4 Update SingularValueDecomposition.h
The bookkeeping for decomposing the bidiagonal matrix into a block matrix with bidiagonal blocks was not working correctly when a superdiagonal entry was zero. I decided to revisit every piece of the SVD code and updated the unit tests to ensure the code is working properly. The output of the SVD now produces only a singular-value matrix with diagonal elements occurring in descending order. The interfaces were modified slightly. (This is a significant revision of the code.)
2021-11-19 16:07:05 -08:00
David Eberly 0108088359 Update SymmetricEigensolver2x2.h
The sortType is an integer type that needs to be cast to a Real type. Replaced the raw diagonal[2] by a std::array object.
2021-11-19 16:05:54 -08:00
David Eberly 0c96b87c3a Update TriangulateCDT.h
The previous version had a bug fix in the non-deprecated version of FillRegion. I also added that fix to the deprecated version in case folks are still using it.
2021-11-19 16:04:58 -08:00
David Eberly b51c7fb49e Update TriangulateCDT.h
In FillRegion, accessing tkey from the front of regionQueue using a const reference is incorrect, because the next line of code is a pop of the queue which invalidates the memory, corrupting the value of tkey. A copy must be made of the front of the queue. Thanks to Aaron Barony for tracking down the problem.
2021-11-02 15:27:23 -07:00
David Eberly 0c097fd30a Fixed project/solution settings.
The project settings had incorrect paths to the dependent libraries and to the GTE header files.
2021-10-20 16:03:02 -07:00
David Eberly 35ad23e050 Create CMakeLibrariesAndSamples.sh
Added a new file to build libraries and samples together on Linux. The directions for use and the command-line parameters are the same as for CMakeLibraries.sh.
2021-10-20 15:43:23 -07:00
David Eberly e570d1e6c2 Initialize class members, convert from enum to enum class.
Modified "enum Type" to "enum class Type". Added initialization of class members in the constructors.
2021-10-20 15:42:08 -07:00
David Eberly 054b973acf Update ConvexMesh3.h
Added initialization of class members to the constructor. Switched to using int32_t instead of int.
2021-10-20 15:35:30 -07:00
David Eberly b464a1e91e Update DistOrientedBox3Cone3.h
Replaced "SomeClass<3, T>" by "SomeClass3<T>" for consistency when implementing 3-dimensional algorithms.
2021-10-20 15:34:43 -07:00
David Eberly 41bb020d86 Initialize closest[] members.
GTE Vector constructors do not initialize their data (GTL does). Added an initialization of closest[].
2021-10-20 15:33:43 -07:00
David Eberly 1f2c9f8be3 Initialization of Result members.
Added initialization of class members to the Result constructors. Renamed closestPoint[] to closest[] in DistPoint3ConvexPolyhedron3.h.
2021-10-20 15:31:28 -07:00
David Eberly b2eb683929 Update DistPoint3Cylinder3.h
Modified the Result structure to have a squared-distance member and an array of two closest points, the input point and the closest cylinder point. Added initialization of class members to the Result constructor.
2021-10-20 15:28:54 -07:00
David Eberly 21fb886c9e Update DistPoint3Frustum3.h
Modified the Result structure to have an array of two closest points, the input point and the closest frustum point. Added initialization of class members to the Result constructor.
2021-10-20 15:27:30 -07:00
David Eberly fba08dcd6e Update Ellipse3.h
Modified the axis member to be of type std::array. Moved the initialization of axis to the initializer portion of the constructor.
2021-10-20 15:25:57 -07:00
David Eberly 66de61e1ec Port to GTL, modified GTE track to match.
Ported the GTE code to GTL with modifications in both tracks, more comments and
unit tests.
2021-10-20 15:24:56 -07:00
David Eberly 9a68ca0999 Initialization of Result members.
Added initialization to the Result structures.
2021-10-20 15:22:32 -07:00
David Eberly 62b9df456c Update LCPSolver.h
Modified "enum Result" to "enum class Result". Added initialization to the Variable constructor.
2021-10-20 15:21:13 -07:00
David Eberly 53d82425c3 Updated minor version to 13.
The pushes before the tag of GTE 5.13 should have included modified CMakeLists.txt files (with minor version changed from 12 to 13).
2021-10-19 13:48:34 -07:00
David Eberly 864bf93549 Merge pull request #28 from avilleret/feature/cmake_option
add option and set PROJECT_SOURCE_DIR to make it easier to build
2021-10-19 13:33:57 -07:00
Antoine Villeret 6d728eaa94 add option and set PROJECT_SOURCE_DIR to make it easier to build 2021-10-19 21:52:49 +02:00
David Eberly dcc4e04561 Graphics buffer modifications for performance.
The application created an index buffer for each tetrahedron, but only one index buffer is needed and can be shared by all tetrahedra. The vertex buffer for each tetrahedron created enough space for all the points in the dataset, but only 4 vertices are needed per buffer.
2021-10-15 14:07:51 -07:00
David Eberly 422f11365a Update SeparatePoints3.h
The numTriangles1 variable was initialized incorrectly.
2021-10-12 22:47:29 -07:00
David Eberly 9167f559d3 Modifications to some intersection queries.
Fixed a bug where the return value was not of type Result. The Result constructor had an input inEpsilon, but the caller of operator()(...) has no chance to specify this. The operator function now has a third parameter epsilon, defaulted to 0 to avoid breaking application code. The addition of 'explicit' to the Result constructor in IntrTriangle3Cylinder3 appears to be unnecessary because all branches the code can take have a return of a Result object. It is not possible to reach the end of the if-else statements without exiting, so there is no need for a return statement as the last line of the function. However, I modified the code to set result.intersect in each of the locks and added a single return statement as the last line in the function.  [Replacement of template Real by T is a flag to remind me I have ported and tested the code in the GTL development track. GTL also eliminates the annoyance of 'int' versus 'size_t' indexing. Inclusion of default-constructor braces is to avoid Visual Studio's code analyzer warning about potential uninitialized variables when in fact is is provable they are.]
2021-09-30 23:06:51 -07:00
David Eberly 4ac598dc24 Merge pull request #27 from aG-MathWorks/master
Fixed undefined behavior bug due to unintentional implicit cast.
2021-09-30 22:01:16 -07:00
Alex Goldberg b650268d17 Fixed undefined behavior bug due to unintentional implicit cast.
- Switched to explicit constructor to avoid similar bugs in the future.
- Added explicit to several other Result constructors

Resolves #26
2021-09-30 20:36:04 -07:00
David Eberly bf7f357610 Update IntrPlane3Circle3.h
Several of the Result members in the FIQuery were uninitialized. Added initialization in the default constructor for Result. Removed the isPoints member (not essential to the query), setting numIntersections to the maximum size_t to indicate when the circle is contained fully by the plane.
2021-09-29 15:20:31 -07:00
David Eberly 429f31dc9b Update SymmetricEigensolver3x3.h
The August 24, 2021 modification replaced the GTE Math.h by the C++ header <cmath>. The eigensolver code also needs <limits>which Math.h provided. The code compiled with Microsoft Visual Studio 2019 (latest) and Ubuntu 20.04.1 LTS gcc 9.3.0 but not Fedora 34 gcc 11.1.1.
2021-09-25 13:45:45 -07:00
David Eberly a2e885d126 Update PdeFilter3.h
The function GetUyy had F[zp1][yp1][zp1], but it should be F[zp1][yp1][xp1].
2021-09-25 12:35:09 -07:00
David Eberly c6f752d6ca Update BSplineCurveFit.h
Fixing the comment about the numControls constraints was the first step. Changing the code that asserts the constraint is satisfied is the second step.
2021-09-23 21:12:27 -07:00
David Eberly 0778fe2322 Fixed type of mask in constructors.
The 'mask' type in the constructors was 'bool const*', which is from old code that was ported. The type should be instead 'int const*'. It is not clear why the compilers allowed assignment of a 'bool' to an 'int' without warnings/errors.
2021-09-23 17:24:03 -07:00
David Eberly 9bfa4d9552 Update BSplineCurveFit.h
Fixed a comment about the constraints on the number of control points.
2021-09-23 16:59:23 -07:00
David Eberly 2f3fea1ae1 Minor fixes to SurfaceExtractorMC and SurfaceExtractorCubes.
An occurrence of 'float' should have been 'Real' in the second Extract function of SurfaceExtractorMC.h. The expressions in GetGradient of SurfaceExtractorCubes.h using the 'float' number 1.0f needed to have '(Real)1'.
2021-09-23 16:15:20 -07:00
David Eberly 022ea5a3c4 Update DistPoint3Circle3.h
In the tests for modifying DistPoint3Circle3.h, the Logger.h header was implicitly included in the environment before the query header file. The inclusion must be explicit.
2021-09-20 12:01:23 -07:00
David Eberly 9e537c3a5e Update DistPoint3Circle3.h
The source code did not match the description for computing the distance robustly in the PDF entitled "Distance to Circles in 3D" (Section 2). It computed a closest point first, which was not robust, and then computed the distance using the input point and that closest point. The robustness problem occurs when the input point is nearly on the normal line C+tN, where C is the circle center and N is a unit-length normal to the plane of the circle. The distance computation now matches the PDF and is robust. The closest-point code was revised to be robust, and the PDF was expanded to describe the new code.
2021-09-19 23:08:23 -07:00
David Eberly 7c68eb09e9 Update ApprPolynomialSpecial3.h
Two loops in DoLeastSquares had incorrect upper bounds.
2021-09-07 17:16:28 -07:00
David Eberly fd48bf6557 Update ApprCone3.h
Fixed a bug in the last blocks of code in function ApprCone3::ComputeInitialCone. The roots were supposed to be searched for the minimum, but the code for updating minItem did not update minError. The quartic roots are generally stored in increasing order except when a repeated root 0 is found (for the depressed quartic). The cone fitting should not lead to a root of 0, so the previous code worked. The least-squares fitting PDF at the Geometric Tools website was updated accordingly.
2021-09-07 13:06:08 -07:00
David Eberly cf47c3fdf9 Added a test-intersection query for two finite cylinders.
Implemented the test-intersection query for two finite cylinders that is described in IntersectionOfCylinders.pdf. The original version of the PDF showed that generally computing a separating axis requires minimizing a convex function. No details were provided about implementing the minimizer. In an attempt to implement the query, it was clear that a deeper analysis was required. The latest version of the PDF has those details. Added a sample application to illustrate the ideas.
2021-09-05 22:59:50 -07:00
David Eberly 69b9121d5b Update SymmetricEigensolver3x3.h
The GetCosSin function was failing when the floating-point model was set to /fp:fast instead of the default model /fp:precise used by GTE. The function was simplified to avoid the problem. The PDF documentation "A Robust Eigensolver for 3x3 Symmetric Matrices" and the source code were revised to match each other. The PDF file is https://www.geometrictools.com/Documentation/RobustEigenSymmetric3x3.pdf
2021-08-24 18:06:27 -07:00
David Eberly 2381a3bd68 Major revision of distance-query subsystem.
Most of the distance subsystem of GTE was revised or rewritten, mainly to avoid the LCP solver which was a performance problem when object features were (nearly) parallel. The subsystem consists of linear algebraic objects: point, line, ray, segment, triangle, rectangle, plane, box. The Result objects now have constructors that initialize the members explicitly, and the member names are consistent among files. Derivation of distance queries involving aligned boxes and oriented boxes was removed by factoring out canonical boxes, which are aligned boxes with centers
at the origin. An aligned box can be reduced to a canonical box by a translation. An oriented box can be reduced to a canonical box by a rotation and a translation. Unit tests were updated, and some classes needed unit testing. Validation of the unit-test results was performed using convex quadratic programming in Mathematica (via NMinimize).

Several bugs were discovered and fixed. DistPointOrientedBox.h had a template alias using AlignedBox when it should have used OrientedBox. DistSegment3OrientedBox3.h had segExtent instead of -segExtent in the last else-block. DistSegment3Rectangle3.had segExtent instead of -segExtent in the last else-block.

AlignedBox has a new member function GetVertices.

Hyperplane has a new member 'origin', a point on the hyperplane.

DistPoint3Rectangle3.h is obsolete, replaced by DistPointRectangle.h (distance in any dimension). DistPoint3Plane3 is obsolete, replaced by DistPointHyperplane.h (distance in any dimension).

DistPointTriangleExact.h is obsolete, its code moved into DistPointTriangle.h DistSegmentSegmentExact.h is obsolete, its code moved into DistSegmentSegment.h.
2021-08-02 16:19:01 -07:00
David Eberly 127c46ef27 Reordered the coefficients of ApprQuadratic* to match that of QuadricSurface.
Reordered the coefficients of the fitted quadratic functions. Modified the coefficients argument to use std::array. This allows the array of output coefficients of ApprQuadratic3::operator() to be passed directly as an input to the QuadricSurface constructor. NOTE: The reordering will affect any of your applications that use the quadratic approximations.
2021-07-13 00:16:50 -07:00
David Eberly 9f0f89bd92 Update IntrRay2Triangle2.h
Fixed a copy-and-paste error that should have been trapped by my instantiation tool; replaced T by Real.
2021-06-21 23:46:12 -07:00
David Eberly a4aa8cb30f Update DistPointRay.h
When the line parameter for the point-ray distance test is negative, the Result.parameter member was not clamped to $0$.
2021-06-21 23:45:48 -07:00
David Eberly 9de411b490 Update README.md
My Fedora Linux machine has been upgraded to Fedora 34 with gcc 11.1.1.
2021-06-21 20:03:29 -07:00
David Eberly 44de52631a Added new file to project.
The GTMathematics files needed to be updated to include the new file IntrTriangle3Triangle3.h.
2021-06-20 19:37:02 -07:00
David Eberly 801fc970e3 Create IntrTriangle3Triangle3.h
Ported from Wild Magic to GTE the test-intersection and find-intersection queries for two stationary triangles in 3D. The template type can be floating-point, but rounding errors can cause misclassifications when two triangles are nearly touching. The template type can also be an arbitrary precision type, such as BSRational<UIntegerAP32>, and the intersection set (if any) is theoretically correct.
2021-06-20 16:37:55 -07:00
David Eberly 5faf0ac03c Relaxed restriction for line to have unit-length direction vector.
Modified the 2D line-triangle find-intersection query to allow for Line2 objects with direction vectors that are not unit length. This is necessary to support exact arithmetic in the forthcoming port of IntrTriangle3Triangle3 from Wild Magic to GTE. This query projects points from 3D to 2D and calls the IntrSegment2Triangle2 query.

NOTE: The modified IntrSegment2Triangle2 is a breaking change if you were accessing the Result.parameter[] values. In the previous code, the Result.parameter[] values were relative to the center-direction-extent form of the segment, where t in [-e,e] for extent e. The modified code does not convert the segment to center-direction-extent form in order to avoid floating-point rounding errors when computing the unit-length direction vector. Consequently, the modified code now has Result.parameter[] values relative to [0,1] where the segment is parameterized by p[0] + t (p[1] - p[0]) for t in [0,1].
2021-06-17 17:22:58 -07:00
David Eberly 327a62b693 Cosmetic changes to some line-object intersection queries.
Cosmetic changes to make the post-line-query code the same for all find-intersection queries of the code modified in the June 14, 2021 entry.
2021-06-17 17:18:59 -07:00
7260 changed files with 399224 additions and 409846 deletions
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/Application.h>
@@ -15,3 +15,5 @@ Application::Application(Parameters const& parameters)
mProgramFactory(parameters.factory)
{
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.09.15
// File Version: 8.0.2025.05.10
#pragma once
@@ -56,3 +56,5 @@ namespace gte
std::shared_ptr<ProgramFactory> mProgramFactory;
};
}
+5 -5
View File
@@ -1,8 +1,9 @@
project(gtapplications VERSION ${GTE_VERSION_MAJOR}.${GTE_VERSION_MINOR})
cmake_minimum_required(VERSION 3.10)
cmake_minimum_required(VERSION 3.8)
option(BUILD_RELEASE_LIB, "Build release library" OFF)
option(BUILD_SHARED_LIB, "Build shared library" OFF)
project(gtapplications VERSION ${GTE_VERSION_MAJOR}.${GTE_VERSION_MINOR})
option(BUILD_RELEASE_LIB "Build release library" OFF)
option(BUILD_SHARED_LIB "Build shared library" OFF)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
@@ -30,7 +31,6 @@ Command.cpp
ConsoleApplication.cpp
Environment.cpp
GTApplications.cpp
LogReporter.cpp
OnIdleTimer.cpp
Timer.cpp
TrackBall.cpp
+54 -52
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2026.02.16
#include <Applications/GTApplicationsPCH.h>
#include <Applications/CameraRig.h>
@@ -47,13 +47,13 @@ void CameraRig::ComputeWorldAxes()
}
}
bool CameraRig::PushMotion(int trigger)
bool CameraRig::PushMotion(int32_t trigger)
{
auto element = mIndirectMap.find(trigger);
return (element != mIndirectMap.end() ? SetActive(element->second) : false);
}
bool CameraRig::PopMotion(int trigger)
bool CameraRig::PopMotion(int32_t trigger)
{
auto element = mIndirectMap.find(trigger);
return (element != mIndirectMap.end() ? SetInactive(element->second) : false);
@@ -68,7 +68,7 @@ bool CameraRig::Move()
// idle loop.
if (mNumActiveMotions > 0)
{
for (int i = 0; i < mNumActiveMotions; ++i)
for (int32_t i = 0; i < mNumActiveMotions; ++i)
{
(this->*mActiveMotions[i])();
}
@@ -151,20 +151,20 @@ void CameraRig::TurnRight()
Matrix4x4<float> incremental = Rotation<4, float>(
AxisAngle<4, float>(mWorldAxis[1], -mRotationSpeed));
#if defined(GTE_USE_MAT_VEC)
mWorldAxis[0] = incremental * mWorldAxis[0];
mWorldAxis[2] = incremental * mWorldAxis[2];
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#else
#if defined(GTE_USE_VEC_MAT)
mWorldAxis[0] = mWorldAxis[0] * incremental;
mWorldAxis[2] = mWorldAxis[2] * incremental;
mCamera->SetAxes(
mCamera->GetDVector() * incremental,
mCamera->GetUVector() * incremental,
mCamera->GetRVector() * incremental);
#else
mWorldAxis[0] = incremental * mWorldAxis[0];
mWorldAxis[2] = incremental * mWorldAxis[2];
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#endif
}
}
@@ -176,20 +176,20 @@ void CameraRig::TurnLeft()
Matrix4x4<float> incremental = Rotation<4, float>(
AxisAngle<4, float>(mWorldAxis[1], +mRotationSpeed));
#if defined(GTE_USE_MAT_VEC)
mWorldAxis[0] = incremental * mWorldAxis[0];
mWorldAxis[2] = incremental * mWorldAxis[2];
mCamera->SetAxes(
incremental*mCamera->GetDVector(),
incremental*mCamera->GetUVector(),
incremental*mCamera->GetRVector());
#else
#if defined(GTE_USE_VEC_MAT)
mWorldAxis[0] = mWorldAxis[0] * incremental;
mWorldAxis[2] = mWorldAxis[2] * incremental;
mCamera->SetAxes(
mCamera->GetDVector() * incremental,
mCamera->GetUVector() * incremental,
mCamera->GetRVector() * incremental);
#else
mWorldAxis[0] = incremental * mWorldAxis[0];
mWorldAxis[2] = incremental * mWorldAxis[2];
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#endif
}
}
@@ -201,16 +201,16 @@ void CameraRig::LookUp()
Matrix4x4<float> incremental = Rotation<4, float>(
AxisAngle<4, float>(mWorldAxis[2], +mRotationSpeed));
#if defined(GTE_USE_MAT_VEC)
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#else
#if defined(GTE_USE_VEC_MAT)
mCamera->SetAxes(
mCamera->GetDVector() * incremental,
mCamera->GetUVector() * incremental,
mCamera->GetRVector() * incremental);
#else
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#endif
}
}
@@ -222,16 +222,16 @@ void CameraRig::LookDown()
Matrix4x4<float> incremental = Rotation<4, float>(
AxisAngle<4, float>(mWorldAxis[2], -mRotationSpeed));
#if defined(GTE_USE_MAT_VEC)
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#else
#if defined(GTE_USE_VEC_MAT)
mCamera->SetAxes(
mCamera->GetDVector() * incremental,
mCamera->GetUVector() * incremental,
mCamera->GetRVector() * incremental);
#else
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#endif
}
}
@@ -243,16 +243,16 @@ void CameraRig::RollClockwise()
Matrix4x4<float> incremental = Rotation<4, float>(
AxisAngle<4, float>(mWorldAxis[0], +mRotationSpeed));
#if defined(GTE_USE_MAT_VEC)
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#else
#if defined(GTE_USE_VEC_MAT)
mCamera->SetAxes(
mCamera->GetDVector() * incremental,
mCamera->GetUVector() * incremental,
mCamera->GetRVector() * incremental);
#else
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#endif
}
}
@@ -264,21 +264,21 @@ void CameraRig::RollCounterclockwise()
Matrix4x4<float> incremental = Rotation<4, float>(
AxisAngle<4, float>(mWorldAxis[0], -mRotationSpeed));
#if defined(GTE_USE_MAT_VEC)
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#else
#if defined(GTE_USE_VEC_MAT)
mCamera->SetAxes(
mCamera->GetDVector() * incremental,
mCamera->GetUVector() * incremental,
mCamera->GetRVector() * incremental);
#else
mCamera->SetAxes(
incremental * mCamera->GetDVector(),
incremental * mCamera->GetUVector(),
incremental * mCamera->GetRVector());
#endif
}
}
void CameraRig::Register(int trigger, MoveFunction function)
void CameraRig::Register(int32_t trigger, MoveFunction function)
{
if (trigger >= 0)
{
@@ -290,11 +290,11 @@ void CameraRig::Register(int trigger, MoveFunction function)
}
else
{
for (auto element : mIndirectMap)
for (auto const& element : mIndirectMap)
{
if (element.second == function)
{
mIndirectMap.erase(trigger);
mIndirectMap.erase(element.first);
return;
}
}
@@ -303,7 +303,7 @@ void CameraRig::Register(int trigger, MoveFunction function)
bool CameraRig::SetActive(MoveFunction function)
{
for (int i = 0; i < mNumActiveMotions; ++i)
for (int32_t i = 0; i < mNumActiveMotions; ++i)
{
if (mActiveMotions[i] == function)
{
@@ -324,11 +324,11 @@ bool CameraRig::SetActive(MoveFunction function)
bool CameraRig::SetInactive(MoveFunction function)
{
for (int i = 0; i < mNumActiveMotions; ++i)
for (int32_t i = 0; i < mNumActiveMotions; ++i)
{
if (mActiveMotions[i] == function)
{
for (int j0 = i, j1 = j0 + 1; j1 < mNumActiveMotions; j0 = j1++)
for (int32_t j0 = i, j1 = j0 + 1; j1 < mNumActiveMotions; j0 = j1++)
{
mActiveMotions[j0] = mActiveMotions[j1];
}
@@ -336,7 +336,7 @@ bool CameraRig::SetInactive(MoveFunction function)
mActiveMotions[mNumActiveMotions] = nullptr;
if (mNumActiveMotions > 0)
{
mMotion = mActiveMotions[mNumActiveMotions - 1];
mMotion = mActiveMotions[static_cast<size_t>(mNumActiveMotions) - 1];
}
else
{
@@ -347,3 +347,5 @@ bool CameraRig::SetInactive(MoveFunction function)
}
return false;
}
+21 -19
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -133,68 +133,68 @@ namespace gte
// iff the trigger is mapped. A call to PopMotion(trigger) will
// disable the motion if the trigger is currently mapped; the Boolean
// return it 'true' iff the trigger is currently mapped.
inline void RegisterMoveForward(int trigger)
inline void RegisterMoveForward(int32_t trigger)
{
Register(trigger, &CameraRig::MoveForward);
}
inline void RegisterMoveBackward(int trigger)
inline void RegisterMoveBackward(int32_t trigger)
{
Register(trigger, &CameraRig::MoveBackward);
}
inline void RegisterMoveUp(int trigger)
inline void RegisterMoveUp(int32_t trigger)
{
Register(trigger, &CameraRig::MoveUp);
}
inline void RegisterMoveDown(int trigger)
inline void RegisterMoveDown(int32_t trigger)
{
Register(trigger, &CameraRig::MoveDown);
}
inline void RegisterMoveRight(int trigger)
inline void RegisterMoveRight(int32_t trigger)
{
Register(trigger, &CameraRig::MoveRight);
}
inline void RegisterMoveLeft(int trigger)
inline void RegisterMoveLeft(int32_t trigger)
{
Register(trigger, &CameraRig::MoveLeft);
}
inline void RegisterTurnRight(int trigger)
inline void RegisterTurnRight(int32_t trigger)
{
Register(trigger, &CameraRig::TurnRight);
}
inline void RegisterTurnLeft(int trigger)
inline void RegisterTurnLeft(int32_t trigger)
{
Register(trigger, &CameraRig::TurnLeft);
}
inline void RegisterLookUp(int trigger)
inline void RegisterLookUp(int32_t trigger)
{
Register(trigger, &CameraRig::LookUp);
}
inline void RegisterLookDown(int trigger)
inline void RegisterLookDown(int32_t trigger)
{
Register(trigger, &CameraRig::LookDown);
}
inline void RegisterRollClockwise(int trigger)
inline void RegisterRollClockwise(int32_t trigger)
{
Register(trigger, &CameraRig::RollClockwise);
}
inline void RegisterRollCounterclockwise(int trigger)
inline void RegisterRollCounterclockwise(int32_t trigger)
{
Register(trigger, &CameraRig::RollCounterclockwise);
}
bool PushMotion(int trigger);
bool PopMotion(int trigger);
bool PushMotion(int32_t trigger);
bool PopMotion(int32_t trigger);
bool Move();
void ClearMotions();
@@ -217,7 +217,7 @@ namespace gte
virtual void RollCounterclockwise();
typedef void(CameraRig::* MoveFunction)(void);
void Register(int trigger, MoveFunction function);
void Register(int32_t trigger, MoveFunction function);
bool SetActive(MoveFunction function);
bool SetInactive(MoveFunction function);
@@ -230,8 +230,10 @@ namespace gte
// Move via direct or indirect triggers.
MoveFunction mMotion;
std::map<int, MoveFunction> mIndirectMap;
int mNumActiveMotions;
std::map<int32_t, MoveFunction> mIndirectMap;
int32_t mNumActiveMotions;
std::array<MoveFunction, MAX_ACTIVE_MOTIONS> mActiveMotions;
};
}
+76 -61
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.01.10
// File Version: 8.0.2026.02.16
#include <Applications/GTApplicationsPCH.h>
#include <Applications/Command.h>
@@ -16,7 +16,7 @@ std::string const Command::msArgOutOfRange("Argument out of range.");
std::string const Command::msFilenameNotFound("Filename not found.");
std::string const Command::msDash("-");
Command::Command (int numArguments, char const* arguments[])
Command::Command(int32_t numArguments, char const* arguments[])
:
mSmall(0.0),
mLarge(0.0),
@@ -29,9 +29,9 @@ Command::Command (int numArguments, char const* arguments[])
// The first argument is always the executable name.
LogAssert(numArguments > 0, "Invalid number of arguments.");
mArguments.resize(numArguments);
mProcessed.resize(numArguments);
for (int i = 0; i < numArguments; ++i)
mArguments.resize(static_cast<size_t>(numArguments));
mProcessed.resize(mArguments.size());
for (size_t i = 0; i < mArguments.size(); ++i)
{
mArguments[i] = std::string(arguments[i]);
mProcessed[i] = false;
@@ -41,7 +41,7 @@ Command::Command (int numArguments, char const* arguments[])
mProcessed[0] = true;
}
Command::Command(int numArguments, char* arguments[])
Command::Command(int32_t numArguments, char* arguments[])
:
mSmall(0.0),
mLarge(0.0),
@@ -54,9 +54,9 @@ Command::Command(int numArguments, char* arguments[])
// The first argument is always the executable name.
LogAssert(numArguments > 0, "Invalid number of arguments.");
mArguments.resize(numArguments);
mProcessed.resize(numArguments);
for (int i = 0; i < numArguments; ++i)
mArguments.resize(static_cast<size_t>(numArguments));
mProcessed.resize(mArguments.size());
for (size_t i = 0; i < mArguments.size(); ++i)
{
mArguments[i] = std::string(arguments[i]);
mProcessed[i] = false;
@@ -66,11 +66,10 @@ Command::Command(int numArguments, char* arguments[])
mProcessed[0] = true;
}
int Command::ExcessArguments () const
size_t Command::ExcessArguments() const
{
// Check to see whether any command line arguments were not processed.
int const numArguments = (int)mArguments.size();
for (int i = 1; i < numArguments; ++i)
for (size_t i = 1; i < mArguments.size(); ++i)
{
if (!mProcessed[i])
{
@@ -80,47 +79,46 @@ int Command::ExcessArguments () const
return 0;
}
Command& Command::Min (double value)
Command& Command::Min(double value)
{
mSmall = value;
mMinSet = true;
return *this;
}
Command& Command::Max (double value)
Command& Command::Max(double value)
{
mLarge = value;
mMaxSet = true;
return *this;
}
Command& Command::Inf (double value)
Command& Command::Inf(double value)
{
mSmall = value;
mInfSet = true;
return *this;
}
Command& Command::Sup (double value)
Command& Command::Sup(double value)
{
mLarge = value;
mSupSet = true;
return *this;
}
int Command::GetBoolean (std::string const& name)
size_t Command::GetBoolean(std::string const& name)
{
bool value = false;
return GetBoolean(name, value);
}
int Command::GetBoolean (std::string const& name, bool& value)
size_t Command::GetBoolean(std::string const& name, bool& value)
{
int matchFound = 0;
size_t matchFound = 0;
value = false;
int const numArguments = (int)mArguments.size();
for (int i = 1; i < numArguments; ++i)
for (size_t i = 1; i < mArguments.size(); ++i)
{
std::string tmp = mArguments[i];
if (!mProcessed[i] && mArguments[i] == (msDash + name))
@@ -140,28 +138,32 @@ int Command::GetBoolean (std::string const& name, bool& value)
return matchFound;
}
int Command::GetInteger (std::string const& name, int& value)
size_t Command::GetInteger(std::string const& name, int32_t& value)
{
int matchFound = 0;
size_t matchFound = 0;
int const numArguments = (int)mArguments.size();
for (int i = 1; i < numArguments; ++i)
for (size_t i = 1; i < mArguments.size(); ++i)
{
if (!mProcessed[i] && mArguments[i] == (msDash + name))
{
if (i + 1 >= mArguments.size())
{
mLastError = msArgRequired;
return 0;
}
std::string argument = mArguments[i + 1];
if (mProcessed[i + 1]
|| (argument[0] == '-' && !isdigit((int)argument[1])))
if (mProcessed[i + 1] ||
(argument[0] == '-' && !isdigit(static_cast<int32_t>(argument[1]))))
{
mLastError = msArgRequired;
return 0;
}
value = atoi(argument.c_str());
if ((mMinSet && value < mSmall)
|| (mMaxSet && value > mLarge)
|| (mInfSet && value <= mSmall)
|| (mSupSet && value >= mLarge))
if ((mMinSet && value < mSmall) ||
(mMaxSet && value > mLarge) ||
(mInfSet && value <= mSmall) ||
(mSupSet && value >= mLarge))
{
mLastError = msArgOutOfRange;
return 0;
@@ -187,28 +189,32 @@ int Command::GetInteger (std::string const& name, int& value)
return matchFound;
}
int Command::GetFloat (std::string const& name, float& value)
size_t Command::GetFloat(std::string const& name, float& value)
{
int matchFound = 0;
size_t matchFound = 0;
int const numArguments = (int)mArguments.size();
for (int i = 1; i <numArguments; ++i)
for (size_t i = 1; i < mArguments.size(); ++i)
{
if (!mProcessed[i] && mArguments[i] == (msDash + name))
{
if (i + 1 >= mArguments.size())
{
mLastError = msArgRequired;
return 0;
}
std::string argument = mArguments[i + 1];
if (mProcessed[i + 1]
|| (argument[0] == '-' && !isdigit((int)argument[1])))
if (mProcessed[i + 1] ||
(argument[0] == '-' && !isdigit(static_cast<int32_t>(argument[1]))))
{
mLastError = msArgRequired;
return 0;
}
value = (float)atof(argument.c_str());
if ((mMinSet && value < mSmall)
|| (mMaxSet && value > mLarge)
|| (mInfSet && value <= mSmall)
|| (mSupSet && value >= mLarge))
value = static_cast<float>(atof(argument.c_str()));
if ((mMinSet && value < mSmall) ||
(mMaxSet && value > mLarge) ||
(mInfSet && value <= mSmall) ||
(mSupSet && value >= mLarge))
{
mLastError = msArgOutOfRange;
return 0;
@@ -234,28 +240,32 @@ int Command::GetFloat (std::string const& name, float& value)
return matchFound;
}
int Command::GetDouble (std::string const& name, double& value)
size_t Command::GetDouble(std::string const& name, double& value)
{
int matchFound = 0;
size_t matchFound = 0;
int const numArguments = (int)mArguments.size();
for (int i = 1; i < numArguments; ++i)
for (size_t i = 1; i < mArguments.size(); ++i)
{
if (!mProcessed[i] && mArguments[i] == (msDash + name))
{
if (i + 1 >= mArguments.size())
{
mLastError = msArgRequired;
return 0;
}
std::string argument = mArguments[i + 1];
if (mProcessed[i + 1]
|| (argument[0] == '-' && !isdigit((int)argument[1])))
if (mProcessed[i + 1] ||
(argument[0] == '-' && !isdigit(static_cast<int32_t>(argument[1]))))
{
mLastError = msArgRequired;
return 0;
}
value = atof(argument.c_str());
if ((mMinSet && value < mSmall)
|| (mMaxSet && value > mLarge)
|| (mInfSet && value <= mSmall)
|| (mSupSet && value >= mLarge))
if ((mMinSet && value < mSmall) ||
(mMaxSet && value > mLarge) ||
(mInfSet && value <= mSmall) ||
(mSupSet && value >= mLarge))
{
mLastError = msArgOutOfRange;
return 0;
@@ -281,15 +291,19 @@ int Command::GetDouble (std::string const& name, double& value)
return matchFound;
}
int Command::GetString (std::string const& name, std::string& value)
size_t Command::GetString(std::string const& name, std::string& value)
{
int matchFound = 0;
size_t matchFound = 0;
int const numArguments = (int)mArguments.size();
for (int i = 1; i < numArguments; ++i)
for (size_t i = 1; i < mArguments.size(); ++i)
{
if (!mProcessed[i] && mArguments[i] == (msDash + name))
{
if (i + 1 >= mArguments.size())
{
mLastError = msArgRequired;
return 0;
}
std::string argument = mArguments[i + 1];
if (mProcessed[i + 1] || argument[0] == '-')
{
@@ -313,12 +327,11 @@ int Command::GetString (std::string const& name, std::string& value)
return matchFound;
}
int Command::GetFilename (std::string& value, int startArgIndex)
size_t Command::GetFilename(std::string& value, size_t startArgIndex)
{
int matchFound = 0;
size_t matchFound = 0;
int const numArguments = (int)mArguments.size();
for (int i = startArgIndex; i < numArguments; ++i)
for (size_t i = startArgIndex; i < mArguments.size(); ++i)
{
std::string argument = mArguments[i];
if (!mProcessed[i] && argument[0] != '-')
@@ -337,3 +350,5 @@ int Command::GetFilename (std::string& value, int startArgIndex)
return matchFound;
}
+14 -12
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.01.10
// File Version: 8.0.2025.05.10
#pragma once
@@ -17,11 +17,11 @@ namespace gte
public:
// Construction and destruction.
~Command() = default;
Command(int numArguments, char const* arguments[]);
Command(int numArguments, char* arguments[]);
Command(int32_t numArguments, char const* arguments[]);
Command(int32_t numArguments, char* arguments[]);
// The return value is the index of the first excess argument.
int ExcessArguments() const;
size_t ExcessArguments() const;
// Set bounds for numerical arguments. If bounds are required, they
// must be set for each argument.
@@ -38,13 +38,13 @@ namespace gte
// myprogram -debug -x 10 -y 20 filename
// the option -debug has no argument. The first GetBoolean function
// returns only the existence of the option.
int GetBoolean(std::string const& name);
int GetBoolean(std::string const& name, bool& value);
int GetInteger(std::string const& name, int& value);
int GetFloat(std::string const& name, float& value);
int GetDouble(std::string const& name, double& value);
int GetString(std::string const& name, std::string& value);
int GetFilename(std::string& value, int startArgIndex = 1);
size_t GetBoolean(std::string const& name);
size_t GetBoolean(std::string const& name, bool& value);
size_t GetInteger(std::string const& name, int32_t& value);
size_t GetFloat(std::string const& name, float& value);
size_t GetDouble(std::string const& name, double& value);
size_t GetString(std::string const& name, std::string& value);
size_t GetFilename(std::string& value, size_t startArgIndex = 1);
// Last-error reporting.
inline std::string GetLastError() const
@@ -76,3 +76,5 @@ namespace gte
static std::string const msDash;
};
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -14,3 +14,5 @@
#if defined(GTE_USE_LINUX)
#include<Applications/GLX/Console.h>
#endif
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/ConsoleApplication.h>
@@ -29,3 +29,5 @@ ConsoleApplication::ConsoleApplication(Parameters const& parameters)
mTitle(parameters.title)
{
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -48,3 +48,5 @@ namespace gte
std::wstring mTitle;
};
}
+9 -10
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.09.15
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/Environment.h>
@@ -36,14 +36,14 @@ std::string Environment::GetVariable(std::string const& name) const
#endif
}
int Environment::GetNumDirectories() const
int32_t Environment::GetNumDirectories() const
{
return static_cast<int>(mDirectories.size());
return static_cast<int32_t>(mDirectories.size());
}
std::string Environment::Get(int i) const
std::string Environment::Get(int32_t i) const
{
if (0 <= i && i < static_cast<int>(mDirectories.size()))
if (0 <= i && i < static_cast<int32_t>(mDirectories.size()))
{
return mDirectories[i];
}
@@ -115,9 +115,8 @@ std::string Environment::GetPath(std::string const& name) const
std::string Environment::GetGTEPath() const
{
std::string path = GetVariable("GTE_PATH");
if (path == "")
{
LogWarning("You must create the environment variable GTE_PATH.");
}
LogAssert(path != "", "You must create the environment variable GTE_PATH.");
return path;
}
+20 -15
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.09.15
// File Version: 8.0.2025.05.10
#pragma once
@@ -17,19 +17,24 @@ namespace gte
{
public:
// Construction and destruction.
Environment()
:
mDirectories{}
{
}
~Environment() = default;
Environment() = default;
// Get the string corresponding to an environment variable.
std::string GetVariable(std::string const& name) const;
// Support for paths to locate files. For platform independence, use
// "/" for the path separator. The input 'directory' will
// Support for paths to locate files. For platform independence, use
// "/" for the path separator. The input 'directory' will
// automatically be appended with a trailing "/" if it does not end
// in '/' or '\\'. The Insert*/Remove* functions return 'true' iff
// in '/' or '\\'. The Insert*/Remove* functions return 'true' iff
// the operation was successful.
int GetNumDirectories() const;
std::string Get(int i) const;
int32_t GetNumDirectories() const;
std::string Get(int32_t i) const;
bool Insert(std::string const& directory);
bool Remove(std::string const& directory);
void RemoveAll();
@@ -39,13 +44,11 @@ namespace gte
// for reading.
std::string GetPath(std::string const& name) const;
// Get the path to the GTE folder. This is obtained from the
// GTE_PATH environment variable, and it is required when you want
// a guaranteed way of finding application data/files in the GTE
// subtree. If you call this function and the environment variable
// does not exist, the returned string is "". The function calls
// LogWarning(...) so that any listeners are informed about the
// problem.
// Get the path to the GTE folder. This is obtained from the GTE_PATH
// environment variable. It is required when you want a guaranteed way
// of finding application data/files in the GTE subtree. If you call
// this function and the environment variable does not exist, an
// exception is thrown.
std::string GetGTEPath() const;
private:
@@ -53,3 +56,5 @@ namespace gte
std::vector<std::string> mDirectories;
};
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/GLX/Console.h>
@@ -36,3 +36,5 @@ Console::Console(Parameters& parameters)
mEngine(std::static_pointer_cast<GraphicsEngine>(mBaseEngine))
{
}
+5 -3
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -27,7 +27,7 @@ namespace gte
_XDisplay* display;
unsigned long window;
unsigned int deviceCreationFlags;
uint32_t deviceCreationFlags;
};
public:
@@ -46,3 +46,5 @@ namespace gte
// previously in this file and is known to the compiler when it includes this
// file.
#include <Applications/GLX/ConsoleSystem.h>
+6 -4
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/GLX/Console.h>
@@ -42,7 +42,7 @@ void ConsoleSystem::CreateEngineAndProgramFactory(Console::Parameters& parameter
auto engine = std::make_shared<WGLEngine>(false, saveDriverInfo);
if (!engine->MeetsRequirements())
{
LogError("OpenGL 4.5 or later is required.");
LogError("OpenGL 4.6 or later is required.");
}
if (engine->GetDevice())
@@ -67,7 +67,7 @@ void ConsoleSystem::CreateEngineAndProgramFactory(Console::Parameters& parameter
auto engine = std::make_shared<GLXEngine>(true, saveDriverInfo);
if (!engine->MeetsRequirements())
{
LogError("OpenGL 4.5 or later is required.");
LogError("OpenGL 4.6 or later is required.");
}
if (engine->GetDisplay())
@@ -89,3 +89,5 @@ void ConsoleSystem::CreateEngineAndProgramFactory(Console::Parameters& parameter
}
#endif
#endif
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -63,3 +63,5 @@ namespace gte
extern ConsoleSystem TheConsoleSystem;
}
+17 -15
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2026.02.16
// The functions were written based on the example source code
// https://dev.w3.org/Amaya/libpng/example.c
@@ -87,7 +87,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
png_read_png(helper.png_ptr, helper.info_ptr, 0, nullptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_method, compression_method, filter_method;
int32_t bit_depth, color_type, interlace_method, compression_method, filter_method;
png_get_IHDR(helper.png_ptr, helper.info_ptr, &width, &height, &bit_depth,
&color_type, &interlace_method, &compression_method, &filter_method);
@@ -125,7 +125,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
src = reinterpret_cast<uint8_t const*>(rows[y]);
for (png_uint_32 x = 0; x < width; ++x)
{
for (int i = 0; i < 4; ++i)
for (int32_t i = 0; i < 4; ++i)
{
*trg++ = src[4 * x + i];
}
@@ -141,7 +141,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
src = reinterpret_cast<uint8_t const*>(rows[y]);
for (png_uint_32 x = 0; x < width; ++x)
{
for (int i = 0; i < 3; ++i)
for (int32_t i = 0; i < 3; ++i)
{
*trg++ = src[3 * x + i];
}
@@ -171,7 +171,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
src = reinterpret_cast<uint8_t const*>(rows[y]);
for (png_uint_32 x = 0; x < width; ++x)
{
for (int i = 0; i < 2; ++i)
for (int32_t i = 0; i < 2; ++i)
{
*trg++ = src[2 * x + i];
}
@@ -192,7 +192,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
src = reinterpret_cast<uint16_t const*>(rows[y]);
for (png_uint_32 x = 0; x < width; ++x)
{
for (int i = 0; i < 4; ++i)
for (int32_t i = 0; i < 4; ++i)
{
*trg++ = src[4 * x + i];
}
@@ -201,14 +201,14 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
}
else if (color_type == PNG_COLOR_TYPE_RGB)
{
texture = std::make_shared<Texture2>(DF_R8G8B8A8_UNORM, width, height, wantMipmaps);
texture = std::make_shared<Texture2>(DF_R16G16B16A16_UNORM, width, height, wantMipmaps);
trg = texture->Get<uint16_t>();
for (png_uint_32 y = 0; y < height; ++y)
{
src = reinterpret_cast<uint16_t const*>(rows[y]);
for (png_uint_32 x = 0; x < width; ++x)
{
for (int i = 0; i < 3; ++i)
for (int32_t i = 0; i < 3; ++i)
{
*trg++ = src[3 * x + i];
}
@@ -238,7 +238,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
src = reinterpret_cast<uint16_t const*>(rows[y]);
for (png_uint_32 x = 0; x < width; ++x)
{
for (int i = 0; i < 2; ++i)
for (int32_t i = 0; i < 2; ++i)
{
*trg++ = src[2 * x + i];
}
@@ -257,8 +257,8 @@ bool WICFileIO::SaveToPNG(std::string const& filename, std::shared_ptr<Texture2>
return false;
}
int bit_depth = 0;
int color_type = 0;
int32_t bit_depth = 0;
int32_t color_type = 0;
png_uint_32 bytes_per_pixel = 0;
switch (texture->GetFormat())
{
@@ -327,9 +327,9 @@ bool WICFileIO::SaveToPNG(std::string const& filename, std::shared_ptr<Texture2>
png_uint_32 width = texture->GetWidth();
png_uint_32 height = texture->GetHeight();
int interlace_method = PNG_INTERLACE_NONE;
int compression_method = PNG_COMPRESSION_TYPE_BASE;
int filter_method = PNG_FILTER_TYPE_BASE;
int32_t interlace_method = PNG_INTERLACE_NONE;
int32_t compression_method = PNG_COMPRESSION_TYPE_BASE;
int32_t filter_method = PNG_FILTER_TYPE_BASE;
png_set_IHDR(helper.png_ptr, helper.info_ptr, width, height, bit_depth,
color_type, interlace_method, compression_method, filter_method);
@@ -346,3 +346,5 @@ bool WICFileIO::SaveToPNG(std::string const& filename, std::shared_ptr<Texture2>
png_write_end(helper.png_ptr, helper.info_ptr);
return true;
}
+6 -4
View File
@@ -1,17 +1,17 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
#include <Graphics/Texture2.h>
#include <memory>
// The supported texture types are DF_R8G8B8A8_UNORM, DF_R8_UNORM, and
// DF_R8G8_UNORM (gray+alpha).
// The supported texture types are DF_R8G8B8A8_UNORM, DF_R8_UNORM
// and DF_R8G8_UNORM (gray+alpha).
namespace gte
{
@@ -29,3 +29,5 @@ namespace gte
std::shared_ptr<Texture2> const& texture);
};
}
+59 -57
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/GLX/Window.h>
@@ -25,7 +25,7 @@ namespace gte
}
Window::Parameters::Parameters(std::wstring const& inTitle,
int inXOrigin, int inYOrigin, int inXSize, int inYSize)
int32_t inXOrigin, int32_t inYOrigin, int32_t inXSize, int32_t inYSize)
:
WindowApplication::Parameters(inTitle, inXOrigin, inYOrigin, inXSize, inYSize),
display(nullptr),
@@ -64,17 +64,17 @@ namespace gte
XMapWindow(mDisplay, mWindow);
}
void Window::SetMousePosition(int x, int y)
void Window::SetMousePosition(int32_t x, int32_t y)
{
XWarpPointer(mDisplay, 0, mWindow, 0, 0, 0, 0, x, y);
XFlush(mDisplay);
}
void Window::GetMousePosition(int& x, int& y) const
void Window::GetMousePosition(int32_t& x, int32_t& y) const
{
XID rootWindow, childWindow;
int rootX, rootY;
unsigned int modifier;
int32_t rootX, rootY;
uint32_t modifier;
XQueryPointer(mDisplay, mWindow, &rootWindow, &childWindow,
&rootX, &rootY, &x, &y, &modifier);
}
@@ -84,7 +84,7 @@ namespace gte
XDestroyWindow(mDisplay, mWindow);
}
int Window::ProcessedEvent()
int32_t Window::ProcessedEvent()
{
if (!XPending(mDisplay))
{
@@ -119,8 +119,8 @@ namespace gte
if (evt.type == MotionNotify)
{
int button = MOUSE_NONE;
for (int i = MOUSE_LEFT; i <= MOUSE_RIGHT; ++i)
int32_t button = MOUSE_NONE;
for (int32_t i = MOUSE_LEFT; i <= MOUSE_RIGHT; ++i)
{
if (mButtonDown[i])
{
@@ -134,11 +134,11 @@ namespace gte
if (evt.type == KeyPress || evt.type == KeyRelease)
{
int keysyms_per_keycode_return;
int32_t keysyms_per_keycode_return;
KeySym* pKeySym = XGetKeyboardMapping(mDisplay,
evt.xkey.keycode, 1, &keysyms_per_keycode_return);
KeySym& keySym = *pKeySym;
int key = (keySym & 0x00FF);
int32_t key = (keySym & 0x00FF);
// Quit application if the KEY_ESCAPE key is pressed.
if (key == KEY_ESCAPE)
@@ -208,10 +208,10 @@ namespace gte
if (evt.type == KeyPress)
{
// Get key-modifier state. Adjust for shift state.
unsigned char ucKey = static_cast<unsigned char>(key);
uint8_t ucKey = static_cast<uint8_t>(key);
if (mShiftDown && 'a' <= ucKey && ucKey <= 'z')
{
ucKey = static_cast<unsigned char>(key - 32);
ucKey = static_cast<uint8_t>(key - 32);
}
OnCharPress(ucKey, evt.xbutton.x, evt.xbutton.y);
}
@@ -236,7 +236,7 @@ namespace gte
if (evt.type == ClientMessage)
{
Atom* wmDelete = nullptr;
int count;
int32_t count;
if (XGetWMProtocols(mDisplay, mWindow, &wmDelete, &count))
{
if ((unsigned long)evt.xclient.data.l[0] == *wmDelete)
@@ -249,49 +249,51 @@ namespace gte
return EVT_NONE_PENDING;
}
int const WindowApplication::KEY_ESCAPE = 0x1B;
int const WindowApplication::KEY_HOME = 0x95;
int const WindowApplication::KEY_LEFT = 0x96;
int const WindowApplication::KEY_UP = 0x97;
int const WindowApplication::KEY_RIGHT = 0x98;
int const WindowApplication::KEY_DOWN = 0x99;
int const WindowApplication::KEY_PAGE_UP = 0x9A;
int const WindowApplication::KEY_PAGE_DOWN = 0x9B;
int const WindowApplication::KEY_END = 0x9C;
int const WindowApplication::KEY_INSERT = 0x9E;
int const WindowApplication::KEY_DELETE = 0x9F;
int const WindowApplication::KEY_F1 = 0xBE;
int const WindowApplication::KEY_F2 = 0xBF;
int const WindowApplication::KEY_F3 = 0xC0;
int const WindowApplication::KEY_F4 = 0xC1;
int const WindowApplication::KEY_F5 = 0xC2;
int const WindowApplication::KEY_F6 = 0xC3;
int const WindowApplication::KEY_F7 = 0xC4;
int const WindowApplication::KEY_F8 = 0xC5;
int const WindowApplication::KEY_F9 = 0xC6;
int const WindowApplication::KEY_F10 = 0xC7;
int const WindowApplication::KEY_F11 = 0xC8;
int const WindowApplication::KEY_F12 = 0xC9;
int const WindowApplication::KEY_BACKSPACE = 0x08;
int const WindowApplication::KEY_TAB = 0x09;
int const WindowApplication::KEY_ENTER = 0x0D;
int const WindowApplication::KEY_RETURN = 0x0D;
int32_t const WindowApplication::KEY_ESCAPE = 0x1B;
int32_t const WindowApplication::KEY_HOME = 0x95;
int32_t const WindowApplication::KEY_LEFT = 0x96;
int32_t const WindowApplication::KEY_UP = 0x97;
int32_t const WindowApplication::KEY_RIGHT = 0x98;
int32_t const WindowApplication::KEY_DOWN = 0x99;
int32_t const WindowApplication::KEY_PAGE_UP = 0x9A;
int32_t const WindowApplication::KEY_PAGE_DOWN = 0x9B;
int32_t const WindowApplication::KEY_END = 0x9C;
int32_t const WindowApplication::KEY_INSERT = 0x9E;
int32_t const WindowApplication::KEY_DELETE = 0x9F;
int32_t const WindowApplication::KEY_F1 = 0xBE;
int32_t const WindowApplication::KEY_F2 = 0xBF;
int32_t const WindowApplication::KEY_F3 = 0xC0;
int32_t const WindowApplication::KEY_F4 = 0xC1;
int32_t const WindowApplication::KEY_F5 = 0xC2;
int32_t const WindowApplication::KEY_F6 = 0xC3;
int32_t const WindowApplication::KEY_F7 = 0xC4;
int32_t const WindowApplication::KEY_F8 = 0xC5;
int32_t const WindowApplication::KEY_F9 = 0xC6;
int32_t const WindowApplication::KEY_F10 = 0xC7;
int32_t const WindowApplication::KEY_F11 = 0xC8;
int32_t const WindowApplication::KEY_F12 = 0xC9;
int32_t const WindowApplication::KEY_BACKSPACE = 0x08;
int32_t const WindowApplication::KEY_TAB = 0x09;
int32_t const WindowApplication::KEY_ENTER = 0x0D;
int32_t const WindowApplication::KEY_RETURN = 0x0D;
int const WindowApplication::KEY_SHIFT = 0xE1; // L-shift
int const WindowApplication::KEY_CONTROL = 0xE3; // L-ctrl
int const WindowApplication::KEY_ALT = 0xE9; // L-alt
int const WindowApplication::KEY_COMMAND = 0xEB; // L-command
int32_t const WindowApplication::KEY_SHIFT = 0xE1; // L-shift
int32_t const WindowApplication::KEY_CONTROL = 0xE3; // L-ctrl
int32_t const WindowApplication::KEY_ALT = 0xE9; // L-alt
int32_t const WindowApplication::KEY_COMMAND = 0xEB; // L-command
int const WindowApplication::MOUSE_NONE = 0x0000;
int const WindowApplication::MOUSE_LEFT = 0x0001;
int const WindowApplication::MOUSE_MIDDLE = 0x0002;
int const WindowApplication::MOUSE_RIGHT = 0x0003;
int const WindowApplication::MOUSE_DOWN = 0x0004;
int const WindowApplication::MOUSE_UP = 0x0005;
int32_t const WindowApplication::MOUSE_NONE = 0x0000;
int32_t const WindowApplication::MOUSE_LEFT = 0x0001;
int32_t const WindowApplication::MOUSE_MIDDLE = 0x0002;
int32_t const WindowApplication::MOUSE_RIGHT = 0x0003;
int32_t const WindowApplication::MOUSE_DOWN = 0x0004;
int32_t const WindowApplication::MOUSE_UP = 0x0005;
int const WindowApplication::MODIFIER_CONTROL = 0x0004;
int const WindowApplication::MODIFIER_LBUTTON = 0x0001;
int const WindowApplication::MODIFIER_MBUTTON = 0x0002;
int const WindowApplication::MODIFIER_RBUTTON = 0x0003;
int const WindowApplication::MODIFIER_SHIFT = 0x0001;
int32_t const WindowApplication::MODIFIER_CONTROL = 0x0004;
int32_t const WindowApplication::MODIFIER_LBUTTON = 0x0001;
int32_t const WindowApplication::MODIFIER_MBUTTON = 0x0002;
int32_t const WindowApplication::MODIFIER_RBUTTON = 0x0003;
int32_t const WindowApplication::MODIFIER_SHIFT = 0x0001;
}
+10 -8
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -24,11 +24,11 @@ namespace gte
Parameters();
Parameters(std::wstring const& inTitle,
int inXOrigin, int inYOrigin, int inXSize, int inYSize);
int32_t inXOrigin, int32_t inYOrigin, int32_t inXSize, int32_t inYSize);
_XDisplay* display;
unsigned long window;
unsigned int deviceCreationFlags;
uint32_t deviceCreationFlags;
};
protected:
@@ -38,14 +38,14 @@ namespace gte
public:
virtual ~Window();
virtual void SetTitle(std::wstring const& title);
virtual void SetTitle(std::wstring const& title) override;
// Draw the window.
void ShowWindow();
// Mouse position information.
virtual void SetMousePosition(int x, int y) override;
virtual void GetMousePosition(int& x, int& y) const override;
virtual void SetMousePosition(int32_t x, int32_t y) override;
virtual void GetMousePosition(int32_t& x, int32_t& y) const override;
// Actions to take before the window closes.
virtual void OnClose() override;
@@ -58,7 +58,7 @@ namespace gte
EVT_PROCESSED,
EVT_QUIT
};
int ProcessedEvent();
int32_t ProcessedEvent();
protected:
_XDisplay* mDisplay;
@@ -78,3 +78,5 @@ namespace gte
// previously in this file and is known to the compiler when it includes this
// file.
#include <Applications/GLX/WindowSystem.h>
+18 -17
View File
@@ -1,15 +1,15 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/GLX/WindowSystem.h>
#include <Applications/GLX/Window.h>
#include <Graphics/GL45/GLX/GLXEngine.h>
#include <Graphics/GL45/GLSLProgramFactory.h>
#include <Graphics/GL46/GLX/GLXEngine.h>
#include <Graphics/GL46/GLSLProgramFactory.h>
#include <X11/Xlib.h>
#include <GL/glx.h>
using namespace gte;
@@ -27,7 +27,6 @@ WindowSystem::~WindowSystem()
WindowSystem::WindowSystem()
:
mDisplayName("GTEngineWindow"),
mDisplay(nullptr)
{
// Connect to the X server.
@@ -39,7 +38,7 @@ WindowSystem::WindowSystem()
}
// Make sure the X server has OpenGL GLX extensions.
int errorBase, eventBase;
int32_t errorBase, eventBase;
Bool success = glXQueryExtension(mDisplay, &errorBase, &eventBase);
if (!success)
{
@@ -59,10 +58,10 @@ bool WindowSystem::Create(_XDisplay*& display, __GLXcontextRec*& context, unsign
window = 0;
// Select the attributes for the frame buffer.
int attributes[256];
int32_t attributes[256];
// Create a 32-bit RGBA buffer.
int i = 0;
int32_t i = 0;
attributes[i++] = GLX_RGBA;
attributes[i++] = GLX_RED_SIZE;
attributes[i++] = 8;
@@ -97,7 +96,7 @@ bool WindowSystem::Create(_XDisplay*& display, __GLXcontextRec*& context, unsign
attributes[i] = 0;
// Get an OpenGL-capable visual.
int screen = DefaultScreen(mDisplay);
int32_t screen = DefaultScreen(mDisplay);
XVisualInfo* visualInfo = glXChooseVisual(mDisplay, screen, attributes);
if (!visualInfo)
{
@@ -138,8 +137,8 @@ bool WindowSystem::Create(_XDisplay*& display, __GLXcontextRec*& context, unsign
ExposureMask |
StructureNotifyMask;
unsigned int xOrigin = 0, yOrigin = 0, xSize = 16, ySize = 16;
unsigned int borderWidth = 0;
uint32_t xOrigin = 0, yOrigin = 0, xSize = 16, ySize = 16;
uint32_t borderWidth = 0;
unsigned long valueMask = CWBorderPixel | CWColormap | CWEventMask;
window = XCreateWindow(mDisplay, rootWindow, xOrigin,
yOrigin, xSize, ySize, borderWidth,
@@ -155,7 +154,7 @@ bool WindowSystem::Create(_XDisplay*& display, __GLXcontextRec*& context, unsign
std::string title = "GL4ComputeWindowClass";
Pixmap iconPixmap = None;
int numArguments = 0;
int32_t numArguments = 0;
char** arguments = nullptr;
XSetStandardProperties(mDisplay, window, title.c_str(),
title.c_str(), iconPixmap, arguments, numArguments, &hints);
@@ -170,10 +169,10 @@ bool WindowSystem::Create(_XDisplay*& display, __GLXcontextRec*& context, unsign
void WindowSystem::CreateFrom(Window::Parameters& parameters)
{
// Select the attributes for the frame buffer.
int attributes[256];
int32_t attributes[256];
// Create a 32-bit RGBA buffer.
int i = 0;
int32_t i = 0;
attributes[i++] = GLX_RGBA;
attributes[i++] = GLX_RED_SIZE;
attributes[i++] = 8;
@@ -208,7 +207,7 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
attributes[i] = 0;
// Get an OpenGL-capable visual.
int screen = DefaultScreen(mDisplay);
int32_t screen = DefaultScreen(mDisplay);
XVisualInfo* visualInfo = glXChooseVisual(mDisplay, screen, attributes);
if (!visualInfo)
{
@@ -251,7 +250,7 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
ExposureMask |
StructureNotifyMask;
unsigned int borderWidth = 0;
uint32_t borderWidth = 0;
unsigned long valueMask = CWBorderPixel | CWColormap | CWEventMask;
parameters.window = XCreateWindow(mDisplay, rootWindow, parameters.xOrigin,
parameters.yOrigin, parameters.xSize, parameters.ySize, borderWidth,
@@ -267,7 +266,7 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
std::string title(parameters.title.begin(), parameters.title.end());
Pixmap iconPixmap = None;
int numArguments = 0;
int32_t numArguments = 0;
char** arguments = nullptr;
XSetStandardProperties(mDisplay, parameters.window, title.c_str(),
title.c_str(), iconPixmap, arguments, numArguments, &hints);
@@ -307,3 +306,5 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
parameters.created = false;
}
}
+7 -6
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -42,13 +42,12 @@ namespace gte
};
template <typename WindowType>
void MessagePump(std::shared_ptr<WindowType> const& window, unsigned int flags);
void MessagePump(std::shared_ptr<WindowType> const& window, uint32_t flags);
private:
// Window creation and destruction.
void CreateFrom(Window::Parameters& parameters);
char const* mDisplayName;
_XDisplay* mDisplay;
std::map<unsigned long, std::shared_ptr<Window>> mWindowMap;
};
@@ -85,7 +84,7 @@ namespace gte
}
template <typename WindowType>
void WindowSystem::MessagePump(std::shared_ptr<WindowType> const& window, unsigned int flags)
void WindowSystem::MessagePump(std::shared_ptr<WindowType> const& window, uint32_t flags)
{
if (window)
{
@@ -93,7 +92,7 @@ namespace gte
for (;;)
{
int result = window->ProcessedEvent();
int32_t result = window->ProcessedEvent();
if (result == Window::EVT_QUIT)
{
return;
@@ -113,3 +112,5 @@ namespace gte
}
}
}
+37 -36
View File
@@ -1,55 +1,56 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
// The preprocessor symbol GTE_USE_MSWINDOWS is added to all Visual Studio project
// configurations.
// On Microsoft Windows 10/11, the preprocessor symbol GTE_USE_MSWINDOWS is
// added to the Visual Studio project configurations. If a project uses
// DirectX 11 (or later), the symbol GTE_USE_DIRECTX is added to the Visual
// Studio projects. If a project uses OpenGL, the symbol GTE_USE_OPENGL is
// added to the Visual Studio projects.
//
// On Linux, the make system has the defines GTE_USE_LINUX and GTE_USE_OPENGL.
//
// By default, GTE uses row-major order for storing matrices. Previously
// you had to add to the project settings the preprocessor symbol
// GTE_USE_ROW_MAJOR. The source code has been modified so that you no
// longer need to define GTE_USE_ROW_MAJOR. If you want column-major order
// instead, add to the project settings the preprocessor symbol
// GTE_USE_COL_MAJOR.
//
// By default, GTE multiplies a matrix M and a vector V using M*V, which is
// the vector-on-the-right convention. Previously you had to add to the
// project settings the preprocessor symbol GTE_USE_MAT_VEC. The source code
// has been modified so that you no longer need to define GTE_USE_MAT_VEC.
// If you want the multiplication to represent V*M instead, which is the
// vector-on-the-left convention, add to the project settings the preprocessor
// symbol GTE_USE_VEC_MAT.
#if defined(GTE_USE_MSWINDOWS)
// The _MSC_VER macro has integer values as described at the webpage
// https://learn.microsoft.com/en-us/cpp/overview/compiler-versions?view=msvc-170
// Currently, projects are provided only for Visual Studio 2019/2022, but the
// macro allows you to compile with Visual Studio 2015 or later.
#if !defined(_MSC_VER)
#error Microsoft Visual Studio 2015 or later is required.
#endif
// MSVC 6 is version 12.0
// MSVC 7.0 is version 13.0 (MSVS 2002)
// MSVC 7.1 is version 13.1 (MSVS 2003)
// MSVC 8.0 is version 14.0 (MSVS 2005)
// MSVC 9.0 is version 15.0 (MSVS 2008)
// MSVC 10.0 is version 16.0 (MSVS 2010)
// MSVC 11.0 is version 17.0 (MSVS 2012)
// MSVC 12.0 is version 18.0 (MSVS 2013)
// MSVC 14.0 is version 19.0 (MSVS 2015)
// MSVC 15.0 is version 19.1 (MSVS 2017) [latest is 19.16 for 15.9.1]
// MSVC 16.0 is version 19.2 (MSVS 2019)
// Currently, projects are provided only for MSVS 2013, 2015, 2017, 2019
#if _MSC_VER < 1900
#error Microsoft Visual Studio 2015 or later is required.
#endif
// You can enable iterator debugging by adding to the preprocessor
// symbols:
// _ITERATOR_DEBUG_LEVEL=value
//
// Debug build values (choose_your_value is 0, 1, or 2)
// 0: Disables checked iterators and disables iterator debugging.
// 1: Enables checked iterators and disables iterator debugging.
// 2: (default) Enables iterator debugging; checked iterators are not relevant.
//
// Release build values (choose_your_value is 0 or 1)
// 0: (default) Disables checked iterators.
// 1: Enables checked iterators; iterator debugging is not relevant.
#if !defined(GTE_USE_DIRECTX) && !defined(GTE_USE_OPENGL)
#error At least one of GTE_USE_DIRECTX or GTE_USE_OPENGL must be defined.
#endif
// The preprocessor symbols include GTE_USE_ROW_MAJOR; matrices are stored
// in row-major order. If you want column-major-order matrices, remove this
// preprocessor symbol.
// The preprocessor symbols include GTE_USE_MAT_VEC; the action of a matrix M
// on a vector V is M*V. If you want the action to be V*M, remove this
// preprocessor symbol.
#if defined(GTE_USE_DIRECTX) && defined(GTE_USE_OPENGL)
#error Only one of GTE_USE_DIRECTX or GTE_USE_OPENGL must be defined.
#endif
#endif
+4 -5
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -14,7 +14,6 @@
#include <Applications/Console.h>
#include <Applications/ConsoleApplication.h>
#include <Applications/Environment.h>
#include <Applications/LogReporter.h>
#include <Applications/OnIdleTimer.h>
#include <Applications/Timer.h>
#include <Applications/TrackBall.h>
@@ -27,8 +26,6 @@
// Applications/MSW
#include <Applications/MSW/Console.h>
#include <Applications/MSW/ConsoleSystem.h>
#include <Applications/MSW/LogToMessageBox.h>
#include <Applications/MSW/LogToOutputWindow.h>
#include <Applications/MSW/Window.h>
#include <Applications/MSW/WindowSystem.h>
#include <Applications/MSW/WICFileIO.h>
@@ -40,3 +37,5 @@
#include <Applications/GLX/WindowSystem.h>
#include <Applications/GLX/WICFileIO.h>
#endif
+4 -2
View File
@@ -1,11 +1,13 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
// Define GTE_DISABLE_PCH to turn off the precompiled header system.
#ifndef GTE_DISABLE_PCH
#include <Applications/GTApplications.h>
#endif
-73
View File
@@ -1,73 +0,0 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#include <Applications/GTApplicationsPCH.h>
#include <Applications/LogReporter.h>
using namespace gte;
LogReporter::~LogReporter()
{
if (mLogToStdout)
{
Logger::Unsubscribe(mLogToStdout.get());
}
if (mLogToFile)
{
Logger::Unsubscribe(mLogToFile.get());
}
#if defined(GTE_USE_MSWINDOWS)
if (mLogToOutputWindow)
{
Logger::Unsubscribe(mLogToOutputWindow.get());
}
if (mLogToMessageBox)
{
Logger::Unsubscribe(mLogToMessageBox.get());
}
#endif
}
LogReporter::LogReporter(std::string const& logFile, int logFileFlags,
int logStdoutFlags, int logMessageBoxFlags, int logOutputWindowFlags)
:
mLogToFile(nullptr),
mLogToStdout(nullptr)
#if defined(GTE_USE_MSWINDOWS)
,
mLogToMessageBox(nullptr),
mLogToOutputWindow(nullptr)
#endif
{
if (logFileFlags != Logger::Listener::LISTEN_FOR_NOTHING)
{
mLogToFile = std::make_unique<LogToFile>(logFile, logFileFlags);
Logger::Subscribe(mLogToFile.get());
}
if (logStdoutFlags != Logger::Listener::LISTEN_FOR_NOTHING)
{
mLogToStdout = std::make_unique<LogToStdout>(logStdoutFlags);
Logger::Subscribe(mLogToStdout.get());
}
#if defined(GTE_USE_MSWINDOWS)
if (logMessageBoxFlags != Logger::Listener::LISTEN_FOR_NOTHING)
{
mLogToMessageBox = std::make_unique<LogToMessageBox>(logMessageBoxFlags);
Logger::Subscribe(mLogToMessageBox.get());
}
if (logOutputWindowFlags != Logger::Listener::LISTEN_FOR_NOTHING)
{
mLogToOutputWindow = std::make_unique<LogToOutputWindow>(logOutputWindowFlags);
Logger::Subscribe(mLogToOutputWindow.get());
}
#endif
}
-41
View File
@@ -1,41 +0,0 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#pragma once
#include <Mathematics/LogToFile.h>
#include <Mathematics/LogToStdout.h>
#if defined(GTE_USE_MSWINDOWS)
#include <Applications/MSW/LogToMessageBox.h>
#include <Applications/MSW/LogToOutputWindow.h>
#endif
#include <memory>
namespace gte
{
class LogReporter
{
public:
// Construction and destruction. Create one of these objects in an
// application for logging. The GenerateProject tool creates such
// code. If you do not want a particular logger, set the flags to
// LISTEN_FOR_NOTHING and set logFile to "" if you do not want a file.
~LogReporter();
LogReporter(std::string const& logFile, int logFileFlags, int logStdoutFlags,
int logMessageBoxFlags = 0, int logOutputWindowFlags = 0);
private:
std::unique_ptr<LogToFile> mLogToFile;
std::unique_ptr<LogToStdout> mLogToStdout;
#if defined(GTE_USE_MSWINDOWS)
std::unique_ptr<LogToMessageBox> mLogToMessageBox;
std::unique_ptr<LogToOutputWindow> mLogToOutputWindow;
#endif
};
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/Console.h>
@@ -32,3 +32,5 @@ Console::Console(Parameters& parameters)
mEngine(std::static_pointer_cast<GraphicsEngine>(mBaseEngine))
{
}
+8 -6
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -24,15 +24,15 @@ namespace gte
// For DX11, the device creation flags are passed to the function
// D3D11CreateDevice during construction of a DX11Engine object.
// See the documentation for D3D11CreateDevice for the available
// flags. For GL45, set the flags to 0 for the default behavior;
// no additional semantics occur on GL45Engine construction. Set
// bit 0 of the flag to 1 to tell the GL45Engine construction to
// flags. For GL46, set the flags to 0 for the default behavior;
// no additional semantics occur on GL46Engine construction. Set
// bit 0 of the flag to 1 to tell the GL46Engine construction to
// write a text file that contains the OpenGL driver information.
// The default value is 0. When bit 0 is set to 1, a text file
// named OpenGLDriverInfo.txt is generated that contains the
// OpenGL driver information. Other bit flags may be defined at
// a later date.
unsigned int deviceCreationFlags;
uint32_t deviceCreationFlags;
};
public:
@@ -55,3 +55,5 @@ namespace gte
// previously in this file and is known to the compiler when it includes this
// file.
#include <Applications/MSW/ConsoleSystem.h>
+40 -4
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/Console.h>
@@ -16,9 +16,43 @@ namespace gte
}
#if defined(GTE_USE_DIRECTX)
#include <Graphics/DX11/DXGIAdapter.h>
void ConsoleSystem::CreateEngineAndProgramFactory(Console::Parameters& parameters)
{
auto engine = std::make_shared<DX11Engine>(nullptr, D3D_DRIVER_TYPE_HARDWARE,
// The adapterManager must be declared outside the if-then-else
// statement so that it persists long enough to create the 'engine'
// object.
DXGIAdapter adapterManager;
IDXGIAdapter* adapter = nullptr;
if ((parameters.deviceCreationFlags & D3D11_CREATE_DEVICE_DEBUG) == 0)
{
// The GPU adapter is selected using the following algorithm. If a
// discrete adapter is available (NVIDIA, AMD or other manufacturer),
// it is selected. If a discrete adapter is not available, Intel
// Integrated Graphics is chosen. Although these days Intel Core
// architecture is the norm, in the event Intel Integrated Graphics is
// not found, the fallback is to Microsoft WARP which is a software
// implementation for DirectX 11 that is multithreaded and has decent
// performance.
adapterManager = DXGIAdapter::GetMostPowerful();
adapter = adapterManager.GetAdapter();
}
else
{
// If parameters.deviceCreationFlags is 0 (no flags specified), the
// first adapter in the adapter enumeration is selected. This is
// invariably the adapter to which the display monitors are attached.
//
// If the debug layer is selected using D3D11_CREATE_DEVICE_DEBUG,
// choosing a non-null adapter does not work. It will cause the
// D3D11CreateDevice funtion to throw an exception and not return
// an HRESULT code.
adapter = nullptr;
}
auto engine = std::make_shared<DX11Engine>(adapter, D3D_DRIVER_TYPE_HARDWARE,
nullptr, parameters.deviceCreationFlags);
if (engine->GetDevice())
@@ -41,7 +75,7 @@ void ConsoleSystem::CreateEngineAndProgramFactory(Console::Parameters& parameter
auto engine = std::make_shared<WGLEngine>(false, saveDriverInfo);
if (!engine->MeetsRequirements())
{
LogError("OpenGL 4.5 or later is required.");
LogError("OpenGL 4.6 or later is required.");
}
if (engine->GetDevice())
@@ -56,3 +90,5 @@ void ConsoleSystem::CreateEngineAndProgramFactory(Console::Parameters& parameter
}
}
#endif
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -62,3 +62,5 @@ namespace gte
extern ConsoleSystem TheConsoleSystem;
}
-44
View File
@@ -1,44 +0,0 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/LogToMessageBox.h>
#include <Windows.h>
using namespace gte;
LogToMessageBox::LogToMessageBox(int flags)
:
Logger::Listener(flags)
{
}
void LogToMessageBox::Report(std::string const& message)
{
std::string output = message + "Do you want to debug?";
std::wstring text(output.begin(), output.end());
int selection = MessageBox(nullptr, text.c_str(), L"Report",
MB_ICONERROR | MB_YESNOCANCEL | MB_APPLMODAL | MB_TOPMOST);
switch (selection)
{
case IDYES:
// Break and debug.
__debugbreak();
break;
case IDNO:
// Continue execution.
break;
case IDCANCEL:
default:
// Terminate execution.
exit(0);
break;
}
}
-22
View File
@@ -1,22 +0,0 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#pragma once
#include <Mathematics/Logger.h>
namespace gte
{
class LogToMessageBox : public Logger::Listener
{
public:
LogToMessageBox(int flags);
private:
virtual void Report(std::string const& message);
};
}
@@ -1,23 +0,0 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/LogToOutputWindow.h>
#include <Windows.h>
using namespace gte;
LogToOutputWindow::LogToOutputWindow(int flags)
:
Logger::Listener(flags)
{
}
void LogToOutputWindow::Report(std::string const& message)
{
std::wstring text(message.begin(), message.end());
OutputDebugString(text.c_str());
}
-22
View File
@@ -1,22 +0,0 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
#pragma once
#include <Mathematics/Logger.h>
namespace gte
{
class LogToOutputWindow : public Logger::Listener
{
public:
LogToOutputWindow(int flags);
private:
virtual void Report(std::string const& message);
};
}
+10 -7
View File
@@ -1,12 +1,13 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.06.06
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/WICFileIO.h>
#include <Mathematics/Logger.h>
using namespace gte;
std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool wantMipmaps)
@@ -15,7 +16,7 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
auto creator = [&texture, &wantMipmaps](uint32_t format, size_t width, size_t height)
{
DFType type = msFormatToDFType[format];
uint32_t type = msFormatToDFType[format];
texture = std::make_shared<Texture2>(type, static_cast<uint32_t>(width),
static_cast<uint32_t>(height), wantMipmaps);
return texture->Get<uint8_t>();
@@ -27,13 +28,13 @@ std::shared_ptr<Texture2> WICFileIO::Load(std::string const& filename, bool want
}
std::shared_ptr<Texture2> WICFileIO::Load(void* module, std::string const& rtype,
int resource, bool wantMipmaps)
int32_t resource, bool wantMipmaps)
{
std::shared_ptr<Texture2> texture;
auto creator = [&texture, &wantMipmaps](uint32_t format, size_t width, size_t height)
{
DFType type = msFormatToDFType[format];
uint32_t type = msFormatToDFType[format];
texture = std::make_shared<Texture2>(type, static_cast<uint32_t>(width),
static_cast<uint32_t>(height), wantMipmaps);
return texture->Get<uint8_t>();
@@ -60,7 +61,7 @@ void WICFileIO::SaveToJPEG(std::string const& filename,
texture->GetHeight(), texture->Get<uint8_t>(), imageQuality);
}
uint32_t WICFileIO::DFTypeToFormat(DFType type)
uint32_t WICFileIO::DFTypeToFormat(uint32_t type)
{
switch (type)
{
@@ -90,7 +91,7 @@ uint32_t WICFileIO::DFTypeToFormat(DFType type)
}
std::array<DFType, WICFileIO::NUM_SUPPORTED_FORMATS> const
std::array<uint32_t, WICFileIO::NUM_SUPPORTED_FORMATS> const
WICFileIO::msFormatToDFType =
{
DF_R10G10B10A2_UNORM,
@@ -104,3 +105,5 @@ WICFileIO::msFormatToDFType =
DF_R16_UNORM,
DF_R8G8B8A8_UNORM
};
+7 -5
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.06.06
// File Version: 8.0.2025.05.10
#pragma once
@@ -64,7 +64,7 @@ namespace gte
// HMODULE. The use of void* avoids having to expose the windows.h
// header file to other source files.
static std::shared_ptr<Texture2> Load(void* module, std::string const& rtype,
int resource, bool wantMipmaps);
int32_t resource, bool wantMipmaps);
// Support for saving to PNG or JPEG.
//
@@ -97,9 +97,11 @@ namespace gte
std::shared_ptr<Texture2> const& texture, float imageQuality);
private:
static uint32_t DFTypeToFormat(DFType type);
static uint32_t DFTypeToFormat(uint32_t type);
static size_t constexpr NUM_SUPPORTED_FORMATS = 10;
static std::array<DFType, NUM_SUPPORTED_FORMATS> const msFormatToDFType;
static std::array<uint32_t, NUM_SUPPORTED_FORMATS> const msFormatToDFType;
};
}
+12 -15
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.7.2021.05.27
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/WICFileIONative.h>
@@ -136,7 +136,7 @@ void WICFileIONative::Load(std::string const& filename, TextureCreator const& cr
}
void WICFileIONative::Load(void* module, std::string const& rtype,
int resource, uint32_t& outFormat, size_t& outWidth, size_t& outHeight,
int32_t resource, uint32_t& outFormat, size_t& outWidth, size_t& outHeight,
std::vector<uint8_t>& outTexels)
{
auto const* bytesPerTexel = msBytesPerTexel.data();
@@ -155,7 +155,7 @@ void WICFileIONative::Load(void* module, std::string const& rtype,
}
void WICFileIONative::Load(void* module, std::string const& rtype,
int resource, TextureCreator const& creator)
int32_t resource, TextureCreator const& creator)
{
// Start COM and create WIC.
ComInitializer comInitializer;
@@ -439,15 +439,16 @@ void WICFileIONative::SaveTo(std::string const& filename, uint32_t inFormat,
throw std::runtime_error("wicEncoder->CreateNewFrame failed.");
}
// Set the options for the PNG encoder.
PROPBAG2 option{};
VARIANT varValue{};
ZeroMemory(&option, sizeof(option));
VariantInit(&varValue);
if (imageQuality == -1.0f)
{
// Set the options for the PNG encoder.
PROPBAG2 option = { 0 };
VARIANT varValue;
// Default subsampling.
option.pstrName = const_cast<LPOLESTR>(L"InterlaceOption");
VariantInit(&varValue);
varValue.vt = VT_BOOL;
varValue.boolVal = FALSE;
hr = wicPropertyBag->Write(1, &option, &varValue);
@@ -458,7 +459,6 @@ void WICFileIONative::SaveTo(std::string const& filename, uint32_t inFormat,
// Disable filtering.
option.pstrName = const_cast<LPOLESTR>(L"FilterOption");
VariantInit(&varValue);
varValue.vt = VT_UI1;
varValue.bVal = WICPngFilterNone;
hr = wicPropertyBag->Write(1, &option, &varValue);
@@ -469,13 +469,8 @@ void WICFileIONative::SaveTo(std::string const& filename, uint32_t inFormat,
}
else
{
// Set the options for the PNG encoder.
PROPBAG2 option = { 0 };
VARIANT varValue;
// Set image quality, a number in [0,1].
option.pstrName = const_cast<LPOLESTR>(L"ImageQuality");
VariantInit(&varValue);
varValue.vt = VT_R4;
varValue.fltVal = imageQuality;
hr = wicPropertyBag->Write(1, &option, &varValue);
@@ -626,3 +621,5 @@ WICFileIONative::msSaveFormatMap =
{ B8G8R8A8, &GUID_WICPixelFormat32bppBGRA },
{ R16G16B16A16, &GUID_WICPixelFormat64bppRGBA }
} };
+6 -4
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.7.2020.06.06
// File Version: 8.0.2025.05.10
#pragma once
@@ -86,13 +86,13 @@ namespace gte
// Load from a resource with direct output. The input 'module' is an
// HMODULE. The use of void* avoids having to expose the windows.h
// header file to other source files.
static void Load(void* module, std::string const& rtype, int resource,
static void Load(void* module, std::string const& rtype, int32_t resource,
uint32_t& outFormat, size_t& outWidth, size_t& outHeight,
std::vector<uint8_t>& outTexels);
// Load from a resource with indirect output stored in the object
// created by 'creator'.
static void Load(void* module, std::string const& rtype, int resource,
static void Load(void* module, std::string const& rtype, int32_t resource,
TextureCreator const& creator);
// Support for saving to PNG or JPEG.
@@ -164,3 +164,5 @@ namespace gte
static std::array<SaveFormatMap, NUM_SAVE_FORMATS> const msSaveFormatMap;
};
}
+68 -64
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/Window.h>
@@ -12,6 +12,7 @@ using namespace gte;
Window::Parameters::Parameters()
:
handle(nullptr),
parent(nullptr),
hscrollBar(false),
vscrollBar(false),
deviceCreationFlags(0)
@@ -19,10 +20,11 @@ Window::Parameters::Parameters()
}
Window::Parameters::Parameters(std::wstring const& inTitle,
int inXOrigin, int inYOrigin, int inXSize, int inYSize)
int32_t inXOrigin, int32_t inYOrigin, int32_t inXSize, int32_t inYSize)
:
WindowApplication::Parameters(inTitle, inXOrigin, inYOrigin, inXSize, inYSize),
handle(nullptr),
parent(nullptr),
hscrollBar(false),
vscrollBar(false),
deviceCreationFlags(0)
@@ -52,7 +54,7 @@ Window::Window(Parameters& parameters)
// directly via class members.
mHasScroll[0] = parameters.hscrollBar;
mHasScroll[1] = parameters.vscrollBar;
for (int i = 0; i < 2; ++i)
for (int32_t i = 0; i < 2; ++i)
{
ZeroMemory(&mScrollInfo[i], sizeof(SCROLLINFO));
mScrollInfo[i].cbSize = sizeof(SCROLLINFO);
@@ -69,20 +71,20 @@ void Window::SetTitle(std::wstring const& title)
SetWindowText(mHandle, title.c_str());
}
void Window::SetMousePosition(int x, int y)
void Window::SetMousePosition(int32_t x, int32_t y)
{
POINT point = { static_cast<LONG>(x), static_cast<LONG>(y) };
ClientToScreen(mHandle, &point);
SetCursorPos(point.x, point.y);
}
void Window::GetMousePosition(int& x, int& y) const
void Window::GetMousePosition(int32_t& x, int32_t& y) const
{
POINT point;
GetCursorPos(&point);
ScreenToClient(mHandle, &point);
x = static_cast<int>(point.x);
y = static_cast<int>(point.y);
x = static_cast<int32_t>(point.x);
y = static_cast<int32_t>(point.y);
}
void Window::OnClose()
@@ -90,7 +92,7 @@ void Window::OnClose()
PostQuitMessage(0);
}
void Window::SetScrollInterval(int bar, int minValue, int maxValue)
void Window::SetScrollInterval(int32_t bar, int32_t minValue, int32_t maxValue)
{
mScrollInfo[bar].fMask = SIF_RANGE;
mScrollInfo[bar].nMin = minValue;
@@ -98,7 +100,7 @@ void Window::SetScrollInterval(int bar, int minValue, int maxValue)
SetScrollInfo(mHandle, bar, &mScrollInfo[bar], FALSE);
}
void Window::GetScrollInterval(int bar, int& minValue, int& maxValue) const
void Window::GetScrollInterval(int32_t bar, int32_t& minValue, int32_t& maxValue) const
{
mScrollInfo[bar].fMask = SIF_RANGE;
GetScrollInfo(mHandle, bar, &mScrollInfo[bar]);
@@ -106,26 +108,26 @@ void Window::GetScrollInterval(int bar, int& minValue, int& maxValue) const
maxValue = mScrollInfo[bar].nMax;
}
int Window::SetScrollPosition(int bar, int value)
int32_t Window::SetScrollPosition(int32_t bar, int32_t value)
{
mScrollInfo[bar].fMask = SIF_POS;
mScrollInfo[bar].nPos = value;
return SetScrollInfo(mHandle, bar, &mScrollInfo[bar], FALSE);
}
int Window::GetScrollPosition(int bar) const
int32_t Window::GetScrollPosition(int32_t bar) const
{
mScrollInfo[bar].fMask = SIF_POS;
GetScrollInfo(mHandle, bar, &mScrollInfo[bar]);
return mScrollInfo[bar].nPos;
}
int Window::OnScrollIncrementLoRes(int bar)
int32_t Window::OnScrollIncrementLoRes(int32_t bar)
{
SCROLLINFO& info = mScrollInfo[bar];
info.fMask = SIF_POS;
GetScrollInfo(mHandle, bar, &info);
int delta = info.nMax - info.nPos;
int32_t delta = info.nMax - info.nPos;
if (delta > 0)
{
delta = std::min(delta, mScrollLoResDelta[bar]);
@@ -135,12 +137,12 @@ int Window::OnScrollIncrementLoRes(int bar)
return delta;
}
int Window::OnScrollDecrementLoRes(int bar)
int32_t Window::OnScrollDecrementLoRes(int32_t bar)
{
SCROLLINFO& info = mScrollInfo[bar];
info.fMask = SIF_POS;
GetScrollInfo(mHandle, bar, &info);
int delta = info.nPos - info.nMin;
int32_t delta = info.nPos - info.nMin;
if (delta > 0)
{
delta = std::min(delta, mScrollLoResDelta[bar]);
@@ -150,12 +152,12 @@ int Window::OnScrollDecrementLoRes(int bar)
return delta;
}
int Window::OnScrollIncrementHiRes(int bar)
int32_t Window::OnScrollIncrementHiRes(int32_t bar)
{
SCROLLINFO& info = mScrollInfo[bar];
info.fMask = SIF_POS;
GetScrollInfo(mHandle, bar, &info);
int delta = info.nMax - info.nPos;
int32_t delta = info.nMax - info.nPos;
if (delta > 0)
{
delta = std::min(delta, mScrollHiResDelta[bar]);
@@ -165,12 +167,12 @@ int Window::OnScrollIncrementHiRes(int bar)
return delta;
}
int Window::OnScrollDecrementHiRes(int bar)
int32_t Window::OnScrollDecrementHiRes(int32_t bar)
{
SCROLLINFO& info = mScrollInfo[bar];
info.fMask = SIF_POS;
GetScrollInfo(mHandle, bar, &info);
int delta = info.nPos - info.nMin;
int32_t delta = info.nPos - info.nMin;
if (delta > 0)
{
delta = std::min(delta, mScrollHiResDelta[bar]);
@@ -180,7 +182,7 @@ int Window::OnScrollDecrementHiRes(int bar)
return delta;
}
int Window::OnScrollTracking(int bar)
int32_t Window::OnScrollTracking(int32_t bar)
{
SCROLLINFO& info = mScrollInfo[bar];
info.fMask = SIF_TRACKPOS;
@@ -188,7 +190,7 @@ int Window::OnScrollTracking(int bar)
return info.nTrackPos;
}
int Window::OnScrollEndTracking(int bar)
int32_t Window::OnScrollEndTracking(int32_t bar)
{
SCROLLINFO& info = mScrollInfo[bar];
info.fMask = SIF_TRACKPOS;
@@ -201,48 +203,50 @@ int Window::OnScrollEndTracking(int bar)
// Class-static constants for Microsoft Windows applications.
int const WindowApplication::KEY_ESCAPE = VK_ESCAPE;
int const WindowApplication::KEY_LEFT = VK_LEFT;
int const WindowApplication::KEY_RIGHT = VK_RIGHT;
int const WindowApplication::KEY_UP = VK_UP;
int const WindowApplication::KEY_DOWN = VK_DOWN;
int const WindowApplication::KEY_HOME = VK_HOME;
int const WindowApplication::KEY_END = VK_END;
int const WindowApplication::KEY_PAGE_UP = VK_PRIOR;
int const WindowApplication::KEY_PAGE_DOWN = VK_NEXT;
int const WindowApplication::KEY_INSERT = VK_INSERT;
int const WindowApplication::KEY_DELETE = VK_DELETE;
int const WindowApplication::KEY_F1 = VK_F1;
int const WindowApplication::KEY_F2 = VK_F2;
int const WindowApplication::KEY_F3 = VK_F3;
int const WindowApplication::KEY_F4 = VK_F4;
int const WindowApplication::KEY_F5 = VK_F5;
int const WindowApplication::KEY_F6 = VK_F6;
int const WindowApplication::KEY_F7 = VK_F7;
int const WindowApplication::KEY_F8 = VK_F8;
int const WindowApplication::KEY_F9 = VK_F9;
int const WindowApplication::KEY_F10 = VK_F10;
int const WindowApplication::KEY_F11 = VK_F11;
int const WindowApplication::KEY_F12 = VK_F12;
int const WindowApplication::KEY_BACKSPACE = VK_BACK;
int const WindowApplication::KEY_TAB = VK_TAB;
int const WindowApplication::KEY_ENTER = VK_RETURN;
int const WindowApplication::KEY_RETURN = VK_RETURN;
int32_t const WindowApplication::KEY_ESCAPE = VK_ESCAPE;
int32_t const WindowApplication::KEY_LEFT = VK_LEFT;
int32_t const WindowApplication::KEY_RIGHT = VK_RIGHT;
int32_t const WindowApplication::KEY_UP = VK_UP;
int32_t const WindowApplication::KEY_DOWN = VK_DOWN;
int32_t const WindowApplication::KEY_HOME = VK_HOME;
int32_t const WindowApplication::KEY_END = VK_END;
int32_t const WindowApplication::KEY_PAGE_UP = VK_PRIOR;
int32_t const WindowApplication::KEY_PAGE_DOWN = VK_NEXT;
int32_t const WindowApplication::KEY_INSERT = VK_INSERT;
int32_t const WindowApplication::KEY_DELETE = VK_DELETE;
int32_t const WindowApplication::KEY_F1 = VK_F1;
int32_t const WindowApplication::KEY_F2 = VK_F2;
int32_t const WindowApplication::KEY_F3 = VK_F3;
int32_t const WindowApplication::KEY_F4 = VK_F4;
int32_t const WindowApplication::KEY_F5 = VK_F5;
int32_t const WindowApplication::KEY_F6 = VK_F6;
int32_t const WindowApplication::KEY_F7 = VK_F7;
int32_t const WindowApplication::KEY_F8 = VK_F8;
int32_t const WindowApplication::KEY_F9 = VK_F9;
int32_t const WindowApplication::KEY_F10 = VK_F10;
int32_t const WindowApplication::KEY_F11 = VK_F11;
int32_t const WindowApplication::KEY_F12 = VK_F12;
int32_t const WindowApplication::KEY_BACKSPACE = VK_BACK;
int32_t const WindowApplication::KEY_TAB = VK_TAB;
int32_t const WindowApplication::KEY_ENTER = VK_RETURN;
int32_t const WindowApplication::KEY_RETURN = VK_RETURN;
int const WindowApplication::KEY_SHIFT = VK_SHIFT;
int const WindowApplication::KEY_CONTROL = VK_CONTROL;
int const WindowApplication::KEY_ALT = 0; // not currently handled
int const WindowApplication::KEY_COMMAND = 0; // not currently handled
int32_t const WindowApplication::KEY_SHIFT = VK_SHIFT;
int32_t const WindowApplication::KEY_CONTROL = VK_CONTROL;
int32_t const WindowApplication::KEY_ALT = 0; // not currently handled
int32_t const WindowApplication::KEY_COMMAND = 0; // not currently handled
int32_t const WindowApplication::MOUSE_NONE = 0;
int32_t const WindowApplication::MOUSE_LEFT = 1;
int32_t const WindowApplication::MOUSE_MIDDLE = 2;
int32_t const WindowApplication::MOUSE_RIGHT= 3;
int32_t const WindowApplication::MOUSE_UP = 0;
int32_t const WindowApplication::MOUSE_DOWN = 1;
int32_t const WindowApplication::MODIFIER_CONTROL = MK_CONTROL;
int32_t const WindowApplication::MODIFIER_LBUTTON = MK_LBUTTON;
int32_t const WindowApplication::MODIFIER_MBUTTON = MK_MBUTTON;
int32_t const WindowApplication::MODIFIER_RBUTTON = MK_RBUTTON;
int32_t const WindowApplication::MODIFIER_SHIFT = MK_SHIFT;
int const WindowApplication::MOUSE_NONE = 0;
int const WindowApplication::MOUSE_LEFT = 1;
int const WindowApplication::MOUSE_MIDDLE = 2;
int const WindowApplication::MOUSE_RIGHT= 3;
int const WindowApplication::MOUSE_UP = 0;
int const WindowApplication::MOUSE_DOWN = 1;
int const WindowApplication::MODIFIER_CONTROL = MK_CONTROL;
int const WindowApplication::MODIFIER_LBUTTON = MK_LBUTTON;
int const WindowApplication::MODIFIER_MBUTTON = MK_MBUTTON;
int const WindowApplication::MODIFIER_RBUTTON = MK_RBUTTON;
int const WindowApplication::MODIFIER_SHIFT = MK_SHIFT;
+23 -20
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -31,17 +31,18 @@ namespace gte
Parameters();
Parameters(std::wstring const& inTitle,
int inXOrigin, int inYOrigin, int inXSize, int inYSize);
int32_t inXOrigin, int32_t inYOrigin, int32_t inXSize, int32_t inYSize);
HWND handle;
HWND parent;
bool hscrollBar, vscrollBar;
// For DX11, the device creation flags are passed to the function
// D3D11CreateDevice during construction of a DX11Engine object.
// See the documentation for D3D11CreateDevice for the available
// flags. For GL45, set the flags to 0 for the default behavior;
// no additional semantics occur on GL45Engine construction. Set
// bit 0 of the flag to 1 to tell the GL45Engine construction to
// flags. For GL46, set the flags to 0 for the default behavior;
// no additional semantics occur on GL46Engine construction. Set
// bit 0 of the flag to 1 to tell the GL46Engine construction to
// write a text file that contains the OpenGL driver information.
// The default value is 0. When bit 0 is set to 1, a text file
// named OpenGLDriverInfo.txt is generated that contains the
@@ -62,30 +63,30 @@ namespace gte
virtual void SetTitle(std::wstring const& title) override;
// Mouse position information.
virtual void SetMousePosition(int x, int y) override;
virtual void GetMousePosition(int& x, int& y) const override;
virtual void SetMousePosition(int32_t x, int32_t y) override;
virtual void GetMousePosition(int32_t& x, int32_t& y) const override;
// Actions to take before the window closes.
virtual void OnClose() override;
// Scroll support. The 'bar' value is 0 for horizontal scroll bars
// or 1 for vertical scroll bars.
void SetScrollInterval(int bar, int minValue, int maxValue);
void GetScrollInterval(int bar, int& minValue, int& maxValue) const;
int SetScrollPosition(int bar, int value);
int GetScrollPosition(int bar) const;
void SetScrollInterval(int32_t bar, int32_t minValue, int32_t maxValue);
void GetScrollInterval(int32_t bar, int32_t& minValue, int32_t& maxValue) const;
int32_t SetScrollPosition(int32_t bar, int32_t value);
int32_t GetScrollPosition(int32_t bar) const;
// The return value of the increment/decrement functions is the delta
// of the slider thumb. If zero, the scroll state did not change.
// For the tracking functions, the return value is the current slider
// thumb position. A derived-class override must call the base-class
// function first.
int OnScrollIncrementLoRes(int bar);
int OnScrollDecrementLoRes(int bar);
int OnScrollIncrementHiRes(int bar);
int OnScrollDecrementHiRes(int bar);
int OnScrollTracking(int bar);
int OnScrollEndTracking(int bar);
int32_t OnScrollIncrementLoRes(int32_t bar);
int32_t OnScrollDecrementLoRes(int32_t bar);
int32_t OnScrollIncrementHiRes(int32_t bar);
int32_t OnScrollDecrementHiRes(int32_t bar);
int32_t OnScrollTracking(int32_t bar);
int32_t OnScrollEndTracking(int32_t bar);
protected:
Window(Parameters& parameters);
@@ -96,8 +97,8 @@ namespace gte
// Scroll bar support.
bool mHasScroll[2];
mutable SCROLLINFO mScrollInfo[2];
int mScrollLoResDelta[2];
int mScrollHiResDelta[2];
int32_t mScrollLoResDelta[2];
int32_t mScrollHiResDelta[2];
// TODO: This is assigned mBaseEngine, which allows development of
// the DX12 engine independently of DX11 and WGL. The DX12 engine
@@ -112,3 +113,5 @@ namespace gte
// previously in this file and is known to the compiler when it includes this
// file.
#include <Applications/MSW/WindowSystem.h>
+66 -50
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2020.04.12
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/MSW/Window.h>
@@ -17,7 +17,7 @@ namespace gte
WindowSystem::~WindowSystem()
{
if (mHandleMap.size() == 0 && mAtom)
if (mHandleMap.empty() && mAtom)
{
UnregisterClass(mWindowClassName, nullptr);
}
@@ -28,7 +28,7 @@ WindowSystem::WindowSystem()
mWindowClassName(L"GTEngineWindow"),
mAtom(0)
{
WNDCLASS wc;
WNDCLASS wc{};
wc.style = CS_OWNDC;
wc.lpfnWndProc = WindowProcedure;
wc.cbClsExtra = 0;
@@ -42,7 +42,7 @@ WindowSystem::WindowSystem()
mAtom = RegisterClass(&wc);
}
bool WindowSystem::GetWindowRectangle(int xClientSize, int yClientSize,
bool WindowSystem::GetWindowRectangle(int32_t xClientSize, int32_t yClientSize,
DWORD style, RECT& windowRectangle)
{
windowRectangle.left = 0;
@@ -81,11 +81,11 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
style, rectangle);
if (adjusted)
{
int adjustedXSize = (int)rectangle.right - (int)rectangle.left + 1;
int adjustedYSize = (int)rectangle.bottom - (int)rectangle.top + 1;
int32_t adjustedXSize = (int32_t)rectangle.right - (int32_t)rectangle.left + 1;
int32_t adjustedYSize = (int32_t)rectangle.bottom - (int32_t)rectangle.top + 1;
parameters.handle = CreateWindow(mWindowClassName,
parameters.title.c_str(), style, parameters.xOrigin,
parameters.yOrigin, adjustedXSize, adjustedYSize, nullptr,
parameters.yOrigin, adjustedXSize, adjustedYSize, parameters.parent,
nullptr, nullptr, nullptr);
// AdjustWindowRect decides that scroll bars cover client space,
@@ -94,8 +94,8 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
if (parameters.hscrollBar || parameters.vscrollBar)
{
GetClientRect(parameters.handle, &rectangle);
int clientXSize = (int)rectangle.right - (int)rectangle.left;
int clientYSize = (int)rectangle.bottom - (int)rectangle.top;
int32_t clientXSize = (int32_t)rectangle.right - (int32_t)rectangle.left;
int32_t clientYSize = (int32_t)rectangle.bottom - (int32_t)rectangle.top;
if (clientXSize != parameters.xSize
|| clientYSize != parameters.ySize)
{
@@ -105,7 +105,7 @@ void WindowSystem::CreateFrom(Window::Parameters& parameters)
parameters.handle = CreateWindow(mWindowClassName,
parameters.title.c_str(), style, parameters.xOrigin,
parameters.yOrigin, adjustedXSize, adjustedYSize,
0, 0, 0, 0);
parameters.parent, nullptr, nullptr, nullptr);
GetClientRect(parameters.handle, &rectangle);
}
}
@@ -146,7 +146,7 @@ void WindowSystem::CreateEngineAndProgramFactory(Window::Parameters& parameters)
{
// If parameters.deviceCreationFlags is 0 (no flags specified), the
// first adapter in the adapter enumeration is selected. This is
// invariable the adapter to which the display monitors are attached.
// invariably the adapter to which the display monitors are attached.
//
// If the debug layer is selected using D3D11_CREATE_DEVICE_DEBUG,
// choosing a non-null adapter does not work. It will cause the
@@ -181,7 +181,7 @@ void WindowSystem::CreateEngineAndProgramFactory(Window::Parameters& parameters)
parameters.useDepth24Stencil8, saveDriverInfo);
if (!engine->MeetsRequirements())
{
LogError("OpenGL 4.5 or later is required.");
LogError("OpenGL 4.6 or later is required.");
}
if (engine->GetDevice())
@@ -189,6 +189,7 @@ void WindowSystem::CreateEngineAndProgramFactory(Window::Parameters& parameters)
parameters.engine = engine;
parameters.factory = std::make_shared<GLSLProgramFactory>();
parameters.created = true;
engine->DisplayColorBuffer(0);
}
else
{
@@ -197,16 +198,16 @@ void WindowSystem::CreateEngineAndProgramFactory(Window::Parameters& parameters)
}
#endif
void WindowSystem::Extract(LPARAM lParam, int& x, int& y)
void WindowSystem::Extract(LPARAM lParam, int32_t& x, int32_t& y)
{
x = static_cast<int>(static_cast<short>(lParam & 0xFFFF));
y = static_cast<int>(static_cast<short>((lParam & 0xFFFF0000) >> 16));
x = static_cast<int32_t>(static_cast<int16_t>(lParam & 0xFFFF));
y = static_cast<int32_t>(static_cast<int16_t>((lParam & 0xFFFF0000) >> 16));
}
void WindowSystem::Extract(WPARAM wParam, int& x, int& y)
void WindowSystem::Extract(WPARAM wParam, int32_t& x, int32_t& y)
{
x = static_cast<int>(static_cast<short>(wParam & 0xFFFF));
y = static_cast<int>(static_cast<short>((wParam & 0xFFFF0000) >> 16));
x = static_cast<int32_t>(static_cast<int16_t>(wParam & 0xFFFF));
y = static_cast<int32_t>(static_cast<int16_t>((wParam & 0xFFFF0000) >> 16));
}
LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
@@ -220,6 +221,14 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
Window& window = *iter->second;
LRESULT lResult = 0;
if (window.OnWindowsMessage(handle, message, wParam, lParam, lResult))
{
// The 'window' does not want the message interpreted by the switch
// statement below.
return lResult;
}
switch (message)
{
case WM_PAINT:
@@ -240,7 +249,7 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
{
// Get the origin of the moved window. The y-value for window
// moves is left-handed.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMove(x, y);
return 0;
@@ -248,7 +257,7 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_SIZE:
{
// Get the new size of the window.
int xSize, ySize;
int32_t xSize, ySize;
Extract(lParam, xSize, ySize);
if (wParam == SIZE_MINIMIZED)
@@ -271,14 +280,14 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_CHAR:
{
// Get thet translated key code.
unsigned char key = static_cast<unsigned char>(static_cast<char>(wParam));
uint8_t key = static_cast<uint8_t>(static_cast<char>(wParam));
// Get the cursor position in client coordinates.
POINT point;
GetCursorPos(&point);
ScreenToClient(handle, &point);
int x = static_cast<int>(point.x);
int y = static_cast<int>(point.y);
int32_t x = static_cast<int32_t>(point.x);
int32_t y = static_cast<int32_t>(point.y);
window.OnCharPress(key, x, y);
return 0;
@@ -286,14 +295,14 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_KEYDOWN:
{
// Get the virtual key code.
int key = static_cast<int>(wParam);
int32_t key = static_cast<int32_t>(wParam);
// Get the cursor position in client coordinates.
POINT point;
GetCursorPos(&point);
ScreenToClient(handle, &point);
int x = static_cast<int>(point.x);
int y = static_cast<int>(point.y);
int32_t x = static_cast<int32_t>(point.x);
int32_t y = static_cast<int32_t>(point.y);
window.OnKeyDown(key, x, y);
return 0;
@@ -301,14 +310,14 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_KEYUP:
{
// Get the virtual key code.
int key = static_cast<int>(wParam);
int32_t key = static_cast<int32_t>(wParam);
// Get the cursor position in client coordinates.
POINT point;
GetCursorPos(&point);
ScreenToClient(handle, &point);
int x = static_cast<int>(point.x);
int y = static_cast<int>(point.y);
int32_t x = static_cast<int32_t>(point.x);
int32_t y = static_cast<int32_t>(point.y);
window.OnKeyUp(key, x, y);
return 0;
@@ -316,10 +325,10 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_LBUTTONDOWN:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMouseClick(WindowApplication::MOUSE_LEFT, WindowApplication::MOUSE_DOWN,
@@ -329,10 +338,10 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_LBUTTONUP:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMouseClick(WindowApplication::MOUSE_LEFT, WindowApplication::MOUSE_UP,
@@ -342,10 +351,10 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_MBUTTONDOWN:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMouseClick(WindowApplication::MOUSE_MIDDLE, WindowApplication::MOUSE_DOWN,
@@ -355,10 +364,10 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_MBUTTONUP:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMouseClick(WindowApplication::MOUSE_MIDDLE, WindowApplication::MOUSE_UP,
@@ -368,10 +377,10 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_RBUTTONDOWN:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMouseClick(WindowApplication::MOUSE_RIGHT, WindowApplication::MOUSE_DOWN,
@@ -381,10 +390,10 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_RBUTTONUP:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
window.OnMouseClick(WindowApplication::MOUSE_RIGHT, WindowApplication::MOUSE_UP,
@@ -394,13 +403,13 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_MOUSEMOVE:
{
// Get the modifier flags.
unsigned int modifiers = static_cast<unsigned int>(wParam);
uint32_t modifiers = static_cast<uint32_t>(wParam);
// Get the cursor position in client coordinates.
int x, y;
int32_t x, y;
Extract(lParam, x, y);
int button;
int32_t button;
if (wParam & MK_LBUTTON)
{
button = WindowApplication::MOUSE_LEFT;
@@ -424,23 +433,23 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
case WM_MOUSEWHEEL:
{
// Get the modifier flags and the amount the wheel rotated.
int modifiers, delta;
int32_t modifiers, delta;
Extract(wParam, modifiers, delta);
// Get the cursor position in client coordinates.
POINT point;
GetCursorPos(&point);
ScreenToClient(handle, &point);
int x = static_cast<int>(point.x);
int y = static_cast<int>(point.y);
int32_t x = static_cast<int32_t>(point.x);
int32_t y = static_cast<int32_t>(point.y);
window.OnMouseWheel(delta, x, y, (unsigned int)modifiers);
window.OnMouseWheel(delta, x, y, (uint32_t)modifiers);
return 0;
}
case WM_HSCROLL: // 0x0114
case WM_VSCROLL: // 0x0115
{
int bar = message - WM_HSCROLL; // 0 or 1
int32_t bar = message - WM_HSCROLL; // 0 or 1
switch (LOWORD(wParam))
{
case SB_LINELEFT:
@@ -472,7 +481,14 @@ LRESULT CALLBACK WindowSystem::WindowProcedure(HWND handle, UINT message,
window.OnClose();
return 0;
}
case WM_COPYDATA:
{
window.OnCopyData((HWND)wParam, reinterpret_cast<PCOPYDATASTRUCT>(lParam));
return 1;
}
}
return DefWindowProc(handle, message, wParam, lParam);
}
+8 -6
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -65,7 +65,7 @@ namespace gte
};
template <typename WindowType>
void MessagePump(std::shared_ptr<WindowType> const& window, unsigned int flags)
void MessagePump(std::shared_ptr<WindowType> const& window, uint32_t flags)
{
if (window)
{
@@ -111,7 +111,7 @@ namespace gte
// menu bar, and so on). This information is useful to know before
// creating a window to ensure the to-be-created window fits within
// the monitor resolution.
static bool GetWindowRectangle(int xClientSize, int yClientSize,
static bool GetWindowRectangle(int32_t xClientSize, int32_t yClientSize,
DWORD style, RECT& windowRectangle);
// Window creation and destruction. The CreateEngineAndProgramFactory
@@ -125,8 +125,8 @@ namespace gte
// Extraction of cursor location, avoiding the extraction in <windows.h>
// that does not work when you have dual monitors.
static void Extract(LPARAM lParam, int& x, int& y);
static void Extract(WPARAM wParam, int& x, int& y);
static void Extract(LPARAM lParam, int32_t& x, int32_t& y);
static void Extract(WPARAM wParam, int32_t& x, int32_t& y);
// The event handler.
static LRESULT CALLBACK WindowProcedure(HWND handle, UINT message, WPARAM wParam, LPARAM lParam);
@@ -138,3 +138,5 @@ namespace gte
extern WindowSystem TheWindowSystem;
}
+5 -3
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2026.02.16
#include <Applications/GTApplicationsPCH.h>
#include <Applications/OnIdleTimer.h>
@@ -63,7 +63,7 @@ double OnIdleTimer::GetSecondsPerFrame() const
{
double numFrames = static_cast<double>(mAccumulatedFrameCount);
double numMilliseconds = static_cast<double>(mAccumulatedTime);
return 1000.0 * numMilliseconds / numFrames;
return numMilliseconds / (1000.0 * numFrames);
}
else
{
@@ -94,3 +94,5 @@ std::string OnIdleTimer::GetFPS() const
stream << "fps: " << GetFramesPerSecond();
return stream.str();
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -48,3 +48,5 @@ namespace gte
std::chrono::high_resolution_clock::time_point mTime0, mTime1;
};
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/Timer.h>
@@ -45,3 +45,5 @@ void Timer::Reset()
{
mInitialTime = std::chrono::high_resolution_clock::now();
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -31,3 +31,5 @@ namespace gte
std::chrono::high_resolution_clock::time_point mInitialTime;
};
}
+11 -9
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/TrackBall.h>
@@ -17,7 +17,7 @@ TrackBall::TrackBall()
mInitialOrientation.MakeIdentity();
}
TrackBall::TrackBall(int xSize, int ySize, std::shared_ptr<Camera> const& camera)
TrackBall::TrackBall(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera)
:
TrackObject(xSize, ySize, camera)
{
@@ -132,20 +132,22 @@ void TrackBall::OnSetFinalPoint()
{
Matrix4x4<float> parWRotate = parent->worldTransform.GetRotation();
Matrix4x4<float> trnParWRotate = Transpose(parWRotate);
#if defined(GTE_USE_MAT_VEC)
rotate = trnParWRotate * incrRotate * parWRotate * mInitialOrientation;
#else
#if defined(GTE_USE_VEC_MAT)
rotate = mInitialOrientation * parWRotate * incrRotate * trnParWRotate;
#else
rotate = trnParWRotate * incrRotate * parWRotate * mInitialOrientation;
#endif
}
else
{
#if defined(GTE_USE_MAT_VEC)
rotate = incrRotate * mInitialOrientation;
#else
#if defined(GTE_USE_VEC_MAT)
rotate = mInitialOrientation * incrRotate;
#else
rotate = incrRotate * mInitialOrientation;
#endif
}
NormalizeAndUpdateRoot(rotate);
}
+5 -3
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -21,7 +21,7 @@ namespace gte
// (ySize - 1 - y).
virtual ~TrackBall() = default;
TrackBall();
TrackBall(int xSize, int ySize, std::shared_ptr<Camera> const& camera);
TrackBall(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera);
// Reset the trackball rotation to the identity.
void Reset();
@@ -33,3 +33,5 @@ namespace gte
Matrix4x4<float> mInitialOrientation;
};
}
+13 -10
View File
@@ -1,12 +1,13 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/TrackCylinder.h>
#include <Mathematics/Functions.h>
using namespace gte;
TrackCylinder::TrackCylinder()
@@ -20,7 +21,7 @@ TrackCylinder::TrackCylinder()
mRoot = std::make_shared<Node>();
}
TrackCylinder::TrackCylinder(int xSize, int ySize, std::shared_ptr<Camera> const& camera)
TrackCylinder::TrackCylinder(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera)
:
TrackObject(xSize, ySize, camera),
mInitialYaw(0.0f),
@@ -61,19 +62,21 @@ void TrackCylinder::OnSetFinalPoint()
mPitch = gte::clamp(mPitch, -halfPi, halfPi);
// The angle order depends on camera {D=0, U=1, R=2}.
#if defined(GTE_USE_MAT_VEC)
AxisAngle<4, float> yawAxisAngle(Vector4<float>::Unit(2), mYaw);
Matrix4x4<float> yawRotate = Rotation<4, float>(yawAxisAngle);
AxisAngle<4, float> pitchAxisAngle(Vector4<float>::Unit(1), mPitch);
Matrix4x4<float> pitchRotate = Rotation<4, float>(pitchAxisAngle);
Matrix4x4<float> rotate = pitchRotate * yawRotate;
#else
#if defined(GTE_USE_VEC_MAT)
AxisAngle<4, float> yawAxisAngle(Vector4<float>::Unit(2), -mYaw);
Matrix4x4<float> yawRotate = Rotation<4, float>(yawAxisAngle);
AxisAngle<4, float> pitchAxisAngle(Vector4<float>::Unit(1), -mPitch);
Matrix4x4<float> pitchRotate = Rotation<4, float>(pitchAxisAngle);
Matrix4x4<float> rotate = yawRotate * pitchRotate;
#else
AxisAngle<4, float> yawAxisAngle(Vector4<float>::Unit(2), mYaw);
Matrix4x4<float> yawRotate = Rotation<4, float>(yawAxisAngle);
AxisAngle<4, float> pitchAxisAngle(Vector4<float>::Unit(1), mPitch);
Matrix4x4<float> pitchRotate = Rotation<4, float>(pitchAxisAngle);
Matrix4x4<float> rotate = pitchRotate * yawRotate;
#endif
NormalizeAndUpdateRoot(rotate);
}
+5 -3
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -23,7 +23,7 @@ namespace gte
// as desired.
virtual ~TrackCylinder() = default;
TrackCylinder();
TrackCylinder(int xSize, int ySize, std::shared_ptr<Camera> const& camera);
TrackCylinder(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera);
// Reset the trackcylinder rotation to the identity.
void Reset();
@@ -46,3 +46,5 @@ namespace gte
float mInitialPitch, mPitch;
};
}
+8 -6
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/TrackObject.h>
@@ -24,7 +24,7 @@ TrackObject::TrackObject()
mRoot = std::make_shared<Node>();
}
TrackObject::TrackObject(int xSize, int ySize, std::shared_ptr<Camera> const& camera)
TrackObject::TrackObject(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera)
:
mXSize(0),
mYSize(0),
@@ -40,7 +40,7 @@ TrackObject::TrackObject(int xSize, int ySize, std::shared_ptr<Camera> const& ca
mRoot = std::make_shared<Node>();
}
void TrackObject::Set(int xSize, int ySize, std::shared_ptr<Camera> const& camera)
void TrackObject::Set(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera)
{
if (xSize > 0 && ySize > 0 && camera)
{
@@ -102,7 +102,7 @@ void TrackObject::DetachAll()
}
}
void TrackObject::SetInitialPoint(int x, int y)
void TrackObject::SetInitialPoint(int32_t x, int32_t y)
{
if (mValid && mRoot)
{
@@ -112,7 +112,7 @@ void TrackObject::SetInitialPoint(int x, int y)
}
}
void TrackObject::SetFinalPoint(int x, int y)
void TrackObject::SetFinalPoint(int32_t x, int32_t y)
{
if (mValid && mRoot)
{
@@ -145,3 +145,5 @@ void TrackObject::NormalizeAndUpdateRoot(Matrix4x4<float>& rotate)
mRoot->localTransform.SetRotation(rotate);
mRoot->Update();
}
+21 -9
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -18,22 +18,32 @@ namespace gte
// Construction and destruction.
virtual ~TrackObject() = default;
TrackObject();
TrackObject(int xSize, int ySize, std::shared_ptr<Camera> const& camera);
TrackObject(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera);
// Member access. The Set functions are for deferred construction
// after a default construction of a trackball.
void Set(int xSize, int ySize, std::shared_ptr<Camera> const& camera);
void Set(int32_t xSize, int32_t ySize, std::shared_ptr<Camera> const& camera);
inline int GetXSize() const
inline int32_t GetXSize() const
{
return mXSize;
}
inline int GetYSize() const
inline int32_t GetYSize() const
{
return mYSize;
}
inline void SetXSize(int32_t size)
{
mXSize = size;
}
inline void SetYSize(int32_t size)
{
mYSize = size;
}
inline std::shared_ptr<Camera> const& GetCamera() const
{
return mCamera;
@@ -93,12 +103,12 @@ namespace gte
// Set the initial point of the track object. The current track
// object orientation is recorded.
void SetInitialPoint(int x, int y);
void SetInitialPoint(int32_t x, int32_t y);
// Set the final point of the track object. The track object
// orientation is updated by the incremental rotation implied by the
// initial and final points.
void SetFinalPoint(int x, int y);
void SetFinalPoint(int32_t x, int32_t y);
protected:
virtual void OnSetInitialPoint() = 0;
@@ -108,8 +118,10 @@ namespace gte
std::shared_ptr<Camera> mCamera;
std::shared_ptr<Spatial> mRoot;
int mXSize, mYSize;
int32_t mXSize, mYSize;
float mX0, mY0, mX1, mY1, mMultiplier;
bool mActive, mValid;
};
}
+4 -2
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -14,3 +14,5 @@
#if defined(GTE_USE_LINUX)
#include<Applications/GLX/WICFileIO.h>
#endif
+58 -39
View File
@@ -1,13 +1,14 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/Window2.h>
#include <Mathematics/ImageUtility2.h>
#include <Graphics/SamplerState.h>
using namespace gte;
Window2::Window2(Parameters& parameters)
@@ -19,17 +20,15 @@ Window2::Window2(Parameters& parameters)
mDoFlip(false),
mScreenTextureNeedsUpdate(false)
{
if (parameters.allowResize)
{
parameters.created = false;
return;
}
mOverlay = std::make_shared<OverlayEffect>(mProgramFactory, mXSize, mYSize, mXSize, mYSize,
SamplerState::MIN_P_MAG_P_MIP_P, SamplerState::CLAMP, SamplerState::CLAMP, true);
mOverlay = std::make_shared<OverlayEffect>(mProgramFactory,
mXSize, mYSize, mXSize, mYSize,
SamplerState::Filter::MIN_P_MAG_P_MIP_P,
SamplerState::Mode::CLAMP,
SamplerState::Mode::CLAMP,
true);
mScreenTexture = std::make_shared<Texture2>(DF_R8G8B8A8_UNORM, mXSize, mYSize);
mScreenTexture->SetUsage(Resource::DYNAMIC_UPDATE);
mScreenTexture->SetUsage(Resource::Usage::DYNAMIC_UPDATE);
mOverlay->SetTexture(mScreenTexture);
// The default is to disable depth and stenciling. For layered drawing in
@@ -41,12 +40,12 @@ Window2::Window2(Parameters& parameters)
mEngine->SetDepthStencilState(mNoDepthStencilState);
// Callback functions for ImageUtility2 functions.
mDrawPixel = [this](int x, int y) { SetPixel(x, y, mPixelColor); };
mDrawThickPixel = [this](int x, int y)
mDrawPixel = [this](int32_t x, int32_t y) { SetPixel(x, y, mPixelColor); };
mDrawThickPixel = [this](int32_t x, int32_t y)
{
for (int dy = -mThick; dy <= mThick; ++dy)
for (int32_t dy = -mThick; dy <= mThick; ++dy)
{
for (int dx = -mThick; dx <= mThick; ++dx)
for (int32_t dx = -mThick; dx <= mThick; ++dx)
{
SetPixel(x + dx, y + dy, mPixelColor);
}
@@ -54,10 +53,28 @@ Window2::Window2(Parameters& parameters)
};
}
bool Window2::OnResize(int, int)
bool Window2::OnResize(int32_t xSize, int32_t ySize)
{
// See the comments in GteWindow.h.
return false;
if (xSize != mXSize || ySize != mYSize)
{
mXSize = xSize;
mYSize = ySize;
mOverlay = std::make_shared<OverlayEffect>(mProgramFactory,
mXSize, mYSize, mXSize, mYSize,
SamplerState::Filter::MIN_P_MAG_P_MIP_P,
SamplerState::Mode::CLAMP,
SamplerState::Mode::CLAMP,
true);
mScreenTexture = std::make_shared<Texture2>(DF_R8G8B8A8_UNORM, mXSize, mYSize);
mScreenTexture->SetUsage(Resource::Usage::DYNAMIC_UPDATE);
mOverlay->SetTexture(mScreenTexture);
mEngine->Resize(static_cast<uint32_t>(mXSize), static_cast<uint32_t>(mYSize));
}
return true;
}
void Window2::OnDisplay()
@@ -78,17 +95,17 @@ void Window2::DrawScreenOverlay()
// Stub for derived classes.
}
void Window2::ClearScreen(unsigned int color)
void Window2::ClearScreen(uint32_t color)
{
unsigned int const numTexels = mScreenTexture->GetNumElements();
unsigned int* texels = mScreenTexture->Get<unsigned int>();
for (unsigned int i = 0; i < numTexels; ++i)
uint32_t const numTexels = mScreenTexture->GetNumElements();
uint32_t* texels = mScreenTexture->Get<uint32_t>();
for (uint32_t i = 0; i < numTexels; ++i)
{
*texels++ = color;
}
}
void Window2::SetPixel(int x, int y, unsigned int color)
void Window2::SetPixel(int32_t x, int32_t y, uint32_t color)
{
if (mClampToWindow)
{
@@ -103,10 +120,10 @@ void Window2::SetPixel(int x, int y, unsigned int color)
y = mYSize - 1 - y;
}
mScreenTexture->Get<unsigned int>()[x + mXSize * y] = color;
mScreenTexture->Get<uint32_t>()[x + mXSize * y] = color;
}
unsigned int Window2::GetPixel(int x, int y)
uint32_t Window2::GetPixel(int32_t x, int32_t y)
{
if (mClampToWindow)
{
@@ -121,70 +138,72 @@ unsigned int Window2::GetPixel(int x, int y)
y = mYSize - 1 - y;
}
return mScreenTexture->Get<unsigned int>()[x + mXSize * y];
return mScreenTexture->Get<uint32_t>()[x + mXSize * y];
}
void Window2::DrawThickPixel(int x, int y, int thick, unsigned int color)
void Window2::DrawThickPixel(int32_t x, int32_t y, int32_t thick, uint32_t color)
{
mPixelColor = color;
ImageUtility2::DrawThickPixel(x, y, thick, mDrawPixel);
}
void Window2::DrawLine(int x0, int y0, int x1, int y1, unsigned int color)
void Window2::DrawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color)
{
mPixelColor = color;
ImageUtility2::DrawLine(x0, y0, x1, y1, mDrawPixel);
}
void Window2::DrawThickLine(int x0, int y0, int x1, int y1, int thick, unsigned int color)
void Window2::DrawThickLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t thick, uint32_t color)
{
mPixelColor = color;
mThick = thick;
ImageUtility2::DrawLine(x0, y0, x1, y1, mDrawThickPixel);
}
void Window2::DrawRectangle(int xMin, int yMin, int xMax, int yMax, unsigned int color, bool solid)
void Window2::DrawRectangle(int32_t xMin, int32_t yMin, int32_t xMax, int32_t yMax, uint32_t color, bool solid)
{
mPixelColor = color;
ImageUtility2::DrawRectangle(xMin, yMin, xMax, yMax, solid, mDrawPixel);
}
void Window2::DrawThickRectangle(int xMin, int yMin, int xMax, int yMax, int thick, unsigned int color, bool solid)
void Window2::DrawThickRectangle(int32_t xMin, int32_t yMin, int32_t xMax, int32_t yMax, int32_t thick, uint32_t color, bool solid)
{
mPixelColor = color;
mThick = thick;
ImageUtility2::DrawRectangle(xMin, yMin, xMax, yMax, solid, mDrawThickPixel);
}
void Window2::DrawCircle(int xCenter, int yCenter, int radius, unsigned int color, bool solid)
void Window2::DrawCircle(int32_t xCenter, int32_t yCenter, int32_t radius, uint32_t color, bool solid)
{
mPixelColor = color;
ImageUtility2::DrawCircle(xCenter, yCenter, radius, solid, mDrawPixel);
}
void Window2::DrawThickCircle(int xCenter, int yCenter, int radius, int thick, unsigned int color, bool solid)
void Window2::DrawThickCircle(int32_t xCenter, int32_t yCenter, int32_t radius, int32_t thick, uint32_t color, bool solid)
{
mPixelColor = color;
mThick = thick;
ImageUtility2::DrawCircle(xCenter, yCenter, radius, solid, mDrawThickPixel);
}
void Window2::DrawEllipse(int xCenter, int yCenter, int xExtent, int yExtent, unsigned int color)
void Window2::DrawEllipse(int32_t xCenter, int32_t yCenter, int32_t xExtent, int32_t yExtent, uint32_t color)
{
mPixelColor = color;
ImageUtility2::DrawEllipse(xCenter, yCenter, xExtent, yExtent, mDrawPixel);
}
void Window2::DrawThickEllipse(int xCenter, int yCenter, int xExtent, int yExtent, int thick, unsigned int color)
void Window2::DrawThickEllipse(int32_t xCenter, int32_t yCenter, int32_t xExtent, int32_t yExtent, int32_t thick, uint32_t color)
{
mPixelColor = color;
mThick = thick;
ImageUtility2::DrawEllipse(xCenter, yCenter, xExtent, yExtent, mDrawThickPixel);
}
void Window2::DrawFloodFill4(int x, int y, unsigned int foreColor, unsigned int backColor)
void Window2::DrawFloodFill4(int32_t x, int32_t y, uint32_t foreColor, uint32_t backColor)
{
ImageUtility2::DrawFloodFill4<unsigned int>(x, y, mXSize, mYSize, foreColor, backColor,
[this](int x, int y, unsigned int color) { SetPixel(x, y, color); },
[this](int x, int y) { return GetPixel(x, y); });
ImageUtility2::DrawFloodFill4<uint32_t>(x, y, mXSize, mYSize, foreColor, backColor,
[this](int32_t x, int32_t y, uint32_t color) { SetPixel(x, y, color); },
[this](int32_t x, int32_t y) { return GetPixel(x, y); });
}
+47 -25
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -13,7 +13,10 @@
#if defined(GTE_USE_LINUX)
#include <Applications/GLX/Window.h>
#endif
#include <Graphics/DepthStencilState.h>
#include <Graphics/OverlayEffect.h>
#include <Graphics/Texture2.h>
#include <cstdint>
// The 2D application support is for GTEngine samples and is not a
// general-purpose 2D windowing layer. The window resizing is disabled to
@@ -31,13 +34,30 @@ namespace gte
Window2(Parameters& parameters);
public:
// Display functions. The OnResize function always returns 'false';
// that is, you cannot resize the window. The DrawScreenOverlay
// function is called after the screen texture is drawn but before the
// swap-buffers call is made. This allows you to draw text or GUI
// elements on top of the screen texture.
virtual bool OnResize(int xSize, int ySize) override;
// Display functions.
// OnResize is called during window resize events. The screen texture
// and the overlay objects are recreated. The engine then resizes its
// renderer. If a class derived from Window2 wants resizing, it must
// set the parameters.allowResize to true. Moreover, the class must
// override OnResize, calling the Window2::OnResize first and then
// calling either its own OnDisplay or OnIdle, whichever it is using
// for drawing. This is required because during the window resizing,
// the message pump is receiving the events and OnIdle() is not
// called directly in the message pump because there are messages
// that must be processed first. If you do not call your own OnIdle,
// the rendered client window will not display properly.
virtual bool OnResize(int32_t xSize, int32_t ySize) override;
// The OnDisplay function updates the screen texture if it is 'dirty'
// and then draws the 2D overlay followed by a call to
// DrawScreenOverlay.
virtual void OnDisplay() override;
// The DrawScreenOverlay function is called after the screen texture
// is drawn but before the swap-buffers call is made. This allows you
// to draw text or user-created GUI elements on top of the screen
// texture.
virtual void DrawScreenOverlay();
// Drawing functions. Each color is packed as R8G8B8A8 with the alpha
@@ -45,43 +65,43 @@ namespace gte
// bits. For example, (r,g,b,a) = (1,2,3,4) is 0x04030201.
// Set all pixels to the specified color.
void ClearScreen(unsigned int color);
void ClearScreen(uint32_t color);
// Set the pixel at location (x,y) to the specified color.
void SetPixel(int x, int y, unsigned int color);
void SetPixel(int32_t x, int32_t y, uint32_t color);
// Get the pixel color at location (x,y).
unsigned int GetPixel(int x, int y);
uint32_t GetPixel(int32_t x, int32_t y);
// Set the pixels (x',y') for x-thick <= x' <= x+thick and
// y-thick <= y' <= y+thick.
void DrawThickPixel(int x, int y, int thick, unsigned int color);
void DrawThickPixel(int32_t x, int32_t y, int32_t thick, uint32_t color);
// Use Bresenham's algorithm to draw the line from (x0,y0) to (x1,y1)
// using the specified color for the drawn pixels. The algorithm is
// biased in that the pixels set by DrawLine(x0,y0,x1,y1) are not
// necessarily the same as those set by DrawLine(x1,y1,x0,y0).
// TODO: Implement the midpoint algorithm to avoid the bias.
void DrawLine(int x0, int y0, int x1, int y1, unsigned int color);
void DrawThickLine(int x0, int y0, int x1, int y1, int thick, unsigned int color);
void DrawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color);
void DrawThickLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t thick, uint32_t color);
// Draw an axis-aligned rectangle using the specified color. The
// 'solid' parameter indicates whether or not to fill the rectangle.
void DrawRectangle(int xMin, int yMin, int xMax, int yMax, unsigned int color, bool solid);
void DrawThickRectangle(int xMin, int yMin, int xMax, int yMax, int thick, unsigned int color, bool solid);
void DrawRectangle(int32_t xMin, int32_t yMin, int32_t xMax, int32_t yMax, uint32_t color, bool solid);
void DrawThickRectangle(int32_t xMin, int32_t yMin, int32_t xMax, int32_t yMax, int32_t thick, uint32_t color, bool solid);
// Use Bresenham's algorithm to draw the circle centered at
// (xCenter,yCenter) with the specified 'radius' and using the
// specified color. The 'solid' parameter indicates whether or not
// to fill the circle.
void DrawCircle(int xCenter, int yCenter, int radius, unsigned int color, bool solid);
void DrawThickCircle(int xCenter, int yCenter, int radius, int thick, unsigned int color, bool solid);
void DrawCircle(int32_t xCenter, int32_t yCenter, int32_t radius, uint32_t color, bool solid);
void DrawThickCircle(int32_t xCenter, int32_t yCenter, int32_t radius, int32_t thick, uint32_t color, bool solid);
// Use Bresenham's algorithm to draw the axis-aligned ellipse
// ((x-xc)/a)^2 + ((y-yc)/b)^2 = 1, where xCenter is xc, yCenter
// is yc, xExtent is a, and yExtent is b.
void DrawEllipse(int xCenter, int yCenter, int xExtent, int yExtent, unsigned int color);
void DrawThickEllipse(int xCenter, int yCenter, int xExtent, int yExtent, int thick, unsigned int color);
void DrawEllipse(int32_t xCenter, int32_t yCenter, int32_t xExtent, int32_t yExtent, uint32_t color);
void DrawThickEllipse(int32_t xCenter, int32_t yCenter, int32_t xExtent, int32_t yExtent, int32_t thick, uint32_t color);
// Flood-fill a region whose pixels are of color 'backColor' by
// changing their color to 'foreColor'. The fill treats the screen
@@ -90,18 +110,20 @@ namespace gte
// the screen boundary). The function simulates recursion by using
// stacks, which avoids the expense of true recursion and the
// potential to overflow the calling stack.
void DrawFloodFill4(int x, int y, unsigned int foreColor, unsigned int backColor);
void DrawFloodFill4(int32_t x, int32_t y, uint32_t foreColor, uint32_t backColor);
protected:
std::shared_ptr<OverlayEffect> mOverlay;
std::shared_ptr<Texture2> mScreenTexture;
std::shared_ptr<DepthStencilState> mNoDepthStencilState;
std::function<void(int, int)> mDrawPixel;
std::function<void(int, int)> mDrawThickPixel;
unsigned int mPixelColor;
int mThick;
std::function<void(int32_t, int32_t)> mDrawPixel;
std::function<void(int32_t, int32_t)> mDrawThickPixel;
uint32_t mPixelColor;
int32_t mThick;
bool mClampToWindow;
bool mDoFlip;
bool mScreenTextureNeedsUpdate;
};
}
+12 -8
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/Window3.h>
@@ -46,20 +46,22 @@ void Window3::InitializeCamera(float upFovDegrees, float aspectRatio, float dmin
mCameraRig.SetRotationSpeed(rotationSpeed);
}
bool Window3::OnResize(int xSize, int ySize)
bool Window3::OnResize(int32_t xSize, int32_t ySize)
{
if (Window::OnResize(xSize, ySize))
{
float upFovDegrees, aspectRatio, dMin, dMax;
mCamera->GetFrustum(upFovDegrees, aspectRatio, dMin, dMax);
mCamera->SetFrustum(upFovDegrees, GetAspectRatio(), dMin, dMax);
mTrackBall.SetXSize(xSize);
mTrackBall.SetYSize(ySize);
mPVWMatrices.Update();
return true;
}
return false;
}
bool Window3::OnCharPress(unsigned char key, int x, int y)
bool Window3::OnCharPress(uint8_t key, int32_t x, int32_t y)
{
switch (key)
{
@@ -83,17 +85,17 @@ bool Window3::OnCharPress(unsigned char key, int x, int y)
return Window::OnCharPress(key, x, y);
}
bool Window3::OnKeyDown(int key, int, int)
bool Window3::OnKeyDown(int32_t key, int32_t, int32_t)
{
return mCameraRig.PushMotion(key);
}
bool Window3::OnKeyUp(int key, int, int)
bool Window3::OnKeyUp(int32_t key, int32_t, int32_t)
{
return mCameraRig.PopMotion(key);
}
bool Window3::OnMouseClick(MouseButton button, MouseState state, int x, int y, unsigned int)
bool Window3::OnMouseClick(MouseButton button, MouseState state, int32_t x, int32_t y, uint32_t)
{
if (button == MOUSE_LEFT)
{
@@ -113,7 +115,7 @@ bool Window3::OnMouseClick(MouseButton button, MouseState state, int x, int y, u
return false;
}
bool Window3::OnMouseMotion(MouseButton button, int x, int y, unsigned int)
bool Window3::OnMouseMotion(MouseButton button, int32_t x, int32_t y, uint32_t)
{
if (button == MOUSE_LEFT && mTrackBall.GetActive())
{
@@ -124,3 +126,5 @@ bool Window3::OnMouseMotion(MouseButton button, int x, int y, unsigned int)
return false;
}
+12 -10
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -36,31 +36,31 @@ namespace gte
// to OnDisplay() or OnIdle(). The base class is unaware of which
// display method you use, so to have a visual update you must
// override OnResize
// bool MyApplication::OnResize(int xSize, int ySize)
// bool MyApplication::OnResize(int32_t xSize, int32_t ySize)
// {
// if (Window3::OnResize(xSize, ySize))
// {
// OnIdle(); // or OnDisplay() or MyOwnDrawFunction() ...
// }
// }
virtual bool OnResize(int xSize, int ySize) override;
virtual bool OnResize(int32_t xSize, int32_t ySize) override;
// The key 't' decreases the translation speed and the 'T' key
// increases the translation speed. The 'r' key decreases the
// rotation speed and the 'R' key increases the rotation speed.
virtual bool OnCharPress(unsigned char key, int x, int y) override;
virtual bool OnCharPress(uint8_t key, int32_t x, int32_t y) override;
// The appropriate camera rig motion is selected when 'key' is mapped
// to a camera motion.
virtual bool OnKeyDown(int key, int x, int y) override;
virtual bool OnKeyUp(int key, int x, int y) override;
virtual bool OnKeyDown(int32_t key, int32_t x, int32_t y) override;
virtual bool OnKeyUp(int32_t key, int32_t x, int32_t y) override;
// Control the rotation of the trackball.
virtual bool OnMouseClick(MouseButton button, MouseState state,
int x, int y, unsigned int modifiers) override;
int32_t x, int32_t y, uint32_t modifiers) override;
virtual bool OnMouseMotion(MouseButton button, int x, int y,
unsigned int modifiers) override;
virtual bool OnMouseMotion(MouseButton button, int32_t x, int32_t y,
uint32_t modifiers) override;
protected:
BufferUpdater mUpdater;
@@ -70,3 +70,5 @@ namespace gte
TrackBall mTrackBall;
};
}
+31 -13
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#include <Applications/GTApplicationsPCH.h>
#include <Applications/WindowApplication.h>
@@ -23,7 +23,7 @@ WindowApplication::Parameters::Parameters()
}
WindowApplication::Parameters::Parameters(std::wstring const& inTitle,
int inXOrigin, int inYOrigin, int inXSize, int inYSize)
int32_t inXOrigin, int32_t inYOrigin, int32_t inXSize, int32_t inYSize)
:
title(inTitle),
xOrigin(inXOrigin),
@@ -50,13 +50,13 @@ WindowApplication::WindowApplication(Parameters& parameters)
{
}
void WindowApplication::OnMove(int x, int y)
void WindowApplication::OnMove(int32_t x, int32_t y)
{
mXOrigin = x;
mYOrigin = y;
}
bool WindowApplication::OnResize(int xSize, int ySize)
bool WindowApplication::OnResize(int32_t xSize, int32_t ySize)
{
mIsMinimized = false;
mIsMaximized = false;
@@ -98,7 +98,7 @@ void WindowApplication::OnIdle()
// Stub for derived classes.
}
bool WindowApplication::OnCharPress(unsigned char key, int, int)
bool WindowApplication::OnCharPress(uint8_t key, int32_t, int32_t)
{
if (key == KEY_ESCAPE)
{
@@ -116,47 +116,65 @@ bool WindowApplication::OnCharPress(unsigned char key, int, int)
return false;
}
bool WindowApplication::OnKeyDown(int, int, int)
bool WindowApplication::OnKeyDown(int32_t, int32_t, int32_t)
{
// Stub for derived classes.
return false;
}
bool WindowApplication::OnKeyUp(int, int, int)
bool WindowApplication::OnKeyUp(int32_t, int32_t, int32_t)
{
// Stub for derived classes.
return false;
}
bool WindowApplication::OnMouseClick(int, int, int, int, unsigned int)
bool WindowApplication::OnMouseClick(int32_t, int32_t, int32_t, int32_t, uint32_t)
{
// stub for derived classes
return false;
}
bool WindowApplication::OnMouseMotion(int, int, int, unsigned int)
bool WindowApplication::OnMouseMotion(int32_t, int32_t, int32_t, uint32_t)
{
// stub for derived classes
return false;
}
bool WindowApplication::OnMouseWheel(int, int, int, unsigned int)
bool WindowApplication::OnMouseWheel(int32_t, int32_t, int32_t, uint32_t)
{
// Stub for derived classes.
return false;
}
void WindowApplication::SetMousePosition(int, int)
void WindowApplication::SetMousePosition(int32_t, int32_t)
{
// Stub for derived classes.
}
void WindowApplication::GetMousePosition(int&, int&) const
void WindowApplication::GetMousePosition(int32_t&, int32_t&) const
{
// Stub for derived classes.
}
#if defined(GTE_USE_MSWINDOWS)
void WindowApplication::OnCopyData(HWND, PCOPYDATASTRUCT)
{
// Stub for derived classes.
}
#endif
void WindowApplication::OnClose()
{
// Stub for derived classes.
}
#if defined(GTE_USE_MSWINDOWS)
bool WindowApplication::OnWindowsMessage(HWND, UINT,
WPARAM, LPARAM, LRESULT& result)
{
result = 0;
return false;
}
#endif
+81 -63
View File
@@ -1,9 +1,9 @@
// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Copyright (c) 1998-2026
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13
// File Version: 8.0.2025.05.10
#pragma once
@@ -20,10 +20,10 @@ namespace gte
Parameters();
Parameters(std::wstring const& inTitle,
int inXOrigin, int inYOrigin, int inXSize, int inYSize);
int32_t inXOrigin, int32_t inYOrigin, int32_t inXSize, int32_t inYSize);
std::wstring title;
int xOrigin, yOrigin, xSize, ySize;
int32_t xOrigin, yOrigin, xSize, ySize;
bool allowResize, useDepth24Stencil8, created;
};
@@ -45,22 +45,22 @@ namespace gte
return mTitle;
}
inline int GetXOrigin() const
inline int32_t GetXOrigin() const
{
return mXOrigin;
}
inline int GetYOrigin() const
inline int32_t GetYOrigin() const
{
return mYOrigin;
}
inline int GetXSize() const
inline int32_t GetXSize() const
{
return mXSize;
}
inline int GetYSize() const
inline int32_t GetYSize() const
{
return mYSize;
}
@@ -81,8 +81,8 @@ namespace gte
}
// Display callbacks.
virtual void OnMove(int x, int y);
virtual bool OnResize(int xSize, int ySize);
virtual void OnMove(int32_t x, int32_t y);
virtual bool OnResize(int32_t xSize, int32_t ySize);
virtual void OnMinimize();
virtual void OnMaximize();
virtual void OnDisplay();
@@ -92,83 +92,99 @@ namespace gte
// upper-case and lower-case letters; OnKeyDown and OnKeyUp do not.
// For OnCharPress, pressing KEY_ESCAPE terminates the application.
// Pressing ' ' resets the application timer.
virtual bool OnCharPress(unsigned char key, int x, int y);
virtual bool OnKeyDown(int key, int x, int y);
virtual bool OnKeyUp(int key, int x, int y);
virtual bool OnCharPress(uint8_t key, int32_t x, int32_t y);
virtual bool OnKeyDown(int32_t key, int32_t x, int32_t y);
virtual bool OnKeyUp(int32_t key, int32_t x, int32_t y);
// Mouse callbacks and state information.
// TODO: HACK FOR NOW. Once these are removed, all the sample
// applications must have their signatures changed.
typedef int MouseButton;
typedef int MouseState;
typedef int32_t MouseButton;
typedef int32_t MouseState;
// END TODO;
virtual bool OnMouseClick(int button, int state, int x, int y, unsigned int modifiers);
virtual bool OnMouseMotion(int button, int x, int y, unsigned int modifiers);
virtual bool OnMouseWheel(int delta, int x, int y, unsigned int modifiers);
virtual void SetMousePosition(int x, int y);
virtual void GetMousePosition(int& x, int& y) const;
virtual bool OnMouseClick(int32_t button, int32_t state, int32_t x, int32_t y, uint32_t modifiers);
virtual bool OnMouseMotion(int32_t button, int32_t x, int32_t y, uint32_t modifiers);
virtual bool OnMouseWheel(int32_t delta, int32_t x, int32_t y, uint32_t modifiers);
virtual void SetMousePosition(int32_t x, int32_t y);
virtual void GetMousePosition(int32_t& x, int32_t& y) const;
#if defined(GTE_USE_MSWINDOWS)
// Allow an application to pass data to another application.
virtual void OnCopyData(HWND sender, PCOPYDATASTRUCT copyData);
#endif
// Actions to take before the window closes.
virtual void OnClose();
#if defined(GTE_USE_MSWINDOWS)
// Allow an application to process the Windows message. The function
// is called in WindowSystem::WindowProcedure. If the return value is
// 'true', the message is not passed to 'window' via the message pump.
// If the return value is 'false', the message is passed to 'window'.
// This allows a third-party UI package to intercept messages and
// process them as needed.
virtual bool OnWindowsMessage(HWND handle, UINT message,
WPARAM wParam, LPARAM lParam, LRESULT& result);
#endif
// Key identifiers. These are platform-specific, so classes that
// derived from WindowApplication must define these variables. They
// are not defined by WindowApplication itself.
static int const KEY_ESCAPE;
static int const KEY_LEFT;
static int const KEY_RIGHT;
static int const KEY_UP;
static int const KEY_DOWN;
static int const KEY_HOME;
static int const KEY_END;
static int const KEY_PAGE_UP;
static int const KEY_PAGE_DOWN;
static int const KEY_INSERT;
static int const KEY_DELETE;
static int const KEY_F1;
static int const KEY_F2;
static int const KEY_F3;
static int const KEY_F4;
static int const KEY_F5;
static int const KEY_F6;
static int const KEY_F7;
static int const KEY_F8;
static int const KEY_F9;
static int const KEY_F10;
static int const KEY_F11;
static int const KEY_F12;
static int const KEY_BACKSPACE;
static int const KEY_TAB;
static int const KEY_ENTER;
static int const KEY_RETURN;
static int32_t const KEY_ESCAPE;
static int32_t const KEY_LEFT;
static int32_t const KEY_RIGHT;
static int32_t const KEY_UP;
static int32_t const KEY_DOWN;
static int32_t const KEY_HOME;
static int32_t const KEY_END;
static int32_t const KEY_PAGE_UP;
static int32_t const KEY_PAGE_DOWN;
static int32_t const KEY_INSERT;
static int32_t const KEY_DELETE;
static int32_t const KEY_F1;
static int32_t const KEY_F2;
static int32_t const KEY_F3;
static int32_t const KEY_F4;
static int32_t const KEY_F5;
static int32_t const KEY_F6;
static int32_t const KEY_F7;
static int32_t const KEY_F8;
static int32_t const KEY_F9;
static int32_t const KEY_F10;
static int32_t const KEY_F11;
static int32_t const KEY_F12;
static int32_t const KEY_BACKSPACE;
static int32_t const KEY_TAB;
static int32_t const KEY_ENTER;
static int32_t const KEY_RETURN;
// Keyboard modifiers.
static int const KEY_SHIFT;
static int const KEY_CONTROL;
static int const KEY_ALT;
static int const KEY_COMMAND;
static int32_t const KEY_SHIFT;
static int32_t const KEY_CONTROL;
static int32_t const KEY_ALT;
static int32_t const KEY_COMMAND;
// Mouse buttons.
static int const MOUSE_NONE;
static int const MOUSE_LEFT;
static int const MOUSE_MIDDLE;
static int const MOUSE_RIGHT;
static int32_t const MOUSE_NONE;
static int32_t const MOUSE_LEFT;
static int32_t const MOUSE_MIDDLE;
static int32_t const MOUSE_RIGHT;
// Mouse state.
static int const MOUSE_UP;
static int const MOUSE_DOWN;
static int32_t const MOUSE_UP;
static int32_t const MOUSE_DOWN;
// Mouse modifiers.
static int const MODIFIER_CONTROL;
static int const MODIFIER_LBUTTON;
static int const MODIFIER_MBUTTON;
static int const MODIFIER_RBUTTON;
static int const MODIFIER_SHIFT;
static int32_t const MODIFIER_CONTROL;
static int32_t const MODIFIER_LBUTTON;
static int32_t const MODIFIER_MBUTTON;
static int32_t const MODIFIER_RBUTTON;
static int32_t const MODIFIER_SHIFT;
protected:
// Standard window information.
std::wstring mTitle;
int mXOrigin, mYOrigin, mXSize, mYSize;
int32_t mXOrigin, mYOrigin, mXSize, mYSize;
bool mAllowResize;
bool mIsMinimized;
bool mIsMaximized;
@@ -176,3 +192,5 @@ namespace gte
OnIdleTimer mTimer;
};
}
-3149
View File
File diff suppressed because it is too large Load Diff
-3152
View File
File diff suppressed because it is too large Load Diff
-3152
View File
File diff suppressed because it is too large Load Diff
+3900
View File
File diff suppressed because it is too large Load Diff
+3900
View File
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+35
View File
@@ -0,0 +1,35 @@
#!/bin/bash
# usage: ./CMakeLibraries.sh BUILD_TYPE LIBRARY_TYPE
# where BUILD_TYPE is in {Debug,Release}
# and where LIBRARY_TYPE is in {Static,Shared}
BUILD_TYPE=$1
LIBRARY_TYPE=$2
GCC=gcc
GXX=g++
if [[ ! "${BUILD_TYPE}" = "Debug" && ! "${BUILD_TYPE}" = "Release" ]]; then
echo "Invalid build type: ${BUILD_TYPE}, must be in {Debug, Release}"
exit 1
fi
if [[ ! "${LIBRARY_TYPE}" = "Static" && ! "${LIBRARY_TYPE}" = "Shared" ]]; then
echo "Invalid library type: ${LIBRARY_TYPE}, must be in {Static, Shared}"
exit 2
fi
if [ "${BUILD_TYPE}" = "Debug" ]; then
if [ "${LIBRARY_TYPE}" = "Static" ]; then
cmake -DBUILD_SAMPLES=ON -DCMAKE_BUILD_TYPE:STRING=Debug -DBUILD_RELEASE_LIB:BOOL=FALSE -DBUILD_SHARED_LIB:BOOL=FALSE -DCMAKE_C_COMPILER:FILEPATH=${GCC} -DCMAKE_CXX_COMPILER:FILEPATH=${GXX} -B./build -G "Unix Makefiles"
else
cmake -DBUILD_SAMPLES=ON -DCMAKE_BUILD_TYPE:STRING=Debug -DBUILD_RELEASE_LIB:BOOL=FALSE -DBUILD_SHARED_LIB:BOOL=TRUE -DCMAKE_C_COMPILER:FILEPATH=${GCC} -DCMAKE_CXX_COMPILER:FILEPATH=${GXX} -B./build -G "Unix Makefiles"
fi
cmake --build ./build --config Debug --target all -- -j 10
else
if [ "${LIBRARY_TYPE}" = "Static" ]; then
cmake -DBUILD_SAMPLES=ON -DCMAKE_BUILD_TYPE:STRING=Release -DBUILD_RELEASE_LIB:BOOL=TRUE -DBUILD_SHARED_LIB:BOOL=FALSE -DCMAKE_C_COMPILER:FILEPATH=${GCC} -DCMAKE_CXX_COMPILER:FILEPATH=${GXX} -B./build -G "Unix Makefiles"
else
cmake -DBUILD_SAMPLES=ON -DCMAKE_BUILD_TYPE:STRING=Release -DBUILD_RELEASE_LIB:BOOL=TRUE -DBUILD_SHARED_LIB:BOOL=TRUE -DCMAKE_C_COMPILER:FILEPATH=${GCC} -DCMAKE_CXX_COMPILER:FILEPATH=${GXX} -B./build -G "Unix Makefiles"
fi
cmake --build ./build --config Release --target all -- -j 10
fi
+10 -3
View File
@@ -3,13 +3,20 @@ if(COMMAND cmake_policy)
cmake_policy(SET CMP0048 NEW)
endif()
set(GTE_VERSION_MAJOR 5)
set(GTE_VERSION_MINOR 11)
cmake_minimum_required(VERSION 3.10)
set(GTE_VERSION_MAJOR 8)
set(GTE_VERSION_MINOR 2)
set(PROJECT_SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR})
project(GTE VERSION ${GTE_VERSION_MAJOR}.${GTE_VERSION_MINOR})
cmake_minimum_required(VERSION 3.8)
add_subdirectory(Applications)
add_subdirectory(Graphics)
add_subdirectory(Mathematics)
add_subdirectory(MathematicsGPU)
option(BUILD_SAMPLES "Build Samples" OFF)
if(BUILD_SAMPLES)
add_subdirectory(Samples)
endif()
-65
View File
@@ -1,65 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.25420.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsDX11.v14", "GTApplicationsDX11.v14.vcxproj", "{741CFCD7-01A2-4325-AF0D-6678F7686FD8}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{467CF875-4855-4CBE-9D8D-86ADA3BA1AC5}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v14", "GTMathematics.v14.vcxproj", "{10A02379-886E-46F8-93F1-1E14235D42F9}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v14", "GTGraphics.v14.vcxproj", "{7BE071FB-E33C-4903-9278-6D12BBA46E0D}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsDX11.v14", "GTGraphicsDX11.v14.vcxproj", "{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Debug|x64.ActiveCfg = Debug|x64
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Debug|x64.Build.0 = Debug|x64
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Debug|x86.ActiveCfg = Debug|Win32
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Debug|x86.Build.0 = Debug|Win32
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Release|x64.ActiveCfg = Release|x64
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Release|x64.Build.0 = Release|x64
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Release|x86.ActiveCfg = Release|Win32
{741CFCD7-01A2-4325-AF0D-6678F7686FD8}.Release|x86.Build.0 = Release|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x64.ActiveCfg = Debug|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x64.Build.0 = Debug|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x86.ActiveCfg = Debug|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x86.Build.0 = Debug|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x64.ActiveCfg = Release|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x64.Build.0 = Release|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x86.ActiveCfg = Release|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x86.Build.0 = Release|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x64.ActiveCfg = Debug|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x64.Build.0 = Debug|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x86.ActiveCfg = Debug|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x86.Build.0 = Debug|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x64.ActiveCfg = Release|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x64.Build.0 = Release|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x86.ActiveCfg = Release|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x86.Build.0 = Release|Win32
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Debug|x64.ActiveCfg = Debug|x64
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Debug|x64.Build.0 = Debug|x64
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Debug|x86.ActiveCfg = Debug|Win32
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Debug|x86.Build.0 = Debug|Win32
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Release|x64.ActiveCfg = Release|x64
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Release|x64.Build.0 = Release|x64
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Release|x86.ActiveCfg = Release|Win32
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{10A02379-886E-46F8-93F1-1E14235D42F9} = {467CF875-4855-4CBE-9D8D-86ADA3BA1AC5}
{7BE071FB-E33C-4903-9278-6D12BBA46E0D} = {467CF875-4855-4CBE-9D8D-86ADA3BA1AC5}
{56D7218D-8CCB-49A4-A2B9-D38D538EA42E} = {467CF875-4855-4CBE-9D8D-86ADA3BA1AC5}
EndGlobalSection
EndGlobal
-233
View File
@@ -1,233 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{741CFCD7-01A2-4325-AF0D-6678F7686FD8}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsDX11.v14</RootNamespace>
<WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>Use</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>Use</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v14.vcxproj">
<Project>{7be071fb-e33c-4903-9278-6d12bba46e0d}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsDX11.v14.vcxproj">
<Project>{56d7218d-8ccb-49a4-a2b9-d38d538ea42e}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\LogReporter.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h" />
<ClInclude Include="Applications\MSW\LogToOutputWindow.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp" />
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp" />
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp" />
<ClCompile Include="Applications\Window3.cpp" />
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
-156
View File
@@ -1,156 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{cb2ad3b5-22f9-4e38-ae16-341e12a5fba1}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{b496b533-4480-46b5-9faf-e66d58d3e420}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\LogReporter.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToMessageBox.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToOutputWindow.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
</Project>
-68
View File
@@ -1,68 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.28307.645
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsDX11.v15", "GTApplicationsDX11.v15.vcxproj", "{B8757F4C-106D-4E38-98F6-D013BE27BA74}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{6B439195-378D-4804-AEEC-79FAED351859}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v15", "GTMathematics.v15.vcxproj", "{49616508-0E21-4645-AC0B-7FE8E3628AB0}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v15", "GTGraphics.v15.vcxproj", "{51BBAD44-0632-4222-A199-F45BB78E5989}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsDX11.v15", "GTGraphicsDX11.v15.vcxproj", "{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Debug|x64.ActiveCfg = Debug|x64
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Debug|x64.Build.0 = Debug|x64
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Debug|x86.ActiveCfg = Debug|Win32
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Debug|x86.Build.0 = Debug|Win32
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Release|x64.ActiveCfg = Release|x64
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Release|x64.Build.0 = Release|x64
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Release|x86.ActiveCfg = Release|Win32
{B8757F4C-106D-4E38-98F6-D013BE27BA74}.Release|x86.Build.0 = Release|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x64.ActiveCfg = Debug|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x64.Build.0 = Debug|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x86.ActiveCfg = Debug|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x86.Build.0 = Debug|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x64.ActiveCfg = Release|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x64.Build.0 = Release|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x86.ActiveCfg = Release|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x86.Build.0 = Release|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x64.ActiveCfg = Debug|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x64.Build.0 = Debug|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x86.ActiveCfg = Debug|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x86.Build.0 = Debug|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x64.ActiveCfg = Release|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x64.Build.0 = Release|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x86.ActiveCfg = Release|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x86.Build.0 = Release|Win32
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Debug|x64.ActiveCfg = Debug|x64
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Debug|x64.Build.0 = Debug|x64
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Debug|x86.ActiveCfg = Debug|Win32
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Debug|x86.Build.0 = Debug|Win32
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Release|x64.ActiveCfg = Release|x64
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Release|x64.Build.0 = Release|x64
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Release|x86.ActiveCfg = Release|Win32
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{49616508-0E21-4645-AC0B-7FE8E3628AB0} = {6B439195-378D-4804-AEEC-79FAED351859}
{51BBAD44-0632-4222-A199-F45BB78E5989} = {6B439195-378D-4804-AEEC-79FAED351859}
{08B9FE3D-A338-42AD-9AE5-3F483FCFD64B} = {6B439195-378D-4804-AEEC-79FAED351859}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {49965E7C-6FAE-4AB4-BCE0-15796A3D58E6}
EndGlobalSection
EndGlobal
-238
View File
@@ -1,238 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>15.0</VCProjectVersion>
<ProjectGuid>{B8757F4C-106D-4E38-98F6-D013BE27BA74}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsDX11.v15</RootNamespace>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v15.vcxproj">
<Project>{51bbad44-0632-4222-a199-f45bb78e5989}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsDX11.v15.vcxproj">
<Project>{08b9fe3d-a338-42ad-9ae5-3f483fcfd64b}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp" />
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp" />
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp" />
<ClCompile Include="Applications\Window3.cpp" />
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\LogReporter.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h" />
<ClInclude Include="Applications\MSW\LogToOutputWindow.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
-156
View File
@@ -1,156 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{c32b676f-1007-43e3-8d8d-fcc60950882c}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{cf17034e-4fdd-4bbf-8af0-77d5bf25863d}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\LogReporter.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToOutputWindow.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
</Project>
-68
View File
@@ -1,68 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.28803.452
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsDX11.v16", "GTApplicationsDX11.v16.vcxproj", "{85367BB5-0DE5-477A-B880-0005612F8D1C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{47C55BEE-24FC-4D7C-A401-CCF8332DC6CD}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v16", "GTMathematics.v16.vcxproj", "{3F553568-76EF-48F0-88DD-270482C058B9}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v16", "GTGraphics.v16.vcxproj", "{ED37722A-40DE-4B07-9A4A-65E978D43643}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsDX11.v16", "GTGraphicsDX11.v16.vcxproj", "{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Debug|x64.ActiveCfg = Debug|x64
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Debug|x64.Build.0 = Debug|x64
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Debug|x86.ActiveCfg = Debug|Win32
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Debug|x86.Build.0 = Debug|Win32
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Release|x64.ActiveCfg = Release|x64
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Release|x64.Build.0 = Release|x64
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Release|x86.ActiveCfg = Release|Win32
{85367BB5-0DE5-477A-B880-0005612F8D1C}.Release|x86.Build.0 = Release|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x64.ActiveCfg = Debug|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x64.Build.0 = Debug|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x86.ActiveCfg = Debug|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x86.Build.0 = Debug|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x64.ActiveCfg = Release|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x64.Build.0 = Release|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x86.ActiveCfg = Release|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x86.Build.0 = Release|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x64.ActiveCfg = Debug|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x64.Build.0 = Debug|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x86.ActiveCfg = Debug|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x86.Build.0 = Debug|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x64.ActiveCfg = Release|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x64.Build.0 = Release|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x86.ActiveCfg = Release|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x86.Build.0 = Release|Win32
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Debug|x64.ActiveCfg = Debug|x64
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Debug|x64.Build.0 = Debug|x64
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Debug|x86.ActiveCfg = Debug|Win32
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Debug|x86.Build.0 = Debug|Win32
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Release|x64.ActiveCfg = Release|x64
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Release|x64.Build.0 = Release|x64
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Release|x86.ActiveCfg = Release|Win32
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{3F553568-76EF-48F0-88DD-270482C058B9} = {47C55BEE-24FC-4D7C-A401-CCF8332DC6CD}
{ED37722A-40DE-4B07-9A4A-65E978D43643} = {47C55BEE-24FC-4D7C-A401-CCF8332DC6CD}
{B24EA8FC-D596-42A1-AA46-72DEF1BE24BC} = {47C55BEE-24FC-4D7C-A401-CCF8332DC6CD}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {1CD44720-5081-46D2-8BE2-16D9BE17A4AA}
EndGlobalSection
EndGlobal
-258
View File
@@ -1,258 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp" />
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp" />
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\LogReporter.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h" />
<ClInclude Include="Applications\MSW\LogToOutputWindow.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v16.vcxproj">
<Project>{ed37722a-40de-4b07-9a4a-65e978d43643}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsDX11.v16.vcxproj">
<Project>{b24ea8fc-d596-42a1-aa46-72def1be24bc}</Project>
</ProjectReference>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<ProjectGuid>{85367BB5-0DE5-477A-B880-0005612F8D1C}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsDX11.v16</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
-156
View File
@@ -1,156 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{108bb8b1-880b-478f-b5f2-01a02c0235e2}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{5fcf44bc-cff8-487c-b2b6-7c3346df6e5d}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\LogReporter.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToMessageBox.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToOutputWindow.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
</Project>
+68
View File
@@ -0,0 +1,68 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.32014.148
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsDX11.v17", "GTApplicationsDX11.v17.vcxproj", "{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{A6702790-A89B-4C1B-BB65-A21A6970C2C5}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v17", "GTMathematics.v17.vcxproj", "{0CADDB12-31D9-4F60-A8C0-678D1773DA03}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v17", "GTGraphics.v17.vcxproj", "{B15CB711-F650-4063-9C7C-E7A5F88139A2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsDX11.v17", "GTGraphicsDX11.v17.vcxproj", "{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x64.ActiveCfg = Debug|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x64.Build.0 = Debug|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x86.ActiveCfg = Debug|Win32
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x86.Build.0 = Debug|Win32
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x64.ActiveCfg = Release|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x64.Build.0 = Release|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x86.ActiveCfg = Release|Win32
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x86.Build.0 = Release|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x64.ActiveCfg = Debug|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x64.Build.0 = Debug|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x86.ActiveCfg = Debug|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x86.Build.0 = Debug|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x64.ActiveCfg = Release|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x64.Build.0 = Release|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x86.ActiveCfg = Release|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x86.Build.0 = Release|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x64.ActiveCfg = Debug|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x64.Build.0 = Debug|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x86.ActiveCfg = Debug|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x86.Build.0 = Debug|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x64.ActiveCfg = Release|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x64.Build.0 = Release|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x86.ActiveCfg = Release|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x86.Build.0 = Release|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x64.ActiveCfg = Debug|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x64.Build.0 = Debug|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x86.ActiveCfg = Debug|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x86.Build.0 = Debug|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x64.ActiveCfg = Release|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x64.Build.0 = Release|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x86.ActiveCfg = Release|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{0CADDB12-31D9-4F60-A8C0-678D1773DA03} = {A6702790-A89B-4C1B-BB65-A21A6970C2C5}
{B15CB711-F650-4063-9C7C-E7A5F88139A2} = {A6702790-A89B-4C1B-BB65-A21A6970C2C5}
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004} = {A6702790-A89B-4C1B-BB65-A21A6970C2C5}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {156E34D8-849A-442A-B83B-B08AE1E1AF2C}
EndGlobalSection
EndGlobal
+256
View File
@@ -0,0 +1,256 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v17.vcxproj">
<Project>{B15CB711-F650-4063-9C7C-E7A5F88139A2}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsDX11.v17.vcxproj">
<Project>{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}</Project>
</ProjectReference>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>17.0</VCProjectVersion>
<ProjectGuid>{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsDX11.v17</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
+138
View File
@@ -0,0 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{108bb8b1-880b-478f-b5f2-01a02c0235e2}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{5fcf44bc-cff8-487c-b2b6-7c3346df6e5d}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
</Project>
+68
View File
@@ -0,0 +1,68 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 18
VisualStudioVersion = 18.1.11312.151 d18.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsDX11.v18", "GTApplicationsDX11.v18.vcxproj", "{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{A6702790-A89B-4C1B-BB65-A21A6970C2C5}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v18", "GTMathematics.v18.vcxproj", "{0CADDB12-31D9-4F60-A8C0-678D1773DA03}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v18", "GTGraphics.v18.vcxproj", "{B15CB711-F650-4063-9C7C-E7A5F88139A2}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsDX11.v18", "GTGraphicsDX11.v18.vcxproj", "{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x64.ActiveCfg = Debug|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x64.Build.0 = Debug|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x86.ActiveCfg = Debug|Win32
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Debug|x86.Build.0 = Debug|Win32
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x64.ActiveCfg = Release|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x64.Build.0 = Release|x64
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x86.ActiveCfg = Release|Win32
{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}.Release|x86.Build.0 = Release|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x64.ActiveCfg = Debug|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x64.Build.0 = Debug|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x86.ActiveCfg = Debug|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Debug|x86.Build.0 = Debug|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x64.ActiveCfg = Release|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x64.Build.0 = Release|x64
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x86.ActiveCfg = Release|Win32
{0CADDB12-31D9-4F60-A8C0-678D1773DA03}.Release|x86.Build.0 = Release|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x64.ActiveCfg = Debug|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x64.Build.0 = Debug|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x86.ActiveCfg = Debug|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Debug|x86.Build.0 = Debug|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x64.ActiveCfg = Release|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x64.Build.0 = Release|x64
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x86.ActiveCfg = Release|Win32
{B15CB711-F650-4063-9C7C-E7A5F88139A2}.Release|x86.Build.0 = Release|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x64.ActiveCfg = Debug|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x64.Build.0 = Debug|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x86.ActiveCfg = Debug|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Debug|x86.Build.0 = Debug|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x64.ActiveCfg = Release|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x64.Build.0 = Release|x64
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x86.ActiveCfg = Release|Win32
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{0CADDB12-31D9-4F60-A8C0-678D1773DA03} = {A6702790-A89B-4C1B-BB65-A21A6970C2C5}
{B15CB711-F650-4063-9C7C-E7A5F88139A2} = {A6702790-A89B-4C1B-BB65-A21A6970C2C5}
{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004} = {A6702790-A89B-4C1B-BB65-A21A6970C2C5}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {156E34D8-849A-442A-B83B-B08AE1E1AF2C}
EndGlobalSection
EndGlobal
+256
View File
@@ -0,0 +1,256 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Use</PrecompiledHeader>
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v18.vcxproj">
<Project>{B15CB711-F650-4063-9C7C-E7A5F88139A2}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsDX11.v18.vcxproj">
<Project>{00DEFF42-0F7C-4A7C-9C1F-59322B9E9004}</Project>
</ProjectReference>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>18.0</VCProjectVersion>
<ProjectGuid>{8BB237C2-2D3A-41AD-9B98-A35BA75D5DEA}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsDX11.v18</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v145</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v145</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v145</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v145</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\DX11\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_DIRECTX;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
<DisableSpecificWarnings>6262;26812</DisableSpecificWarnings>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
+138
View File
@@ -0,0 +1,138 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{108bb8b1-880b-478f-b5f2-01a02c0235e2}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{5fcf44bc-cff8-487c-b2b6-7c3346df6e5d}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
</Project>
-65
View File
@@ -1,65 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.25420.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsGL45.v14", "GTApplicationsGL45.v14.vcxproj", "{8AE08D71-B1FF-471C-9EEB-2ADF97593747}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{D4CA8594-EBBF-49A6-856A-041C80426153}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v14", "GTMathematics.v14.vcxproj", "{10A02379-886E-46F8-93F1-1E14235D42F9}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v14", "GTGraphics.v14.vcxproj", "{7BE071FB-E33C-4903-9278-6D12BBA46E0D}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsGL45.v14", "GTGraphicsGL45.v14.vcxproj", "{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Debug|x64.ActiveCfg = Debug|x64
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Debug|x64.Build.0 = Debug|x64
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Debug|x86.ActiveCfg = Debug|Win32
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Debug|x86.Build.0 = Debug|Win32
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Release|x64.ActiveCfg = Release|x64
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Release|x64.Build.0 = Release|x64
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Release|x86.ActiveCfg = Release|Win32
{8AE08D71-B1FF-471C-9EEB-2ADF97593747}.Release|x86.Build.0 = Release|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x64.ActiveCfg = Debug|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x64.Build.0 = Debug|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x86.ActiveCfg = Debug|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Debug|x86.Build.0 = Debug|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x64.ActiveCfg = Release|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x64.Build.0 = Release|x64
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x86.ActiveCfg = Release|Win32
{10A02379-886E-46F8-93F1-1E14235D42F9}.Release|x86.Build.0 = Release|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x64.ActiveCfg = Debug|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x64.Build.0 = Debug|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x86.ActiveCfg = Debug|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Debug|x86.Build.0 = Debug|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x64.ActiveCfg = Release|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x64.Build.0 = Release|x64
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x86.ActiveCfg = Release|Win32
{7BE071FB-E33C-4903-9278-6D12BBA46E0D}.Release|x86.Build.0 = Release|Win32
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Debug|x64.ActiveCfg = Debug|x64
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Debug|x64.Build.0 = Debug|x64
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Debug|x86.ActiveCfg = Debug|Win32
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Debug|x86.Build.0 = Debug|Win32
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Release|x64.ActiveCfg = Release|x64
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Release|x64.Build.0 = Release|x64
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Release|x86.ActiveCfg = Release|Win32
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{10A02379-886E-46F8-93F1-1E14235D42F9} = {D4CA8594-EBBF-49A6-856A-041C80426153}
{7BE071FB-E33C-4903-9278-6D12BBA46E0D} = {D4CA8594-EBBF-49A6-856A-041C80426153}
{77148ADE-5F3A-47D4-9F7F-B8CB621592AD} = {D4CA8594-EBBF-49A6-856A-041C80426153}
EndGlobalSection
EndGlobal
-293
View File
@@ -1,293 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{8AE08D71-B1FF-471C-9EEB-2ADF97593747}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsGL45.v14</RootNamespace>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>Use</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>Use</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v14.vcxproj">
<Project>{7be071fb-e33c-4903-9278-6d12bba46e0d}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsGL45.v14.vcxproj">
<Project>{77148ade-5f3a-47d4-9f7f-b8cb621592ad}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GLX\Console.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\ConsoleSystem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\WICFileIO.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\Window.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\WindowSystem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\LogReporter.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h" />
<ClInclude Include="Applications\MSW\LogToOutputWindow.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GLX\Console.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\ConsoleSystem.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\WICFileIO.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\Window.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\WindowSystem.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp" />
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp" />
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp" />
<ClCompile Include="Applications\Window3.cpp" />
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
-189
View File
@@ -1,189 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{c03aff5c-0ebd-4e30-9f11-42023bd3137f}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{71cb904f-976c-4379-a07f-7d3849cbb438}</UniqueIdentifier>
</Filter>
<Filter Include="GLX">
<UniqueIdentifier>{e68475bc-ecff-43e6-ab37-6806684c4478}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\LogReporter.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToOutputWindow.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\WICFileIO.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\Window.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\WindowSystem.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\Console.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\ConsoleSystem.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\WICFileIO.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\Window.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\WindowSystem.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\Console.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\ConsoleSystem.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
</Project>
-68
View File
@@ -1,68 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.28307.645
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsGL45.v15", "GTApplicationsGL45.v15.vcxproj", "{14364644-585C-43A8-9C45-E2EBCD8EEE4F}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{998B0775-BF22-470C-86F2-D729250B9A33}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v15", "GTMathematics.v15.vcxproj", "{49616508-0E21-4645-AC0B-7FE8E3628AB0}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v15", "GTGraphics.v15.vcxproj", "{51BBAD44-0632-4222-A199-F45BB78E5989}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsGL45.v15", "GTGraphicsGL45.v15.vcxproj", "{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Debug|x64.ActiveCfg = Debug|x64
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Debug|x64.Build.0 = Debug|x64
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Debug|x86.ActiveCfg = Debug|Win32
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Debug|x86.Build.0 = Debug|Win32
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Release|x64.ActiveCfg = Release|x64
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Release|x64.Build.0 = Release|x64
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Release|x86.ActiveCfg = Release|Win32
{14364644-585C-43A8-9C45-E2EBCD8EEE4F}.Release|x86.Build.0 = Release|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x64.ActiveCfg = Debug|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x64.Build.0 = Debug|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x86.ActiveCfg = Debug|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Debug|x86.Build.0 = Debug|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x64.ActiveCfg = Release|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x64.Build.0 = Release|x64
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x86.ActiveCfg = Release|Win32
{49616508-0E21-4645-AC0B-7FE8E3628AB0}.Release|x86.Build.0 = Release|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x64.ActiveCfg = Debug|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x64.Build.0 = Debug|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x86.ActiveCfg = Debug|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Debug|x86.Build.0 = Debug|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x64.ActiveCfg = Release|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x64.Build.0 = Release|x64
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x86.ActiveCfg = Release|Win32
{51BBAD44-0632-4222-A199-F45BB78E5989}.Release|x86.Build.0 = Release|Win32
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Debug|x64.ActiveCfg = Debug|x64
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Debug|x64.Build.0 = Debug|x64
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Debug|x86.ActiveCfg = Debug|Win32
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Debug|x86.Build.0 = Debug|Win32
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Release|x64.ActiveCfg = Release|x64
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Release|x64.Build.0 = Release|x64
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Release|x86.ActiveCfg = Release|Win32
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{49616508-0E21-4645-AC0B-7FE8E3628AB0} = {998B0775-BF22-470C-86F2-D729250B9A33}
{51BBAD44-0632-4222-A199-F45BB78E5989} = {998B0775-BF22-470C-86F2-D729250B9A33}
{F85F48E2-4D4A-48F5-8A54-AF1F788DF531} = {998B0775-BF22-470C-86F2-D729250B9A33}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {B036766D-D7F6-4477-A0B2-6C0D380980AC}
EndGlobalSection
EndGlobal
-298
View File
@@ -1,298 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>15.0</VCProjectVersion>
<ProjectGuid>{14364644-585C-43A8-9C45-E2EBCD8EEE4F}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsGL45.v15</RootNamespace>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v15.vcxproj">
<Project>{51bbad44-0632-4222-a199-f45bb78e5989}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsGL45.v15.vcxproj">
<Project>{f85f48e2-4d4a-48f5-8a54-af1f788df531}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GLX\Console.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\ConsoleSystem.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\WICFileIO.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\Window.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\WindowSystem.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp" />
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp" />
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp" />
<ClCompile Include="Applications\Window3.cpp" />
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GLX\Console.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\ConsoleSystem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\WICFileIO.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\Window.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\WindowSystem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\LogReporter.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h" />
<ClInclude Include="Applications\MSW\LogToOutputWindow.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
-189
View File
@@ -1,189 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Common">
<UniqueIdentifier>{bdd603a2-d1bc-462c-bd58-cf585d8adf59}</UniqueIdentifier>
</Filter>
<Filter Include="MSW">
<UniqueIdentifier>{4de8142b-1464-43a8-a0ec-1973e6b6085e}</UniqueIdentifier>
</Filter>
<Filter Include="GLX">
<UniqueIdentifier>{19852bbb-292e-4b2e-b8ea-545c692b5cc1}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\OnIdleTimer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Timer.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackBall.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackCylinder.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\TrackObject.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window2.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Window3.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\CameraRig.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Command.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Environment.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIO.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\WindowApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\Application.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\ConsoleApplication.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Console.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\Window.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WindowSystem.cpp">
<Filter>MSW</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\WICFileIO.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\Window.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\WindowSystem.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\Console.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\GLX\ConsoleSystem.cpp">
<Filter>GLX</Filter>
</ClCompile>
<ClCompile Include="Applications\MSW\WICFileIONative.cpp">
<Filter>MSW</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\OnIdleTimer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Timer.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackBall.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackCylinder.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\TrackObject.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\WICFileIO.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window2.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Window3.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\CameraRig.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Command.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Environment.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\LogReporter.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\LogToOutputWindow.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIO.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\WindowApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Application.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\Console.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\ConsoleApplication.h">
<Filter>Common</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Console.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\ConsoleSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\Window.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WindowSystem.h">
<Filter>MSW</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\WICFileIO.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\Window.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\WindowSystem.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\Console.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\GLX\ConsoleSystem.h">
<Filter>GLX</Filter>
</ClInclude>
<ClInclude Include="Applications\MSW\WICFileIONative.h">
<Filter>MSW</Filter>
</ClInclude>
</ItemGroup>
</Project>
-68
View File
@@ -1,68 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.28922.388
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTApplicationsGL45.v16", "GTApplicationsGL45.v16.vcxproj", "{EA72EE75-14B3-448F-828A-231FE02D0B38}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Required", "Required", "{A384113F-71DF-4725-AD9A-AACFA10EB6C3}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTMathematics.v16", "GTMathematics.v16.vcxproj", "{3F553568-76EF-48F0-88DD-270482C058B9}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphics.v16", "GTGraphics.v16.vcxproj", "{ED37722A-40DE-4B07-9A4A-65E978D43643}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GTGraphicsGL45.v16", "GTGraphicsGL45.v16.vcxproj", "{93806879-D052-48B1-AFAF-BF190FC67B7F}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Debug|x64.ActiveCfg = Debug|x64
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Debug|x64.Build.0 = Debug|x64
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Debug|x86.ActiveCfg = Debug|Win32
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Debug|x86.Build.0 = Debug|Win32
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Release|x64.ActiveCfg = Release|x64
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Release|x64.Build.0 = Release|x64
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Release|x86.ActiveCfg = Release|Win32
{EA72EE75-14B3-448F-828A-231FE02D0B38}.Release|x86.Build.0 = Release|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x64.ActiveCfg = Debug|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x64.Build.0 = Debug|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x86.ActiveCfg = Debug|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Debug|x86.Build.0 = Debug|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x64.ActiveCfg = Release|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x64.Build.0 = Release|x64
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x86.ActiveCfg = Release|Win32
{3F553568-76EF-48F0-88DD-270482C058B9}.Release|x86.Build.0 = Release|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x64.ActiveCfg = Debug|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x64.Build.0 = Debug|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x86.ActiveCfg = Debug|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Debug|x86.Build.0 = Debug|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x64.ActiveCfg = Release|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x64.Build.0 = Release|x64
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x86.ActiveCfg = Release|Win32
{ED37722A-40DE-4B07-9A4A-65E978D43643}.Release|x86.Build.0 = Release|Win32
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Debug|x64.ActiveCfg = Debug|x64
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Debug|x64.Build.0 = Debug|x64
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Debug|x86.ActiveCfg = Debug|Win32
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Debug|x86.Build.0 = Debug|Win32
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Release|x64.ActiveCfg = Release|x64
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Release|x64.Build.0 = Release|x64
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Release|x86.ActiveCfg = Release|Win32
{93806879-D052-48B1-AFAF-BF190FC67B7F}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{3F553568-76EF-48F0-88DD-270482C058B9} = {A384113F-71DF-4725-AD9A-AACFA10EB6C3}
{ED37722A-40DE-4B07-9A4A-65E978D43643} = {A384113F-71DF-4725-AD9A-AACFA10EB6C3}
{93806879-D052-48B1-AFAF-BF190FC67B7F} = {A384113F-71DF-4725-AD9A-AACFA10EB6C3}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {5AA4F78B-E10F-4485-8EBE-4968A5C54B62}
EndGlobalSection
EndGlobal
-300
View File
@@ -1,300 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<ProjectGuid>{EA72EE75-14B3-448F-828A-231FE02D0B38}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>GTApplicationsGL45.v16</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<OutDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</OutDir>
<IntDir>_Output\Applications\GL45\$(PlatformToolset)\$(Platform)\$(Configuration)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Use</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>GTE_USE_MSWINDOWS;GTE_USE_ROW_MAJOR;GTE_USE_MAT_VEC;GTE_USE_OPENGL;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalIncludeDirectories>.</AdditionalIncludeDirectories>
<TreatWarningAsError>true</TreatWarningAsError>
<PrecompiledHeaderFile>Applications/GTApplicationsPCH.h</PrecompiledHeaderFile>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="GTGraphics.v16.vcxproj">
<Project>{ed37722a-40de-4b07-9a4a-65e978d43643}</Project>
</ProjectReference>
<ProjectReference Include="GTGraphicsGL45.v16.vcxproj">
<Project>{93806879-d052-48b1-afaf-bf190fc67b7f}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClCompile Include="Applications\Application.cpp" />
<ClCompile Include="Applications\CameraRig.cpp" />
<ClCompile Include="Applications\Command.cpp" />
<ClCompile Include="Applications\ConsoleApplication.cpp" />
<ClCompile Include="Applications\Environment.cpp" />
<ClCompile Include="Applications\GLX\Console.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\ConsoleSystem.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\WICFileIO.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\Window.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GLX\WindowSystem.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="Applications\GTApplications.cpp">
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
<PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="Applications\LogReporter.cpp" />
<ClCompile Include="Applications\MSW\Console.cpp" />
<ClCompile Include="Applications\MSW\ConsoleSystem.cpp" />
<ClCompile Include="Applications\MSW\LogToMessageBox.cpp" />
<ClCompile Include="Applications\MSW\LogToOutputWindow.cpp" />
<ClCompile Include="Applications\MSW\WICFileIO.cpp" />
<ClCompile Include="Applications\MSW\WICFileIONative.cpp" />
<ClCompile Include="Applications\MSW\Window.cpp" />
<ClCompile Include="Applications\MSW\WindowSystem.cpp" />
<ClCompile Include="Applications\OnIdleTimer.cpp" />
<ClCompile Include="Applications\Timer.cpp" />
<ClCompile Include="Applications\TrackBall.cpp" />
<ClCompile Include="Applications\TrackCylinder.cpp" />
<ClCompile Include="Applications\TrackObject.cpp" />
<ClCompile Include="Applications\Window2.cpp" />
<ClCompile Include="Applications\Window3.cpp" />
<ClCompile Include="Applications\WindowApplication.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Applications\Application.h" />
<ClInclude Include="Applications\CameraRig.h" />
<ClInclude Include="Applications\Command.h" />
<ClInclude Include="Applications\Console.h" />
<ClInclude Include="Applications\ConsoleApplication.h" />
<ClInclude Include="Applications\Environment.h" />
<ClInclude Include="Applications\GLX\Console.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\ConsoleSystem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\WICFileIO.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\Window.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GLX\WindowSystem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="Applications\GTApplications.h" />
<ClInclude Include="Applications\GTApplicationsPCH.h" />
<ClInclude Include="Applications\LogReporter.h" />
<ClInclude Include="Applications\MSW\Console.h" />
<ClInclude Include="Applications\MSW\ConsoleSystem.h" />
<ClInclude Include="Applications\MSW\LogToMessageBox.h" />
<ClInclude Include="Applications\MSW\LogToOutputWindow.h" />
<ClInclude Include="Applications\MSW\WICFileIO.h" />
<ClInclude Include="Applications\MSW\WICFileIONative.h" />
<ClInclude Include="Applications\MSW\Window.h" />
<ClInclude Include="Applications\MSW\WindowSystem.h" />
<ClInclude Include="Applications\OnIdleTimer.h" />
<ClInclude Include="Applications\Timer.h" />
<ClInclude Include="Applications\TrackBall.h" />
<ClInclude Include="Applications\TrackCylinder.h" />
<ClInclude Include="Applications\TrackObject.h" />
<ClInclude Include="Applications\WICFileIO.h" />
<ClInclude Include="Applications\Window2.h" />
<ClInclude Include="Applications\Window3.h" />
<ClInclude Include="Applications\WindowApplication.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

Some files were not shown because too many files have changed in this diff Show More