jMonkeyCSG Files

WCOmohundro - jMonkey3 Constructive Solid Geometry - 

*** BUILD 2019/10/21 ***
jMonkeyCSG has been rebuilt to include various enhancements to the XMLLoader,
especially in regards to substitution/definition processing.
This version (1.1) is built against the jMonkey SDK 3.2.1 libraries.

Jar file:  WCOmoCSG321-b20191021-j17.jar   		- the core CSG support classes
Jar file:  WCOmoCSGtest321-b20191021-j17.jar	- test drivers and assets
Jar file:  WCOmoCSGjme321-b20191021-j17.jar     - core jme3 extensions needed for full XML 
                                                  import/construction of CSG elements
Jar file:  WCOmoCSGsrc321-b20191021-j17.jar     - all associated source files


*** BUILD 2019/03/05 ***
jMonkeyCSG has been rebuilt to include various enhancements to the XMLLoader, and
the new shape CSGHexahedron has been created.  This version is built against 
the jMonkey SDK 3.2.1 libraries.

Jar file:  WCOmoCSG321-b20190305-j17.jar   		- the core CSG support classes
Jar file:  WCOmoCSGtest321-b20190305-j17.jar	- test drivers and assets
Jar file:  WCOmoCSGjme321-b20190305-j17.jar     - core jme3 extensions needed for full XML 
                                                  import/construction of CSG elements
Jar file:  WCOmoCSGsrc321-b20190305-j17.jar     - all associated source files


*** BUILD 2018/05/30 ***
jMonkeyCSG has been reconfigured a bit to be more compatible with the standard jme3 
releases.  In particular, CSG is now built against the stable jMonkey SDK rather than 
relying directly on the Github source repository.  Java 1.7 remains the minimal runtime
environment.

This build is now compatible with jMonkey SDK 3.2.1

Jar file:  WCOmoCSG321-b20180530-j17.jar   		- the core CSG support classes
Jar file:  WCOmoCSGtest321-b20180530-j17.jar	- test drivers and assets
Jar file:  WCOmoCSGjme321-b20180530-j17.jar     - core jme3 extensions needed for full XML 
                                                  import/construction of CSG elements

You can now run with the core CSG support without needing any of the jme3 modifications.
All you need is the WCOmoCSG321 jar.  You will NOT be able to leverage any of the XML
import extensions, but you can exercise all of the CSG functionality directly from
Java code.

For example (using the jMonkey 3.2.1 SDK)
1)  Create a new project
2)  Add WCOmoCSG321-b20180530-j17.jar to the project libraries
3)  Copy the file 'net.wcomohundro.jme3.csg.test.Main.java' into the project main class
4)  Run the project
You will see a series of blended shapes being constructed and added into the scene.

If you want to leverage the XML import facilities to load and blend shapes, then 
add WCOmoCSGjme321-b20180530-j17.jar into your project libraries.  

  ---> BE SURE TO POSITION THIS JAR BEFORE ANY OF THE STANDARD jme3 JARS <---
  
There are many examples of XML definition files in the test jar.


AFTER 2015/10/21
	I have backed off my reliance on java 1.8 and retrofitted the code to operate within
	java 1.7.  This makes it more compatible with operating with the jMonkey SDK.  
PRIOR TO 2015/10/21
	The CSG source leverages new java 1.8 language features, therefore you must be running 
	in a 1.8 java environment.


*** BUILD 2016/03/08 ***
Jar file WCOmoCSG-b08032016-j17.jar  - based on the jme3 trunk source code at version 6067
Jar file jMonkey3-b08032016-j17.jar  - all jMonkey engine classes from trunk 6067
Zip file CSGTestPackaging-Windows.zip - self contained Windows executable sample of CSG

This build incorporates the latest JME3 truck changes and a sample zip file that holds all
the libraries used in running CSG, as well as a sample Windows executable. The Windows
executable now contains multiple test drivers which you select from via a dialog posted
during startup.

The test drivers now post a dynamic status message which tracks the progress during 
CSG construction.



*** BUILD 2016/02/05 ***
Jar file WCOmoCSG-b05022016-j17.jar  - based on the jme3 trunk source code at version 6046
Jar file jMonkey3-b05022016-j17.jar  - all jMonkey engine classes from trunk 6046
Zip file CSGTestPackaging-Windows.zip - self contained Windows executable sample of CSG

