コード例 #1
0
ファイル: Form1.cs プロジェクト: pBactusp/REngine
        private void Form1_ResizeEnd(object sender, EventArgs e)
        {
            int tempMin = Math.Min(displayPB.Size.Width, displayPB.Size.Height);

            camera_Selected.Set_Resolution(new Size(tempMin, tempMin));

            RE.Initialize_Shaders(camera_Selected.fdBuffer);

            Render();
        }
コード例 #2
0
ファイル: Form1.cs プロジェクト: pBactusp/REngine
        private void fromNoiseBU_Click(object sender, EventArgs e)
        {
            NoiseGenerationWindow ngw = new NoiseGenerationWindow();

            ngw.ShowDialog();

            if (ngw.HasNoise)
            {
                mesh_Selected = RE.Mesh_FromArray(ngw.NoiseMap, new Vector3(0.1f, 2f, 0.1f));
                scene_Selected.Meshes.Add(mesh_Selected);
                propPRLI.FromMesh(mesh_Selected);
            }
        }
コード例 #3
0
ファイル: Form1.cs プロジェクト: pBactusp/REngine
        private void Render()
        {
            RE.Render(camera_Selected, scene_Selected, mesh_Selected);

            Bitmap tempBitmap = RE.ScaleToFit(RE.Frame, displayPB.Size);

            displayPB.BackgroundImage = tempBitmap; // RE.ScaleToFit(RE.Frame, displayPB.Size);
            offset_w = (displayPB.Width - tempBitmap.Width) / 2;
            offset_h = (displayPB.Height - tempBitmap.Height) / 2;

            displayPB.Refresh();

            //MessageBox.Show("Rendering has completed");
        }
コード例 #4
0
ファイル: Form1.cs プロジェクト: pBactusp/REngine
        private void importBU_Click(object sender, EventArgs e)
        {
            OpenFileDialog fd = new OpenFileDialog();

            fd.InitialDirectory = @"D:\C#\REngine\Models";
            fd.ShowDialog();

            if (File.Exists(fd.FileName))
            {
                mesh_Selected = RE.Mesh_Import(fd.FileName);
                scene_Selected.Meshes.Add(mesh_Selected);
                propPRLI.FromMesh(mesh_Selected);
                //MessageBox.Show(mesh_Selected.Name + " has been imported.");
            }
        }
コード例 #5
0
ファイル: Form1.cs プロジェクト: pBactusp/REngine
        public Form1()
        {
            InitializeComponent();
            RE.Initialize();

            displayPB.BackgroundImage = new Bitmap(displayPB.Width, displayPB.Height);

            propPRLI.Value_Changed += PropPRLI_Value_Changed;


            //RE.World_Light_Intensity = 100;

            scenes = new List <Scene>();
            scenes.Add(new Scene("Main"));
            scene_Selected = scenes[0];

            int tempMin = Math.Min(displayPB.Size.Width, displayPB.Size.Height);

            scene_Selected.Cameras.Add(new Camera(new Vector3(0, 0, 5), new Vector3(0, 90, 0), new Size(tempMin, tempMin), 45, 45)); //new Size(displayPB.Size.Width * 2, displayPB.Size.Height * 2), 45, 45));
            camera_Selected = scene_Selected.Cameras[0];
            RE.Initialize_Shaders(camera_Selected.fdBuffer);
            camera_Selected.LookAt(new Vector3(0, 0, 0));

            light_Selected = new Light(new Size(4000, 4000), new Vector3(-10, 0, 0), new Vector3(0, 0, 0), 15, 70, true);
            scene_Selected.Lights.Add(light_Selected);
            light_Selected.LookAt(new Vector3(0, 0, 0));


            //light_Selected = new Light(new Size(2000, 2000), new Vector3(-10, 5, 5), new Vector3(0, 0, 0), 1, 80, true, 200);
            //scene_Selected.Lights.Add(light_Selected);
            //light_Selected.LookAt(new Vector3(0, 0, 0));


            //scene_Selected.Lights[1].LookAt(new Vector3(0, 0, 0));

            //camera_Selected.Render(scene_Selected);


            displayPB.MouseWheel += DisplayPB_MouseWheel;
        }
