mesh, gis, dds and tga are all binary files. Their Key data and filter methods are different and can only be applied in a certain version. Some files only support specific methods. Here are some rule examples.

1. mesh Rules

mesh files can be interpreted through Struct as fixed-length bytes in Nexo with a engine older than 0x50004(327684).   

Container: 
    header = Container: 
        file_mark = mesh (total 4)
        version = 327684
        file_version = 327684
        file_version_mask = 0
    patch_version = 0
    mesh_type = skeletal (total 8)
    bone_count = 25
    bones = ListContainer: 
        24
        11
    bone_names = ListContainer: 
        98
    has_bones_bi = True
    bone_bounding_info = <LazyRangeContainer: 25 possible items, 0 cached>
    bone_matrix = <LazyRangeContainer: 25 possible items, 0 cached>
    has_bi = False
    table_offset = 22516
    data_table = Container: 
        block_count = 1
        block_infos = ListContainer: 
            3170
        pair_count = 1
        data_pairs = ListContainer: 
            Container: 
                type = lod (total 3)
                block_idx = 0
        content = ListContainer: 
            Container: 
                sub_mesh_headers = ListContainer: 
                    Container: 
                        v_count = 229
                        tri_count = 314
                        uv_chnl_count = 2
                        has_color = False
                lod_new_v = 1
                v_count = 229
                tri_count = 314
                vb = <LazyRangeContainer: 229 possible items, 0 cached>
                nb = <LazyRangeContainer: 229 possible items, 0 cached>
                has_tangent = 1
                tangent = <LazyRangeContainer: 229 possible items, 0 cached>
                ib = <LazyRangeContainer: 942 possible items, 0 cached>
                tb = ListContainer: 
                    ListContainer: 
                        <LazyRangeContainer: 229 possible items, 0 cached>
                        <LazyRangeContainer: 229 possible items, 0 cached>
                cb = None
                ref_bones = ListContainer: 
                    1507350
                    4294967295
                    1441804
    tail = ListContainer: 
The file is converted to an object root data in the checker server. For example, the above version code is converted to root.header.version. Supported rules include root, root/version, root/bone_count and root/refbone_count, which corresponds to ref_bones in root, root.header.version, root.bone_count and root.data_table.content, respectively. Customized attribute root/{} is also supported to find corresponding root object data. Example: Maximum bone count for one model is 80. xpath=.* .mesh xpath=root/bone_count condition=["Satisfy the expression","d<80"]

2. gis Rules

What type of content is supported in gis files also depends on the engine version. Versions that are supported by track function extensions are not available. The files can be interpreted through Struct as fixed-length bytes. Example format:

