public DisplayableRenderable GetRenderable(BHash hash, RenderableBuilder builder)
{
DisplayableRenderable renderable = null;
lock (Renderables) {
if (!Renderables.TryGetValue(hash, out renderable))
{
try {
if (builder != null)
{
renderable = builder();
}
else
{
renderable = null;
}
}
catch (Exception e) {
ConvOAR.Globals.log.ErrorFormat("{0} GetRenderable: builder exception: {1}", _logHeader, e);
}
Renderables.Add(hash, renderable);
}
}
return(renderable);
}
public InvertedMesh(BScene pBs, BInstance pInst, Displayable pDisp, DisplayableRenderable pDisprend, RenderableMesh pRm)
{
containingScene = pBs;
containingInstance = pInst;
containingDisplayable = pDisp;
containingDisplayableRenderable = pDisprend;
renderableMesh = pRm;
// Compute the global position of the Displayable
globalPosition = containingDisplayable.offsetPosition * containingInstance.Rotation + containingInstance.Position;
globalRotation = containingDisplayable.offsetRotation * containingInstance.Rotation;
}
private Promise <DisplayableRenderable> MeshFromPrimShapeData(SceneObjectGroup sog, SceneObjectPart sop,
OMV.Primitive prim, IAssetFetcher assetFetcher, OMVR.DetailLevel lod)
{
return(new Promise <DisplayableRenderable>((resolve, reject) => {
OMVR.FacetedMesh mesh = _mesher.GenerateFacetedMesh(prim, lod);
DisplayableRenderable dr = ConvertFacetedMeshToDisplayable(assetFetcher, mesh, prim.Textures.DefaultTexture, prim.Scale);
BHash drHash = dr.GetBHash();
DisplayableRenderable realDR = assetFetcher.GetRenderable(drHash, () => { return dr; });
BConverterOS.LogBProgress("{0} MeshFromPrimShapeData. numGenedMeshed={1}",
_logHeader, ((RenderableMeshGroup)realDR).meshes.Count);
resolve(realDR);
}));
}
public Displayable(DisplayableRenderable pRenderable, SceneObjectPart sop) : this()
{
name = sop.Name;
baseSOP = sop;
baseUUID = sop.UUID;
// If not a root prim, add the offset to the root.
// The root Displayable will be zeros (not world position which is in the BInstance).
if (!sop.IsRoot)
{
offsetPosition = baseSOP.OffsetPosition;
offsetRotation = baseSOP.RotationOffset;
}
if (ConvOAR.Globals.parms.P <bool>("DisplayTimeScaling"))
{
scale = sop.Scale;
}
attributes.Add("HasSciptsInInventory", sop.Inventory.ContainsScripts());
attributes.Add("IsPhysical", (sop.PhysActor != null && sop.PhysActor.IsPhysical));
renderable = pRenderable;
}
private Promise <DisplayableRenderable> MeshFromPrimSculptData(SceneObjectGroup sog, SceneObjectPart sop,
OMV.Primitive prim, IAssetFetcher assetFetcher, OMVR.DetailLevel lod)
{
return(new Promise <DisplayableRenderable>((resolve, reject) => {
// Get the asset that the sculpty is built on
EntityHandleUUID texHandle = new EntityHandleUUID(prim.Sculpt.SculptTexture);
assetFetcher.FetchTexture(texHandle)
.Then((bm) => {
OMVR.FacetedMesh fMesh = _mesher.GenerateFacetedSculptMesh(prim, bm.Image.ExportBitmap(), lod);
DisplayableRenderable dr =
ConvertFacetedMeshToDisplayable(assetFetcher, fMesh, prim.Textures.DefaultTexture, prim.Scale);
BHash drHash = dr.GetBHash();
DisplayableRenderable realDR = assetFetcher.GetRenderable(drHash, () => { return dr; });
BConverterOS.LogBProgress("{0} MeshFromPrimSculptData. numFaces={1}, numGenedMeshed={2}",
_logHeader, fMesh.Faces.Count, ((RenderableMeshGroup)realDR).meshes.Count);
resolve(realDR);
}, (e) => {
ConvOAR.Globals.log.ErrorFormat("{0} MeshFromPrimSculptData: Rejected FetchTexture: {1}: {2}", _logHeader, texHandle, e);
reject(null);
});
}));
}
private Promise <DisplayableRenderable> MeshFromPrimMeshData(SceneObjectGroup sog, SceneObjectPart sop,
OMV.Primitive prim, IAssetFetcher assetFetcher, OMVR.DetailLevel lod)
{
EntityHandleUUID meshHandle = new EntityHandleUUID(prim.Sculpt.SculptTexture);
return(new Promise <DisplayableRenderable>((resolve, reject) => {
assetFetcher.FetchRawAsset(meshHandle)
.Then(meshBytes => {
// OMVA.AssetMesh meshAsset = new OMVA.AssetMesh(prim.ID, meshBytes);
// if (OMVR.FacetedMesh.TryDecodeFromAsset(prim, meshAsset, lod, out fMesh)) {
OMVR.FacetedMesh fMesh = null;
try {
fMesh = _mesher.GenerateFacetedMeshMesh(prim, meshBytes);
}
catch (Exception e) {
ConvOAR.Globals.log.ErrorFormat("{0} Exception in GenerateFacetedMeshMesh: {1}", _logHeader, e);
}
if (fMesh != null)
{
DisplayableRenderable dr = ConvertFacetedMeshToDisplayable(assetFetcher, fMesh, prim.Textures.DefaultTexture, prim.Scale);
// Don't know the hash of the DisplayableRenderable until after it has been created.
// Now use the hash to see if this has already been done.
// If this DisplayableRenderable has already been built, use the other one and throw this away.
BHash drHash = dr.GetBHash();
DisplayableRenderable realDR = assetFetcher.GetRenderable(drHash, () => { return dr; });
resolve(realDR);
}
else
{
reject(new Exception("MeshFromPrimMeshData: could not decode mesh information from asset. ID="
+ prim.ID.ToString()));
}
}, e => {
ConvOAR.Globals.log.ErrorFormat("{0} MeshFromPrimMeshData: exception: {1}", _logHeader, e);
reject(e);
});
}));
}
// Create a mesh for the terrain of the current scene
public static BInstance CreateTerrainMesh(
Scene scene,
PrimToMesh assetMesher, IAssetFetcher assetFetcher)
{
ITerrainChannel terrainDef = scene.Heightmap;
int XSize = terrainDef.Width;
int YSize = terrainDef.Height;
float[,] heightMap = new float[XSize, YSize];
if (ConvOAR.Globals.parms.P <bool>("HalfRezTerrain"))
{
ConvOAR.Globals.log.DebugFormat("{0}: CreateTerrainMesh. creating half sized terrain sized <{1},{2}>", LogHeader, XSize / 2, YSize / 2);
// Half resolution mesh that approximates the heightmap
heightMap = new float[XSize / 2, YSize / 2];
for (int xx = 0; xx < XSize; xx += 2)
{
for (int yy = 0; yy < YSize; yy += 2)
{
float here = terrainDef.GetHeightAtXYZ(xx + 0, yy + 0, 26);
float ln = terrainDef.GetHeightAtXYZ(xx + 1, yy + 0, 26);
float ll = terrainDef.GetHeightAtXYZ(xx + 0, yy + 1, 26);
float lr = terrainDef.GetHeightAtXYZ(xx + 1, yy + 1, 26);
heightMap[xx / 2, yy / 2] = (here + ln + ll + lr) / 4;
}
}
}
else
{
ConvOAR.Globals.log.DebugFormat("{0}: CreateTerrainMesh. creating terrain sized <{1},{2}>", LogHeader, XSize / 2, YSize / 2);
for (int xx = 0; xx < XSize; xx++)
{
for (int yy = 0; yy < YSize; yy++)
{
heightMap[xx, yy] = terrainDef.GetHeightAtXYZ(xx, yy, 26);
}
}
}
// Number found in RegionSettings.cs as DEFAULT_TERRAIN_TEXTURE_3
OMV.UUID convoarID = new OMV.UUID(ConvOAR.Globals.parms.P <string>("ConvoarID"));
OMV.UUID defaultTextureID = new OMV.UUID("179cdabd-398a-9b6b-1391-4dc333ba321f");
OMV.Primitive.TextureEntryFace terrainFace = new OMV.Primitive.TextureEntryFace(null);
terrainFace.TextureID = defaultTextureID;
EntityHandleUUID terrainTextureHandle = new EntityHandleUUID();
MaterialInfo terrainMaterialInfo = new MaterialInfo(terrainFace);
if (ConvOAR.Globals.parms.P <bool>("CreateTerrainSplat"))
{
// Use the OpenSim maptile generator to create a texture for the terrain
var terrainRenderer = new TexturedMapTileRenderer();
Nini.Config.IConfigSource config = new Nini.Config.IniConfigSource();
terrainRenderer.Initialise(scene, config);
var mapbmp = new Bitmap(terrainDef.Width, terrainDef.Height,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
terrainRenderer.TerrainToBitmap(mapbmp);
// Place the newly created image into the Displayable caches
ImageInfo terrainImageInfo = new ImageInfo();
terrainImageInfo.handle = terrainTextureHandle;
terrainImageInfo.image = mapbmp;
terrainImageInfo.resizable = false; // terrain image resolution is not reduced
assetFetcher.Images.Add(new BHashULong(terrainTextureHandle.GetHashCode()), terrainTextureHandle, terrainImageInfo);
// Store the new image into the asset system so it can be read later.
assetFetcher.StoreTextureImage(terrainTextureHandle, scene.Name + " Terrain", convoarID, mapbmp);
// Link this image to the material
terrainFace.TextureID = terrainTextureHandle.GetUUID();
}
else
{
// Use the default texture code for terrain
terrainTextureHandle = new EntityHandleUUID(defaultTextureID);
BHash terrainHash = new BHashULong(defaultTextureID.GetHashCode());
assetFetcher.GetImageInfo(terrainHash, () => {
ImageInfo terrainImageInfo = new ImageInfo();
terrainImageInfo.handle = terrainTextureHandle;
assetFetcher.FetchTextureAsImage(terrainTextureHandle)
.Then(img => {
terrainImageInfo.image = img;
});
return(terrainImageInfo);
});
}
// The above has created a MaterialInfo for the terrain texture
ConvOAR.Globals.log.DebugFormat("{0}: CreateTerrainMesh. calling MeshFromHeightMap", LogHeader);
DisplayableRenderable terrainDisplayable = assetMesher.MeshFromHeightMap(heightMap,
terrainDef.Width, terrainDef.Height, assetFetcher, terrainFace);
BInstance terrainInstance = new BInstance();
Displayable terrainDisp = new Displayable(terrainDisplayable);
terrainDisp.name = "Terrain";
terrainDisp.baseUUID = OMV.UUID.Random();
terrainInstance.Representation = terrainDisp;
return(terrainInstance);
}
public Displayable(DisplayableRenderable pRenderable) : this()
{
renderable = pRenderable;
}
// Add another level of parenting
public InvertedMesh AddDisplayableLevel(InvertedMesh imesh, Displayable pDisp, DisplayableRenderable pDispRend)
{
InvertedMesh newIMesh = new InvertedMesh(imesh.containingScene, imesh.containingInstance,
imesh.containingDisplayable, imesh.containingDisplayableRenderable, imesh.renderableMesh);
globalPosition += pDisp.offsetPosition;
globalRotation *= pDisp.offsetRotation;
newIMesh.containingDisplayable = pDisp;
newIMesh.containingDisplayableRenderable = pDispRend;
return(newIMesh);
}
