_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q169600 | native | validation | func (v *Pattern) native() *C.cairo_pattern_t {
if v == nil {
return nil
}
return v.pattern
} | go | {
"resource": ""
} |
q169601 | native | validation | func (v *Window) native() *C.GtkWindow {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGtkWindow(p)
} | go | {
"resource": ""
} |
q169602 | native | validation | func (v Atom) native() C.GdkAtom {
return C.toGdkAtom(unsafe.Pointer(uintptr(v)))
} | go | {
"resource": ""
} |
q169603 | GdkAtomIntern | validation | func GdkAtomIntern(atomName string, onlyIfExists bool) Atom {
cstr := C.CString(atomName)
defer C.free(unsafe.Pointer(cstr))
c := C.gdk_atom_intern((*C.gchar)(cstr), gbool(onlyIfExists))
return Atom(uintptr(unsafe.Pointer(c)))
} | go | {
"resource": ""
} |
q169604 | native | validation | func (v *Device) native() *C.GdkDevice {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGdkDevice(p)
} | go | {
"resource": ""
} |
q169605 | native | validation | func (v *Cursor) native() *C.GdkCursor {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGdkCursor(p)
} | go | {
"resource": ""
} |
q169606 | native | validation | func (v *DeviceManager) native() *C.GdkDeviceManager {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGdkDeviceManager(p)
} | go | {
"resource": ""
} |
q169607 | native | validation | func (v *Display) native() *C.GdkDisplay {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGdkDisplay(p)
} | go | {
"resource": ""
} |
q169608 | native | validation | func (v *DragContext) native() *C.GdkDragContext {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGdkDragContext(p)
} | go | {
"resource": ""
} |
q169609 | native | validation | func (v *Event) native() *C.GdkEvent {
if v == nil {
return nil
}
return v.GdkEvent
} | go | {
"resource": ""
} |
q169610 | XRoot | validation | func (v *EventButton) XRoot() float64 {
c := v.native().x_root
return float64(c)
} | go | {
"resource": ""
} |
q169611 | YRoot | validation | func (v *EventButton) YRoot() float64 {
c := v.native().y_root
return float64(c)
} | go | {
"resource": ""
} |
q169612 | SetColors | validation | func (c *RGBA) SetColors(r, g, b, a float64) {
c.rgba.red = C.gdouble(r)
c.rgba.green = C.gdouble(g)
c.rgba.blue = C.gdouble(b)
c.rgba.alpha = C.gdouble(a)
} | go | {
"resource": ""
} |
q169613 | native | validation | func (v *Window) native() *C.GdkWindow {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGdkWindow(p)
} | go | {
"resource": ""
} |
q169614 | ClosureNew | validation | func ClosureNew(f interface{}, marshalData ...interface{}) (*C.GClosure, error) {
// Create a reflect.Value from f. This is called when the
// returned GClosure runs.
rf := reflect.ValueOf(f)
// Create closure context which points to the reflected func.
cc := closureContext{rf: rf}
// Closures can only be crea... | go | {
"resource": ""
} |
q169615 | native | validation | func (v *ColorChooser) native() *C.GtkColorChooser {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGtkColorChooser(p)
} | go | {
"resource": ""
} |
q169616 | native | validation | func (v *ColorChooserDialog) native() *C.GtkColorChooserDialog {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGtkColorChooserDialog(p)
} | go | {
"resource": ""
} |
q169617 | native | validation | func (v *Source) native() *C.GSource {
if v == nil {
return nil
}
return (*C.GSource)(v)
} | go | {
"resource": ""
} |
q169618 | Translate | validation | func (v *Context) Translate(tx, ty float64) {
C.cairo_translate(v.native(), C.double(tx), C.double(ty))
} | go | {
"resource": ""
} |
q169619 | Scale | validation | func (v *Context) Scale(sx, sy float64) {
C.cairo_scale(v.native(), C.double(sx), C.double(sy))
} | go | {
"resource": ""
} |
q169620 | Rotate | validation | func (v *Context) Rotate(angle float64) {
C.cairo_rotate(v.native(), C.double(angle))
} | go | {
"resource": ""
} |
q169621 | Transform | validation | func (v *Context) Transform(matrix *Matrix) {
C.cairo_transform(v.native(), matrix.native())
} | go | {
"resource": ""
} |
q169622 | SetMatrix | validation | func (v *Context) SetMatrix(matrix *Matrix) {
C.cairo_set_matrix(v.native(), matrix.native())
} | go | {
"resource": ""
} |
q169623 | GetMatrix | validation | func (v *Context) GetMatrix() *Matrix {
var matrix C.cairo_matrix_t
C.cairo_get_matrix(v.native(), &matrix)
return &Matrix{
Xx: float64(matrix.xx),
Yx: float64(matrix.yx),
Xy: float64(matrix.xy),
Yy: float64(matrix.yy),
X0: float64(matrix.x0),
Y0: float64(matrix.y0),
}
} | go | {
"resource": ""
} |
q169624 | UserToDevice | validation | func (v *Context) UserToDevice(x, y float64) (float64, float64) {
C.cairo_user_to_device(v.native(), (*C.double)(&x), (*C.double)(&y))
return x, y
} | go | {
"resource": ""
} |
q169625 | UserToDeviceDistance | validation | func (v *Context) UserToDeviceDistance(dx, dy float64) (float64, float64) {
C.cairo_user_to_device_distance(v.native(), (*C.double)(&dx), (*C.double)(&dy))
return dx, dy
} | go | {
"resource": ""
} |
q169626 | DeviceToUser | validation | func (v *Context) DeviceToUser(x, y float64) (float64, float64) {
C.cairo_device_to_user(v.native(), (*C.double)(&x), (*C.double)(&y))
return x, y
} | go | {
"resource": ""
} |
q169627 | DeviceToUserDistance | validation | func (v *Context) DeviceToUserDistance(x, y float64) (float64, float64) {
C.cairo_device_to_user_distance(v.native(), (*C.double)(&x), (*C.double)(&y))
return x, y
} | go | {
"resource": ""
} |
q169628 | Draw | validation | func (s *Sprite) Draw(screen *ebiten.Image, dx, dy int, alpha float64) {
op := &ebiten.DrawImageOptions{}
op.GeoM.Translate(float64(s.x+dx), float64(s.y+dy))
op.ColorM.Scale(1, 1, 1, alpha)
screen.DrawImage(s.image, op)
screen.DrawImage(s.image, op)
} | go | {
"resource": ""
} |
q169629 | Length | validation | func (s *Stream) Length() int64 {
if s.resampling != nil {
return s.resampling.Length()
}
return s.orig.Length()
} | go | {
"resource": ""
} |
q169630 | Decode | validation | func Decode(context *audio.Context, src audio.ReadSeekCloser) (*Stream, error) {
d, err := mp3.NewDecoder(src)
if err != nil {
return nil, err
}
var r *convert.Resampling
if d.SampleRate() != context.SampleRate() {
r = convert.NewResampling(d, d.Length(), d.SampleRate(), context.SampleRate())
}
s := &Stream... | go | {
"resource": ""
} |
q169631 | IsMouseButtonPressed | validation | func IsMouseButtonPressed(mouseButton MouseButton) bool {
return uiDriver().Input().IsMouseButtonPressed(driver.MouseButton(mouseButton))
} | go | {
"resource": ""
} |
q169632 | Touches | validation | func Touches() []Touch {
var ts []Touch
for _, id := range TouchIDs() {
x, y := TouchPosition(id)
ts = append(ts, &touch{
id: id,
x: x,
y: y,
})
}
return ts
} | go | {
"resource": ""
} |
q169633 | paeth | validation | func paeth(a, b, c uint8) uint8 {
// This is an optimized version of the sample code in the PNG spec.
// For example, the sample code starts with:
// p := int(a) + int(b) - int(c)
// pa := abs(p - int(a))
// but the optimized form uses fewer arithmetic operations:
// pa := int(b) - int(c)
// pa = abs(pa)
pc := ... | go | {
"resource": ""
} |
q169634 | filterPaeth | validation | func filterPaeth(cdat, pdat []byte, bytesPerPixel int) {
var a, b, c, pa, pb, pc int
for i := 0; i < bytesPerPixel; i++ {
a, c = 0, 0
for j := i; j < len(cdat); j += bytesPerPixel {
b = int(pdat[j])
pa = b - c
pb = a - c
pc = abs(pa + pb)
pa = abs(pa)
pb = abs(pb)
if pa <= pb && pa <= pc {
... | go | {
"resource": ""
} |
q169635 | MipmapLevel | validation | func MipmapLevel(det float32) int {
if math.IsNaN(float64(det)) {
panic("graphicsutil: det must be finite")
}
if det == 0 {
return -1
}
d := math.Abs(float64(det))
level := 0
for d < 0.25 {
level++
d *= 4
}
return level
} | go | {
"resource": ""
} |
q169636 | hideConsoleWindowOnWindows | validation | func hideConsoleWindowOnWindows() {
pid, err := getCurrentProcessId()
if err != nil {
// Ignore errors because:
// 1. It is not critical if the console can't be hid.
// 2. There is nothing to do when errors happen.
return
}
w, err := getConsoleWindow()
if err != nil {
// Ignore errors
return
}
// Get... | go | {
"resource": ""
} |
q169637 | DepthMask | validation | func DepthMask(flag bool) {
C.glowDepthMask(gpDepthMask, (C.GLboolean)(boolToInt(flag)))
} | go | {
"resource": ""
} |
q169638 | EdgeFlag | validation | func EdgeFlag(flag bool) {
C.glowEdgeFlag(gpEdgeFlag, (C.GLboolean)(boolToInt(flag)))
} | go | {
"resource": ""
} |
q169639 | TexImage3D | validation | func TexImage3D(target uint32, level int32, internalformat int32, width int32, height int32, depth int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) {
C.glowTexImage3D(gpTexImage3D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsiz... | go | {
"resource": ""
} |
q169640 | QuadVertices | validation | func (i *Image) QuadVertices(sx0, sy0, sx1, sy1 int, a, b, c, d, tx, ty float32, cr, cg, cb, ca float32) []float32 {
if i.backend == nil {
i.allocate(true)
}
ox, oy, _, _ := i.region()
return i.backend.restorable.QuadVertices(sx0+ox, sy0+oy, sx1+ox, sy1+oy, a, b, c, d, tx, ty, cr, cg, cb, ca)
} | go | {
"resource": ""
} |
q169641 | PutVertex | validation | func (i *Image) PutVertex(dest []float32, dx, dy, sx, sy float32, bx0, by0, bx1, by1 float32, cr, cg, cb, ca float32) {
if i.backend == nil {
i.allocate(true)
}
ox, oy, _, _ := i.region()
oxf, oyf := float32(ox), float32(oy)
i.backend.restorable.PutVertex(dest, dx, dy, sx+oxf, sy+oyf, bx0+oxf, by0+oyf, bx1+oxf, ... | go | {
"resource": ""
} |
q169642 | scaleUpdater | validation | func scaleUpdater() {
for {
s := getscale(0, 0)
atomic.StoreUint64(&cachedScale, math.Float64bits(s))
time.Sleep(cacheUpdateWait)
}
} | go | {
"resource": ""
} |
q169643 | NewBoard | validation | func NewBoard(size int) (*Board, error) {
b := &Board{
size: size,
tiles: map[*Tile]struct{}{},
}
for i := 0; i < 2; i++ {
if err := addRandomTile(b.tiles, b.size); err != nil {
return nil, err
}
}
return b, nil
} | go | {
"resource": ""
} |
q169644 | Update | validation | func (b *Board) Update(input *Input) error {
for t := range b.tiles {
if err := t.Update(); err != nil {
return err
}
}
if 0 < len(b.tasks) {
t := b.tasks[0]
if err := t(); err == taskTerminated {
b.tasks = b.tasks[1:]
} else if err != nil {
return err
}
return nil
}
if dir, ok := input.Dir(... | go | {
"resource": ""
} |
q169645 | Move | validation | func (b *Board) Move(dir Dir) error {
for t := range b.tiles {
t.stopAnimation()
}
if !MoveTiles(b.tiles, b.size, dir) {
return nil
}
b.tasks = append(b.tasks, func() error {
for t := range b.tiles {
if t.IsMoving() {
return nil
}
}
return taskTerminated
})
b.tasks = append(b.tasks, func() er... | go | {
"resource": ""
} |
q169646 | Size | validation | func (b *Board) Size() (int, int) {
x := b.size*tileSize + (b.size+1)*tileMargin
y := x
return x, y
} | go | {
"resource": ""
} |
q169647 | Draw | validation | func (b *Board) Draw(boardImage *ebiten.Image) {
boardImage.Fill(frameColor)
for j := 0; j < b.size; j++ {
for i := 0; i < b.size; i++ {
v := 0
op := &ebiten.DrawImageOptions{}
x := i*tileSize + (i+1)*tileMargin
y := j*tileSize + (j+1)*tileMargin
op.GeoM.Translate(float64(x), float64(y))
r, g, b, ... | go | {
"resource": ""
} |
q169648 | ClearIndex | validation | func ClearIndex(c float32) {
syscall.Syscall(gpClearIndex, 1, uintptr(math.Float32bits(c)), 0, 0)
} | go | {
"resource": ""
} |
q169649 | CreateProgram | validation | func CreateProgram() uint32 {
ret, _, _ := syscall.Syscall(gpCreateProgram, 0, 0, 0, 0)
return (uint32)(ret)
} | go | {
"resource": ""
} |
q169650 | DebugMessageCallback | validation | func DebugMessageCallback(callback unsafe.Pointer, userParam unsafe.Pointer) {
syscall.Syscall(gpDebugMessageCallback, 2, syscall.NewCallback(callback), uintptr(userParam), 0)
} | go | {
"resource": ""
} |
q169651 | GetError | validation | func GetError() uint32 {
ret, _, _ := syscall.Syscall(gpGetError, 0, 0, 0, 0)
return (uint32)(ret)
} | go | {
"resource": ""
} |
q169652 | GetGraphicsResetStatus | validation | func GetGraphicsResetStatus() uint32 {
ret, _, _ := syscall.Syscall(gpGetGraphicsResetStatus, 0, 0, 0, 0)
return (uint32)(ret)
} | go | {
"resource": ""
} |
q169653 | LineWidth | validation | func LineWidth(width float32) {
syscall.Syscall(gpLineWidth, 1, uintptr(math.Float32bits(width)), 0, 0)
} | go | {
"resource": ""
} |
q169654 | PassThrough | validation | func PassThrough(token float32) {
syscall.Syscall(gpPassThrough, 1, uintptr(math.Float32bits(token)), 0, 0)
} | go | {
"resource": ""
} |
q169655 | PointSize | validation | func PointSize(size float32) {
syscall.Syscall(gpPointSize, 1, uintptr(math.Float32bits(size)), 0, 0)
} | go | {
"resource": ""
} |
q169656 | IsReady | validation | func (c *Context) IsReady() bool {
c.m.Lock()
r := c.ready
c.m.Unlock()
return r
} | go | {
"resource": ""
} |
q169657 | NewPlayerFromBytes | validation | func NewPlayerFromBytes(context *Context, src []byte) (*Player, error) {
b := BytesReadSeekCloser(src)
p, err := NewPlayer(context, b)
if err != nil {
// Errors should never happen.
panic(fmt.Sprintf("audio: %v at NewPlayerFromBytes", err))
}
return p, nil
} | go | {
"resource": ""
} |
q169658 | Close | validation | func (p *Player) Close() error {
runtime.SetFinalizer(p, nil)
return p.p.Close()
} | go | {
"resource": ""
} |
q169659 | Seek | validation | func (p *Player) Seek(offset time.Duration) error {
return p.p.Seek(offset)
} | go | {
"resource": ""
} |
q169660 | decode | validation | func (d *decoder) decode() (image.Image, error) {
r, err := zlib.NewReader(d)
if err != nil {
return nil, err
}
defer r.Close()
var img image.Image
if d.interlace == itNone {
img, err = d.readImagePass(r, 0, false)
if err != nil {
return nil, err
}
} else if d.interlace == itAdam7 {
// Allocate a bl... | go | {
"resource": ""
} |
q169661 | Decode | validation | func Decode(r io.Reader) (image.Image, error) {
d := &decoder{
r: r,
crc: crc32.NewIEEE(),
}
if err := d.checkHeader(); err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
return nil, err
}
for d.stage != dsSeenIEND {
if err := d.parseChunk(); err != nil {
if err == io.EOF {
err = i... | go | {
"resource": ""
} |
q169662 | DecodeConfig | validation | func DecodeConfig(r io.Reader) (image.Config, error) {
d := &decoder{
r: r,
crc: crc32.NewIEEE(),
}
if err := d.checkHeader(); err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
return image.Config{}, err
}
for {
if err := d.parseChunk(); err != nil {
if err == io.EOF {
err = io.Er... | go | {
"resource": ""
} |
q169663 | Add | validation | func (c *ColorM) Add(other *ColorM) *ColorM {
lhsb := colorMIdentityBody
lhst := colorMIdentityTranslate
rhsb := colorMIdentityBody
rhst := colorMIdentityTranslate
if other.isInited() {
if other.body != nil {
lhsb = other.body
}
if other.translate != nil {
lhst = other.translate
}
}
if c.isInited()... | go | {
"resource": ""
} |
q169664 | IsButtonPressed | validation | func (c *gamepadConfig) IsButtonPressed(b virtualGamepadButton) bool {
if !c.gamepadIDInitialized {
panic("not reached")
}
c.initializeIfNeeded()
bb, ok := c.buttons[b]
if ok {
return ebiten.IsGamepadButtonPressed(c.gamepadID, bb)
}
a, ok := c.axes[b]
if ok {
v := ebiten.GamepadAxis(c.gamepadID, a.id)
... | go | {
"resource": ""
} |
q169665 | ButtonName | validation | func (c *gamepadConfig) ButtonName(b virtualGamepadButton) string {
if !c.gamepadIDInitialized {
panic("not reached")
}
c.initializeIfNeeded()
bb, ok := c.buttons[b]
if ok {
return fmt.Sprintf("Button %d", bb)
}
a, ok := c.axes[b]
if ok {
if a.positive {
return fmt.Sprintf("Axis %d+", a.id)
} else... | go | {
"resource": ""
} |
q169666 | AppendHookOnBeforeUpdate | validation | func AppendHookOnBeforeUpdate(f func() error) {
m.Lock()
onBeforeUpdateHooks = append(onBeforeUpdateHooks, f)
m.Unlock()
} | go | {
"resource": ""
} |
q169667 | DebugPrint | validation | func DebugPrint(image *ebiten.Image, str string) error {
DebugPrintAt(image, str, 0, 0)
return nil
} | go | {
"resource": ""
} |
q169668 | GamepadIDButtonPressed | validation | func (i *Input) GamepadIDButtonPressed() int {
for _, id := range ebiten.GamepadIDs() {
for b := ebiten.GamepadButton(0); b <= ebiten.GamepadButtonMax; b++ {
if ebiten.IsGamepadButtonPressed(id, b) {
return id
}
}
}
return -1
} | go | {
"resource": ""
} |
q169669 | Seek | validation | func (s *Stream) Seek(offset int64, whence int) (int64, error) {
return s.decoded.Seek(offset, whence)
} | go | {
"resource": ""
} |
q169670 | decode | validation | func decode(in audio.ReadSeekCloser) (*decoded, int, int, error) {
r, err := newDecoder(in)
if err != nil {
return nil, 0, 0, err
}
d := &decoded{
// TODO: r.Length() returns 0 when the format is unknown.
// Should we check that?
totalBytes: int(r.Length()) * r.Channels() * 2, // 2 means 16bit per sample.
... | go | {
"resource": ""
} |
q169671 | MovePieceToLeft | validation | func (f *Field) MovePieceToLeft(piece *Piece, x, y int, angle Angle) int {
if piece.collides(f, x-1, y, angle) {
return x
}
return x - 1
} | go | {
"resource": ""
} |
q169672 | RotatePieceRight | validation | func (f *Field) RotatePieceRight(piece *Piece, x, y int, angle Angle) Angle {
if piece.collides(f, x, y, angle.RotateRight()) {
return angle
}
return angle.RotateRight()
} | go | {
"resource": ""
} |
q169673 | RotatePieceLeft | validation | func (f *Field) RotatePieceLeft(piece *Piece, x, y int, angle Angle) Angle {
if piece.collides(f, x, y, angle.RotateLeft()) {
return angle
}
return angle.RotateLeft()
} | go | {
"resource": ""
} |
q169674 | flushable | validation | func (f *Field) flushable() bool {
for j := fieldBlockNumY - 1; 0 <= j; j-- {
if f.flushableLine(j) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q169675 | flushableLine | validation | func (f *Field) flushableLine(j int) bool {
for i := 0; i < fieldBlockNumX; i++ {
if f.blocks[i][j] == BlockTypeNone {
return false
}
}
return true
} | go | {
"resource": ""
} |
q169676 | flushLine | validation | func (f *Field) flushLine(j int) bool {
for i := 0; i < fieldBlockNumX; i++ {
if f.blocks[i][j] == BlockTypeNone {
return false
}
}
for j2 := j; 1 <= j2; j2-- {
for i := 0; i < fieldBlockNumX; i++ {
f.blocks[i][j2] = f.blocks[i][j2-1]
}
}
for i := 0; i < fieldBlockNumX; i++ {
f.blocks[i][0] = Block... | go | {
"resource": ""
} |
q169677 | intersection | validation | func intersection(l1, l2 line) (float64, float64, bool) {
// https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection#Given_two_points_on_each_line
denom := (l1.X1-l1.X2)*(l2.Y1-l2.Y2) - (l1.Y1-l1.Y2)*(l2.X1-l2.X2)
tNum := (l1.X1-l2.X1)*(l2.Y1-l2.Y2) - (l1.Y1-l2.Y1)*(l2.X1-l2.X2)
uNum := -((l1.X1-l1.X2)*(l1.Y1-... | go | {
"resource": ""
} |
q169678 | rayCasting | validation | func rayCasting(cx, cy float64, objects []object) []line {
const rayLength = 1000 // something large enough to reach all objects
var rays []line
for _, obj := range objects {
// Cast two rays per point
for _, p := range obj.points() {
l := line{cx, cy, p[0], p[1]}
angle := l.angle()
for _, offset := r... | go | {
"resource": ""
} |
q169679 | Str | validation | func Str(str string) *uint8 {
if !strings.HasSuffix(str, "\x00") {
panic("str argument missing null terminator: " + str)
}
header := (*reflect.StringHeader)(unsafe.Pointer(&str))
return (*uint8)(unsafe.Pointer(header.Data))
} | go | {
"resource": ""
} |
q169680 | Close | validation | func (s *Stream) Close() error {
runtime.SetFinalizer(s, nil)
return s.inner.Close()
} | go | {
"resource": ""
} |
q169681 | NewWorld | validation | func NewWorld(width, height int, maxInitLiveCells int) *World {
w := &World{
area: make([]bool, width*height),
width: width,
height: height,
}
w.init(maxInitLiveCells)
return w
} | go | {
"resource": ""
} |
q169682 | init | validation | func (w *World) init(maxLiveCells int) {
for i := 0; i < maxLiveCells; i++ {
x := rand.Intn(w.width)
y := rand.Intn(w.height)
w.area[y*w.width+x] = true
}
} | go | {
"resource": ""
} |
q169683 | Update | validation | func (w *World) Update() {
width := w.width
height := w.height
next := make([]bool, width*height)
for y := 0; y < height; y++ {
for x := 0; x < width; x++ {
pop := neighbourCount(w.area, width, height, x, y)
switch {
case pop < 2:
// rule 1. Any live cell with fewer than two live neighbours
// di... | go | {
"resource": ""
} |
q169684 | Draw | validation | func (w *World) Draw(pix []byte) {
for i, v := range w.area {
if v {
pix[4*i] = 0xff
pix[4*i+1] = 0xff
pix[4*i+2] = 0xff
pix[4*i+3] = 0xff
} else {
pix[4*i] = 0
pix[4*i+1] = 0
pix[4*i+2] = 0
pix[4*i+3] = 0
}
}
} | go | {
"resource": ""
} |
q169685 | DrawLine | validation | func DrawLine(dst *ebiten.Image, x1, y1, x2, y2 float64, clr color.Color) {
ew, eh := emptyImage.Size()
length := math.Hypot(x2-x1, y2-y1)
op := &ebiten.DrawImageOptions{}
op.GeoM.Scale(length/float64(ew), 1/float64(eh))
op.GeoM.Rotate(math.Atan2(y2-y1, x2-x1))
op.GeoM.Translate(x1, y1)
op.ColorM.Scale(colorSca... | go | {
"resource": ""
} |
q169686 | DrawRect | validation | func DrawRect(dst *ebiten.Image, x, y, width, height float64, clr color.Color) {
ew, eh := emptyImage.Size()
op := &ebiten.DrawImageOptions{}
op.GeoM.Scale(width/float64(ew), height/float64(eh))
op.GeoM.Translate(x, y)
op.ColorM.Scale(colorScale(clr))
// Filter must be 'nearest' filter (default).
// Linear filt... | go | {
"resource": ""
} |
q169687 | NewGame | validation | func NewGame() (*Game, error) {
g := &Game{
input: NewInput(),
}
var err error
g.board, err = NewBoard(boardSize)
if err != nil {
return nil, err
}
return g, nil
} | go | {
"resource": ""
} |
q169688 | Update | validation | func (g *Game) Update() error {
g.input.Update()
if err := g.board.Update(g.input); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q169689 | Draw | validation | func (g *Game) Draw(screen *ebiten.Image) {
if g.boardImage == nil {
w, h := g.board.Size()
g.boardImage, _ = ebiten.NewImage(w, h, ebiten.FilterDefault)
}
screen.Fill(backgroundColor)
g.board.Draw(g.boardImage)
op := &ebiten.DrawImageOptions{}
sw, sh := screen.Size()
bw, bh := g.boardImage.Size()
x := (sw ... | go | {
"resource": ""
} |
q169690 | IsKeyJustReleased | validation | func IsKeyJustReleased(key ebiten.Key) bool {
theInputState.m.RLock()
r := theInputState.keyDurations[key] == 0 && theInputState.prevKeyDurations[key] > 0
theInputState.m.RUnlock()
return r
} | go | {
"resource": ""
} |
q169691 | KeyPressDuration | validation | func KeyPressDuration(key ebiten.Key) int {
theInputState.m.RLock()
s := theInputState.keyDurations[key]
theInputState.m.RUnlock()
return s
} | go | {
"resource": ""
} |
q169692 | IsMouseButtonJustReleased | validation | func IsMouseButtonJustReleased(button ebiten.MouseButton) bool {
theInputState.m.RLock()
r := theInputState.mouseButtonDurations[button] == 0 &&
theInputState.prevMouseButtonDurations[button] > 0
theInputState.m.RUnlock()
return r
} | go | {
"resource": ""
} |
q169693 | MouseButtonPressDuration | validation | func MouseButtonPressDuration(button ebiten.MouseButton) int {
theInputState.m.RLock()
s := theInputState.mouseButtonDurations[button]
theInputState.m.RUnlock()
return s
} | go | {
"resource": ""
} |
q169694 | JustConnectedGamepadIDs | validation | func JustConnectedGamepadIDs() []int {
var ids []int
theInputState.m.RLock()
for id := range theInputState.gamepadIDs {
if _, ok := theInputState.prevGamepadIDs[id]; !ok {
ids = append(ids, id)
}
}
theInputState.m.RUnlock()
sort.Ints(ids)
return ids
} | go | {
"resource": ""
} |
q169695 | IsGamepadJustDisconnected | validation | func IsGamepadJustDisconnected(id int) bool {
theInputState.m.RLock()
_, prev := theInputState.prevGamepadIDs[id]
_, current := theInputState.gamepadIDs[id]
theInputState.m.RUnlock()
return prev && !current
} | go | {
"resource": ""
} |
q169696 | IsGamepadButtonJustPressed | validation | func IsGamepadButtonJustPressed(id int, button ebiten.GamepadButton) bool {
return GamepadButtonPressDuration(id, button) == 1
} | go | {
"resource": ""
} |
q169697 | IsGamepadButtonJustReleased | validation | func IsGamepadButtonJustReleased(id int, button ebiten.GamepadButton) bool {
theInputState.m.RLock()
prev := 0
if _, ok := theInputState.prevGamepadButtonDurations[id]; ok {
prev = theInputState.prevGamepadButtonDurations[id][button]
}
current := 0
if _, ok := theInputState.gamepadButtonDurations[id]; ok {
cu... | go | {
"resource": ""
} |
q169698 | GamepadButtonPressDuration | validation | func GamepadButtonPressDuration(id int, button ebiten.GamepadButton) int {
theInputState.m.RLock()
s := 0
if _, ok := theInputState.gamepadButtonDurations[id]; ok {
s = theInputState.gamepadButtonDurations[id][button]
}
theInputState.m.RUnlock()
return s
} | go | {
"resource": ""
} |
q169699 | JustPressedTouchIDs | validation | func JustPressedTouchIDs() []int {
var ids []int
theInputState.m.RLock()
for id, s := range theInputState.touchDurations {
if s == 1 {
ids = append(ids, id)
}
}
theInputState.m.RUnlock()
sort.Ints(ids)
return ids
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.