/// <summary>
        /// BeginBuildingLightmaps
        /// ----------------------
        /// Initializes the lightmap building process
        /// </summary>
        public void BeginBuildingLightmaps(ref CModel.SModel _SModel)
        {
            CLocal.SLightStyle[] _LightStyle;

            // no dlightcache
            CMain.r_framecount = 1;

            // setup the base lightstyles so the lightmaps won't have to be regenerated
            // the first time they're seen
            _LightStyle = new CLocal.SLightStyle[CLocal.MAX_LIGHTSTYLES];
            for (int i = 0; i < CLocal.MAX_LIGHTSTYLES; i++)
            {
                _LightStyle[i].rgb = new float[3];
                _LightStyle[i].rgb[0] = 1.0f;
                _LightStyle[i].rgb[1] = 1.0f;
                _LightStyle[i].rgb[2] = 1.0f;
                _LightStyle[i].white = 3.0f;
            }

            CClient.cl.RefDef.lightstyles = _LightStyle;

            // jkrige ??
            //if (!gl_state.lightmap_textures)
            //{
            //    gl_state.lightmap_textures = TEXNUM_LIGHTMAPS;
            //}
            // jkrige ??

            CProgram.gQ2Game.gCMain.gCImage.StartLightmaps(ref _SModel);
            LM_InitBlock();
        }
Example #2
0
        private void Mod_LoadTexinfo(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<CModel.SMTexInfo> MTexInfo = new List<CModel.SMTexInfo>();

            br.BaseStream.Seek(header.lumps[LUMP_TEXINFO].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_TEXINFO].fileofs + header.lumps[LUMP_TEXINFO].filelen))
            {
                CModel.SMTexInfo _MTexInfo;
                string texture;
                int next;

                _MTexInfo.vecs = new Microsoft.Xna.Framework.Vector4[2];
                for (int i = 0; i < 2; i++)
                {
                    _MTexInfo.vecs[i].X = br.ReadSingle();
                    _MTexInfo.vecs[i].Y = br.ReadSingle();
                    _MTexInfo.vecs[i].Z = br.ReadSingle();
                    _MTexInfo.vecs[i].W = br.ReadSingle();
                }

                _MTexInfo.flags = (ESurface)br.ReadInt32();
                br.ReadInt32(); // value
                texture = CShared.Com_ToString(br.ReadChars(32));
                texture = "textures/" + texture;

                next = br.ReadInt32();
                if (next > 0)
                    _MTexInfo.next = next;
                else
                    _MTexInfo.next = 0;

                _MTexInfo.image = CProgram.gQ2Game.gCMain.gCImage.FindImage(texture, out _MTexInfo.Width, out _MTexInfo.Height, CImage.EImageType.IT_WALL);

                // TODO
                //out->image = GL_FindImage (name, it_wall);
                //if (!out->image)
                //{
                //    ri.Con_Printf (PRINT_ALL, "Couldn't load %s\n", name);
                //    out->image = r_notexture;
                //}

                _MTexInfo.numframes = 0;

                MTexInfo.Add(_MTexInfo);
            }

            // count animation frames
            for (int i = 0; i < MTexInfo.Count; i++)
            {
                CModel.SMTexInfo _MTexInfo = MTexInfo[i];
                _MTexInfo.numframes = 1;

                for (int step = _MTexInfo.next; step != 0 && step != i; step = MTexInfo[step].next)
                {
                    _MTexInfo.numframes++;
                }

                MTexInfo[i] = _MTexInfo;
            }

            _SModel.numtexinfo = MTexInfo.Count;
            _SModel.texinfo = MTexInfo.ToArray();
        }
        /// <summary>
        /// SubdivideSurface
        /// ----------------
        /// Breaks a polygon up along axial 64 unit boundaries
        /// so that turbulent and sky warps can be done reasonably.
        /// </summary>
        public void SubdivideSurface(ref CModel.SMSurface surf)
        {
            float[] verts;
            int numverts;
            List<CModel.SGLPoly> polys;

            if ((surf.flags & CModel.EMSurface.SURF_DRAWTURB) != CModel.EMSurface.SURF_DRAWTURB)
                return;

            verts = new float[64 * 3];
            numverts = surf.polys[0].numverts;

            for (int i = 0; i < surf.polys[0].numverts; i++)
            {
                verts[(i * 3) + 0] = surf.polys[0].verts[i].vertex.Position.X;
                verts[(i * 3) + 1] = surf.polys[0].verts[i].vertex.Position.Y;
                verts[(i * 3) + 2] = surf.polys[0].verts[i].vertex.Position.Z;
            }

            surf.polys = null;
            polys = new List<CModel.SGLPoly>();

            SubdividePolygon(surf, ref polys, numverts, verts);

            surf.polys = polys.ToArray();
            polys.Clear();
        }
 /// <summary>
 /// EndBuildingLightmaps
 /// --------------------
 /// Finalizes the processed lightmaps
 /// </summary>
 public void EndBuildingLightmaps(ref CModel.SModel _SModel)
 {
     LM_UploadBlock(false);
     CProgram.gQ2Game.gCMain.gCImage.FinalizeLightmaps(ref _SModel);
 }
        /// <summary>
        /// BuildSurfaceIndex
        /// ------------------
        /// Convert the surface's vertex format from triangle fan to triangle list
        /// This is used to speed up surface warping by using an index buffer
        /// </summary>
        public int[] BuildSurfaceIndex(CModel.SMSurface surf)
        {
            List<int> ib = new List<int>();
            ib.Clear();

            for (int i = 0; i < surf.polys.Length; i++)
            {
                for (int j = 2; j < surf.polys[i].verts.Length; j++)
                {
                    ib.Add(surf.polys[i].verts[0].offset);
                    ib.Add(surf.polys[i].verts[j - 1].offset);
                    ib.Add(surf.polys[i].verts[j].offset);
                }
            }

            return ib.ToArray();
        }
 public void BuildPolygonFromSurface(ref CModel.SMSurface surf)
 {
     // most parts of the BuildWorld() function in CMain could be done here
     // if so, the polygons needs to be subdivided first most likely
     // see the function calling this function
 }
Example #7
0
        public void SetCacheState(ref CModel.SMSurface surf)
        {
            surf.cached_light = new float[CQ2BSP.MAXLIGHTMAPS];

            for(int maps = 0; maps < CQ2BSP.MAXLIGHTMAPS && surf.styles[maps] != 255; maps++)
            {
                surf.cached_light[maps] = CClient.cl.RefDef.lightstyles[surf.styles[maps]].white;
            }
        }
Example #8
0
        private void Mod_LoadSubmodels(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<SDModel> DModel = new List<SDModel>();
            List<CModel.SMModel> MModel = new List<CModel.SMModel>();

            br.BaseStream.Seek(header.lumps[LUMP_MODELS].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_MODELS].fileofs + header.lumps[LUMP_MODELS].filelen))
            {
                SDModel _DModel;

                _DModel.mins = new float[3];
                _DModel.mins[0] = br.ReadSingle();
                _DModel.mins[1] = br.ReadSingle();
                _DModel.mins[2] = br.ReadSingle();

                _DModel.maxs = new float[3];
                _DModel.maxs[0] = br.ReadSingle();
                _DModel.maxs[1] = br.ReadSingle();
                _DModel.maxs[2] = br.ReadSingle();

                _DModel.origin = new float[3];
                _DModel.origin[0] = br.ReadSingle();
                _DModel.origin[1] = br.ReadSingle();
                _DModel.origin[2] = br.ReadSingle();

                _DModel.headnode = br.ReadInt32();

                _DModel.firstface = br.ReadInt32();
                _DModel.numfaces = br.ReadInt32();

                DModel.Add(_DModel);
            }

            for (int i = 0; i < DModel.Count; i++)
            {
                CModel.SMModel _MModel;

                _MModel.bounds.Min.X = DModel[i].mins[0] - 1;
                _MModel.bounds.Min.Y = DModel[i].mins[1] - 1;
                _MModel.bounds.Min.Z = DModel[i].mins[2] - 1;
                _MModel.bounds.Max.X = DModel[i].maxs[0] + 1;
                _MModel.bounds.Max.Y = DModel[i].maxs[1] + 1;
                _MModel.bounds.Max.Z = DModel[i].maxs[2] + 1;

                _MModel.origin.X = DModel[i].origin[0];
                _MModel.origin.Y = DModel[i].origin[1];
                _MModel.origin.Z = DModel[i].origin[2];

                _MModel.radius = RadiusFromBounds(_MModel.bounds);

                _MModel.headnode = DModel[i].headnode;
                _MModel.firstface = DModel[i].firstface;
                _MModel.numfaces = DModel[i].numfaces;

                _MModel.visleafs = 0;

                MModel.Add(_MModel);
            }

            _SModel.numsubmodels = MModel.Count;
            _SModel.submodels = MModel.ToArray();
        }