コード例 #6
0
        private void generateBU_Click(object sender, EventArgs e)
        {
            int f = (int)frequencyNUPDO.Value;
            int w = (int)widthNUPDO.Value,
                h = (int)heightNUPDO.Value;

            //NoiseMap = Make_PerlinNoise(f, w, h);
            //HasNoise = true;

            //displayPIBO.BackgroundImage = RE.Array_To_Bitmap(NoiseMap);
            //displayPIBO.Refresh();
            //return;

            NoiseMap = new float[w, h];

            int blockSize_x = NoiseMap.GetLength(0) / f,
                blockSize_y = NoiseMap.GetLength(1) / f;

            Vector3[,] vectors_net = new Vector3[f + 1, f + 1];
            Random rnd = new Random();

            Vector3[,] random_points = new Vector3[f, f];;
            float[,] cornerValues    = new float[f + 1, f + 1];
            Vector3[] tempDots = new Vector3[4];


            for (int y = 0; y < f + 1; y++)
            {
                for (int x = 0; x < f + 1; x++)
                {
                    vectors_net[x, y] = new Vector3(potential_vectors[rnd.Next(potential_vectors.Length)]);
                    //Vector3.Normalized(vectors_net[x, y]);
                }
            }

            float min = 0, max = 0;

            for (int y = 0; y < f; y++)
            {
                for (int x = 0; x < f; x++)
                {
                    random_points[x, y] = new Vector3(rnd.Next(0, blockSize_x), rnd.Next(0, blockSize_y), 0);

                    tempDots[0] = new Vector3(random_points[x, y]);
                    tempDots[1] = new Vector3(1 - random_points[x, y].X, random_points[x, y].Y, 0);
                    tempDots[2] = new Vector3(random_points[x, y].X, 1 - random_points[x, y].Y, 0);
                    tempDots[3] = new Vector3(1 - random_points[x, y].X, 1 - random_points[x, y].Y, 0);

                    //tempDots[0] = Vector3.Normalized(tempDots[0]);
                    //tempDots[1] = Vector3.Normalized(tempDots[1]);
                    //tempDots[2] = Vector3.Normalized(tempDots[2]);
                    //tempDots[3] = Vector3.Normalized(tempDots[3]);


                    cornerValues[x, y]         = Vector3.Dot(tempDots[0], vectors_net[x, y]);
                    cornerValues[x + 1, y]     = Vector3.Dot(tempDots[1], vectors_net[x + 1, y]);
                    cornerValues[x, y + 1]     = Vector3.Dot(tempDots[2], vectors_net[x, y + 1]);
                    cornerValues[x + 1, y + 1] = Vector3.Dot(tempDots[3], vectors_net[x + 1, y + 1]);
                }
            }

            foreach (float tempVal in cornerValues)
            {
                if (tempVal > max)
                {
                    max = tempVal;
                }
                else if (tempVal < min)
                {
                    min = tempVal;
                }
            }

            float range = max - min;

            for (int y = 0; y < f + 1; y++)
            {
                for (int x = 0; x < f + 1; x++)
                {
                    cornerValues[x, y] = (cornerValues[x, y] - min) / range;
                    //cornerValues[x, y] = RE.EaseCurve_Perlin(cornerValues[x, y]);
                }
            }


            for (int y = 0; y < f; y++)
            {
                for (int x = 0; x < f; x++)
                {
                    int real_x = x * blockSize_x,
                        real_y = y * blockSize_y;

                    //for (int yy = 0; yy < blockSize_y; yy++)
                    //{
                    //    float intrepolation_factor = (float)yy / (float)blockSize_y;

                    //    NoiseMap[real_x, real_y + yy] = RE.Interpolate_Linear(cornerValues[x, y], cornerValues[x, y + 1], intrepolation_factor);
                    //    NoiseMap[real_x, real_y + yy] = RE.EaseCurve_Perlin(NoiseMap[real_x, real_y + yy]);

                    //    NoiseMap[real_x + blockSize_x - 1, real_y + yy] = RE.Interpolate_Linear(cornerValues[x + 1, y], cornerValues[x + 1, y + 1], intrepolation_factor);
                    //    NoiseMap[real_x + blockSize_x - 1, real_y + yy] = RE.EaseCurve_Perlin(NoiseMap[real_x + blockSize_x - 1, real_y + yy]);

                    //    for (int xx = 0; xx < blockSize_x; xx++)
                    //    {
                    //        intrepolation_factor = (float)xx / (float)blockSize_x;

                    //        NoiseMap[real_x + xx, real_y + yy] = RE.Interpolate_Linear(NoiseMap[real_x, real_y + yy], NoiseMap[real_x + blockSize_x - 1, real_y + yy], intrepolation_factor);
                    //        NoiseMap[real_x + xx, real_y + yy] = RE.EaseCurve_Perlin(NoiseMap[real_x + xx, real_y + yy]);
                    //    }

                    //}

                    for (int xx = 0; xx < blockSize_x; xx++)
                    {
                        float intrepolation_factor = 1 - (float)xx / (float)blockSize_x;
                        //intrepolation_factor = RE.EaseCurve_Perlin(intrepolation_factor);

                        NoiseMap[real_x + xx, real_y] = RE.Lerp(cornerValues[x, y], cornerValues[x + 1, y], intrepolation_factor);
                        //NoiseMap[real_x + xx, real_y] = RE.EaseCurve_Perlin(NoiseMap[real_x + xx, real_y]);

                        NoiseMap[real_x + xx, real_y + blockSize_y - 1] = RE.Lerp(cornerValues[x, y + 1], cornerValues[x + 1, y + 1], intrepolation_factor);
                        //NoiseMap[real_x + xx, real_y + blockSize_y - 1] = RE.EaseCurve_Perlin(NoiseMap[real_x + xx, real_y + blockSize_y - 1]);

                        for (int yy = 0; yy < blockSize_y; yy++)
                        {
                            intrepolation_factor = 1 - (float)yy / (float)blockSize_y;
                            //intrepolation_factor = RE.EaseCurve_Perlin(intrepolation_factor);

                            NoiseMap[real_x + xx, real_y + yy] = RE.Lerp(NoiseMap[real_x + xx, real_y], NoiseMap[real_x + xx, real_y + blockSize_y - 1], intrepolation_factor);
                            //NoiseMap[real_x + xx, real_y + yy] = RE.EaseCurve_Perlin(NoiseMap[real_x + xx, real_y + yy]);
                        }
                    }
                }
            }

            for (int y = 0; y < NoiseMap.GetLength(1); y++)
            {
                for (int x = 0; x < NoiseMap.GetLength(0); x++)
                {
                    NoiseMap[x, y] = RE.EaseCurve_Perlin(NoiseMap[x, y]);
                }
            }


            HasNoise = true;

            displayPIBO.BackgroundImage = RE.Array_To_Bitmap(NoiseMap);
            displayPIBO.Refresh();
        }
