Enumeration VisibilityContextInterfaceSignal

The VisibilityContextInterfaceSignal lists all the signals that may be sent by the VisibilityContextInterface.

These signals are emitted by the VisibilityContextInterface when it is modified.

There is no way to know when the VisibilityContextInterface is ready since the VisibilityContextInterface is only an union of FilterSolverInterface and a ConfContextInterface that serves as a limitation for another filtering request (usually a FilterSolverInterface). As such, there is no way to get the part instances or geometric instances that are included in such a filtering context.

The VisibilityContextInterface may fire the following signals :

• VisibilitySolverAdded : a FilterSolverInterface has been added into the VisibilityContextInterface.
• VisibilitySolverRemoved : a FilterSolverInterface has been removed from the VisibilityContextInterface.
• VisibilityChanged : a FilterItemInterface inside a FilterSolverInterface of the given VisibilityContextInterface has changed, or a FilterSolverInterface has been removed or added.
• VisibilityConfChanged : a ConfContextInterface has changed or a new ConfContextInterface (or undefined) has been set for this given VisibilityContextInterface.
• VisibilityParentSolverChanged : the VisibilityContextInterface has been set as a filtering context for a FilterSolverInterface.

/** 
 * Sample to illustrate the use of multiple FilterSolverInterfaces to define a set of visible pieces, and
 * colorize a subset.
 * The visibility is composed of all the part instances included in a Box, that have the "CompletionStatus" attribute
 * set to "done".
 * The colorization set is based on the visibility, the part instances that have the attribute "ToBeRedesigned"
 * true should be colored in yellow.
 * This colors all part instance in yellow in the given box, that ave the attribute "ToBeRedesigned"
 * true and  "CompletionStatus" attribute set to "done".
 * This sample uses multiple FilterSolverInterface, VisibilityContextInterface, 
 * It uses some FilterAABBInterface, FilterAttributeInterface, FilterBooleanInterface.
 */
import {
    AttributesDictionaryInterface, AttributeInfoInterface, AttributeType, DataSessionInterface,
    InfiniteEngineInterface, ConfContextInterface, Vector3, AABB, FilterSolverInterface, VisibilityContextInterface, FilterAABBInterface, FilterAttributeInterface, FilterOperator, FilterSolverInterfaceSignal, VisualStates, FilterBooleanInterface,
} from 'generated/documentation/appinfiniteapi';

// lEngineInterface has been created previously
let lEngineInterface : InfiniteEngineInterface;
// the DataSessionInterface has been created previously and is connected
let lDataSession : DataSessionInterface;

// MAKE SURE the attributes "CompletionStatus", "ToBeRedesigned" are relevant
const lAttributeDictionary : AttributesDictionaryInterface = lDataSession.getAttributesDictionary();
let lAttributeInfo : AttributeInfoInterface | undefined = lAttributeDictionary.getAttributeInfo('CompletionStatus');
// make sure the attribute is a string one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_STRING));

lAttributeInfo = lAttributeDictionary.getAttributeInfo('ToBeRedesigned');
// make sure the attribute is a date one
console.assert((lAttributeInfo !== undefined) && (lAttributeInfo.getAttributeType() === AttributeType.ATTR_BOOLEAN));

// create a custom material yellow
const lMaterialId : number = lEngineInterface.getMaterialManager().createNewMaterial(new Vector3(1, 1, 0));
// create a conf context
const lConfContext : ConfContextInterface = lDataSession.createConfContext();
// no configuration for the moment (all `part instances`)
lConfContext.setActiveConfs([]);
// the AABB to use
const lABB : AABB = new AABB();
lABB.mCenter.x = 3.0;
lABB.mCenter.y = 3.0;
lABB.mCenter.z = 3.0;

lABB.mHalfExtent.x = 10.0;
lABB.mHalfExtent.y = 10.0;
lABB.mHalfExtent.z = 10.0;

// create the visibility Filter Solver
const lVisibilityFilterSolver : FilterSolverInterface = lDataSession.createFilterSolver();

