public string GetOrCreateMaterial(WarpRenderer renderer, Color4 faceColor, UUID textureID, bool useAverageTextureColor, SceneObjectPart sop)
{
int color = ConvertColor(faceColor);
string idstr = textureID.ToString() + color.ToString();
string materialName = "MAPMAT" + idstr;
if (renderer.Scene.material(materialName) != null)
{
return(materialName);
}
warp_Material mat = new warp_Material();
warp_Texture texture = GetTexture(textureID, sop);
if (texture != null)
{
if (useAverageTextureColor)
{
color = warp_Color.multiply(color, texture.averageColor);
}
else
{
mat.setTexture(texture);
}
}
else
{
color = warp_Color.multiply(color, warp_Color.Grey);
}
mat.setColor(color);
renderer.Scene.addMaterial(materialName, mat);
return(materialName);
}
private Bitmap GenImage()
{
m_colors.Clear();
m_warpTextures.Clear();
WarpRenderer renderer = new WarpRenderer();
if (!renderer.CreateScene(viewWitdh, viewHeight))
{
return(new Bitmap(viewWitdh, viewHeight));
}
#region Camera
warp_Vector pos = ConvertVector(cameraPos);
warp_Vector lookat = warp_Vector.add(pos, ConvertVector(cameraDir));
if (orto)
{
renderer.Scene.defaultCamera.setOrthographic(true, viewWitdh, viewHeight);
}
else
{
renderer.Scene.defaultCamera.setFov(fov);
}
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
#endregion Camera
renderer.Scene.setAmbient(warp_Color.getColor(192, 191, 173));
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(0f, 1f, 8f), warp_Color.White, 0, 200, 20));
CreateWater(renderer);
CreateTerrain(renderer);
if (m_drawPrimVolume)
{
CreateAllPrims(renderer);
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
renderer.Scene.destroy();
renderer.Reset();
renderer = null;
m_colors.Clear();
m_warpTextures.Clear();
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.Default;
return(bitmap);
}
private string GetOrCreateMaterial(WarpRenderer renderer, Color4 color)
{
string name = color.ToString();
warp_Material material = renderer.Scene.material(name);
if (material != null)
{
return(name);
}
renderer.AddMaterial(name, ConvertColor(color));
return(name);
}
// Add a water plane to the renderer.
private void CreateWater(WarpRenderer renderer)
{
float waterHeight = (float)m_scene.RegionInfo.RegionSettings.WaterHeight;
renderer.AddPlane("Water", m_scene.RegionInfo.RegionSizeX * 0.5f, false);
renderer.Scene.sceneobject("Water").setPos(m_scene.RegionInfo.RegionSizeX * 0.5f,
waterHeight,
m_scene.RegionInfo.RegionSizeY * 0.5f);
warp_Material waterMaterial = new warp_Material(ConvertColor(WATER_COLOR));
renderer.Scene.addMaterial("WaterMat", waterMaterial);
renderer.SetObjectMaterial("Water", "WaterMat");
}
private void CreateAllPrims(WarpRenderer renderer)
{
if (m_primMesher == null)
{
return;
}
m_scene.ForEachSOG(
delegate(SceneObjectGroup group)
{
foreach (SceneObjectPart child in group.Parts)
{
CreatePrim(renderer, child);
}
}
);
}
private void CreatePrim(WarpRenderer renderer, SceneObjectPart prim)
{
if ((PCode)prim.Shape.PCode != PCode.Prim)
{
return;
}
Vector3 ppos = prim.GetWorldPosition();
if (ppos.Z < m_renderMinHeight || ppos.Z > m_renderMaxHeight)
{
return;
}
warp_Vector primPos = ConvertVector(ppos);
warp_Quaternion primRot = ConvertQuaternion(prim.GetWorldRotation());
warp_Matrix m = warp_Matrix.quaternionMatrix(primRot);
float screenFactor = renderer.Scene.EstimateBoxProjectedArea(primPos, ConvertVector(prim.Scale), m);
if (screenFactor < 0)
{
return;
}
const float log2inv = -1.442695f;
int p2 = (int)((float)Math.Log(screenFactor) * log2inv * 0.25 - 1);
if (p2 < 0)
{
p2 = 0;
}
else if (p2 > 3)
{
p2 = 3;
}
DetailLevel lod = (DetailLevel)(3 - p2);
FacetedMesh renderMesh = null;
Primitive omvPrim = prim.Shape.ToOmvPrimitive(prim.OffsetPosition, prim.RotationOffset);
if (m_renderMeshes)
{
if (omvPrim.Sculpt != null && omvPrim.Sculpt.SculptTexture != UUID.Zero)
{
// Try fetchinng the asset
AssetBase sculptAsset = m_scene.AssetService.Get(omvPrim.Sculpt.SculptTexture.ToString());
if (sculptAsset != null)
{
// Is it a mesh?
if (omvPrim.Sculpt.Type == SculptType.Mesh)
{
AssetMesh meshAsset = new AssetMesh(omvPrim.Sculpt.SculptTexture, sculptAsset.Data);
FacetedMesh.TryDecodeFromAsset(omvPrim, meshAsset, lod, out renderMesh);
meshAsset = null;
}
else // It's sculptie
{
if (m_imgDecoder != null)
{
Image sculpt = m_imgDecoder.DecodeToImage(sculptAsset.Data);
if (sculpt != null)
{
renderMesh = m_primMesher.GenerateFacetedSculptMesh(omvPrim, (Bitmap)sculpt, lod);
sculpt.Dispose();
}
}
}
}
else
{
m_log.WarnFormat("[Warp3D] failed to get mesh or sculpt asset {0} of prim {1} at {2}",
omvPrim.Sculpt.SculptTexture.ToString(), prim.Name, prim.GetWorldPosition().ToString());
}
}
}
// If not a mesh or sculptie, try the regular mesher
if (renderMesh == null)
{
renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, lod);
}
if (renderMesh == null)
{
return;
}
string primID = prim.UUID.ToString();
// Create the prim faces
// TODO: Implement the useTextures flag behavior
for (int i = 0; i < renderMesh.Faces.Count; i++)
{
Face face = renderMesh.Faces[i];
string meshName = primID + i.ToString();
// Avoid adding duplicate meshes to the scene
if (renderer.Scene.objectData.ContainsKey(meshName))
{
continue;
}
warp_Object faceObj = new warp_Object();
Primitive.TextureEntryFace teFace = prim.Shape.Textures.GetFace((uint)i);
Color4 faceColor = teFace.RGBA;
if (faceColor.A == 0)
{
continue;
}
string materialName = string.Empty;
if (m_texturePrims)
{
// if(lod > DetailLevel.Low)
{
// materialName = GetOrCreateMaterial(renderer, faceColor, teFace.TextureID, lod == DetailLevel.Low);
materialName = GetOrCreateMaterial(renderer, faceColor, teFace.TextureID, false, prim);
if (String.IsNullOrEmpty(materialName))
{
continue;
}
int c = renderer.Scene.material(materialName).getColor();
if ((c & warp_Color.MASKALPHA) == 0)
{
continue;
}
}
}
else
{
materialName = GetOrCreateMaterial(renderer, faceColor);
}
if (renderer.Scene.material(materialName).getTexture() == null)
{
// uv map details dont not matter for color;
for (int j = 0; j < face.Vertices.Count; j++)
{
Vertex v = face.Vertices[j];
warp_Vector pos = ConvertVector(v.Position);
warp_Vertex vert = new warp_Vertex(pos, v.TexCoord.X, v.TexCoord.Y);
faceObj.addVertex(vert);
}
}
else
{
float tu;
float tv;
float offsetu = teFace.OffsetU + 0.5f;
float offsetv = teFace.OffsetV + 0.5f;
float scaleu = teFace.RepeatU;
float scalev = teFace.RepeatV;
float rotation = teFace.Rotation;
float rc = 0;
float rs = 0;
if (rotation != 0)
{
rc = (float)Math.Cos(rotation);
rs = (float)Math.Sin(rotation);
}
for (int j = 0; j < face.Vertices.Count; j++)
{
warp_Vertex vert;
Vertex v = face.Vertices[j];
warp_Vector pos = ConvertVector(v.Position);
if (teFace.TexMapType == MappingType.Planar)
{
UVPlanarMap(v, prim.Scale, out tu, out tv);
}
else
{
tu = v.TexCoord.X - 0.5f;
tv = 0.5f - v.TexCoord.Y;
}
if (rotation != 0)
{
float tur = tu * rc - tv * rs;
float tvr = tu * rs + tv * rc;
tur *= scaleu;
tur += offsetu;
tvr *= scalev;
tvr += offsetv;
vert = new warp_Vertex(pos, tur, tvr);
}
else
{
tu *= scaleu;
tu += offsetu;
tv *= scalev;
tv += offsetv;
vert = new warp_Vertex(pos, tu, tv);
}
faceObj.addVertex(vert);
}
}
for (int j = 0; j < face.Indices.Count; j += 3)
{
faceObj.addTriangle(
face.Indices[j + 0],
face.Indices[j + 1],
face.Indices[j + 2]);
}
faceObj.scaleSelf(prim.Scale.X, prim.Scale.Z, prim.Scale.Y);
faceObj.transform(m);
faceObj.setPos(primPos);
renderer.Scene.addObject(meshName, faceObj);
renderer.SetObjectMaterial(meshName, materialName);
}
}
// Add a terrain to the renderer.
// Note that we create a 'low resolution' 257x257 vertex terrain rather than trying for
// full resolution. This saves a lot of memory especially for very large regions.
private void CreateTerrain(WarpRenderer renderer)
{
ITerrainChannel terrain = m_scene.Heightmap;
float regionsx = m_scene.RegionInfo.RegionSizeX;
float regionsy = m_scene.RegionInfo.RegionSizeY;
// 'diff' is the difference in scale between the real region size and the size of terrain we're buiding
int bitWidth;
int bitHeight;
const double log2inv = 1.4426950408889634073599246810019;
bitWidth = (int)Math.Ceiling((Math.Log(terrain.Width) * log2inv));
bitHeight = (int)Math.Ceiling((Math.Log(terrain.Height) * log2inv));
if (bitWidth > 8) // more than 256 is very heavy :(
{
bitWidth = 8;
}
if (bitHeight > 8)
{
bitHeight = 8;
}
int twidth = (int)Math.Pow(2, bitWidth);
int theight = (int)Math.Pow(2, bitHeight);
float diff = regionsx / twidth;
int npointsx = (int)(regionsx / diff);
int npointsy = (int)(regionsy / diff);
float invsx = 1.0f / (npointsx * diff);
float invsy = 1.0f / (npointsy * diff);
npointsx++;
npointsy++;
// Create all the vertices for the terrain
warp_Object obj = new warp_Object();
warp_Vector pos;
float x, y;
float tv;
for (y = 0; y < regionsy; y += diff)
{
tv = y * invsy;
for (x = 0; x < regionsx; x += diff)
{
pos = ConvertVector(x, y, (float)terrain[(int)x, (int)y]);
obj.addVertex(new warp_Vertex(pos, x * invsx, tv));
}
pos = ConvertVector(x, y, (float)terrain[(int)(x - diff), (int)y]);
obj.addVertex(new warp_Vertex(pos, 1.0f, tv));
}
int lastY = (int)(y - diff);
for (x = 0; x < regionsx; x += diff)
{
pos = ConvertVector(x, y, (float)terrain[(int)x, lastY]);
obj.addVertex(new warp_Vertex(pos, x * invsx, 1.0f));
}
pos = ConvertVector(x, y, (float)terrain[(int)(x - diff), lastY]);
obj.addVertex(new warp_Vertex(pos, 1.0f, 1.0f));
// create triangles.
int limx = npointsx - 1;
int limy = npointsy - 1;
for (int j = 0; j < limy; j++)
{
for (int i = 0; i < limx; i++)
{
int v = j * npointsx + i;
// Make two triangles for each of the squares in the grid of vertices
obj.addTriangle(
v,
v + 1,
v + npointsx);
obj.addTriangle(
v + npointsx + 1,
v + npointsx,
v + 1);
}
}
renderer.Scene.addObject("Terrain", obj);
UUID[] textureIDs = new UUID[4];
float[] startHeights = new float[4];
float[] heightRanges = new float[4];
OpenSim.Framework.RegionSettings regionInfo = m_scene.RegionInfo.RegionSettings;
textureIDs[0] = regionInfo.TerrainTexture1;
textureIDs[1] = regionInfo.TerrainTexture2;
textureIDs[2] = regionInfo.TerrainTexture3;
textureIDs[3] = regionInfo.TerrainTexture4;
startHeights[0] = (float)regionInfo.Elevation1SW;
startHeights[1] = (float)regionInfo.Elevation1NW;
startHeights[2] = (float)regionInfo.Elevation1SE;
startHeights[3] = (float)regionInfo.Elevation1NE;
heightRanges[0] = (float)regionInfo.Elevation2SW;
heightRanges[1] = (float)regionInfo.Elevation2NW;
heightRanges[2] = (float)regionInfo.Elevation2SE;
heightRanges[3] = (float)regionInfo.Elevation2NE;
warp_Texture texture;
using (Bitmap image = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges,
m_scene.RegionInfo.WorldLocX, m_scene.RegionInfo.WorldLocY,
m_scene.AssetService, m_imgDecoder, m_textureTerrain, m_textureAverageTerrain,
twidth, twidth))
texture = new warp_Texture(image);
warp_Material material = new warp_Material(texture);
renderer.Scene.addMaterial("TerrainMat", material);
renderer.SetObjectMaterial("Terrain", "TerrainMat");
}
