get ready for public release

Author: markus-wa

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Saiko Technology Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,6 +1,45 @@
 # bsp-tracer
 
-BSP (Source Engine Map) Ray Tracer / Ray Caster Library
+BSP (Source Engine Map) Ray Tracer / Ray Caster Library.
+
+Allows to do static / out-of-engine visibility checks and ray casting on BSP map files.<br>
+Can be used to get more accurate visibility info between players than there is available in CS:GO demos/replays (.dem files).
+
+## Features
+
+- [x] Faces (basic map geometry)
+- [x] Brushes (walls / level shape)
+- [x] Static Props (boxes, barrels, etc.)
+- [ ] Displacements (terrain bumps and slopes)
+- [ ] Entities ("dynamic" props - doors, vents, etc.)
+
+## Example
+
+```go
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-gl/mathgl/mgl32"
+	"github.com/saiko-tech/bsp-tracer/pkg/bsptracer"
+)
+
+func main() {
+	csgoDir := os.Getenv("CSGO_DIR") // should point to "SteamLibrary/steamapps/common/Counter-Strike Global Offensive"
+
+	m, err := bsptracer.LoadMapFromFileSystem(csgoDir+"/csgo/maps/de_cache.bsp", csgoDir+"/csgo/pak01", csgoDir+"/platform/platform_pak01")
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println("A site -> A site, open:", m.IsVisible(mgl32.Vec3{-12, 1444, 1751}, mgl32.Vec3{-233, 1343, 1751})) // true
+	fmt.Println("T spawn -> A site:", m.IsVisible(mgl32.Vec3{3306, 431, 1723}, mgl32.Vec3{-233, 1343, 1751}))      // false
+	fmt.Println("mid through box:", m.IsVisible(mgl32.Vec3{-94, 452, 1677}, mgl32.Vec3{138, 396, 1677}))           // false
+	fmt.Println("T spawn -> T spawn:", m.IsVisible(mgl32.Vec3{3306, 431, 1723}, mgl32.Vec3{3300, 400, 1720}))      // true
+}
+```
 
 ## Development
 
@@ -14,4 +53,6 @@ Follows https://github.com/golang-standards/project-layout
 
 ## Acknowledgements
 
