Skip to content

Commit

Permalink
Revert GeometryCompiler changes that broke the feature generation
Browse files Browse the repository at this point in the history
  • Loading branch information
@gwaldron
gwaldron committed Jan 22, 2025
1 parent dd4b584 commit b2cf598
Show file tree
Hide file tree
Showing 2 changed files with 148 additions and 85 deletions.
102 changes: 74 additions & 28 deletions src/osgEarth/GeometryCompiler
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,8 @@
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
*/
#pragma once
#ifndef OSGEARTH_FEATURES_GEOMETRY_COMPILER_H
#define OSGEARTH_FEATURES_GEOMETRY_COMPILER_H 1

#include <osgEarth/Common>
#include <osgEarth/Feature>
Expand All @@ -32,69 +33,112 @@ namespace osgEarth
class OSGEARTH_EXPORT GeometryCompilerOptions
{
public:
//! Set the global default values for the options.
/**
* Set the global default values for the options.
*/
static void setDefaults(const GeometryCompilerOptions& defaults);

public:
//! Construct new compiler options, optionally deserializing them
/**
* Construct new copiler options, optionally deserializing them
*/
GeometryCompilerOptions(const ConfigOptions& conf =ConfigOptions());

public:
//! Maximum span of a generated edge, in degrees. Applicable to geocentric maps only
OE_OPTION(double, maxGranularity, 10.0);
/** Maximum span of a generated edge, in degrees. Applicable to geocentric maps only */
optional<double>& maxGranularity() { return _maxGranularity_deg; }
const optional<double>& maxGranularity() const { return _maxGranularity_deg; }

//! Interpolation type to use for geodetic points
OE_OPTION(GeoInterpolation, geoInterpolation, GEOINTERP_GREAT_CIRCLE);
/** Interpolation type to use for geodetic points */
optional<GeoInterpolation>& geoInterp() { return _geoInterp; }
const optional<GeoInterpolation>& geoInterp() const { return _geoInterp; }

//! Whether to merge geometry from multiple features
OE_OPTION(bool, mergeGeometry, true);
/** Whether to merge geometry from multiple features */
optional<bool>& mergeGeometry() { return _mergeGeometry; }
const optional<bool>& mergeGeometry() const { return _mergeGeometry; }

//! Expression to evaluate to extract a feature's readable name
OE_OPTION(StringExpression, featureName);
/** Expression to evaluate to extract a feature's readable name */
optional<StringExpression>& featureName() { return _featureNameExpr; }
const optional<StringExpression>& featureName() const { return _featureNameExpr; }

//! Whether to cluster feature geometries together for speed
OE_OPTION(bool, clustering, false);
/** Whether to cluster feature geometries together for speed */
optional<bool>& clustering() { return _clustering; }
const optional<bool>& clustering() const { return _clustering; }

//! Whether to enabled draw-instancing for model substitution
OE_OPTION(bool, instancing, true);
/** Whether to enabled draw-instancing for model substitution */
optional<bool>& instancing() { return _instancing; }
const optional<bool>& instancing() const { return _instancing; }

//! Whether to ignore the altitude filter (e.g. if you plan to do auto-clamping layer)
OE_OPTION(bool, ignoreAltitudeSymbol, false);
/** Whether to ignore the altitude filter (e.g. if you plan to do auto-clamping layer) */
optional<bool>& ignoreAltitudeSymbol() { return _ignoreAlt; }
const optional<bool>& ignoreAltitudeSymbol() const { return _ignoreAlt; }

//todo: merge this with geoInterp()
OE_OPTION(ResampleFilter::ResampleMode, resampleMode, ResampleFilter::RESAMPLE_LINEAR);
OE_OPTION(double, resampleMaxLength);
optional<osgEarth::ResampleFilter::ResampleMode>& resampleMode() { return _resampleMode;}
const optional<osgEarth::ResampleFilter::ResampleMode>& resampleMode() const { return _resampleMode;}

optional<double>& resampleMaxLength() { return _resampleMaxLength; }
const optional<double>& resampleMaxLength() const { return _resampleMaxLength;}

/** Whether to generate shader components on compiled geometry */
OE_OPTION(ShaderPolicy, shaderPolicy, SHADERPOLICY_GENERATE);
optional<ShaderPolicy>& shaderPolicy() { return _shaderPolicy; }
const optional<ShaderPolicy>& shaderPolicy() const { return _shaderPolicy; }

/** Whether to run consolidate equivalent state attributes for better performance. */
OE_OPTION(bool, optimizeStateSharing, true);
optional<bool>& optimizeStateSharing() { return _optimizeStateSharing; }
const optional<bool>& optimizeStateSharing() const { return _optimizeStateSharing; }

/** Whether to run the optimizer on the resulting group. */
OE_OPTION(bool, optimize, false);
optional<bool>& optimize() { return _optimize; }
const optional<bool>& optimize() const { return _optimize; }

/** Whether to run the vertex order optimizer on geometry. */
OE_OPTION(bool, optimizeVertexOrdering, true);
optional<bool>& optimizeVertexOrdering() { return _optimizeVertexOrdering; }
const optional<bool>& optimizeVertexOrdering() const { return _optimizeVertexOrdering; }

/** Whether to run a geometry validation pass on the resulting group. This is for debugging
purposes and will dump issues to the console. */
OE_OPTION(bool, validate, false);
optional<bool>& validate() { return _validate; }
const optional<bool>& validate() const { return _validate; }

/** Maximum size (angle, degrees) of a polygon tile, when breaking up a large polygon for tessellation;
only applies to geocentric maps */
OE_OPTION(float, maxPolygonTilingAngle, 45.0f);
only applies to geocentric maps (detault = 5.0) */
optional<float>& maxPolygonTilingAngle() { return _maxPolyTilingAngle; }
const optional<float>& maxPolygonTilingAngle() const { return _maxPolyTilingAngle; }

/** Whether to use OSG tessellator */
OE_OPTION(bool, useOSGTessellator, false);
/** Whether to use OSG tessellator (default=false) */
optional<bool>& useOSGTessellator() { return _useOSGTessellator; }
const optional<bool>& useOSGTessellator() const { return _useOSGTessellator; }

public:
Config getConfig() const;

protected:
void fromConfig( const Config& conf );

private:
optional<double> _maxGranularity_deg;
optional<GeoInterpolation> _geoInterp;
optional<bool> _mergeGeometry;
optional<StringExpression> _featureNameExpr;
optional<bool> _clustering;
optional<bool> _instancing;
optional<ResampleFilter::ResampleMode> _resampleMode;
optional<double> _resampleMaxLength;
optional<bool> _ignoreAlt;
optional<ShaderPolicy> _shaderPolicy;
optional<bool> _optimizeStateSharing;
optional<bool> _optimize;
optional<bool> _optimizeVertexOrdering;
optional<bool> _validate;
optional<float> _maxPolyTilingAngle;
optional<bool> _useOSGTessellator;


static GeometryCompilerOptions s_defaults;

public:
GeometryCompilerOptions(bool); // internal
};


