public warp_Vertex (warp_Vector ppos, warp_Vector norm, float u, float v)
{
pos = ppos;
n = norm;
this.u = u;
this.v = v;
}
public void clipFrustrum(int w, int h)
{
if (parent.material == null)
{
visible = false;
return;
}
outOfFrustrum = (p1.clipcode & p2.clipcode & p3.clipcode) != 0;
if (outOfFrustrum)
{
visible = false;
return;
}
if (n2.z > 0.5)
{
visible = true;
return;
}
warp_Vector triangleCenter = new warp_Vector(
(p1.pos2.x + p2.pos2.x + p3.pos2.x),
(p1.pos2.y + p2.pos2.y + p3.pos2.y),
(p1.pos2.z + p2.pos2.z + p3.pos2.z));
visible = warp_Vector.angle(triangleCenter, n2) > 0;
}
public void project (warp_Matrix vertexProjection, warp_Matrix normalProjection, warp_Camera camera)
// Projects this vertex into camera space
{
pos2 = pos.transform (vertexProjection);
n2 = n.transform (normalProjection);
float fact;
if (camera.isOrthographic)
{
x = (int)(pos2.x * (camera.screenscale / camera.orthoViewWidth) + (camera.screenwidth >> 1));
y = (int)(-pos2.y * (camera.screenscale / camera.orthoViewHeight) + (camera.screenheight >> 1));
} else
{
fact = camera.screenscale / camera.fovfact / ((pos2.z > 0.1) ? pos2.z : 0.1f);
x = (int)(pos2.x * fact + (camera.screenwidth >> 1));
y = (int)(-pos2.y * fact + (camera.screenheight >> 1));
}
z = (int)(65536f * pos2.z);
sw = -(pos2.z);
nx = (int)(n2.x * 127 + 127);
ny = (int)(n2.y * 127 + 127);
if (parent.material == null)
return;
if (parent.material.texture == null)
return;
tx = (int)((float)parent.material.texture.width * u);
ty = (int)((float)parent.material.texture.height * v);
}
public void clipFrustrum (int w, int h)
{
if (parent.material == null)
{
visible = false;
return;
}
outOfFrustrum = (p1.clipcode & p2.clipcode & p3.clipcode) != 0;
if (outOfFrustrum)
{
visible = false;
return;
}
if (n2.z > 0.5)
{
visible = true;
return;
}
warp_Vector triangleCenter = new warp_Vector (
(p1.pos2.x + p2.pos2.x + p3.pos2.x),
(p1.pos2.y + p2.pos2.y + p3.pos2.y),
(p1.pos2.z + p2.pos2.z + p3.pos2.z));
visible = warp_Vector.angle (triangleCenter, n2) > 0;
}
public Bitmap CreateMapTile(Viewport viewport, bool useTextures)
{
m_colors.Clear();
int width = viewport.Width;
int height = viewport.Height;
WarpRenderer renderer = new WarpRenderer();
if (!renderer.CreateScene(width, height))
{
return(new Bitmap(width, height));
}
#region Camera
warp_Vector pos = ConvertVector(viewport.Position);
warp_Vector lookat = warp_Vector.add(ConvertVector(viewport.Position), ConvertVector(viewport.LookDirection));
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
if (viewport.Orthographic)
{
renderer.Scene.defaultCamera.setOrthographic(true, viewport.OrthoWindowWidth, viewport.OrthoWindowHeight);
}
else
{
float fov = viewport.FieldOfView;
fov *= 1.75f; // FIXME: ???
renderer.Scene.defaultCamera.setFov(fov);
}
#endregion Camera
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(1.0f, 0.5f, 1f), 0xffffff, 0, 320, 40));
renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 0, 100, 40));
CreateWater(renderer);
CreateTerrain(renderer, m_textureTerrain);
if (m_drawPrimVolume)
{
CreateAllPrims(renderer, useTextures);
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
renderer.Scene.destroy();
renderer.Reset();
renderer = null;
viewport = null;
m_colors.Clear();
GC.Collect();
m_log.Debug("[WARP 3D IMAGE MODULE]: GC.Collect()");
return(bitmap);
}
public warp_Light(warp_Vector direction, int color, int highlightSheen, int highlightSpread)
{
v = direction;
v.normalize();
diffuse = color;
specular = color;
this.highlightSheen = highlightSheen;
this.highlightSpread = highlightSpread;
}
public warp_Light(warp_Vector direction, int diffuse, int specular, int highlightSheen, int highlightSpread)
{
v = direction;
v.normalize();
this.diffuse = diffuse;
this.specular = specular;
this.highlightSheen = highlightSheen;
this.highlightSpread = highlightSpread;
}
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);
}
public warp_Light(warp_Vector direction, int diffuse, int specular,int highlightSheen, int highlightSpread)
{
v = direction;
v.normalize();
this.diffuse = diffuse;
this.specular = specular;
this.highlightSheen = highlightSheen;
this.highlightSpread = highlightSpread;
}
public warp_Matrix (warp_Vector right, warp_Vector up, warp_Vector forward)
{
m00 = right.x;
m10 = right.y;
m20 = right.z;
m01 = up.x;
m11 = up.y;
m21 = up.z;
m02 = forward.x;
m12 = forward.y;
m22 = forward.z;
}
public warp_Matrix(warp_Vector right, warp_Vector up, warp_Vector forward)
{
m00 = right.x;
m10 = right.y;
m20 = right.z;
m01 = up.x;
m11 = up.y;
m21 = up.z;
m02 = forward.x;
m12 = forward.y;
m22 = forward.z;
}
public static void projectTop(warp_Object obj)
{
obj.rebuild();
warp_Vector min = obj.minimum();
warp_Vector max = obj.maximum();
float du = 1 / (max.x - min.x);
float dv = 1 / (max.z - min.z);
for (int i = 0; i < obj.vertices; i++)
{
obj.fastvertex [i].u = (obj.fastvertex [i].pos.x - min.x) * du;
obj.fastvertex [i].v = (obj.fastvertex [i].pos.z - min.z) * dv;
}
}
public static void projectCylindric(warp_Object obj)
{
obj.rebuild();
warp_Vector min = obj.minimum();
warp_Vector max = obj.maximum();
float dz = 1 / (max.z - min.z);
for (int i = 0; i < obj.vertices; i++)
{
obj.fastvertex[i].pos.buildCylindric();
obj.fastvertex[i].u = obj.fastvertex[i].pos.theta / (2 * 3.14159265f);
obj.fastvertex[i].v = (obj.fastvertex[i].pos.z - min.z) * dz;
}
}
void rebuildMatrices ()
{
if (!needsRebuild)
return;
needsRebuild = false;
warp_Vector forward, up, right;
forward = warp_Vector.sub (lookat, pos);
up = new warp_Vector (0f, 1f, 0f);
right = warp_Vector.getNormal (up, forward);
up = warp_Vector.getNormal (forward, right);
forward.normalize ();
up.normalize ();
right.normalize ();
normalmatrix = new warp_Matrix (right, up, forward);
normalmatrix.rotate (0, 0, rollfactor);
matrix = normalmatrix.getClone ();
matrix.shift (pos.x, pos.y, pos.z);
normalmatrix = normalmatrix.inverse ();
matrix = matrix.inverse ();
}
public void regenerateNormal()
{
n = warp_Vector.getNormal(p1.pos, p2.pos, p3.pos);
}
// Add a terrain to the renderer.
// Note that we create a 'low resolution' 256x256 vertex terrain rather than trying for
// full resolution. This saves a lot of memory especially for very large regions.
private void CreateTerrain(WarpRenderer renderer, bool textureTerrain)
{
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
float diff = regionsx / 256f;
int npointsx = (int)(regionsx / diff);
int npointsy = (int)(regionsy / diff);
float invsx = 1.0f / regionsx;
float invsy = 1.0f / (float)m_scene.RegionInfo.RegionSizeY;
// Create all the vertices for the terrain
warp_Object obj = new warp_Object();
for (float y = 0; y < regionsy; y += diff)
{
for (float x = 0; x < regionsx; x += diff)
{
warp_Vector pos = ConvertVector(x, y, (float)terrain[(int)x, (int)y]);
obj.addVertex(new warp_Vertex(pos, x * invsx, 1.0f - y * invsy));
}
}
// Now that we have all the vertices, make another pass and
// create the list of triangle indices.
float invdiff = 1.0f / diff;
int limx = npointsx - 1;
int limy = npointsy - 1;
for (float y = 0; y < regionsy; y += diff)
{
for (float x = 0; x < regionsx; x += diff)
{
float newX = x * invdiff;
float newY = y * invdiff;
if (newX < limx && newY < limy)
{
int v = (int)newY * npointsx + (int)newX;
// 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;
uint globalX, globalY;
Util.RegionHandleToWorldLoc(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
warp_Texture texture;
using (Bitmap image = TerrainSplat.Splat(
terrain, textureIDs, startHeights, heightRanges,
new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain))
texture = new warp_Texture(image);
warp_Material material = new warp_Material(texture);
material.setReflectivity(50);
renderer.Scene.addMaterial("TerrainColor", material);
renderer.Scene.material("TerrainColor").setReflectivity(0); // reduces tile seams a bit thanks lkalif
renderer.SetObjectMaterial("Terrain", "TerrainColor");
}
public static warp_Object TORUSKNOT (float p, float q, float r_tube, float r_out, float r_in, float h, int segments, int steps)
{
float x, y, z, r, t, theta;
warp_Vector[] path = new warp_Vector[segments + 1];
for (int i = 0; i < segments + 1; i++)
{
t = 2 * 3.14159265f * i / (float)segments;
r = r_out + r_in * warp_Math.cos (p * t);
z = h * warp_Math.sin (p * t);
theta = q * t;
x = r * warp_Math.cos (theta);
y = r * warp_Math.sin (theta);
path [i] = new warp_Vector (x, y, z);
}
return TUBE (path, r_tube, steps, true);
}
public void project(warp_Matrix m)
{
matrix2 = m.getClone();
matrix2.transform(m);
v2 = v.transform(matrix2);
}
public Bitmap CreateMapTile(Viewport viewport, bool useTextures)
{
bool drawPrimVolume = true;
bool textureTerrain = true;
try
{
IConfig startupConfig = m_config.Configs["Startup"];
drawPrimVolume = startupConfig.GetBoolean("DrawPrimOnMapTile", drawPrimVolume);
textureTerrain = startupConfig.GetBoolean("TextureOnMapTile", textureTerrain);
}
catch
{
m_log.Warn("[MAPTILE]: Failed to load StartupConfig");
}
m_colors.Clear();
int width = viewport.Width;
int height = viewport.Height;
if (m_useAntiAliasing)
{
width *= 2;
height *= 2;
}
WarpRenderer renderer = new WarpRenderer();
renderer.CreateScene(width, height);
renderer.Scene.autoCalcNormals = false;
#region Camera
warp_Vector pos = ConvertVector(viewport.Position);
pos.z -= 0.001f; // Works around an issue with the Warp3D camera
warp_Vector lookat = warp_Vector.add(ConvertVector(viewport.Position), ConvertVector(viewport.LookDirection));
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
if (viewport.Orthographic)
{
renderer.Scene.defaultCamera.isOrthographic = true;
renderer.Scene.defaultCamera.orthoViewWidth = viewport.OrthoWindowWidth;
renderer.Scene.defaultCamera.orthoViewHeight = viewport.OrthoWindowHeight;
}
else
{
float fov = viewport.FieldOfView;
fov *= 1.75f; // FIXME: ???
renderer.Scene.defaultCamera.setFov(fov);
}
#endregion Camera
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(0.2f, 0.2f, 1f), 0xffffff, 320, 80));
renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 100, 40));
CreateWater(renderer);
CreateTerrain(renderer, textureTerrain);
if (drawPrimVolume)
{
CreateAllPrims(renderer, useTextures);
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
if (m_useAntiAliasing)
{
bitmap = ImageUtils.ResizeImage(bitmap, viewport.Width, viewport.Height);
}
return(bitmap);
}
public void setPos (warp_Vector p)
{
pos = p;
needsRebuild = true;
}
public static warp_Object BOX (warp_Vector size)
{
return BOX (size.x, size.y, size.z);
}
public void rotate (warp_Vector v)
{
rotate (v.x, v.y, v.z);
}
public static warp_Object SPHERE (float radius, int segments)
{
warp_Vector[] path = new warp_Vector[segments];
float x, y, angle;
path [0] = new warp_Vector (0, radius, 0);
path [segments - 1] = new warp_Vector (0, -radius, 0);
for (int i = 1; i < segments - 1; i++)
{
angle = -(((float)i / (float)(segments - 2)) - 0.5f) *
3.14159265f;
x = (float)Math.Cos (angle) * radius;
y = (float)Math.Sin (angle) * radius;
path [i] = new warp_Vector (x, y, 0);
}
return ROTATIONOBJECT (path, segments);
}
public void shift (warp_Vector v)
{
shift (v.x, v.y, v.z);
}
public void rotate (float dx, float dy, float dz)
{
pos = pos.transform (warp_Matrix.rotateMatrix (dx, dy, dz));
needsRebuild = true;
}
public void shift (float dx, float dy, float dz)
{
pos = pos.transform (warp_Matrix.shiftMatrix (dx, dy, dz));
lookat = lookat.transform (warp_Matrix.shiftMatrix (dx, dy, dz));
needsRebuild = true;
}
public void lookAt (warp_Vector p)
{
lookat = p;
needsRebuild = true;
}
public void lookAt (float px, float py, float pz)
{
lookat = new warp_Vector (px, py, pz);
needsRebuild = true;
}
public warp_Light(warp_Vector direction, int diffuse)
{
v = direction;
v.normalize();
this.diffuse = diffuse;
}
public warp_Light(warp_Vector direction, int diffuse)
{
v = direction;
v.normalize();
this.diffuse = diffuse;
}
public void project(warp_Matrix m)
{
matrix2 = m.getClone();
matrix2.transform(m);
v2 = v.transform(matrix2);
}
public void setPos (float px, float py, float pz)
{
pos = new warp_Vector (px, py, pz);
needsRebuild = true;
}
public Bitmap CreateMapTile(Viewport viewport, bool useTextures)
{
bool drawPrimVolume = true;
bool textureTerrain = true;
try
{
IConfig startupConfig = m_config.Configs["Startup"];
drawPrimVolume = startupConfig.GetBoolean("DrawPrimOnMapTile", drawPrimVolume);
textureTerrain = startupConfig.GetBoolean("TextureOnMapTile", textureTerrain);
}
catch
{
m_log.Warn("[WARP 3D IMAGE MODULE]: Failed to load StartupConfig");
}
m_colors.Clear();
int width = viewport.Width;
int height = viewport.Height;
if (m_useAntiAliasing)
{
width *= 2;
height *= 2;
}
WarpRenderer renderer = new WarpRenderer();
renderer.CreateScene(width, height);
renderer.Scene.autoCalcNormals = false;
#region Camera
warp_Vector pos = ConvertVector(viewport.Position);
pos.z -= 0.001f; // Works around an issue with the Warp3D camera
warp_Vector lookat = warp_Vector.add(ConvertVector(viewport.Position), ConvertVector(viewport.LookDirection));
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
if (viewport.Orthographic)
{
renderer.Scene.defaultCamera.isOrthographic = true;
renderer.Scene.defaultCamera.orthoViewWidth = viewport.OrthoWindowWidth;
renderer.Scene.defaultCamera.orthoViewHeight = viewport.OrthoWindowHeight;
}
else
{
float fov = viewport.FieldOfView;
fov *= 1.75f; // FIXME: ???
renderer.Scene.defaultCamera.setFov(fov);
}
#endregion Camera
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(1.0f, 0.5f, 1f), 0xffffff, 0, 320, 40));
renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 0, 100, 40));
CreateWater(renderer);
CreateTerrain(renderer, textureTerrain);
if (drawPrimVolume)
{
CreateAllPrims(renderer, useTextures);
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
if (m_useAntiAliasing)
{
using (Bitmap origBitmap = bitmap)
bitmap = ImageUtils.ResizeImage(origBitmap, viewport.Width, viewport.Height);
}
// XXX: It shouldn't really be necesary to force a GC here as one should occur anyway pretty shortly
// afterwards. It's generally regarded as a bad idea to manually GC. If Warp3D is using lots of memory
// then this may be some issue with the Warp3D code itself, though it's also quite possible that generating
// this map tile simply takes a lot of memory.
GC.Collect();
m_log.Debug("[WARP 3D IMAGE MODULE]: GC.Collect()");
return(bitmap);
}
// Add a terrain to the renderer.
// Note that we create a 'low resolution' 256x256 vertex terrain rather than trying for
// full resolution. This saves a lot of memory especially for very large regions.
private void CreateTerrain(WarpRenderer renderer, bool textureTerrain)
{
ITerrainChannel terrain = m_scene.Heightmap;
// 'diff' is the difference in scale between the real region size and the size of terrain we're buiding
float diff = (float)m_scene.RegionInfo.RegionSizeX / 256f;
warp_Object obj = new warp_Object(256 * 256, 255 * 255 * 2);
// Create all the vertices for the terrain
for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff)
{
for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff)
{
warp_Vector pos = ConvertVector(x, y, (float)terrain[(int)x, (int)y]);
obj.addVertex(new warp_Vertex(pos,
x / (float)m_scene.RegionInfo.RegionSizeX,
(((float)m_scene.RegionInfo.RegionSizeY) - y) / m_scene.RegionInfo.RegionSizeY));
}
}
// Now that we have all the vertices, make another pass and create
// the normals for each of the surface triangles and
// create the list of triangle indices.
for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff)
{
for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff)
{
float newX = x / diff;
float newY = y / diff;
if (newX < 255 && newY < 255)
{
int v = (int)newY * 256 + (int)newX;
// Normal for a triangle made up of three adjacent vertices
Vector3 v1 = new Vector3(newX, newY, (float)terrain[(int)x, (int)y]);
Vector3 v2 = new Vector3(newX + 1, newY, (float)terrain[(int)(x + 1), (int)y]);
Vector3 v3 = new Vector3(newX, newY + 1, (float)terrain[(int)x, ((int)(y + 1))]);
warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3));
norm = norm.reverse();
obj.vertex(v).n = norm;
// Make two triangles for each of the squares in the grid of vertices
obj.addTriangle(
v,
v + 1,
v + 256);
obj.addTriangle(
v + 256 + 1,
v + 256,
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;
uint globalX, globalY;
Util.RegionHandleToWorldLoc(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
warp_Texture texture;
using (
Bitmap image
= TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges,
new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain))
{
texture = new warp_Texture(image);
}
warp_Material material = new warp_Material(texture);
material.setReflectivity(50);
renderer.Scene.addMaterial("TerrainColor", material);
renderer.Scene.material("TerrainColor").setReflectivity(0); // reduces tile seams a bit thanks lkalif
renderer.SetObjectMaterial("Terrain", "TerrainColor");
}
public warp_Vertex (warp_Vector ppos, float u, float v)
{
pos = ppos;
this.u = u;
this.v = v;
}
public void shift(warp_Vector v)
{
matrix.shift(v.x, v.y, v.z);
}
public static warp_Object TUBE (warp_Vector[] path, float r, int steps, bool closed)
{
warp_Vector[] circle = new warp_Vector[steps];
float angle;
for (int i = 0; i < steps; i++)
{
angle = 2 * 3.14159265f * (float)i / (float)steps;
circle [i] = new warp_Vector (r * warp_Math.cos (angle),
r * warp_Math.sin (angle), 0f);
}
warp_Object newObject = new warp_Object ();
int segments = path.GetLength (0);
warp_Vector forward, up, right;
warp_Matrix frenetmatrix;
warp_Vertex tempvertex;
float relx, rely;
int a, b, c, d;
for (int i = 0; i < segments; i++)
{
// Calculate frenet frame matrix
if (i != segments - 1)
{
forward = warp_Vector.sub (path [i + 1], path [i]);
} else
{
if (!closed)
{
forward = warp_Vector.sub (path [i], path [i - 1]);
} else
{
forward = warp_Vector.sub (path [1], path [0]);
}
}
forward.normalize ();
up = new warp_Vector (0f, 0f, 1f);
right = warp_Vector.getNormal (forward, up);
up = warp_Vector.getNormal (forward, right);
frenetmatrix = new warp_Matrix (right, up, forward);
frenetmatrix.shift (path [i].x, path [i].y, path [i].z);
// Add nodes
relx = (float)i / (float)(segments - 1);
for (int k = 0; k < steps; k++)
{
rely = (float)k / (float)steps;
tempvertex = new warp_Vertex (circle [k].transform (frenetmatrix));
tempvertex.u = relx;
tempvertex.v = rely;
newObject.addVertex (tempvertex);
}
}
for (int i = 0; i < segments - 1; i++)
{
for (int k = 0; k < steps - 1; k++)
{
a = i * steps + k;
b = a + 1;
c = a + steps;
d = b + steps;
newObject.addTriangle (a, c, b);
newObject.addTriangle (b, c, d);
}
a = (i + 1) * steps - 1;
b = a + 1 - steps;
c = a + steps;
d = b + steps;
newObject.addTriangle (a, c, b);
newObject.addTriangle (b, c, d);
}
return newObject;
}
public Bitmap TerrainToBitmap(Bitmap mapbmp)
{
List <string> renderers = RenderingLoader.ListRenderers(Util.ExecutingDirectory());
if (renderers.Count > 0)
{
m_primMesher = RenderingLoader.LoadRenderer(renderers[0]);
MainConsole.Instance.Debug("[MAPTILE]: Loaded prim mesher " + m_primMesher);
}
else
{
MainConsole.Instance.Info("[MAPTILE]: No prim mesher loaded, prim rendering will be disabled");
}
bool drawPrimVolume = true;
bool textureTerrain = true;
try
{
IConfig startupConfig = m_config.Configs["Startup"];
drawPrimVolume = startupConfig.GetBoolean("DrawPrimOnMapTile", drawPrimVolume);
textureTerrain = startupConfig.GetBoolean("TextureOnMapTile", textureTerrain);
}
catch
{
MainConsole.Instance.Warn("[MAPTILE]: Failed to load StartupConfig");
}
m_texturePrims = m_config.Configs["MapModule"].GetBoolean("WarpTexturePrims", false);
int scaledRemovalFactor = m_scene.RegionInfo.RegionSizeX / (Constants.RegionSize / 2);
Vector3 camPos = new Vector3(m_scene.RegionInfo.RegionSizeX / 2 - 0.5f,
m_scene.RegionInfo.RegionSizeY / 2 - 0.5f, 221.7025033688163f);
Viewport viewport = new Viewport(camPos, -Vector3.UnitZ, 1024f, 0.1f,
m_scene.RegionInfo.RegionSizeX - scaledRemovalFactor,
m_scene.RegionInfo.RegionSizeY - scaledRemovalFactor,
m_scene.RegionInfo.RegionSizeX - scaledRemovalFactor,
m_scene.RegionInfo.RegionSizeY - scaledRemovalFactor);
int width = viewport.Width;
int height = viewport.Height;
WarpRenderer renderer = new WarpRenderer();
warp_Object terrainObj = null;
renderer.CreateScene(width, height);
renderer.Scene.autoCalcNormals = false;
#region Camera
warp_Vector pos = ConvertVector(viewport.Position);
pos.z -= 0.001f; // Works around an issue with the Warp3D camera
warp_Vector lookat = warp_Vector.add(ConvertVector(viewport.Position), ConvertVector(viewport.LookDirection));
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
if (viewport.Orthographic)
{
renderer.Scene.defaultCamera.isOrthographic = true;
renderer.Scene.defaultCamera.orthoViewWidth = viewport.OrthoWindowWidth;
renderer.Scene.defaultCamera.orthoViewHeight = viewport.OrthoWindowHeight;
}
else
{
viewport.Orthographic = false;
float fov = 256;
//fov *= 1.75f; // FIXME: ???
renderer.Scene.defaultCamera.setFov(fov);
}
#endregion Camera
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(1.0f, 0.5f, 1f), 0xffffff, 0, 320, 40));
renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 0, 100, 40));
try
{
CreateWater(renderer);
terrainObj = CreateTerrain(renderer, textureTerrain);
if (drawPrimVolume && m_primMesher != null)
{
foreach (ISceneChildEntity part in m_scene.Entities.GetEntities().SelectMany(ent => ent.ChildrenEntities()))
{
CreatePrim(renderer, part);
}
}
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[Warp3D]: Exception in the map generation, " + ex);
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
bitmap = ImageUtils.ResizeImage(bitmap, Constants.RegionSize, Constants.RegionSize);
foreach (var o in renderer.Scene.objectData.Values)
{
warp_Object obj = (warp_Object)o;
obj.vertexData = null;
obj.triangleData = null;
}
renderer.Scene.removeAllObjects();
renderer = null;
viewport = null;
m_primMesher = null;
terrainObj.fastvertex = null;
terrainObj.fasttriangle = null;
terrainObj = null;
SaveCache();
m_colors.Clear();
//Force GC to try to clean this mess up
GC.Collect();
return(bitmap);
}
public void setPos(warp_Vector v)
{
setPos(v.x, v.y, v.z);
}
public Bitmap TerrainBitmap(Viewport viewport, bool threeD, bool useTextures)
{
// AntiAliasing
int width = viewport.Width * 2;
int height = viewport.Height * 2;
var texTerrain = m_textureTerrain & useTextures;
var texPrims = m_texturePrims & useTextures;
WarpRenderer renderer = new WarpRenderer();
if (!renderer.CreateScene(width, height))
{
MainConsole.Instance.Error("[WarpTile generator]: Unable to create the required scene! Maybe lack of RAM?");
return(new Bitmap(Constants.RegionSize, Constants.RegionSize, PixelFormat.Format24bppRgb));
}
renderer.Scene.autoCalcNormals = false;
if (threeD)
{
renderer.SetBackgroundColor(SKYCOLOR);
}
#region Camera
warp_Vector pos = ConvertVector(viewport.Position);
pos.z -= 0.001f; // Works around an issue with the Warp3D camera
warp_Vector lookat = warp_Vector.add(ConvertVector(viewport.Position), ConvertVector(viewport.LookDirection));
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
if (viewport.Orthographic)
{
renderer.Scene.defaultCamera.isOrthographic = true;
if (viewport.OrthoWindowWidth <= viewport.OrthoWindowHeight)
{
renderer.Scene.defaultCamera.orthoViewWidth = viewport.OrthoWindowWidth;
renderer.Scene.defaultCamera.orthoViewHeight = viewport.OrthoWindowWidth;
}
else
{
renderer.Scene.defaultCamera.orthoViewWidth = viewport.OrthoWindowHeight;
renderer.Scene.defaultCamera.orthoViewHeight = viewport.OrthoWindowHeight;
}
}
else
{
viewport.Orthographic = false;
float fov = viewport.FieldOfView;
renderer.Scene.defaultCamera.setFov(fov);
}
#endregion Camera
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(1.0f, 0.5f, 1f), 0xffffff, 0, 320, 40));
renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 0, 100, 40));
try {
CreateWater(renderer, threeD);
CreateTerrain(renderer, texTerrain);
if (m_drawPrimVolume && m_primMesher != null)
{
foreach (ISceneChildEntity part in m_scene.Entities.GetEntities().SelectMany(ent => ent.ChildrenEntities()))
{
CreatePrim(renderer, part, texPrims);
}
}
} catch (Exception ex) {
MainConsole.Instance.Warn("[WarpTile generator]: Exception in the map generation, " + ex);
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
// AntiAliasing
using (Bitmap origBitmap = bitmap)
bitmap = ImageUtils.ResizeImage(origBitmap, viewport.Width, viewport.Height);
// Clean up
SaveCache();
foreach (var o in renderer.Scene.objectData.Values)
{
warp_Object obj = (warp_Object)o;
obj.vertexData = null;
obj.triangleData = null;
}
renderer.Scene.removeAllObjects();
renderer.Reset();
m_colors.Clear();
//Force GC to try to clean this mess up
GC.Collect();
return(bitmap);
}
public void rotateSelf(warp_Vector d)
{
rotateSelf(d.x, d.y, d.z);
}
warp_Object CreateTerrain(WarpRenderer renderer, bool textureTerrain)
{
ITerrainChannel terrain = m_scene.RequestModuleInterface <ITerrainChannel> ();
float diffX = 1.0f; //(float) m_scene.RegionInfo.RegionSizeX/(float) Constants.RegionSize;
float diffY = 1.0f; //(float) m_scene.RegionInfo.RegionSizeY/(float) Constants.RegionSize;
int newRsX = m_scene.RegionInfo.RegionSizeX / (int)diffX;
int newRsY = m_scene.RegionInfo.RegionSizeY / (int)diffY;
warp_Object obj = new warp_Object(newRsX * newRsY, ((newRsX - 1) * (newRsY - 1) * 2));
for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diffY)
{
for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diffX)
{
float t_height = terrain [(int)x, (int)y];
float waterHeight = (float)m_scene.RegionInfo.RegionSettings.WaterHeight;
//clamp to eliminate artifacts
t_height = Utils.Clamp(t_height, waterHeight - 0.5f, waterHeight + 0.5f);
if (t_height < 0.0f)
{
t_height = 0.0f;
}
warp_Vector pos = ConvertVector(x / diffX, y / diffY, t_height);
obj.addVertex(
new warp_Vertex(pos,
x / m_scene.RegionInfo.RegionSizeX,
(m_scene.RegionInfo.RegionSizeY - y) / (m_scene.RegionInfo.RegionSizeY)));
}
}
const float normal_map_reduction = 2.0f; //2.0f-2.5f is the sweet spot
for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diffY)
{
for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diffX)
{
float newX = x / diffX;
float newY = y / diffY;
if (newX < newRsX - 1 && newY < newRsY - 1)
{
int v = (int)(newY * newRsX + newX);
// Normal
Vector3 v1 = new Vector3(newX, newY, (terrain [(int)x, (int)y]) / normal_map_reduction);
Vector3 v2 = new Vector3(newX + 1, newY,
(terrain [(int)x + 1, (int)y]) / normal_map_reduction);
Vector3 v3 = new Vector3(newX, newY + 1,
(terrain [(int)x, (int)(y + 1)]) / normal_map_reduction);
warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3));
norm = norm.reverse();
obj.vertex(v).n = norm;
// Triangle 1
obj.addTriangle(
v,
v + 1,
v + newRsX);
// Triangle 2
obj.addTriangle(
v + newRsX + 1,
v + newRsX,
v + 1);
}
}
}
renderer.Scene.addObject("Terrain", obj);
renderer.Scene.sceneobject("Terrain").setPos(0.0f, 0.0f, 0.0f);
UUID [] textureIDs = new UUID [4];
float [] startHeights = new float [4];
float [] heightRanges = new float [4];
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;
uint globalX, globalY;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
Bitmap image = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges,
new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain);
warp_Texture texture = new warp_Texture(image);
warp_Material material = new warp_Material(texture);
material.setReflectivity(0); // reduces tile seams a bit thanks lkalif
renderer.Scene.addMaterial("TerrainColor", material);
renderer.SetObjectMaterial("Terrain", "TerrainColor");
image.Dispose();
return(obj);
}
public static warp_Object SPIRAL (float h, float r_out, float r_in,
float r_tube, float w, float f,
int segments, int steps)
{
float x, y, z, r, t, theta;
warp_Vector[] path = new warp_Vector[segments + 1];
for (int i = 0; i < segments + 1; i++)
{
t = (float)i / (float)segments;
r = r_out + r_in * warp_Math.sin (2 * 3.14159265f * f * t);
z = (h / 2) + h * t;
theta = 2 * 3.14159265f * w * t;
x = r * warp_Math.cos (theta);
y = r * warp_Math.sin (theta);
path [i] = new warp_Vector (x, y, z);
}
return TUBE (path, r_tube, steps, false);
}
void CreatePrim(WarpRenderer renderer, ISceneChildEntity prim, bool texturePrims)
{
try {
if ((PCode)prim.Shape.PCode != PCode.Prim)
{
return;
}
if (prim.Scale.LengthSquared() < MIN_PRIM_SIZE * MIN_PRIM_SIZE)
{
return;
}
Primitive omvPrim = prim.Shape.ToOmvPrimitive(prim.OffsetPosition, prim.GetRotationOffset());
FacetedMesh renderMesh = null;
// Are we dealing with a sculptie or mesh?
if (omvPrim.Sculpt != null && omvPrim.Sculpt.SculptTexture != UUID.Zero)
{
// Try fetching the asset
byte [] sculptAsset = m_scene.AssetService.GetData(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);
FacetedMesh.TryDecodeFromAsset(omvPrim, meshAsset, DetailLevel.Highest, out renderMesh);
meshAsset = null;
}
else // It's sculptie
{
Image sculpt = m_imgDecoder.DecodeToImage(sculptAsset);
if (sculpt != null)
{
renderMesh = m_primMesher.GenerateFacetedSculptMesh(omvPrim, (Bitmap)sculpt,
DetailLevel.Medium);
sculpt.Dispose();
}
}
sculptAsset = null;
}
else
{
// missing sculpt data... replace with something
renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium);
}
}
else // Prim
{
renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium);
}
if (renderMesh == null)
{
return;
}
warp_Vector primPos = ConvertVector(prim.GetWorldPosition());
warp_Quaternion primRot = ConvertQuaternion(prim.GetRotationOffset());
warp_Matrix m = warp_Matrix.quaternionMatrix(primRot);
if (prim.ParentID != 0)
{
ISceneEntity group = m_scene.GetGroupByPrim(prim.LocalId);
if (group != null)
{
m.transform(warp_Matrix.quaternionMatrix(ConvertQuaternion(group.RootChild.GetRotationOffset())));
}
}
warp_Vector primScale = ConvertVector(prim.Scale);
string primID = prim.UUID.ToString();
// Create the prim faces
for (int i = 0; i < renderMesh.Faces.Count; i++)
{
Face renderFace = renderMesh.Faces [i];
string meshName = primID + "-Face-" + i;
warp_Object faceObj = new warp_Object(renderFace.Vertices.Count, renderFace.Indices.Count / 3);
foreach (Vertex v in renderFace.Vertices)
{
warp_Vector pos = ConvertVector(v.Position);
warp_Vector norm = ConvertVector(v.Normal);
if (prim.Shape.SculptTexture == UUID.Zero)
{
norm = norm.reverse();
}
warp_Vertex vert = new warp_Vertex(pos, norm, v.TexCoord.X, v.TexCoord.Y);
faceObj.addVertex(vert);
}
for (int j = 0; j < renderFace.Indices.Count;)
{
faceObj.addTriangle(
renderFace.Indices [j++],
renderFace.Indices [j++],
renderFace.Indices [j++]);
}
Primitive.TextureEntryFace teFace = prim.Shape.Textures.GetFace((uint)i);
string materialName;
Color4 faceColor = GetFaceColor(teFace);
if (texturePrims && (prim.Scale.LengthSquared() > m_texturePrimSize))
{
materialName = GetOrCreateMaterial(renderer, faceColor, teFace.TextureID);
}
else
{
materialName = GetOrCreateMaterial(renderer, faceColor);
}
faceObj.transform(m);
faceObj.setPos(primPos);
faceObj.scaleSelf(primScale.x, primScale.y, primScale.z);
renderer.Scene.addObject(meshName, faceObj);
renderer.SetObjectMaterial(meshName, materialName);
faceObj = null;
}
renderMesh.Faces.Clear();
renderMesh = null;
} catch (Exception ex) {
MainConsole.Instance.Warn("[WarpTile generator]: Exception creating prim, " + ex);
}
}
private void CreatePrim(WarpRenderer renderer, SceneObjectPart prim,
bool useTextures)
{
const float MIN_SIZE_SQUARE = 4f;
if ((PCode)prim.Shape.PCode != PCode.Prim)
{
return;
}
float primScaleLenSquared = prim.Scale.LengthSquared();
if (primScaleLenSquared < MIN_SIZE_SQUARE)
{
return;
}
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
byte[] sculptAsset = m_scene.AssetService.GetData(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);
FacetedMesh.TryDecodeFromAsset(omvPrim, meshAsset, DetailLevel.Highest, out renderMesh);
meshAsset = null;
}
else // It's sculptie
{
IJ2KDecoder imgDecoder = m_scene.RequestModuleInterface <IJ2KDecoder>();
if (imgDecoder != null)
{
Image sculpt = imgDecoder.DecodeToImage(sculptAsset);
if (sculpt != null)
{
renderMesh = m_primMesher.GenerateFacetedSculptMesh(omvPrim, (Bitmap)sculpt,
DetailLevel.Medium);
sculpt.Dispose();
}
}
}
}
}
}
// If not a mesh or sculptie, try the regular mesher
if (renderMesh == null)
{
renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium);
}
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();
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);
}
for (int j = 0; j < face.Indices.Count; j += 3)
{
faceObj.addTriangle(
face.Indices[j + 0],
face.Indices[j + 1],
face.Indices[j + 2]);
}
Primitive.TextureEntryFace teFace = prim.Shape.Textures.GetFace((uint)i);
Color4 faceColor = GetFaceColor(teFace);
string materialName = String.Empty;
if (m_texturePrims && primScaleLenSquared > m_texturePrimSize * m_texturePrimSize)
{
materialName = GetOrCreateMaterial(renderer, faceColor, teFace.TextureID);
}
else
{
materialName = GetOrCreateMaterial(renderer, faceColor);
}
warp_Vector primPos = ConvertVector(prim.GetWorldPosition());
warp_Quaternion primRot = ConvertQuaternion(prim.GetWorldRotation());
warp_Matrix m = warp_Matrix.quaternionMatrix(primRot);
faceObj.transform(m);
faceObj.setPos(primPos);
faceObj.scaleSelf(prim.Scale.X, prim.Scale.Z, prim.Scale.Y);
renderer.Scene.addObject(meshName, faceObj);
renderer.SetObjectMaterial(meshName, materialName);
}
}
private void CreatePrim(WarpRenderer renderer, SceneObjectPart prim,
bool useTextures)
{
const float MIN_SIZE = 2f;
if ((PCode)prim.Shape.PCode != PCode.Prim)
{
return;
}
if (prim.Scale.LengthSquared() < MIN_SIZE * MIN_SIZE)
{
return;
}
Primitive omvPrim = prim.Shape.ToOmvPrimitive(prim.OffsetPosition, prim.RotationOffset);
FacetedMesh renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium);
if (renderMesh == null)
{
return;
}
warp_Vector primPos = ConvertVector(prim.GetWorldPosition());
warp_Quaternion primRot = ConvertQuaternion(prim.RotationOffset);
warp_Matrix m = warp_Matrix.quaternionMatrix(primRot);
if (prim.ParentID != 0)
{
SceneObjectGroup group = m_scene.SceneGraph.GetGroupByPrim(prim.LocalId);
if (group != null)
{
m.transform(warp_Matrix.quaternionMatrix(ConvertQuaternion(group.RootPart.RotationOffset)));
}
}
warp_Vector primScale = ConvertVector(prim.Scale);
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 + "-Face-" + i.ToString();
// Avoid adding duplicate meshes to the scene
if (renderer.Scene.objectData.ContainsKey(meshName))
{
continue;
}
warp_Object faceObj = new warp_Object(face.Vertices.Count, face.Indices.Count / 3);
for (int j = 0; j < face.Vertices.Count; j++)
{
Vertex v = face.Vertices[j];
warp_Vector pos = ConvertVector(v.Position);
warp_Vector norm = ConvertVector(v.Normal);
if (prim.Shape.SculptTexture == UUID.Zero)
{
norm = norm.reverse();
}
warp_Vertex vert = new warp_Vertex(pos, norm, v.TexCoord.X, v.TexCoord.Y);
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]);
}
Primitive.TextureEntryFace teFace = prim.Shape.Textures.GetFace((uint)i);
Color4 faceColor = GetFaceColor(teFace);
string materialName = GetOrCreateMaterial(renderer, faceColor);
faceObj.transform(m);
faceObj.setPos(primPos);
faceObj.scaleSelf(primScale.x, primScale.y, primScale.z);
renderer.Scene.addObject(meshName, faceObj);
renderer.SetObjectMaterial(meshName, materialName);
}
}
public void project(warp_Matrix normalProjection)
{
n2 = n.transform(normalProjection);
dist = getDist();
}
private warp_Object CreateTerrain(WarpRenderer renderer, bool textureTerrain)
{
ITerrainChannel terrain = m_scene.RequestModuleInterface <ITerrainChannel>();
float diff = (float)m_scene.RegionInfo.RegionSizeY / (float)Constants.RegionSize;
warp_Object obj =
new warp_Object(Constants.RegionSize * Constants.RegionSize,
((Constants.RegionSize - 1) * (Constants.RegionSize - 1) * 2));
for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff)
{
for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff)
{
warp_Vector pos = ConvertVector(x, y, terrain[(int)x, (int)y]);
obj.addVertex(new warp_Vertex(pos, x / (float)(m_scene.RegionInfo.RegionSizeX),
(((float)m_scene.RegionInfo.RegionSizeX) - y) /
(m_scene.RegionInfo.RegionSizeX)));
}
}
for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff)
{
for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff)
{
float newX = x / diff;
float newY = y / diff;
if (newX < Constants.RegionSize - 1 && newY < Constants.RegionSize - 1)
{
int v = (int)(newY * Constants.RegionSize + newX);
// Normal
Vector3 v1 = new Vector3(newX, newY, (terrain[(int)x, (int)y]) / Constants.TerrainCompression);
Vector3 v2 = new Vector3(newX + 1, newY,
(terrain[(int)x + 1, (int)y]) / Constants.TerrainCompression);
Vector3 v3 = new Vector3(newX, newY + 1,
(terrain[(int)x, (int)(y + 1)]) / Constants.TerrainCompression);
warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3));
norm = norm.reverse();
obj.vertex(v).n = norm;
// Triangle 1
obj.addTriangle(
v,
v + 1,
v + Constants.RegionSize);
// Triangle 2
obj.addTriangle(
v + Constants.RegionSize + 1,
v + Constants.RegionSize,
v + 1);
}
}
}
renderer.Scene.addObject("Terrain", obj);
UUID[] textureIDs = new UUID[4];
float[] startHeights = new float[4];
float[] heightRanges = new float[4];
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;
uint globalX, globalY;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
Bitmap image = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges,
new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain);
warp_Texture texture = new warp_Texture(image);
warp_Material material = new warp_Material(texture);
material.setReflectivity(0); // reduces tile seams a bit thanks lkalif
renderer.Scene.addMaterial("TerrainColor", material);
renderer.SetObjectMaterial("Terrain", "TerrainColor");
return(obj);
}
public warp_Light(warp_Vector direction)
{
v = direction;
v.normalize();
}
public void regenerateNormal ()
{
n = warp_Vector.getNormal (p1.pos, p2.pos, p3.pos);
}
public static warp_Object ROTATIONOBJECT (warp_Vector[] path, int sides)
{
int steps = sides + 1;
warp_Object newObject = new warp_Object ();
double alpha = 2 * pi / ((double)steps - 1);
float qx, qz;
int nodes = path.GetLength (0);
warp_Vertex vertex = null;
float u, v; // Texture coordinates
for (int j = 0; j < steps; j++)
{
u = (float)(steps - j - 1) / (float)(steps - 1);
for (int i = 0; i < nodes; i++)
{
v = (float)i / (float)(nodes - 1);
qx = (float)(path [i].x * Math.Cos (j * alpha) +
path [i].z * Math.Sin (j * alpha));
qz = (float)(path [i].z * Math.Cos (j * alpha) -
path [i].x * Math.Sin (j * alpha));
vertex = new warp_Vertex (new warp_Vector (qx, path [i].y, qz));
vertex.u = u;
vertex.v = v;
newObject.addVertex (vertex);
}
}
for (int j = 0; j < steps - 1; j++)
{
for (int i = 0; i < nodes - 1; i++)
{
newObject.addTriangle (i + nodes * j, i + nodes * (j + 1),
i + 1 + nodes * j);
newObject.addTriangle (i + nodes * (j + 1),
i + 1 + nodes * (j + 1),
i + 1 + nodes * j);
}
}
for (int i = 0; i < nodes - 1; i++)
{
newObject.addTriangle (i + nodes * (steps - 1), i,
i + 1 + nodes * (steps - 1));
newObject.addTriangle (i, i + 1, i + 1 + nodes * (steps - 1));
}
return newObject;
}
public void regenerateNormal ()
{
warp_Vector wn;
float nx = 0f;
float ny = 0f;
float nz = 0f;
for (int i = 0; i < neighbor.Count; i++)
{
wn = neighbor [i].getWeightedNormal ();
nx += wn.x;
ny += wn.y;
nz += wn.z;
}
n = new warp_Vector (nx, ny, nz).normalize ();
}
public void setPos (warp_Vector pos)
{
flareObject.fastvertex [0].pos = pos;
}
public warp_Vertex (warp_Vector ppos)
{
pos = ppos;
}
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);
}
}
public warp_Vertex (warp_Vector ppos, warp_Vector norm)
{
pos = ppos;
n = norm;
}
private void CreateTerrain(WarpRenderer renderer, bool textureTerrain)
{
ITerrainChannel terrain = m_scene.Heightmap;
float[] heightmap = terrain.GetFloatsSerialised();
warp_Object obj = new warp_Object(256 * 256, 255 * 255 * 2);
for (int y = 0; y < 256; y++)
{
for (int x = 0; x < 256; x++)
{
int v = y * 256 + x;
float height = heightmap[v];
warp_Vector pos = ConvertVector(new Vector3(x, y, height));
obj.addVertex(new warp_Vertex(pos, (float)x / 255f, (float)(255 - y) / 255f));
}
}
for (int y = 0; y < 256; y++)
{
for (int x = 0; x < 256; x++)
{
if (x < 255 && y < 255)
{
int v = y * 256 + x;
// Normal
Vector3 v1 = new Vector3(x, y, heightmap[y * 256 + x]);
Vector3 v2 = new Vector3(x + 1, y, heightmap[y * 256 + x + 1]);
Vector3 v3 = new Vector3(x, y + 1, heightmap[(y + 1) * 256 + x]);
warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3));
norm = norm.reverse();
obj.vertex(v).n = norm;
// Triangle 1
obj.addTriangle(
v,
v + 1,
v + 256);
// Triangle 2
obj.addTriangle(
v + 256 + 1,
v + 256,
v + 1);
}
}
}
renderer.Scene.addObject("Terrain", obj);
UUID[] textureIDs = new UUID[4];
float[] startHeights = new float[4];
float[] heightRanges = new float[4];
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;
uint globalX, globalY;
Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
warp_Texture texture;
using (
Bitmap image
= TerrainSplat.Splat(
heightmap, textureIDs, startHeights, heightRanges,
new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain))
{
texture = new warp_Texture(image);
}
warp_Material material = new warp_Material(texture);
material.setReflectivity(50);
renderer.Scene.addMaterial("TerrainColor", material);
renderer.Scene.material("TerrainColor").setReflectivity(0); // reduces tile seams a bit thanks lkalif
renderer.SetObjectMaterial("Terrain", "TerrainColor");
}
public warp_Light(warp_Vector direction)
{
v = direction;
v.normalize();
}
public void project (warp_Matrix normalProjection)
{
n2 = n.transform (normalProjection);
dist = getDist ();
}
public Bitmap TerrainToBitmap(System.Drawing.Bitmap mapbmp)
{
mapbmp = new Bitmap(m_scene.RegionInfo.RegionSizeX, m_scene.RegionInfo.RegionSizeY);
List <string> renderers = RenderingLoader.ListRenderers(Util.ExecutingDirectory());
if (renderers.Count > 0)
{
m_primMesher = RenderingLoader.LoadRenderer(renderers[0]);
m_log.Info("[MAPTILE]: Loaded prim mesher " + m_primMesher.ToString());
}
else
{
m_log.Info("[MAPTILE]: No prim mesher loaded, prim rendering will be disabled");
}
bool drawPrimVolume = true;
bool textureTerrain = true;
try
{
IConfig startupConfig = m_config.Configs["Startup"];
drawPrimVolume = startupConfig.GetBoolean("DrawPrimOnMapTile", drawPrimVolume);
textureTerrain = startupConfig.GetBoolean("TextureOnMapTile", textureTerrain);
}
catch
{
m_log.Warn("[MAPTILE]: Failed to load StartupConfig");
}
m_colors.Clear();
Vector3 camPos = new Vector3(m_scene.RegionInfo.RegionSizeX / 2, m_scene.RegionInfo.RegionSizeY / 2, 221.7025033688163f);
Viewport viewport = new Viewport(camPos, -Vector3.UnitZ, 1024f, 0.1f, m_scene.RegionInfo.RegionSizeX, m_scene.RegionInfo.RegionSizeY, m_scene.RegionInfo.RegionSizeX, m_scene.RegionInfo.RegionSizeY);
int width = viewport.Width;
int height = viewport.Height;
if (m_useAntiAliasing)
{
width *= 2;
height *= 2;
}
WarpRenderer renderer = new WarpRenderer();
renderer.CreateScene(width, height);
renderer.Scene.autoCalcNormals = false;
#region Camera
warp_Vector pos = ConvertVector(viewport.Position);
pos.z -= 0.001f; // Works around an issue with the Warp3D camera
warp_Vector lookat = warp_Vector.add(ConvertVector(viewport.Position), ConvertVector(viewport.LookDirection));
renderer.Scene.defaultCamera.setPos(pos);
renderer.Scene.defaultCamera.lookAt(lookat);
if (viewport.Orthographic)
{
renderer.Scene.defaultCamera.isOrthographic = true;
renderer.Scene.defaultCamera.orthoViewWidth = viewport.OrthoWindowWidth;
renderer.Scene.defaultCamera.orthoViewHeight = viewport.OrthoWindowHeight;
}
else
{
float fov = viewport.FieldOfView;
fov *= 1.75f; // FIXME: ???
renderer.Scene.defaultCamera.setFov(fov);
}
#endregion Camera
renderer.Scene.addLight("Light1", new warp_Light(new warp_Vector(0.2f, 0.2f, 1f), 0xffffff, 320, 80));
renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 100, 40));
CreateWater(renderer);
CreateTerrain(renderer, textureTerrain);
if (drawPrimVolume && m_primMesher != null)
{
m_scene.ForEachSOG(delegate(SceneObjectGroup group)
{
group.ForEachPart(delegate(SceneObjectPart part) { CreatePrim(renderer, part); });
});
}
renderer.Render();
Bitmap bitmap = renderer.Scene.getImage();
renderer.Scene.removeAllObjects();
renderer = null;
viewport = null;
m_primMesher = null;
m_colors.Clear();
//Force GC to try to clean this mess up
GC.GetTotalMemory(true);
if (m_useAntiAliasing)
{
bitmap = ImageUtils.ResizeImage(bitmap, width / 2, height / 2);
}
return(bitmap);
}
