예제 #1
0
 public void Register(IBrushShape brushshape)
 {
     Console.WriteLine(this.GetType() + " registering " + brushshape);
     this.brushshapes.Add(brushshape.GetType(), brushshape);
     if (CurrentEditBrush.GetInstance().BrushShape == null)
     {
         CurrentEditBrush.GetInstance().BrushShape = brushshape;
     }
     MainUI.GetInstance().uiwindow.AddBrushShape(brushshape.Name, brushshape.Description, brushshape);
 }
예제 #2
0
 public void Register(IBrushEffect brusheffect)
 {
     Console.WriteLine(this.GetType() + " registering " + brusheffect);
     this.brusheffects.Add(brusheffect.GetType(), brusheffect);
     if (CurrentEditBrush.GetInstance().BrushEffect == null)
     {
         CurrentEditBrush.GetInstance().BrushEffect = brusheffect;
     }
     MainUI.GetInstance().uiwindow.AddBrushEffect(brusheffect.Name, brusheffect.Description, brusheffect);
 }
예제 #3
0
        public void LoadSm3(string filename)
        {
            terrain.tdfparser = TdfParser.FromFile(filename);
            TdfParser.Section terrainsection = terrain.tdfparser.RootSection.SubSection("map/terrain");
            string            tdfdirectory   = Path.GetDirectoryName(Path.GetDirectoryName(filename));

            LoadTextureStages(tdfdirectory, terrainsection);
            LoadHeightMap(tdfdirectory, terrainsection);
            terrain.OnTerrainModified();
            MainUI.GetInstance().uiwindow.InfoMessage("SM3 load completed");
        }
예제 #4
0
        public void on_btnLoadFeatures_clicked(object o, EventArgs e)
        {
            MainUI.GetInstance().uiwindow.InfoMessage("Load.  We're going to ask you for two filepaths.  One is the featurelist textfile and one is the feature data binary file");
            string featurefilepath = MainUI.GetInstance().uiwindow.GetFilePath("Load.  Please enter filepath for featurelist text file:", "features.tdf");

            if (featurefilepath != "")
            {
                string featurebinfilepath = MainUI.GetInstance().uiwindow.GetFilePath("Load.  Please enter filepath for feature data binary file:", "features.features");
                if (featurebinfilepath != "")
                {
                    FeaturePersistence.GetInstance().LoadFeatures(featurefilepath, featurebinfilepath);
                }
            }
        }
예제 #5
0
        public void Save(string filename)
        {
            double[,] mesh = Terrain.GetInstance().Map;
            int   width  = mesh.GetUpperBound(0) + 1;
            int   height = mesh.GetUpperBound(1) + 1;
            Image image  = new Image(width, height);
            //Bitmap bitmap = new Bitmap( width, height, PixelFormat.Format24bppRgb );
            //Graphics g = Graphics.FromImage(bitmap);
            //Pen[] pens = new Pen[256];
            //for (int i = 0; i < 256; i++)
            //{
            //  pens[i] = new Pen(System.Drawing.Color.FromArgb(i, i, i));
            //}
            double minheight        = Config.GetInstance().minheight;
            double maxheight        = Config.GetInstance().maxheight;
            double heightmultiplier = 255 / (maxheight - minheight);

            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < height; j++)
                {
                    int normalizedmeshvalue = (int)((mesh[i, j] - minheight) * heightmultiplier);
                    normalizedmeshvalue = Math.Max(0, normalizedmeshvalue);
                    normalizedmeshvalue = Math.Min(255, normalizedmeshvalue);
                    byte normalizedmeshvaluebyte = (byte)normalizedmeshvalue;
                    image.SetPixel(i, j, normalizedmeshvaluebyte, normalizedmeshvaluebyte, normalizedmeshvaluebyte, 255);
                    //g.DrawRectangle(pens[ normalizedmeshvalue ], i, j, 1, 1);
                }
            }
            if (File.Exists(filename))
            {
                File.Delete(filename);
            }
            image.Save(filename);
            //DevIL.DevIL.SaveBitmap(filename, bitmap);
            //bitmap.Save(filename, ImageFormat.Bmp);
            Terrain.GetInstance().HeightmapFilename = filename;
            Terrain.GetInstance().OnTerrainModified();
            MainUI.GetInstance().uiwindow.InfoMessage("Heightmap saved");
        }
