How to use

RenderablePrototype

in

org.deegree.rendering.r3d.opengl.rendering.model.prototype

/**
 * @param wro
 * @return
 */
private RenderablePrototype createRenderablePrototype( WorldRenderableObject wro ) {
  RenderableQualityModel[] models = wro.getQualityLevels();
  if ( models == null || models.length != 1 ) {
    return null;
  }
  return new RenderablePrototype( wro.getId(), wro.getTime(), wro.getBbox(), models[0] );
}

@Override
public List<RenderablePrototype> loadProtoTypes( DirectGeometryBuffer geometryBuffer, ICRS baseCRS ) {
  List<RenderablePrototype> result = new LinkedList<RenderablePrototype>();
  try {
    PrototypeSerializer serializer = getPrototypeSerializer();
    serializer.setGeometryBuffer( geometryBuffer );
    List<DataObjectInfo<RenderablePrototype>> readAllFromFile = prototypeFile.readAllFromFile( baseCRS );
    Envelope datasetEnvelope = prototypeFile.getBackendInfo().getDatasetEnvelope();
    if ( datasetEnvelope == null && !readAllFromFile.isEmpty() ) {
      LOG.warn( "Could not determine the envelope of the prototypes, this is strange!" );
    } else {
      LOG.debug( "The envelope of the prototypes: " + datasetEnvelope );
    }
    for ( DataObjectInfo<RenderablePrototype> doi : readAllFromFile ) {
      RenderablePrototype rp = doi.getData();
      rp.setId( doi.getUuid() );
      rp.setTime( new Timestamp( doi.getTime() ).toString() );
      rp.setExternalReference( doi.getExternalRef() );
      rp.setName( doi.getName() );
      rp.setType( doi.getType() );
      result.add( rp );
    }
  } catch ( IOException e ) {
    LOG.error( "Could not read prototypes from file backend because: " + e.getLocalizedMessage(), e );
  }
  return result;
}

/**
 * @param glRenderContext
 * @param prototype
 * @param buffer
 *            to be used for rendering.
 */
public synchronized static void render( RenderContext glRenderContext, PrototypeReference prototype,
                    DirectGeometryBuffer buffer ) {
  if ( prototype == null || prototype.getPrototypeID() == null ) {
    return;
  }
  RenderablePrototype model = prototypes.get( prototype.getPrototypeID() );
  if ( model == null ) {
    LOG.warn( "No model found for prototype: " + prototype.getPrototypeID() );
    return;
  }
  GL context = glRenderContext.getContext();
  context.glPushMatrix();
  float[] loc = prototype.getLocation();
  context.glTranslatef( loc[0], loc[1], loc[2] );
  context.glRotatef( prototype.getAngle(), 0, 0, 1 );
  context.glScalef( prototype.getWidth(), prototype.getDepth(), prototype.getHeight() );
  if ( buffer == null ) {
    model.render( null );
  } else {
    model.renderPrepared( glRenderContext, buffer );
  }
  context.glPopMatrix();
}

PrototypePool.addPrototype( rp.getId(), rp );

private static RenderablePrototype createBoxPrototype() {
  RenderableQualityModel rqm = new RenderableQualityModel();
  RenderableGeometry rg = new BOXGeometry();
  rqm.addQualityModelPart( rg );
  Envelope env = new GeometryFactory().createEnvelope( 0, 0, 1, 1, null );
  return new RenderablePrototype( "box", "yeah", env, rqm );
}

/**
 * @param building
 * @return the DataObjectInfo which holds values of the given building.
 */
private DataObjectInfo<RenderablePrototype> createDataObjectInfo( WorldRenderableObject building ) {
  RenderableQualityModel rqm = building.getQualityLevel( 0 );
  if ( rqm == null ) {
    LOG.info( "Could not extract the quality level of the RenderablePrototype with id:" + building.getId() );
    return null;
  }
  rqm = createScaledQualityModel( rqm );
  Envelope env = new GeometryFactory().createEnvelope( new double[] { 0, 0, 0 }, new double[] { 1, 1, 1 }, null );
  building.setBbox( env );
  RenderablePrototype rp = new RenderablePrototype( building.getId(), building.getTime(), building.getBbox(), rqm );
  return new DataObjectInfo<RenderablePrototype>( building.getId(), Type.PROTOTYPE.getModelTypeName(),
                          building.getName(), building.getExternalReference(),
                          building.getBbox(), rp );
}