func PositionOfVertexNoRotation(v *Vertex) *Position {
t := mgl32.Vec3{-v.cvec.X(), -v.cvec.Y(), -v.cvec.Z()}
return &Position{
trans: t,
quat: mgl32.QuatIdent(),
}
}
func NewNodeModel(id string) *NodeModel {
return &NodeModel{
Id: id,
Scale: mgl32.Vec3{1, 1, 1},
Translation: mgl32.Vec3{},
Orientation: mgl32.QuatIdent(),
Children: make([]*NodeModel, 0),
}
}
func NewNode() *Node {
node := &Node{
children: make([]Spatial, 0, 0),
deleted: make([]Spatial, 0, 0),
Translation: mgl32.Vec3{0, 0, 0},
Orientation: mgl32.QuatIdent(),
FrustrumCulling: true,
}
node.SetScale(mgl32.Vec3{1, 1, 1})
return node
}
func (e *Editor) resetGroup() {
if node, _ := findNodeById(e.overviewMenu.selectedNodeId, e.currentMap.Root); node != nil {
selectedNode := node.GetNode()
if selectedNode != nil {
selectedNode.SetScale(node.Scale)
selectedNode.SetTranslation(node.Translation)
selectedNode.SetOrientation(node.Orientation)
}
node.Scale = mgl32.Vec3{1, 1, 1}
node.Translation = mgl32.Vec3{}
node.Orientation = mgl32.QuatIdent()
}
}
// NewTransform creates a new Transform struct with defaults.
// The given multiplier can be used to invert the matrix, e.g. camera matrix
// This value should be 1 or -1 (inverted).
//
// Position: 0,0,0
// Rotation: 0,0,0
// Scale: 1,1,1
//
// Up: 0,1,0
// Right: 1,0,0
// Forward: 0,0,-1
func NewTransform() *Transform {
return &Transform{
position: mgl32.Vec3{0, 0, 0},
rotation: mgl32.Vec3{0, 0, 0},
quaternion: mgl32.QuatIdent(),
scale: mgl32.Vec3{1, 1, 1},
Up: mgl32.Vec3{0, 1, 0},
Right: mgl32.Vec3{1, 0, 0},
Forward: mgl32.Vec3{0, 0, -1},
matrix: mgl32.Ident4(),
}
}
func TestNewTransform(t *testing.T) {
transform := NewTransform()
defaultPosition := mgl32.Vec3{0, 0, 0}
defaultRotation := mgl32.Vec3{0, 0, 0}
defaultQuaternion := mgl32.QuatIdent()
defaultUp := mgl32.Vec3{0, 1, 0}
defaultRight := mgl32.Vec3{1, 0, 0}
defaultForward := mgl32.Vec3{0, 0, -1}
defaultMatrix := mgl32.Ident4()
if transform.position != defaultPosition {
t.Errorf("Default position was not %v got %v", defaultPosition, transform.position)
}
if transform.rotation != defaultRotation {
t.Errorf("Default rotation was not %v got %v", defaultRotation, transform.rotation)
}
if transform.quaternion != defaultQuaternion {
t.Errorf("Default quaternion was not identity, got: %v", transform.quaternion)
}
if transform.Up != defaultUp {
t.Errorf("Expected up to be %v got %v", defaultUp, transform.Up)
}
if transform.Right != defaultRight {
t.Errorf("Expected right to be %v got %v", defaultRight, transform.Right)
}
if transform.Forward != defaultForward {
t.Errorf("Expected forward to be %v got %v", defaultForward, transform.Forward)
}
if transform.matrix != defaultMatrix {
t.Errorf("Expected default matrix to be identity matrix.")
}
}
// NewEntity creates a new entity object with default values
func NewEntity() *Entity {
e := new(Entity)
e.Rotation = mgl.QuatIdent()
return e
}
func NewQuatCamera() *QuatCamera {
return &QuatCamera{
rotation: mgl.QuatIdent(),
}
}
// NewApp returns a new ExampleApp object to control the display of the example app.
func NewApp() *ExampleApp {
app := new(ExampleApp)
app.CameraRotation = mgl.QuatIdent()
return app
}
func NewPosition() *Position {
return &Position{
quat: mgl32.QuatIdent(),
trans: mgl32.Vec3{0, 0, 0},
}
}