This build incorporates the latest JME3 truck changes and a sample zip file that holds all
the libraries used in running CSG, as well as a sample Windows executable.


*** BUILD 2016/02/01 ***
Jar file WCOmoCSG-b01022016-j17.jar  - based on the jme3 trunk source code at version 5707

1)  .regenerate() signature change to return the resultant CSGShape, which can then be
	fed back into blending as part of 'progressive' mode
2)	CSGFaceProperties texture support for origin/span/terminus for better alignment
3)	Monitor of Thread.interrupted to stop long running process
4)	Thread aware separation of face/shape generation versus scene update
5)	Blended local lights
6)	Blended Physics
7)  CSGAxialBox to better align textures with other Axial/Radial shapes
8)	CSGSurface shape for 2D 'floor' support
9)	CSGSkyDome helper class to create a 'sky', including gradient color generation
10) Rework of error reporting and standardization on CSGConstructionException
11) Face split and categorization bug fixes which make the entire blend process much
	more solid and robust, hopefully eliminating infinite splits and bogus/missing
	triangles.
	
Continue to use this jar in conjunction with the jMonkey3 minimal jar within the jMonkey IDE.


*** BUILD 2015/11/07 ***
Jar file WCOmoCSG-b07112015-j17.jar  - based on the jme3 trunk source code at version 5707

Calling .regenerate() for a second time with the same CSGShapes whose underlying Meshes 
have changed resulted in using an obsolete copy of a Mesh.  This has been fixed.  You may
now alter the underlying Meshes (say via translate or rotate) and simply call 
.regenerate() to produce the expected blend.
Thanks to 
	http://hub.jmonkeyengine.org/t/solved-how-to-get-intersection-areas/34311 
for identifying this problem.  FYI -- the same code with this post makes a nice demo
of how CSG is supposed to operate.
Continue to use this jar in conjunction with the jMonkey3 minimal jar within the jMonkey IDE.


*** BUILD 2015/11/02 ***
Jar file WCOmoCSG-b02112015-j17.jar  - based on the jme3 trunk source code at version 5707

I found another optimization in the IOB split processing that both saves some processing
time and may help prevent a certain class of infinite iterations.
Continue to use this jar in conjunction with the jMonkey3 minimal jar within the jMonkey IDE.


*** BUILD 2015/10/31 ***
Jar file jMonkey3-b31102015-j17-minimal.jar

It was reported that there was a corruption problem with the jMonkey3-b21102015-j17.jar file.
I downloaded it from SourceForge and could find nothing wrong.  But I have gone back looking
for the fewest jme3 core files needed to run CSG within the jMonkey IDE.  The result is
this new 'minimal' file that contains only those components needed to operate.  For now, it
appears this is limited to Vector3d from the blender math package.

Including the minimal jar, instead of the full one, allows my simple CSG test to run within
the jMonkey IDE.  Keep it at the end of the Libraries list.


*** BUILD 2015/10/30 ***
Jar file WCOmoCSG-b30102015-j17.jar  - based on the jme3 trunk source code at version 5707

I stumbled over a test that caused infinite iteration in the IOB processor. I fixed it with
a code update and some tweaks to the 'tolerances'.  CSGShape XML now supports an alternate
CSGTransform, which allows you to define rotation in terms of angular pitch/yawl/roll.
Continue to also include the jMonkey3-b21102015-j17.jar for jMonkey IDE integration.


*** BUILD 2015/10/28 ***
Jar file WCOmoCSG-b28102015-j17.jar  - based on the jme3 trunk source code at version 5707

This build contains minor tweaks and fixups to better support the on-line documentation.
Continue to use jMonkey3-b21102015-j17.jar for jMonkey IDE integration.


*** BUILD 2015/10/23 ***
Jar file WCOmoCSG-b21102015-j17.jar  - based on the jme3 trunk source code at version 5707
Jar file jMonkey3-b21102015-j17.jar  - all jMonkey engine classes from trunk 5707
Zip file WCOmoCSG-b21102015.zip      - all components needed to run a simple CSG test (Windows 64)

