DirectPython 11 Code

import pickle
import random
import unittest
import struct
import sys

import d3d11
from d3d11c import *

RED = (255, 47, 74, 255)
HLINE = (176, 255, 168, 255)
HLINEBG = (83, 71, 255, 255)

#ISPY3 = sys.version_info.major >= 3

class Color:
    def __init__(self, color):
        self.color = color

    def __getitem__(self, index):
        return self.color
 
        
class Test(unittest.TestCase):

    def createTexture(self, name, sizes=(0, 0)):
        t = d3d11.Texture(name, sizes, format=FORMAT_R8G8B8A8_UNORM, bind=0,  
            usage=USAGE_STAGING, cpuaccess=CPU_ACCESS_WRITE|CPU_ACCESS_READ)
        size = t.size() 
        self.assert_(t.getItemSize() == 4)
        self.assert_(t.getItemFormat() == "4B")
        return t
           
    def partition(self, data, chunk=4):
        result = []
        i = 0
        while i < len(data):
            rgba = data[i:i+chunk]
            r = int(rgba[0])
            g = int(rgba[1])        
            b = int(rgba[2])
            a = int(rgba[3])            
            result.append((r, g, b, a))
            i += chunk
        return result
           
    def compare(self, data, color):
        for p in data:
            self.assert_(p == color)
           
    def test_slice(self):
        t = self.createTexture("images/red.dds")
        
        t.map(MAP_READ_WRITE, 0)
        data = t[::, ::]
        t.unmap()
        
        pixels = self.partition(data)
        size = t.size()
        self.assert_(size[0] == 77 and size[1] == 100)
        self.assert_(size[0] * size[1] == len(pixels))
        self.compare(pixels, RED)
     
    def test_write(self):
        t = self.createTexture("images/horizontal.dds")
        
        w, h = t.size()
        
        t.map(MAP_READ_WRITE)
        orginal = t[::, ::]
        t[::, ::] = Color(0)
        blacked = t[::, ::]
        t.unmap()
        
        self.assert_(len(orginal) == (w * h * 4))
        self.assert_(blacked == b'\0' * (w * h * 4)) 
  
        self.assert_(orginal != blacked)

     
    def test_slicing(self):
        t = self.createTexture("images/horizontal.dds")
        
        t.map(MAP_READ_WRITE)
        row1 = t[::, 26:27]
        row2 = t[::, 79:80]
        row3 = t[::, 87:88]
        col1 = t[91:92, 40:69]
        t.unmap()
   
        w, h = t.size()
        self.assert_(w == 109 and h == 93)
        
        pixels1 = self.partition(row1)
        self.assert_(len(pixels1) == w)
        
        pixels2 = self.partition(row2)   
        pixels3 = self.partition(row3)  
        self.compare(pixels1, HLINE)
        self.compare(pixels2, HLINE)
        self.compare(pixels3, HLINEBG)
        
        self.failUnlessRaises(AssertionError, self.compare, pixels3, HLINE)

        pcol = self.partition(col1)
        self.assert_(len(pcol) == (69 - 40))
        self.compare(pcol, (255, 25, 67, 255))
        
    def test_array(self):
        t = self.createTexture(None, (73, 87, 3))
        for i in range(3):
            t.map(MAP_READ_WRITE, i)
            t[::, ::] = Color(i * 70)
            t.unmap()
        
        w, h = t.size()
        
        for i in range(3):
            t.map(MAP_READ_WRITE, i)
            
            color = bytearray([i * 70]) 
            self.assert_(t[::, ::] == color * (w*h*4))
            t.unmap()
        
        dest = self.createTexture(None, (73, 87))
        dest.map(MAP_READ_WRITE)
        dest[::, ::] = Color(1)
        dest.unmap()
        
        for i in range(3):
            dest.copyRegion(0, 0, w, h, 0, 0, t, 0, i)
            dest.map(MAP_READ_WRITE)
            
            color = bytearray([i * 70]) 
            self.assert_(dest[::, ::] == color * (w*h*4))

            dest.unmap()