예제 #6
0
        // what we need to do is to render the splatted texture in ortho mode with lighting off
        // or normals off (to be tested)
        // then to export the generated bitmap
        // viewport should be set to heightmapwidth x heightmapheight
        public void Export(string filepath)
        {
            Terrain terrain       = Terrain.GetInstance();
            int     picturewidth  = terrain.MapWidth * Terrain.SquareSize;
            int     pictureheight = terrain.MapHeight * Terrain.SquareSize;

            LogFile.GetInstance().WriteLine("Export to " + filepath + " picturewidth " + picturewidth + " pictureheight: " + pictureheight);
            //int windowwidth = RendererSdl.GetInstance().WindowWidth;
            //int windowheight = RendererSdl.GetInstance().WindowHeight;
            int windowwidth  = 256;
            int windowheight = 256;

            Gl.glViewport(0, 0, windowwidth, windowheight);

            byte[] buffer = new byte[windowwidth * windowheight * 4];
            //System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap( picturewidth, pictureheight );
            //byte[] imagedata = new byte[picturewidth * pictureheight * 4];
            Image image = new Image(picturewidth, pictureheight);

            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++)
                {
                    MapTextureStage 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, picturewidth, pictureheight));
                        }
                        rendererpasses.Add(rendererpass);
                    }
                }
            }

            GraphicsHelperGl g = new GraphicsHelperGl();

            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glPushMatrix();
            Gl.glLoadIdentity();
            Gl.glOrtho(0, windowwidth, windowheight, 0, -1, 1);

            Gl.glMatrixMode(Gl.GL_MODELVIEW);
            Gl.glPushMatrix();
            Gl.glLoadIdentity();

            Gl.glDisable(Gl.GL_CULL_FACE);
            Gl.glDisable(Gl.GL_LIGHTING);

            g.EnableBlendSrcAlpha();
            Gl.glDepthFunc(Gl.GL_LEQUAL);

            for (int chunkx = 0; chunkx < Math.Ceiling((double)picturewidth / windowwidth); chunkx++)
            {
                for (int chunky = 0; chunky < Math.Ceiling((double)pictureheight / windowheight); chunky++)
                {
                    Console.WriteLine("chunkx " + chunkx + " chunky " + chunky);

                    Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);                // Clear The Screen And Depth Buffer

                    foreach (RendererPass rendererpass in rendererpasses)
                    {
                        rendererpass.Apply();

                        Gl.glBegin(Gl.GL_QUADS);

                        double ul = (chunkx * windowwidth);
                        double ur = (chunkx * windowwidth + windowwidth);
                        double vt = (chunky * windowheight);
                        double vb = (chunky * windowheight + windowheight);
                        Gl.glTexCoord2d(ul, vt);
                        Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ul, vt);
                        Gl.glVertex2i(0, 0);

                        Gl.glTexCoord2d(ul, vb);
                        Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ul, vb);
                        Gl.glVertex2i(0, windowheight);

                        Gl.glTexCoord2d(ur, vb);
                        Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ur, vb);
                        Gl.glVertex2i(windowwidth, windowheight);

                        Gl.glTexCoord2d(ur, vt);
                        Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB, ur, vt);
                        Gl.glVertex2i(windowwidth, 0);

                        Gl.glEnd();
                    }

                    IntPtr ptr = Marshal.AllocHGlobal(windowwidth * windowheight * 4);
                    Gl.glReadPixels(0, 0, windowwidth, windowheight, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, ptr);
                    Marshal.Copy(ptr, buffer, 0, windowwidth * windowheight * 4);
                    Marshal.FreeHGlobal(ptr);

                    for (int x = 0; x < windowwidth; x++)
                    {
                        for (int y = 0; y < windowheight; y++)
                        {
                            if ((chunky * windowheight + y < pictureheight) &&
                                (chunkx * windowwidth + x < picturewidth))
                            {
                                int pixeloffset = (windowheight - y - 1) * windowwidth * 4 + x * 4;
                                //bitmap.SetPixel(x + chunkx * windowwidth, y + chunky * windowheight, System.Drawing.Color.FromArgb(buffer[pixeloffset + 0],
                                //buffer[pixeloffset + 1], buffer[pixeloffset + 2]));
                                image.SetPixel(x + chunkx * windowwidth, y + chunky * windowheight,
                                               buffer[pixeloffset + 0],
                                               buffer[pixeloffset + 1],
                                               buffer[pixeloffset + 2],
                                               255
                                               );
                            }
                        }
                    }
                }
            }
            if (File.Exists(filepath))
            {
                File.Delete(filepath);
            }
            image.Save(filepath);
            //DevIL.DevIL.SaveBitmap( filepath, bitmap);

            Gl.glPopMatrix();
            Gl.glMatrixMode(Gl.GL_PROJECTION);
            Gl.glPopMatrix();
            Gl.glMatrixMode(Gl.GL_MODELVIEW);

            Gl.glEnable(Gl.GL_LIGHTING);

            g.ActiveTexture(1);
            g.DisableTexture2d();
            g.SetTextureScale(1);
            g.ActiveTexture(0);
            g.SetTextureScale(1);

            Gl.glEnable(Gl.GL_CULL_FACE);
            Gl.glEnable(Gl.GL_LIGHTING);
            Gl.glDisable(Gl.GL_BLEND);

            g.EnableModulate();

            Gl.glViewport(0, 0, RendererSdl.GetInstance().OuterWindowWidth, RendererSdl.GetInstance().OuterWindowHeight);
            g.CheckError();

            MainUI.GetInstance().uiwindow.InfoMessage("Exported blended terrain texture to " + filepath);
        }
