progs/gallium/python: New home for python statetracker scripts.
This commit is contained in:
José Fonseca
@@ -30,7 +30,7 @@ or (in Windows)
|
||||
|
||||
and then try running
|
||||
|
||||
python src/gallium/state_trackers/python/samples/tri.py
|
||||
python progs/gallium/python/samples/tri.py
|
||||
|
||||
which should show a triangle.
|
||||
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
This is an application written in python to replay the traces captured by the
|
||||
trace pipe driver.
|
||||
|
||||
|
||||
To use it follow the instructions in src/gallium/drivers/trace/README and
|
||||
src/gallium/state_trackers/python/README, and then do
|
||||
|
||||
python src/gallium/state_trackers/python/samples/retrace/interpreter.py filename.trace
|
||||
|
||||
|
||||
This is still work in progress:
|
||||
- not everything is captured/replayed
|
||||
- surface/textures contents
|
||||
- any tiny error will result in a crash
|
||||
|
||||
--
|
||||
Jose Fonseca <jrfonseca@tungstengraphics.com>
|
||||
@@ -1,173 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
|
||||
class Formatter:
|
||||
'''Plain formatter'''
|
||||
|
||||
def __init__(self, stream):
|
||||
self.stream = stream
|
||||
|
||||
def text(self, text):
|
||||
self.stream.write(text)
|
||||
|
||||
def newline(self):
|
||||
self.text('\n')
|
||||
|
||||
def function(self, name):
|
||||
self.text(name)
|
||||
|
||||
def variable(self, name):
|
||||
self.text(name)
|
||||
|
||||
def literal(self, value):
|
||||
self.text(str(value))
|
||||
|
||||
def address(self, addr):
|
||||
self.text(str(addr))
|
||||
|
||||
|
||||
class AnsiFormatter(Formatter):
|
||||
'''Formatter for plain-text files which outputs ANSI escape codes. See
|
||||
http://en.wikipedia.org/wiki/ANSI_escape_code for more information
|
||||
concerning ANSI escape codes.
|
||||
'''
|
||||
|
||||
_csi = '\33['
|
||||
|
||||
_normal = '0m'
|
||||
_bold = '1m'
|
||||
_italic = '3m'
|
||||
_red = '31m'
|
||||
_green = '32m'
|
||||
_blue = '34m'
|
||||
|
||||
def _escape(self, code):
|
||||
self.text(self._csi + code)
|
||||
|
||||
def function(self, name):
|
||||
self._escape(self._bold)
|
||||
Formatter.function(self, name)
|
||||
self._escape(self._normal)
|
||||
|
||||
def variable(self, name):
|
||||
self._escape(self._italic)
|
||||
Formatter.variable(self, name)
|
||||
self._escape(self._normal)
|
||||
|
||||
def literal(self, value):
|
||||
self._escape(self._blue)
|
||||
Formatter.literal(self, value)
|
||||
self._escape(self._normal)
|
||||
|
||||
def address(self, value):
|
||||
self._escape(self._green)
|
||||
Formatter.address(self, value)
|
||||
self._escape(self._normal)
|
||||
|
||||
|
||||
class WindowsConsoleFormatter(Formatter):
|
||||
'''Formatter for the Windows Console. See
|
||||
http://code.activestate.com/recipes/496901/ for more information.
|
||||
'''
|
||||
|
||||
STD_INPUT_HANDLE = -10
|
||||
STD_OUTPUT_HANDLE = -11
|
||||
STD_ERROR_HANDLE = -12
|
||||
|
||||
FOREGROUND_BLUE = 0x01
|
||||
FOREGROUND_GREEN = 0x02
|
||||
FOREGROUND_RED = 0x04
|
||||
FOREGROUND_INTENSITY = 0x08
|
||||
BACKGROUND_BLUE = 0x10
|
||||
BACKGROUND_GREEN = 0x20
|
||||
BACKGROUND_RED = 0x40
|
||||
BACKGROUND_INTENSITY = 0x80
|
||||
|
||||
_normal = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
|
||||
_bold = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY
|
||||
_italic = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED
|
||||
_red = FOREGROUND_RED | FOREGROUND_INTENSITY
|
||||
_green = FOREGROUND_GREEN | FOREGROUND_INTENSITY
|
||||
_blue = FOREGROUND_BLUE | FOREGROUND_INTENSITY
|
||||
|
||||
def __init__(self, stream):
|
||||
Formatter.__init__(self, stream)
|
||||
|
||||
if stream is sys.stdin:
|
||||
nStdHandle = self.STD_INPUT_HANDLE
|
||||
elif stream is sys.stdout:
|
||||
nStdHandle = self.STD_OUTPUT_HANDLE
|
||||
elif stream is sys.stderr:
|
||||
nStdHandle = self.STD_ERROR_HANDLE
|
||||
else:
|
||||
nStdHandle = None
|
||||
|
||||
if nStdHandle:
|
||||
import ctypes
|
||||
self.handle = ctypes.windll.kernel32.GetStdHandle(nStdHandle)
|
||||
else:
|
||||
self.handle = None
|
||||
|
||||
def _attribute(self, attr):
|
||||
if self.handle:
|
||||
import ctypes
|
||||
ctypes.windll.kernel32.SetConsoleTextAttribute(self.handle, attr)
|
||||
|
||||
def function(self, name):
|
||||
self._attribute(self._bold)
|
||||
Formatter.function(self, name)
|
||||
self._attribute(self._normal)
|
||||
|
||||
def variable(self, name):
|
||||
self._attribute(self._italic)
|
||||
Formatter.variable(self, name)
|
||||
self._attribute(self._normal)
|
||||
|
||||
def literal(self, value):
|
||||
self._attribute(self._blue)
|
||||
Formatter.literal(self, value)
|
||||
self._attribute(self._normal)
|
||||
|
||||
def address(self, value):
|
||||
self._attribute(self._green)
|
||||
Formatter.address(self, value)
|
||||
self._attribute(self._normal)
|
||||
|
||||
|
||||
def DefaultFormatter(stream):
|
||||
if sys.platform in ('linux2', 'cygwin'):
|
||||
return AnsiFormatter(stream)
|
||||
elif sys.platform in ('win32',):
|
||||
return WindowsConsoleFormatter(stream)
|
||||
else:
|
||||
return Formatter(stream)
|
||||
|
||||
@@ -1,756 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
import sys
|
||||
import struct
|
||||
|
||||
import gallium
|
||||
import model
|
||||
import parse as parser
|
||||
|
||||
|
||||
try:
|
||||
from struct import unpack_from
|
||||
except ImportError:
|
||||
def unpack_from(fmt, buf, offset=0):
|
||||
size = struct.calcsize(fmt)
|
||||
return struct.unpack(fmt, buf[offset:offset + size])
|
||||
|
||||
|
||||
def make_image(surface, x=None, y=None, w=None, h=None):
|
||||
if x is None:
|
||||
x = 0
|
||||
if y is None:
|
||||
y = 0
|
||||
if w is None:
|
||||
w = surface.width - x
|
||||
if h is None:
|
||||
h = surface.height - y
|
||||
data = surface.get_tile_rgba8(x, y, surface.width, surface.height)
|
||||
|
||||
import Image
|
||||
outimage = Image.fromstring('RGBA', (w, h), data, "raw", 'RGBA', 0, 1)
|
||||
return outimage
|
||||
|
||||
def save_image(filename, surface, x=None, y=None, w=None, h=None):
|
||||
outimage = make_image(surface, x, y, w, h)
|
||||
outimage.save(filename, "PNG")
|
||||
|
||||
def show_image(surface, title, x=None, y=None, w=None, h=None):
|
||||
outimage = make_image(surface, x, y, w, h)
|
||||
|
||||
import Tkinter as tk
|
||||
from PIL import Image, ImageTk
|
||||
root = tk.Tk()
|
||||
|
||||
root.title(title)
|
||||
|
||||
image1 = ImageTk.PhotoImage(outimage)
|
||||
w = image1.width()
|
||||
h = image1.height()
|
||||
x = 100
|
||||
y = 100
|
||||
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
|
||||
panel1 = tk.Label(root, image=image1)
|
||||
panel1.pack(side='top', fill='both', expand='yes')
|
||||
panel1.image = image1
|
||||
root.mainloop()
|
||||
|
||||
|
||||
class Struct:
|
||||
"""C-like struct"""
|
||||
|
||||
# A basic Python class can pass as a C-like structure
|
||||
pass
|
||||
|
||||
|
||||
struct_factories = {
|
||||
"pipe_blend_color": gallium.BlendColor,
|
||||
"pipe_blend_state": gallium.Blend,
|
||||
#"pipe_clip_state": gallium.Clip,
|
||||
#"pipe_buffer": gallium.Buffer,
|
||||
"pipe_depth_state": gallium.Depth,
|
||||
"pipe_stencil_state": gallium.Stencil,
|
||||
"pipe_alpha_state": gallium.Alpha,
|
||||
"pipe_depth_stencil_alpha_state": gallium.DepthStencilAlpha,
|
||||
#"pipe_framebuffer_state": gallium.Framebuffer,
|
||||
"pipe_poly_stipple": gallium.PolyStipple,
|
||||
"pipe_rasterizer_state": gallium.Rasterizer,
|
||||
"pipe_sampler_state": gallium.Sampler,
|
||||
"pipe_scissor_state": gallium.Scissor,
|
||||
#"pipe_shader_state": gallium.Shader,
|
||||
#"pipe_vertex_buffer": gallium.VertexBuffer,
|
||||
"pipe_vertex_element": gallium.VertexElement,
|
||||
"pipe_viewport_state": gallium.Viewport,
|
||||
#"pipe_texture": gallium.Texture,
|
||||
}
|
||||
|
||||
|
||||
member_array_factories = {
|
||||
#"pipe_rasterizer_state": {"sprite_coord_mode": gallium.ByteArray},
|
||||
"pipe_poly_stipple": {"stipple": gallium.UnsignedArray},
|
||||
"pipe_viewport_state": {"scale": gallium.FloatArray, "translate": gallium.FloatArray},
|
||||
#"pipe_clip_state": {"ucp": gallium.FloatArray},
|
||||
"pipe_depth_stencil_alpha_state": {"stencil": gallium.StencilArray},
|
||||
"pipe_blend_color": {"color": gallium.FloatArray},
|
||||
"pipe_sampler_state": {"border_color": gallium.FloatArray},
|
||||
}
|
||||
|
||||
|
||||
class Translator(model.Visitor):
|
||||
"""Translate model arguments into regular Python objects"""
|
||||
|
||||
def __init__(self, interpreter):
|
||||
self.interpreter = interpreter
|
||||
self.result = None
|
||||
|
||||
def visit(self, node):
|
||||
self.result = None
|
||||
node.visit(self)
|
||||
return self.result
|
||||
|
||||
def visit_literal(self, node):
|
||||
self.result = node.value
|
||||
|
||||
def visit_named_constant(self, node):
|
||||
# lookup the named constant in the gallium module
|
||||
self.result = getattr(gallium, node.name)
|
||||
|
||||
def visit_array(self, node):
|
||||
array = []
|
||||
for element in node.elements:
|
||||
array.append(self.visit(element))
|
||||
self.result = array
|
||||
|
||||
def visit_struct(self, node):
|
||||
struct_factory = struct_factories.get(node.name, Struct)
|
||||
struct = struct_factory()
|
||||
for member_name, member_node in node.members:
|
||||
member_value = self.visit(member_node)
|
||||
try:
|
||||
array_factory = member_array_factories[node.name][member_name]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
assert isinstance(member_value, list)
|
||||
array = array_factory(len(member_value))
|
||||
for i in range(len(member_value)):
|
||||
array[i] = member_value[i]
|
||||
member_value = array
|
||||
#print node.name, member_name, member_value
|
||||
assert isinstance(struct, Struct) or hasattr(struct, member_name)
|
||||
setattr(struct, member_name, member_value)
|
||||
self.result = struct
|
||||
|
||||
def visit_pointer(self, node):
|
||||
self.result = self.interpreter.lookup_object(node.address)
|
||||
|
||||
|
||||
class Object:
|
||||
|
||||
def __init__(self, interpreter, real):
|
||||
self.interpreter = interpreter
|
||||
self.real = real
|
||||
|
||||
|
||||
class Global(Object):
|
||||
|
||||
def __init__(self, interpreter, real):
|
||||
self.interpreter = interpreter
|
||||
self.real = real
|
||||
|
||||
def pipe_winsys_create(self):
|
||||
return Winsys(self.interpreter, gallium.Device())
|
||||
|
||||
def pipe_screen_create(self, winsys=None):
|
||||
if winsys is None:
|
||||
real = gallium.Device()
|
||||
else:
|
||||
real = winsys.real
|
||||
return Screen(self.interpreter, real)
|
||||
|
||||
def pipe_context_create(self, screen):
|
||||
context = screen.real.context_create()
|
||||
return Context(self.interpreter, context)
|
||||
|
||||
|
||||
class Winsys(Object):
|
||||
|
||||
def __init__(self, interpreter, real):
|
||||
self.interpreter = interpreter
|
||||
self.real = real
|
||||
|
||||
def get_name(self):
|
||||
pass
|
||||
|
||||
def user_buffer_create(self, data, size):
|
||||
# We don't really care to distinguish between user and regular buffers
|
||||
buffer = self.real.buffer_create(size,
|
||||
4,
|
||||
gallium.PIPE_BUFFER_USAGE_CPU_READ |
|
||||
gallium.PIPE_BUFFER_USAGE_CPU_WRITE )
|
||||
assert size == len(data)
|
||||
buffer.write(data)
|
||||
return buffer
|
||||
|
||||
def buffer_create(self, alignment, usage, size):
|
||||
return self.real.buffer_create(size, alignment, usage)
|
||||
|
||||
def buffer_destroy(self, buffer):
|
||||
pass
|
||||
|
||||
def buffer_write(self, buffer, data, size):
|
||||
assert size == len(data)
|
||||
buffer.write(data)
|
||||
|
||||
def fence_finish(self, fence, flags):
|
||||
pass
|
||||
|
||||
def fence_reference(self, dst, src):
|
||||
pass
|
||||
|
||||
def flush_frontbuffer(self, surface):
|
||||
pass
|
||||
|
||||
def surface_alloc(self):
|
||||
return None
|
||||
|
||||
def surface_release(self, surface):
|
||||
pass
|
||||
|
||||
|
||||
class Transfer:
|
||||
|
||||
def __init__(self, surface, x, y, w, h):
|
||||
self.surface = surface
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.w = w
|
||||
self.h = h
|
||||
|
||||
|
||||
class Screen(Object):
|
||||
|
||||
def destroy(self):
|
||||
pass
|
||||
|
||||
def get_name(self):
|
||||
pass
|
||||
|
||||
def get_vendor(self):
|
||||
pass
|
||||
|
||||
def get_param(self, param):
|
||||
pass
|
||||
|
||||
def get_paramf(self, param):
|
||||
pass
|
||||
|
||||
def is_format_supported(self, format, target, tex_usage, geom_flags):
|
||||
return self.real.is_format_supported(format, target, tex_usage, geom_flags)
|
||||
|
||||
def texture_create(self, templat):
|
||||
return self.real.texture_create(
|
||||
format = templat.format,
|
||||
width = templat.width,
|
||||
height = templat.height,
|
||||
depth = templat.depth,
|
||||
last_level = templat.last_level,
|
||||
target = templat.target,
|
||||
tex_usage = templat.tex_usage,
|
||||
)
|
||||
|
||||
def texture_destroy(self, texture):
|
||||
self.interpreter.unregister_object(texture)
|
||||
|
||||
def texture_release(self, surface):
|
||||
pass
|
||||
|
||||
def get_tex_surface(self, texture, face, level, zslice, usage):
|
||||
if texture is None:
|
||||
return None
|
||||
return texture.get_surface(face, level, zslice)
|
||||
|
||||
def tex_surface_destroy(self, surface):
|
||||
self.interpreter.unregister_object(surface)
|
||||
|
||||
def tex_surface_release(self, surface):
|
||||
pass
|
||||
|
||||
def surface_write(self, surface, data, stride, size):
|
||||
if surface is None:
|
||||
return
|
||||
# assert surface.nblocksy * stride == size
|
||||
surface.put_tile_raw(0, 0, surface.width, surface.height, data, stride)
|
||||
|
||||
def get_tex_transfer(self, texture, face, level, zslice, usage, x, y, w, h):
|
||||
if texture is None:
|
||||
return None
|
||||
transfer = Transfer(texture.get_surface(face, level, zslice), x, y, w, h)
|
||||
if transfer and usage & gallium.PIPE_TRANSFER_READ:
|
||||
if self.interpreter.options.all:
|
||||
self.interpreter.present(transfer.surface, 'transf_read', x, y, w, h)
|
||||
return transfer
|
||||
|
||||
def tex_transfer_destroy(self, transfer):
|
||||
self.interpreter.unregister_object(transfer)
|
||||
|
||||
def transfer_write(self, transfer, stride, data, size):
|
||||
if transfer is None:
|
||||
return
|
||||
transfer.surface.put_tile_raw(transfer.x, transfer.y, transfer.w, transfer.h, data, stride)
|
||||
if self.interpreter.options.all:
|
||||
self.interpreter.present(transfer.surface, 'transf_write', transfer.x, transfer.y, transfer.w, transfer.h)
|
||||
|
||||
def user_buffer_create(self, data, size):
|
||||
# We don't really care to distinguish between user and regular buffers
|
||||
buffer = self.real.buffer_create(size,
|
||||
4,
|
||||
gallium.PIPE_BUFFER_USAGE_CPU_READ |
|
||||
gallium.PIPE_BUFFER_USAGE_CPU_WRITE )
|
||||
assert size == len(data)
|
||||
buffer.write(data)
|
||||
return buffer
|
||||
|
||||
def buffer_create(self, alignment, usage, size):
|
||||
return self.real.buffer_create(size, alignment, usage)
|
||||
|
||||
def buffer_destroy(self, buffer):
|
||||
pass
|
||||
|
||||
def buffer_write(self, buffer, data, size, offset=0):
|
||||
assert size == len(data)
|
||||
buffer.write(data)
|
||||
|
||||
def fence_finish(self, fence, flags):
|
||||
pass
|
||||
|
||||
def fence_reference(self, dst, src):
|
||||
pass
|
||||
|
||||
def flush_frontbuffer(self, surface):
|
||||
pass
|
||||
|
||||
|
||||
class Context(Object):
|
||||
|
||||
def __init__(self, interpreter, real):
|
||||
Object.__init__(self, interpreter, real)
|
||||
self.cbufs = []
|
||||
self.zsbuf = None
|
||||
self.vbufs = []
|
||||
self.velems = []
|
||||
self.dirty = False
|
||||
|
||||
def destroy(self):
|
||||
pass
|
||||
|
||||
def create_blend_state(self, state):
|
||||
return state
|
||||
|
||||
def bind_blend_state(self, state):
|
||||
if state is not None:
|
||||
self.real.set_blend(state)
|
||||
|
||||
def delete_blend_state(self, state):
|
||||
pass
|
||||
|
||||
def create_sampler_state(self, state):
|
||||
return state
|
||||
|
||||
def delete_sampler_state(self, state):
|
||||
pass
|
||||
|
||||
def bind_vertex_sampler_states(self, num_states, states):
|
||||
for i in range(num_states):
|
||||
self.real.set_vertex_sampler(i, states[i])
|
||||
|
||||
def bind_fragment_sampler_states(self, num_states, states):
|
||||
for i in range(num_states):
|
||||
self.real.set_fragment_sampler(i, states[i])
|
||||
|
||||
def create_rasterizer_state(self, state):
|
||||
return state
|
||||
|
||||
def bind_rasterizer_state(self, state):
|
||||
if state is not None:
|
||||
self.real.set_rasterizer(state)
|
||||
|
||||
def delete_rasterizer_state(self, state):
|
||||
pass
|
||||
|
||||
def create_depth_stencil_alpha_state(self, state):
|
||||
return state
|
||||
|
||||
def bind_depth_stencil_alpha_state(self, state):
|
||||
if state is not None:
|
||||
self.real.set_depth_stencil_alpha(state)
|
||||
|
||||
def delete_depth_stencil_alpha_state(self, state):
|
||||
pass
|
||||
|
||||
def create_fs_state(self, state):
|
||||
tokens = str(state.tokens)
|
||||
shader = gallium.Shader(tokens)
|
||||
return shader
|
||||
|
||||
create_vs_state = create_fs_state
|
||||
|
||||
def bind_fs_state(self, state):
|
||||
self.real.set_fragment_shader(state)
|
||||
|
||||
def bind_vs_state(self, state):
|
||||
self.real.set_vertex_shader(state)
|
||||
|
||||
def delete_fs_state(self, state):
|
||||
pass
|
||||
|
||||
delete_vs_state = delete_fs_state
|
||||
|
||||
def set_blend_color(self, state):
|
||||
self.real.set_blend_color(state)
|
||||
|
||||
def set_stencil_ref(self, state):
|
||||
self.real.set_stencil_ref(state)
|
||||
|
||||
def set_clip_state(self, state):
|
||||
_state = gallium.Clip()
|
||||
_state.nr = state.nr
|
||||
if state.nr:
|
||||
# FIXME
|
||||
ucp = gallium.FloatArray(gallium.PIPE_MAX_CLIP_PLANES*4)
|
||||
for i in range(len(state.ucp)):
|
||||
for j in range(len(state.ucp[i])):
|
||||
ucp[i*4 + j] = state.ucp[i][j]
|
||||
_state.ucp = ucp
|
||||
self.real.set_clip(_state)
|
||||
|
||||
def dump_constant_buffer(self, buffer):
|
||||
if not self.interpreter.verbosity(2):
|
||||
return
|
||||
|
||||
data = buffer.read()
|
||||
format = '4f'
|
||||
index = 0
|
||||
for offset in range(0, len(data), struct.calcsize(format)):
|
||||
x, y, z, w = unpack_from(format, data, offset)
|
||||
sys.stdout.write('\tCONST[%2u] = {%10.4f, %10.4f, %10.4f, %10.4f}\n' % (index, x, y, z, w))
|
||||
index += 1
|
||||
sys.stdout.flush()
|
||||
|
||||
def set_constant_buffer(self, shader, index, buffer):
|
||||
if buffer is not None:
|
||||
self.real.set_constant_buffer(shader, index, buffer)
|
||||
|
||||
self.dump_constant_buffer(buffer)
|
||||
|
||||
def set_framebuffer_state(self, state):
|
||||
_state = gallium.Framebuffer()
|
||||
_state.width = state.width
|
||||
_state.height = state.height
|
||||
_state.nr_cbufs = state.nr_cbufs
|
||||
for i in range(len(state.cbufs)):
|
||||
_state.set_cbuf(i, state.cbufs[i])
|
||||
_state.set_zsbuf(state.zsbuf)
|
||||
self.real.set_framebuffer(_state)
|
||||
|
||||
self.cbufs = state.cbufs
|
||||
self.zsbuf = state.zsbuf
|
||||
|
||||
def set_polygon_stipple(self, state):
|
||||
self.real.set_polygon_stipple(state)
|
||||
|
||||
def set_scissor_state(self, state):
|
||||
self.real.set_scissor(state)
|
||||
|
||||
def set_viewport_state(self, state):
|
||||
self.real.set_viewport(state)
|
||||
|
||||
def set_fragment_sampler_textures(self, num_textures, textures):
|
||||
for i in range(num_textures):
|
||||
self.real.set_fragment_sampler_texture(i, textures[i])
|
||||
|
||||
def set_vertex_sampler_textures(self, num_textures, textures):
|
||||
for i in range(num_textures):
|
||||
self.real.set_vertex_sampler_texture(i, textures[i])
|
||||
|
||||
def set_vertex_buffers(self, num_buffers, buffers):
|
||||
self.vbufs = buffers[0:num_buffers]
|
||||
for i in range(num_buffers):
|
||||
vbuf = buffers[i]
|
||||
self.real.set_vertex_buffer(
|
||||
i,
|
||||
stride = vbuf.stride,
|
||||
max_index = vbuf.max_index,
|
||||
buffer_offset = vbuf.buffer_offset,
|
||||
buffer = vbuf.buffer,
|
||||
)
|
||||
|
||||
def set_vertex_elements(self, num_elements, elements):
|
||||
self.velems = elements[0:num_elements]
|
||||
for i in range(num_elements):
|
||||
self.real.set_vertex_element(i, elements[i])
|
||||
self.real.set_vertex_elements(num_elements)
|
||||
|
||||
def dump_vertices(self, start, count):
|
||||
if not self.interpreter.verbosity(2):
|
||||
return
|
||||
|
||||
for index in range(start, start + count):
|
||||
if index >= start + 16:
|
||||
sys.stdout.write('\t...\n')
|
||||
break
|
||||
sys.stdout.write('\t{\n')
|
||||
for velem in self.velems:
|
||||
vbuf = self.vbufs[velem.vertex_buffer_index]
|
||||
|
||||
offset = vbuf.buffer_offset + velem.src_offset + vbuf.stride*index
|
||||
format = {
|
||||
gallium.PIPE_FORMAT_R32_FLOAT: 'f',
|
||||
gallium.PIPE_FORMAT_R32G32_FLOAT: '2f',
|
||||
gallium.PIPE_FORMAT_R32G32B32_FLOAT: '3f',
|
||||
gallium.PIPE_FORMAT_R32G32B32A32_FLOAT: '4f',
|
||||
gallium.PIPE_FORMAT_B8G8R8A8_UNORM: '4B',
|
||||
gallium.PIPE_FORMAT_R8G8B8A8_UNORM: '4B',
|
||||
gallium.PIPE_FORMAT_R16G16B16_SNORM: '3h',
|
||||
}[velem.src_format]
|
||||
|
||||
data = vbuf.buffer.read()
|
||||
values = unpack_from(format, data, offset)
|
||||
sys.stdout.write('\t\t{' + ', '.join(map(str, values)) + '},\n')
|
||||
assert len(values) == velem.nr_components
|
||||
sys.stdout.write('\t},\n')
|
||||
sys.stdout.flush()
|
||||
|
||||
def dump_indices(self, ibuf, isize, start, count):
|
||||
if not self.interpreter.verbosity(2):
|
||||
return
|
||||
|
||||
format = {
|
||||
1: 'B',
|
||||
2: 'H',
|
||||
4: 'I',
|
||||
}[isize]
|
||||
|
||||
assert struct.calcsize(format) == isize
|
||||
|
||||
data = ibuf.read()
|
||||
maxindex, minindex = 0, 0xffffffff
|
||||
|
||||
sys.stdout.write('\t{\n')
|
||||
for i in range(start, start + count):
|
||||
if i >= start + 16:
|
||||
sys.stdout.write('\t...\n')
|
||||
break
|
||||
offset = i*isize
|
||||
index, = unpack_from(format, data, offset)
|
||||
sys.stdout.write('\t\t%u,\n' % index)
|
||||
minindex = min(minindex, index)
|
||||
maxindex = max(maxindex, index)
|
||||
sys.stdout.write('\t},\n')
|
||||
sys.stdout.flush()
|
||||
|
||||
return minindex, maxindex
|
||||
|
||||
def draw_arrays(self, mode, start, count):
|
||||
self.dump_vertices(start, count)
|
||||
|
||||
self.real.draw_arrays(mode, start, count)
|
||||
self._set_dirty()
|
||||
|
||||
def draw_elements(self, indexBuffer, indexSize, mode, start, count):
|
||||
if self.interpreter.verbosity(2):
|
||||
minindex, maxindex = self.dump_indices(indexBuffer, indexSize, start, count)
|
||||
self.dump_vertices(minindex, maxindex - minindex)
|
||||
|
||||
self.real.draw_elements(indexBuffer, indexSize, mode, start, count)
|
||||
self._set_dirty()
|
||||
|
||||
def draw_range_elements(self, indexBuffer, indexSize, minIndex, maxIndex, mode, start, count):
|
||||
if self.interpreter.verbosity(2):
|
||||
minindex, maxindex = self.dump_indices(indexBuffer, indexSize, start, count)
|
||||
minindex = min(minindex, minIndex)
|
||||
maxindex = min(maxindex, maxIndex)
|
||||
self.dump_vertices(minindex, maxindex - minindex)
|
||||
|
||||
self.real.draw_range_elements(indexBuffer, indexSize, minIndex, maxIndex, mode, start, count)
|
||||
self._set_dirty()
|
||||
|
||||
def surface_copy(self, dest, destx, desty, src, srcx, srcy, width, height):
|
||||
if dest is not None and src is not None:
|
||||
if self.interpreter.options.all:
|
||||
self.interpreter.present(src, 'surface_copy_src', srcx, srcy, width, height)
|
||||
self.real.surface_copy(dest, destx, desty, src, srcx, srcy, width, height)
|
||||
if dest in self.cbufs:
|
||||
self._set_dirty()
|
||||
flags = gallium.PIPE_FLUSH_FRAME
|
||||
else:
|
||||
flags = 0
|
||||
self.flush(flags)
|
||||
if self.interpreter.options.all:
|
||||
self.interpreter.present(dest, 'surface_copy_dest', destx, desty, width, height)
|
||||
|
||||
def is_texture_referenced(self, texture, face, level):
|
||||
#return self.real.is_texture_referenced(format, texture, face, level)
|
||||
pass
|
||||
|
||||
def is_buffer_referenced(self, buf):
|
||||
#return self.real.is_buffer_referenced(format, buf)
|
||||
pass
|
||||
|
||||
def _set_dirty(self):
|
||||
if self.interpreter.options.step:
|
||||
self._present()
|
||||
else:
|
||||
self.dirty = True
|
||||
|
||||
def flush(self, flags):
|
||||
self.real.flush(flags)
|
||||
if self.dirty:
|
||||
if flags & gallium.PIPE_FLUSH_FRAME:
|
||||
self._present()
|
||||
self.dirty = False
|
||||
return None
|
||||
|
||||
def clear(self, buffers, rgba, depth, stencil):
|
||||
_rgba = gallium.FloatArray(4)
|
||||
for i in range(4):
|
||||
_rgba[i] = rgba[i]
|
||||
self.real.clear(buffers, _rgba, depth, stencil)
|
||||
|
||||
def _present(self):
|
||||
self.real.flush()
|
||||
|
||||
if self.cbufs and self.cbufs[0]:
|
||||
self.interpreter.present(self.cbufs[0], "cbuf")
|
||||
if self.zsbuf:
|
||||
if self.interpreter.options.all:
|
||||
self.interpreter.present(self.zsbuf, "zsbuf")
|
||||
|
||||
|
||||
class Interpreter(parser.TraceDumper):
|
||||
|
||||
ignore_calls = set((
|
||||
('pipe_screen', 'is_format_supported'),
|
||||
('pipe_screen', 'get_param'),
|
||||
('pipe_screen', 'get_paramf'),
|
||||
))
|
||||
|
||||
def __init__(self, stream, options):
|
||||
parser.TraceDumper.__init__(self, stream)
|
||||
self.options = options
|
||||
self.objects = {}
|
||||
self.result = None
|
||||
self.globl = Global(self, None)
|
||||
self.call_no = None
|
||||
|
||||
def register_object(self, address, object):
|
||||
self.objects[address] = object
|
||||
|
||||
def unregister_object(self, object):
|
||||
# FIXME:
|
||||
pass
|
||||
|
||||
def lookup_object(self, address):
|
||||
return self.objects[address]
|
||||
|
||||
def interpret(self, trace):
|
||||
for call in trace.calls:
|
||||
self.interpret_call(call)
|
||||
|
||||
def handle_call(self, call):
|
||||
if self.options.stop and call.no > self.options.stop:
|
||||
sys.exit(0)
|
||||
|
||||
if (call.klass, call.method) in self.ignore_calls:
|
||||
return
|
||||
|
||||
self.call_no = call.no
|
||||
|
||||
if self.verbosity(1):
|
||||
parser.TraceDumper.handle_call(self, call)
|
||||
sys.stdout.flush()
|
||||
|
||||
args = [(str(name), self.interpret_arg(arg)) for name, arg in call.args]
|
||||
|
||||
if call.klass:
|
||||
name, obj = args[0]
|
||||
args = args[1:]
|
||||
else:
|
||||
obj = self.globl
|
||||
|
||||
method = getattr(obj, call.method)
|
||||
ret = method(**dict(args))
|
||||
|
||||
if call.ret and isinstance(call.ret, model.Pointer):
|
||||
if ret is None:
|
||||
sys.stderr.write('warning: NULL returned\n')
|
||||
self.register_object(call.ret.address, ret)
|
||||
|
||||
self.call_no = None
|
||||
|
||||
def interpret_arg(self, node):
|
||||
translator = Translator(self)
|
||||
return translator.visit(node)
|
||||
|
||||
def verbosity(self, level):
|
||||
return self.options.verbosity >= level
|
||||
|
||||
def present(self, surface, description, x=None, y=None, w=None, h=None):
|
||||
if self.call_no < self.options.start:
|
||||
return
|
||||
|
||||
if self.options.images:
|
||||
filename = '%04u_%s.png' % (self.call_no, description)
|
||||
save_image(filename, surface, x, y, w, h)
|
||||
else:
|
||||
title = '%u. %s' % (self.call_no, description)
|
||||
show_image(surface, title, x, y, w, h)
|
||||
|
||||
|
||||
class Main(parser.Main):
|
||||
|
||||
def get_optparser(self):
|
||||
optparser = parser.Main.get_optparser(self)
|
||||
optparser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbosity", help="no messages")
|
||||
optparser.add_option("-v", "--verbose", action="count", dest="verbosity", default=1, help="increase verbosity level")
|
||||
optparser.add_option("-i", "--images", action="store_true", dest="images", default=False, help="save images instead of showing them")
|
||||
optparser.add_option("-a", "--all", action="store_true", dest="all", default=False, help="show depth, stencil, and transfers")
|
||||
optparser.add_option("-s", "--step", action="store_true", dest="step", default=False, help="step trhough every draw")
|
||||
optparser.add_option("-f", "--from", action="store", type="int", dest="start", default=0, help="from call no")
|
||||
optparser.add_option("-t", "--to", action="store", type="int", dest="stop", default=0, help="until call no")
|
||||
return optparser
|
||||
|
||||
def process_arg(self, stream, options):
|
||||
parser = Interpreter(stream, options)
|
||||
parser.parse()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
Main().main()
|
||||
@@ -1,213 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
'''Trace data model.'''
|
||||
|
||||
|
||||
import sys
|
||||
import string
|
||||
import format
|
||||
|
||||
try:
|
||||
from cStringIO import StringIO
|
||||
except ImportError:
|
||||
from StringIO import StringIO
|
||||
|
||||
|
||||
class Node:
|
||||
|
||||
def visit(self, visitor):
|
||||
raise NotImplementedError
|
||||
|
||||
def __str__(self):
|
||||
stream = StringIO()
|
||||
formatter = format.DefaultFormatter(stream)
|
||||
pretty_printer = PrettyPrinter(formatter)
|
||||
self.visit(pretty_printer)
|
||||
return stream.getvalue()
|
||||
|
||||
|
||||
class Literal(Node):
|
||||
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_literal(self)
|
||||
|
||||
|
||||
class NamedConstant(Node):
|
||||
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_named_constant(self)
|
||||
|
||||
|
||||
class Array(Node):
|
||||
|
||||
def __init__(self, elements):
|
||||
self.elements = elements
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_array(self)
|
||||
|
||||
|
||||
class Struct(Node):
|
||||
|
||||
def __init__(self, name, members):
|
||||
self.name = name
|
||||
self.members = members
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_struct(self)
|
||||
|
||||
|
||||
class Pointer(Node):
|
||||
|
||||
def __init__(self, address):
|
||||
self.address = address
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_pointer(self)
|
||||
|
||||
|
||||
class Call:
|
||||
|
||||
def __init__(self, no, klass, method, args, ret):
|
||||
self.no = no
|
||||
self.klass = klass
|
||||
self.method = method
|
||||
self.args = args
|
||||
self.ret = ret
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_call(self)
|
||||
|
||||
|
||||
class Trace:
|
||||
|
||||
def __init__(self, calls):
|
||||
self.calls = calls
|
||||
|
||||
def visit(self, visitor):
|
||||
visitor.visit_trace(self)
|
||||
|
||||
|
||||
class Visitor:
|
||||
|
||||
def visit_literal(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
def visit_named_constant(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
def visit_array(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
def visit_struct(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
def visit_pointer(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
def visit_call(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
def visit_trace(self, node):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class PrettyPrinter:
|
||||
|
||||
def __init__(self, formatter):
|
||||
self.formatter = formatter
|
||||
|
||||
def visit_literal(self, node):
|
||||
if isinstance(node.value, basestring):
|
||||
if len(node.value) >= 4096 or node.value.strip(string.printable):
|
||||
self.formatter.text('...')
|
||||
return
|
||||
|
||||
self.formatter.literal('"' + node.value + '"')
|
||||
return
|
||||
|
||||
self.formatter.literal(repr(node.value))
|
||||
|
||||
def visit_named_constant(self, node):
|
||||
self.formatter.literal(node.name)
|
||||
|
||||
def visit_array(self, node):
|
||||
self.formatter.text('{')
|
||||
sep = ''
|
||||
for value in node.elements:
|
||||
self.formatter.text(sep)
|
||||
value.visit(self)
|
||||
sep = ', '
|
||||
self.formatter.text('}')
|
||||
|
||||
def visit_struct(self, node):
|
||||
self.formatter.text('{')
|
||||
sep = ''
|
||||
for name, value in node.members:
|
||||
self.formatter.text(sep)
|
||||
self.formatter.variable(name)
|
||||
self.formatter.text(' = ')
|
||||
value.visit(self)
|
||||
sep = ', '
|
||||
self.formatter.text('}')
|
||||
|
||||
def visit_pointer(self, node):
|
||||
self.formatter.address(node.address)
|
||||
|
||||
def visit_call(self, node):
|
||||
self.formatter.text('%s ' % node.no)
|
||||
if node.klass is not None:
|
||||
self.formatter.function(node.klass + '::' + node.method)
|
||||
else:
|
||||
self.formatter.function(node.method)
|
||||
self.formatter.text('(')
|
||||
sep = ''
|
||||
for name, value in node.args:
|
||||
self.formatter.text(sep)
|
||||
self.formatter.variable(name)
|
||||
self.formatter.text(' = ')
|
||||
value.visit(self)
|
||||
sep = ', '
|
||||
self.formatter.text(')')
|
||||
if node.ret is not None:
|
||||
self.formatter.text(' = ')
|
||||
node.ret.visit(self)
|
||||
|
||||
def visit_trace(self, node):
|
||||
for call in node.calls:
|
||||
call.visit(self)
|
||||
self.formatter.newline()
|
||||
|
||||
@@ -1,392 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
import sys
|
||||
import xml.parsers.expat
|
||||
import binascii
|
||||
import optparse
|
||||
|
||||
from model import *
|
||||
|
||||
|
||||
ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF = range(4)
|
||||
|
||||
|
||||
class XmlToken:
|
||||
|
||||
def __init__(self, type, name_or_data, attrs = None, line = None, column = None):
|
||||
assert type in (ELEMENT_START, ELEMENT_END, CHARACTER_DATA, EOF)
|
||||
self.type = type
|
||||
self.name_or_data = name_or_data
|
||||
self.attrs = attrs
|
||||
self.line = line
|
||||
self.column = column
|
||||
|
||||
def __str__(self):
|
||||
if self.type == ELEMENT_START:
|
||||
return '<' + self.name_or_data + ' ...>'
|
||||
if self.type == ELEMENT_END:
|
||||
return '</' + self.name_or_data + '>'
|
||||
if self.type == CHARACTER_DATA:
|
||||
return self.name_or_data
|
||||
if self.type == EOF:
|
||||
return 'end of file'
|
||||
assert 0
|
||||
|
||||
|
||||
class XmlTokenizer:
|
||||
"""Expat based XML tokenizer."""
|
||||
|
||||
def __init__(self, fp, skip_ws = True):
|
||||
self.fp = fp
|
||||
self.tokens = []
|
||||
self.index = 0
|
||||
self.final = False
|
||||
self.skip_ws = skip_ws
|
||||
|
||||
self.character_pos = 0, 0
|
||||
self.character_data = ''
|
||||
|
||||
self.parser = xml.parsers.expat.ParserCreate()
|
||||
self.parser.StartElementHandler = self.handle_element_start
|
||||
self.parser.EndElementHandler = self.handle_element_end
|
||||
self.parser.CharacterDataHandler = self.handle_character_data
|
||||
|
||||
def handle_element_start(self, name, attributes):
|
||||
self.finish_character_data()
|
||||
line, column = self.pos()
|
||||
token = XmlToken(ELEMENT_START, name, attributes, line, column)
|
||||
self.tokens.append(token)
|
||||
|
||||
def handle_element_end(self, name):
|
||||
self.finish_character_data()
|
||||
line, column = self.pos()
|
||||
token = XmlToken(ELEMENT_END, name, None, line, column)
|
||||
self.tokens.append(token)
|
||||
|
||||
def handle_character_data(self, data):
|
||||
if not self.character_data:
|
||||
self.character_pos = self.pos()
|
||||
self.character_data += data
|
||||
|
||||
def finish_character_data(self):
|
||||
if self.character_data:
|
||||
if not self.skip_ws or not self.character_data.isspace():
|
||||
line, column = self.character_pos
|
||||
token = XmlToken(CHARACTER_DATA, self.character_data, None, line, column)
|
||||
self.tokens.append(token)
|
||||
self.character_data = ''
|
||||
|
||||
def next(self):
|
||||
size = 16*1024
|
||||
while self.index >= len(self.tokens) and not self.final:
|
||||
self.tokens = []
|
||||
self.index = 0
|
||||
data = self.fp.read(size)
|
||||
self.final = len(data) < size
|
||||
data = data.rstrip('\0')
|
||||
try:
|
||||
self.parser.Parse(data, self.final)
|
||||
except xml.parsers.expat.ExpatError, e:
|
||||
#if e.code == xml.parsers.expat.errors.XML_ERROR_NO_ELEMENTS:
|
||||
if e.code == 3:
|
||||
pass
|
||||
else:
|
||||
raise e
|
||||
if self.index >= len(self.tokens):
|
||||
line, column = self.pos()
|
||||
token = XmlToken(EOF, None, None, line, column)
|
||||
else:
|
||||
token = self.tokens[self.index]
|
||||
self.index += 1
|
||||
return token
|
||||
|
||||
def pos(self):
|
||||
return self.parser.CurrentLineNumber, self.parser.CurrentColumnNumber
|
||||
|
||||
|
||||
class TokenMismatch(Exception):
|
||||
|
||||
def __init__(self, expected, found):
|
||||
self.expected = expected
|
||||
self.found = found
|
||||
|
||||
def __str__(self):
|
||||
return '%u:%u: %s expected, %s found' % (self.found.line, self.found.column, str(self.expected), str(self.found))
|
||||
|
||||
|
||||
|
||||
class XmlParser:
|
||||
"""Base XML document parser."""
|
||||
|
||||
def __init__(self, fp):
|
||||
self.tokenizer = XmlTokenizer(fp)
|
||||
self.consume()
|
||||
|
||||
def consume(self):
|
||||
self.token = self.tokenizer.next()
|
||||
|
||||
def match_element_start(self, name):
|
||||
return self.token.type == ELEMENT_START and self.token.name_or_data == name
|
||||
|
||||
def match_element_end(self, name):
|
||||
return self.token.type == ELEMENT_END and self.token.name_or_data == name
|
||||
|
||||
def element_start(self, name):
|
||||
while self.token.type == CHARACTER_DATA:
|
||||
self.consume()
|
||||
if self.token.type != ELEMENT_START:
|
||||
raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token)
|
||||
if self.token.name_or_data != name:
|
||||
raise TokenMismatch(XmlToken(ELEMENT_START, name), self.token)
|
||||
attrs = self.token.attrs
|
||||
self.consume()
|
||||
return attrs
|
||||
|
||||
def element_end(self, name):
|
||||
while self.token.type == CHARACTER_DATA:
|
||||
self.consume()
|
||||
if self.token.type != ELEMENT_END:
|
||||
raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token)
|
||||
if self.token.name_or_data != name:
|
||||
raise TokenMismatch(XmlToken(ELEMENT_END, name), self.token)
|
||||
self.consume()
|
||||
|
||||
def character_data(self, strip = True):
|
||||
data = ''
|
||||
while self.token.type == CHARACTER_DATA:
|
||||
data += self.token.name_or_data
|
||||
self.consume()
|
||||
if strip:
|
||||
data = data.strip()
|
||||
return data
|
||||
|
||||
|
||||
class TraceParser(XmlParser):
|
||||
|
||||
def __init__(self, fp):
|
||||
XmlParser.__init__(self, fp)
|
||||
self.last_call_no = 0
|
||||
|
||||
def parse(self):
|
||||
self.element_start('trace')
|
||||
while self.token.type not in (ELEMENT_END, EOF):
|
||||
call = self.parse_call()
|
||||
self.handle_call(call)
|
||||
if self.token.type != EOF:
|
||||
self.element_end('trace')
|
||||
|
||||
def parse_call(self):
|
||||
attrs = self.element_start('call')
|
||||
try:
|
||||
no = int(attrs['no'])
|
||||
except KeyError:
|
||||
self.last_call_no += 1
|
||||
no = self.last_call_no
|
||||
else:
|
||||
self.last_call_no = no
|
||||
klass = attrs['class']
|
||||
method = attrs['method']
|
||||
args = []
|
||||
ret = None
|
||||
while self.token.type == ELEMENT_START:
|
||||
if self.token.name_or_data == 'arg':
|
||||
arg = self.parse_arg()
|
||||
args.append(arg)
|
||||
elif self.token.name_or_data == 'ret':
|
||||
ret = self.parse_ret()
|
||||
elif self.token.name_or_data == 'call':
|
||||
# ignore nested function calls
|
||||
self.parse_call()
|
||||
else:
|
||||
raise TokenMismatch("<arg ...> or <ret ...>", self.token)
|
||||
self.element_end('call')
|
||||
|
||||
return Call(no, klass, method, args, ret)
|
||||
|
||||
def parse_arg(self):
|
||||
attrs = self.element_start('arg')
|
||||
name = attrs['name']
|
||||
value = self.parse_value()
|
||||
self.element_end('arg')
|
||||
|
||||
return name, value
|
||||
|
||||
def parse_ret(self):
|
||||
attrs = self.element_start('ret')
|
||||
value = self.parse_value()
|
||||
self.element_end('ret')
|
||||
|
||||
return value
|
||||
|
||||
def parse_value(self):
|
||||
expected_tokens = ('null', 'bool', 'int', 'uint', 'float', 'string', 'enum', 'array', 'struct', 'ptr', 'bytes')
|
||||
if self.token.type == ELEMENT_START:
|
||||
if self.token.name_or_data in expected_tokens:
|
||||
method = getattr(self, 'parse_' + self.token.name_or_data)
|
||||
return method()
|
||||
raise TokenMismatch(" or " .join(expected_tokens), self.token)
|
||||
|
||||
def parse_null(self):
|
||||
self.element_start('null')
|
||||
self.element_end('null')
|
||||
return Literal(None)
|
||||
|
||||
def parse_bool(self):
|
||||
self.element_start('bool')
|
||||
value = int(self.character_data())
|
||||
self.element_end('bool')
|
||||
return Literal(value)
|
||||
|
||||
def parse_int(self):
|
||||
self.element_start('int')
|
||||
value = int(self.character_data())
|
||||
self.element_end('int')
|
||||
return Literal(value)
|
||||
|
||||
def parse_uint(self):
|
||||
self.element_start('uint')
|
||||
value = int(self.character_data())
|
||||
self.element_end('uint')
|
||||
return Literal(value)
|
||||
|
||||
def parse_float(self):
|
||||
self.element_start('float')
|
||||
value = float(self.character_data())
|
||||
self.element_end('float')
|
||||
return Literal(value)
|
||||
|
||||
def parse_enum(self):
|
||||
self.element_start('enum')
|
||||
name = self.character_data()
|
||||
self.element_end('enum')
|
||||
return NamedConstant(name)
|
||||
|
||||
def parse_string(self):
|
||||
self.element_start('string')
|
||||
value = self.character_data()
|
||||
self.element_end('string')
|
||||
return Literal(value)
|
||||
|
||||
def parse_bytes(self):
|
||||
self.element_start('bytes')
|
||||
value = binascii.a2b_hex(self.character_data())
|
||||
self.element_end('bytes')
|
||||
return Literal(value)
|
||||
|
||||
def parse_array(self):
|
||||
self.element_start('array')
|
||||
elems = []
|
||||
while self.token.type != ELEMENT_END:
|
||||
elems.append(self.parse_elem())
|
||||
self.element_end('array')
|
||||
return Array(elems)
|
||||
|
||||
def parse_elem(self):
|
||||
self.element_start('elem')
|
||||
value = self.parse_value()
|
||||
self.element_end('elem')
|
||||
return value
|
||||
|
||||
def parse_struct(self):
|
||||
attrs = self.element_start('struct')
|
||||
name = attrs['name']
|
||||
members = []
|
||||
while self.token.type != ELEMENT_END:
|
||||
members.append(self.parse_member())
|
||||
self.element_end('struct')
|
||||
return Struct(name, members)
|
||||
|
||||
def parse_member(self):
|
||||
attrs = self.element_start('member')
|
||||
name = attrs['name']
|
||||
value = self.parse_value()
|
||||
self.element_end('member')
|
||||
|
||||
return name, value
|
||||
|
||||
def parse_ptr(self):
|
||||
self.element_start('ptr')
|
||||
address = self.character_data()
|
||||
self.element_end('ptr')
|
||||
|
||||
return Pointer(address)
|
||||
|
||||
def handle_call(self, call):
|
||||
pass
|
||||
|
||||
|
||||
class TraceDumper(TraceParser):
|
||||
|
||||
def __init__(self, fp):
|
||||
TraceParser.__init__(self, fp)
|
||||
self.formatter = format.DefaultFormatter(sys.stdout)
|
||||
self.pretty_printer = PrettyPrinter(self.formatter)
|
||||
|
||||
def handle_call(self, call):
|
||||
call.visit(self.pretty_printer)
|
||||
self.formatter.newline()
|
||||
|
||||
|
||||
class Main:
|
||||
'''Common main class for all retrace command line utilities.'''
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def main(self):
|
||||
optparser = self.get_optparser()
|
||||
(options, args) = optparser.parse_args(sys.argv[1:])
|
||||
|
||||
if args:
|
||||
for arg in args:
|
||||
if arg.endswith('.gz'):
|
||||
from gzip import GzipFile
|
||||
stream = GzipFile(arg, 'rt')
|
||||
elif arg.endswith('.bz2'):
|
||||
from bz2 import BZ2File
|
||||
stream = BZ2File(arg, 'rU')
|
||||
else:
|
||||
stream = open(arg, 'rt')
|
||||
self.process_arg(stream, options)
|
||||
else:
|
||||
self.process_arg(stream, options)
|
||||
|
||||
def get_optparser(self):
|
||||
optparser = optparse.OptionParser(
|
||||
usage="\n\t%prog [options] [traces] ...")
|
||||
return optparser
|
||||
|
||||
def process_arg(self, stream, options):
|
||||
parser = TraceDumper(stream)
|
||||
parser.parse()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
Main().main()
|
||||
@@ -1,34 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
from parse import *
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
Main().main()
|
||||
@@ -1,254 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
from gallium import *
|
||||
|
||||
|
||||
def make_image(surface):
|
||||
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
|
||||
|
||||
import Image
|
||||
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
|
||||
return outimage
|
||||
|
||||
def save_image(filename, surface):
|
||||
outimage = make_image(surface)
|
||||
outimage.save(filename, "PNG")
|
||||
|
||||
def show_image(surface):
|
||||
outimage = make_image(surface)
|
||||
|
||||
import Tkinter as tk
|
||||
from PIL import Image, ImageTk
|
||||
root = tk.Tk()
|
||||
|
||||
root.title('background image')
|
||||
|
||||
image1 = ImageTk.PhotoImage(outimage)
|
||||
w = image1.width()
|
||||
h = image1.height()
|
||||
x = 100
|
||||
y = 100
|
||||
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
|
||||
panel1 = tk.Label(root, image=image1)
|
||||
panel1.pack(side='top', fill='both', expand='yes')
|
||||
panel1.image = image1
|
||||
root.mainloop()
|
||||
|
||||
|
||||
def test(dev):
|
||||
ctx = dev.context_create()
|
||||
|
||||
width = 255
|
||||
height = 255
|
||||
minz = 0.0
|
||||
maxz = 1.0
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
depth_stencil_alpha.depth.enabled = 1
|
||||
depth_stencil_alpha.depth.writemask = 1
|
||||
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.scissor = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# viewport
|
||||
viewport = Viewport()
|
||||
scale = FloatArray(4)
|
||||
scale[0] = width / 2.0
|
||||
scale[1] = -height / 2.0
|
||||
scale[2] = (maxz - minz) / 2.0
|
||||
scale[3] = 1.0
|
||||
viewport.scale = scale
|
||||
translate = FloatArray(4)
|
||||
translate[0] = width / 2.0
|
||||
translate[1] = height / 2.0
|
||||
translate[2] = (maxz - minz) / 2.0
|
||||
translate[3] = 0.0
|
||||
viewport.translate = translate
|
||||
ctx.set_viewport(viewport)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
ctx.set_sampler(0, sampler)
|
||||
|
||||
# scissor
|
||||
scissor = Scissor()
|
||||
scissor.minx = 0
|
||||
scissor.miny = 0
|
||||
scissor.maxx = width
|
||||
scissor.maxy = height
|
||||
ctx.set_scissor(scissor)
|
||||
|
||||
clip = Clip()
|
||||
clip.nr = 0
|
||||
ctx.set_clip(clip)
|
||||
|
||||
# framebuffer
|
||||
cbuf = dev.texture_create(
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
width, height,
|
||||
tex_usage=PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
).get_surface()
|
||||
zbuf = dev.texture_create(
|
||||
PIPE_FORMAT_Z32_UNORM,
|
||||
width, height,
|
||||
tex_usage=PIPE_TEXTURE_USAGE_DEPTH_STENCIL,
|
||||
).get_surface()
|
||||
fb = Framebuffer()
|
||||
fb.width = width
|
||||
fb.height = height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, cbuf)
|
||||
fb.set_zsbuf(zbuf)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.0
|
||||
rgba[1] = 0.0
|
||||
rgba[2] = 0.0
|
||||
rgba[3] = 0.0
|
||||
ctx.clear(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0xff)
|
||||
|
||||
# vertex shader
|
||||
vs = Shader('''
|
||||
VERT
|
||||
DCL IN[0], POSITION, CONSTANT
|
||||
DCL IN[1], COLOR, CONSTANT
|
||||
DCL OUT[0], POSITION, CONSTANT
|
||||
DCL OUT[1], COLOR, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:MOV OUT[1], IN[1]
|
||||
2:END
|
||||
''')
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
gs = Shader('''
|
||||
GEOM
|
||||
PROPERTY GS_INPUT_PRIMITIVE TRIANGLES
|
||||
PROPERTY GS_OUTPUT_PRIMITIVE TRIANGLE_STRIP
|
||||
DCL IN[][0], POSITION, CONSTANT
|
||||
DCL IN[][1], COLOR, CONSTANT
|
||||
DCL OUT[0], POSITION, CONSTANT
|
||||
DCL OUT[1], COLOR, CONSTANT
|
||||
0:MOV OUT[0], IN[0][0]
|
||||
1:MOV OUT[1], IN[0][1]
|
||||
2:EMIT
|
||||
3:MOV OUT[0], IN[1][0]
|
||||
4:MOV OUT[1], IN[1][1]
|
||||
5:EMIT
|
||||
6:MOV OUT[0], IN[2][0]
|
||||
7:MOV OUT[1], IN[2][1]
|
||||
8:EMIT
|
||||
9:ENDPRIM
|
||||
10:END
|
||||
''')
|
||||
ctx.set_geometry_shader(gs)
|
||||
|
||||
# fragment shader
|
||||
fs = Shader('''
|
||||
FRAG
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:END
|
||||
''')
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
nverts = 3
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
verts[ 0] = 0.0 # x1
|
||||
verts[ 1] = 0.8 # y1
|
||||
verts[ 2] = 0.2 # z1
|
||||
verts[ 3] = 1.0 # w1
|
||||
verts[ 4] = 1.0 # r1
|
||||
verts[ 5] = 0.0 # g1
|
||||
verts[ 6] = 0.0 # b1
|
||||
verts[ 7] = 1.0 # a1
|
||||
verts[ 8] = -0.8 # x2
|
||||
verts[ 9] = -0.8 # y2
|
||||
verts[10] = 0.5 # z2
|
||||
verts[11] = 1.0 # w2
|
||||
verts[12] = 0.0 # r2
|
||||
verts[13] = 1.0 # g2
|
||||
verts[14] = 0.0 # b2
|
||||
verts[15] = 1.0 # a2
|
||||
verts[16] = 0.8 # x3
|
||||
verts[17] = -0.8 # y3
|
||||
verts[18] = 0.8 # z3
|
||||
verts[19] = 1.0 # w3
|
||||
verts[20] = 0.0 # r3
|
||||
verts[21] = 0.0 # g3
|
||||
verts[22] = 1.0 # b3
|
||||
verts[23] = 1.0 # a3
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
show_image(cbuf)
|
||||
#show_image(zbuf)
|
||||
#save_image('cbuf.png', cbuf)
|
||||
#save_image('zbuf.png', zbuf)
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
dev = Device()
|
||||
test(dev)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,232 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
from gallium import *
|
||||
|
||||
|
||||
def make_image(surface):
|
||||
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
|
||||
|
||||
import Image
|
||||
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
|
||||
return outimage
|
||||
|
||||
def save_image(filename, surface):
|
||||
outimage = make_image(surface)
|
||||
outimage.save(filename, "PNG")
|
||||
|
||||
def show_image(surface):
|
||||
outimage = make_image(surface)
|
||||
|
||||
import Tkinter as tk
|
||||
from PIL import Image, ImageTk
|
||||
root = tk.Tk()
|
||||
|
||||
root.title('background image')
|
||||
|
||||
image1 = ImageTk.PhotoImage(outimage)
|
||||
w = image1.width()
|
||||
h = image1.height()
|
||||
x = 100
|
||||
y = 100
|
||||
root.geometry("%dx%d+%d+%d" % (w, h, x, y))
|
||||
panel1 = tk.Label(root, image=image1)
|
||||
panel1.pack(side='top', fill='both', expand='yes')
|
||||
panel1.image = image1
|
||||
root.mainloop()
|
||||
|
||||
|
||||
def test(dev):
|
||||
ctx = dev.context_create()
|
||||
|
||||
width = 255
|
||||
height = 255
|
||||
minz = 0.0
|
||||
maxz = 1.0
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
depth_stencil_alpha.depth.enabled = 1
|
||||
depth_stencil_alpha.depth.writemask = 1
|
||||
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.scissor = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# viewport
|
||||
viewport = Viewport()
|
||||
scale = FloatArray(4)
|
||||
scale[0] = width / 2.0
|
||||
scale[1] = -height / 2.0
|
||||
scale[2] = (maxz - minz) / 2.0
|
||||
scale[3] = 1.0
|
||||
viewport.scale = scale
|
||||
translate = FloatArray(4)
|
||||
translate[0] = width / 2.0
|
||||
translate[1] = height / 2.0
|
||||
translate[2] = (maxz - minz) / 2.0
|
||||
translate[3] = 0.0
|
||||
viewport.translate = translate
|
||||
ctx.set_viewport(viewport)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
ctx.set_fragment_sampler(0, sampler)
|
||||
|
||||
# scissor
|
||||
scissor = Scissor()
|
||||
scissor.minx = 0
|
||||
scissor.miny = 0
|
||||
scissor.maxx = width
|
||||
scissor.maxy = height
|
||||
ctx.set_scissor(scissor)
|
||||
|
||||
clip = Clip()
|
||||
clip.nr = 0
|
||||
ctx.set_clip(clip)
|
||||
|
||||
# framebuffer
|
||||
cbuf = dev.texture_create(
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
width, height,
|
||||
tex_usage=PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
).get_surface()
|
||||
zbuf = dev.texture_create(
|
||||
PIPE_FORMAT_Z32_UNORM,
|
||||
width, height,
|
||||
tex_usage=PIPE_TEXTURE_USAGE_DEPTH_STENCIL,
|
||||
).get_surface()
|
||||
fb = Framebuffer()
|
||||
fb.width = width
|
||||
fb.height = height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, cbuf)
|
||||
fb.set_zsbuf(zbuf)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.0
|
||||
rgba[1] = 0.0
|
||||
rgba[2] = 0.0
|
||||
rgba[3] = 0.0
|
||||
ctx.clear(PIPE_CLEAR_COLOR | PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0xff)
|
||||
|
||||
# vertex shader
|
||||
vs = Shader('''
|
||||
VERT
|
||||
DCL IN[0], POSITION, CONSTANT
|
||||
DCL IN[1], COLOR, CONSTANT
|
||||
DCL OUT[0], POSITION, CONSTANT
|
||||
DCL OUT[1], COLOR, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:MOV OUT[1], IN[1]
|
||||
2:END
|
||||
''')
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
# fragment shader
|
||||
fs = Shader('''
|
||||
FRAG
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:END
|
||||
''')
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
nverts = 3
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
verts[ 0] = 0.0 # x1
|
||||
verts[ 1] = 0.8 # y1
|
||||
verts[ 2] = 0.2 # z1
|
||||
verts[ 3] = 1.0 # w1
|
||||
verts[ 4] = 1.0 # r1
|
||||
verts[ 5] = 0.0 # g1
|
||||
verts[ 6] = 0.0 # b1
|
||||
verts[ 7] = 1.0 # a1
|
||||
verts[ 8] = -0.8 # x2
|
||||
verts[ 9] = -0.8 # y2
|
||||
verts[10] = 0.5 # z2
|
||||
verts[11] = 1.0 # w2
|
||||
verts[12] = 0.0 # r2
|
||||
verts[13] = 1.0 # g2
|
||||
verts[14] = 0.0 # b2
|
||||
verts[15] = 1.0 # a2
|
||||
verts[16] = 0.8 # x3
|
||||
verts[17] = -0.8 # y3
|
||||
verts[18] = 0.8 # z3
|
||||
verts[19] = 1.0 # w3
|
||||
verts[20] = 0.0 # r3
|
||||
verts[21] = 0.0 # g3
|
||||
verts[22] = 1.0 # b3
|
||||
verts[23] = 1.0 # a3
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
show_image(cbuf)
|
||||
#show_image(zbuf)
|
||||
#save_image('cbuf.png', cbuf)
|
||||
#save_image('zbuf.png', zbuf)
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
dev = Device()
|
||||
test(dev)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,3 +0,0 @@
|
||||
*.txt
|
||||
*.tsv
|
||||
*.dot
|
||||
@@ -1,344 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
"""Base classes for tests.
|
||||
|
||||
Loosely inspired on Python's unittest module.
|
||||
"""
|
||||
|
||||
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
from gallium import *
|
||||
|
||||
|
||||
# Enumerate all pixel formats
|
||||
formats = {}
|
||||
for name, value in globals().items():
|
||||
if name.startswith("PIPE_FORMAT_") and isinstance(value, int):
|
||||
formats[value] = name
|
||||
|
||||
def is_depth_stencil_format(format):
|
||||
# FIXME: make and use binding to util_format_is_depth_or_stencil
|
||||
return format in (
|
||||
PIPE_FORMAT_Z32_UNORM,
|
||||
PIPE_FORMAT_Z24S8_UNORM,
|
||||
PIPE_FORMAT_Z24X8_UNORM,
|
||||
PIPE_FORMAT_Z16_UNORM,
|
||||
)
|
||||
|
||||
def make_image(width, height, rgba):
|
||||
import Image
|
||||
outimage = Image.new(
|
||||
mode='RGB',
|
||||
size=(width, height),
|
||||
color=(0,0,0))
|
||||
outpixels = outimage.load()
|
||||
for y in range(0, height):
|
||||
for x in range(0, width):
|
||||
offset = (y*width + x)*4
|
||||
r, g, b, a = [int(min(max(rgba[offset + ch], 0.0), 1.0)*255) for ch in range(4)]
|
||||
outpixels[x, y] = r, g, b
|
||||
return outimage
|
||||
|
||||
def save_image(width, height, rgba, filename):
|
||||
outimage = make_image(width, height, rgba)
|
||||
outimage.save(filename, "PNG")
|
||||
|
||||
def show_image(width, height, **rgbas):
|
||||
import Tkinter as tk
|
||||
from PIL import Image, ImageTk
|
||||
|
||||
root = tk.Tk()
|
||||
|
||||
x = 64
|
||||
y = 64
|
||||
|
||||
labels = rgbas.keys()
|
||||
labels.sort()
|
||||
for i in range(len(labels)):
|
||||
label = labels[i]
|
||||
outimage = make_image(width, height, rgbas[label])
|
||||
|
||||
if i:
|
||||
window = tk.Toplevel(root)
|
||||
else:
|
||||
window = root
|
||||
window.title(label)
|
||||
image1 = ImageTk.PhotoImage(outimage)
|
||||
w = image1.width()
|
||||
h = image1.height()
|
||||
window.geometry("%dx%d+%d+%d" % (w, h, x, y))
|
||||
panel1 = tk.Label(window, image=image1)
|
||||
panel1.pack(side='top', fill='both', expand='yes')
|
||||
panel1.image = image1
|
||||
x += w + 2
|
||||
|
||||
root.mainloop()
|
||||
|
||||
|
||||
class TestFailure(Exception):
|
||||
|
||||
pass
|
||||
|
||||
class TestSkip(Exception):
|
||||
|
||||
pass
|
||||
|
||||
|
||||
class Test:
|
||||
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def _run(self, result):
|
||||
raise NotImplementedError
|
||||
|
||||
def run(self):
|
||||
result = TestResult()
|
||||
self._run(result)
|
||||
result.summary()
|
||||
|
||||
def assert_rgba(self, surface, x, y, w, h, expected_rgba, pixel_tol=4.0/256, surface_tol=0.85):
|
||||
total = h*w
|
||||
different = surface.compare_tile_rgba(x, y, w, h, expected_rgba, tol=pixel_tol)
|
||||
if different:
|
||||
sys.stderr.write("%u out of %u pixels differ\n" % (different, total))
|
||||
|
||||
if float(total - different)/float(total) < surface_tol:
|
||||
if 0:
|
||||
rgba = FloatArray(h*w*4)
|
||||
surface.get_tile_rgba(x, y, w, h, rgba)
|
||||
show_image(w, h, Result=rgba, Expected=expected_rgba)
|
||||
save_image(w, h, rgba, "result.png")
|
||||
save_image(w, h, expected_rgba, "expected.png")
|
||||
#sys.exit(0)
|
||||
|
||||
raise TestFailure
|
||||
|
||||
|
||||
class TestCase(Test):
|
||||
|
||||
tags = ()
|
||||
|
||||
def __init__(self, dev, **kargs):
|
||||
Test.__init__(self)
|
||||
self.dev = dev
|
||||
self.__dict__.update(kargs)
|
||||
|
||||
def description(self):
|
||||
descriptions = []
|
||||
for tag in self.tags:
|
||||
value = self.get(tag)
|
||||
if value is not None and value != '':
|
||||
descriptions.append(tag + '=' + str(value))
|
||||
return ' '.join(descriptions)
|
||||
|
||||
def get(self, tag):
|
||||
try:
|
||||
method = getattr(self, '_get_' + tag)
|
||||
except AttributeError:
|
||||
return getattr(self, tag, None)
|
||||
else:
|
||||
return method()
|
||||
|
||||
def _get_target(self):
|
||||
return {
|
||||
PIPE_TEXTURE_1D: "1d",
|
||||
PIPE_TEXTURE_2D: "2d",
|
||||
PIPE_TEXTURE_3D: "3d",
|
||||
PIPE_TEXTURE_CUBE: "cube",
|
||||
}[self.target]
|
||||
|
||||
def _get_format(self):
|
||||
name = formats[self.format]
|
||||
if name.startswith('PIPE_FORMAT_'):
|
||||
name = name[12:]
|
||||
name = name.lower()
|
||||
return name
|
||||
|
||||
def _get_face(self):
|
||||
if self.target == PIPE_TEXTURE_CUBE:
|
||||
return {
|
||||
PIPE_TEX_FACE_POS_X: "+x",
|
||||
PIPE_TEX_FACE_NEG_X: "-x",
|
||||
PIPE_TEX_FACE_POS_Y: "+y",
|
||||
PIPE_TEX_FACE_NEG_Y: "-y",
|
||||
PIPE_TEX_FACE_POS_Z: "+z",
|
||||
PIPE_TEX_FACE_NEG_Z: "-z",
|
||||
}[self.face]
|
||||
else:
|
||||
return ''
|
||||
|
||||
def test(self):
|
||||
raise NotImplementedError
|
||||
|
||||
def _run(self, result):
|
||||
result.test_start(self)
|
||||
try:
|
||||
self.test()
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except TestSkip:
|
||||
result.test_skipped(self)
|
||||
except TestFailure:
|
||||
result.test_failed(self)
|
||||
else:
|
||||
result.test_passed(self)
|
||||
|
||||
|
||||
class TestSuite(Test):
|
||||
|
||||
def __init__(self, tests = None):
|
||||
Test.__init__(self)
|
||||
if tests is None:
|
||||
self.tests = []
|
||||
else:
|
||||
self.tests = tests
|
||||
|
||||
def add_test(self, test):
|
||||
self.tests.append(test)
|
||||
|
||||
def _run(self, result):
|
||||
for test in self.tests:
|
||||
test._run(result)
|
||||
|
||||
|
||||
class TestResult:
|
||||
|
||||
def __init__(self):
|
||||
self.tests = 0
|
||||
self.passed = 0
|
||||
self.skipped = 0
|
||||
self.failed = 0
|
||||
|
||||
self.names = ['result']
|
||||
self.types = ['pass skip fail']
|
||||
self.rows = []
|
||||
|
||||
def test_start(self, test):
|
||||
sys.stdout.write("Running %s...\n" % test.description())
|
||||
sys.stdout.flush()
|
||||
self.tests += 1
|
||||
|
||||
def test_passed(self, test):
|
||||
sys.stdout.write("PASS\n")
|
||||
sys.stdout.flush()
|
||||
self.passed += 1
|
||||
self.log_result(test, 'pass')
|
||||
|
||||
def test_skipped(self, test):
|
||||
sys.stdout.write("SKIP\n")
|
||||
sys.stdout.flush()
|
||||
self.skipped += 1
|
||||
#self.log_result(test, 'skip')
|
||||
|
||||
def test_failed(self, test):
|
||||
sys.stdout.write("FAIL\n")
|
||||
sys.stdout.flush()
|
||||
self.failed += 1
|
||||
self.log_result(test, 'fail')
|
||||
|
||||
def log_result(self, test, result):
|
||||
row = ['']*len(self.names)
|
||||
|
||||
# add result
|
||||
assert self.names[0] == 'result'
|
||||
assert result in ('pass', 'skip', 'fail')
|
||||
row[0] = result
|
||||
|
||||
# add tags
|
||||
for tag in test.tags:
|
||||
value = test.get(tag)
|
||||
|
||||
# infer type
|
||||
if value is None:
|
||||
continue
|
||||
elif isinstance(value, (int, float)):
|
||||
value = str(value)
|
||||
type = 'c' # continous
|
||||
elif isinstance(value, basestring):
|
||||
type = 'd' # discrete
|
||||
else:
|
||||
assert False
|
||||
value = str(value)
|
||||
type = 'd' # discrete
|
||||
|
||||
# insert value
|
||||
try:
|
||||
col = self.names.index(tag, 1)
|
||||
except ValueError:
|
||||
self.names.append(tag)
|
||||
self.types.append(type)
|
||||
row.append(value)
|
||||
else:
|
||||
row[col] = value
|
||||
assert self.types[col] == type
|
||||
|
||||
self.rows.append(row)
|
||||
|
||||
def summary(self):
|
||||
sys.stdout.write("%u tests, %u passed, %u skipped, %u failed\n\n" % (self.tests, self.passed, self.skipped, self.failed))
|
||||
sys.stdout.flush()
|
||||
|
||||
name, ext = os.path.splitext(os.path.basename(sys.argv[0]))
|
||||
filename = name + '.tsv'
|
||||
stream = file(filename, 'wt')
|
||||
|
||||
# header
|
||||
stream.write('\t'.join(self.names) + '\n')
|
||||
stream.write('\t'.join(self.types) + '\n')
|
||||
stream.write('class\n')
|
||||
|
||||
# rows
|
||||
for row in self.rows:
|
||||
row += ['']*(len(self.names) - len(row))
|
||||
stream.write('\t'.join(row) + '\n')
|
||||
|
||||
stream.close()
|
||||
|
||||
# See http://www.ailab.si/orange/doc/ofb/c_otherclass.htm
|
||||
try:
|
||||
import orange
|
||||
import orngTree
|
||||
except ImportError:
|
||||
sys.stderr.write('Install Orange from http://www.ailab.si/orange/ for a classification tree.\n')
|
||||
return
|
||||
|
||||
data = orange.ExampleTable(filename)
|
||||
|
||||
tree = orngTree.TreeLearner(data, sameMajorityPruning=1, mForPruning=2)
|
||||
|
||||
orngTree.printTxt(tree, maxDepth=4)
|
||||
|
||||
file(name+'.txt', 'wt').write(orngTree.dumpTree(tree))
|
||||
|
||||
orngTree.printDot(tree, fileName=name+'.dot', nodeShape='ellipse', leafShape='box')
|
||||
@@ -1 +0,0 @@
|
||||
*.png
|
||||
@@ -1,13 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { -0.5, -0.4, -0.6, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
ABS OUT[0], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
ADD OUT[0], IN[0], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
DCL CONST[1]
|
||||
DCL CONST[3]
|
||||
DCL TEMP[0..1]
|
||||
|
||||
ADD TEMP[0], IN[0], CONST[1]
|
||||
RCP TEMP[1], CONST[3].xxxx
|
||||
MUL OUT[0], TEMP[0], TEMP[1]
|
||||
|
||||
END
|
||||
@@ -1,9 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
DCL CONST[1][1..2]
|
||||
|
||||
MAD OUT[0], IN[0], CONST[1][2], CONST[1][1]
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DP3 OUT[0], IN[0], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DP4 OUT[0], IN[0].xyzx, IN[0].xyzx
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DST OUT[0], IN[0], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
EX2 TEMP[0], IN[0].xxxx
|
||||
MUL OUT[0], TEMP[0], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 2.5, 4.0, 2.0, 1.0 }
|
||||
IMM FLT32 { 0.4, 0.25, 0.5, 1.0 }
|
||||
|
||||
MUL TEMP[0], IN[0], IMM[0]
|
||||
FLR TEMP[0], TEMP[0]
|
||||
MUL OUT[0], TEMP[0], IMM[1]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 2.7, 3.1, 4.5, 1.0 }
|
||||
|
||||
MUL TEMP[0], IN[0], IMM[0]
|
||||
FRC OUT[0], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
|
||||
IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
LG2 TEMP[0].x, TEMP[0].xxxx
|
||||
ADD OUT[0], TEMP[0], IMM[1]
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
LIT OUT[0], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
ABS TEMP[0], IN[0]
|
||||
LRP OUT[0], TEMP[0], IN[0].xxxx, IN[0].yyyy
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
IMM FLT32 { 0.5, 0.4, 0.6, 1.0 }
|
||||
IMM FLT32 { 0.5, 0.4, 0.6, 0.0 }
|
||||
|
||||
MAD OUT[0], IN[0], IMM[0], IMM[1]
|
||||
|
||||
END
|
||||
@@ -1,10 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
IMM FLT32 { 0.4, 0.4, 0.4, 0.0 }
|
||||
|
||||
MAX OUT[0], IN[0], IMM[0]
|
||||
|
||||
END
|
||||
@@ -1,10 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
IMM FLT32 { 0.6, 0.6, 0.6, 1.0 }
|
||||
|
||||
MIN OUT[0], IN[0], IMM[0]
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,10 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
IMM FLT32 { 0.5, 0.6, 0.7, 1.0 }
|
||||
|
||||
MUL OUT[0], IN[0], IMM[0]
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
|
||||
IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
RCP TEMP[0].x, TEMP[0].xxxx
|
||||
SUB OUT[0], TEMP[0], IMM[1]
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
|
||||
IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
RSQ TEMP[0].x, TEMP[0].xxxx
|
||||
SUB OUT[0], TEMP[0], IMM[1]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.6, 0.6, 0.6, 0.0 }
|
||||
|
||||
SGE TEMP[0], IN[0], IMM[0]
|
||||
MUL OUT[0], IN[0], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.6, 0.6, 0.6, 0.0 }
|
||||
|
||||
SLT TEMP[0], IN[0], IMM[0]
|
||||
MUL OUT[0], IN[0], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { -0.3, -0.5, -0.4, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
MOV OUT[0], |TEMP[0]|
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { -0.2, -0.3, -0.4, 0.0 }
|
||||
IMM FLT32 { -1.0, -1.0, -1.0, -1.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
MOV TEMP[0], -|TEMP[0]|
|
||||
MUL OUT[0], TEMP[0], IMM[1]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
SUB TEMP[0], IN[0], IN[0].yzxw
|
||||
MOV OUT[0], -TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
MOV OUT[0], IN[0].yxzw
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
SUB OUT[0], IN[0], IN[0].yzxw
|
||||
|
||||
END
|
||||
@@ -1,8 +0,0 @@
|
||||
FRAG
|
||||
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR
|
||||
|
||||
XPD OUT[0], IN[0], IN[0].yzxw
|
||||
|
||||
END
|
||||
@@ -1,257 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
import struct
|
||||
|
||||
from gallium import *
|
||||
|
||||
def make_image(surface):
|
||||
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
|
||||
|
||||
import Image
|
||||
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
|
||||
return outimage
|
||||
|
||||
def save_image(filename, surface):
|
||||
outimage = make_image(surface)
|
||||
outimage.save(filename, "PNG")
|
||||
|
||||
def test(dev, name):
|
||||
ctx = dev.context_create()
|
||||
|
||||
width = 320
|
||||
height = 320
|
||||
minz = 0.0
|
||||
maxz = 1.0
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
depth_stencil_alpha.depth.enabled = 0
|
||||
depth_stencil_alpha.depth.writemask = 1
|
||||
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.scissor = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# viewport
|
||||
viewport = Viewport()
|
||||
scale = FloatArray(4)
|
||||
scale[0] = width / 2.0
|
||||
scale[1] = -height / 2.0
|
||||
scale[2] = (maxz - minz) / 2.0
|
||||
scale[3] = 1.0
|
||||
viewport.scale = scale
|
||||
translate = FloatArray(4)
|
||||
translate[0] = width / 2.0
|
||||
translate[1] = height / 2.0
|
||||
translate[2] = (maxz - minz) / 2.0
|
||||
translate[3] = 0.0
|
||||
viewport.translate = translate
|
||||
ctx.set_viewport(viewport)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
ctx.set_fragment_sampler(0, sampler)
|
||||
|
||||
# scissor
|
||||
scissor = Scissor()
|
||||
scissor.minx = 0
|
||||
scissor.miny = 0
|
||||
scissor.maxx = width
|
||||
scissor.maxy = height
|
||||
ctx.set_scissor(scissor)
|
||||
|
||||
clip = Clip()
|
||||
clip.nr = 0
|
||||
ctx.set_clip(clip)
|
||||
|
||||
# framebuffer
|
||||
cbuf = dev.texture_create(
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
width, height,
|
||||
tex_usage=PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
).get_surface()
|
||||
fb = Framebuffer()
|
||||
fb.width = width
|
||||
fb.height = height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, cbuf)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.5
|
||||
rgba[1] = 0.5
|
||||
rgba[2] = 0.5
|
||||
rgba[3] = 0.5
|
||||
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
|
||||
|
||||
# vertex shader
|
||||
vs = Shader('''
|
||||
VERT
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
MOV OUT[0], IN[0]
|
||||
MOV OUT[1], IN[1]
|
||||
END
|
||||
''')
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
# fragment shader
|
||||
fs = Shader(file('frag-' + name + '.sh', 'rt').read())
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
constbuf0 = dev.buffer_create(64,
|
||||
(PIPE_BUFFER_USAGE_CONSTANT |
|
||||
PIPE_BUFFER_USAGE_GPU_READ |
|
||||
PIPE_BUFFER_USAGE_CPU_WRITE),
|
||||
4 * 4 * 4)
|
||||
|
||||
cbdata = ''
|
||||
cbdata += struct.pack('4f', 0.4, 0.0, 0.0, 1.0)
|
||||
cbdata += struct.pack('4f', 1.0, 1.0, 1.0, 1.0)
|
||||
cbdata += struct.pack('4f', 2.0, 2.0, 2.0, 2.0)
|
||||
cbdata += struct.pack('4f', 4.0, 8.0, 16.0, 32.0)
|
||||
|
||||
constbuf0.write(cbdata, 0)
|
||||
|
||||
ctx.set_constant_buffer(PIPE_SHADER_FRAGMENT,
|
||||
0,
|
||||
constbuf0)
|
||||
|
||||
constbuf1 = dev.buffer_create(64,
|
||||
(PIPE_BUFFER_USAGE_CONSTANT |
|
||||
PIPE_BUFFER_USAGE_GPU_READ |
|
||||
PIPE_BUFFER_USAGE_CPU_WRITE),
|
||||
4 * 4 * 4)
|
||||
|
||||
cbdata = ''
|
||||
cbdata += struct.pack('4f', 0.1, 0.1, 0.1, 0.1)
|
||||
cbdata += struct.pack('4f', 0.25, 0.25, 0.25, 0.25)
|
||||
cbdata += struct.pack('4f', 0.5, 0.5, 0.5, 0.5)
|
||||
cbdata += struct.pack('4f', 0.75, 0.75, 0.75, 0.75)
|
||||
|
||||
constbuf1.write(cbdata, 0)
|
||||
|
||||
ctx.set_constant_buffer(PIPE_SHADER_FRAGMENT,
|
||||
1,
|
||||
constbuf1)
|
||||
|
||||
xy = [
|
||||
-0.8, -0.8,
|
||||
0.8, -0.8,
|
||||
0.0, 0.8,
|
||||
]
|
||||
color = [
|
||||
1.0, 0.0, 0.0,
|
||||
0.0, 1.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
]
|
||||
|
||||
nverts = 3
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
for i in range(0, nverts):
|
||||
verts[i * nattrs * 4 + 0] = xy[i * 2 + 0] # x
|
||||
verts[i * nattrs * 4 + 1] = xy[i * 2 + 1] # y
|
||||
verts[i * nattrs * 4 + 2] = 0.5 # z
|
||||
verts[i * nattrs * 4 + 3] = 1.0 # w
|
||||
verts[i * nattrs * 4 + 4] = color[i * 3 + 0] # r
|
||||
verts[i * nattrs * 4 + 5] = color[i * 3 + 1] # g
|
||||
verts[i * nattrs * 4 + 6] = color[i * 3 + 2] # b
|
||||
verts[i * nattrs * 4 + 7] = 1.0 # a
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
save_image('frag-' + name + '.png', cbuf)
|
||||
|
||||
def main():
|
||||
tests = [
|
||||
'abs',
|
||||
'add',
|
||||
'cb-1d',
|
||||
'cb-2d',
|
||||
'dp3',
|
||||
'dp4',
|
||||
'dst',
|
||||
'ex2',
|
||||
'flr',
|
||||
'frc',
|
||||
'lg2',
|
||||
'lit',
|
||||
'lrp',
|
||||
'mad',
|
||||
'max',
|
||||
'min',
|
||||
'mov',
|
||||
'mul',
|
||||
'rcp',
|
||||
'rsq',
|
||||
'sge',
|
||||
'slt',
|
||||
'srcmod-abs',
|
||||
'srcmod-absneg',
|
||||
'srcmod-neg',
|
||||
'srcmod-swz',
|
||||
'sub',
|
||||
'xpd',
|
||||
]
|
||||
|
||||
dev = Device()
|
||||
for t in tests:
|
||||
test(dev, t)
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1 +0,0 @@
|
||||
*.png
|
||||
@@ -1,15 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.2, 0.2, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
ABS OUT[0], TEMP[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
IMM FLT32 { 0.2, -0.1, 0.0, 0.0 }
|
||||
|
||||
ADD OUT[0], IN[0], IMM[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,23 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
DCL ADDR[0]
|
||||
|
||||
IMM FLT32 { 3.0, 1.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 1.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 1.0, 1.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 1.0, 1.0, 1.0 }
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MUL TEMP[0], IN[0], IMM[0]
|
||||
ARL ADDR[0].x, TEMP[0]
|
||||
MOV OUT[1], IMM[ADDR[0].x + 3]
|
||||
|
||||
END
|
||||
@@ -1,23 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
DCL ADDR[0]
|
||||
|
||||
IMM FLT32 { 3.0, 1.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 1.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 1.0, 1.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 1.0, 1.0, 1.0 }
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MUL TEMP[0], IN[0], IMM[0]
|
||||
ARR ADDR[0].x, TEMP[0]
|
||||
MOV OUT[1], IMM[ADDR[0].x + 3]
|
||||
|
||||
END
|
||||
@@ -1,16 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL CONST[1]
|
||||
DCL CONST[3]
|
||||
DCL TEMP[0..1]
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
ADD TEMP[0], IN[1], CONST[1]
|
||||
RCP TEMP[1], CONST[3].xxxx
|
||||
MUL OUT[1], TEMP[0], TEMP[1]
|
||||
|
||||
END
|
||||
@@ -1,12 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL CONST[1][1..2]
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MAD OUT[1], IN[1], CONST[1][2], CONST[1][1]
|
||||
|
||||
END
|
||||
@@ -1,16 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
|
||||
|
||||
DP3 TEMP[0].xy, IN[0], IN[0]
|
||||
MOV TEMP[0].zw, IMM[0]
|
||||
MUL OUT[0], IN[0], TEMP[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,16 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
|
||||
|
||||
DP4 TEMP[0].xy, IN[0], IN[0]
|
||||
MOV TEMP[0].zw, IMM[0]
|
||||
MUL OUT[0], IN[0], TEMP[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
DST OUT[1], IN[1], IN[0]
|
||||
|
||||
END
|
||||
@@ -1,18 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0..1]
|
||||
|
||||
IMM FLT32 { 0.3, 0.3, 0.3, 1.0 }
|
||||
|
||||
EX2 TEMP[0], IN[0]
|
||||
EX2 TEMP[1], IN[1].yyyy
|
||||
MUL TEMP[0], TEMP[0], IMM[0]
|
||||
MOV OUT[0], IN[0]
|
||||
MUL OUT[1], TEMP[0], TEMP[1]
|
||||
|
||||
END
|
||||
@@ -1,23 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
DCL ADDR[0]
|
||||
|
||||
IMM FLT32 { 3.0, 1.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 1.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 0.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 1.0, 1.0, 0.0, 1.0 }
|
||||
IMM FLT32 { 0.0, 1.0, 1.0, 1.0 }
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MUL TEMP[0], IN[0], IMM[0]
|
||||
FLR ADDR[0].x, TEMP[0]
|
||||
MOV OUT[1], IMM[ADDR[0].x + 3]
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 2.7, 3.1, 4.5, 1.0 }
|
||||
|
||||
MUL TEMP[0], IN[0].xyxw, IMM[0]
|
||||
MOV OUT[0], IN[0]
|
||||
FRC OUT[1], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,18 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
|
||||
IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
LG2 TEMP[0].x, TEMP[0].xxxx
|
||||
ADD OUT[0], TEMP[0], IMM[1]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
LIT OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,14 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
ABS TEMP[0], IN[0]
|
||||
MOV OUT[0], IN[0]
|
||||
LRP OUT[1], TEMP[0], IN[1].xxxx, IN[1].yyyy
|
||||
|
||||
END
|
||||
@@ -1,14 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
IMM FLT32 { 0.5, 1.0, 1.0, 1.0 }
|
||||
IMM FLT32 { 0.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
MAD OUT[0], IN[0], IMM[0], IMM[1]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
IMM FLT32 { 0.5, 0.5, 0.5, 0.0 }
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MAX OUT[1], IN[1], IMM[0]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
IMM FLT32 { 0.5, 0.5, 0.5, 0.0 }
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MIN OUT[1], IN[1], IMM[0]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
IMM FLT32 { 0.6, 0.6, 1.0, 1.0 }
|
||||
|
||||
MUL OUT[0], IN[0], IMM[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,18 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
|
||||
IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
RCP TEMP[0].x, TEMP[0].xxxx
|
||||
SUB OUT[0], TEMP[0], IMM[1]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,18 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 1.0, 0.0, 0.0, 0.0 }
|
||||
IMM FLT32 { 1.5, 0.0, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
RSQ TEMP[0].x, TEMP[0].xxxx
|
||||
SUB OUT[0], TEMP[0], IMM[1]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,16 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { -0.1, -0.1, 1.0, 0.0 }
|
||||
|
||||
SGE TEMP[0], IN[0], IMM[0]
|
||||
MOV OUT[0], IN[0]
|
||||
MUL OUT[1], IN[1], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,16 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.6, 0.6, 0.0, 0.0 }
|
||||
|
||||
SLT TEMP[0], IN[0], IMM[0]
|
||||
MOV OUT[0], IN[0]
|
||||
MUL OUT[1], IN[1], TEMP[0]
|
||||
|
||||
END
|
||||
@@ -1,15 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { 0.1, 0.1, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
MOV OUT[0], |TEMP[0]|
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,16 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
DCL TEMP[0]
|
||||
|
||||
IMM FLT32 { -0.2, -0.2, 0.0, 0.0 }
|
||||
|
||||
ADD TEMP[0], IN[0], IMM[0]
|
||||
MOV OUT[0].xy, -|TEMP[0]|
|
||||
MOV OUT[0].zw, IN[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,12 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
MOV OUT[0].xy, -IN[0]
|
||||
MOV OUT[0].zw, IN[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
MOV OUT[0], IN[0].yxzw
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,13 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
IMM FLT32 { 0.1, 0.1, 0.0, 0.0 }
|
||||
|
||||
SUB OUT[0], IN[0], IMM[0]
|
||||
MOV OUT[1], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,11 +0,0 @@
|
||||
VERT
|
||||
|
||||
DCL IN[0], POSITION
|
||||
DCL IN[1], COLOR
|
||||
DCL OUT[0], POSITION
|
||||
DCL OUT[1], COLOR
|
||||
|
||||
MOV OUT[0], IN[0]
|
||||
XPD OUT[1], IN[0], IN[1]
|
||||
|
||||
END
|
||||
@@ -1,287 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
import struct
|
||||
|
||||
from gallium import *
|
||||
|
||||
def make_image(surface):
|
||||
data = surface.get_tile_rgba8(0, 0, surface.width, surface.height)
|
||||
|
||||
import Image
|
||||
outimage = Image.fromstring('RGBA', (surface.width, surface.height), data, "raw", 'RGBA', 0, 1)
|
||||
return outimage
|
||||
|
||||
def save_image(filename, surface):
|
||||
outimage = make_image(surface)
|
||||
outimage.save(filename, "PNG")
|
||||
|
||||
def test(dev, name):
|
||||
ctx = dev.context_create()
|
||||
|
||||
width = 320
|
||||
height = 320
|
||||
minz = 0.0
|
||||
maxz = 1.0
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
depth_stencil_alpha.depth.enabled = 0
|
||||
depth_stencil_alpha.depth.writemask = 1
|
||||
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.scissor = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# viewport
|
||||
viewport = Viewport()
|
||||
scale = FloatArray(4)
|
||||
scale[0] = width / 2.0
|
||||
scale[1] = -height / 2.0
|
||||
scale[2] = (maxz - minz) / 2.0
|
||||
scale[3] = 1.0
|
||||
viewport.scale = scale
|
||||
translate = FloatArray(4)
|
||||
translate[0] = width / 2.0
|
||||
translate[1] = height / 2.0
|
||||
translate[2] = (maxz - minz) / 2.0
|
||||
translate[3] = 0.0
|
||||
viewport.translate = translate
|
||||
ctx.set_viewport(viewport)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
ctx.set_fragment_sampler(0, sampler)
|
||||
|
||||
# scissor
|
||||
scissor = Scissor()
|
||||
scissor.minx = 0
|
||||
scissor.miny = 0
|
||||
scissor.maxx = width
|
||||
scissor.maxy = height
|
||||
ctx.set_scissor(scissor)
|
||||
|
||||
clip = Clip()
|
||||
clip.nr = 0
|
||||
ctx.set_clip(clip)
|
||||
|
||||
# framebuffer
|
||||
cbuf = dev.texture_create(
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
width, height,
|
||||
tex_usage=PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
).get_surface()
|
||||
fb = Framebuffer()
|
||||
fb.width = width
|
||||
fb.height = height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, cbuf)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.5
|
||||
rgba[1] = 0.5
|
||||
rgba[2] = 0.5
|
||||
rgba[3] = 0.5
|
||||
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
|
||||
|
||||
# vertex shader
|
||||
vs = Shader(file('vert-' + name + '.sh', 'rt').read())
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
# fragment shader
|
||||
fs = Shader('''
|
||||
FRAG
|
||||
DCL IN[0], COLOR, LINEAR
|
||||
DCL OUT[0], COLOR, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:END
|
||||
''')
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
constbuf0 = dev.buffer_create(64,
|
||||
(PIPE_BUFFER_USAGE_CONSTANT |
|
||||
PIPE_BUFFER_USAGE_GPU_READ |
|
||||
PIPE_BUFFER_USAGE_CPU_WRITE),
|
||||
4 * 4 * 4)
|
||||
|
||||
cbdata = ''
|
||||
cbdata += struct.pack('4f', 0.4, 0.0, 0.0, 1.0)
|
||||
cbdata += struct.pack('4f', 1.0, 1.0, 1.0, 1.0)
|
||||
cbdata += struct.pack('4f', 2.0, 2.0, 2.0, 2.0)
|
||||
cbdata += struct.pack('4f', 4.0, 8.0, 16.0, 32.0)
|
||||
|
||||
constbuf0.write(cbdata, 0)
|
||||
|
||||
ctx.set_constant_buffer(PIPE_SHADER_VERTEX,
|
||||
0,
|
||||
constbuf0)
|
||||
|
||||
constbuf1 = dev.buffer_create(64,
|
||||
(PIPE_BUFFER_USAGE_CONSTANT |
|
||||
PIPE_BUFFER_USAGE_GPU_READ |
|
||||
PIPE_BUFFER_USAGE_CPU_WRITE),
|
||||
4 * 4 * 4)
|
||||
|
||||
cbdata = ''
|
||||
cbdata += struct.pack('4f', 0.1, 0.1, 0.1, 0.1)
|
||||
cbdata += struct.pack('4f', 0.25, 0.25, 0.25, 0.25)
|
||||
cbdata += struct.pack('4f', 0.5, 0.5, 0.5, 0.5)
|
||||
cbdata += struct.pack('4f', 0.75, 0.75, 0.75, 0.75)
|
||||
|
||||
constbuf1.write(cbdata, 0)
|
||||
|
||||
ctx.set_constant_buffer(PIPE_SHADER_VERTEX,
|
||||
1,
|
||||
constbuf1)
|
||||
|
||||
xy = [
|
||||
0.0, 0.8,
|
||||
-0.2, 0.4,
|
||||
0.2, 0.4,
|
||||
-0.4, 0.0,
|
||||
0.0, 0.0,
|
||||
0.4, 0.0,
|
||||
-0.6, -0.4,
|
||||
-0.2, -0.4,
|
||||
0.2, -0.4,
|
||||
0.6, -0.4,
|
||||
-0.8, -0.8,
|
||||
-0.4, -0.8,
|
||||
0.0, -0.8,
|
||||
0.4, -0.8,
|
||||
0.8, -0.8,
|
||||
]
|
||||
color = [
|
||||
1.0, 0.0, 0.0,
|
||||
0.0, 1.0, 0.0,
|
||||
0.0, 0.0, 1.0,
|
||||
]
|
||||
tri = [
|
||||
1, 2, 0,
|
||||
3, 4, 1,
|
||||
4, 2, 1,
|
||||
4, 5, 2,
|
||||
6, 7, 3,
|
||||
7, 4, 3,
|
||||
7, 8, 4,
|
||||
8, 5, 4,
|
||||
8, 9, 5,
|
||||
10, 11, 6,
|
||||
11, 7, 6,
|
||||
11, 12, 7,
|
||||
12, 8, 7,
|
||||
12, 13, 8,
|
||||
13, 9, 8,
|
||||
13, 14, 9,
|
||||
]
|
||||
|
||||
nverts = 16 * 3
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
for i in range(0, nverts):
|
||||
verts[i * nattrs * 4 + 0] = xy[tri[i] * 2 + 0] # x
|
||||
verts[i * nattrs * 4 + 1] = xy[tri[i] * 2 + 1] # y
|
||||
verts[i * nattrs * 4 + 2] = 0.5 # z
|
||||
verts[i * nattrs * 4 + 3] = 1.0 # w
|
||||
verts[i * nattrs * 4 + 4] = color[(i % 3) * 3 + 0] # r
|
||||
verts[i * nattrs * 4 + 5] = color[(i % 3) * 3 + 1] # g
|
||||
verts[i * nattrs * 4 + 6] = color[(i % 3) * 3 + 2] # b
|
||||
verts[i * nattrs * 4 + 7] = 1.0 # a
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLES,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
save_image('vert-' + name + '.png', cbuf)
|
||||
|
||||
def main():
|
||||
tests = [
|
||||
'abs',
|
||||
'add',
|
||||
'arl',
|
||||
'arr',
|
||||
'cb-1d',
|
||||
'cb-2d',
|
||||
'dp3',
|
||||
'dp4',
|
||||
'dst',
|
||||
'ex2',
|
||||
'flr',
|
||||
'frc',
|
||||
'lg2',
|
||||
'lit',
|
||||
'lrp',
|
||||
'mad',
|
||||
'max',
|
||||
'min',
|
||||
'mov',
|
||||
'mul',
|
||||
'rcp',
|
||||
'rsq',
|
||||
'sge',
|
||||
'slt',
|
||||
'srcmod-abs',
|
||||
'srcmod-absneg',
|
||||
'srcmod-neg',
|
||||
'srcmod-swz',
|
||||
'sub',
|
||||
'xpd',
|
||||
]
|
||||
|
||||
dev = Device()
|
||||
for t in tests:
|
||||
test(dev, t)
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,200 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
from gallium import *
|
||||
from base import *
|
||||
|
||||
|
||||
def lods(*dims):
|
||||
size = max(dims)
|
||||
lods = 0
|
||||
while size:
|
||||
lods += 1
|
||||
size >>= 1
|
||||
return lods
|
||||
|
||||
|
||||
class TextureTest(TestCase):
|
||||
|
||||
tags = (
|
||||
'target',
|
||||
'format',
|
||||
'width',
|
||||
'height',
|
||||
'depth',
|
||||
'last_level',
|
||||
'face',
|
||||
'level',
|
||||
'zslice',
|
||||
)
|
||||
|
||||
def test(self):
|
||||
dev = self.dev
|
||||
|
||||
target = self.target
|
||||
format = self.format
|
||||
width = self.width
|
||||
height = self.height
|
||||
depth = self.depth
|
||||
last_level = self.last_level
|
||||
face = self.face
|
||||
level = self.level
|
||||
zslice = self.zslice
|
||||
|
||||
# textures
|
||||
dst_texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = width,
|
||||
height = height,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
)
|
||||
if dst_texture is None:
|
||||
raise TestSkip
|
||||
|
||||
dst_surface = dst_texture.get_surface(face = face, level = level, zslice = zslice)
|
||||
|
||||
src_texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = dst_surface.width,
|
||||
height = dst_surface.height,
|
||||
depth = 1,
|
||||
last_level = 0,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_SAMPLER,
|
||||
)
|
||||
|
||||
src_surface = src_texture.get_surface()
|
||||
|
||||
x = 0
|
||||
y = 0
|
||||
w = dst_surface.width
|
||||
h = dst_surface.height
|
||||
|
||||
# ???
|
||||
stride = pf_get_stride(texture->format, w)
|
||||
size = pf_get_nblocksy(texture->format) * stride
|
||||
src_raw = os.urandom(size)
|
||||
|
||||
src_surface.put_tile_raw(0, 0, w, h, src_raw, stride)
|
||||
|
||||
ctx = self.dev.context_create()
|
||||
|
||||
ctx.surface_copy(dst_surface, 0, 0,
|
||||
src_surface, 0, 0, w, h)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
dst_raw = dst_surface.get_tile_raw(0, 0, w, h)
|
||||
|
||||
if dst_raw != src_raw:
|
||||
raise TestFailure
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
dev = Device()
|
||||
suite = TestSuite()
|
||||
|
||||
targets = [
|
||||
PIPE_TEXTURE_2D,
|
||||
PIPE_TEXTURE_CUBE,
|
||||
#PIPE_TEXTURE_3D,
|
||||
]
|
||||
|
||||
formats = [
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
PIPE_FORMAT_A8R8G8B8_SRGB,
|
||||
PIPE_FORMAT_R5G6B5_UNORM,
|
||||
PIPE_FORMAT_A1R5G5B5_UNORM,
|
||||
PIPE_FORMAT_A4R4G4B4_UNORM,
|
||||
PIPE_FORMAT_Z32_UNORM,
|
||||
PIPE_FORMAT_Z24S8_UNORM,
|
||||
PIPE_FORMAT_Z24X8_UNORM,
|
||||
PIPE_FORMAT_Z16_UNORM,
|
||||
PIPE_FORMAT_S8_UNORM,
|
||||
PIPE_FORMAT_A8_UNORM,
|
||||
PIPE_FORMAT_L8_UNORM,
|
||||
PIPE_FORMAT_DXT1_RGB,
|
||||
PIPE_FORMAT_DXT1_RGBA,
|
||||
PIPE_FORMAT_DXT3_RGBA,
|
||||
PIPE_FORMAT_DXT5_RGBA,
|
||||
]
|
||||
|
||||
sizes = [64, 32, 16, 8, 4, 2, 1]
|
||||
#sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
|
||||
#sizes = [64]
|
||||
#sizes = [63]
|
||||
|
||||
faces = [
|
||||
PIPE_TEX_FACE_POS_X,
|
||||
PIPE_TEX_FACE_NEG_X,
|
||||
PIPE_TEX_FACE_POS_Y,
|
||||
PIPE_TEX_FACE_NEG_Y,
|
||||
PIPE_TEX_FACE_POS_Z,
|
||||
PIPE_TEX_FACE_NEG_Z,
|
||||
]
|
||||
|
||||
for target in targets:
|
||||
for format in formats:
|
||||
for size in sizes:
|
||||
if target == PIPE_TEXTURE_3D:
|
||||
depth = size
|
||||
else:
|
||||
depth = 1
|
||||
for face in faces:
|
||||
if target != PIPE_TEXTURE_CUBE and face:
|
||||
continue
|
||||
levels = lods(size)
|
||||
for last_level in range(levels):
|
||||
for level in range(0, last_level + 1):
|
||||
zslice = 0
|
||||
while zslice < depth >> level:
|
||||
test = TextureTest(
|
||||
dev = dev,
|
||||
target = target,
|
||||
format = format,
|
||||
width = size,
|
||||
height = size,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
)
|
||||
suite.add_test(test)
|
||||
zslice = (zslice + 1)*2 - 1
|
||||
suite.run()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,320 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
from gallium import *
|
||||
from base import *
|
||||
|
||||
|
||||
def lods(*dims):
|
||||
size = max(dims)
|
||||
lods = 0
|
||||
while size:
|
||||
lods += 1
|
||||
size >>= 1
|
||||
return lods
|
||||
|
||||
|
||||
class TextureTest(TestCase):
|
||||
|
||||
tags = (
|
||||
'target',
|
||||
'format',
|
||||
'width',
|
||||
'height',
|
||||
'depth',
|
||||
'last_level',
|
||||
'face',
|
||||
'level',
|
||||
'zslice',
|
||||
)
|
||||
|
||||
def test(self):
|
||||
dev = self.dev
|
||||
|
||||
target = self.target
|
||||
format = self.format
|
||||
width = self.width
|
||||
height = self.height
|
||||
depth = self.depth
|
||||
last_level = self.last_level
|
||||
face = self.face
|
||||
level = self.level
|
||||
zslice = self.zslice
|
||||
|
||||
# textures
|
||||
dst_texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = width,
|
||||
height = height,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
)
|
||||
if dst_texture is None:
|
||||
raise TestSkip
|
||||
|
||||
dst_surface = dst_texture.get_surface(face = face, level = level, zslice = zslice)
|
||||
|
||||
ref_texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = dst_surface.width,
|
||||
height = dst_surface.height,
|
||||
depth = 1,
|
||||
last_level = 0,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_SAMPLER,
|
||||
)
|
||||
|
||||
ref_surface = ref_texture.get_surface()
|
||||
|
||||
src_texture = dev.texture_create(
|
||||
target = target,
|
||||
format = PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
width = dst_surface.width,
|
||||
height = dst_surface.height,
|
||||
depth = 1,
|
||||
last_level = 0,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_SAMPLER,
|
||||
)
|
||||
|
||||
src_surface = src_texture.get_surface()
|
||||
|
||||
expected_rgba = FloatArray(height*width*4)
|
||||
ref_surface.sample_rgba(expected_rgba)
|
||||
|
||||
src_surface.put_tile_rgba(0, 0, src_surface.width, src_surface.height, expected_rgba)
|
||||
|
||||
ctx = self.dev.context_create()
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# no-op depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.bypass_vs_clip_and_viewport = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
sampler.min_lod = 0
|
||||
sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
|
||||
ctx.set_fragment_sampler(0, sampler)
|
||||
ctx.set_fragment_sampler_texture(0, src_texture)
|
||||
|
||||
# framebuffer
|
||||
cbuf_tex = dev.texture_create(
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
width,
|
||||
height,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
)
|
||||
|
||||
fb = Framebuffer()
|
||||
fb.width = dst_surface.width
|
||||
fb.height = dst_surface.height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, dst_surface)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.0
|
||||
rgba[1] = 0.0
|
||||
rgba[2] = 0.0
|
||||
rgba[3] = 0.0
|
||||
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
|
||||
del fb
|
||||
|
||||
# vertex shader
|
||||
vs = Shader('''
|
||||
VERT
|
||||
DCL IN[0], POSITION, CONSTANT
|
||||
DCL IN[1], GENERIC, CONSTANT
|
||||
DCL OUT[0], POSITION, CONSTANT
|
||||
DCL OUT[1], GENERIC, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:MOV OUT[1], IN[1]
|
||||
2:END
|
||||
''')
|
||||
#vs.dump()
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
# fragment shader
|
||||
fs = Shader('''
|
||||
FRAG
|
||||
DCL IN[0], GENERIC[0], LINEAR
|
||||
DCL OUT[0], COLOR, CONSTANT
|
||||
DCL SAMP[0], CONSTANT
|
||||
0:TEX OUT[0], IN[0], SAMP[0], 2D
|
||||
1:END
|
||||
''')
|
||||
#fs.dump()
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
nverts = 4
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
x = 0
|
||||
y = 0
|
||||
w = dst_surface.width
|
||||
h = dst_surface.height
|
||||
|
||||
pos = [
|
||||
[x, y],
|
||||
[x+w, y],
|
||||
[x+w, y+h],
|
||||
[x, y+h],
|
||||
]
|
||||
|
||||
tex = [
|
||||
[0.0, 0.0],
|
||||
[1.0, 0.0],
|
||||
[1.0, 1.0],
|
||||
[0.0, 1.0],
|
||||
]
|
||||
|
||||
for i in range(0, 4):
|
||||
j = 8*i
|
||||
verts[j + 0] = pos[i][0] # x
|
||||
verts[j + 1] = pos[i][1] # y
|
||||
verts[j + 2] = 0.0 # z
|
||||
verts[j + 3] = 1.0 # w
|
||||
verts[j + 4] = tex[i][0] # s
|
||||
verts[j + 5] = tex[i][1] # r
|
||||
verts[j + 6] = 0.0
|
||||
verts[j + 7] = 1.0
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
self.assert_rgba(dst_surface, x, y, w, h, expected_rgba, 4.0/256, 0.85)
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
dev = Device()
|
||||
suite = TestSuite()
|
||||
|
||||
targets = [
|
||||
PIPE_TEXTURE_2D,
|
||||
PIPE_TEXTURE_CUBE,
|
||||
#PIPE_TEXTURE_3D,
|
||||
]
|
||||
|
||||
formats = [
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
#PIPE_FORMAT_A8R8G8B8_SRGB,
|
||||
PIPE_FORMAT_R5G6B5_UNORM,
|
||||
PIPE_FORMAT_A1R5G5B5_UNORM,
|
||||
PIPE_FORMAT_A4R4G4B4_UNORM,
|
||||
#PIPE_FORMAT_Z32_UNORM,
|
||||
#PIPE_FORMAT_Z24S8_UNORM,
|
||||
#PIPE_FORMAT_Z24X8_UNORM,
|
||||
#PIPE_FORMAT_Z16_UNORM,
|
||||
#PIPE_FORMAT_S8_UNORM,
|
||||
PIPE_FORMAT_A8_UNORM,
|
||||
PIPE_FORMAT_L8_UNORM,
|
||||
#PIPE_FORMAT_DXT1_RGB,
|
||||
#PIPE_FORMAT_DXT1_RGBA,
|
||||
#PIPE_FORMAT_DXT3_RGBA,
|
||||
#PIPE_FORMAT_DXT5_RGBA,
|
||||
]
|
||||
|
||||
sizes = [64, 32, 16, 8, 4, 2, 1]
|
||||
#sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
|
||||
#sizes = [64]
|
||||
#sizes = [63]
|
||||
|
||||
faces = [
|
||||
PIPE_TEX_FACE_POS_X,
|
||||
PIPE_TEX_FACE_NEG_X,
|
||||
PIPE_TEX_FACE_POS_Y,
|
||||
PIPE_TEX_FACE_NEG_Y,
|
||||
PIPE_TEX_FACE_POS_Z,
|
||||
PIPE_TEX_FACE_NEG_Z,
|
||||
]
|
||||
|
||||
for target in targets:
|
||||
for format in formats:
|
||||
for size in sizes:
|
||||
if target == PIPE_TEXTURE_3D:
|
||||
depth = size
|
||||
else:
|
||||
depth = 1
|
||||
for face in faces:
|
||||
if target != PIPE_TEXTURE_CUBE and face:
|
||||
continue
|
||||
levels = lods(size)
|
||||
for last_level in range(levels):
|
||||
for level in range(0, last_level + 1):
|
||||
zslice = 0
|
||||
while zslice < depth >> level:
|
||||
test = TextureTest(
|
||||
dev = dev,
|
||||
target = target,
|
||||
format = format,
|
||||
width = size,
|
||||
height = size,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
)
|
||||
suite.add_test(test)
|
||||
zslice = (zslice + 1)*2 - 1
|
||||
suite.run()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,591 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
from gallium import *
|
||||
from base import *
|
||||
|
||||
|
||||
def lods(*dims):
|
||||
size = max(dims)
|
||||
lods = 0
|
||||
while size:
|
||||
lods += 1
|
||||
size >>= 1
|
||||
return lods
|
||||
|
||||
|
||||
def minify(dims, level = 1):
|
||||
return [max(dim>>level, 1) for dim in dims]
|
||||
|
||||
|
||||
def tex_coords(texture, face, level, zslice):
|
||||
st = [
|
||||
[0.0, 0.0],
|
||||
[1.0, 0.0],
|
||||
[1.0, 1.0],
|
||||
[0.0, 1.0],
|
||||
]
|
||||
|
||||
if texture.target == PIPE_TEXTURE_2D:
|
||||
return [[s, t, 0.0] for s, t in st]
|
||||
elif texture.target == PIPE_TEXTURE_3D:
|
||||
depth = texture.get_depth(level)
|
||||
if depth > 1:
|
||||
r = float(zslice)/float(depth - 1)
|
||||
else:
|
||||
r = 0.0
|
||||
return [[s, t, r] for s, t in st]
|
||||
elif texture.target == PIPE_TEXTURE_CUBE:
|
||||
result = []
|
||||
for s, t in st:
|
||||
# See http://developer.nvidia.com/object/cube_map_ogl_tutorial.html
|
||||
sc = 2.0*s - 1.0
|
||||
tc = 2.0*t - 1.0
|
||||
if face == PIPE_TEX_FACE_POS_X:
|
||||
rx = 1.0
|
||||
ry = -tc
|
||||
rz = -sc
|
||||
if face == PIPE_TEX_FACE_NEG_X:
|
||||
rx = -1.0
|
||||
ry = -tc
|
||||
rz = sc
|
||||
if face == PIPE_TEX_FACE_POS_Y:
|
||||
rx = sc
|
||||
ry = 1.0
|
||||
rz = tc
|
||||
if face == PIPE_TEX_FACE_NEG_Y:
|
||||
rx = sc
|
||||
ry = -1.0
|
||||
rz = -tc
|
||||
if face == PIPE_TEX_FACE_POS_Z:
|
||||
rx = sc
|
||||
ry = -tc
|
||||
rz = 1.0
|
||||
if face == PIPE_TEX_FACE_NEG_Z:
|
||||
rx = -sc
|
||||
ry = -tc
|
||||
rz = -1.0
|
||||
result.append([rx, ry, rz])
|
||||
return result
|
||||
|
||||
def is_pot(n):
|
||||
return n & (n - 1) == 0
|
||||
|
||||
|
||||
class TextureColorSampleTest(TestCase):
|
||||
|
||||
tags = (
|
||||
'target',
|
||||
'format',
|
||||
'width',
|
||||
'height',
|
||||
'depth',
|
||||
'last_level',
|
||||
'face',
|
||||
'level',
|
||||
'zslice',
|
||||
)
|
||||
|
||||
def test(self):
|
||||
dev = self.dev
|
||||
|
||||
target = self.target
|
||||
format = self.format
|
||||
width = self.width
|
||||
height = self.height
|
||||
depth = self.depth
|
||||
last_level = self.last_level
|
||||
face = self.face
|
||||
level = self.level
|
||||
zslice = self.zslice
|
||||
|
||||
tex_usage = PIPE_TEXTURE_USAGE_SAMPLER
|
||||
geom_flags = 0
|
||||
if width != height:
|
||||
geom_flags |= PIPE_TEXTURE_GEOM_NON_SQUARE
|
||||
if not is_pot(width) or not is_pot(height) or not is_pot(depth):
|
||||
geom_flags |= PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO
|
||||
|
||||
if not dev.is_format_supported(format, target, tex_usage, geom_flags):
|
||||
raise TestSkip
|
||||
|
||||
ctx = self.dev.context_create()
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# no-op depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.bypass_vs_clip_and_viewport = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
sampler.min_lod = 0
|
||||
sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
|
||||
ctx.set_fragment_sampler(0, sampler)
|
||||
|
||||
# texture
|
||||
texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = width,
|
||||
height = height,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
tex_usage = tex_usage,
|
||||
)
|
||||
|
||||
expected_rgba = FloatArray(height*width*4)
|
||||
texture.get_surface(
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
).sample_rgba(expected_rgba)
|
||||
|
||||
ctx.set_fragment_sampler_texture(0, texture)
|
||||
|
||||
# framebuffer
|
||||
cbuf_tex = dev.texture_create(
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
width,
|
||||
height,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
)
|
||||
|
||||
cbuf = cbuf_tex.get_surface()
|
||||
fb = Framebuffer()
|
||||
fb.width = width
|
||||
fb.height = height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, cbuf)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.5
|
||||
rgba[1] = 0.5
|
||||
rgba[2] = 0.5
|
||||
rgba[3] = 0.5
|
||||
ctx.clear(PIPE_CLEAR_COLOR, rgba, 0.0, 0)
|
||||
del fb
|
||||
|
||||
# vertex shader
|
||||
vs = Shader('''
|
||||
VERT
|
||||
DCL IN[0], POSITION, CONSTANT
|
||||
DCL IN[1], GENERIC, CONSTANT
|
||||
DCL OUT[0], POSITION, CONSTANT
|
||||
DCL OUT[1], GENERIC, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:MOV OUT[1], IN[1]
|
||||
2:END
|
||||
''')
|
||||
#vs.dump()
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
# fragment shader
|
||||
op = {
|
||||
PIPE_TEXTURE_1D: "1D",
|
||||
PIPE_TEXTURE_2D: "2D",
|
||||
PIPE_TEXTURE_3D: "3D",
|
||||
PIPE_TEXTURE_CUBE: "CUBE",
|
||||
}[target]
|
||||
fs = Shader('''
|
||||
FRAG
|
||||
DCL IN[0], GENERIC[0], LINEAR
|
||||
DCL OUT[0], COLOR, CONSTANT
|
||||
DCL SAMP[0], CONSTANT
|
||||
0:TEX OUT[0], IN[0], SAMP[0], %s
|
||||
1:END
|
||||
''' % op)
|
||||
#fs.dump()
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
nverts = 4
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
x = 0
|
||||
y = 0
|
||||
w, h = minify((width, height), level)
|
||||
|
||||
pos = [
|
||||
[x, y],
|
||||
[x+w, y],
|
||||
[x+w, y+h],
|
||||
[x, y+h],
|
||||
]
|
||||
|
||||
tex = tex_coords(texture, face, level, zslice)
|
||||
|
||||
for i in range(0, 4):
|
||||
j = 8*i
|
||||
verts[j + 0] = pos[i][0] # x
|
||||
verts[j + 1] = pos[i][1] # y
|
||||
verts[j + 2] = 0.0 # z
|
||||
verts[j + 3] = 1.0 # w
|
||||
verts[j + 4] = tex[i][0] # s
|
||||
verts[j + 5] = tex[i][1] # r
|
||||
verts[j + 6] = tex[i][2] # q
|
||||
verts[j + 7] = 1.0
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
cbuf = cbuf_tex.get_surface()
|
||||
|
||||
self.assert_rgba(cbuf, x, y, w, h, expected_rgba, 4.0/256, 0.85)
|
||||
|
||||
|
||||
class TextureDepthSampleTest(TestCase):
|
||||
|
||||
tags = (
|
||||
'target',
|
||||
'format',
|
||||
'width',
|
||||
'height',
|
||||
'depth',
|
||||
'last_level',
|
||||
'face',
|
||||
'level',
|
||||
'zslice',
|
||||
)
|
||||
|
||||
def test(self):
|
||||
dev = self.dev
|
||||
|
||||
target = self.target
|
||||
format = self.format
|
||||
width = self.width
|
||||
height = self.height
|
||||
depth = self.depth
|
||||
last_level = self.last_level
|
||||
face = self.face
|
||||
level = self.level
|
||||
zslice = self.zslice
|
||||
|
||||
tex_usage = PIPE_TEXTURE_USAGE_SAMPLER
|
||||
geom_flags = 0
|
||||
if width != height:
|
||||
geom_flags |= PIPE_TEXTURE_GEOM_NON_SQUARE
|
||||
if not is_pot(width) or not is_pot(height) or not is_pot(depth):
|
||||
geom_flags |= PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO
|
||||
|
||||
if not dev.is_format_supported(format, target, tex_usage, geom_flags):
|
||||
raise TestSkip
|
||||
|
||||
ctx = self.dev.context_create()
|
||||
|
||||
# disabled blending/masking
|
||||
blend = Blend()
|
||||
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE
|
||||
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO
|
||||
blend.rt[0].colormask = PIPE_MASK_RGBA
|
||||
ctx.set_blend(blend)
|
||||
|
||||
# depth/stencil/alpha
|
||||
depth_stencil_alpha = DepthStencilAlpha()
|
||||
depth_stencil_alpha.depth.enabled = 1
|
||||
depth_stencil_alpha.depth.writemask = 1
|
||||
depth_stencil_alpha.depth.func = PIPE_FUNC_LESS
|
||||
ctx.set_depth_stencil_alpha(depth_stencil_alpha)
|
||||
|
||||
# rasterizer
|
||||
rasterizer = Rasterizer()
|
||||
rasterizer.front_winding = PIPE_WINDING_CW
|
||||
rasterizer.cull_mode = PIPE_WINDING_NONE
|
||||
rasterizer.bypass_vs_clip_and_viewport = 1
|
||||
ctx.set_rasterizer(rasterizer)
|
||||
|
||||
# samplers
|
||||
sampler = Sampler()
|
||||
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE
|
||||
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST
|
||||
sampler.normalized_coords = 1
|
||||
sampler.min_lod = 0
|
||||
sampler.max_lod = PIPE_MAX_TEXTURE_LEVELS - 1
|
||||
ctx.set_fragment_sampler(0, sampler)
|
||||
|
||||
# texture
|
||||
texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = width,
|
||||
height = height,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
tex_usage = tex_usage,
|
||||
)
|
||||
|
||||
expected_rgba = FloatArray(height*width*4)
|
||||
texture.get_surface(
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
).sample_rgba(expected_rgba)
|
||||
|
||||
ctx.set_fragment_sampler_texture(0, texture)
|
||||
|
||||
# framebuffer
|
||||
cbuf_tex = dev.texture_create(
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
width,
|
||||
height,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
)
|
||||
|
||||
zsbuf_tex = dev.texture_create(
|
||||
PIPE_FORMAT_Z24X8_UNORM,
|
||||
width,
|
||||
height,
|
||||
tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET,
|
||||
)
|
||||
|
||||
cbuf = cbuf_tex.get_surface()
|
||||
zsbuf = zsbuf_tex.get_surface()
|
||||
fb = Framebuffer()
|
||||
fb.width = width
|
||||
fb.height = height
|
||||
fb.nr_cbufs = 1
|
||||
fb.set_cbuf(0, cbuf)
|
||||
fb.set_zsbuf(zsbuf)
|
||||
ctx.set_framebuffer(fb)
|
||||
rgba = FloatArray(4);
|
||||
rgba[0] = 0.5
|
||||
rgba[1] = 0.5
|
||||
rgba[2] = 0.5
|
||||
rgba[3] = 0.5
|
||||
ctx.clear(PIPE_CLEAR_DEPTHSTENCIL, rgba, 1.0, 0)
|
||||
del fb
|
||||
|
||||
# vertex shader
|
||||
vs = Shader('''
|
||||
VERT
|
||||
DCL IN[0], POSITION, CONSTANT
|
||||
DCL IN[1], GENERIC, CONSTANT
|
||||
DCL OUT[0], POSITION, CONSTANT
|
||||
DCL OUT[1], GENERIC, CONSTANT
|
||||
0:MOV OUT[0], IN[0]
|
||||
1:MOV OUT[1], IN[1]
|
||||
2:END
|
||||
''')
|
||||
#vs.dump()
|
||||
ctx.set_vertex_shader(vs)
|
||||
|
||||
# fragment shader
|
||||
op = {
|
||||
PIPE_TEXTURE_1D: "1D",
|
||||
PIPE_TEXTURE_2D: "2D",
|
||||
PIPE_TEXTURE_3D: "3D",
|
||||
PIPE_TEXTURE_CUBE: "CUBE",
|
||||
}[target]
|
||||
fs = Shader('''
|
||||
FRAG
|
||||
DCL IN[0], GENERIC[0], LINEAR
|
||||
DCL SAMP[0], CONSTANT
|
||||
DCL OUT[0].z, POSITION
|
||||
0:TEX OUT[0].z, IN[0], SAMP[0], %s
|
||||
1:END
|
||||
''' % op)
|
||||
#fs.dump()
|
||||
ctx.set_fragment_shader(fs)
|
||||
|
||||
nverts = 4
|
||||
nattrs = 2
|
||||
verts = FloatArray(nverts * nattrs * 4)
|
||||
|
||||
x = 0
|
||||
y = 0
|
||||
w, h = minify((width, height), level)
|
||||
|
||||
pos = [
|
||||
[x, y],
|
||||
[x+w, y],
|
||||
[x+w, y+h],
|
||||
[x, y+h],
|
||||
]
|
||||
|
||||
tex = tex_coords(texture, face, level, zslice)
|
||||
|
||||
for i in range(0, 4):
|
||||
j = 8*i
|
||||
verts[j + 0] = pos[i][0] # x
|
||||
verts[j + 1] = pos[i][1] # y
|
||||
verts[j + 2] = 0.0 # z
|
||||
verts[j + 3] = 1.0 # w
|
||||
verts[j + 4] = tex[i][0] # s
|
||||
verts[j + 5] = tex[i][1] # r
|
||||
verts[j + 6] = tex[i][2] # q
|
||||
verts[j + 7] = 1.0
|
||||
|
||||
ctx.draw_vertices(PIPE_PRIM_TRIANGLE_FAN,
|
||||
nverts,
|
||||
nattrs,
|
||||
verts)
|
||||
|
||||
ctx.flush()
|
||||
|
||||
zsbuf = zsbuf_tex.get_surface()
|
||||
|
||||
self.assert_rgba(zsbuf, x, y, w, h, expected_rgba, 4.0/256, 0.85)
|
||||
|
||||
|
||||
|
||||
|
||||
def main():
|
||||
dev = Device()
|
||||
suite = TestSuite()
|
||||
|
||||
targets = [
|
||||
PIPE_TEXTURE_2D,
|
||||
PIPE_TEXTURE_CUBE,
|
||||
PIPE_TEXTURE_3D,
|
||||
]
|
||||
|
||||
color_formats = [
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
#PIPE_FORMAT_A8R8G8B8_SRGB,
|
||||
PIPE_FORMAT_R5G6B5_UNORM,
|
||||
PIPE_FORMAT_A1R5G5B5_UNORM,
|
||||
PIPE_FORMAT_A4R4G4B4_UNORM,
|
||||
PIPE_FORMAT_A8_UNORM,
|
||||
PIPE_FORMAT_L8_UNORM,
|
||||
PIPE_FORMAT_YCBCR,
|
||||
PIPE_FORMAT_DXT1_RGB,
|
||||
#PIPE_FORMAT_DXT1_RGBA,
|
||||
#PIPE_FORMAT_DXT3_RGBA,
|
||||
#PIPE_FORMAT_DXT5_RGBA,
|
||||
]
|
||||
|
||||
depth_formats = [
|
||||
PIPE_FORMAT_Z32_UNORM,
|
||||
PIPE_FORMAT_Z24S8_UNORM,
|
||||
PIPE_FORMAT_Z24X8_UNORM,
|
||||
PIPE_FORMAT_Z16_UNORM,
|
||||
]
|
||||
|
||||
sizes = [64, 32, 16, 8, 4, 2, 1]
|
||||
#sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
|
||||
#sizes = [64]
|
||||
#sizes = [63]
|
||||
|
||||
faces = [
|
||||
PIPE_TEX_FACE_POS_X,
|
||||
PIPE_TEX_FACE_NEG_X,
|
||||
PIPE_TEX_FACE_POS_Y,
|
||||
PIPE_TEX_FACE_NEG_Y,
|
||||
PIPE_TEX_FACE_POS_Z,
|
||||
PIPE_TEX_FACE_NEG_Z,
|
||||
]
|
||||
|
||||
for format in color_formats:
|
||||
for target in targets:
|
||||
for size in sizes:
|
||||
if target == PIPE_TEXTURE_3D:
|
||||
depth = size
|
||||
else:
|
||||
depth = 1
|
||||
for face in faces:
|
||||
if target != PIPE_TEXTURE_CUBE and face:
|
||||
continue
|
||||
levels = lods(size)
|
||||
for last_level in range(levels):
|
||||
for level in range(0, last_level + 1):
|
||||
zslice = 0
|
||||
while zslice < depth >> level:
|
||||
test = TextureColorSampleTest(
|
||||
dev = dev,
|
||||
target = target,
|
||||
format = format,
|
||||
width = size,
|
||||
height = size,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
)
|
||||
suite.add_test(test)
|
||||
zslice = (zslice + 1)*2 - 1
|
||||
for format in depth_formats:
|
||||
target = PIPE_TEXTURE_2D
|
||||
depth = 1
|
||||
face = 0
|
||||
last_level = 0
|
||||
level = 0
|
||||
zslice = 0
|
||||
for size in sizes:
|
||||
test = TextureDepthSampleTest(
|
||||
dev = dev,
|
||||
target = target,
|
||||
format = format,
|
||||
width = size,
|
||||
height = size,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
)
|
||||
suite.add_test(test)
|
||||
suite.run()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,180 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
##########################################################################
|
||||
#
|
||||
# Copyright 2009 VMware, Inc.
|
||||
# Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a
|
||||
# copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sub license, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice (including the
|
||||
# next paragraph) shall be included in all copies or substantial portions
|
||||
# of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
||||
# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
||||
# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
##########################################################################
|
||||
|
||||
|
||||
import os
|
||||
|
||||
from gallium import *
|
||||
from base import *
|
||||
|
||||
|
||||
def lods(*dims):
|
||||
size = max(dims)
|
||||
lods = 0
|
||||
while size:
|
||||
lods += 1
|
||||
size >>= 1
|
||||
return lods
|
||||
|
||||
|
||||
class TextureTest(TestCase):
|
||||
|
||||
tags = (
|
||||
'target',
|
||||
'format',
|
||||
'width',
|
||||
'height',
|
||||
'depth',
|
||||
'last_level',
|
||||
'face',
|
||||
'level',
|
||||
'zslice',
|
||||
)
|
||||
|
||||
def test(self):
|
||||
dev = self.dev
|
||||
|
||||
target = self.target
|
||||
format = self.format
|
||||
width = self.width
|
||||
height = self.height
|
||||
depth = self.depth
|
||||
last_level = self.last_level
|
||||
face = self.face
|
||||
level = self.level
|
||||
zslice = self.zslice
|
||||
|
||||
tex_usage = 0
|
||||
|
||||
texture = dev.texture_create(
|
||||
target = target,
|
||||
format = format,
|
||||
width = width,
|
||||
height = height,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
tex_usage = tex_usage,
|
||||
)
|
||||
if texture is None:
|
||||
raise TestSkip
|
||||
|
||||
surface = texture.get_surface(face, level, zslice)
|
||||
|
||||
# ???
|
||||
stride = pf_get_stride(texture->format, w)
|
||||
size = pf_get_nblocksy(texture->format) * stride
|
||||
|
||||
in_raw = os.urandom(size)
|
||||
|
||||
surface.put_tile_raw(0, 0, surface.width, surface.height, in_raw, stride)
|
||||
|
||||
out_raw = surface.get_tile_raw(0, 0, surface.width, surface.height)
|
||||
|
||||
if in_raw != out_raw:
|
||||
raise TestFailure
|
||||
|
||||
|
||||
def main():
|
||||
dev = Device()
|
||||
suite = TestSuite()
|
||||
|
||||
targets = [
|
||||
PIPE_TEXTURE_2D,
|
||||
PIPE_TEXTURE_CUBE,
|
||||
PIPE_TEXTURE_3D,
|
||||
]
|
||||
|
||||
formats = [
|
||||
PIPE_FORMAT_A8R8G8B8_UNORM,
|
||||
PIPE_FORMAT_X8R8G8B8_UNORM,
|
||||
PIPE_FORMAT_A8R8G8B8_SRGB,
|
||||
PIPE_FORMAT_R5G6B5_UNORM,
|
||||
PIPE_FORMAT_A1R5G5B5_UNORM,
|
||||
PIPE_FORMAT_A4R4G4B4_UNORM,
|
||||
PIPE_FORMAT_Z32_UNORM,
|
||||
PIPE_FORMAT_Z24S8_UNORM,
|
||||
PIPE_FORMAT_Z24X8_UNORM,
|
||||
PIPE_FORMAT_Z16_UNORM,
|
||||
PIPE_FORMAT_S8_UNORM,
|
||||
PIPE_FORMAT_A8_UNORM,
|
||||
PIPE_FORMAT_L8_UNORM,
|
||||
PIPE_FORMAT_DXT1_RGB,
|
||||
PIPE_FORMAT_DXT1_RGBA,
|
||||
PIPE_FORMAT_DXT3_RGBA,
|
||||
PIPE_FORMAT_DXT5_RGBA,
|
||||
]
|
||||
|
||||
sizes = [64, 32, 16, 8, 4, 2, 1]
|
||||
#sizes = [1020, 508, 252, 62, 30, 14, 6, 3]
|
||||
#sizes = [64]
|
||||
#sizes = [63]
|
||||
|
||||
faces = [
|
||||
PIPE_TEX_FACE_POS_X,
|
||||
PIPE_TEX_FACE_NEG_X,
|
||||
PIPE_TEX_FACE_POS_Y,
|
||||
PIPE_TEX_FACE_NEG_Y,
|
||||
PIPE_TEX_FACE_POS_Z,
|
||||
PIPE_TEX_FACE_NEG_Z,
|
||||
]
|
||||
|
||||
for target in targets:
|
||||
for format in formats:
|
||||
for size in sizes:
|
||||
if target == PIPE_TEXTURE_3D:
|
||||
depth = size
|
||||
else:
|
||||
depth = 1
|
||||
for face in faces:
|
||||
if target != PIPE_TEXTURE_CUBE and face:
|
||||
continue
|
||||
levels = lods(size)
|
||||
for last_level in range(levels):
|
||||
for level in range(0, last_level + 1):
|
||||
zslice = 0
|
||||
while zslice < depth >> level:
|
||||
test = TextureTest(
|
||||
dev = dev,
|
||||
target = target,
|
||||
format = format,
|
||||
width = size,
|
||||
height = size,
|
||||
depth = depth,
|
||||
last_level = last_level,
|
||||
face = face,
|
||||
level = level,
|
||||
zslice = zslice,
|
||||
)
|
||||
suite.add_test(test)
|
||||
zslice = (zslice + 1)*2 - 1
|
||||
suite.run()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -1,23 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
#
|
||||
# See also:
|
||||
# http://www.ailab.si/orange/doc/ofb/c_otherclass.htm
|
||||
|
||||
import os.path
|
||||
import sys
|
||||
|
||||
import orange
|
||||
import orngTree
|
||||
|
||||
for arg in sys.argv[1:]:
|
||||
name, ext = os.path.splitext(arg)
|
||||
|
||||
data = orange.ExampleTable(arg)
|
||||
|
||||
tree = orngTree.TreeLearner(data, sameMajorityPruning=1, mForPruning=2)
|
||||
|
||||
orngTree.printTxt(tree)
|
||||
|
||||
file(name+'.txt', 'wt').write(orngTree.dumpTree(tree) + '\n')
|
||||
|
||||
orngTree.printDot(tree, fileName=name+'.dot', nodeShape='ellipse', leafShape='box')
|
||||
@@ -12,4 +12,4 @@ Run as:
|
||||
|
||||
export PYTHONPATH=$PWD/build/linux-x86-debug/gallium/winsys/drm/radeon/python:$PWD/build/linux-x86-debug/gallium/state_trackers/python
|
||||
|
||||
python src/gallium/state_trackers/python/samples/tri.py
|
||||
python progs/gallium/python/samples/tri.py
|
||||
|
||||
Reference in New Issue
Block a user