Example #9
0
        public void R_DrawBrushModel(CModel.SEntities _CurrentEntity)
        {
            Matrix wMatrix;
            //EffectParameter EP;
            Vector3 mins;
            Vector3 maxs;
            bool rotated;

            // update HLSL variables
            CProgram.gQ2Game.gCMain.UpdateHLSL(-1);

            // sort textures and surfaces
            if (CProgram.gQ2Game.gCMain.MarkSurfaceSetupStatic(ref _CurrentEntity.Model) == false)
                return;

            // set vertex buffer
            CProgram.gQ2Game.gGraphicsDevice.SetVertexBuffer(_CurrentEntity.Model.vbWorldSolid);

            if (_CurrentEntity.Angles.X != 0.0f || _CurrentEntity.Angles.Y != 0.0f || _CurrentEntity.Angles.Z != 0.0f)
            {
                rotated = true;

                mins.X = _CurrentEntity.Origin.X - _CurrentEntity.Model.radius;
                mins.Y = _CurrentEntity.Origin.Y - _CurrentEntity.Model.radius;
                mins.Z = _CurrentEntity.Origin.Z - _CurrentEntity.Model.radius;

                maxs.X = _CurrentEntity.Origin.X + _CurrentEntity.Model.radius;
                maxs.Y = _CurrentEntity.Origin.Y + _CurrentEntity.Model.radius;
                maxs.Z = _CurrentEntity.Origin.Z + _CurrentEntity.Model.radius;
            }
            else
            {
                rotated = false;

                mins.X = _CurrentEntity.Origin.X + _CurrentEntity.Model.mins.X;
                mins.Y = _CurrentEntity.Origin.Y + _CurrentEntity.Model.mins.Y;
                mins.Z = _CurrentEntity.Origin.Z + _CurrentEntity.Model.mins.Z;

                maxs.X = _CurrentEntity.Origin.X + _CurrentEntity.Model.maxs.X;
                maxs.Y = _CurrentEntity.Origin.Y + _CurrentEntity.Model.maxs.Y;
                maxs.Z = _CurrentEntity.Origin.Z + _CurrentEntity.Model.maxs.Z;
            }

            //if (R_CullBox(mins, maxs))
            //    return;

            CMain.ModelOrigin.X = CClient.cl.RefDef.ViewOrigin.X - _CurrentEntity.Origin.X;
            CMain.ModelOrigin.Y = CClient.cl.RefDef.ViewOrigin.Y - _CurrentEntity.Origin.Y;
            CMain.ModelOrigin.Z = CClient.cl.RefDef.ViewOrigin.Z - _CurrentEntity.Origin.Z;

            if (rotated == true)
            {
                Vector3 temp;
                Vector3 forward, right, up;

                temp.X = CMain.ModelOrigin.X;
                temp.Y = CMain.ModelOrigin.Y;
                temp.Z = CMain.ModelOrigin.Z;

                forward = Vector3.Zero;
                right = Vector3.Zero;
                up = Vector3.Zero;

                CShared.AngleVectors(_CurrentEntity.Angles, ref forward, ref right, ref up);

                CMain.ModelOrigin.X = Vector3.Dot(temp, forward);
                CMain.ModelOrigin.Y = -Vector3.Dot(temp, right);
                CMain.ModelOrigin.Z = Vector3.Dot(temp, up);
            }

            if (rotated == false)
            {
                wMatrix = Matrix.CreateFromYawPitchRoll(_CurrentEntity.Angles.Y, _CurrentEntity.Angles.X, _CurrentEntity.Angles.Z);
                wMatrix *= Matrix.CreateTranslation(_CurrentEntity.Origin);
            }
            else
            {
                wMatrix = Matrix.CreateTranslation(_CurrentEntity.Origin);
            }

            // update HLSL variables
            CProgram.gQ2Game.gEffect.Parameters["xWorld"].SetValue(wMatrix);

            // set a rendering technique
            if ((_CurrentEntity.Model.Flags & CQ2MD2.EModelFlags.RF_TRANSLUCENT) == CQ2MD2.EModelFlags.RF_TRANSLUCENT)
                CProgram.gQ2Game.gEffect.CurrentTechnique = CProgram.gQ2Game.gEffect.Techniques["TexturedTranslucent"];
            else
            {
                if (CProgram.gQ2Game.gCMain.r_hardwarelight == false)
                    CProgram.gQ2Game.gEffect.CurrentTechnique = CProgram.gQ2Game.gEffect.Techniques["TexturedLightmap"];
                else
                    CProgram.gQ2Game.gEffect.CurrentTechnique = CProgram.gQ2Game.gEffect.Techniques["TexturedLight"];
            }

            // jkrige TODO - probably need to update this since most brushmodels can translate/rotate
            // save effect parameter collection shortcut
            //EP = CProgram.gQ2Game.gEffect.Parameters["lights"];

            for (int i = 0; i < _CurrentEntity.Model.nummodelsurfaces; i++)
            {
                int surf = _CurrentEntity.Model.firstmodelsurface + i;

                // update surface HLSL variables
                CProgram.gQ2Game.gCMain.UpdateHLSL(surf);

                // set lights for current surface
                //for (int k = 0; k < CProgram.gQ2Game.gCMain.r_maxLights; k++)
                //{
                //    _CurrentEntity.Model.lights[CQ2BSP.SWorldData.surfaces[surf].lightIndex[k]].SetLight(EP.Elements[k]);
                //}
            }

            for (int i = 0; i < _CurrentEntity.Model.lSChainLightmap.Count; i++)
            {
                // bind new lightmap
                int lightmaptexturenum = _CurrentEntity.Model.lSChainLightmap[i].lightmaptexturenum;
                CProgram.gQ2Game.gEffect.Parameters["xTextureLightmap"].SetValue(CQ2BSP.SWorldData.WorldLightmaps[lightmaptexturenum]);

                for (int j = 0; j < _CurrentEntity.Model.lSChainLightmap[i].TexInfo.Count; j++)
                {
                    // bind new texture
                    int texanim = CProgram.gQ2Game.gCMain.TextureAnimation(_CurrentEntity.Model.lSChainLightmap[i].TexInfo[j].texinfo);
                    int texinfo = _CurrentEntity.Model.lSChainLightmap[i].TexInfo[j].texinfo;
                    CProgram.gQ2Game.gEffect.Parameters["xTextureDiffuse"].SetValue(CQ2BSP.SWorldData.WorldTextures[CQ2BSP.SWorldData.texinfo[texanim].image].Tex2D);

                    // set the indices
                    CProgram.gQ2Game.gGraphicsDevice.Indices = _CurrentEntity.Model.ibWorldSolid[lightmaptexturenum, texinfo].ibBuffer;

                    foreach (EffectPass pass in CProgram.gQ2Game.gEffect.CurrentTechnique.Passes)
                    {
                        pass.Apply();
                        CProgram.gQ2Game.gGraphicsDevice.DrawIndexedPrimitives(
                            PrimitiveType.TriangleList,
                            0,
                            0,
                            _CurrentEntity.Model.vbWorldSolid.VertexCount,
                            0,
                            _CurrentEntity.Model.ibWorldSolid[lightmaptexturenum, texinfo].PrimitiveCount);
                    }
                    CMain.c_brush_polys += _CurrentEntity.Model.ibWorldSolid[lightmaptexturenum, texinfo].PrimitiveCount;
                }
            }
        }