This build represents two major shifts within my CSG support:
1)	The requirement for Java 1.8 has been eliminated.  The jMonkey SDK standard of 1.7 will
	now work.
2)	From research on the web and my own experiments with this code, I have decided that the
	problem of 'artifacts' within the BSP processing is an inherent (and unfortunate) 
	consequence of running on a real computer with limited precision. None of my adjustments
	of the various tolerances reliably produced uncorrupted solids for my various test cases.
	However, I have implemented a different algorithm that is not BSP based, but which 
	seems to produce good results.
	
The new algorithm is based on matching every faceA in one solidA to every faceB in the solidB
it is blending with. If the two faces intersect, then faceA is split into subpieces such that
no subpiece intersects with any face in solidB. Edges and vertices may touch, but no two faces
will pass through each other.  Once the split is done, then every face can be marked as 
Inside/Outside/Boundary in regards to the other solid. The blend is an accumulation from the two
solid those faces with the appropriate status.

I have not yet encountered any corrupted solid from the IOB blend processing. But remember,
you are looking at a 2 * M * N processing multiplier based on the number of faces in each solid.
As more faces are close to each other and overlap, both the M and N counts will rise. The IOB
processing always seems to come back, but have patience.

Both the BSP and IOB algorithms remain available.  BSP supports either single precision (float)
or double precision (double).  IOB is inherently double, and I have no reason to implement 
single precision at this time.


*** BUILD 2015/08/18 ***
Jar file WCOmoCSG-b18082015-j18.jar  - based on the jme3 trunk source code at version 5454.

This build corrects my misunderstanding of how normalDot operates within CSGPlane and properly
accepts a vertex of (x, y, 0) (-x, y, 0) (0, 0, z).
Usage of TempVars has also been made more efficient.



*** BUILD 2015/08/14 ***
Jar file WCOmoCSG-b14082015-j18.jar  - based on the jme3 trunk source code at version 5454.

This build expands upon the configuration options within CSGEnvironment.  It allows for null
TexCoord buffers within a mesh, and eliminates the expectation that normal vectors are of length 1.
The CheckStructure control flag has been defaulted to 'false' to speed up processing in the default
CSGEnvironment.



*** BUILD 2015/08/13 ***
Jar file WCOmoCSG-b13082015-j18.jar  - based on the jme3 trunk source code at version 5454.

This build includes initial support for a CSGEnvironment configuration packet, which contains the 
active values to use for various tolerances and limits.  By defining your own set of limits, you can
drive CSG with higher resolution shapes that contain more polygons, which cause deeper BSP processing.

The standard defaults are still defined in the ConstructiveSolidGeometry class, but those values are
copied into a CSGEnvironment instance which is used during processing.  These standard values work for
many examples, but can fail with a high resolution shape (like a Sphere with 64 slices).



*** BUILD 2015/08/12 ***
Jar file WCOmoCSG-b12082015-j18.jar  - based on the jme3 trunk source code at version 5454.

This build includes an enhancement to "fromMesh" processing that accepts meshes that have no UV TexCoord
buffer.  A default value of 0,0 is used for every UV coordinate point.



*** BUILD 2015/08/10 ***
Jar file WCOmoCSG-b10082015-j18.jar  - based on the jme3 trunk source code at version 5454.

The package net.wcomohundro.jme3.csg contains all of the CSG support classes.
The package com.jme3 contains all of my modifications to the jme3 core classes.  These modifications are 
not needed to run the basic CSG functionality.  However, if you wish to utilize my XML loader extensions, then
these changes are needed.  

Basically, if your environment loads the WCOmoCSG jar before the core jme3 jars, then my changes should be
active.  If your environment loads the WCOmoCSG jar after the core jme3 jars, then my changes should be
hidden.

My development environment of choice is Eclipse (version Mars, currently) and I do all of my builds, testing,
and debugging there.  I do not actively use the jMonkey IDE and do not understand it very well at all.

Compile time errors have been reported when trying to incorporate my CSG source into the jMonkey IDE.  I do
not know how to repair this problem.

However, I have pre-built the WCOmoCSG jar file from Eclipse, and my simple tests including this jar 
in the jMonkey IDE environment have been successful.
So if you want to use this CSG within your jMonkey IDE projects, leave out my source code altogether, and
instead, include the .jar in your Libraries section of your jme project.