Container: 
    header = Container: 
        file_mark = anim (total 4)
        version = 50724865
        file_version = 393217
        file_version_mask = 3
    anim_count = 5
    bone_count = 3
    bone_names = ListContainer: 
        b'bone001'
        b'bone002'
        b'root'
    bone_trans = ListContainer: 
        Container: 
            pos = ListContainer: 
                0.0
                4.044138431549072
                -3.159993298140762e-07
            rot = ListContainer: 
                1.4527657299368002e-08
                -1.4527657299368002e-08
                0.7071068286895752
                0.7071068286895752
            scale = ListContainer: 
                1.0
                1.0
                1.0
        Container: 
            pos = ListContainer: 
                0.0
                1.0272369384765625
                -0.025091886520385742
            rot = ListContainer: 
                0.5000001192092896
                0.4999999403953552
                -0.49999988079071045
                -0.5000000596046448
            scale = ListContainer: 
                1.0
                1.0
                1.0
        Container: 
            pos = ListContainer: 
                0.0
                0.0
                0.0
            rot = ListContainer: 
                0.0
                0.0
                0.0
                1.0
            scale = ListContainer: 
                1.0
                1.0
                1.0
    seperate_storage = 0
    base_size = None
    anim = ListContainer: 
        Container: 
            name = obtain (total 6)
            anim_root_name = root (total 4)
            bone_count = 3
            bone_names = ListContainer: 
                b'bone001'
                b'bone002'
                b'root'
            sample_fps = 30
            loop = False
            has_scaled = True
            prs_flags = 7
            accum_flags = 0
            pack_prs_flags = 6
            bone_separate_flags = 0
            keys_data = Container: 
                key_count = 16
                key_times = ListContainer: 
                    0.0
                    33.33333206176758
                    66.66666412353516
                    100.0
                    133.3333282470703
                    166.6666717529297
                    200.0
                    233.3333282470703
                    266.6666564941406
                    300.0
                    333.3333435058594
                    366.6666564941406
                    400.0
                    433.3333435058594
                    466.6666564941406
                    500.0
                key_data = ListContainer: 
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = True
                        euler_flags = False
                        position_key_count = 16
                        positions = <LazyRangeContainer: 16 possible items, 0 cached>
                        rot_key_count = 16
                        rot = <LazyRangeContainer: 16 possible items, 0 cached>
                        scale_key_count = 16
                        scales = <LazyRangeContainer: 16 possible items, 0 cached>
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = True
                        euler_flags = False
                        position_key_count = 16
                        positions = <LazyRangeContainer: 16 possible items, 0 cached>
                        rot_key_count = 16
                        rot = <LazyRangeContainer: 16 possible items, 0 cached>
                        scale_key_count = 16
                        scales = <LazyRangeContainer: 16 possible items, 0 cached>
                    Container: 
                        has_pos_keys = False
                        has_rot_keys = False
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 1
                        positions = <LazyRangeContainer: 1 possible items, 0 cached>
                        rot_key_count = 1
                        rot = <LazyRangeContainer: 1 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
            pivot = Container: 
                has_pivot_track = False
                track_data = None
        Container: 
            name = idle (total 4)
            anim_root_name = root (total 4)
            bone_count = 3
            bone_names = ListContainer: 
                b'bone001'
                b'bone002'
                b'root'
            sample_fps = 30
            loop = True
            has_scaled = True
            prs_flags = 7
            prs_flags = 0
            pack_prs_flags = 6
            bone_separate_flags = 0
            keys_data = Container: 
                key_count = 101
                data_pairs = ListContainer: 
                    0.0
                    33.33333206176758
                    66.66666412353516
                key_data = ListContainer: 
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 101
                        positions = <LazyRangeContainer: 101 possible items, 0 cached>
                        rot_key_count = 101
                        rot = <LazyRangeContainer: 101 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 101
                        positions = <LazyRangeContainer: 101 possible items, 0 cached>
                        rot_key_count = 101
                        rot = <LazyRangeContainer: 101 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
                    Container: 
                        has_pos_keys = False
                        has_rot_keys = False
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 1
                        positions = <LazyRangeContainer: 1 possible items, 0 cached>
                        rot_key_count = 1
                        rot = <LazyRangeContainer: 1 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
            pivot = Container: 
                has_pivot_track = False
                track_data = None
        Container: 
            name = born (total 4)
            anim_root_name = root (total 4)
            bone_count = 3
            bone_names = ListContainer: 
                b'bone001'
                b'bone002'
                b'root'
            sample_fps = 30
            loop = False
            has_scaled = True
            prs_flags = 7
            accum_flags = 0
            pack_prs_flags = 6
            bone_separate_flags = 0
            keys_data = Container: 
                key_count = 25
                key_times = ListContainer: 
                    0.0
                    33.54166793823242
                    66.875
                key_data = ListContainer: 
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 25
                        positions = <LazyRangeContainer: 25 possible items, 0 cached>
                        rot_key_count = 25
                        rot = <LazyRangeContainer: 25 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 25
                        positions = <LazyRangeContainer: 25 possible items, 0 cached>
                        rot_key_count = 25
                        rot = <LazyRangeContainer: 25 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
                    Container: 
                        has_pos_keys = False
                        has_rot_keys = False
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 1
                        positions = <LazyRangeContainer: 1 possible items, 0 cached>
                        rot_key_count = 1
                        rot = <LazyRangeContainer: 1 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
            pivot = Container: 
                has_pivot_track = False
                track_data = None
        Container: 
            name = dead (total 4)
            anim_root_name = root (total 4)
            bone_count = 3
            bone_names = ListContainer: 
                b'bone001'
                b'bone002'
                b'root'
            sample_fps = 30
            loop = False
            has_scaled = True
            prs_flags = 7
            accum_flags = 0
            pack_prs_flags = 6
            bone_separate_flags = 0
            keys_data = Container: 
                key_count = 29
                key_times = ListContainer: 
                    0.0
                    33.33333206176758
                    66.66666412353516
                key_data = ListContainer: 
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 29
                        positions = <LazyRangeContainer: 29 possible items, 0 cached>
                        rot_key_count = 29
                        rot = <LazyRangeContainer: 29 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 29
                        positions = <LazyRangeContainer: 29 possible items, 0 cached>
                        rot_key_count = 29
                        rot = <LazyRangeContainer: 29 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
                    Container: 
                        has_pos_keys = False
                        has_rot_keys = False
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 1
                        positions = <LazyRangeContainer: 1 possible items, 0 cached>
                        rot_key_count = 1
                        rot = <LazyRangeContainer: 1 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
            pivot = Container: 
                has_pivot_track = False
                track_data = None
        Container: 
            name = buffering (total 9)
            anim_root_name = root (total 4)
            bone_count = 3
            bone_names = ListContainer: 
                b'bone001'
                b'bone002'
                b'root'
            sample_fps = 30
            loop = False
            has_scaled = True
            prs_flags = 7
            accum_flags = 0
            pack_prs_flags = 6
            bone_separate_flags = 0
            keys_data = Container: 
                key_count = 31
                bone_names = ListContainer: 
                    0.0
                    33.33333206176758
                    66.66666412353516
                key_data = ListContainer: 
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = True
                        euler_flags = False
                        position_key_count = 31
                        positions = <LazyRangeContainer: 31 possible items, 0 cached>
                        rot_key_count = 31
                        rot = <LazyRangeContainer: 31 possible items, 0 cached>
                        scale_key_count = 31
                        scales = <LazyRangeContainer: 31 possible items, 0 cached>
                    Container: 
                        has_pos_keys = True
                        has_rot_keys = True
                        has_scale_keys = True
                        euler_flags = False
                        position_key_count = 31
                        positions = <LazyRangeContainer: 31 possible items, 0 cached>
                        rot_key_count = 31
                        rot = <LazyRangeContainer: 31 possible items, 0 cached>
                        scale_key_count = 31
                        scales = <LazyRangeContainer: 31 possible items, 0 cached>
                    Container: 
                        has_pos_keys = False
                        has_rot_keys = False
                        has_scale_keys = False
                        euler_flags = False
                        position_key_count = 1
                        positions = <LazyRangeContainer: 1 possible items, 0 cached>
                        rot_key_count = 1
                        rot = <LazyRangeContainer: 1 possible items, 0 cached>
                        scale_key_count = 1
                        scales = <LazyRangeContainer: 1 possible items, 0 cached>
            pivot = Container: 
                has_pivot_track = False
                track_data = None
    tail =  (total 0)
