/// <summary>
/// Create and return a set of meshes/materials that make the passed SOP.
/// This just deals the making a mesh from the SOP and getting the material/texture of the meshes
/// into the caches.
/// </summary>
// Returns 'null' if the SOG/SOP could not be converted into a displayable
public IPromise <Displayable> CreateMeshResource(SceneObjectGroup sog, SceneObjectPart sop,
OMV.Primitive prim, IAssetFetcher assetFetcher, OMVR.DetailLevel lod)
{
var prom = new Promise <Displayable>();
try {
if (prim.Sculpt != null)
{
if (prim.Sculpt.Type == OMV.SculptType.Mesh)
{
BConverterOS.LogBProgress("{0}: CreateMeshResource: creating mesh", _logHeader);
ConvOAR.Globals.stats.numMeshAssets++;
MeshFromPrimMeshData(sog, sop, prim, assetFetcher, lod)
.Then(dispable => {
prom.Resolve(new Displayable(dispable, sop));
}, e => {
// prom.Reject(e);
prom.Resolve(null);
});
}
else
{
BConverterOS.LogBProgress("{0}: CreateMeshResource: creating sculpty", _logHeader);
ConvOAR.Globals.stats.numSculpties++;
MeshFromPrimSculptData(sog, sop, prim, assetFetcher, lod)
.Then(dispable => {
prom.Resolve(new Displayable(dispable, sop));
}, e => {
// prom.Reject(e);
prom.Resolve(null);
});
}
}
else
{
BConverterOS.LogBProgress("{0}: CreateMeshResource: creating primshape", _logHeader);
ConvOAR.Globals.stats.numSimplePrims++;
MeshFromPrimShapeData(sog, sop, prim, assetFetcher, lod)
.Then(dispable => {
BConverterOS.LogBProgress("{0} CreateMeshResource: prim created", _logHeader);
prom.Resolve(new Displayable(dispable, sop));
}, e => {
// prom.Reject(e);
prom.Resolve(null);
});
}
}
catch (Exception e) {
prom.Reject(e);
}
return(prom);
}
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 OarConverter(BLogger pLog, ConvoarParams pParams)
{
_log = pLog;
_params = pParams;
_converter = new BConverterOS(_log, new BConverterOSParams()
{
addTerrainMesh = _params.AddTerrainMesh,
displayTimeScaling = _params.DisplayTimeScaling,
doubleSided = _params.DoubleSided,
logBuilding = _params.LogBuilding,
convoarId = _params.ConvoarID
});
}
public bool LoadOAR(IAssetService assetService, IAssetFetcher assetFetcher, BSceneLoadedCallback loadedCallback)
{
bool ret = false;
BConverterOS converter = new BConverterOS();
converter.ConvertOarToScene(assetService, assetFetcher)
.Catch(e => {
ConvOAR.Globals.log.ErrorFormat("{0} LoadOAR exception: {1}", _logHeader, e);
throw (e);
})
.Then(bScene => {
loadedCallback(bScene);
});
return(ret);
}
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);
});
}));
}
public OarConverter(BLogger pLog, IParameters pParams)
{
_log = pLog;
_params = pParams;
_converter = new BConverterOS(pLog, pParams);
}
private RenderableMesh ConvertFaceToRenderableMesh(OMVR.Face face, IAssetFetcher assetFetcher,
OMV.Primitive.TextureEntryFace defaultTexture, OMV.Vector3 primScale)
{
RenderableMesh rmesh = new RenderableMesh();
rmesh.num = face.ID;
// Copy one face's mesh imformation from the FacetedMesh into a MeshInfo
MeshInfo meshInfo = new MeshInfo {
vertexs = new List <OMVR.Vertex>(face.Vertices),
indices = face.Indices.ConvertAll(ii => (int)ii),
faceCenter = face.Center,
scale = primScale
};
BConverterOS.LogBProgress("{0} ConvertFaceToRenderableMesh: faceId={1}, numVert={2}, numInd={3}",
_logHeader, face.ID, meshInfo.vertexs.Count, meshInfo.indices.Count);
if (!ConvOAR.Globals.parms.P <bool>("DisplayTimeScaling"))
{
if (ScaleMeshes(meshInfo, primScale))
{
BConverterOS.LogBProgress("{0} ConvertFaceToRenderableMesh: scaled mesh to {1}",
_logHeader, primScale);
}
meshInfo.scale = OMV.Vector3.One;
}
// Find or create the MaterialInfo for this face.
MaterialInfo matInfo = new MaterialInfo(face, defaultTexture);
if (matInfo.textureID != null &&
matInfo.textureID != OMV.UUID.Zero &&
matInfo.textureID != OMV.Primitive.TextureEntry.WHITE_TEXTURE)
{
// Textures/images use the UUID from OpenSim and the hash is just the hash of the UUID
EntityHandleUUID textureHandle = new EntityHandleUUID((OMV.UUID)matInfo.textureID);
BHash textureHash = new BHashULong(textureHandle.GetUUID().GetHashCode());
ImageInfo lookupImageInfo = assetFetcher.GetImageInfo(textureHash, () => {
// The image is not in the cache yet so create an ImageInfo entry for it
// Note that image gets the same UUID as the OpenSim texture
ImageInfo imageInfo = new ImageInfo(textureHandle);
assetFetcher.FetchTextureAsImage(textureHandle)
.Then(img => {
imageInfo.SetImage(img);
})
.Catch(e => {
// Failure getting the image
ConvOAR.Globals.log.ErrorFormat("{0} Failure fetching texture. id={1}. {2}",
_logHeader, matInfo.textureID, e);
// Create a simple, single color image to fill in for the missing image
var fillInImage = new Bitmap(32, 32, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Color theColor = Color.FromArgb(128, 202, 213, 170); // 0x80CAB5AA
for (int xx = 0; xx < 32; xx++)
{
for (int yy = 0; yy < 32; yy++)
{
fillInImage.SetPixel(xx, yy, theColor);
}
}
imageInfo.SetImage(fillInImage);
});
imageInfo.imageIdentifier = (OMV.UUID)matInfo.textureID;
BConverterOS.LogBProgress("{0} ConvertFaceToRenderableMesh: create ImageInfo. hash={1}, id={2}",
_logHeader, textureHash, imageInfo.handle);
return(imageInfo);
});
matInfo.image = lookupImageInfo;
// Update the UV information for the texture mapping
BConverterOS.LogBProgress("{0} ConvertFaceToRenderableMesh: Converting tex coords using {1} texture",
_logHeader, face.TextureFace == null ? "default" : "face");
_mesher.TransformTexCoords(meshInfo.vertexs, meshInfo.faceCenter,
face.TextureFace == null ? defaultTexture : face.TextureFace, primScale);
}
// See that the material is in the cache
MaterialInfo lookupMatInfo = assetFetcher.GetMaterialInfo(matInfo.GetBHash(), () => { return(matInfo); });
rmesh.material = lookupMatInfo;
// See that the mesh is in the cache
MeshInfo lookupMeshInfo = assetFetcher.GetMeshInfo(meshInfo.GetBHash(true), () => { return(meshInfo); });
rmesh.mesh = lookupMeshInfo;
if (lookupMeshInfo.indices.Count == 0) // DEBUG DEBUG
{
ConvOAR.Globals.log.ErrorFormat("{0} indices count of zero. rmesh={1}", _logHeader, rmesh.ToString());
} // DEBUG DEBUG
BConverterOS.LogBProgress("{0} ConvertFaceToRenderableMesh: rmesh.mesh={1}, rmesh.material={2}",
_logHeader, rmesh.mesh, rmesh.material);
return(rmesh);
}