Example #10
0
        public void Mod_LoadBrushModel(ref CModel.SModel _SModel, MemoryStream ms)
        {
            SDHeader header;
            List<SLump> lumps;
            BinaryReader br;

            ms.Seek(0, System.IO.SeekOrigin.Begin);
            br = new BinaryReader(ms);

            if (worldMapLoaded == true)
            {
                CMain.Error(CMain.EErrorParm.ERR_FATAL, "ERROR: attempted to redundantly load world map");
                return;
            }

            worldMapLoaded = true;

            _SModel.ModType = CModel.EModType.MOD_BRUSH;

            header.ident = br.ReadInt32();
            if (header.ident != IDBSPHEADER)
            {
                CMain.Error(CMain.EErrorParm.ERR_WARNING, "RE_LoadWorldMap: " + _SModel.name + " has wrong identity.");
                return;
            }

            header.version = br.ReadInt32();
            if (header.version != BSP_VERSION)
            {
                CMain.Error(CMain.EErrorParm.ERR_FATAL, "RE_LoadWorldMap: " + _SModel.name + " has wrong version number (" + header.version.ToString() + " should be " + BSP_VERSION.ToString() + ")");
                return;
            }

            lumps = new List<SLump>();
            for (int i = 0; i < HEADER_LUMPS; i++)
            {
                SLump _lump;
                _lump.fileofs = br.ReadInt32();
                _lump.filelen = br.ReadInt32();

                lumps.Add(_lump);
            }
            header.lumps = lumps.ToArray();

            CProgram.gQ2Game.gCMain.gCImage.StartWAL(ref _SModel);

            // load into heap
            Mod_LoadVertexes(header, ref _SModel, ref br);
            Mod_LoadEdges(header, ref _SModel, ref br);
            Mod_LoadSurfedges(header, ref _SModel, ref br);
            Mod_LoadLighting(header, ref _SModel, ref br);
            Mod_LoadPlanes(header, ref _SModel, ref br);
            Mod_LoadTexinfo(header, ref _SModel, ref br);
            Mod_LoadFaces(header, ref _SModel, ref br);
            Mod_LoadMarksurfaces(header, ref _SModel, ref br);
            Mod_LoadVisibility(header, ref _SModel, ref br);
            Mod_LoadNodesAndLeafs(header, ref _SModel, ref br);
            Mod_LoadSubmodels(header, ref _SModel, ref br);
            Mod_LoadAreas(header, ref _SModel, ref br);
            Mod_LoadAreaPortals(header, ref _SModel, ref br);
            Mod_LoadEntityString(header, ref _SModel, ref br);
            _SModel.numframes = 2;

            // set up the submodels
            for (int i = 0; i < _SModel.numsubmodels; i++)
            {
                CModel.SMModel bm;
                CModel.SModel starmod;

                bm = _SModel.submodels[i];
                starmod = CProgram.gQ2Game.gCMain.gCModel.mod_inline[i];

                starmod.ModType = CModel.EModType.MOD_BRUSH;
                starmod.firstmodelsurface = bm.firstface;
                starmod.nummodelsurfaces = bm.numfaces;
                starmod.firstnode = bm.headnode;

                if (starmod.firstnode >= _SModel.numnodes)
                    System.Diagnostics.Debug.WriteLine("Inline model " + i.ToString() + " has bad firstnode");

                starmod.maxs = bm.bounds.Max;
                starmod.mins = bm.bounds.Min;
                starmod.radius = bm.radius;
                starmod.numleafs = bm.visleafs;

                CProgram.gQ2Game.gCMain.gCModel.mod_inline[i] = starmod;
            }

            CProgram.gQ2Game.gCMain.gCImage.FinalizeWAL(ref _SModel);

            portalopen = new bool[MAX_MAP_AREAPORTALS];
            FloodAreaConnections(ref _SModel);
        }
Example #11
0
        // ================================================================
        //
        // AREAPORTALS
        //
        // ================================================================
        public void FloodArea_r(CModel.SModel _SModel, ref CModel.SMArea area, int floodnum)
        {
            if (area.floodvalid == floodvalid)
            {
                if (area.floodnum == floodnum)
                    return;

                System.Diagnostics.Debug.WriteLine("FloodArea_r: reflooded");
                return;
            }

            area.floodnum = floodnum;
            area.floodvalid = floodvalid;

            for (int i = 0; i < area.numareaportals; i++)
            {
                if (portalopen[_SModel.areaportals[area.firstareaportal + i].portalnum] == true)
                    FloodArea_r(_SModel, ref _SModel.areas[_SModel.areaportals[area.firstareaportal + i].otherarea], floodnum);
            }
        }
Example #12
0
        public void FloodAreaConnections(ref CModel.SModel _SModel)
        {
            int floodnum;

            // all current floods are now invalid
            floodvalid++;
            floodnum = 0;

            // area 0 is not used
            for (int i = 1; i < _SModel.numareas; i++)
            {
                if (_SModel.areas[i].floodvalid == floodvalid)
                    continue; // already flooded into

                floodnum++;
                FloodArea_r(_SModel, ref _SModel.areas[i], floodnum);
            }
        }
Example #13
0
        private void Mod_SetParent(ref CModel.SModel _SModel, int idx_node, int idx_parent)
        {
            _SModel.nodes[idx_node].parent = idx_parent;

            if (_SModel.nodes[idx_node].contents != -1)
                return;

            Mod_SetParent(ref _SModel, _SModel.nodes[idx_node].children[0], idx_node);
            Mod_SetParent(ref _SModel, _SModel.nodes[idx_node].children[1], idx_node);
        }
Example #14
0
        private void Mod_LoadVisibility(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            int pos_visdata = 0;
            br.BaseStream.Seek(header.lumps[LUMP_VISIBILITY].fileofs, System.IO.SeekOrigin.Begin);

            if (header.lumps[LUMP_VISIBILITY].filelen == 0)
            {
                _SModel.vis.numclusters = 0;
                _SModel.vis.bitofs = null;
                _SModel.visdata = null;

                return;
            }

            _SModel.vis.numclusters = br.ReadInt32();
            _SModel.vis.bitofs = new int[_SModel.vis.numclusters, 2];

            for (int i = 0; i < _SModel.vis.numclusters; i++)
            {
                _SModel.vis.bitofs[i, DVIS_PVS] = br.ReadInt32();
                _SModel.vis.bitofs[i, DVIS_PHS] = br.ReadInt32();

                // decrement the offsets, because the data is stored in a seperate byte array
                _SModel.vis.bitofs[i, DVIS_PVS] -= 4 + ((4 * _SModel.vis.numclusters * 2));
                _SModel.vis.bitofs[i, DVIS_PHS] -= 4 + ((4 * _SModel.vis.numclusters * 2));
            }

            _SModel.visdata = new byte[(header.lumps[LUMP_VISIBILITY].fileofs + header.lumps[LUMP_VISIBILITY].filelen) - br.BaseStream.Position];
            while (br.BaseStream.Position < (header.lumps[LUMP_VISIBILITY].fileofs + header.lumps[LUMP_VISIBILITY].filelen))
            {
                _SModel.visdata[pos_visdata++] = br.ReadByte();
            }
        }
Example #15
0
        private void Mod_LoadVertexes(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<CModel.SMVertex> MVertex = new List<CModel.SMVertex>();

            br.BaseStream.Seek(header.lumps[LUMP_VERTEXES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_VERTEXES].fileofs + header.lumps[LUMP_VERTEXES].filelen))
            {
                CModel.SMVertex _MVertex;

                _MVertex.Position.X = br.ReadSingle();
                _MVertex.Position.Y = br.ReadSingle();
                _MVertex.Position.Z = br.ReadSingle();

                MVertex.Add(_MVertex);
            }

            _SModel.numvertexes = MVertex.Count;
            _SModel.vertexes = MVertex.ToArray();
        }