The file is also converted to an object root data in the checker server. Supported rules include root, root/framecount and root/samplefps which correspond to keys_data.key_count, root.anim.sample_fps under root, root.anim respectively. Customized attribute root/{} is also supported to find the root object data. Example: Maximum frames for an action is 5. xpath=.* .gis xpath=root/anim condition=['Satisfy the expression','d < 5']

3.dds Rules (applies to tga files)

dds files are interpreted by a 3rd party library and only support pixel format in FOURCC OR RGB. RGB format includes A8R8G8B8, A1R5G5B5, A4R4G4B4, R8G8B8 and R5G6B5 and FOURCC includes DXT1, DXT2, DXT3, DXT4 and DXT5. Attributes which can be interpreted are as followed:

root.size, height and width of the file (1024,1024)

root.header_size. The size of header must be 124 bytes and it can be used to check if the file format is valid.

root.mipmaps, minemap layer count

root.pfsize. The size of pixel format must be 32 bytes.

root.pfflags. The value range flag bits of pixel format.

oot.fourcc. A compressed file format, i.e. DXTn series. It requires a valid DDPF_FOURCC flag bits of pfflags.

root.bitcount. The bit size of RGB. It requires a valid DDPF_RGB flag bits of pfflags.

root.pixel_format. A compressed file format which is more detailed than fourcc.

Example: The length and width of a file should be no more than 1024. xpath=.*.dds$ xpath=root/size condition=['Satisfy the expression',"int(d[0]) <= 1024 and int(d[1]) <= 1024"]