Expand Down Expand Up @@ -158,3 +202,5 @@ namespace osgEarth
GeometryCompilerOptions _options;
};
} // namespace osgEarth

#endif // OSGEARTH_FEATURES_GEOMETRY_COMPILER_H
131 changes: 74 additions & 57 deletions src/osgEarth/GeometryCompiler.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,81 +55,98 @@ using namespace osgEarth::Util;

//-----------------------------------------------------------------------

GeometryCompilerOptions GeometryCompilerOptions::s_defaults;
GeometryCompilerOptions GeometryCompilerOptions::s_defaults(true);

void
GeometryCompilerOptions::setDefaults(const GeometryCompilerOptions& defaults)
{
s_defaults = defaults;
}

// defaults.
GeometryCompilerOptions::GeometryCompilerOptions(bool stockDefaults) :
_maxGranularity_deg ( 10.0 ),
_mergeGeometry ( true ),
_clustering ( false ),
_instancing ( true ),
_ignoreAlt ( false ),
_shaderPolicy ( SHADERPOLICY_GENERATE ),
_geoInterp ( GEOINTERP_GREAT_CIRCLE ),
_optimizeStateSharing ( true ),
_optimize ( false ),
_optimizeVertexOrdering( true ),
_validate ( false ),
_maxPolyTilingAngle ( 45.0f ),
_useOSGTessellator ( false )
{
//nop
}

//-----------------------------------------------------------------------

