Esempio n. 1
0
def iter_body(cp):
    tmpl = Template(iter_body_code, 'iter_body')
    NWARPS = NTHREADS / 32

    # TODO: detect this properly and use it
    chaos_used = False

    vars = globals()
    vars.update(locals())
    return tmpl.substitute(vars)
Esempio n. 2
0
def iter_body(cp):
    tmpl = Template(iter_body_code, 'iter_body')
    NWARPS = NTHREADS / 32

    # TODO: detect this properly and use it
    chaos_used = False

    vars = globals()
    vars.update(locals())
    return tmpl.substitute(vars)
Esempio n. 3
0
def precalc_camera(cam):
    # Maxima code to check my logic:
    #   matrix([1,0,0.5*width + g],[0,1,0.5*height+g],[0,0,1])
    # . matrix([width * scale,0,0], [0,width * scale,0], [0,0,1])
    # . matrix([cosr,-sinr,0], [sinr,cosr,0], [0,0,1])
    # . matrix([1,0,-cenx],[0,1,-ceny],[0,0,1])
    # . matrix([X],[Y],[1]);

    cam._code(
        Template(
            r"""
        float rot = {{cam.rotation}} * M_PI / 180.0f;
        float rotsin = sin(rot), rotcos = cos(rot);
        float cenx = {{cam.center.x}}, ceny = {{cam.center.y}};
        float scale = {{cam.scale}} * acc_size.width;

        {{cam._set('xx')}} = scale * rotcos;
        {{cam._set('xy')}} = scale * -rotsin;
        {{cam._set('xo')}} = scale * (rotsin * ceny - rotcos * cenx)
                           + 0.5f * acc_size.awidth;

        {{cam._set('yx')}} = scale * rotsin;
        {{cam._set('yy')}} = scale * rotcos;
        {{cam._set('yo')}} = scale * -(rotsin * cenx + rotcos * ceny)
                           + 0.5f * acc_size.aheight;
    """, 'precalc_camera').substitute(cam=cam))
Esempio n. 4
0
def precalc_chaos(cp):
    cp._code(
        Template("""
        float sum, rsum;

        {{for p in cp.xforms}}
        sum = 0.0f;

        {{for n in cp.xforms}}
        float den_{{p}}_{{n}} = {{cp.xforms[n].weight}}
                              * {{cp.xforms[p].chaos[n]}};
        sum += den_{{p}}_{{n}};
        {{endfor}}

        rsum = 1.0f / sum;
        sum = 0.0f;

        {{for n in cp.xforms.keys()[:-1]}}
        sum += den_{{p}}_{{n}} * rsum;
        {{cp._set('chaos_%s_%s' % (p, n))}} = sum;
        {{endfor}}

        {{endfor}}
    """,
                 name='precalc_chaos').substitute(cp=cp))
Esempio n. 5
0
def apply_affine(names, packer):
    x, y, xo, yo = names.split()
    return Template(
        """
    {{xo}} = {{packer.xx}} * {{x}} + {{packer.xy}} * {{y}} + {{packer.xo}};
    {{yo}} = {{packer.yx}} * {{x}} + {{packer.yy}} * {{y}} + {{packer.yo}};
    """, 'apply_affine').substitute(locals())
Esempio n. 6
0
    def get_door_status(self):
        print("判断是否开门")

        jt.window_capture(self.dt_name)
        zb1 = tl.template(self.blue, self.dt_name, 0.0001)
        if zb1[0] != 0:
            print('已开门')
            return True
        else:
            print('未开门')
        return False
Esempio n. 7
0
 def attack_boss(self):
     for i in range(100):
         time.sleep(1)
         jt.window_capture(self.dt_name)
         zb = tl.template(self.copper, self.dt_name, 0.0000001)
         if zb[0] != 0:
             print('打boss完成')
             return True
         elif i == 99:
             print('打boss失败')
             return False
         self.daguai()