Example #16
0
        private void Mod_LoadNodesAndLeafs(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<SDNode> DNode = new List<SDNode>();
            List<SDLeaf> DLeaf = new List<SDLeaf>();
            List<CModel.SMNode> MNode = new List<CModel.SMNode>();

            // load nodes
            br.BaseStream.Seek(header.lumps[LUMP_NODES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_NODES].fileofs + header.lumps[LUMP_NODES].filelen))
            {
                SDNode _DNode;

                _DNode.planenum = br.ReadInt32();

                _DNode.children = new int[2];
                _DNode.children[0] = br.ReadInt32();
                _DNode.children[1] = br.ReadInt32();

                _DNode.mins = new short[3];
                _DNode.mins[0] = br.ReadInt16();
                _DNode.mins[1] = br.ReadInt16();
                _DNode.mins[2] = br.ReadInt16();

                _DNode.maxs = new short[3];
                _DNode.maxs[0] = br.ReadInt16();
                _DNode.maxs[1] = br.ReadInt16();
                _DNode.maxs[2] = br.ReadInt16();

                _DNode.firstface = br.ReadUInt16();
                _DNode.numfaces = br.ReadUInt16();

                DNode.Add(_DNode);
            }

            for (int i = 0; i < DNode.Count; i++)
            {
                CModel.SMNode _MNode;
                int p;

                _MNode.bounds.Min.X = DNode[i].mins[0];
                _MNode.bounds.Min.Y = DNode[i].mins[1];
                _MNode.bounds.Min.Z = DNode[i].mins[2];
                _MNode.bounds.Max.X = DNode[i].maxs[0];
                _MNode.bounds.Max.Y = DNode[i].maxs[1];
                _MNode.bounds.Max.Z = DNode[i].maxs[2];

                _MNode.plane = DNode[i].planenum;

                _MNode.firstsurface = DNode[i].firstface;
                _MNode.numsurfaces = DNode[i].numfaces;
                _MNode.contents = -1; // differentiate from leafs

                _MNode.children = new int[2];
                for (int j = 0; j < 2; j++)
                {
                    p = DNode[i].children[j];

                    if (p >= 0)
                        _MNode.children[j] = p;
                    else
                        _MNode.children[j] = DNode.Count + (-1 - p);
                }

                _MNode.parent = 0;
                _MNode.visframe = 0;

                // leaf specific
                _MNode.cluster = 0;
                _MNode.area = 0;
                _MNode.firstmarksurface = 0;
                _MNode.nummarksurfaces = 0;

                MNode.Add(_MNode);
            }

            // load leafs
            br.BaseStream.Seek(header.lumps[LUMP_LEAFS].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_LEAFS].fileofs + header.lumps[LUMP_LEAFS].filelen))
            {
                SDLeaf _DLeaf;

                _DLeaf.contents = br.ReadInt32();

                _DLeaf.cluster = br.ReadInt16();
                _DLeaf.area = br.ReadInt16();

                _DLeaf.mins = new short[3];
                _DLeaf.mins[0] = br.ReadInt16();
                _DLeaf.mins[1] = br.ReadInt16();
                _DLeaf.mins[2] = br.ReadInt16();

                _DLeaf.maxs = new short[3];
                _DLeaf.maxs[0] = br.ReadInt16();
                _DLeaf.maxs[1] = br.ReadInt16();
                _DLeaf.maxs[2] = br.ReadInt16();

                _DLeaf.firstleafface = br.ReadUInt16();
                _DLeaf.numleaffaces = br.ReadUInt16();

                _DLeaf.firstleafbrush = br.ReadUInt16();
                _DLeaf.numleafbrushes = br.ReadUInt16();

                DLeaf.Add(_DLeaf);
            }

            for (int i = 0; i < DLeaf.Count; i++)
            {
                CModel.SMNode _MNode;

                _MNode.bounds.Min.X = DLeaf[i].mins[0];
                _MNode.bounds.Min.Y = DLeaf[i].mins[1];
                _MNode.bounds.Min.Z = DLeaf[i].mins[2];
                _MNode.bounds.Max.X = DLeaf[i].maxs[0];
                _MNode.bounds.Max.Y = DLeaf[i].maxs[1];
                _MNode.bounds.Max.Z = DLeaf[i].maxs[2];

                _MNode.contents = DLeaf[i].contents;

                _MNode.cluster = DLeaf[i].cluster;
                _MNode.area = DLeaf[i].area;

                _MNode.firstmarksurface = DLeaf[i].firstleafface;
                _MNode.nummarksurfaces = DLeaf[i].numleaffaces;

                _MNode.parent = 0;
                _MNode.visframe = 0;

                // node specific
                _MNode.plane = 0;
                _MNode.firstsurface = 0;
                _MNode.numsurfaces = 0;
                _MNode.children = null;

                MNode.Add(_MNode);
            }

            _SModel.numnodes = DNode.Count + DLeaf.Count;
            _SModel.numDecisionNodes = DNode.Count;
            _SModel.numleafs = DLeaf.Count;
            _SModel.nodes = MNode.ToArray();

            // chain decendants
            Mod_SetParent(ref _SModel, 0, -1);
        }
Example #17
0
        private void Mod_LoadPlanes(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            int bits;
            float[] normal = new float[3];
            List<CShared.SCPlane> CPlane = new List<CShared.SCPlane>();

            br.BaseStream.Seek(header.lumps[LUMP_PLANES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_PLANES].fileofs + header.lumps[LUMP_PLANES].filelen))
            {
                CShared.SCPlane _CPlane;

                normal[0] = 0.0f;
                normal[1] = 0.0f;
                normal[2] = 0.0f;

                bits = 0;

                for (int j = 0; j < 3; j++)
                {
                    normal[j] = br.ReadSingle();

                    if (normal[j] < 0)
                        bits |= 1 << j;
                }

                _CPlane.normal.X = normal[0];
                _CPlane.normal.Y = normal[1];
                _CPlane.normal.Z = normal[2];

                _CPlane.dist = br.ReadSingle();
                _CPlane.type = (byte)br.ReadInt32();
                _CPlane.signbits = (byte)bits;

                _CPlane.pad = new byte[2];

                CPlane.Add(_CPlane);
            }

            _SModel.planes = CPlane.ToArray();
            _SModel.numplanes = _SModel.planes.Length;
        }
Example #18
0
        private void Mod_LoadAreaPortals(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<SDAreaPortal> DAreaPortal = new List<SDAreaPortal>();
            List<CModel.SMAreaPortal> MAreaPortal = new List<CModel.SMAreaPortal>();

            br.BaseStream.Seek(header.lumps[LUMP_AREAPORTALS].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_AREAPORTALS].fileofs + header.lumps[LUMP_AREAPORTALS].filelen))
            {
                SDAreaPortal _DAreaPortal;

                _DAreaPortal.portalnum = br.ReadInt32();
                _DAreaPortal.otherarea = br.ReadInt32();

                DAreaPortal.Add(_DAreaPortal);
            }

            for (int i = 0; i < DAreaPortal.Count; i++)
            {
                CModel.SMAreaPortal _MAreaPortal;

                _MAreaPortal.portalnum = DAreaPortal[i].portalnum;
                _MAreaPortal.otherarea = DAreaPortal[i].otherarea;

                MAreaPortal.Add(_MAreaPortal);
            }

            _SModel.numareaportals = MAreaPortal.Count;
            _SModel.areaportals = MAreaPortal.ToArray();
        }
Example #19
0
        private void Mod_LoadSurfedges(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<int> DSurfEdge = new List<int>();

            br.BaseStream.Seek(header.lumps[LUMP_SURFEDGES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_SURFEDGES].fileofs + header.lumps[LUMP_SURFEDGES].filelen))
            {
                DSurfEdge.Add(br.ReadInt32());
            }

            _SModel.numsurfedges = DSurfEdge.Count;
            _SModel.surfedges = DSurfEdge.ToArray();
        }