GeometryCompilerOptions::GeometryCompilerOptions(const ConfigOptions& conf) :
_maxGranularity(s_defaults.maxGranularity().value()),
_geoInterpolation(s_defaults.geoInterpolation().value()),
_mergeGeometry(s_defaults.mergeGeometry().value()),
_featureName(s_defaults.featureName().value()),
_clustering(s_defaults.clustering().value()),
_instancing(s_defaults.instancing().value()),
_ignoreAltitudeSymbol(s_defaults.ignoreAltitudeSymbol().value()),
_resampleMode(s_defaults.resampleMode().value()),
_resampleMaxLength(s_defaults.resampleMaxLength().value()),
_shaderPolicy(s_defaults.shaderPolicy().value()),
_optimizeStateSharing(s_defaults.optimizeStateSharing().value()),
_optimize(s_defaults.optimize().value()),
_optimizeVertexOrdering(s_defaults.optimizeVertexOrdering().value()),
_validate(s_defaults.validate().value()),
_maxPolygonTilingAngle(s_defaults.maxPolygonTilingAngle().value()),
_useOSGTessellator(s_defaults.useOSGTessellator().value())
_maxGranularity_deg ( s_defaults.maxGranularity().value() ),
_mergeGeometry ( s_defaults.mergeGeometry().value() ),
_clustering ( s_defaults.clustering().value() ),
_instancing ( s_defaults.instancing().value() ),
_ignoreAlt ( s_defaults.ignoreAltitudeSymbol().value() ),
_shaderPolicy ( s_defaults.shaderPolicy().value() ),
_geoInterp ( s_defaults.geoInterp().value() ),
_optimizeStateSharing ( s_defaults.optimizeStateSharing().value() ),
_optimize ( s_defaults.optimize().value() ),
_optimizeVertexOrdering( s_defaults.optimizeVertexOrdering().value() ),
_validate ( s_defaults.validate().value() ),
_maxPolyTilingAngle ( s_defaults.maxPolygonTilingAngle().value() ),
_useOSGTessellator (s_defaults.useOSGTessellator().value())
{
fromConfig(conf.getConfig());
}

void
GeometryCompilerOptions::fromConfig( const Config& conf )
{
conf.get("max_granularity", _maxGranularity);
conf.get("merge_geometry", _mergeGeometry);
conf.get("clustering", _clustering);
conf.get("instancing", _instancing);
conf.get("feature_name", _featureName);
conf.get("ignore_altitude", _ignoreAltitudeSymbol);
conf.get("geo_interpolation", "great_circle", _geoInterpolation, GEOINTERP_GREAT_CIRCLE);
conf.get("geo_interpolation", "rhumb_line", _geoInterpolation, GEOINTERP_RHUMB_LINE);
conf.get("optimize_state_sharing", _optimizeStateSharing);
conf.get("optimize", _optimize);
conf.get("optimize_vertex_ordering", _optimizeVertexOrdering);
conf.get("validate", _validate);
conf.get("max_polygon_tiling_angle", _maxPolygonTilingAngle);
conf.get("use_osg_tessellator", _useOSGTessellator);

conf.get("shader_policy", "disable", _shaderPolicy, SHADERPOLICY_DISABLE);
conf.get("shader_policy", "inherit", _shaderPolicy, SHADERPOLICY_INHERIT);
conf.get("shader_policy", "generate", _shaderPolicy, SHADERPOLICY_GENERATE);
conf.get( "max_granularity", _maxGranularity_deg );
conf.get( "merge_geometry", _mergeGeometry );
conf.get( "clustering", _clustering );
conf.get( "instancing", _instancing );
conf.get( "feature_name", _featureNameExpr );
conf.get( "ignore_altitude", _ignoreAlt );
conf.get( "geo_interpolation", "great_circle", _geoInterp, GEOINTERP_GREAT_CIRCLE );
conf.get( "geo_interpolation", "rhumb_line", _geoInterp, GEOINTERP_RHUMB_LINE );
conf.get( "optimize_state_sharing", _optimizeStateSharing );
conf.get( "optimize", _optimize );
conf.get( "optimize_vertex_ordering", _optimizeVertexOrdering);
conf.get( "validate", _validate );
conf.get( "max_polygon_tiling_angle", _maxPolyTilingAngle );
conf.get( "use_osg_tessellator", _useOSGTessellator);

conf.get( "shader_policy", "disable", _shaderPolicy, SHADERPOLICY_DISABLE );
conf.get( "shader_policy", "inherit", _shaderPolicy, SHADERPOLICY_INHERIT );
conf.get( "shader_policy", "generate", _shaderPolicy, SHADERPOLICY_GENERATE );
}