Esempio n. 8
0
    def guomen(self, menFangXiang):
        print('执行过门')
        if self.get_door_status():
            if int(menFangXiang) == 8:
                key_input('w', 1)
            elif int(menFangXiang) == 6:
                key_input('d', 1)
            elif int(menFangXiang) == 2:
                key_input('s', 1)
            elif int(menFangXiang) == 4:
                key_input('a', 1)
            else:
                print('错误:', menFangXiang)
                return
        else:
            print('未开门')
            return False
        #
        # for i in range(100):
        #     jt.window_capture(self.dt_name)
        #     zb = tl.template(self.blue, self.dt_name, 0.00001)
        #     zb2 = tl.template(self.blue, self.dt_name, 0.00001)
        #     zb3 = tl.template(self.blue, self.dt_name, 0.00001)
        #     zb[0] = zb[0] + zb2[0] + zb3[0]
        #     if zb[0] == 0:
        #         print('已过门')
        #         break
        #     elif i == 19:
        #         print('过门失败')
        #         return False

        for i in range(20):
            time.sleep(1)
            jt.window_capture(self.dt_name)
            zb = tl.template(self.blue, self.dt_name, 0.00001)
            if zb[0] == 0:
                print('开图成功')
                if int(menFangXiang) == 8:
                    key_input('w', 1)
                elif int(menFangXiang) == 6:
                    key_input('d', 1)
                elif int(menFangXiang) == 2:
                    key_input('s', 1)
                elif int(menFangXiang) == 4:
                    key_input('a', 1)
                return True
            elif i == 19:
                print('开图失败')
                return False
Esempio n. 9
0
def precalc_xf_affine(px):
    px._code(
        Template(
            r"""
        float pri = {{px.angle}} * M_PI / 180.0f;
        float spr = {{px.spread}} * M_PI / 180.0f;

        float magx = {{px.magnitude.x}};
        float magy = {{px.magnitude.y}};

        {{px._set('xx')}} = magx * cos(pri-spr);
        {{px._set('yx')}} = -magx * sin(pri-spr);
        {{px._set('xy')}} = -magy * cos(pri+spr);
        {{px._set('yy')}} = magy * sin(pri+spr);
        {{px._set('xo')}} = {{px.offset.x}};
        {{px._set('yo')}} = -{{px.offset.y}};
    """, 'precalc_xf_affine').substitute(px=px))
Esempio n. 10
0
 def daguai(self, threshold=0.001):
     sleep(1)
     # print('status=1;  开始打怪')
     while True:
         jt.window_capture(self.dt_name)
         zb = tl.template(xt_name=self.xt_name,
                          dt_name=self.dt_name,
                          threshold=threshold)
         if zb[0] != 0:
             print('有怪', '打怪')
             mouse_move(zb[0] + 25, zb[1] + 25)
             a.status = True
         else:
             print('没怪了')
             a.status = False
             break
     return self
Esempio n. 11
0
def precalc_densities(cp):
    # This pattern recurs a few times for precalc segments. Unfortunately,
    # namespace stuff means it's not easy to functionalize this boilerplate
    cp._code(
        Template(r"""
        float sum = 0.0f;

        {{for n in cp.xforms}}
        float den_{{n}} = {{cp.xforms[n].weight}};
        sum += den_{{n}};
        {{endfor}}

        float rsum = 1.0f / sum;
        sum = 0.0f;

        {{for n in cp.xforms.keys()[:-1]}}
        sum += den_{{n}} * rsum;
        {{cp._set('den_' + n)}} = sum;
        {{endfor}}
    """,
                 name='precalc_densities').substitute(cp=cp))
Esempio n. 12
0
def iter_xf_body(cp, xfid, px):
    tmpl = Template(iter_xf_body_code, 'apply_xf_' + xfid)
    g = dict(globals())
    g.update(locals())
    return tmpl.substitute(g)
