id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c12600 | predicate or literal for opening \" delimiter")
return nil
}
if pIdx > 0 && (lIdx < 0 || pIdx < lIdx) {
return lexPredicate
}
return lexLiteral
} | |
c12601 | 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; missi... | |
c12602 | 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
... | |
c12603 | == eof {
l.backup()
l.emit(t)
break
}
}
} | |
c12604 | Text: l.input[l.start:l.pos],
ErrorMessage: fmt.Sprintf("[lexer:%d:%d] %s", l.line, l.col, msg),
}
l.start = l.pos
} | |
c12605 | return true
}
l.backup()
return false
} | |
c12606 | {
return base64.StdEncoding.EncodeToString([]byte(uuid))
} | |
c12607 | {
return nil, fmt.Errorf("invalid UUID size; got %d, want %d", got, want)
}
return uuid.UUID(bs), nil
} | |
c12608 | float32(float64(c.deltaStamp) / float64(secondsInNano))
} | |
c12609 | float32(float64(currStamp-c.startStamp) / float64(secondsInNano))
} | |
c12610 | formats.formats[ext] = loader
} | |
c12611 |
}
defer f.Close()
return loader.Load(url, f)
}
return fmt.Errorf("no `FileLoader` associated with this extension: %q in url %q", ext, url)
} | |
c12612 |
}
return fmt.Errorf("no `FileLoader` associated with this extension: %q in url %q", ext, url)
} | |
c12613 | return fmt.Errorf("no `FileLoader` associated with this extension: %q in url %q", ext, url)
} | |
c12614 |
return &Spritesheet{
texture: tr.Texture,
width: tr.Width,
height: tr.Height,
cells: spriteRegions,
cache: make(map[int]Texture),
}
} | |
c12615 | {
log.Println("[WARNING] [NewAsymmetricSpritesheetFromFile]: Resource not of type `TextureResource`:", textureName)
return nil
}
return NewAsymmetricSpritesheetFromTexture(&img, spriteRegions)
} | |
c12616 | cellHeight, 0, 0)
return NewAsymmetricSpritesheetFromTexture(tr, spriteRegions)
} | |
c12617 | {
log.Println("[WARNING] [NewSpritesheetFromFile]: Resource not of type `TextureResource`:", textureName)
return nil
}
return NewSpritesheetFromTexture(&img, cellWidth, cellHeight)
} | |
c12618 | {
spriteRegions := generateSymmetricSpriteRegions(tr.Width, tr.Height, cellWidth, cellHeight, borderWidth, borderHeight)
return NewAsymmetricSpritesheetFromTexture(tr, spriteRegions)
} | |
c12619 | {
log.Println("[WARNING] [NewSpritesheetWithBorderFromFile]: Resource not of type `TextureResource`:", textureName)
return nil
}
return NewSpritesheetWithBorderFromTexture(&img, cellWidth, cellHeight, borderWidth, borderHeight)
} | |
c12620 | 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]
} | |
c12621 | s.CellCount(); i++ {
drawables[i] = s.Drawable(i)
}
return drawables
} | |
c12622 | < cellsNo; i++ {
cells[i] = s.Cell(i)
}
return cells
} | |
c12623 | blue := colorB << 16
alpha := colorA << 24
return math.Float32frombits((alpha | blue | green | red) & 0xfeffffff)
} | |
c12624 | 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, n... | |
c12625 | s
engo.Mailbox.Dispatch(&renderChangeMessage{})
} | |
c12626 | index
engo.Mailbox.Dispatch(&renderChangeMessage{})
} | |
c12627 | z
engo.Mailbox.Dispatch(renderChangeMessage{})
} | |
c12628 | z
engo.Mailbox.Dispatch(renderChangeMessage{})
} | |
c12629 |
})
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
})
} | |
c12630 | 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{b... | |
c12631 | entity.ID() == basic.ID() {
return index
}
}
return -1
} | |
c12632 | o.GetRenderComponent(), o.GetSpaceComponent())
} | |
c12633 | = append(rs.entities[:d], rs.entities[d+1:]...)
rs.sortingNeeded = true
}
delete(rs.ids, basic.ID())
} | |
c12634 | = 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()
}
sh... | |
c12635 | engo.Gl.ClearColor(float32(r)/0xffff, float32(g)/0xffff, float32(b)/0xffff, float32(a)/0xffff)
}
} | |
c12636 | 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 Ot... | |
c12637 | = append(a.entities, audioEntity{basic, audio})
} | |
c12638 | {
o, _ := i.(Audioable)
a.Add(o.GetBasicEntity(), o.GetAudioComponent())
} | |
c12639 | }
if delete >= 0 {
a.entities = append(a.entities[:delete], a.entities[delete+1:]...)
}
} | |
c12640 | range a.entities {
if e.Player.isPlaying {
players = append(players, e.Player)
}
}
a.playerCh <- players
} | |
c12641 | 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
} | |
c12642 | buttons: make(map[string]Button),
keys: NewKeyManager(),
}
} | |
c12643 | = Axis{
Name: name,
Pairs: pairs,
}
} | |
c12644 | = Button{
Triggers: keys,
Name: name,
}
} | |
c12645 |
f.face = truetype.NewFace(f.TTF, &truetype.Options{
Size: f.Size,
DPI: dpi,
Hinting: font.HintingFull,
})
return nil
} | |
c12646 | 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)
totalWid... | |
c12647 |
// Create texture
imObj := NewImageObject(nrgba)
return NewTextureSingle(imObj)
} | |
c12648 | }
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
} | |
c12649 | 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
} | |
c12650 | }
}
if m.camera == nil {
log.Println("ERROR: CameraSystem not found - have you added the `RenderSystem` before the `MouseSystem`?")
return
}
} | |
c12651 | o.GetMouseComponent(), o.GetSpaceComponent(), o.GetRenderComponent())
} | |
c12652 |
}
}
if delete >= 0 {
m.entities = append(m.entities[:delete], m.entities[delete+1:]...)
}
} | |
c12653 | return s.resampling.Close()
}
return nil
} | |
c12654 |
}
if d.SampleRate() != sr {
stream.resampling = convert.NewResampling(stream, stream.orig.Length(), stream.orig.SampleRate(), sr)
}
return stream, nil
} | |
c12655 | }
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(&readSeekClos... | |
c12656 | error {
delete(a.audios, url)
return nil
} | |
c12657 | fmt.Errorf("resource not loaded by `FileLoader`: %q", url)
}
return texture, nil
} | |
c12658 | = x
p.Y = y
return p
} | |
c12659 | += s
p.Y += s
return p
} | |
c12660 | p.AddScalar(-s)
return p
} | |
c12661 | p.X *= s
p.Y *= s
return p
} | |
c12662 | -= p2.X
p.Y -= p2.Y
return p
} | |
c12663 |
return FloatEqual(p.X, p2.X) && FloatEqual(p.Y, p2.Y)
} | |
c12664 | math.Sqrt(p.PointDistanceSquared(p2))
} | |
c12665 | (p.X-p2.X)*(p.X-p2.X) + (p.Y-p2.Y)*(p.Y-p2.Y)
} | |
c12666 | return Point{}
}
return Point{
dot / denom * p2.X,
dot / denom * p2.Y,
}
} | |
c12667 | := math.Sqrt(p.X*p.X + p.Y*p.Y)
unit := Point{p.X / mag, p.Y / mag}
return unit, mag
} | |
c12668 | *Matrix {
copy(m.Val[:], val)
return m
} | |
c12669 | 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
} | |
c12670 | multiplyMatricies(m.Val[:], m2.Val[:])
return m
} | |
c12671 | return m.Translate(p.X, p.Y)
} | |
c12672 |
return m.Val[m00], m.Val[m11]
} | |
c12673 |
return m.Val[m02], m.Val[m12]
} | |
c12674 | math.Atan2(m.Val[m10], m.Val[m00])
} | |
c12675 | m.RotateRad(deg * DegToRad)
} | |
c12676 | m.tmp[m21] = 0
m.tmp[m02] = 0
m.tmp[m12] = 0
m.tmp[m22] = 1
multiplyMatricies(m.Val[:], m.tmp[:])
return m
} | |
c12677 | math.Sqrt(l.PointDistanceSquared(point))
} | |
c12678 | {
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)))
} | |
c12679 | unit, _ := inverse.Normalize()
return unit
} | |
c12680 | this.X*that.X + this.Y*that.Y
} | |
c12681 | this.X*that.Y - this.Y*that.X
} | |
c12682 | 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
} | |
c12683 | }
traceMag := tracer.P1.PointDistance(pt)
lineMag := tracer.P1.PointDistance(tracer.P2)
return traceMag / lineMag
} | |
c12684 | = cl
moveVector := tracer.P2
moveVector.Subtract(tracer.P1)
moveVector.MultiplyScalar(t.Fraction)
t.EndPosition = tracer.P1
t.EndPosition.Add(moveVector)
}
}
return t
} | |
c12685 | 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}
} | |
c12686 | m.Val[m11]*p.Y + m.Val[m12]
p.X, p.Y = x, y
return p
} | |
c12687 | 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
} | |
c12688 | Width: float32(img.Width()), Height: float32(img.Height())}
} | |
c12689 | float32(img.Height()), engo.AABB{Max: engo.Point{X: 1.0, Y: 1.0}}}
} | |
c12690 | draw.Draw(newm, newm.Bounds(), img, image.Point{0, 0}, draw.Src)
return newm
} | |
c12691 | {
engo.Gl.DeleteTexture(t.id)
}
} | |
c12692 | 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
} | |
c12693 | v != AxisNeutral {
return v
}
}
return AxisNeutral
} | |
c12694 | Input.keys.Get(keys.Min).Down() {
return AxisMin
}
return AxisNeutral
} | |
c12695 | if d == AxisMouseHori {
old = Input.Mouse.X
}
return &AxisMouse{
direction: d,
old: old,
}
} | |
c12696 | (Input.Mouse.Y - am.old + (ResizeYOffset / (2 * GetGlobalScale().Y * CanvasScale())))
am.old = (Input.Mouse.Y + (ResizeYOffset / (2 * GetGlobalScale().Y * CanvasScale())))
}
return diff
} | |
c12697 | }
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),
}
... | |
c12698 |
if strings.HasPrefix(url, "assets/") {
usedUrl = usedUrl[7:]
}
return asset.Open(usedUrl)
} | |
c12699 | canvasHeight = float32(opts.MobileHeight)
ResizeXOffset = gameWidth - canvasWidth
ResizeYOffset = gameHeight - canvasHeight
Gl.Viewport(0, 0, opts.MobileWidth, opts.MobileHeight)
Time = NewClock()
SetScene(defaultScene, false)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.