Config
GeometryCompilerOptions::getConfig() const
{
Config conf;
conf.set("max_granularity", _maxGranularity);
conf.set("merge_geometry", _mergeGeometry);
conf.set("clustering", _clustering);
conf.set("instancing", _instancing);
conf.set("feature_name", _featureName);
conf.set("ignore_altitude", _ignoreAltitudeSymbol);
conf.set("geo_interpolation", "great_circle", _geoInterpolation, GEOINTERP_GREAT_CIRCLE);
conf.set("geo_interpolation", "rhumb_line", _geoInterpolation, GEOINTERP_RHUMB_LINE);
conf.set("optimize_state_sharing", _optimizeStateSharing);
conf.set("optimize", _optimize);
conf.set("optimize_vertex_ordering", _optimizeVertexOrdering);
conf.set("validate", _validate);
conf.set("max_polygon_tiling_angle", _maxPolygonTilingAngle);
conf.set("use_osg_tessellator", _useOSGTessellator);

conf.set("shader_policy", "disable", _shaderPolicy, SHADERPOLICY_DISABLE);
conf.set("shader_policy", "inherit", _shaderPolicy, SHADERPOLICY_INHERIT);
conf.set("shader_policy", "generate", _shaderPolicy, SHADERPOLICY_GENERATE);
conf.set( "max_granularity", _maxGranularity_deg );
conf.set( "merge_geometry", _mergeGeometry );
conf.set( "clustering", _clustering );
conf.set( "instancing", _instancing );
conf.set( "feature_name", _featureNameExpr );
conf.set( "ignore_altitude", _ignoreAlt );
conf.set( "geo_interpolation", "great_circle", _geoInterp, GEOINTERP_GREAT_CIRCLE );
conf.set( "geo_interpolation", "rhumb_line", _geoInterp, GEOINTERP_RHUMB_LINE );
conf.set( "optimize_state_sharing", _optimizeStateSharing );
conf.set( "optimize", _optimize );
conf.set( "optimize_vertex_ordering", _optimizeVertexOrdering);
conf.set( "validate", _validate );
conf.set( "max_polygon_tiling_angle", _maxPolyTilingAngle );
conf.set( "use_osg_tessellator", _useOSGTessellator);

conf.set( "shader_policy", "disable", _shaderPolicy, SHADERPOLICY_DISABLE );
conf.set( "shader_policy", "inherit", _shaderPolicy, SHADERPOLICY_INHERIT );
conf.set( "shader_policy", "generate", _shaderPolicy, SHADERPOLICY_GENERATE );
return conf;
}

Expand All @@ -142,7 +159,7 @@ GeometryCompiler::GeometryCompiler()
}

GeometryCompiler::GeometryCompiler( const GeometryCompilerOptions& options ) :
_options( options )
_options( options )
{
//nop
}
Expand Down Expand Up @@ -250,15 +267,15 @@ GeometryCompiler::compile(FeatureList& workingSet,
{
TessellateOperator filter;
filter.setNumPartitions( *line->tessellation() );
filter.setDefaultGeoInterp( _options.geoInterpolation().get() );
filter.setDefaultGeoInterp( _options.geoInterp().get() );
sharedCX = filter.push( workingSet, sharedCX );
if ( trackHistory ) history.push_back( "tessellation" );
}
else if ( line->tessellationSize().isSet() )
{
TessellateOperator filter;
filter.setMaxPartitionSize( *line->tessellationSize() );
filter.setDefaultGeoInterp( _options.geoInterpolation().get() );
filter.setDefaultGeoInterp( _options.geoInterp().get() );
sharedCX = filter.push( workingSet, sharedCX );
if ( trackHistory ) history.push_back( "tessellationSize" );
}
Expand Down Expand Up @@ -423,7 +440,7 @@ GeometryCompiler::compile(FeatureList& workingSet,
BuildGeometryFilter filter( style );

filter.maxGranularity() = *_options.maxGranularity();
filter.geoInterp() = *_options.geoInterpolation();
filter.geoInterp() = *_options.geoInterp();
filter.useOSGTessellator() = *_options.useOSGTessellator();

if (_options.maxPolygonTilingAngle().isSet())
Expand Down

0 comments on commit b2cf598

Please sign in to comment.