Esempio n. 13
0
flushatomlib = devlib(defs=Template(
    r'''
__global__ void flush_atom(uint64_t out_ptr, uint64_t atom_ptr, int nbins) {
    int i = (blockIdx.y * gridDim.x + blockIdx.x) * blockDim.x + threadIdx.x;
    if (i >= nbins) return;
    asm volatile ({{crep("""
{
    .reg .u32   off, hi, lo, d, y, u, v;
    .reg .u64   val, ptr;
    .reg .f32   yf, uf, vf, df, yg, ug, vg, dg;

    // TODO: use explicit movs to handle this
    shl.b32             off,    %0,     3;
    cvt.u64.u32         ptr,    off;
    add.u64             ptr,    ptr,    %1;
    ld.global.v2.u32    {lo, hi},   [ptr];
    shl.b32             off,    %0,     4;
    cvt.u64.u32         ptr,    off;
    add.u64             ptr,    ptr,    %2;
    ld.global.v4.f32    {yg,ug,vg,dg},  [ptr];
    shr.u32             d,      hi,     22;
    bfe.u32             y,      hi,     4,      18;
    bfe.u32             u,      lo,     18,     14;
    bfi.b32             u,      hi,     u,      14,     4;
    and.b32             v,      lo,     ((1<<18)-1);
    cvt.rn.f32.u32      yf,     y;
    cvt.rn.f32.u32      uf,     u;
    cvt.rn.f32.u32      vf,     v;
    cvt.rn.f32.u32      df,     d;
    fma.rn.ftz.f32      yg,     yf,     (1.0/255.0),    yg;
    fma.rn.ftz.f32      ug,     uf,     (1.0/255.0),    ug;
    fma.rn.ftz.f32      vg,     vf,     (1.0/255.0),    vg;

    add.rn.ftz.f32      dg,     df,     dg;
    st.global.v4.f32    [ptr],  {yg,ug,vg,dg};
}
    """)}}  ::  "r"(i), "l"(atom_ptr), "l"(out_ptr));
}
''', 'flush_atom').substitute())
Esempio n. 14
0
def iter_xf_body(cp, xfid, px):
    tmpl = Template(iter_xf_body_code, 'apply_xf_'+xfid)
    g = dict(globals())
    g.update(locals())
    return tmpl.substitute(g)