-- This is a port of https://github.com/ReactiioN1337/valve-bsp-parser
+- This library is based on the C++ [valve-bsp-parser](https://github.com/ReactiioN1337/valve-bsp-parser) by [@ReactiioN1337](https://github.com/ReactiioN1337)
+- Thanks to [@jangler](https://github.com/jangler) for porting the C++ library to Go
+- Thanks to [@Galaco](https://github.com/Galaco) for creating Go tooling for the BSP file format & source engine

pkg/bsptracer/bsptracer.go

@@ -18,6 +18,8 @@ import (
 	"github.com/galaco/vpk2"
 	"github.com/go-gl/mathgl/mgl32"
 	"github.com/pkg/errors"
+
+	"github.com/saiko-tech/bsp-tracer/pkg/bsptracer/mollertrumbore"
 )
 
 const (
@@ -48,24 +50,7 @@ type Map struct {
 	entities          []map[string]string // TODO: not yet sure if we'll need this
 	polygons          []polygon
 	models            []*studiomodel.StudioModel // TODO: place props in the world and trace against them
-	staticPropsByLeaf map[uint16][]*studiomodel.StudioModel
-}
-
-func staticPropsByLeaf(bspfile *bsp.Bsp, models []*studiomodel.StudioModel) map[uint16][]*studiomodel.StudioModel {
-	res := make(map[uint16][]*studiomodel.StudioModel)
-
-	gameLump := bspfile.Lump(bsp.LumpGame).(*lumps.Game).GetData()
-	spLump := gameLump.GetStaticPropLump()
-
-	for _, p := range spLump.PropLumps {
-		leafIndices := spLump.LeafLump.Leaf[p.GetFirstLeaf() : p.GetFirstLeaf()+p.GetLeafCount()]
-
-		for _, i := range leafIndices {
-			res[i] = append(res[i], models[p.GetPropType()])
-		}
-	}
-
-	return res
+	staticPropsByLeaf map[uint16][]staticProp
 }
 
 // LoadMap loads a map from a BSP file and VPKs.
@@ -196,6 +181,21 @@ func (m Map) rayCastNode(nodeIndex int32, startFraction, endFraction float32,
 			out.Brush = brush
 		}
 
+		for _, p := range m.staticPropsByLeaf[uint16(leafIndex)] {
+			for _, t := range p.triangles {
+				r := mollertrumbore.RayIntersectsTriangle(origin, destination, t)
+				if r.Hit {
+					out.Fraction = 0 // TODO: should not be 0, should be fraction of ray
+
+					return
+				}
+			}
+
+			// TODO: use bounding box if no phy and model is set up to fall back to bbox
+		}
+
+		// TODO: handle leaf displacements
+
 		if out.StartSolid || out.Fraction < 1 {
 			return
 		}
@@ -205,15 +205,6 @@ func (m Map) rayCastNode(nodeIndex int32, startFraction, endFraction float32,
 				origin, destination, out)
 		}
 
-		for _, p := range m.staticPropsByLeaf[uint16(leafIndex)] {
-			_ = p.Phy.Vertices
-			_ = p.Phy.TriangleFaces
-
-			// TODO: trace against triangle faces (build them up during map load)
-		}
-
-		// TODO: handle leaf displacements
-
 		return
 	}
 

pkg/bsptracer/bsptracer_test.go

@@ -1,62 +1,54 @@
-package bsptracer
+package bsptracer_test
 
 import (
 	"os"
 	"testing"
 
 	"github.com/go-gl/mathgl/mgl32"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/saiko-tech/bsp-tracer/pkg/bsptracer"
 )
 
-func TestBspTracer_NonExisting(t *testing.T) {
-	t.Parallel()
+// expects CS:GO to be installed in "$HOME/games/SteamLibrary/steamapps/common/Counter-Strike Global Offensive"
+func csgoDir(tb testing.TB) string {
+	tb.Helper()
 
-	_, err := LoadMapFromFileSystem("../../testdata/does_not_exist.bsp")
-	assert.NotNil(t, err)
+	userHome, err := os.UserHomeDir()
+	assert.NoError(tb, err)
+
+	return userHome + "/games/SteamLibrary/steamapps/common/Counter-Strike Global Offensive"
 }
 
-func TestBspTracer_BadFile(t *testing.T) {
+func TestBspTracer_NonExisting(t *testing.T) {
 	t.Parallel()
 
-	_, err := LoadMapFromFileSystem("./map_test.go")
+	_, err := bsptracer.LoadMapFromFileSystem("../../testdata/does_not_exist.bsp")
 	assert.NotNil(t, err)
 }
 
-func TestLoadMap_de_cache(t *testing.T) {
+func TestBspTracer_BadFile(t *testing.T) {
 	t.Parallel()
 
-	m, err := LoadMapFromFileSystem("../../testdata/de_cache.bsp")
-	assert.Error(t, err)
-	assert.ErrorAs(t, err, new(MissingModelsError))
-
-	assert.Equal(t, 5560, len(m.brushes))
-	assert.Equal(t, 39815, len(m.brushSides))
-	assert.Equal(t, 129415, len(m.edges))
-	assert.Equal(t, 24072, len(m.leafBrushes))
-	assert.Equal(t, 18843, len(m.leafFaces))
-	assert.Equal(t, 8906, len(m.leaves))
-	assert.Equal(t, 8648, len(m.nodes))
-	assert.Equal(t, 30626, len(m.planes))
-	assert.Equal(t, 23221, len(m.surfaces))
-	assert.Equal(t, 185200, len(m.surfEdges))
-	assert.Equal(t, 48496, len(m.vertices))
-	assert.Equal(t, 46442, len(m.polygons))
+	_, err := bsptracer.LoadMapFromFileSystem("./map_test.go")
+	assert.NotNil(t, err)
 }
 
 func TestMap_TraceRay_de_cache(t *testing.T) {
 	t.Parallel()
 
-	m, err := LoadMapFromFileSystem("../../testdata/de_cache.bsp")
-	assert.Error(t, err)
-	assert.ErrorAs(t, err, new(MissingModelsError))
+	csgoDir := csgoDir(t)
+
+	m, err := bsptracer.LoadMapFromFileSystem("../../testdata/de_cache.bsp", csgoDir+"/csgo/pak01", csgoDir+"/platform/platform_pak01")
+	assert.NoError(t, err)
 
 	type args struct {
 		origin      mgl32.Vec3
 		destination mgl32.Vec3
 	}
 	type out struct {
 		visible bool
-		trace   Trace
+		trace   bsptracer.Trace
 	}
 	tests := []struct {
 		name string
@@ -71,55 +63,57 @@ func TestMap_TraceRay_de_cache(t *testing.T) {
 			},
 			want: out{
 				visible: true,
-				trace:   Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{-233, 1343, 1751}},
+				trace:   bsptracer.Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{-233, 1343, 1751}},
 			},
 		},
 		{
 			name: "T spawn -> A site",
 			args: args{
-				mgl32.Vec3{3306, 431, 1723},
-				mgl32.Vec3{-233, 1343, 1751},
+				origin:      mgl32.Vec3{3306, 431, 1723},
+				destination: mgl32.Vec3{-233, 1343, 1751},
 			},
 			want: out{
 				visible: false,
-				trace:   Trace{AllSolid: true, StartSolid: true, FractionLeftSolid: 1, EndPos: mgl32.Vec3{3306, 431, 1723}, Contents: 1, NumBrushSides: 7},
+				trace:   bsptracer.Trace{AllSolid: true, StartSolid: true, FractionLeftSolid: 1, EndPos: mgl32.Vec3{3306, 431, 1723}, Contents: 1, NumBrushSides: 7},
 			},
 		},
 		{
 			name: "T spawn -> T spawn",
 			args: args{
-				mgl32.Vec3{3306, 431, 1723},
-				mgl32.Vec3{3303, 431, 1723},
+				origin:      mgl32.Vec3{3306, 431, 1723},
+				destination: mgl32.Vec3{3303, 431, 1723},
 			},
 			want: out{
 				visible: true,
-				trace:   Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{3303, 431, 1723}},
+				trace:   bsptracer.Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{3303, 431, 1723}},
 			},
 		},
 		{
 			name: "through door",
 			args: args{
-				mgl32.Vec3{207, 1948, 1751},
-				mgl32.Vec3{259, 2251, 1752},
+				origin:      mgl32.Vec3{207, 1948, 1751},
+				destination: mgl32.Vec3{259, 2251, 1752},
 			},
 			want: out{
-				visible: true,
-				trace:   Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{259, 2251, 1752}},
+				visible: false,
+				trace:   bsptracer.Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{259, 2251, 1752}},
 			},
 		},
 		{
 			name: "through mid box",
 			args: args{
-				mgl32.Vec3{-94, 452, 1677},
-				mgl32.Vec3{138, 396, 1677},
+				origin:      mgl32.Vec3{-94, 452, 1677},
+				destination: mgl32.Vec3{138, 396, 1677},
 			},
 			want: out{
-				visible: true,
-				trace:   Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{138, 396, 1677}},
+				visible: false,
+				trace:   bsptracer.Trace{AllSolid: true, StartSolid: true, Fraction: 1, EndPos: mgl32.Vec3{138, 396, 1677}},
 			},
 		},
 	}
 	for _, tt := range tests {
+		tt := tt
+
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
@@ -133,15 +127,24 @@ func TestMap_TraceRay_de_cache(t *testing.T) {
 	}
 }
 
