_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")
... | 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 \"@[")... | 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:")
... | 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 ... | 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.Pri... | 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] [NewSpr... | 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.(TextureResou... | 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... | 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)
ret... | 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.MULT... | 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.shad... | 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]s... | 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... | 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,... | 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... | 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(... | 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 {
ca... | 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 charact... | 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 `Re... | 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(),... | 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}, SampleR... | 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 <... | 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 / rc... | 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.Mu... | 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 ... | 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_WRA... | 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: ... | 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 ... | 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... | 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.M... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.