コード例 #7
0
        private float[,] Make_PerlinNoise(int f, int w, int h)
        {
            float[,] ret = new float[w, h];

            int blockSize_x = ret.GetLength(0) / f,
                blockSize_y = ret.GetLength(1) / f;

            Vector3[,] vectors_net = new Vector3[f + 1, f + 1];
            Random rnd = new Random();

            float[,] cornerValues = new float[f + 1, f + 1];
            Vector3[] tempVecs = new Vector3[4];
            float[]   tempDots = new float[4];

            for (int y = 0; y < f + 1; y++)
            {
                for (int x = 0; x < f + 1; x++)
                {
                    vectors_net[x, y] = new Vector3(potential_vectors[rnd.Next(potential_vectors.Length)]);
                    //vectors_net[x, y] = new Vector3(potential_vector_values[rnd.Next(2)], potential_vector_values[rnd.Next(2)], 0);
                    //Vector3.Normalized(vectors_net[x, y]);
                }
            }



            float min = 0, max = 0;
            int   currentBlock_X,
                  currentBlock_y;

            for (int y = 0; y < h; y++)
            {
                currentBlock_y = y / blockSize_y;

                for (int x = 0; x < w; x++)
                {
                    currentBlock_X = x / blockSize_x;

                    tempVecs[0] = new Vector3(x - currentBlock_X * blockSize_x, y - currentBlock_y * blockSize_y, 0);
                    tempVecs[1] = new Vector3(x - (currentBlock_X + 1) * blockSize_x, y - currentBlock_y * blockSize_y, 0);
                    tempVecs[2] = new Vector3(x - currentBlock_X * blockSize_x, y - (currentBlock_y + 1) * blockSize_y, 0);
                    tempVecs[3] = new Vector3(x - (currentBlock_X + 1) * blockSize_x, y - (currentBlock_y + 1) * blockSize_y, 0);

                    //tempVecs[0] = Vector3.Normalized(tempVecs[0]);
                    //tempVecs[1] = Vector3.Normalized(tempVecs[1]);
                    //tempVecs[2] = Vector3.Normalized(tempVecs[2]);
                    //tempVecs[3] = Vector3.Normalized(tempVecs[3]);

                    tempDots[0] = Vector3.Dot(tempVecs[0], vectors_net[currentBlock_X, currentBlock_y]);
                    tempDots[1] = Vector3.Dot(tempVecs[1], vectors_net[currentBlock_X + 1, currentBlock_y]);
                    tempDots[2] = Vector3.Dot(tempVecs[2], vectors_net[currentBlock_X, currentBlock_y + 1]);
                    tempDots[3] = Vector3.Dot(tempVecs[3], vectors_net[currentBlock_X + 1, currentBlock_y + 1]);

                    //tempDots[0] = (tempDots[0] + 1) / 2;
                    //tempDots[1] = (tempDots[1] + 1) / 2;
                    //tempDots[2] = (tempDots[2] + 1) / 2;
                    //tempDots[3] = (tempDots[3] + 1) / 2;


                    float lerp_weight = 1 - ((float)((x % blockSize_x) / blockSize_x));
                    if (lerp_weight < 0 || lerp_weight > 1)
                    {
                        MessageBox.Show(lerp_weight.ToString());
                    }
                    lerp_weight = RE.EaseCurve_Perlin(lerp_weight);

                    float tempValue1 = RE.Lerp(tempDots[0], tempDots[1], lerp_weight);
                    float tempValue2 = RE.Lerp(tempDots[2], tempDots[3], lerp_weight);

                    //tempValue1 = (tempValue1 + 18) / 36;
                    //tempValue2 = (tempValue2 + 18) / 36;

                    lerp_weight = 1 - ((float)((y % blockSize_y) / blockSize_y));
                    if (lerp_weight < 0 || lerp_weight > 1)
                    {
                        MessageBox.Show(lerp_weight.ToString());
                    }
                    lerp_weight = RE.EaseCurve_Perlin(lerp_weight);

                    ret[x, y] = RE.Lerp(tempValue1, tempValue2, lerp_weight);
                    //ret[x, y] = RE.EaseCurve_Perlin(ret[x, y]);


                    ret[x, y] = (ret[x, y] + 20) / 40;

                    for (int i = 0; i < tempDots.Length; i++)
                    {
                        if (tempDots[i] > max)
                        {
                            max = tempDots[i];
                        }
                        else if (tempDots[i] < min)
                        {
                            min = tempDots[i];
                        }
                    }
                }
            }

            MessageBox.Show("min = " + min + ", max = " + max);

            //float range = max - min;
            //for (int y = 0; y < h; y++)
            //    for (int x = 0; x < w; x++)
            //    {
            //        ret[x, y] = (ret[x, y] - min) / range;
            //        //ret[x, y] = RE.EaseCurve_Perlin(ret[x, y]);
            //    }

            return(ret);
        }