Interface PrimitiveManagerInterface

The PrimitiveManagerInterface interface is the central point used to render primitive elements, such as points, boxes, lines and a rectangle.

This interface holds the primitive elements interfaces and the materials that are used by these primitive elements.

3D Points, 3D lines, 3D boxes and a single 2D rectangle can be rendered on top of the DMU, with a rendering hint depending on the relative depth between the 3D primitives and the geometries. This interface accessed through the getPrimitiveManager function. The colors of the 3D primitive are handled by the PrimitiveManagerMaterialInterface, accessed through getMaterialManager. Materials are accessed by their ids, and modified by their ids. 3D primitives are rendered colored with their material id, and not directly from a color.

3D Points

The rendering can be enriched with 3D points rendered on top of the geometries, with a rendering hint telling if the point is over or under a geometry.

Creating a point may be done with the following :

/** 
 * Sample to explain how to create 3d points on top of the rendering (PrimitiveManagerPointInterface).
 */
import { InfiniteEngineInterface, PrimitiveManagerMaterialInterface, PrimitiveManagerPointInterface, Vector4, Vector3 } from 'generated/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;
// created previously, the point position
let lPointPosition : Vector3;

// the material for the inner point color
let lInnerPointColorMaterial : number = -1;
// the material for the outer point color
let lOuterPointColorMaterial : number = -1;
// the primitive material manager
const lPrimitiveMaterialManager : PrimitiveManagerMaterialInterface = lInfiniteEngine.getPrimitiveManager().getMaterialManager();
// the point manager
const lPointManager : PrimitiveManagerPointInterface = lInfiniteEngine.getPrimitiveManager().getPointManager();

// inner point color is white opaque (1 as last parameter)
const lInnerPointColor : Vector4 = new Vector4(1, 1, 1, 1);
// outer point color is black semi transparent (0.5 as last parameter)
const lOuterPointColor : Vector4 = new Vector4(0, 0, 0, 0.5);

// create materials
lInnerPointColorMaterial = lPrimitiveMaterialManager.createMaterial(lInnerPointColor);
lOuterPointColorMaterial = lPrimitiveMaterialManager.createMaterial(lOuterPointColor);

// and create the point
const lPointId : number = lPointManager.createPoint(
    // position
    lPointPosition,
    // sizes (quite a large point :) )
    40,
    35,
    // colors
    lInnerPointColorMaterial,
    lOuterPointColorMaterial
);

console.log('Point id is ' + lPointId);

3D Lines

The rendering can be enriched with 3D lines rendered on top of the geometries.

Creating a line may be done with the following :

/** 
 * Sample to explain how to create 3d lines on top of the rendering (PrimitiveManagerLineInterface).
 */
import { InfiniteEngineInterface, PrimitiveManagerMaterialInterface, PrimitiveManagerLineInterface, Vector4, Vector3 } from 'generated/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;
// created previously, the segment point position 1
let lLinePosition1 : Vector3;
// created previously, the segment point position 2
let lLinePosition2 : Vector3;

// the material for the line color
let lLineColorMaterial : number = -1;
// the primitive material manager
const lPrimitiveMaterialManager : PrimitiveManagerMaterialInterface = lInfiniteEngine.getPrimitiveManager().getMaterialManager();
// the line manager
const lLineManager : PrimitiveManagerLineInterface = lInfiniteEngine.getPrimitiveManager().getLineManager();
// line color is white opaque (1 as last parameter)
const lLineColor : Vector4 = new Vector4(1, 1, 1, 1);

// create material
lLineColorMaterial = lPrimitiveMaterialManager.createMaterial(lLineColor);

// and create the line
const lLineId : number = lLineManager.createLine(
    // segment extents
    lLinePosition1,
    lLinePosition2,
    lLineColorMaterial,
    // line width
    5
);

console.log('Line id is ' + lLineId);

3D Boxes

The rendering can be enriched with 3D boxes rendered on top of the geometries, with a rendering hint telling if the edge/face is over or under a geometry.

Creating a box may be done with the following :

/** 
 * Sample to explain how to create 3d boxes on top of the rendering (PrimitiveManagerBoxInterface).
 */
import { InfiniteEngineInterface, PrimitiveManagerMaterialInterface, PrimitiveManagerBoxInterface, Vector4, Vector3 } from 'generated/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;
// created previously, the box center
let lBoxCenter : Vector3;
// created previously, the box half extent in x,y,z
let lBoxHalfExtent : Vector3;

// the material edges of the box
let lEdgeColorMaterial : number = -1;
// the material for the faces of the box
let lFaceColorMaterial : number = -1;
// the primitive material manager
const lPrimitiveMaterialManager : PrimitiveManagerMaterialInterface = lInfiniteEngine.getPrimitiveManager().getMaterialManager();
// the box manager
const lBoxManager : PrimitiveManagerBoxInterface = lInfiniteEngine.getPrimitiveManager().getBoxManager();

// face color is white opaque (1 as last parameter)
const lFaceColor : Vector4 = new Vector4(1, 1, 1, 1);
// edge color is red semi transparent (0.5 as last parameter)
const lEdgeColor : Vector4 = new Vector4(1, 0, 0, 0.5);

// create materials
lFaceColorMaterial = lPrimitiveMaterialManager.createMaterial(lFaceColor);
lEdgeColorMaterial = lPrimitiveMaterialManager.createMaterial(lEdgeColor);

// and create the box
const lBoxId : number = lBoxManager.createBox(
    // center, half extent
    lBoxCenter,
    lBoxHalfExtent,
    // colors
    lEdgeColorMaterial,
    lFaceColorMaterial,
    // line width
    5
);

console.log('Box id is ' + lBoxId);

2D rectangle (rubber band)

The rendering can be enriched with a single 2D rectangle rendered on top of the geometries. The color cannot be changed.

Rendering a 2D rectangle may be done with the following :

/** 
 * Sample to explain how to create a 2D rectangle on top of the rendering (PrimitiveManagerRubberBandInterface).
 */
import { InfiniteEngineInterface, PrimitiveManagerRubberBandInterface, Vector2, Rectangle } from 'generated/documentation/appinfiniteapi';

// created previously
let lInfiniteEngine : InfiniteEngineInterface;
const lSelectionRectangle : Rectangle = new Rectangle();

// created previously, the rectangle extents
let lRectanglePosition1 : Vector2;
let lRectanglePosition2 : Vector2;

// the rubber band manager
const lRubberBandManager : PrimitiveManagerRubberBandInterface = lInfiniteEngine.getPrimitiveManager().getRubberBandManager();

// compute rectangle geometry from the 2 extent points
lSelectionRectangle.x = Math.min(lRectanglePosition1.x, lRectanglePosition2.x);
lSelectionRectangle.y = Math.min(lRectanglePosition1.y, lRectanglePosition2.y);
lSelectionRectangle.width = Math.abs(lRectanglePosition1.x - lRectanglePosition2.x);
lSelectionRectangle.height = Math.abs(lRectanglePosition1.y - lRectanglePosition2.y);

// make sure rectangle is correct
console.assert(lSelectionRectangle.isValid() && (!lSelectionRectangle.isEmpty()));

// set rectangle and display it
lRubberBandManager.setRubberBandRectangle(lSelectionRectangle);
lRubberBandManager.setRubberBandVisible(true);

See

• PrimitiveManagerMaterialInterface
• PrimitiveManagerPointInterface
• PrimitiveManagerLineInterface
• PrimitiveManagerBoxInterface
• PrimitiveManagerRubberBandInterface