public void on_operation_changed(object o, EventArgs e)
{
LogFile.WriteLine("on_operation_changed >>> ");
if (!settingtexturestagecomboentry)
{
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
if (maptexturestage != null)
{
if (operationcombo.Entry.Text != "")
{
MapTextureStageModel.OperationType operation = MapTextureStageModel.OperationType.NoTexture;
if (operationcombo.Entry.Text == "Blend")
{
operation = MapTextureStageModel.OperationType.Blend;
}
else if (operationcombo.Entry.Text == "Replace")
{
operation = MapTextureStageModel.OperationType.Replace;
}
else if (operationcombo.Entry.Text == "Nop")
{
operation = MapTextureStageModel.OperationType.Nop;
}
else if (operationcombo.Entry.Text == "NoTexture")
{
operation = MapTextureStageModel.OperationType.NoTexture;
}
maptexturestage.Operation = operation;
terrain.OnTerrainModified();
}
}
}
LogFile.WriteLine("on_operation_changed <<<");
}
// in-place blendmaptexture editing
public void OnBlendMapInPlaceEdited(MapTextureStageModel maptexturestage, int xleft, int ytop, int xright, int ybottom) // probably could be a little more specific...
{
//renderableheightmap.MapTexturesModified(Math.Max(0, xleft), Math.Max(0, ytop), Math.Min(HeightMapWidth - 1, xright), Math.Min(HeightMapHeight - 1, ybottom));
if (BlendmapInPlaceEdited != null)
{
BlendmapInPlaceEdited(maptexturestage, Math.Max(0, xleft), Math.Max(0, ytop), Math.Min(HeightMapWidth - 2, xright), Math.Min(HeightMapHeight - 2, ybottom));
}
}
public MapTextureStageView( MapTextureStageModel maptexturestagemodel )
{
LogFile.WriteLine( "MapTextureStageView(" + maptexturestagemodel + ")" );
this.maptexturestagemodel = maptexturestagemodel;
splattexture = new GlTexture( maptexturestagemodel.splattexture, false );
blendtexture = new GlTexture( maptexturestagemodel.blendtexture, true );
maptexturestagemodel.Changed += new MapTextureStageModel.ChangedHandler( maptexturestagemodel_Changed );
}
public MapTextureStageView(MapTextureStageModel maptexturestagemodel)
{
LogFile.WriteLine("MapTextureStageView(" + maptexturestagemodel + ")");
this.maptexturestagemodel = maptexturestagemodel;
splattexture = new GlTexture(maptexturestagemodel.splattexture, false);
blendtexture = new GlTexture(maptexturestagemodel.blendtexture, true);
maptexturestagemodel.Changed += new MapTextureStageModel.ChangedHandler(maptexturestagemodel_Changed);
}
void on_btnSaveAsBlendTexture_clicked(object o, EventArgs e)
{
string filepath = GetFilePath("Save blend texture as", "*.JPG");
if (filepath != "")
{
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
maptexturestage.SaveBlendTextureToFile(filepath);
blendtexturefilename.Text = filepath;
}
}
void on_btnLoadBlendTexture_clicked(object o, EventArgs e)
{
string filepath = GetFilePath("Load blend texture", "*.JPG");
if (filepath != "")
{
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
maptexturestage.LoadBlendTextureFromFile(filepath);
terrain.OnTerrainModified();
}
}
void on_tilesizescale_value_changed(object o, EventArgs e)
{
if (!settingtexturestagecomboentry)
{
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
if (maptexturestage != null)
{
LogFile.WriteLine("changing tilesize to " + (int)tilesizescale.Value);
maptexturestage.Tilesize = (int)tilesizescale.Value;
}
}
}
void on_btnSaveBlendTexture_clicked(object o, EventArgs e)
{
if (blendtexturefilename.Text == "")
{
on_btnSaveAsBlendTexture_clicked(o, e);
}
else
{
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
maptexturestage.SaveBlendTextureToFile(blendtexturefilename.Text);
}
}
MapTextureStageModel GetSelectedMapTextureStage()
{
try
{
MapTextureStageModel maptexturestage = terrain.texturestages[GetSelectedMapTextureStageIndex()];
return(maptexturestage);
}
catch (Exception)
{
//Console.WriteLine(e);
return(null);
}
}
void on_btnRemoveStage_clicked(object o, EventArgs e)
{
if (terrain.texturestages.Count > 1)
{
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
if (maptexturestage != null)
{
MetaverseClient.GetInstance().worldstorage.terrainmodel.texturestages.Remove(maptexturestage);
terrain.OnTerrainModified();
}
}
else
{
InfoMessage("You need at least one texture stage for the map to run");
}
}
void terrain_BlendmapInPlaceEdited(MapTextureStageModel maptexturestagemodel, int xleft, int ytop, int xright, int ybottom)
{
MapTextureStageView maptexturestageview = terrainview.mapviewbymapmodel[maptexturestagemodel];
for (int chunkx = xleft / chunksize; chunkx <= xright / chunksize && chunkx < width / chunksize;
chunkx++)
{
for (int chunky = ytop / chunksize; chunky <= ybottom / chunksize && chunky < height / chunksize;
chunky++)
{
// Console.WriteLine("chunk " + chunkx + " " + chunky);
//for (int texturestageindex = 0; texturestageindex < maptexturestages.GetLength(0); texturestageindex++)
//{
// maptexturestage = maptexturestages[texturestageindex];
if (maptexturestagemodel.Operation == MapTextureStageModel.OperationType.Blend)
{
bool texturestageused = false;
// go through each point in chunk and check if texturestage is used
for (int mapx = chunkx * chunksize; mapx < (chunkx + 1) * chunksize && !texturestageused;
mapx++)
{
for (int mapy = chunky * chunksize; mapy < (chunky + 1) * chunksize && !texturestageused;
mapy++)
{
//if (mapx < width && mapy < height)
//{
if (maptexturestagemodel.Affects(mapx, mapy, width, height))
{
texturestageused = true;
}
//}
}
}
chunkusestexturestage[maptexturestagemodel][chunkx, chunky] = texturestageused;
// if (chunkusestexturestage[texturestageindex][chunkx, chunky])
//{
// Console.WriteLine("texturestage used: " + texturestageindex + " " + chunkx + " " + chunky);
//}
}
else
{
chunkusestexturestage[maptexturestagemodel][chunkx, chunky] = true;
}
//}
}
}
}
void on_texturestage_changed(object o, EventArgs e)
{
LogFile.WriteLine("on_texturestage_changed() >>>");
MapTextureStageModel maptexturestage = GetSelectedMapTextureStage();
if (maptexturestage != null)
{
texturefilenamelbl.Text = maptexturestage.SplatTextureFilename;
blendtexturefilename.Text = maptexturestage.BlendTextureFilename;
operationcombo.Entry.Text = maptexturestage.Operation.ToString();
(BrushEffectController.GetInstance()
.brusheffects[typeof(PaintTexture)] as PaintTexture)
.SetCurrentEditTexture(maptexturestage);
tilesizescale.Value = maptexturestage.Tilesize;
}
LogFile.WriteLine("on_texturestage_changed() <<<");
}
void LoadTextureData(MapTextureStageModel maptexturestage)
{
LogFile.WriteLine("PaintTexture.LoadTextureData( " + maptexturestage);
thistexture = maptexturestage.blendtexture;
if (thistexture != null)
{
texturewidth = thistexture.Width;
textureheight = thistexture.Height;
LogFile.WriteLine("edittexture width " + texturewidth + " height " + textureheight);
alphadata = new double[texturewidth, textureheight];
for (int x = 0; x < texturewidth; x++)
{
for (int y = 0; y < textureheight; y++)
{
alphadata[x, y] = thistexture.GetRed(x, y);
}
}
}
}
void terrain_BlendmapInPlaceEdited(MapTextureStageModel maptexturestagemodel, int xleft, int ytop, int xright, int ybottom)
{
MapTextureStageView maptexturestageview = terrainview.mapviewbymapmodel[maptexturestagemodel];
for (int chunkx = xleft / chunksize; chunkx <= xright / chunksize && chunkx < width / chunksize;
chunkx++)
{
for (int chunky = ytop / chunksize; chunky <= ybottom / chunksize && chunky < height / chunksize;
chunky++)
{
// Console.WriteLine("chunk " + chunkx + " " + chunky);
//for (int texturestageindex = 0; texturestageindex < maptexturestages.GetLength(0); texturestageindex++)
//{
// maptexturestage = maptexturestages[texturestageindex];
if (maptexturestagemodel.Operation == MapTextureStageModel.OperationType.Blend)
{
bool texturestageused = false;
// go through each point in chunk and check if texturestage is used
for (int mapx = chunkx * chunksize; mapx < (chunkx + 1) * chunksize && !texturestageused;
mapx++)
{
for (int mapy = chunky * chunksize; mapy < (chunky + 1) * chunksize && !texturestageused;
mapy++)
{
//if (mapx < width && mapy < height)
//{
if (maptexturestagemodel.Affects(mapx, mapy, width, height))
{
texturestageused = true;
}
//}
}
}
chunkusestexturestage[maptexturestagemodel][chunkx, chunky] = texturestageused;
// if (chunkusestexturestage[texturestageindex][chunkx, chunky])
//{
// Console.WriteLine("texturestage used: " + texturestageindex + " " + chunkx + " " + chunky);
//}
}
else
{
chunkusestexturestage[maptexturestagemodel][chunkx, chunky] = true;
}
//}
}
}
}
public void SetCurrentEditTexture(MapTextureStageModel maptexturestage)
{
this.maptexturestage = maptexturestage;
LoadTextureData(maptexturestage);
}
void LoadTextureData( MapTextureStageModel maptexturestage )
{
LogFile.WriteLine( "PaintTexture.LoadTextureData( " + maptexturestage );
thistexture = maptexturestage.blendtexture;
if (thistexture != null)
{
texturewidth = thistexture.Width;
textureheight = thistexture.Height;
LogFile.WriteLine( "edittexture width " + texturewidth + " height " + textureheight );
alphadata = new double[texturewidth, textureheight];
for (int x = 0; x < texturewidth; x++)
{
for (int y = 0; y < textureheight; y++)
{
alphadata[x, y] = thistexture.GetRed( x, y );
}
}
}
}
public void SetCurrentEditTexture( MapTextureStageModel maptexturestage )
{
this.maptexturestage = maptexturestage;
LoadTextureData( maptexturestage );
}
// determine which chunks are used by each texture stage
// only affects blend really
void CacheChunkTextureStageUsage()
{
LogFile.WriteLine("Cachchunktexturestageusage");
int numxchunks = width / chunksize;
int numychunks = height / chunksize;
chunkusestexturestage = new Dictionary <MapTextureStageModel, bool[, ]>();
foreach (MapTextureStageModel maptexturestage in maptexturestagemodels)
{
chunkusestexturestage.Add(maptexturestage, new bool[numxchunks, numychunks]);
}
for (int chunkx = 0; chunkx < numxchunks; chunkx++)
{
for (int chunky = 0; chunky < numychunks; chunky++)
{
// Console.WriteLine("chunk " + chunkx + " " + chunky);
for (int texturestageindex = 0; texturestageindex < maptexturestagemodels.Count; texturestageindex++)
{
MapTextureStageModel texturestagemodel = maptexturestagemodels[texturestageindex];
//MapTextureStageView texturestageview = terrainview.mapviewbymapmodel[texturestagemodel];
//Console.WriteLine("texturestage " + texturestageindex + " " + texturestage.Operation );
if (texturestagemodel.Operation == MapTextureStageModel.OperationType.Blend)
{
bool texturestageused = false;
// go through each point in chunk and check if texturestage is used
for (int mapx = chunkx * chunksize; mapx < (chunkx + 1) * chunksize && !texturestageused;
mapx++)
{
for (int mapy = chunky * chunksize; mapy < (chunky + 1) * chunksize && !texturestageused;
mapy++)
{
if (texturestagemodel.Affects(mapx, mapy, width, height))
{
texturestageused = true;
}
}
}
chunkusestexturestage[texturestagemodel][chunkx, chunky] = texturestageused;
// if (chunkusestexturestage[texturestageindex][chunkx, chunky])
//{
// Console.WriteLine("texturestage used: " + texturestageindex + " " + chunkx + " " + chunky);
//}
}
else if (texturestagemodel.Operation == MapTextureStageModel.OperationType.Nop)
{
chunkusestexturestage[texturestagemodel][chunkx, chunky] = false;
}
else
{
//Console.WriteLine("RenderableHeightMap,, cache chunk usage, true");
chunkusestexturestage[texturestagemodel][chunkx, chunky] = true;
}
}
}
}
maxtexels = RendererSdl.GetInstance().MaxTexelUnits;
int totaltexturestagesneeded = 0;
foreach (MapTextureStageModel maptexturestagemodel in maptexturestagemodels)
{
totaltexturestagesneeded += terrainview.mapviewbymapmodel[maptexturestagemodel].NumTextureStagesRequired;
}
multipass = false;
if (totaltexturestagesneeded > maxtexels)
{
multipass = true;
}
rendererpasses = new List <RendererPass>();
//maxtexels = 2;
//int currenttexel = 0;
multipass = true; // force multipass for now for simplicity
LogFile.WriteLine("Adding rendererpasses");
if (multipass)
{
for (int i = 0; i < maptexturestagemodels.Count; i++)
{
MapTextureStageModel maptexturestagemodel = maptexturestagemodels[i];
MapTextureStageView maptexturestage = terrainview.mapviewbymapmodel[maptexturestagemodel];
int numtexturestagesrequired = maptexturestage.NumTextureStagesRequired;
if (numtexturestagesrequired > 0) // exclude Nops
{
RendererPass rendererpass = new RendererPass(maxtexels);
for (int j = 0; j < maptexturestage.NumTextureStagesRequired; j++)
{
rendererpass.AddStage(new RendererTextureStage(maptexturestage, j, true, width, height));
}
rendererpasses.Add(rendererpass);
LogFile.WriteLine("Adding rendererpass: " + rendererpass);
}
}
}
}
// probably could be a little more specific...
// in-place blendmaptexture editing
public void OnBlendMapInPlaceEdited( MapTextureStageModel maptexturestage, int xleft, int ytop, int xright, int ybottom )
{
//renderableheightmap.MapTexturesModified(Math.Max(0, xleft), Math.Max(0, ytop), Math.Min(HeightMapWidth - 1, xright), Math.Min(HeightMapHeight - 1, ybottom));
if (BlendmapInPlaceEdited != null)
{
BlendmapInPlaceEdited(maptexturestage, Math.Max(0, xleft), Math.Max(0, ytop), Math.Min(HeightMapWidth - 2, xright), Math.Min(HeightMapHeight - 2, ybottom));
}
}
// note to self: move this to subscriber?
void DrawMinimap()
{
TerrainModel terrain = MetaverseClient.GetInstance().worldstorage.terrainmodel;
if (DateTime.Now.Subtract(LastMinimapUpdate).TotalMilliseconds > 1000)
//if( true )
{
List <RendererPass> rendererpasses = new List <RendererPass>();
bool multipass = true; // force multipass for now for simplicity
int maxtexels = RendererSdl.GetInstance().MaxTexelUnits;
if (multipass)
{
for (int i = 0; i < terrain.texturestages.Count; i++)
{
MapTextureStageModel maptexturestage = terrain.texturestages[i];
int numtexturestagesrequired = maptexturestage.NumTextureStagesRequired;
if (numtexturestagesrequired > 0) // exclude Nops
{
RendererPass rendererpass = new RendererPass(maxtexels);
for (int j = 0; j < maptexturestage.NumTextureStagesRequired; j++)
{
rendererpass.AddStage(new RendererTextureStage(maptexturestage, j, true, mapwidth, mapheight));
}
rendererpasses.Add(rendererpass);
}
}
}
GraphicsHelperGl g = new GraphicsHelperGl();
//g.ApplyOrtho(windowwidth, windowheight, RendererSdl.GetInstance().OuterWindowWidth, RendererSdl.GetInstance().OuterWindowHeight);
g.EnableBlendSrcAlpha();
Gl.glDepthFunc(Gl.GL_LEQUAL);
int chunkwidth = minimapwidth / numchunks;
int chunkheight = minimapheight / numchunks;
float[] ambientLight = new float[] { 0.4f, 0.4f, 0.4f, 1.0f };
float[] diffuseLight = new float[] { 0.6f, 0.6f, 0.6f, 1.0f };
float[] specularLight = new float[] { 0.2f, 0.2f, 0.2f, 1.0f };
float[] position = new float[] { -1.0f, 0.2f, -0.4f, 1.0f };
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambientLight);
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, diffuseLight);
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPECULAR, specularLight);
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, position);
foreach (RendererPass rendererpass in rendererpasses)
{
rendererpass.Apply();
for (int x = 0; x + chunkwidth < minimapwidth; x += chunkwidth)
{
for (int y = 0; y + chunkheight < minimapheight; y += chunkheight)
{
Gl.glBegin(Gl.GL_QUADS);
//double ul = 0;
//double ur = mapwidth * Terrain.SquareSize;
//double vt = 0;
//double vb = mapheight * Terrain.SquareSize;
double ul = (double)x / minimapwidth * mapwidth;
double ur = (double)(x + chunkwidth) / minimapwidth * mapwidth;
double vt = (double)y / minimapheight * mapheight;
double vb = (double)(y + chunkheight) / minimapheight * mapheight;
double xl = minimapx + x;
double xr = minimapx + x + minimapwidth / (double)numchunks;
double yt = minimapy + y;
double yb = minimapy + y + minimapheight / (double)numchunks;
Gl.glTexCoord2d(ul, vt);
Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ul, vt);
g.Normal(renderableheightmap.GetNormal(x * mapwidth / minimapwidth, y * mapheight / minimapheight));
//g.Normal(renderableheightmap.normalsperquad[, ]);
Gl.glVertex2d(xl, yt);
Gl.glTexCoord2d(ul, vb);
Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ul, vb);
g.Normal(renderableheightmap.GetNormal(x * mapwidth / minimapwidth, (y + chunkheight) * mapheight / minimapheight));
//g.Normal( renderableheightmap.normalsperquad[x * mapwidth / minimapwidth, (y + 1) * mapheight / minimapheight ] );
Gl.glVertex2d(xl, yb);
Gl.glTexCoord2d(ur, vb);
Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ur, vb);
g.Normal(renderableheightmap.GetNormal((x + chunkwidth) * mapwidth / minimapwidth, (y + chunkheight) * mapheight / minimapheight));
//g.Normal(renderableheightmap.normalsperquad[(x + 1) * mapwidth / minimapwidth, (y + 1) * mapheight / minimapheight]);
Gl.glVertex2d(xr, yb);
Gl.glTexCoord2d(ur, vt);
Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ur, vt);
g.Normal(renderableheightmap.GetNormal((x + chunkwidth) * mapwidth / minimapwidth, y * mapheight / minimapheight));
//g.Normal(renderableheightmap.normalsperquad[(x + 1) * mapwidth / minimapwidth, y * mapheight / minimapheight]);
Gl.glVertex2d(xr, yt);
Gl.glEnd();
}
}
}
g.ActiveTexture(0);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, minimaptexture);
Gl.glCopyTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, minimapx,
RendererSdl.GetInstance().WindowHeight - minimapy - minimapsize,
minimapsize, minimapsize, 0);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST);
LastMinimapUpdate = DateTime.Now;
// g.RemoveOrtho();
g.ActiveTexture(1);
g.DisableTexture2d();
g.SetTextureScale(1);
g.ActiveTexture(0);
g.SetTextureScale(1);
g.EnableModulate();
Gl.glDisable(Gl.GL_BLEND);
}
else
{
GraphicsHelperGl g = new GraphicsHelperGl();
//Gl.glMatrixMode(Gl.GL_PROJECTION);
//Gl.glPushMatrix();
//Gl.glLoadIdentity();
//Gl.glOrtho(0, windowwidth, windowheight - RendererSdl.GetInstance().OuterWindowHeight, 0, -1, 1); // we'll just draw the minimap directly onto our display
//Gl.glOrtho(0, windowwidth, windowheight, windowheight - RendererSdl.GetInstance().OuterWindowHeight, -1, 1); // we'll just draw the minimap directly onto our display
//Gl.glMatrixMode(Gl.GL_MODELVIEW);
//Gl.glPushMatrix();
//Gl.glLoadIdentity();
g.ActiveTexture(0);
g.EnableTexture2d();
Gl.glBindTexture(Gl.GL_TEXTURE_2D, minimaptexture);
//Gl.glBindTexture(Gl.GL_TEXTURE_2D, (terrain.texturestages[0].texture as GlTexture).GlReference);
Gl.glDisable(Gl.GL_LIGHTING);
Gl.glBegin(Gl.GL_QUADS);
Gl.glTexCoord2d(0, 1);
Gl.glVertex2i(minimapx, minimapy);
Gl.glTexCoord2d(0, 1 - minimapwidth / (double)minimapsize);
Gl.glVertex2i(minimapx, minimapy + minimapheight);
Gl.glTexCoord2d(minimapwidth / (double)minimapsize, 1 - minimapheight / (double)minimapsize);
Gl.glVertex2i(minimapx + minimapwidth, minimapy + minimapheight);
Gl.glTexCoord2d(minimapwidth / (double)minimapsize, 1);
Gl.glVertex2i(minimapx + minimapwidth, minimapy);
Gl.glEnd();
Gl.glEnable(Gl.GL_LIGHTING);
//Gl.glMatrixMode(Gl.GL_PROJECTION);
//Gl.glPopMatrix();
//Gl.glMatrixMode(Gl.GL_MODELVIEW);
//Gl.glPopMatrix();
}
}