-// expects CS:GO to be installed in "$HOME/games/SteamLibrary/steamapps/common/Counter-Strike Global Offensive"
 func TestLoadMap_de_cache_with_models(t *testing.T) {
 	t.Parallel()
 
-	userHome, err := os.UserHomeDir()
+	csgoDir := csgoDir(t)
+
+	_, err := bsptracer.LoadMapFromFileSystem("../../testdata/de_cache.bsp", csgoDir+"/csgo/pak01", csgoDir+"/platform/platform_pak01")
 	assert.NoError(t, err)
+}
 
-	csgoDir := userHome + "/games/SteamLibrary/steamapps/common/Counter-Strike Global Offensive"
+func BenchmarkTraceBox(b *testing.B) {
+	csgoDir := csgoDir(b)
 
-	_, err = LoadMapFromFileSystem("../../testdata/de_cache.bsp", csgoDir+"/csgo/pak01", csgoDir+"/platform/platform_pak01")
-	assert.NoError(t, err)
+	m, err := bsptracer.LoadMapFromFileSystem("../../testdata/de_cache.bsp", csgoDir+"/csgo/pak01", csgoDir+"/platform/platform_pak01")
+	assert.NoError(b, err)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		assert.False(b, m.IsVisible(mgl32.Vec3{-94, 452, 1677}, mgl32.Vec3{138, 396, 1677}))
+	}
 }