Example #20
0
        private void Mod_LoadAreas(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<SDArea> DArea = new List<SDArea>();
            List<CModel.SMArea> MArea = new List<CModel.SMArea>();

            br.BaseStream.Seek(header.lumps[LUMP_AREAS].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_AREAS].fileofs + header.lumps[LUMP_AREAS].filelen))
            {
                SDArea _DArea;

                _DArea.numareaportals = br.ReadInt32();
                _DArea.firstareaportal = br.ReadInt32();

                DArea.Add(_DArea);
            }

            for (int i = 0; i < DArea.Count; i++)
            {
                CModel.SMArea _MArea;

                _MArea.numareaportals = DArea[i].numareaportals;
                _MArea.firstareaportal = DArea[i].firstareaportal;
                _MArea.floodvalid = 0;
                _MArea.floodnum = 0;

                MArea.Add(_MArea);
            }

            _SModel.numareas = MArea.Count;
            _SModel.areas = MArea.ToArray();
        }
Example #21
0
        /// <summary>
        /// R_BuildLightMap
        /// ---------------
        /// Combine and scale multiple lightmaps into the floating format in blocklights
        /// </summary>
        public void BuildLightMap(CModel.SModel _SModel, ref CModel.SMSurface surf, int dest_pos, ref byte[] dest, int stride)
        {
            int smax, tmax;
            int r, g, b, a, max;
            int size;
            int lightmap;
            float[] scale;
            int nummaps;
            float[] bl;
            CLocal.SLightStyle style;

            int bl_pos;
            float modulate = 1.0f;

            if (
                (_SModel.texinfo[surf.texinfo].flags & CQ2BSP.ESurface.SURF_SKY) == CQ2BSP.ESurface.SURF_SKY
                | (_SModel.texinfo[surf.texinfo].flags & CQ2BSP.ESurface.SURF_TRANS33) == CQ2BSP.ESurface.SURF_TRANS33
                | (_SModel.texinfo[surf.texinfo].flags & CQ2BSP.ESurface.SURF_TRANS66) == CQ2BSP.ESurface.SURF_TRANS66
                | (_SModel.texinfo[surf.texinfo].flags & CQ2BSP.ESurface.SURF_WARP) == CQ2BSP.ESurface.SURF_WARP
                )
            {
                CMain.Error(CMain.EErrorParm.ERR_WARNING, "BuildLightMap called for non-lit surface");
            }

            smax = (surf.extents[0] >> 4) + 1;
            tmax = (surf.extents[1] >> 4) + 1;
            size = smax * tmax;

            if (size > ((sizeof(float) * s_blocklights.Length) >> 4))
                CMain.Error(CMain.EErrorParm.ERR_WARNING, "Bad s_blocklights size");

            // set to full bright if no light data
            if (surf.samples == -1)
            {
                for (int i = 0; i < size * 3; i++)
                {
                    s_blocklights[i] = 255;
                }

                for (int maps = 0; maps < CQ2BSP.MAXLIGHTMAPS && surf.styles[maps] != 255; maps++)
                {
                    style = CClient.cl.RefDef.lightstyles[surf.styles[maps]];
                }

                goto store;
            }

            // count the # of maps
            for (nummaps = 0; nummaps < CQ2BSP.MAXLIGHTMAPS && surf.styles[nummaps] != 255; nummaps++) ;

            lightmap = surf.samples;

            // add all the lightmaps
            if (nummaps == 1)
            {
                scale = new float[3];

                for (int maps = 0; maps < CQ2BSP.MAXLIGHTMAPS && surf.styles[maps] != 255; maps++)
                {
                    bl = s_blocklights;
                    bl_pos = 0;

                    for (int i = 0; i < 3; i++)
                    {
                        scale[i] = modulate * CClient.cl.RefDef.lightstyles[surf.styles[maps]].rgb[i];
                    }

                    if (scale[0] == 1.0f && scale[1] == 1.0f && scale[2] == 1.0f)
                    {
                        for (int i = 0; i < size; i++, bl_pos += 3)
                        {
                            bl[bl_pos + 0] = _SModel.lightdata[lightmap + (i * 3) + 0];
                            bl[bl_pos + 1] = _SModel.lightdata[lightmap + (i * 3) + 1];
                            bl[bl_pos + 2] = _SModel.lightdata[lightmap + (i * 3) + 2];
                        }
                    }
                    else
                    {
                        for (int i = 0; i < size; i++, bl_pos += 3)
                        {
                            bl[bl_pos + 0] = _SModel.lightdata[lightmap + (i * 3) + 0] * scale[0];
                            bl[bl_pos + 1] = _SModel.lightdata[lightmap + (i * 3) + 1] * scale[1];
                            bl[bl_pos + 2] = _SModel.lightdata[lightmap + (i * 3) + 2] * scale[2];
                        }
                    }

                    // skip to next lightmap
                    lightmap += size * 3;
                }
            }
            else
            {
                scale = new float[3];

                for (int i = 0; i < (sizeof(float) * size * 3); i++)
                {
                    s_blocklights[i] = 0;
                }

                for (int maps = 0; maps < CQ2BSP.MAXLIGHTMAPS && surf.styles[maps] != 255; maps++)
                {
                    bl = s_blocklights;
                    bl_pos = 0;

                    for (int i = 0; i < 3; i++)
                    {
                        scale[i] = modulate * CClient.cl.RefDef.lightstyles[surf.styles[maps]].rgb[i];
                    }

                    if (scale[0] == 1.0f && scale[1] == 1.0f && scale[2] == 1.0f)
                    {
                        for (int i = 0; i < size; i++, bl_pos += 3)
                        {
                            bl[bl_pos + 0] += _SModel.lightdata[lightmap + (i * 3) + 0];
                            bl[bl_pos + 1] += _SModel.lightdata[lightmap + (i * 3) + 1];
                            bl[bl_pos + 2] += _SModel.lightdata[lightmap + (i * 3) + 2];
                        }
                    }
                    else
                    {
                        for (int i = 0; i < size; i++, bl_pos += 3)
                        {
                            bl[bl_pos + 0] += _SModel.lightdata[lightmap + (i * 3) + 0] * scale[0];
                            bl[bl_pos + 1] += _SModel.lightdata[lightmap + (i * 3) + 1] * scale[1];
                            bl[bl_pos + 2] += _SModel.lightdata[lightmap + (i * 3) + 2] * scale[2];
                        }
                    }

                    // skip to next lightmap
                    lightmap += size * 3;
                }
            }

            // add all the dynamic lights
            //if (surf.dlightframe == CMain.r_framecount)
            //    R_AddDynamicLights(surf);

            // put into texture format
            store:
            stride -= (smax << 2);
            bl = s_blocklights;
            bl_pos = 0;

            for (int i = 0; i < tmax; i++, dest_pos += stride)
            {
                for (int j = 0; j < smax; j++)
                {
                    r = Convert.ToInt32(bl[bl_pos + 0]);
                    g = Convert.ToInt32(bl[bl_pos + 1]);
                    b = Convert.ToInt32(bl[bl_pos + 2]);

                    // catch negative lights
                    if (r < 0)
                        r = 0;
                    if (g < 0)
                        g = 0;
                    if (b < 0)
                        b = 0;

                    // determine the brightest of the three color components
                    if (r > g)
                        max = r;
                    else
                        max = g;
                    if (b > max)
                        max = b;

                    // alpha is ONLY used for the mono lightmap case.  For this reason
                    // we set it to the brightest of the color components so that
                    // things don't get too dim.
                    a = max;

                    // rescale all the color components if the intensity of the greatest
                    // channel exceeds 1.0
                    if (max > 255)
                    {
                        float t = 255.0f / max;

                        r = (int)(r * t);
                        g = (int)(g * t);
                        b = (int)(b * t);
                        a = (int)(a * t);
                    }

                    dest[dest_pos + 0] = (byte)r;
                    dest[dest_pos + 1] = (byte)g;
                    dest[dest_pos + 2] = (byte)b;
                    dest[dest_pos + 3] = (byte)a;

                    bl_pos += 3;
                    dest_pos += 4;
                }
            }
        }
