SerahToolkit_SharpGL.BattleStage.Process_Step C# (CSharp) Method

Process_Step() private method

private Process_Step ( bool bTriangle, int off ) : void
bTriangle bool
off int
return void
        private void Process_Step(bool bTriangle,int off)
        {
            Console.WriteLine($"BS: Geometry parser: is triangle? {bTriangle}, offset: {off}");
            _v = null;
            _tt = null;
            _fv = null;
            string pathOfd = Path.GetDirectoryName(_pathh);
            if (bTriangle)
                pathOfd += $@"\{Path.GetFileNameWithoutExtension(_pathh)}_{off}_t.obj";
            else
                pathOfd += $@"\{Path.GetFileNameWithoutExtension(_pathh)}_{off}_q.obj";

            if (File.Exists(pathOfd))
                File.Delete(pathOfd);

            StreamWriter sw = new StreamWriter(pathOfd);
            sw.WriteLine(@"#Made with Rinoa's toolset by MaKiPL");
            sw.WriteLine(@"mtllib " + Path.GetFileNameWithoutExtension(_pathh) + ".mtl");
            sw.WriteLine(@"usemtl Textured");
            sw.WriteLine("");
            int vertexOffset = off + 6;
            int vertStop = vertexOffset + (6 * _verts);
            int loopIndexV = vertexOffset;
            Console.WriteLine($"BS: Calculating vertices from {loopIndexV} to {vertStop}");
            while (true)
            {
                short x = (BitConverter.ToInt16(_stage, loopIndexV));
                short y = (BitConverter.ToInt16(_stage, loopIndexV + 2));
                short z = (BitConverter.ToInt16(_stage, loopIndexV + 4));
                float xa = x / 2000.0f; 
                float ya = y / 2000.0f;
                float za = z / 2000.0f;
                string vline = $"v {xa} {ya} {za}" + Environment.NewLine;
                _v += vline;
                _v = _v.Replace(',', '.');
                loopIndexV += 6;
                if (loopIndexV == vertStop)
                    break;
            }
            if (bTriangle)
            {
                _triangleOffset = _absolutePolygon + 12 + (_absolutePolygon % 4);
                Console.WriteLine($"BS: Triangle offset: {_triangleOffset}");
                _currRun = _triangleOffset + 6;
                _trisStop = _currRun + (_triangles * 20);
                Console.WriteLine($"BS: Triangle end offset: {_trisStop}");
            }
            else
            {
                if (_triangles != 0)
                {
                    _quadOffset = _absolutePolygon + 12 + (_absolutePolygon % 4) + _triangles * 20;
                    Console.WriteLine($"BS: Quads offset: {_quadOffset}");
                }
                else
                {
                    _quadOffset = _absolutePolygon + 12 + (_absolutePolygon % 4);
                    Console.WriteLine($"BS: Quads offset: {_quadOffset}");
                }

                _currRun = _quadOffset + 8;
                _quadStop = (_currRun + (_quads * 24));
                _trisStop = (_currRun + (_triangles * 20));
            }
            while (true)
            {
                _u1 = _stage[_currRun];
                _v1 = _stage[_currRun + 1];
                if (bTriangle)
                {
                    _u2 = _stage[_currRun + 2];
                    _v2 = _stage[_currRun + 3];
                    _u3 = _stage[_currRun + 6];
                    _v3 = _stage[_currRun + 7];
                }
                else
                {
                    _u2 = _stage[_currRun + 4];
                    _v2 = _stage[_currRun + 5];
                    _u3 = _stage[_currRun + 8];
                    _v3 = _stage[_currRun + 9];
                    _u4 = _stage[_currRun + 10];
                    _v4 = _stage[_currRun + 11];
                }
                var add86 = bTriangle ? 8 : 6;
                string strByte = _stage[_currRun + add86].ToString("X2");
                strByte = "0" + strByte.Substring(1);
                byte page = byte.Parse(strByte);
                int pageInt = page * 128;
                float uu1 = _u1 / (float)_width + ((float)pageInt / _width);
                float vv1 = 1.0f - (_v1 / 256.0f);
                float uu2 = _u2 / (float)_width + ((float)pageInt / _width);
                float vv2 = 1.0f - (_v2 / 256.0f);
                float uu3 = _u3 / (float)_width + ((float)pageInt / _width);
                float vv3 = 1.0f - (_v3 / 256.0f);
                _tt += string.Format("vt {0} {1}" + Environment.NewLine, uu1, vv1);
                _tt += string.Format("vt {0} {1}" + Environment.NewLine, uu2, vv2);
                _tt += string.Format("vt {0} {1}" + Environment.NewLine, uu3, vv3);
                if (!bTriangle)
                {
                    float uu4 = _u4 / (float)_width + ((float)pageInt / _width);
                    float vv4 = 1.0f - (_v4 / 256.0f);
                    _tt += string.Format("vt {0} {1}" + Environment.NewLine, uu4, vv4);
                }
                if(bTriangle)
                {
                    _changeStop = _trisStop - 20;
                    _changeAdd = 20;
                }
                else
                {
                    _changeStop = _quadStop - 24;
                    _changeAdd = 24;
                }
                if (_currRun == _changeStop)
                    break;
                _currRun += _changeAdd;
            }
            Console.WriteLine($"BS: Calculated UVs and fixed output");
            _v = _v.Replace(',', '.');
            _tt = _tt.Replace(',', '.');
            Console.WriteLine($"BS: Preparing face indices parsing");
            int faceIndex = 1;
            var faceQuad = bTriangle ? _triangleOffset : _quadOffset;
            int quadStoPq;
            if (bTriangle)
                quadStoPq = _triangleOffset + (_triangles * _changeAdd);
            else
                quadStoPq = _quadOffset + (_quads * _changeAdd);
            _fv = null;
            Console.WriteLine($"BS: Polygon parsing...");
            while (true)
            {
                ushort u1U = BitConverter.ToUInt16(_stage, faceQuad);
                ushort u2U = BitConverter.ToUInt16(_stage, faceQuad + 2);
                ushort u3U = BitConverter.ToUInt16(_stage, faceQuad + 4);
                if(!bTriangle)
                    _u4U = BitConverter.ToUInt16(_stage, faceQuad + 6);

                int u1 = u1U + 1;
                int u2 = u2U + 1;
                int u3 = u3U + 1;
                if(!bTriangle)
                    _u5 = _u4U + 1;

                int t1 = faceIndex;
                int t2 = faceIndex + 1;
                int t3 = faceIndex + 2;
                if(!bTriangle)
                    _t5 = faceIndex + 3;
                if(!bTriangle)
                    _fv += $"f {u1}/{t1} {u2}/{t2} {_u5}/{_t5} {u3}/{t3}{Environment.NewLine}";
                else
                    _fv += $"f {u1}/{t2} {u2}/{t3} {u3}/{t1}{Environment.NewLine}";
                if (faceQuad == quadStoPq - _changeAdd)
                    break;
                faceQuad += _changeAdd;
                if (bTriangle)
                    faceIndex += 3;
                else
                    faceIndex += 4;
            }
            Console.WriteLine($"BS: Parsing done! Outputting to file...");
            sw.WriteLine(_v);
            sw.WriteLine(_tt);
            if (bTriangle)
                sw.WriteLine("g " + off + "_t");
            else
                sw.WriteLine("g " + off + "_q");
            sw.WriteLine(_fv);
            sw.Close();
            Console.WriteLine($"BS: Job is done!");
        }