pkg/bsptracer/bsptracer_unit_test.go

@@ -0,0 +1,28 @@
+package bsptracer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLoadMap_de_cache(t *testing.T) {
+	t.Parallel()
+
+	m, err := LoadMapFromFileSystem("../../testdata/de_cache.bsp")
+	assert.Error(t, err)
+	assert.ErrorAs(t, err, new(MissingModelsError))
+
+	assert.Equal(t, 5560, len(m.brushes))
+	assert.Equal(t, 39815, len(m.brushSides))
+	assert.Equal(t, 129415, len(m.edges))
+	assert.Equal(t, 24072, len(m.leafBrushes))
+	assert.Equal(t, 18843, len(m.leafFaces))
+	assert.Equal(t, 8906, len(m.leaves))
+	assert.Equal(t, 8648, len(m.nodes))
+	assert.Equal(t, 30626, len(m.planes))
+	assert.Equal(t, 23221, len(m.surfaces))
+	assert.Equal(t, 185200, len(m.surfEdges))
+	assert.Equal(t, 48496, len(m.vertices))
+	assert.Equal(t, 46442, len(m.polygons))
+}

pkg/bsptracer/example_test.go

@@ -0,0 +1,33 @@
+package bsptracer_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/go-gl/mathgl/mgl32"
+
+	"github.com/saiko-tech/bsp-tracer/pkg/bsptracer"
+)
+
+func ExampleMap_IsVisible() {
+	csgoDir := os.Getenv("CSGO_DIR") // should point to "SteamLibrary/steamapps/common/Counter-Strike Global Offensive"
+
+	m, err := bsptracer.LoadMapFromFileSystem(csgoDir+"/csgo/maps/de_cache.bsp", csgoDir+"/csgo/pak01", csgoDir+"/platform/platform_pak01")
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println("A site -> A site, open:", m.IsVisible(mgl32.Vec3{-12, 1444, 1751}, mgl32.Vec3{-233, 1343, 1751})) // true
+	fmt.Println("T spawn -> A site:", m.IsVisible(mgl32.Vec3{3306, 431, 1723}, mgl32.Vec3{-233, 1343, 1751}))      // false
+	fmt.Println("mid through box:", m.IsVisible(mgl32.Vec3{-94, 452, 1677}, mgl32.Vec3{138, 396, 1677}))           // false
+	fmt.Println("T spawn -> T spawn:", m.IsVisible(mgl32.Vec3{3306, 431, 1723}, mgl32.Vec3{3300, 400, 1720}))      // true
+}
+
+func TestExample(t *testing.T) {
+	csgoDir := csgoDir(t)
+
+	t.Setenv("CSGO_DIR", csgoDir)
+
+	ExampleMap_IsVisible()
+}