Example #22
0
        private void Mod_LoadEdges(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<CModel.SMEdge> MEdge = new List<CModel.SMEdge>();

            br.BaseStream.Seek(header.lumps[LUMP_EDGES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_EDGES].fileofs + header.lumps[LUMP_EDGES].filelen))
            {
                CModel.SMEdge _MEdge;

                _MEdge.v = new ushort[2];
                _MEdge.v[0] = br.ReadUInt16();
                _MEdge.v[1] = br.ReadUInt16();

                _MEdge.cachededgeoffset = 0;

                MEdge.Add(_MEdge);
            }

            _SModel.numedges = MEdge.Count;
            _SModel.edges = MEdge.ToArray();
        }
Example #23
0
        /// <summary>
        /// BuildSurfaceIndex
        /// ------------------
        /// Convert the surface's vertex format from triangle fan to triangle list
        /// This is used to speed up surface warping by using an index buffer
        /// </summary>
        public void BuildSurfaceIndex(ref CModel.SMSurface surf)
        {
            List<int> ib;

            //if ((surf.flags & CModel.EMSurface.SURF_DRAWTURB) != CModel.EMSurface.SURF_DRAWTURB)
            //    return;

            ib = new List<int>();
            ib.Clear();

            for (int i = 0; i < surf.polys.Length; i++)
            {
                for (int j = 2; j < surf.polys[i].verts.Length; j++)
                {
                    ib.Add(surf.polys[i].verts[0].offset);
                    ib.Add(surf.polys[i].verts[j - 1].offset);
                    ib.Add(surf.polys[i].verts[j].offset);
                }
            }

            surf.ibData = ib.ToArray();

            // setup the index buffer
            if (CProgram.gQ2Game.gGraphicsDevice.GraphicsProfile == GraphicsProfile.HiDef)
            {
                surf.ibSurface = new IndexBuffer(CProgram.gQ2Game.gGraphicsDevice, IndexElementSize.ThirtyTwoBits /*typeof(int)*/, surf.ibData.Length, BufferUsage.WriteOnly);
                surf.ibSurface.SetData(surf.ibData);
            }
            else
            {
                short[] ibData16 = new short[surf.ibData.Length];

                for (int i = 0; i < surf.ibData.Length; i++)
                    ibData16[i] = (short)surf.ibData[i];

                surf.ibSurface = new IndexBuffer(CProgram.gQ2Game.gGraphicsDevice, IndexElementSize.SixteenBits, ibData16.Length, BufferUsage.WriteOnly);
                surf.ibSurface.SetData(ibData16);
            }

            //surf.ibSurface.SetData(surf.ibData);
        }
Example #24
0
        private void Mod_LoadEntityString(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            if (header.lumps[LUMP_ENTITIES].filelen > MAX_MAP_ENTSTRING)
            {
                // entity string exceeds maximum
                _SModel.map_entitystring = null;
                return;
            }

            br.BaseStream.Seek(header.lumps[LUMP_ENTITIES].fileofs, System.IO.SeekOrigin.Begin);
            if (br.BaseStream.Position < (header.lumps[LUMP_ENTITIES].fileofs + header.lumps[LUMP_ENTITIES].filelen))
            {
                _SModel.map_entitystring = CShared.Com_ToString(br.ReadChars(header.lumps[LUMP_ENTITIES].filelen));
                _SModel.map_entitystring = _SModel.map_entitystring.Replace("\r", "").Replace("\n", "\r\n");
            }
            else
            {
                _SModel.map_entitystring = null;
            }
        }
Example #25
0
        /// <summary>
        /// CreateSurfaceLightmap
        /// ---------------------
        /// Creates a lightmap surface
        /// </summary>
        public void CreateSurfaceLightmap(CModel.SModel _SModel, ref CModel.SMSurface surf)
        {
            int smax;
            int tmax;
            int bytepos;

            if (
                (surf.flags & CModel.EMSurface.SURF_DRAWSKY) == CModel.EMSurface.SURF_DRAWSKY
                | (surf.flags & CModel.EMSurface.SURF_DRAWTURB) == CModel.EMSurface.SURF_DRAWTURB
                )
            {
                return;
            }

            smax = (surf.extents[0] >> 4) + 1;
            tmax = (surf.extents[1] >> 4) + 1;

            if (LM_AllocBlock(smax, tmax, ref surf.light_s, ref surf.light_t) == false)
            {
                LM_UploadBlock(false);
                LM_InitBlock();

                if (LM_AllocBlock(smax, tmax, ref surf.light_s, ref surf.light_t) == false)
                    CMain.Error(CMain.EErrorParm.ERR_FATAL, "Consecutive calls to LM_AllocBlock(" + smax + "," + tmax + ") failed\n");
            }

            surf.lightmaptexturenum = CProgram.gQ2Game.gCMain.gCImage.current_lightmap_texture;

            bytepos = (surf.light_t * BLOCK_WIDTH + surf.light_s) * LIGHTMAP_BYTES;

            CProgram.gQ2Game.gCMain.gCLight.SetCacheState(ref surf);
            CProgram.gQ2Game.gCMain.gCLight.BuildLightMap(_SModel, ref surf, bytepos, ref lms.lightmap_buffer, BLOCK_WIDTH * LIGHTMAP_BYTES);
        }
Example #26
0
        private void Mod_LoadFaces(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<SDFace> DFace = new List<SDFace>();
            List<CModel.SMSurface> MSurface = new List<CModel.SMSurface>();

            br.BaseStream.Seek(header.lumps[LUMP_FACES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_FACES].fileofs + header.lumps[LUMP_FACES].filelen))
            {
                SDFace _DFace;

                _DFace.planenum = br.ReadUInt16();
                _DFace.side = br.ReadInt16();

                _DFace.firstedge = br.ReadInt32();
                _DFace.numedges = br.ReadInt16();
                _DFace.texinfo = br.ReadInt16();

                _DFace.styles = br.ReadBytes(MAXLIGHTMAPS);
                _DFace.lightofs = br.ReadInt32();

                DFace.Add(_DFace);
            }

            CProgram.gQ2Game.gCMain.gCSurface.BeginBuildingLightmaps(ref _SModel);

            for (int i = 0; i < DFace.Count; i++)
            {
                CModel.SMSurface _MSurface;
                int side;
                short ti;

                _MSurface.firstedge = DFace[i].firstedge;
                _MSurface.numedges = DFace[i].numedges;
                _MSurface.flags = 0;
                _MSurface.polys = null;
                _MSurface.ibSurface = null;
                _MSurface.ibData = null;

                side = DFace[i].side;
                if (side != 0)
                    _MSurface.flags |= CModel.EMSurface.SURF_PLANEBACK;

                _MSurface.plane = DFace[i].planenum;

                _MSurface.plane2 = new Microsoft.Xna.Framework.Plane();

                ti = DFace[i].texinfo;
                if (ti < 0 || ti >= _SModel.numtexinfo)
                    CMain.Error(CMain.EErrorParm.ERR_WARNING, "MOD_LoadBmodel: bad texinfo number");
                _MSurface.texinfo = ti;

                _MSurface.bounds = CLocal.ClearBounds();

                _MSurface.boundsMid.X = 0.0f;
                _MSurface.boundsMid.Y = 0.0f;
                _MSurface.boundsMid.Z = 0.0f;

                _MSurface.lightIndex = null;
                _MSurface.lightLength = null;

                _MSurface.texturechain = 0;
                _MSurface.visframe = 0;

                // lighting info
                _MSurface.dlightframe = 0;
                _MSurface.dlightbits = 0;
                _MSurface.lightmaptexturenum = 0;
                _MSurface.styles = new byte[MAXLIGHTMAPS];
                for (int j = 0; j < MAXLIGHTMAPS; j++)
                {
                    _MSurface.styles[j] = DFace[i].styles[j];
                }

                _MSurface.cached_light = null;
                _MSurface.samples = DFace[i].lightofs;

                _MSurface.light_s = 0;
                _MSurface.light_t = 0;
                _MSurface.dlight_s = 0;
                _MSurface.dlight_t = 0;

                _MSurface.extents = null;
                _MSurface.texturemins = null;
                CModel.CalcSurfaceExtents(ref _SModel, ref _MSurface);

                // set the drawing flags
                if ((_SModel.texinfo[_MSurface.texinfo].flags & ESurface.SURF_WARP) == ESurface.SURF_WARP)
                {
                    _MSurface.flags |= CModel.EMSurface.SURF_DRAWTURB;

                    for (int j = 0; j < 2; j++)
                    {
                        _MSurface.extents[j] = 16384;
                        _MSurface.texturemins[j] = -8192;
                    }

                    // TODO
                    // cut up polygon for warps
                    //SubdivideSurface(i, ref _WorldModel.mfaces[i]);
                    //SubdivideSurface (out);
                }

                // create lightmaps and polygons
                if (
                    (_SModel.texinfo[_MSurface.texinfo].flags & ESurface.SURF_SKY) != ESurface.SURF_SKY
                    && (_SModel.texinfo[_MSurface.texinfo].flags & ESurface.SURF_TRANS33) != ESurface.SURF_TRANS33
                    && (_SModel.texinfo[_MSurface.texinfo].flags & ESurface.SURF_TRANS66) != ESurface.SURF_TRANS66
                    && (_SModel.texinfo[_MSurface.texinfo].flags & ESurface.SURF_WARP) != ESurface.SURF_WARP
                    )
                {
                    CProgram.gQ2Game.gCMain.gCSurface.CreateSurfaceLightmap(_SModel, ref _MSurface);
                }

                if ((_SModel.texinfo[_MSurface.texinfo].flags & ESurface.SURF_WARP) == ESurface.SURF_WARP)
                    CProgram.gQ2Game.gCMain.gCSurface.BuildPolygonFromSurface(ref _MSurface);

                MSurface.Add(_MSurface);
            }

            CProgram.gQ2Game.gCMain.gCSurface.EndBuildingLightmaps(ref _SModel);

            _SModel.numsurfaces = MSurface.Count;
            _SModel.surfaces = MSurface.ToArray();
        }