예제 #7
0
        public void LoadFeatures(string featurelistfilename, string featuredatafilename)
        {
            LogFile.GetInstance().WriteLine("LoadFeatures()");
            TdfParser tdfparser = TdfParser.FromFile(featurelistfilename);
            Terrain   terrain   = Terrain.GetInstance();

            terrain.FeatureMap = new Unit[terrain.MapWidth, terrain.MapHeight];
            Dictionary <int, string> featurenamebynumber = new Dictionary <int, string>();
            int numfeaturetypes = tdfparser.RootSection.GetIntValue("map/featuretypes/numtypes");

            LogFile.GetInstance().WriteLine("Num types: " + numfeaturetypes);
            for (int i = 0; i < numfeaturetypes; i++)
            {
                string featurename = tdfparser.RootSection.GetStringValue("map/featuretypes/type" + i);
                if (!File.Exists(Path.Combine("objects3d", featurename + ".s3o")))
                {
                    MainUI.GetInstance().uiwindow.WarningMessage("Warning: objects3d/" + featurename + ".s3o not found");
                }
                else
                {
                    LogFile.GetInstance().WriteLine("Feature type " + i + " " + featurename.ToLower());
                    featurenamebynumber.Add(i, featurename.ToLower());
                }
            }

            List <Sm3Feature> features = new List <Sm3Feature>();

            // from FeaturePlacer Form1.cs by Jelmer Cnossen
            FileStream fs = new FileStream(featuredatafilename, FileMode.Open);

            if (fs != null)
            {
                BinaryReader br = new BinaryReader(fs);
                if (br.ReadByte() != 0)
                {
                    MainUI.GetInstance().uiwindow.WarningMessage("The featuredata you are trying to load was saved using a different version.");
                    return;
                }

                int numFeatures = br.ReadInt32();
                features.Clear();
                for (int a = 0; a < numFeatures; a++)
                {
                    Sm3Feature f = new Sm3Feature();
                    features.Add(f);
                    f.type     = br.ReadInt32();
                    f.x        = br.ReadSingle();
                    f.y        = br.ReadSingle();
                    f.z        = br.ReadSingle();
                    f.rotation = br.ReadSingle();
                }
            }

            foreach (Sm3Feature sm3feature in features)
            {
                if (featurenamebynumber.ContainsKey(sm3feature.type))
                {
                    string featurename = featurenamebynumber[sm3feature.type].ToLower();
                    if (!UnitCache.GetInstance().UnitsByName.ContainsKey(featurename))
                    {
                        LogFile.GetInstance().WriteLine("Loading unit " + Path.Combine("objects3d", featurename + ".s3o") + " ... ");
                        Unit unit = new S3oLoader().LoadS3o(Path.Combine("objects3d", featurename + ".s3o"));
                        UnitCache.GetInstance().UnitsByName.Add(featurename, unit);
                    }
                    LogFile.GetInstance().WriteLine("Adding " + featurename + " at " + (int)(sm3feature.x / Terrain.SquareSize) + " " + (int)(sm3feature.y / Terrain.SquareSize));
                    terrain.FeatureMap[(int)(sm3feature.x / Terrain.SquareSize), (int)(sm3feature.y / Terrain.SquareSize)] = UnitCache.GetInstance().UnitsByName[featurename];
                }
            }

            terrain.OnTerrainModified();
        }
