_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q12600 | lexPredicateOrLiteral | train | func lexPredicateOrLiteral(l *lexer) stateFn {
text := l.input[l.pos:]
// Fix issue 39 (https://github.com/google/badwolf/issues/39)
pIdx, lIdx := strings.Index(text, "\"@["), strings.Index(text, "\"^^type:")
if pIdx < 0 && lIdx < 0 {
l.emitError("failed to parse predicate or literal for opening \" delimiter")
return nil
}
if pIdx > 0 && (lIdx < 0 || pIdx < lIdx) {
return lexPredicate
}
return lexLiteral
} | go | {
"resource": ""
} |
q12601 | lexPredicate | train | func lexPredicate(l *lexer) stateFn {
l.next()
for done := false; !done; {
switch r := l.next(); r {
case backSlash:
if nr := l.peek(); nr == quote {
l.next()
continue
}
case quote:
l.backup()
if !l.consume(anchor) {
l.emitError("predicates require time anchor information; missing \"@[")
return nil
}
var (
nr rune
commas = 0
)
for {
nr = l.next()
if nr == comma {
commas++
}
if nr == rightSquarePar || nr == eof {
break
}
}
if nr != rightSquarePar {
l.emitError("predicate's time anchors should end with ] delimiter")
return nil
}
if commas > 1 {
l.emitError("predicate bounds should only have one , to separate bounds")
return nil
}
if commas == 0 {
l.emit(ItemPredicate)
} else {
l.emit(ItemPredicateBound)
}
done = true
case eof:
l.emitError("literals needs to be properly terminated; missing \" and type")
return nil
}
}
return lexSpace
} | go | {
"resource": ""
} |
q12602 | lexLiteral | train | func lexLiteral(l *lexer) stateFn {
l.next()
for done := false; !done; {
switch r := l.next(); r {
case backSlash:
if nr := l.peek(); nr == quote {
l.next()
continue
}
case quote:
l.backup()
if !l.consume(literalType) {
l.emitError("literals require a type definintion; missing ^^type:")
return nil
}
literalT := ""
for {
r := l.next()
if !(unicode.IsLetter(r) || unicode.IsDigit(r)) || r == eof {
break
}
literalT += string(r)
}
literalT = strings.ToLower(literalT)
switch literalT {
case literalBool, literalInt, literalFloat, literalText, literalBlob:
l.backup()
l.emit(ItemLiteral)
done = true
default:
l.emitError("invalid literal type " + literalT)
return nil
}
case eof:
l.emitError("literals needs to be properly terminated; missing \" and type")
return nil
}
}
return lexSpace
} | go | {
"resource": ""
} |
q12603 | consumeKeyword | train | func consumeKeyword(l *lexer, t TokenType) {
for {
if r := l.next(); !unicode.IsLetter(r) || r == eof {
l.backup()
l.emit(t)
break
}
}
} | go | {
"resource": ""
} |
q12604 | emitError | train | func (l *lexer) emitError(msg string) {
l.tokens <- Token{
Type: ItemError,
Text: l.input[l.start:l.pos],
ErrorMessage: fmt.Sprintf("[lexer:%d:%d] %s", l.line, l.col, msg),
}
l.start = l.pos
} | go | {
"resource": ""
} |
q12605 | accept | train | func (l *lexer) accept(r rune) bool {
if unicode.ToLower(l.next()) == unicode.ToLower(r) {
return true
}
l.backup()
return false
} | go | {
"resource": ""
} |
q12606 | UUIDToBase64 | train | func UUIDToBase64(uuid uuid.UUID) string {
return base64.StdEncoding.EncodeToString([]byte(uuid))
} | go | {
"resource": ""
} |
q12607 | Base64ToUUID | train | func Base64ToUUID(b64 string) (uuid.UUID, error) {
bs, err := base64.StdEncoding.DecodeString(b64)
if err != nil {
return nil, err
}
if got, want := len(bs), 16; got != want {
return nil, fmt.Errorf("invalid UUID size; got %d, want %d", got, want)
}
return uuid.UUID(bs), nil
} | go | {
"resource": ""
} |
q12608 | Delta | train | func (c *Clock) Delta() float32 {
return float32(float64(c.deltaStamp) / float64(secondsInNano))
} | go | {
"resource": ""
} |
q12609 | Time | train | func (c *Clock) Time() float32 {
currStamp := theTimer.Now()
return float32(float64(currStamp-c.startStamp) / float64(secondsInNano))
} | go | {
"resource": ""
} |
q12610 | Register | train | func (formats *Formats) Register(ext string, loader FileLoader) {
formats.formats[ext] = loader
} | go | {
"resource": ""
} |
q12611 | load | train | func (formats *Formats) load(url string) error {
ext := getExt(url)
if loader, ok := Files.formats[ext]; ok {
f, err := openFile(filepath.Join(formats.root, url))
if err != nil {
return fmt.Errorf("unable to open resource: %s", err)
}
defer f.Close()
return loader.Load(url, f)
}
return fmt.Errorf("no `FileLoader` associated with this extension: %q in url %q", ext, url)
} | go | {
"resource": ""
} |
q12612 | LoadReaderData | train | func (formats *Formats) LoadReaderData(url string, f io.Reader) error {
ext := getExt(url)
if loader, ok := Files.formats[ext]; ok {
return loader.Load(url, f)
}
return fmt.Errorf("no `FileLoader` associated with this extension: %q in url %q", ext, url)
} | go | {
"resource": ""
} |
q12613 | Unload | train | func (formats *Formats) Unload(url string) error {
ext := getExt(url)
if loader, ok := Files.formats[ext]; ok {
return loader.Unload(url)
}
return fmt.Errorf("no `FileLoader` associated with this extension: %q in url %q", ext, url)
} | go | {
"resource": ""
} |
q12614 | NewAsymmetricSpritesheetFromTexture | train | func NewAsymmetricSpritesheetFromTexture(tr *TextureResource, spriteRegions []SpriteRegion) *Spritesheet {
return &Spritesheet{
texture: tr.Texture,
width: tr.Width,
height: tr.Height,
cells: spriteRegions,
cache: make(map[int]Texture),
}
} | go | {
"resource": ""
} |
q12615 | NewAsymmetricSpritesheetFromFile | train | func NewAsymmetricSpritesheetFromFile(textureName string, spriteRegions []SpriteRegion) *Spritesheet {
res, err := engo.Files.Resource(textureName)
if err != nil {
log.Println("[WARNING] [NewAsymmetricSpritesheetFromFile]: Received error:", err)
return nil
}
img, ok := res.(TextureResource)
if !ok {
log.Println("[WARNING] [NewAsymmetricSpritesheetFromFile]: Resource not of type `TextureResource`:", textureName)
return nil
}
return NewAsymmetricSpritesheetFromTexture(&img, spriteRegions)
} | go | {
"resource": ""
} |
q12616 | NewSpritesheetFromTexture | train | func NewSpritesheetFromTexture(tr *TextureResource, cellWidth, cellHeight int) *Spritesheet {
spriteRegions := generateSymmetricSpriteRegions(tr.Width, tr.Height, cellWidth, cellHeight, 0, 0)
return NewAsymmetricSpritesheetFromTexture(tr, spriteRegions)
} | go | {
"resource": ""
} |
q12617 | NewSpritesheetFromFile | train | func NewSpritesheetFromFile(textureName string, cellWidth, cellHeight int) *Spritesheet {
res, err := engo.Files.Resource(textureName)
if err != nil {
log.Println("[WARNING] [NewSpritesheetFromFile]: Received error:", err)
return nil
}
img, ok := res.(TextureResource)
if !ok {
log.Println("[WARNING] [NewSpritesheetFromFile]: Resource not of type `TextureResource`:", textureName)
return nil
}
return NewSpritesheetFromTexture(&img, cellWidth, cellHeight)
} | go | {
"resource": ""
} |
q12618 | NewSpritesheetWithBorderFromTexture | train | func NewSpritesheetWithBorderFromTexture(tr *TextureResource, cellWidth, cellHeight, borderWidth, borderHeight int) *Spritesheet {
spriteRegions := generateSymmetricSpriteRegions(tr.Width, tr.Height, cellWidth, cellHeight, borderWidth, borderHeight)
return NewAsymmetricSpritesheetFromTexture(tr, spriteRegions)
} | go | {
"resource": ""
} |
q12619 | NewSpritesheetWithBorderFromFile | train | func NewSpritesheetWithBorderFromFile(textureName string, cellWidth, cellHeight, borderWidth, borderHeight int) *Spritesheet {
res, err := engo.Files.Resource(textureName)
if err != nil {
log.Println("[WARNING] [NewSpritesheetWithBorderFromFile]: Received error:", err)
return nil
}
img, ok := res.(TextureResource)
if !ok {
log.Println("[WARNING] [NewSpritesheetWithBorderFromFile]: Resource not of type `TextureResource`:", textureName)
return nil
}
return NewSpritesheetWithBorderFromTexture(&img, cellWidth, cellHeight, borderWidth, borderHeight)
} | go | {
"resource": ""
} |
q12620 | Cell | train | func (s *Spritesheet) Cell(index int) Texture {
if r, ok := s.cache[index]; ok {
return r
}
cell := s.cells[index]
s.cache[index] = Texture{
id: s.texture,
width: float32(cell.Width),
height: float32(cell.Height),
viewport: engo.AABB{
Min: engo.Point{
X: cell.Position.X / s.width,
Y: cell.Position.Y / s.height,
},
Max: engo.Point{
X: (cell.Position.X + float32(cell.Width)) / s.width,
Y: (cell.Position.Y + float32(cell.Height)) / s.height,
},
},
}
return s.cache[index]
} | go | {
"resource": ""
} |
q12621 | Drawables | train | func (s *Spritesheet) Drawables() []Drawable {
drawables := make([]Drawable, s.CellCount())
for i := 0; i < s.CellCount(); i++ {
drawables[i] = s.Drawable(i)
}
return drawables
} | go | {
"resource": ""
} |
q12622 | Cells | train | func (s *Spritesheet) Cells() []Texture {
cellsNo := s.CellCount()
cells := make([]Texture, cellsNo)
for i := 0; i < cellsNo; i++ {
cells[i] = s.Cell(i)
}
return cells
} | go | {
"resource": ""
} |
q12623 | colorToFloat32 | train | func colorToFloat32(c color.Color) float32 {
colorR, colorG, colorB, colorA := c.RGBA()
colorR >>= 8
colorG >>= 8
colorB >>= 8
colorA >>= 8
red := colorR
green := colorG << 8
blue := colorB << 16
alpha := colorA << 24
return math.Float32frombits((alpha | blue | green | red) & 0xfeffffff)
} | go | {
"resource": ""
} |
q12624 | LoadShader | train | func LoadShader(vertSrc, fragSrc string) (*gl.Program, error) {
vertShader := engo.Gl.CreateShader(engo.Gl.VERTEX_SHADER)
engo.Gl.ShaderSource(vertShader, vertSrc)
engo.Gl.CompileShader(vertShader)
if !engo.Gl.GetShaderiv(vertShader, engo.Gl.COMPILE_STATUS) {
errorLog := engo.Gl.GetShaderInfoLog(vertShader)
return nil, VertexShaderCompilationError{errorLog}
}
defer engo.Gl.DeleteShader(vertShader)
fragShader := engo.Gl.CreateShader(engo.Gl.FRAGMENT_SHADER)
engo.Gl.ShaderSource(fragShader, fragSrc)
engo.Gl.CompileShader(fragShader)
if !engo.Gl.GetShaderiv(fragShader, engo.Gl.COMPILE_STATUS) {
errorLog := engo.Gl.GetShaderInfoLog(fragShader)
return nil, FragmentShaderCompilationError{errorLog}
}
defer engo.Gl.DeleteShader(fragShader)
program := engo.Gl.CreateProgram()
engo.Gl.AttachShader(program, vertShader)
engo.Gl.AttachShader(program, fragShader)
engo.Gl.LinkProgram(program)
return program, nil
} | go | {
"resource": ""
} |
q12625 | SetShader | train | func (r *RenderComponent) SetShader(s Shader) {
r.shader = s
engo.Mailbox.Dispatch(&renderChangeMessage{})
} | go | {
"resource": ""
} |
q12626 | SetZIndex | train | func (r *RenderComponent) SetZIndex(index float32) {
r.zIndex = index
engo.Mailbox.Dispatch(&renderChangeMessage{})
} | go | {
"resource": ""
} |
q12627 | SetMinFilter | train | func (r *RenderComponent) SetMinFilter(z ZoomFilter) {
r.minFilter = z
engo.Mailbox.Dispatch(renderChangeMessage{})
} | go | {
"resource": ""
} |
q12628 | SetMagFilter | train | func (r *RenderComponent) SetMagFilter(z ZoomFilter) {
r.magFilter = z
engo.Mailbox.Dispatch(renderChangeMessage{})
} | go | {
"resource": ""
} |
q12629 | New | train | func (rs *RenderSystem) New(w *ecs.World) {
rs.world = w
rs.ids = make(map[uint64]struct{})
engo.Mailbox.Listen("NewCameraMessage", func(engo.Message) {
rs.newCamera = true
})
addCameraSystemOnce(w)
if !engo.Headless() {
if err := initShaders(w); err != nil {
panic(err)
}
engo.Gl.Enable(engo.Gl.MULTISAMPLE)
}
engo.Mailbox.Listen("renderChangeMessage", func(engo.Message) {
rs.sortingNeeded = true
})
} | go | {
"resource": ""
} |
q12630 | Add | train | func (rs *RenderSystem) Add(basic *ecs.BasicEntity, render *RenderComponent, space *SpaceComponent) {
// Do nothing if entity already exists
if _, ok := rs.ids[basic.ID()]; ok {
return
}
rs.ids[basic.ID()] = struct{}{}
render.ensureShader()
// This is to prevent users from using the wrong one
if render.shader == HUDShader {
switch render.Drawable.(type) {
case Triangle:
render.shader = LegacyHUDShader
case Circle:
render.shader = LegacyHUDShader
case Rectangle:
render.shader = LegacyHUDShader
case ComplexTriangles:
render.shader = LegacyHUDShader
case Text:
render.shader = TextHUDShader
default:
render.shader = HUDShader
}
}
// If the scale is zero, set it to one.
if render.Scale.X == 0 {
render.Scale.X = 1
}
if render.Scale.Y == 0 {
render.Scale.Y = 1
}
rs.entities = append(rs.entities, renderEntity{basic, render, space})
rs.sortingNeeded = true
} | go | {
"resource": ""
} |
q12631 | EntityExists | train | func (rs *RenderSystem) EntityExists(basic *ecs.BasicEntity) int {
for index, entity := range rs.entities {
if entity.ID() == basic.ID() {
return index
}
}
return -1
} | go | {
"resource": ""
} |
q12632 | AddByInterface | train | func (rs *RenderSystem) AddByInterface(i ecs.Identifier) {
o, _ := i.(Renderable)
rs.Add(o.GetBasicEntity(), o.GetRenderComponent(), o.GetSpaceComponent())
} | go | {
"resource": ""
} |
q12633 | Remove | train | func (rs *RenderSystem) Remove(basic ecs.BasicEntity) {
var d = rs.EntityExists(&basic)
if d >= 0 {
rs.entities = append(rs.entities[:d], rs.entities[d+1:]...)
rs.sortingNeeded = true
}
delete(rs.ids, basic.ID())
} | go | {
"resource": ""
} |
q12634 | Update | train | func (rs *RenderSystem) Update(dt float32) {
if engo.Headless() {
return
}
if rs.sortingNeeded {
sort.Sort(rs.entities)
rs.sortingNeeded = false
}
if rs.newCamera {
newCamera(rs.world)
rs.newCamera = false
}
engo.Gl.Clear(engo.Gl.COLOR_BUFFER_BIT)
preparedCullingShaders := make(map[CullingShader]struct{})
var cullingShader CullingShader // current culling shader
var prevShader Shader // shader of the previous entity
var currentShader Shader // currently "active" shader
// TODO: it's linear for now, but that might very well be a bad idea
for _, e := range rs.entities {
if e.RenderComponent.Hidden {
continue // with other entities
}
// Retrieve a shader, may be the default one -- then use it if we aren't already using it
shader := e.RenderComponent.shader
if !compareShaders(shader, prevShader) {
// to increase performance avoid the type assertions when possible
prevShader = shader
if cs, ok := shader.(CullingShader); ok {
cullingShader = cs
if _, isPrepared := preparedCullingShaders[cullingShader]; !isPrepared {
cullingShader.PrepareCulling()
preparedCullingShaders[cullingShader] = struct{}{}
}
} else {
cullingShader = nil
}
}
if cullingShader != nil && !cullingShader.ShouldDraw(e.RenderComponent, e.SpaceComponent) {
continue
}
// Change Shader if we have to
if !compareShaders(shader, currentShader) {
if currentShader != nil {
currentShader.Post()
}
shader.Pre()
currentShader = shader
}
// Setting default scale to 1
if e.RenderComponent.Scale.X == 0 && e.RenderComponent.Scale.Y == 0 {
e.RenderComponent.Scale = engo.Point{X: 1, Y: 1}
}
// Setting default to white
if e.RenderComponent.Color == nil {
e.RenderComponent.Color = color.White
}
currentShader.Draw(e.RenderComponent, e.SpaceComponent)
}
if currentShader != nil {
currentShader.Post()
}
} | go | {
"resource": ""
} |
q12635 | SetBackground | train | func SetBackground(c color.Color) {
if !engo.Headless() {
r, g, b, a := c.RGBA()
engo.Gl.ClearColor(float32(r)/0xffff, float32(g)/0xffff, float32(b)/0xffff, float32(a)/0xffff)
}
} | go | {
"resource": ""
} |
q12636 | New | train | func (a *AudioSystem) New(w *ecs.World) {
var err error
switch engo.CurrentBackEnd {
case engo.BackEndMobile:
a.bufsize = 12288
default:
a.bufsize = 8192
}
if engo.Headless() {
otoPlayer = &stepPlayer{
stepStart: make(chan []byte),
stepDone: make(chan struct{}, 1),
}
} else {
if otoPlayer == nil {
otoPlayer, err = oto.NewPlayer(SampleRate, channelNum, bytesPerSample, a.bufsize)
if err != nil {
log.Printf("audio error. Unable to create new OtoPlayer: %v \n\r", err)
}
} else {
closeCh <- struct{}{}
<-loopClosedCh
}
}
// run oto on a separate thread so it doesn't slow down updates
closeCh = make(chan struct{}, 1)
a.pauseCh = make(chan struct{}, 1)
a.restartCh = make(chan struct{}, 1)
a.playerCh = make(chan []*Player, 25)
loopClosedCh = make(chan struct{})
go func() {
players := make([]*Player, 0)
loop:
for {
select {
case <-closeCh:
break loop
case <-a.pauseCh:
<-a.restartCh
case players = <-a.playerCh:
default:
buf := make([]byte, 2048)
a.read(buf, players)
if _, err := otoPlayer.Write(buf); err != nil {
log.Printf("error copying to OtoPlayer: %v \r\n", err)
}
}
}
loopClosedCh <- struct{}{}
}()
masterVolume = 1
} | go | {
"resource": ""
} |
q12637 | Add | train | func (a *AudioSystem) Add(basic *ecs.BasicEntity, audio *AudioComponent) {
a.entities = append(a.entities, audioEntity{basic, audio})
} | go | {
"resource": ""
} |
q12638 | AddByInterface | train | func (a *AudioSystem) AddByInterface(i ecs.Identifier) {
o, _ := i.(Audioable)
a.Add(o.GetBasicEntity(), o.GetAudioComponent())
} | go | {
"resource": ""
} |
q12639 | Remove | train | func (a *AudioSystem) Remove(basic ecs.BasicEntity) {
delete := -1
for index, e := range a.entities {
if e.BasicEntity.ID() == basic.ID() {
delete = index
break
}
}
if delete >= 0 {
a.entities = append(a.entities[:delete], a.entities[delete+1:]...)
}
} | go | {
"resource": ""
} |
q12640 | Update | train | func (a *AudioSystem) Update(dt float32) {
if len(a.playerCh) >= 25 { //if the channel is full just return so we don't block the update loop
return
}
players := make([]*Player, 0)
for _, e := range a.entities {
if e.Player.isPlaying {
players = append(players, e.Player)
}
}
a.playerCh <- players
} | go | {
"resource": ""
} |
q12641 | read | train | func (a *AudioSystem) read(b []byte, players []*Player) (int, error) {
l := len(b)
l &= mask
if len(players) == 0 {
copy(b, make([]byte, l))
return l, nil
}
b16s := [][]int16{}
for _, player := range players {
buf, err := player.bufferToInt16(l)
if err != nil {
return 0, err
}
b16s = append(b16s, buf)
}
for i := 0; i < l/2; i++ {
x := 0
for _, b16 := range b16s {
x += int(b16[i])
}
if x > (1<<15)-1 {
x = (1 << 15) - 1
}
if x < -(1 << 15) {
x = -(1 << 15)
}
b[2*i] = byte(x)
b[2*i+1] = byte(x >> 8)
}
for _, player := range players {
if player.eof() {
if player.Repeat {
player.Rewind()
} else {
player.Pause()
}
}
}
return l, nil
} | go | {
"resource": ""
} |
q12642 | NewInputManager | train | func NewInputManager() *InputManager {
return &InputManager{
Touches: make(map[int]Point),
axes: make(map[string]Axis),
buttons: make(map[string]Button),
keys: NewKeyManager(),
}
} | go | {
"resource": ""
} |
q12643 | RegisterAxis | train | func (im *InputManager) RegisterAxis(name string, pairs ...AxisPair) {
im.axes[name] = Axis{
Name: name,
Pairs: pairs,
}
} | go | {
"resource": ""
} |
q12644 | RegisterButton | train | func (im *InputManager) RegisterButton(name string, keys ...Key) {
im.buttons[name] = Button{
Triggers: keys,
Name: name,
}
} | go | {
"resource": ""
} |
q12645 | Create | train | func (f *Font) Create() error {
// Read and parse the font
ttfBytes, err := ioutil.ReadFile(f.URL)
if err != nil {
return err
}
ttf, err := freetype.ParseFont(ttfBytes)
if err != nil {
return err
}
f.TTF = ttf
f.face = truetype.NewFace(f.TTF, &truetype.Options{
Size: f.Size,
DPI: dpi,
Hinting: font.HintingFull,
})
return nil
} | go | {
"resource": ""
} |
q12646 | TextDimensions | train | func (f *Font) TextDimensions(text string) (int, int, int) {
fnt := f.TTF
size := f.Size
var (
totalWidth = fixed.Int26_6(0)
totalHeight = fixed.Int26_6(size)
maxYBearing = fixed.Int26_6(0)
)
fupe := fixed.Int26_6(fnt.FUnitsPerEm())
for _, char := range text {
idx := fnt.Index(char)
hm := fnt.HMetric(fupe, idx)
vm := fnt.VMetric(fupe, idx)
g := truetype.GlyphBuf{}
err := g.Load(fnt, fupe, idx, font.HintingNone)
if err != nil {
log.Println(err)
return 0, 0, 0
}
totalWidth += hm.AdvanceWidth
yB := (vm.TopSideBearing * fixed.Int26_6(size)) / fupe
if yB > maxYBearing {
maxYBearing = yB
}
dY := (vm.AdvanceHeight * fixed.Int26_6(size)) / fupe
if dY > totalHeight {
totalHeight = dY
}
}
// Scale to actual pixel size
totalWidth *= fixed.Int26_6(size)
totalWidth /= fupe
return int(totalWidth), int(totalHeight), int(maxYBearing)
} | go | {
"resource": ""
} |
q12647 | Render | train | func (f *Font) Render(text string) Texture {
nrgba := f.RenderNRGBA(text)
// Create texture
imObj := NewImageObject(nrgba)
return NewTextureSingle(imObj)
} | go | {
"resource": ""
} |
q12648 | Width | train | func (t Text) Width() float32 {
atlas, ok := atlasCache[*t.Font]
if !ok {
// Generate texture first
atlas = t.Font.generateFontAtlas(200)
atlasCache[*t.Font] = atlas
}
var currentX float32
var greatestX float32
for _, char := range t.Text {
// TODO: this might not work for all characters
switch {
case char == '\n':
if currentX > greatestX {
greatestX = currentX
}
currentX = 0
continue
case char < 32: // all system stuff should be ignored
continue
}
currentX += atlas.Width[char] + float32(t.Font.Size)*t.LetterSpacing
}
if currentX > greatestX {
return currentX
}
return greatestX
} | go | {
"resource": ""
} |
q12649 | Height | train | func (t Text) Height() float32 {
atlas, ok := atlasCache[*t.Font]
if !ok {
// Generate texture first
atlas = t.Font.generateFontAtlas(200)
atlasCache[*t.Font] = atlas
}
var currentY float32
var totalY float32
var tallest float32
for _, char := range t.Text {
// TODO: this might not work for all characters
switch {
case char == '\n':
totalY += tallest
tallest = float32(0)
continue
case char < 32: // all system stuff should be ignored
continue
}
currentY = atlas.Height[char] + t.LineSpacing*atlas.Height[char]
if currentY > tallest {
tallest = currentY
}
}
return totalY + tallest
} | go | {
"resource": ""
} |
q12650 | New | train | func (m *MouseSystem) New(w *ecs.World) {
m.world = w
// First check if the CameraSystem is available
for _, system := range m.world.Systems() {
switch sys := system.(type) {
case *CameraSystem:
m.camera = sys
}
}
if m.camera == nil {
log.Println("ERROR: CameraSystem not found - have you added the `RenderSystem` before the `MouseSystem`?")
return
}
} | go | {
"resource": ""
} |
q12651 | AddByInterface | train | func (m *MouseSystem) AddByInterface(i ecs.Identifier) {
o, _ := i.(Mouseable)
m.Add(o.GetBasicEntity(), o.GetMouseComponent(), o.GetSpaceComponent(), o.GetRenderComponent())
} | go | {
"resource": ""
} |
q12652 | Remove | train | func (m *MouseSystem) Remove(basic ecs.BasicEntity) {
var delete = -1
for index, entity := range m.entities {
if entity.ID() == basic.ID() {
delete = index
break
}
}
if delete >= 0 {
m.entities = append(m.entities[:delete], m.entities[delete+1:]...)
}
} | go | {
"resource": ""
} |
q12653 | Close | train | func (s *Stream) Close() error {
if s.resampling != nil {
return s.resampling.Close()
}
return nil
} | go | {
"resource": ""
} |
q12654 | Decode | train | func Decode(src convert.ReadSeekCloser, sr int) (*Stream, error) {
d, err := mp3.NewDecoder(src)
if err != nil {
return nil, err
}
var r *convert.Resampling
stream := &Stream{
orig: d,
resampling: r,
}
if d.SampleRate() != sr {
stream.resampling = convert.NewResampling(stream, stream.orig.Length(), stream.orig.SampleRate(), sr)
}
return stream, nil
} | go | {
"resource": ""
} |
q12655 | Load | train | func (a *audioLoader) Load(url string, data io.Reader) error {
var err error
audioBytes, err := ioutil.ReadAll(data)
if err != nil {
return err
}
audioBuffer := bytes.NewReader(audioBytes)
var player *Player
switch getExt(url) {
case ".wav":
d, err := wav.Decode(&readSeekCloserBuffer{audioBuffer}, SampleRate)
if err != nil {
return err
}
player, err = newPlayer(d, url)
if err != nil {
return err
}
case ".mp3":
d, err := mp3.Decode(&readSeekCloserBuffer{audioBuffer}, SampleRate)
if err != nil {
return err
}
player, err = newPlayer(d, url)
if err != nil {
return err
}
case ".ogg":
d, err := vorbis.Decode(&readSeekCloserBuffer{audioBuffer}, SampleRate)
if err != nil {
return err
}
player, err = newPlayer(d, url)
if err != nil {
return err
}
}
a.audios[url] = player
return nil
} | go | {
"resource": ""
} |
q12656 | Unload | train | func (a *audioLoader) Unload(url string) error {
delete(a.audios, url)
return nil
} | go | {
"resource": ""
} |
q12657 | Resource | train | func (a *audioLoader) Resource(url string) (engo.Resource, error) {
texture, ok := a.audios[url]
if !ok {
return nil, fmt.Errorf("resource not loaded by `FileLoader`: %q", url)
}
return texture, nil
} | go | {
"resource": ""
} |
q12658 | Set | train | func (p *Point) Set(x, y float32) *Point {
p.X = x
p.Y = y
return p
} | go | {
"resource": ""
} |
q12659 | AddScalar | train | func (p *Point) AddScalar(s float32) *Point {
p.X += s
p.Y += s
return p
} | go | {
"resource": ""
} |
q12660 | SubtractScalar | train | func (p *Point) SubtractScalar(s float32) *Point {
p.AddScalar(-s)
return p
} | go | {
"resource": ""
} |
q12661 | MultiplyScalar | train | func (p *Point) MultiplyScalar(s float32) *Point {
p.X *= s
p.Y *= s
return p
} | go | {
"resource": ""
} |
q12662 | Subtract | train | func (p *Point) Subtract(p2 Point) *Point {
p.X -= p2.X
p.Y -= p2.Y
return p
} | go | {
"resource": ""
} |
q12663 | Equal | train | func (p *Point) Equal(p2 Point) bool {
return FloatEqual(p.X, p2.X) && FloatEqual(p.Y, p2.Y)
} | go | {
"resource": ""
} |
q12664 | PointDistance | train | func (p *Point) PointDistance(p2 Point) float32 {
return math.Sqrt(p.PointDistanceSquared(p2))
} | go | {
"resource": ""
} |
q12665 | PointDistanceSquared | train | func (p *Point) PointDistanceSquared(p2 Point) float32 {
return (p.X-p2.X)*(p.X-p2.X) + (p.Y-p2.Y)*(p.Y-p2.Y)
} | go | {
"resource": ""
} |
q12666 | ProjectOnto | train | func (p *Point) ProjectOnto(p2 Point) Point {
dot := p.X*p2.X + p.Y*p2.Y
denom := p2.X*p2.X + p2.Y*p2.Y
if FloatEqual(denom, 0) {
return Point{}
}
return Point{
dot / denom * p2.X,
dot / denom * p2.Y,
}
} | go | {
"resource": ""
} |
q12667 | Normalize | train | func (p *Point) Normalize() (Point, float32) {
if p.X == 0 && p.Y == 0 {
return *p, 0
}
mag := math.Sqrt(p.X*p.X + p.Y*p.Y)
unit := Point{p.X / mag, p.Y / mag}
return unit, mag
} | go | {
"resource": ""
} |
q12668 | Set | train | func (m *Matrix) Set(val []float32) *Matrix {
copy(m.Val[:], val)
return m
} | go | {
"resource": ""
} |
q12669 | Identity | train | func (m *Matrix) Identity() *Matrix {
m.Val[m00] = 1
m.Val[m10] = 0
m.Val[m20] = 0
m.Val[m01] = 0
m.Val[m11] = 1
m.Val[m21] = 0
m.Val[m02] = 0
m.Val[m12] = 0
m.Val[m22] = 1
return m
} | go | {
"resource": ""
} |
q12670 | Multiply | train | func (m *Matrix) Multiply(m2 *Matrix) *Matrix {
multiplyMatricies(m.Val[:], m2.Val[:])
return m
} | go | {
"resource": ""
} |
q12671 | TranslatePoint | train | func (m *Matrix) TranslatePoint(p Point) *Matrix {
return m.Translate(p.X, p.Y)
} | go | {
"resource": ""
} |
q12672 | ScaleComponent | train | func (m *Matrix) ScaleComponent() (x, y float32) {
return m.Val[m00], m.Val[m11]
} | go | {
"resource": ""
} |
q12673 | TranslationComponent | train | func (m *Matrix) TranslationComponent() (x, y float32) {
return m.Val[m02], m.Val[m12]
} | go | {
"resource": ""
} |
q12674 | RotationComponentRad | train | func (m *Matrix) RotationComponentRad() float32 {
return math.Atan2(m.Val[m10], m.Val[m00])
} | go | {
"resource": ""
} |
q12675 | Rotate | train | func (m *Matrix) Rotate(deg float32) *Matrix {
return m.RotateRad(deg * DegToRad)
} | go | {
"resource": ""
} |
q12676 | RotateRad | train | func (m *Matrix) RotateRad(rad float32) *Matrix {
if rad == 0 {
return m
}
sin, cos := math.Sincos(rad)
m.tmp[m00] = cos
m.tmp[m10] = sin
m.tmp[m20] = 0
m.tmp[m01] = -sin
m.tmp[m11] = cos
m.tmp[m21] = 0
m.tmp[m02] = 0
m.tmp[m12] = 0
m.tmp[m22] = 1
multiplyMatricies(m.Val[:], m.tmp[:])
return m
} | go | {
"resource": ""
} |
q12677 | PointDistance | train | func (l *Line) PointDistance(point Point) float32 {
return math.Sqrt(l.PointDistanceSquared(point))
} | go | {
"resource": ""
} |
q12678 | PointDistanceSquared | train | func (l *Line) PointDistanceSquared(point Point) float32 {
p1 := l.P1
p2 := l.P2
x0 := point.X
y0 := point.Y
x1 := p1.X
y1 := p1.Y
x2 := p2.X
y2 := p2.Y
l2 := (y2-y1)*(y2-y1) + (x2-x1)*(x2-x1)
if l2 == 0 {
return (y0-y1)*(y0-y1) + (x0-x1)*(x0-x1)
}
t := ((x0-x1)*(x2-x1) + (y0-y1)*(y2-y1)) / l2
if t < 0 {
return (y0-y1)*(y0-y1) + (x0-x1)*(x0-x1)
} else if t > 1 {
return (y0-y2)*(y0-y2) + (x0-x2)*(x0-x2)
}
return (x0-(x1+t*(x2-x1)))*(x0-(x1+t*(x2-x1))) +
(y0-(y1+t*(y2-y1)))*(y0-(y1+t*(y2-y1)))
} | go | {
"resource": ""
} |
q12679 | Normal | train | func (l *Line) Normal() Point {
dx := l.P2.X - l.P1.X
dy := l.P2.Y - l.P1.Y
inverse := Point{dy, -dx}
unit, _ := inverse.Normalize()
return unit
} | go | {
"resource": ""
} |
q12680 | DotProduct | train | func DotProduct(this, that Point) float32 {
return this.X*that.X + this.Y*that.Y
} | go | {
"resource": ""
} |
q12681 | CrossProduct | train | func CrossProduct(this, that Point) float32 {
return this.X*that.Y - this.Y*that.X
} | go | {
"resource": ""
} |
q12682 | LineIntersection | train | func LineIntersection(one, two Line) (Point, bool) {
p := one.P1
q := two.P1
r := one.P2
r.Subtract(p)
s := two.P2
s.Subtract(q)
// t = (q − p) × s / (r × s)
// u = (q − p) × r / (r × s)
// So then we define
// qmp = (q - p)
// rcs = (r × s)
// and we get simply:
// t = qmp × s / rcs
// u = qmp × r / rcs
qmp := q
qmp.Subtract(p)
qmpcs := CrossProduct(qmp, s)
qmpcr := CrossProduct(qmp, r)
rcs := CrossProduct(r, s)
t := qmpcs / rcs
u := qmpcr / rcs
// if rcs == 0 then it's either collinear or parallel. It'll be +/- inf, so it'll skip this statement and return at the end
if t >= 0 && t <= 1 && u >= 0 && u <= 1 {
// the two line segments meet at the point p + t r = q + u s.
return Point{p.X + t*r.X, p.Y + t*r.Y}, true
}
return Point{}, false
} | go | {
"resource": ""
} |
q12683 | LineTraceFraction | train | func LineTraceFraction(tracer, boundary Line) float32 {
pt, intersect := LineIntersection(tracer, boundary)
if !intersect {
return 1
}
traceMag := tracer.P1.PointDistance(pt)
lineMag := tracer.P1.PointDistance(tracer.P2)
return traceMag / lineMag
} | go | {
"resource": ""
} |
q12684 | LineTrace | train | func LineTrace(tracer Line, boundaries []Line) Trace {
var t Trace
t.Fraction = math.Inf(1)
for _, cl := range boundaries {
fraction := LineTraceFraction(tracer, cl)
if fraction < t.Fraction {
t.Fraction = fraction
t.Line = cl
moveVector := tracer.P2
moveVector.Subtract(tracer.P1)
moveVector.MultiplyScalar(t.Fraction)
t.EndPosition = tracer.P1
t.EndPosition.Add(moveVector)
}
}
return t
} | go | {
"resource": ""
} |
q12685 | MultiplyMatrixVector | train | func MultiplyMatrixVector(m *Matrix, v []float32) []float32 {
if len(v) == 2 {
v = []float32{v[0], v[1], 1}
}
v00 := m.Val[m00]*v[m00] + m.Val[m01]*v[m10] + m.Val[m02]*v[m20]
v10 := m.Val[m10]*v[m00] + m.Val[m11]*v[m10] + m.Val[m12]*v[m20]
v20 := m.Val[m20]*v[m00] + m.Val[m21]*v[m10] + m.Val[m22]*v[m20]
return []float32{v00, v10, v20}
} | go | {
"resource": ""
} |
q12686 | MultiplyMatrixVector | train | func (p *Point) MultiplyMatrixVector(m *Matrix) *Point {
x := m.Val[m00]*p.X + m.Val[m01]*p.Y + m.Val[m02]
y := m.Val[m10]*p.X + m.Val[m11]*p.Y + m.Val[m12]
p.X, p.Y = x, y
return p
} | go | {
"resource": ""
} |
q12687 | UploadTexture | train | func UploadTexture(img Image) *gl.Texture {
var id *gl.Texture
if !engo.Headless() {
id = engo.Gl.CreateTexture()
engo.Gl.BindTexture(engo.Gl.TEXTURE_2D, id)
engo.Gl.TexParameteri(engo.Gl.TEXTURE_2D, engo.Gl.TEXTURE_WRAP_S, engo.Gl.CLAMP_TO_EDGE)
engo.Gl.TexParameteri(engo.Gl.TEXTURE_2D, engo.Gl.TEXTURE_WRAP_T, engo.Gl.CLAMP_TO_EDGE)
engo.Gl.TexParameteri(engo.Gl.TEXTURE_2D, engo.Gl.TEXTURE_MIN_FILTER, engo.Gl.LINEAR)
engo.Gl.TexParameteri(engo.Gl.TEXTURE_2D, engo.Gl.TEXTURE_MAG_FILTER, engo.Gl.NEAREST)
if img.Data() == nil {
panic("Texture image data is nil.")
}
engo.Gl.TexImage2D(engo.Gl.TEXTURE_2D, 0, engo.Gl.RGBA, engo.Gl.RGBA, engo.Gl.UNSIGNED_BYTE, img.Data())
}
return id
} | go | {
"resource": ""
} |
q12688 | NewTextureResource | train | func NewTextureResource(img Image) TextureResource {
id := UploadTexture(img)
return TextureResource{Texture: id, Width: float32(img.Width()), Height: float32(img.Height())}
} | go | {
"resource": ""
} |
q12689 | NewTextureSingle | train | func NewTextureSingle(img Image) Texture {
id := UploadTexture(img)
return Texture{id, float32(img.Width()), float32(img.Height()), engo.AABB{Max: engo.Point{X: 1.0, Y: 1.0}}}
} | go | {
"resource": ""
} |
q12690 | ImageToNRGBA | train | func ImageToNRGBA(img image.Image, width, height int) *image.NRGBA {
newm := image.NewNRGBA(image.Rect(0, 0, width, height))
draw.Draw(newm, newm.Bounds(), img, image.Point{0, 0}, draw.Src)
return newm
} | go | {
"resource": ""
} |
q12691 | Close | train | func (t Texture) Close() {
if !engo.Headless() {
engo.Gl.DeleteTexture(t.id)
}
} | go | {
"resource": ""
} |
q12692 | decode | train | func decode(in convert.ReadSeekCloser) (*decoded, int, int, error) {
r, err := oggvorbis.NewReader(in)
if err != nil {
return nil, 0, 0, err
}
d := &decoded{
data: make([]float32, r.Length()*2),
totalBytes: int(r.Length()) * 4, // TODO: What if length is 0?
posInBytes: 0,
source: in,
decoder: r,
}
runtime.SetFinalizer(d, (*decoded).Close)
if _, err := d.Read(make([]uint8, 65536)); err != nil {
return nil, 0, 0, err
}
if _, err := d.Seek(0, io.SeekStart); err != nil {
return nil, 0, 0, err
}
return d, r.Channels(), r.SampleRate(), nil
} | go | {
"resource": ""
} |
q12693 | Value | train | func (a Axis) Value() float32 {
for _, pair := range a.Pairs {
v := pair.Value()
if v != AxisNeutral {
return v
}
}
return AxisNeutral
} | go | {
"resource": ""
} |
q12694 | Value | train | func (keys AxisKeyPair) Value() float32 {
if Input.keys.Get(keys.Max).Down() {
return AxisMax
} else if Input.keys.Get(keys.Min).Down() {
return AxisMin
}
return AxisNeutral
} | go | {
"resource": ""
} |
q12695 | NewAxisMouse | train | func NewAxisMouse(d AxisMouseDirection) *AxisMouse {
old := Input.Mouse.Y
if d == AxisMouseHori {
old = Input.Mouse.X
}
return &AxisMouse{
direction: d,
old: old,
}
} | go | {
"resource": ""
} |
q12696 | Value | train | func (am *AxisMouse) Value() float32 {
var diff float32
if am.direction == AxisMouseHori {
diff = (Input.Mouse.X - am.old + (ResizeXOffset / (2 * GetGlobalScale().X * CanvasScale())))
am.old = (Input.Mouse.X + (ResizeXOffset / (2 * GetGlobalScale().X * CanvasScale())))
} else {
diff = (Input.Mouse.Y - am.old + (ResizeYOffset / (2 * GetGlobalScale().Y * CanvasScale())))
am.old = (Input.Mouse.Y + (ResizeYOffset / (2 * GetGlobalScale().Y * CanvasScale())))
}
return diff
} | go | {
"resource": ""
} |
q12697 | NewBackground | train | func NewBackground(world *ecs.World, width, height int, colorA, colorB color.Color) *Background {
rect := image.Rect(0, 0, width, height)
img := image.NewNRGBA(rect)
for i := rect.Min.X; i < rect.Max.X; i++ {
for j := rect.Min.Y; j < rect.Max.Y; j++ {
if i%40 > 20 {
if j%40 > 20 {
img.Set(i, j, colorA)
} else {
img.Set(i, j, colorB)
}
} else {
if j%40 > 20 {
img.Set(i, j, colorB)
} else {
img.Set(i, j, colorA)
}
}
}
}
bgTexture := common.NewImageObject(img)
bg := &Background{BasicEntity: ecs.NewBasic()}
bg.RenderComponent = common.RenderComponent{Drawable: common.NewTextureSingle(bgTexture)}
bg.SpaceComponent = common.SpaceComponent{
Position: engo.Point{0, 0},
Width: float32(width),
Height: float32(height),
}
for _, system := range world.Systems() {
switch sys := system.(type) {
case *common.RenderSystem:
sys.Add(&bg.BasicEntity, &bg.RenderComponent, &bg.SpaceComponent)
}
}
return bg
} | go | {
"resource": ""
} |
q12698 | openFile | train | func openFile(url string) (io.ReadCloser, error) {
usedUrl := url
if strings.HasPrefix(url, "assets/") {
usedUrl = usedUrl[7:]
}
return asset.Open(usedUrl)
} | go | {
"resource": ""
} |
q12699 | RunPreparation | train | func RunPreparation(defaultScene Scene) {
windowWidth = float32(opts.MobileWidth)
canvasWidth = float32(opts.MobileWidth)
windowHeight = float32(opts.MobileHeight)
canvasHeight = float32(opts.MobileHeight)
ResizeXOffset = gameWidth - canvasWidth
ResizeYOffset = gameHeight - canvasHeight
Gl.Viewport(0, 0, opts.MobileWidth, opts.MobileHeight)
Time = NewClock()
SetScene(defaultScene, false)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.