Example #27
0
        /// <summary>
        /// SubdividePolygon
        /// ----------------
        /// Breaks a polygon up along axial 64 unit boundaries
        /// so that turbulent and sky warps can be done reasonably.
        /// </summary>
        public void SubdividePolygon(CModel.SMSurface surf, ref List<CModel.SGLPoly> polys, int numverts, float[] verts)
        {
            float[] mins, maxs, dist;
            float m;
            float frac;
            int i, j, k, v;
            float[] Front, Back;
            int f, b;
            CModel.SGLPoly poly;
            Vector3 total;
            float total_s;
            float total_t;

            mins = new float[3];
            maxs = new float[3];
            dist = new float[64];

            Front = new float[64 * 3];
            Back = new float[64 * 3];

            if (numverts > 60)
                CMain.Error(CMain.EErrorParm.ERR_WARNING, "(error) numverts = " + numverts);

            // Bind mins and maxs
            BoundPoly(numverts, verts, ref mins, ref maxs);

            for (i = 0; i < 3; i++)
            {
                m = (mins[i] + maxs[i]) * 0.5f;
                m = SUBDIVIDE_SIZE * (float)Math.Floor(m / (float)SUBDIVIDE_SIZE + 0.5f);

                if (maxs[i] - m < 8)
                    continue;
                if (m - mins[i] < 8)
                    continue;

                // cut it
                v = i;
                for (j = 0; j < numverts; j++, v += 3)
                {
                    dist[j] = verts[v] - m;
                }

                // wrap cases
                dist[j] = dist[0];
                v -= i;
                verts[v + 0] = verts[0 + 0];
                verts[v + 1] = verts[0 + 1];
                verts[v + 2] = verts[0 + 2];

                f = 0;
                b = 0;
                v = 0;
                for (j = 0; j < numverts; j++, v += 3)
                {
                    if (dist[j] >= 0)
                    {
                        Front[(f * 3) + 0] = verts[v + 0];
                        Front[(f * 3) + 1] = verts[v + 1];
                        Front[(f * 3) + 2] = verts[v + 2];
                        f++;
                    }
                    if (dist[j] <= 0)
                    {
                        Back[(b * 3) + 0] = verts[v + 0];
                        Back[(b * 3) + 1] = verts[v + 1];
                        Back[(b * 3) + 2] = verts[v + 2];
                        b++;
                    }

                    if (dist[j] == 0 || dist[j + 1] == 0)
                        continue;

                    if ((dist[j] > 0) != (dist[j + 1] > 0))
                    {
                        // clip point
                        frac = dist[j] / (dist[j] - dist[j + 1]);

                        for (k = 0; k < 3; k++)
                        {
                            Front[(f * 3) + k] = Back[(b * 3) + k] = verts[v + k] + frac * (verts[3 + v + k] - verts[v + k]);
                        }
                        f++;
                        b++;
                    }
                }

                SubdividePolygon(surf, ref polys, f, Front);
                SubdividePolygon(surf, ref polys, b, Back);

                return;
            }

            // add a point in the center to help keep warp valid
            poly.next = 0;
            poly.chain = 0;
            poly.numverts = numverts + 2;
            poly.verts = new CModel.SPolyVerts[poly.numverts];

            total = Vector3.Zero;
            total_s = 0.0f;
            total_t = 0.0f;

            v = 0;
            for (i = 0; i < numverts; i++, v += 3)
            {
                float s;
                float t;
                Vector3 vec0;
                Vector3 vec1;

                poly.verts[i + 1].vertex.Position.X = verts[v + 0];
                poly.verts[i + 1].vertex.Position.Y = verts[v + 1];
                poly.verts[i + 1].vertex.Position.Z = verts[v + 2];

                vec0.X = CQ2BSP.SWorldData.texinfo[surf.texinfo].vecs[0].X;
                vec0.Y = CQ2BSP.SWorldData.texinfo[surf.texinfo].vecs[0].Y;
                vec0.Z = CQ2BSP.SWorldData.texinfo[surf.texinfo].vecs[0].Z;
                vec1.X = CQ2BSP.SWorldData.texinfo[surf.texinfo].vecs[1].X;
                vec1.Y = CQ2BSP.SWorldData.texinfo[surf.texinfo].vecs[1].Y;
                vec1.Z = CQ2BSP.SWorldData.texinfo[surf.texinfo].vecs[1].Z;

                s = Vector3.Dot(poly.verts[i + 1].vertex.Position, vec0);
                t = Vector3.Dot(poly.verts[i + 1].vertex.Position, vec1);

                total_s += s;
                total_t += t;
                total.X += verts[v + 0];
                total.Y += verts[v + 1];
                total.Z += verts[v + 2];

                poly.verts[i + 1].vertex.TextureCoordinate.X = s;
                poly.verts[i + 1].vertex.TextureCoordinate.Y = t;

                poly.verts[i + 1].vertex.LightmapCoordinate.X = 0.0f;
                poly.verts[i + 1].vertex.LightmapCoordinate.Y = 0.0f;

                poly.verts[i + 1].vertex.Normal.X = 0.0f;
                poly.verts[i + 1].vertex.Normal.Y = 0.0f;
                poly.verts[i + 1].vertex.Normal.Z = 0.0f;
            }

            CShared.VectorScale(total, (1.0f / numverts), ref poly.verts[0].vertex.Position);
            poly.verts[0].vertex.TextureCoordinate.X = total_s / numverts;
            poly.verts[0].vertex.TextureCoordinate.Y = total_t / numverts;

            // copy first vertex to last
            poly.verts[i + 1] = poly.verts[1];

            // insert centered point at first index
            polys.Insert(0, poly);
        }
Example #28
0
        private void Mod_LoadLighting(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            if (header.lumps[LUMP_LIGHTING].filelen == 0)
            {
                _SModel.lightdata = null;
                return;
            }

            br.BaseStream.Seek(header.lumps[LUMP_LIGHTING].fileofs, System.IO.SeekOrigin.Begin);
            _SModel.lightdata = br.ReadBytes(header.lumps[LUMP_LIGHTING].filelen);
        }