예제 #8
0
        public void SaveFeatures(string featurelistfilename, string featuredatafilename)
        {
            Dictionary <string, int> featurenumberbyname = new Dictionary <string, int>();
            List <Sm3Feature>        features            = new List <Sm3Feature>();
            int          nextnumber      = 0;
            StreamWriter featurelistfile = new StreamWriter(featurelistfilename, false, Encoding.UTF8);

            for (int x = 0; x < Terrain.GetInstance().MapWidth; x++)
            {
                for (int y = 0; y < Terrain.GetInstance().MapHeight; y++)
                {
                    Unit thisunit = Terrain.GetInstance().FeatureMap[x, y];
                    if (thisunit != null)
                    {
                        if (!featurenumberbyname.ContainsKey(thisunit.Name))
                        {
                            featurenumberbyname.Add(thisunit.Name, nextnumber);
                            nextnumber++;
                        }
                        int featurenumber = featurenumberbyname[thisunit.Name];
                        features.Add(new Sm3Feature(featurenumber, x * Terrain.SquareSize, y * Terrain.SquareSize, Terrain.GetInstance().Map[x, y]));
                        // note to self: unsure whether to multiply by squaresize or not ???
                    }
                }
            }
            featurelistfile.WriteLine("[MAP]");
            featurelistfile.WriteLine("{");
            featurelistfile.WriteLine("   [FeatureTypes]");
            featurelistfile.WriteLine("   {");
            featurelistfile.WriteLine("      NumTypes=" + featurenumberbyname.Count + ";");
            foreach (KeyValuePair <string, int> kvp in featurenumberbyname)
            {
                featurelistfile.WriteLine("      type" + kvp.Value + "=" + kvp.Key + ";");
            }
            featurelistfile.WriteLine("   }");
            featurelistfile.WriteLine("}");
            featurelistfile.Close();

            // from FeaturePlacer Form1.cs by Jelmer Cnossen
            // for reference, FeaturePlacer uses following data types:
            //    public class feature
            //    {
            //        public float x, y, z;
            //       public float rotation;
            //       public int type;
            //   }
            FileStream fs = new FileStream(featuredatafilename, FileMode.Create);

            if (fs != null)
            {
                fs.WriteByte(0); // version

                BinaryWriter bw = new BinaryWriter(fs);
                bw.Write((UInt32)features.Count);

                foreach (Sm3Feature f in features)
                {
                    bw.Write(f.type);
                    bw.Write(f.x);
                    bw.Write(f.y);
                    bw.Write(f.z);
                    bw.Write(f.rotation);
                }
            }
            fs.Close();

            MainUI.GetInstance().uiwindow.InfoMessage("Features stored to file");
        }