// create the filtering context of the filter solver
const lInnerFilteringContext : VisibilityContextInterface = lDataSession.createVisibilityContext();
lInnerFilteringContext.setConfContext(lConfContext);
lVisibilityFilterSolver.setVisibilityContext(lInnerFilteringContext);

// create a box filter
const lFilterAABB : FilterAABBInterface = lDataSession.createFilterAABB();
// useless, FilterOperator.FO_UNION is the default operator when creating a new filter
// lFilterAABB.setFilterOperator(FilterOperator.FO_UNION);
lFilterAABB.setAABB(lABB);

// create a FilterAttributeInterface
const lFilterAttributes : FilterAttributeInterface = lDataSession.createFilterAttribute();
// completion status to done
lFilterAttributes.setAttributeName('CompletionStatus');
lFilterAttributes.setExactValues(['done']);
// no n/a
lFilterAttributes.setNaValueChecked(false);

// intersection is the way to go since intersection of box and instances that have the field "CompletionStatus"
// to "done"
// only change the operator of the filters except the first
lFilterAttributes.setFilterOperator(FilterOperator.FO_INTERSECTION);

// and add the filters
// push back (-1) the AABB filter
lVisibilityFilterSolver.insertFilter(-1, lFilterAABB);
// push back (-1) the FilterAttributeInterface, as it is the second one, its operator is used and therefore
// intersection is used
lVisibilityFilterSolver.insertFilter(-1, lFilterAttributes);

// create the filtering context
const lFilteringContext : VisibilityContextInterface = lDataSession.createVisibilityContext();
// sets the conf context
lFilteringContext.setConfContext(lConfContext);
// the colorize filter should be set a sub set of the visibility
lFilteringContext.insertFilterSolver(-1, lVisibilityFilterSolver);

lVisibilityFilterSolver.addEventListener(FilterSolverInterfaceSignal.SolverReady, () =>
{
    const lGeometries : Uint32Array | undefined = lVisibilityFilterSolver.getGeometricInstanceIds();
    if (lGeometries)
    {
        // set hidden and not ghosted for everyone
        lEngineInterface.updateGeometricStateForAll(VisualStates.S_Ghost | VisualStates.S_Hidden, (~VisualStates.S_Ghost) | VisualStates.S_Hidden);
        // and set not hidden for the given geometries 
        lEngineInterface.updateGeometricState(lGeometries, VisualStates.S_Hidden, ~VisualStates.S_Hidden);
    }
});

// create the colorize Filter Solver
const lColorizeFilterSolver : FilterSolverInterface = lDataSession.createFilterSolver();
// create an attribute filter
const lColorizeFilterAttributes : FilterBooleanInterface = lDataSession.createBooleanFilter();
// search ToBeRedesigned attribute
lColorizeFilterAttributes.setAttributeName('ToBeRedesigned');
// value should be true
lColorizeFilterAttributes.setBooleanValue(true);

// when the FilterSolverInterface is ready, colorize the given `geometric instances` 
lColorizeFilterSolver.addEventListener(FilterSolverInterfaceSignal.SolverReady, () =>
{
    const lGeomIds : Uint32Array | undefined = lColorizeFilterSolver.getGeometricInstanceIds();
    if (lGeomIds)
    {
        // change material for these elements
        lEngineInterface.getMaterialManager().changeMaterialOfInstances(lGeomIds, lMaterialId);
    }
});

// set the filtering context of the given `part instances` list
lColorizeFilterSolver.setVisibilityContext(lFilteringContext);
// add the colorize filter
lColorizeFilterSolver.insertFilter(-1, lColorizeFilterAttributes);
// and tell the DataSessionInterface to update the modified ConfContextInterface, VisibilityContextInterface and FilterSolverInterfaces
lDataSession.update();
// the filtering context may then be used to restrict a search, or a metadata retrieval to the given FilteringContext.

Please refer to the [VisibilityContextInterface](../interfaces/VisibilityContextInterface.html) for more information.

See

• VisibilityContextInterface
• FilterSolverInterface