Example #29
0
        private void Mod_LoadMarksurfaces(SDHeader header, ref CModel.SModel _SModel, ref System.IO.BinaryReader br)
        {
            List<int> MarkSurface = new List<int>();

            br.BaseStream.Seek(header.lumps[LUMP_LEAFFACES].fileofs, System.IO.SeekOrigin.Begin);
            while (br.BaseStream.Position < (header.lumps[LUMP_LEAFFACES].fileofs + header.lumps[LUMP_LEAFFACES].filelen))
            {
                int msurf = br.ReadInt16();

                if (msurf < 0 || msurf >= _SModel.numsurfaces)
                    CMain.Error(CMain.EErrorParm.ERR_FATAL, "Mod_ParseMarksurfaces: bad surface number");

                MarkSurface.Add(msurf);
            }

            _SModel.nummarksurfaces = MarkSurface.Count;
            _SModel.marksurfaces = MarkSurface.ToArray();
        }
Example #30
0
        /// <summary>
        /// MarkSurfaceSetup
        /// ----------------
        /// Sort surfaces according to texture
        /// </summary>
        public bool MarkSurfaceSetupStatic(ref CModel.SModel _SModel)
        {
            List<int> indices;

            if (_SModel.MarkSurfaceListStatic == null)
                return false;

            if (_SModel.MarkSurfaceListStatic.Count == 0)
                return false;

            // build lightmap/texture/surface chains
            _SModel.lSChainLightmap = new List<SChainLightmap>();
            for (int i = 0; i < _SModel.MarkSurfaceListStatic.Count; i++)
            {
                int idxLightmap = -1;
                int idxTexture = -1;
                int idxSurface = -1;

                // check for lightmap modification
                gCLight.LightmapAnimation(_SModel.MarkSurfaceListStatic[i].surf);

                // generate lightmap list
                for (int j = 0; j < _SModel.lSChainLightmap.Count; j++)
                {
                    if (_SModel.lSChainLightmap[j].lightmaptexturenum == _SModel.MarkSurfaceListStatic[i].lightmaptexturenum)
                    {
                        idxLightmap = j;
                        break;
                    }
                }

                if (idxLightmap == -1)
                {
                    SChainLightmap _SCLM;
                    _SCLM.lightmaptexturenum = _SModel.MarkSurfaceListStatic[i].lightmaptexturenum;
                    _SCLM.TexInfo = new List<SChainTexture>();

                    _SModel.lSChainLightmap.Add(_SCLM);
                    idxLightmap = _SModel.lSChainLightmap.Count - 1;
                }

                // generate texinfo list
                SChainLightmap _SChainLightmap = _SModel.lSChainLightmap[idxLightmap];
                for (int j = 0; j < _SChainLightmap.TexInfo.Count; j++)
                {
                    if (_SChainLightmap.TexInfo[j].texinfo == _SModel.MarkSurfaceListStatic[i].texinfo)
                    {
                        idxTexture = j;
                        break;
                    }
                }

                if (idxTexture == -1)
                {
                    SChainTexture _SCT;
                    _SCT.texinfo = _SModel.MarkSurfaceListStatic[i].texinfo;
                    _SCT.surf = new List<int>();

                    _SChainLightmap.TexInfo.Add(_SCT);
                    idxTexture = _SChainLightmap.TexInfo.Count - 1;
                }
                _SModel.lSChainLightmap[idxLightmap] = _SChainLightmap;

                // generate surface list
                SChainTexture _SChainTexture = _SModel.lSChainLightmap[idxLightmap].TexInfo[idxTexture];
                for (int j = 0; j < _SChainTexture.surf.Count; j++)
                {
                    if (_SChainTexture.surf[j] == _SModel.MarkSurfaceListStatic[i].surf)
                    {
                        idxSurface = j;
                        break;
                    }
                }

                if (idxSurface == -1)
                {
                    _SChainTexture.surf.Add(_SModel.MarkSurfaceListStatic[i].surf);
                    idxSurface = _SChainTexture.surf.Count - 1;
                }

                _SModel.lSChainLightmap[idxLightmap].TexInfo[idxTexture] = _SChainTexture;
            }

            // build cluster-based index buffer
            indices = new List<int>();
            for (int i = 0; i < _SModel.lSChainLightmap.Count; i++)
            {
                for (int j = 0; j < _SModel.lSChainLightmap[i].TexInfo.Count; j++)
                {
                    int[] idx1;
                    int[] idx2;
                    int lm = _SModel.lSChainLightmap[i].lightmaptexturenum;
                    int tx = _SModel.lSChainLightmap[i].TexInfo[j].texinfo;
                    bool isEqual = true;

                    indices.Clear();

                    for (int k = 0; k < _SModel.lSChainLightmap[i].TexInfo[j].surf.Count; k++)
                    {
                        int[] idx = gCSurface.BuildSurfaceIndex(CQ2BSP.SWorldData.surfaces[_SModel.lSChainLightmap[i].TexInfo[j].surf[k]]);

                        if (idx == null)
                            continue;

                        for (int l = 0; l < idx.Length; l++)
                        {
                            indices.Add(idx[l]);
                        }
                    }

                    idx1 = indices.ToArray();
                    idx2 = _SModel.ibWorldSolid[lm, tx].ibIndices;

                    if (idx2 != null)
                    {
                        if (idx1.Length == idx2.Length)
                        {
                            for (int k = 0; k < idx1.Length; k++)
                            {
                                if (idx1[k] != idx2[k])
                                {
                                    isEqual = false;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            isEqual = false;
                        }
                    }
                    else
                    {
                        isEqual = false;
                    }

                    // re-build the index buffer the indices doesn't match
                    if(isEqual == false)
                    {
                        _SModel.ibWorldSolid[lm, tx].ibIndices = new int[idx1.Length];
                        for (int k = 0; k < idx1.Length; k++)
                        {
                            _SModel.ibWorldSolid[lm, tx].ibIndices[k] = idx1[k];
                        }
                        _SModel.ibWorldSolid[lm, tx].PrimitiveCount = _SModel.ibWorldSolid[lm, tx].ibIndices.Length / 3;

                        if (_SModel.ibWorldSolid[lm, tx].ibBuffer.IndexCount < idx1.Length)
                        {
                            _SModel.ibWorldSolid[lm, tx].ibBuffer.Dispose();
                            _SModel.ibWorldSolid[lm, tx].ibBuffer = null;

                            if (CProgram.gQ2Game.gGraphicsDevice.GraphicsProfile == GraphicsProfile.HiDef)
                                _SModel.ibWorldSolid[lm, tx].ibBuffer = new IndexBuffer(CProgram.gQ2Game.gGraphicsDevice, IndexElementSize.ThirtyTwoBits, idx1.Length, BufferUsage.WriteOnly);
                            else
                                _SModel.ibWorldSolid[lm, tx].ibBuffer = new IndexBuffer(CProgram.gQ2Game.gGraphicsDevice, IndexElementSize.SixteenBits, idx1.Length, BufferUsage.WriteOnly);
                        }

                        if (CProgram.gQ2Game.gGraphicsDevice.GraphicsProfile == GraphicsProfile.HiDef)
                        {
                            _SModel.ibWorldSolid[lm, tx].ibBuffer.SetData(_SModel.ibWorldSolid[lm, tx].ibIndices);
                        }
                        else
                        {
                            short[] ibData16 = new short[_SModel.ibWorldSolid[lm, tx].ibIndices.Length];

                            for (int k = 0; k < _SModel.ibWorldSolid[lm, tx].ibIndices.Length; k++)
                                ibData16[k] = (short)_SModel.ibWorldSolid[lm, tx].ibIndices[k];

                            _SModel.ibWorldSolid[lm, tx].ibBuffer.SetData(ibData16);
                        }
                    }
                }
            }

            indices.Clear();
            indices = null;

            return true;
        }