Beispiel #1
0
//imports an obj from a filePath and return a Geometry
func ImportObj(filePath string) (geometry *renderer.Geometry, material *renderer.Material, err error) {

	obj := &objData{Indicies: make([]uint32, 0, 0), Vertices: make([]float32, 0, 0)}
	vertexList := make([]float32, 0, 0)
	uvList := make([]float32, 0, 0)
	normalList := make([]float32, 0, 0)

	//split the file name from the file path
	filePathTokens := strings.Split(strings.Replace(filePath, "\\", "/", -1), "/")
	fileName := filePathTokens[len(filePathTokens)-1]
	path := strings.TrimRight(filePath, fileName)

	//open the file and read all lines
	file, err := os.Open(filePath)
	if err != nil {
		fmt.Printf("Error opening geometry file: %v\n", err)
		return
	}
	defer file.Close()

	var mtlErr error
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		tokens := strings.Fields(line)
		if len(tokens) > 0 {
			dataType := tokens[0]
			if dataType == "o" { //sub mesh
				obj.Name = tokens[1]
			} else if dataType == "v" { //xyz vertex
				vertexList = append(vertexList, stf(tokens[1]), stf(tokens[2]), stf(tokens[3]))
			} else if dataType == "vt" { //uv coord
				uvList = append(uvList, stf(tokens[1]), stf(tokens[2]))
			} else if dataType == "vn" { //xyz vertex normal
				normalList = append(normalList, stf(tokens[1]), stf(tokens[2]), stf(tokens[3]))
			} else if dataType == "f" { // v/t/n face
				obj.processFace(line, vertexList, uvList, normalList)
			} else if dataType == "mtllib" {
				obj.Mtl, mtlErr = importMTL(path, tokens[1])
			} else if dataType == "usemtl" { //mtl material
				//TODO: multiple mtls
			}
		}
	}

	geometry = renderer.CreateGeometry(obj.Indicies, obj.Vertices)
	if mtlErr == nil && obj.Mtl != nil {
		textures := []*renderer.Texture{}
		for key, img := range obj.Mtl.maps {
			textures = append(textures, renderer.NewTexture(key, img, true))
		}
		material = renderer.NewMaterial(textures...)
	}

	if err = scanner.Err(); err != nil {
		fmt.Printf("Error loading geometry: %v\n", err)
		return
	}
	return
}
Beispiel #2
0
func sparkParticles() *effects.ParticleSystem {
	img, _ := assets.ImportImageCached("TestAssets/Spark.png")
	smoke := effects.CreateParticleSystem(effects.ParticleSettings{
		MaxParticles:     7,
		ParticleEmitRate: 7,
		BaseGeometry:     renderer.CreateBox(float32(1), float32(1)),
		TotalFrames:      1,
		FramesX:          1,
		FramesY:          1,
		MaxLife:          1.0,
		MinLife:          0.7,
		StartColor:       color.NRGBA{255, 220, 180, 255},
		EndColor:         color.NRGBA{255, 155, 55, 255},
		StartSize:        mgl32.Vec3{1, 1, 1}.Mul(0.008),
		EndSize:          mgl32.Vec3{1, 1, 1}.Mul(0.005),
		MinTranslation:   mgl32.Vec3{1, 1, 1}.Mul(-0.04),
		MaxTranslation:   mgl32.Vec3{1, 1, 1}.Mul(0.04),
		MinStartVelocity: mgl32.Vec3{-0.5, 0.0, -0.5},
		MaxStartVelocity: mgl32.Vec3{0.5, 1.0, 0.5},
		Acceleration:     mgl32.Vec3{0.0, -1.0, 0.0},
		OnParticleUpdate: func(p *effects.Particle) {
			p.Scale[0] = p.Scale[0] * (1 + p.Velocity.Len()*3.5)
			p.Orientation = mgl32.QuatBetweenVectors(mgl32.Vec3{1, 0, 0}, p.Velocity)
		},
	})
	smoke.Node.Material = renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	return smoke
}
Beispiel #3
0
func sparkParticles() *effects.ParticleGroup {
	img, _ := assets.ImportImageCached("resources/spark.png")
	material := renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	particleSystem := effects.CreateParticleSystem(effects.ParticleSettings{
		MaxParticles:     80,
		ParticleEmitRate: 400,
		BaseGeometry:     renderer.CreateBox(float32(1), float32(1)),
		TotalFrames:      1,
		FramesX:          1,
		FramesY:          1,
		MaxLife:          3.3,
		MinLife:          1.7,
		StartColor:       color.NRGBA{254, 160, 90, 254},
		EndColor:         color.NRGBA{254, 160, 90, 254},
		StartSize:        mgl32.Vec2{2, 2}.Vec3(0),
		EndSize:          mgl32.Vec2{2, 2}.Vec3(0),
		MinTranslation:   mgl32.Vec2{-5, -5}.Vec3(0),
		MaxTranslation:   mgl32.Vec2{5, 5}.Vec3(0),
		MinStartVelocity: mgl32.Vec2{-100, -100}.Vec3(0),
		MaxStartVelocity: mgl32.Vec2{100, 100}.Vec3(0),
		Acceleration:     mgl32.Vec2{0, 400}.Vec3(0),
		OnParticleUpdate: func(p *effects.Particle) {
			p.Scale[0] = p.Scale[0] * (1 + p.Velocity.Len()*0.05)
			p.Orientation = mgl32.QuatBetweenVectors(mgl32.Vec3{1, 0, 0}, p.Velocity)
		},
	})
	particleSystem.FaceCamera = false
	particleGroup := effects.NewParticleGroup(nil, particleSystem)
	particleGroup.Node.Material = material
	return particleGroup
}
Beispiel #4
0
func fireParticles() *effects.ParticleSystem {
	img, _ := assets.ImportImageCached("TestAssets/Fire.png")
	fire := effects.CreateParticleSystem(effects.ParticleSettings{
		MaxParticles:     12,
		ParticleEmitRate: 3,
		BaseGeometry:     renderer.CreateBox(float32(1), float32(1)),
		TotalFrames:      36,
		FramesX:          6,
		FramesY:          6,
		MaxLife:          0.8,
		MinLife:          1.5,
		StartColor:       color.NRGBA{255, 180, 80, 255},
		EndColor:         color.NRGBA{255, 60, 20, 255},
		StartSize:        mgl32.Vec3{1, 1, 1}.Mul(0.16),
		EndSize:          mgl32.Vec3{1, 1, 1}.Mul(0.23),
		MinTranslation:   mgl32.Vec3{1, 1, 1}.Mul(-0.01),
		MaxTranslation:   mgl32.Vec3{1, 1, 1}.Mul(0.01),
		MinStartVelocity: mgl32.Vec3{-0.02, 0, -0.02},
		MaxStartVelocity: mgl32.Vec3{0.02, 0.08, 0.02},
		MinRotation:      3.0,
		MaxRotation:      3.6,
	})
	fire.Node.Material = renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	return fire
}
Beispiel #5
0
func dustParticles() *effects.ParticleGroup {
	img, _ := assets.ImportImageCached("resources/smoke.png")
	material := renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	particleSystem := effects.CreateParticleSystem(effects.ParticleSettings{
		MaxParticles:     5,
		ParticleEmitRate: 20,
		BaseGeometry:     renderer.CreateBox(float32(1), float32(1)),
		TotalFrames:      64,
		FramesX:          8,
		FramesY:          8,
		MaxLife:          3.3,
		MinLife:          2.7,
		StartColor:       color.NRGBA{254, 254, 254, 120},
		EndColor:         color.NRGBA{254, 254, 254, 0},
		StartSize:        mgl32.Vec2{40, 40}.Vec3(0),
		EndSize:          mgl32.Vec2{180, 180}.Vec3(0),
		MinTranslation:   mgl32.Vec2{-2, -2}.Vec3(0),
		MaxTranslation:   mgl32.Vec2{2, 2}.Vec3(0),
		MinStartVelocity: mgl32.Vec2{-5.0, -5.0}.Vec3(0),
		MaxStartVelocity: mgl32.Vec2{5.0, 5.0}.Vec3(0),
		MaxRotation:      -3.14,
		MinRotation:      3.14,
	})
	particleSystem.FaceCamera = false
	particleGroup := effects.NewParticleGroup(nil, particleSystem)
	particleGroup.Node.Material = material
	return particleGroup
}
Beispiel #6
0
func majicParticles() *effects.ParticleGroup {
	img, _ := assets.ImportImageCached("resources/majic.png")
	material := renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	particleSystem := effects.CreateParticleSystem(effects.ParticleSettings{
		MaxParticles:     300,
		ParticleEmitRate: 700,
		BaseGeometry:     renderer.CreateBox(float32(1), float32(1)),
		TotalFrames:      9,
		FramesX:          3,
		FramesY:          3,
		MaxLife:          1.3,
		MinLife:          0.7,
		StartColor:       color.NRGBA{254, 254, 254, 254},
		EndColor:         color.NRGBA{254, 254, 254, 254},
		StartSize:        mgl32.Vec2{10, 10}.Vec3(0),
		EndSize:          mgl32.Vec2{10, 10}.Vec3(0),
		MinTranslation:   mgl32.Vec2{-1, -1}.Vec3(0),
		MaxTranslation:   mgl32.Vec2{1, 1}.Vec3(0),
		MinStartVelocity: mgl32.Vec2{-170, -170}.Vec3(0),
		MaxStartVelocity: mgl32.Vec2{170, 170}.Vec3(0),
		MaxRotation:      -3.14,
		MinRotation:      3.14,
	})
	particleSystem.FaceCamera = false
	particleGroup := effects.NewParticleGroup(nil, particleSystem)
	particleGroup.Node.Material = material
	return particleGroup
}
Beispiel #7
0
func (e *Editor) initSelectSprite() {
	img, _ := assets.DecodeImage(bytes.NewBuffer(util.Base64ToBytes(GeometryIconData)))
	mat := renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	selectSprite := effects.CreateSprite(1, 1, 1, mat)
	spriteNode := renderer.NewNode()
	spriteNode.RendererParams = &renderer.RendererParams{Unlit: true}
	spriteNode.Add(selectSprite)
	e.selectSprite = selectSprite
	e.gameEngine.AddSpatialTransparent(spriteNode)
}
Beispiel #8
0
func NewCharacter() *Character {
	characterImg, _ := assets.ImportImageCached("resources/stickman.png")
	characterMat := renderer.NewMaterial(renderer.NewTexture("diffuseMap", characterImg, false))
	sprite := effects.CreateSprite(4, 4, 1, characterMat)
	sprite.FaceCamera = false
	sprite.SetScale(mgl32.Vec2{characterSize, characterSize}.Vec3(0))
	sprite.SetTranslation(mgl32.Vec2{400, 400}.Vec3(0))

	body := chipmunkPhysics.NewChipmunkBody(1, 1)
	circle := chipmunk.NewCircle(vect.Vector_Zero, float32(characterSize*0.5))
	body.Body.AddShape(circle)

	return &Character{
		body:   body,
		sprite: sprite,
	}
}
Beispiel #9
0
func NewWindow() *Window {
	node := renderer.NewNode()
	elementNode := renderer.NewNode()
	background := renderer.NewNode()
	background.Material = renderer.NewMaterial()
	box := renderer.CreateBoxWithOffset(1, 1, 0, 0)
	box.SetColor(color.NRGBA{255, 255, 255, 255})
	background.Add(box)
	node.Add(background)
	node.Add(elementNode)
	return &Window{
		node:          node,
		backgroundBox: box,
		background:    background,
		elementNode:   elementNode,
		size:          mgl32.Vec2{500, 1},
		Tabs:          []Activatable{},
	}
}
Beispiel #10
0
func NewContainer() *Container {
	node := renderer.NewNode()
	elementsNode := renderer.NewNode()
	background := renderer.NewNode()
	box := renderer.CreateBoxWithOffset(1, 1, 0, 0)
	box.SetColor(color.NRGBA{0, 0, 0, 0})
	background.Material = renderer.NewMaterial()
	background.Add(box)
	node.Add(background)
	node.Add(elementsNode)
	return &Container{
		node:          node,
		elementsNode:  elementsNode,
		background:    background,
		backgroundBox: box,
		children:      make([]Element, 0),
		Hitbox:        NewHitbox(),
		padding:       NewMargin(0),
		margin:        NewMargin(0),
	}
}
Beispiel #11
0
func NewTextField(text string, textColor color.Color, textSize float32, textFont *truetype.Font) *TextField {
	cursor := renderer.CreateBoxWithOffset(0.07, 1.1, 0, 0.1)
	cursor.SetColor(color.NRGBA{0, 0, 0, 255})
	cursorNode := renderer.NewNode()
	cursorNode.Material = renderer.NewMaterial()
	cursorNode.Add(cursor)
	tf := &TextField{
		container: NewContainer(),
		text:      NewTextElement(text, textColor, textSize, textFont),
		cursor:    cursorNode,
		cursorPos: len(text),
	}
	tf.text.node.Add(cursorNode)
	tf.container.AddChildren(tf.text)
	tf.GetHitbox().AddOnClick(func(button int, release bool, position mgl32.Vec2) {
		if !release {
			tf.Activate()
		}
	})
	tf.SetBackgroundColor(0, 0, 0, 0)
	tf.SetHeight(textSize * 1.5)
	tf.SetPadding(NewMargin(2))
	return tf
}
Beispiel #12
0
func (ie *ImageElement) SetImage(img image.Image) {
	mat := renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	ie.node.Material = mat
	ie.img = img
}
Beispiel #13
0
func setupScene(gameEngine engine.Engine, shader *renderer.Shader) {
	camera := gameEngine.Camera()

	transparentNode := renderer.NewNode()
	gameEngine.AddSpatialTransparent(transparentNode)
	transparentNode.RendererParams = &renderer.RendererParams{
		DepthTest:    true,
		Unlit:        true,
		Transparency: renderer.EMISSIVE,
	}

	// Sky cubemap
	skyImg, err := assets.ImportImage("TestAssets/cloudSky.jpg")
	if err == nil {
		skyImg = imaging.AdjustBrightness(skyImg, -30)
		skyImg = imaging.AdjustContrast(skyImg, 30)
		geom := renderer.CreateSkyBox()
		geom.Transform(mgl32.Scale3D(10000, 10000, 10000))
		skyNode := renderer.NewNode()
		skyNode.SetOrientation(mgl32.QuatRotate(1.57, mgl32.Vec3{0, 1, 0}))
		skyNode.Material = renderer.NewMaterial(renderer.NewTexture("diffuseMap", skyImg, false))
		skyNode.RendererParams = renderer.NewRendererParams()
		skyNode.RendererParams.CullBackface = false
		skyNode.RendererParams.Unlit = true
		skyNode.Add(geom)
		gameEngine.AddSpatial(skyNode)
		// create an environmentMap using the skybox texture
		envCubeMap := renderer.NewCubemap("environmentMap", skyImg, true)
		gameEngine.DefaultCubeMap(envCubeMap)
	}

	// load scene objs
	objs := []string{
		"TestAssets/wellScene/floor.obj",
		"TestAssets/wellScene/frame1.obj",
		"TestAssets/wellScene/frame2.obj",
		"TestAssets/wellScene/well.obj",
		"TestAssets/wellScene/torches.obj",
	}
	for _, objFile := range objs {
		if geom, mat, err := assets.ImportObjCached(objFile); err == nil {
			sceneNode := renderer.NewNode()
			sceneNode.Add(geom)
			sceneNode.Material = mat
			sceneNode.RendererParams = renderer.NewRendererParams()
			sceneNode.RendererParams.CullBackface = false
			gameEngine.AddSpatial(sceneNode)
		}
	}

	for i := 0; i < 2; i++ {
		torchLocation := mgl32.Vec3{0.86, 1.76, 1.05}
		if i == 1 {
			torchLocation = mgl32.Vec3{0.86, 1.76, -1.05}
		}

		fire := fireParticles()
		spark := sparkParticles()
		torchParticles := effects.NewParticleGroup(camera, fire, spark)
		torchParticles.SetTranslation(torchLocation)
		transparentNode.Add(torchParticles)
		gameEngine.AddUpdatable(torchParticles)

		light := renderer.NewLight(renderer.POINT)
		light.SetTranslation(torchLocation.Add(mgl32.Vec3{0, 0.05, 0}))
		gameEngine.AddLight(light)

		var x float64
		gameEngine.AddUpdatable(engine.UpdatableFunc(func(dt float64) {
			x += dt
			mag := float32(math.Abs(0.6*math.Sin(3*x)+0.3*math.Sin(4*x)+0.15*math.Sin(7*x)+0.1*math.Sin(15*x))) + 0.5
			mag *= 0.05
			light.Color = [3]float32{1 * mag, 0.6 * mag, 0.4 * mag}
		}))
	}
}
Beispiel #14
0
func (c *Container) SetBackgroundImage(img image.Image) {
	mat := renderer.NewMaterial(renderer.NewTexture("diffuseMap", img, false))
	c.background.Material = mat
}
Beispiel #15
0
func (e *Editor) Start() {

	glRenderer := opengl.NewOpenglRenderer("GoEngine Editor", 1800, 900, false)
	e.renderer = glRenderer
	e.gameEngine = engine.NewEngine(e.renderer)

	e.gameEngine.Start(func() {

		shader, err := assets.ImportShader(
			filepath.Join(e.assetDir, "shaders/build/pbr.vert"),
			filepath.Join(e.assetDir, "shaders/build/pbr.frag"),
		)
		if err != nil {
			panic("error importing shader")
		}

		e.gameEngine.DefaultShader(shader)

		// Sky cubemap
		skyImg, err := assets.ImportImage(filepath.Join(e.assetDir, "resources/cubemap.png"))
		if err == nil {
			geom := renderer.CreateSkyBox()
			geom.Transform(mgl32.Scale3D(10000, 10000, 10000))
			skyNode := renderer.NewNode()
			skyNode.SetOrientation(mgl32.QuatRotate(1.57, mgl32.Vec3{0, 1, 0}))
			skyNode.Material = renderer.NewMaterial(renderer.NewTexture("diffuseMap", skyImg, false))
			skyNode.RendererParams = renderer.NewRendererParams()
			skyNode.RendererParams.CullBackface = false
			skyNode.RendererParams.Unlit = true
			skyNode.Add(geom)
			e.gameEngine.AddSpatial(skyNode)
			// create an environmentMap using the skybox texture
			envCubeMap := renderer.NewCubemap("environmentMap", skyImg, true)
			e.gameEngine.DefaultCubeMap(envCubeMap)
		}

		l := renderer.NewLight(renderer.DIRECTIONAL)
		l.Color = [3]float32{0.7, 0.7, 0.8}
		e.gameEngine.AddLight(l)

		//root node
		e.gameEngine.AddSpatial(e.rootMapNode)

		//input/controller manager
		e.controllerManager = glfwController.NewControllerManager(glRenderer.Window)

		//camera + player
		camera := e.gameEngine.Camera()
		freeMoveActor := actor.NewFreeMoveActor(camera)
		freeMoveActor.MoveSpeed = 20.0
		freeMoveActor.LookSpeed = 0.002
		mainController := controller.NewBasicMovementController(freeMoveActor, true)
		e.controllerManager.AddController(mainController.(glfwController.Controller))
		e.gameEngine.AddUpdatable(freeMoveActor)

		e.initSelectSprite()
		e.gameEngine.AddUpdatable(engine.UpdatableFunc(e.updateSelectSprite))

		//editor controller
		e.controllerManager.AddController(NewEditorController(e).(glfwController.Controller))

		//custom controller
		e.customController = controller.CreateController()
		e.controllerManager.AddController(e.customController.(glfwController.Controller))

		e.setupUI()
	})
}
Beispiel #16
0
func main() {

	glRenderer := opengl.NewOpenglRenderer("Simple", 800, 800, false)
	gameEngine := engine.NewEngine(glRenderer)
	gameEngine.InitFpsDial()

	gameEngine.Start(func() {

		if shader, err := assets.ImportShader("shaders/build/basic.vert", "shaders/build/basic.frag"); err == nil {
			gameEngine.DefaultShader(shader)
		}

		// sky cube
		skyImg, err := assets.ImportImage("resources/cubemap.png")
		if err == nil {
			geom := renderer.CreateSkyBox()
			geom.Transform(mgl32.Scale3D(10000, 10000, 10000))
			skyNode := renderer.NewNode()
			skyNode.SetOrientation(mgl32.QuatRotate(1.57, mgl32.Vec3{0, 1, 0}))
			skyNode.Material = renderer.NewMaterial(renderer.NewTexture("diffuseMap", skyImg, false))
			skyNode.RendererParams = renderer.NewRendererParams()
			skyNode.RendererParams.CullBackface = false
			skyNode.RendererParams.Unlit = true
			skyNode.Add(geom)
			gameEngine.AddSpatial(skyNode)
		}

		// Add some light to the scene
		ambientLight := renderer.NewLight(renderer.AMBIENT)
		ambientLight.Color = [3]float32{0.3, 0.3, 0.3}
		gameEngine.AddLight(ambientLight)

		// Create a red box geometry, attach to a node, add the node to the scenegraph
		boxGeometry := renderer.CreateBox(10, 10)
		boxGeometry.SetColor(color.NRGBA{254, 0, 0, 254})
		boxNode := renderer.NewNode()
		boxNode.RendererParams = renderer.NewRendererParams()
		boxNode.RendererParams.CullBackface = false
		boxNode.Material = renderer.NewMaterial()
		boxNode.SetTranslation(mgl32.Vec3{30, 0})
		boxNode.Add(boxGeometry)
		gameEngine.AddSpatial(boxNode)

		// make the box spin
		var angle float64
		gameEngine.AddUpdatable(engine.UpdatableFunc(func(dt float64) {
			angle += dt
			q := mgl32.QuatRotate(float32(angle), mgl32.Vec3{0, 1, 0})
			boxNode.SetOrientation(q)
		}))

		// input/controller manager
		controllerManager := glfwController.NewControllerManager(glRenderer.Window)

		// camera + wasd controls
		camera := gameEngine.Camera()
		freeMoveActor := actor.NewFreeMoveActor(camera)
		freeMoveActor.Location = mgl32.Vec3{}
		mainController := controller.NewBasicMovementController(freeMoveActor, false)
		controllerManager.AddController(mainController.(glfwController.Controller))
		gameEngine.AddUpdatable(freeMoveActor)

		//lock the cursor
		glRenderer.LockCursor(true)

		// custom key bindings
		customController := controller.CreateController()
		controllerManager.AddController(customController.(glfwController.Controller))

		// close window and exit on escape
		customController.BindKeyAction(func() {
			glRenderer.Window.SetShouldClose(true)
		}, controller.KeyEscape, controller.Press)
	})
}