Esempio n. 15
0
class GenomePacker(object):
    """
    Packs a genome for use in iteration.
    """
    def __init__(self, tname, ptr_name, spec):
        """
        Create a new DataPacker.

        ``tname`` is the name of the structure typedef that will be emitted
        via this object's ``decls`` property.
        """
        self.tname, self.ptr_name, self.spec = tname, ptr_name, spec
        # We could do this in the order that things are requested, but we want
        # to be able to treat the direct stuff as a list so this function
        # doesn't unroll any more than it has to. So we separate things into
        # direct requests, and those that need precalculation.
        self.packed_direct = _OrderedSet()
        # Feel kind of bad about this, but it's just under the threshold of
        # being worth refactoring to be agnostic to interpolation types
        self.packed_direct_mag = _OrderedSet()
        self.genome_precalc = _OrderedSet()
        self.packed_precalc = _OrderedSet()
        self.precalc_code = []

        self._len = None
        self.decls = None
        self.defs = None

        self.packed = None
        self.genome = None
        self.search_rounds = util.DEFAULT_SEARCH_ROUNDS

    def __len__(self):
        """Length in elements. (*4 for length in bytes.)"""
        assert self._len is not None, 'len() called before finalize()'
        return self._len

    def view(self, val={}):
        """Create a DataPacker view. See DataPackerView class for details."""
        return PackerWrapper(val, self.spec, packer=self)

    def _require(self, spec, path):
        """
        Called to indicate that the named parameter from the original genome
        must be available during interpolation.
        """
        if spec.interp == 'mag':
            self.packed_direct_mag.add(path)
        else:
            self.packed_direct.add(path)
        return self.devname(path)

    def _require_pre(self, spec, path):
        i = self.genome_precalc.add(path) << self.search_rounds
        func = 'catmull_rom_mag' if spec.interp == 'mag' else 'catmull_rom'
        return '%s(&times[%d], &knots[%d], time)' % (func, i, i)

    def _pre_alloc(self, path):
        self.packed_precalc.add(path)
        return '%s->%s' % (self.ptr_name, '_'.join(path))

    def devname(self, path):
        return '%s.%s' % (self.ptr_name, '_'.join(path))

    def finalize(self):
        """
        Create the code to render this genome.
        """
        # At the risk of packing a few things more than once, we don't
        # uniquify the overall precalc order, sparing us the need to implement
        # recursive code generation
        direct = list(self.packed_direct) + list(self.packed_direct_mag)
        self.packed = direct + list(self.packed_precalc)
        self.genome = direct + list(self.genome_precalc)

        self._len = len(self.packed)

        decls = self._decls.substitute(**self.__dict__)
        defs = self._defs.substitute(**self.__dict__)

        return devlib(deps=[catmullromlib], decls=decls, defs=defs)

    def pack(self, gnm, pool=None):
        """
        Return a packed copy of the genome ready for uploading to the GPU,
        as two float32 NDArrays for the knot times and values.
        """
        width = 1 << self.search_rounds
        if pool:
            times = pool.allocate((len(self.genome), width), 'f4')
            knots = pool.allocate((len(self.genome), width), 'f4')
        else:
            times, knots = np.empty((2, len(self.genome), width), 'f4')
        times.fill(1e9)

        # TODO: do a nicer job of finding the value of scale
        scale = gnm.get('time', {}).get('duration', 1)
        for idx, path in enumerate(self.genome):
            attr = gnm
            for name in path:
                if name not in attr:
                    attr = resolve_spec(specs.anim, path).default
                    break
                attr = attr[name]
            attr = SplineEval.normalize(attr, scale)
            times[idx,:len(attr[0])] = attr[0]
            knots[idx,:len(attr[1])] = attr[1]
        return times, knots

    _defs = Template(r"""
__global__ void interp_{{tname}}(
        {{tname}}* {{ptr_name}},
        const float *times, const float *knots,
        float tstart, float tstep, int maxid)
{
    int id = gtid();
    if (id >= maxid) return;
    {{ptr_name}} = &{{ptr_name}}[id];
    float time = tstart + id * tstep;

    float *outf = reinterpret_cast<float*>({{ptr_name}});

    {{py:lpd = len(packed_direct)}}
    {{py:lpdm = len(packed_direct_mag)}}

    // TODO: unroll pragma?
    for (int i = 0; i < {{lpd}}; i++) {
        int j = i << {{search_rounds}};
        outf[i] = catmull_rom(&times[j], &knots[j], time);
    }

    for (int i = {{lpd}}; i < {{lpd+lpdm}}; i++) {
        int j = i << {{search_rounds}};
        outf[i] = catmull_rom_mag(&times[j], &knots[j], time);
    }

    // Advance 'times' and 'knots' to the purely generated sections, so that
    // the pregenerated statements emitted by _require_pre are correct.
    times = &times[{{(lpd+lpdm)<<search_rounds}}];
    knots = &knots[{{(lpd+lpdm)<<search_rounds}}];

    {{for hunk in precalc_code}}
{
    {{hunk}}
}
    {{endfor}}
}
""")

    _decls = Template(r"""
typedef struct {
{{for path in packed}}
    float   {{'_'.join(path)}};
{{endfor}}
} {{tname}};


""")
Esempio n. 16
0
 def getZB(self):
     jt.window_capture(self.dt_name)
     juese_zb = tl.template(self.juese_name, self.dt_name, 0.1)
     return juese_zb