disp = x[tl.clamp(i + d, 0, tl.vec(*NN) - 1)] - x[i]
length = L * float(d).norm()
acc += disp * (disp.norm() - length) / length**2
v[i] += stiffness * acc * dt
for i in ti.grouped(x):
v[i].y -= gravity * dt
v[i] = tl.ballBoundReflect(x[i], v[i], tl.vec(+0.0, +0.2, -0.0), 0.4, 6)
for i in ti.grouped(x):
v[i] *= ti.exp(-damping * dt)
x[i] += dt * v[i]
### Rendering GUI
scene = t3.Scene()
model = t3.Model(f_n=(N - 1)**2 * 4, vi_n=N**2, vt_n=N**2, f_m=1,
tex=ti.imread('assets/cloth.jpg'))
scene.add_model(model)
camera = t3.Camera(fov=24, pos=[0, 1.1, -1.5], target=[0, 0.25, 0])
scene.add_camera(camera)
light = t3.Light([0.4, -1.5, 1.8])
scene.add_light(light)
@ti.kernel
def init_display():
for i_ in ti.grouped(ti.ndrange(N - 1, N - 1)):
i = i_
a = i.dot(tl.vec(N, 1))
i.x += 1
b = i.dot(tl.vec(N, 1))
i.y += 1
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(ti.cpu)
scene = t3.Scene()
model = t3.Model(t3.Mesh.from_obj(t3.readobj('assets/monkey.obj', scale=0.8)))
scene.add_model(model)
camera = t3.Camera(res=(256, 256))
camera.ctl = t3.CameraCtl(pos=[0, 0, 2.5], target=[0, 0, 0], up=[0, 1, 0])
scene.add_camera(camera)
camera2 = t3.Camera()
camera2.ctl = t3.CameraCtl(pos=[0, 1, -2], target=[0, 1, 0], up=[0, 1, 0])
scene.add_camera(camera2)
light = t3.Light([0.4, -1.5, -0.8])
scene.add_light(light)
camera.type = camera.ORTHO
camera2.set_intrinsic(256, 256, 256, 256)
gui = ti.GUI('Model', camera.res)
gui2 = ti.GUI('Model2', camera2.res)
while gui.running and gui2.running:
gui.get_event(None)
gui2.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
gui2.running = not gui2.is_pressed(ti.GUI.ESCAPE)
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(ti.cpu)
mtllib = [None]
scene = t3.Scene()
obj = t3.readobj('assets/torus.obj', scale=0.8)
model = t3.Model(t3.Mesh.from_obj(obj))
model.material = t3.DeferredMaterial(mtllib, t3.Material(t3.CookTorrance()))
scene.add_model(model)
camera = t3.Camera(res=(600, 400))
camera.ctl = t3.CameraCtl(pos=[0, 1, -1.8])
scene.add_camera_d(camera)
gbuff = t3.FrameBuffer(camera, buffers=dict(
mid=[(), int],
position=[3, float],
texcoord=[2, float],
normal=[3, float],
tangent=[3, float],
))
imgbuf = t3.DeferredShading(gbuff, mtllib)
scene.add_buffer(imgbuf)
light = t3.Light([0.4, -1.5, -0.8], 0.9)
scene.add_light(light)
ambient = t3.AmbientLight(0.1)
scene.add_light(ambient)
gui = ti.GUI('G-Buffer', camera.res)
while gui.running:
def show(self, arguments: list = sys.argv[2:]):
"""Visualize an OBJ/NPZ model using Taichi THREE"""
parser = argparse.ArgumentParser(prog='t3 show',
description=f"{self.show.__doc__}")
parser.add_argument(
'filename',
help='File name of the OBJ/NPZ model to visualize, e.g. monkey.obj'
)
parser.add_argument('-s',
'--scale',
default=0.75,
type=float,
help='Specify a scale parameter')
parser.add_argument('-u',
'--resx',
default=512,
type=int,
help='Specify window width')
parser.add_argument('-v',
'--resy',
default=512,
type=int,
help='Specify window height')
parser.add_argument('-A',
'--ambient',
default=0,
type=float,
help='Specify ambient light strength')
parser.add_argument('-o',
'--ortho',
action='store_true',
help='Display in orthogonal mode')
parser.add_argument('-l',
'--lowp',
action='store_true',
help='Shade faces by interpolation')
parser.add_argument('-x',
'--flipx',
action='store_true',
help='Flip X axis of model when display')
parser.add_argument('-y',
'--flipy',
action='store_true',
help='Flip Y axis of model when display')
parser.add_argument('-z',
'--flipz',
action='store_true',
help='Flip Z axis of model when display')
parser.add_argument('-f',
'--flipface',
action='store_true',
help='Flip face culling direction')
parser.add_argument('-F',
'--flipnorm',
action='store_true',
help='Flip face normal direction')
parser.add_argument('-b',
'--bothface',
action='store_true',
help='Including both face, no culling')
parser.add_argument('-N',
'--renorm',
action='store_true',
help='Reset normal vectors to flat')
parser.add_argument('-S',
'--showhints',
action='store_true',
help='Show information about pixel under cursor')
parser.add_argument('-T',
'--taa',
default=True,
action='store_true',
help='Enable temporal anti-aliasing')
parser.add_argument('-t',
'--texture',
type=str,
help='Path to texture to bind')
parser.add_argument('-n',
'--normtex',
type=str,
help='Path to normal map to bind')
parser.add_argument('-m',
'--metallic',
type=str,
help='Path to metallic map to bind')
parser.add_argument('-r',
'--roughness',
type=str,
help='Path to roughness map to bind')
parser.add_argument('-a',
'--arch',
default='cpu',
type=str,
help='Backend to use for rendering')
args = parser.parse_args(arguments)
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(getattr(ti, args.arch))
scene = t3.Scene()
obj = t3.readobj(args.filename,
scale=args.scale if args.scale != 0 else 1)
t3.objflipaxis(obj, args.flipx, args.flipy, args.flipz)
if args.scale == 0:
t3.objautoscale(obj)
if args.flipface:
t3.objflipface(obj)
if args.flipnorm:
t3.objflipnorm(obj)
if args.renorm:
t3.objmknorm(obj)
if args.bothface:
t3.objbothface(obj)
model = t3.Model(t3.Mesh.from_obj(obj))
if args.texture is not None:
model.add_texture('color', ti.imread(args.texture))
if args.normtex is not None:
model.add_texture('normal', ti.imread(args.normtex))
if args.metallic is not None:
model.add_texture('metallic', ti.imread(args.metallic))
if args.roughness is not None:
model.add_texture('roughness', ti.imread(args.roughness))
scene.add_model(model)
camera = t3.Camera(res=(args.resx, args.resy), taa=args.taa)
if args.showhints:
camera.fb.add_buffer('pos', 3)
camera.fb.add_buffer('texcoor', 2)
camera.fb.add_buffer('normal', 3)
if args.ortho:
camera.type = camera.ORTHO
scene.add_camera(camera)
if args.ambient:
light = t3.AmbientLight(args.ambient)
else:
light = t3.Light([0.4, -1.5, 0.8])
scene.add_light(light)
gui = ti.GUI('Model', camera.res)
while gui.running:
gui.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
camera.from_mouse(gui)
scene.render()
gui.set_image(camera.img)
if args.showhints:
coor = gui.get_cursor_pos()
pos = camera.fb.fetchpixelinfo('pos', coor)
color = camera.fb.fetchpixelinfo('img', coor)
texcoor = camera.fb.fetchpixelinfo('texcoor', coor)
normal = camera.fb.fetchpixelinfo('normal', coor)
gui.text(
f'color: [{color.x:.2f} {color.y:.2f} {color.z:.2f}]; pos: [{pos.x:+.2f} {pos.y:+.2f} {pos.z:+.2f}]',
(0, 1))
gui.text(
f'texcoor: [{texcoor.x:.2f} {texcoor.y:.2f}]; normal: [{normal.x:+.2f} {normal.y:+.2f} {normal.z:+.2f}]',
(0, 1 - 16 / camera.res[1]))
gui.show()
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(ti.cpu)
scene = t3.Scene()
cubic = t3.Model(t3.MeshGen().cube([0, 0, 0], [1, 1, 1]))
cylin = t3.Model(t3.MeshGen().cylinder([0, 0, 0], [0, 1, 0], [0.5, 0, 0],
[0, 0, 0.5], 20))
scene.add_model(cylin)
scene.add_model(cubic)
scene.set_light_dir([0.4, 1.5, -1.8])
gui = ti.GUI('Creating models', scene.res)
while gui.running:
gui.running = not gui.get_event(ti.GUI.ESCAPE)
cylin.L2W.offset[None] = [0, -0.5, 0]
cubic.L2W.offset[None] = [-0.5, -0.5, -0.5]
scene.camera.from_mouse(gui)
scene.render()
gui.set_image(scene.img)
gui.show()
import taichi as ti
import taichi_three as t3
import numpy as np
import math, time
ti.init(ti.cpu)
scene = t3.Scene()
monkey = t3.Model(t3.Mesh.from_obj(t3.readobj('assets/monkey.obj', scale=0.6)))
torus = t3.Model(t3.Mesh.from_obj(t3.readobj('assets/torus.obj')))
scene.add_model(monkey)
scene.add_model(torus)
camera = t3.Camera()
scene.add_camera(camera)
light = t3.Light(dir=[0.4, -1.5, -1.8])
scene.add_light(light)
gui = ti.GUI('Transform', camera.res)
while gui.running:
gui.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
camera.from_mouse(gui)
monkey.L2W[None] = t3.rotateZ(angle=time.time())
torus.L2W[None] = t3.translate(x=0, y=math.cos(time.time()) * 0.5, z=0)
scene.render()
gui.set_image(camera.img)
gui.show()
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(ti.cpu)
mtllib = [None]
scene = t3.Scene()
parts = t3.objunpackmtls(t3.readobj('assets/multimtl.obj', scale=0.8))
model1 = t3.Model(t3.Mesh.from_obj(parts[b'Material1']))
model2 = t3.Model(t3.Mesh.from_obj(parts[b'Material2']))
model1.material = t3.DeferredMaterial(
mtllib,
t3.Material(
t3.CookTorrance( # Up: gold
color=t3.Constant(t3.RGB(1.0, 0.96, 0.88)),
roughness=t3.Constant(0.2),
metallic=t3.Constant(0.75),
)))
model2.material = t3.DeferredMaterial(
mtllib,
t3.Material(
t3.CookTorrance( # Down: cloth
color=t3.Texture('assets/cloth.jpg'),
roughness=t3.Constant(0.3),
metallic=t3.Constant(0.0),
)))
scene.add_model(model1)
scene.add_model(model2)
camera = t3.Camera()
camera.ctl = t3.CameraCtl(pos=[0.8, 0, 2.5])
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(ti.cpu)
scene = t3.Scene()
model = t3.Model(t3.Mesh.from_obj('assets/monkey.obj'))
scene.add_model(model)
camera = t3.Camera()
scene.add_camera_d(camera)
buffer = t3.GaussianBlur(t3.FrameBuffer(camera), 8)
scene.add_buffer(buffer)
light = t3.Light([0.4, -1.5, -0.8])
scene.add_light(light)
gui = ti.GUI('Gaussian', camera.res)
while gui.running:
gui.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
camera.from_mouse(gui)
scene.render()
gui.set_image(buffer.img)
gui.show()
import taichi_three as t3
scene = t3.Scene()
camera = t3.Camera()
scene.add_camera(camera)
light = t3.Light(dir=[-0.2, -0.6, -1.0])
scene.add_light(light)
mesh = t3.Mesh.from_obj(t3.Geometry.cube())
xplus = t3.Model(mesh)
xplus.material = t3.Material(t3.CookTorrance(
color=t3.Constant(t3.RGB(1, 0, 0)),
))
scene.add_model(xplus)
yplus = t3.Model(mesh)
yplus.material = t3.Material(t3.CookTorrance(
color=t3.Constant(t3.RGB(0, 1, 0)),
))
scene.add_model(yplus)
zplus = t3.Model(mesh)
zplus.material = t3.Material(t3.CookTorrance(
color=t3.Constant(t3.RGB(0, 0, 1)),
))
scene.add_model(zplus)
center = t3.Model(mesh)
center.material = t3.Material(t3.CookTorrance(
color=t3.Constant(t3.RGB(1, 1, 1)),
))
scene.add_model(center)
@ti.kernel
def init():
for i in range(n_particles):
x[i] = ti.Vector([ti.random() for i in range(dim)]) * 0.4 + 0.15
J[i] = 1
mciso = MCISO(n_grid * 2)
voxel = Voxelizer(mciso.N)
scene = t3.Scene()
mesh = t3.DynamicMesh(n_faces=mciso.N_res,
n_pos=mciso.N_res,
n_nrm=mciso.N_res)
model = t3.Model(mesh)
scene.add_model(model)
camera = t3.Camera()
scene.add_camera(camera)
scene.add_light(t3.Light([0.4, -1.5, -1.8], 0.8))
scene.add_light(t3.AmbientLight(0.22))
@ti.kernel
def update_mesh():
mesh.n_faces[None] = mciso.Js_n[None]
for i in range(mciso.Js_n[None]):
for t in ti.static(range(3)):
mesh.faces[i][t, 0] = mciso.Jts[i][t]
mesh.faces[i][t, 2] = mciso.Jts[i][t]
mesh.pos[i] = (mciso.vs[i] + 0.5) / mciso.N * 2 - 1
x[i] = b[i]
v[i] += F[i] * beta_dt
def implicit():
prepare()
for i in range(jacobi_steps):
jacobi()
collide(b, v)
update_pos()
### Rendering GUI
scene = t3.Scene()
model = t3.Model()
scene.add_model(model)
faces = t3.Face.var(N**2 * 2)
#lines = t3.Line.var(N**2 * 2)
vertices = t3.Vertex.var(N**2)
model.set_vertices(vertices)
model.add_geometry(faces)
#model.add_geometry(lines)
@ti.kernel
def init_display():
for i_ in ti.grouped(ti.ndrange(N - 1, N - 1)):
i = i_
a = i.dot(tl.vec(N, 1))
import taichi as ti
import taichi_three as t3
ti.init(ti.cpu)
scene = t3.Scene()
mesh = t3.MeshGrid((128, 128))
model = t3.Model(t3.QuadToTri(mesh))
scene.add_model(model)
camera = t3.Camera()
camera.ctl = t3.CameraCtl(pos=[1.1, 1.6, 1.6])
scene.add_camera(camera)
light = t3.Light([0.4, -1.5, -0.8], 0.9)
scene.add_light(light)
ambient = t3.AmbientLight(0.1)
scene.add_light(ambient)
@ti.func
def Z(xy, t):
return 0.1 * ti.sin(10 * xy.norm() - t3.tau * t)
@ti.kernel
def deform_mesh(t: float):
for i, j in model.mesh.mesh.pos:
mesh.pos[i, j].y = Z(mesh.pos[i, j].xZ, t)
gui = ti.GUI('Meshgrid', camera.res)
while gui.running:
import taichi as ti
import taichi_three as t3
ti.init(ti.cpu)
scene = t3.Scene()
model = t3.Model(t3.Mesh.from_obj('assets/monkey.obj'))
scene.add_model(model)
plane = t3.Model(t3.QuadToTri(t3.MeshGrid(2)))
scene.add_model(plane)
camera = t3.Camera()
scene.add_camera_d(camera)
camerafb = t3.FrameBuffer(camera,
buffers=dict(
img=[3, float],
normal=[3, float],
))
ssaobuf = t3.LaplacianBlur(t3.SSAO(camerafb))
buffer = t3.ImgBinaryOp(camerafb, ssaobuf, lambda x, y: x * y)
#buffer = ssaobuf
scene.add_buffer(buffer)
light = t3.Light([0.4, -1.5, -0.8], 0.9)
scene.add_light(light)
ambient = t3.AmbientLight(0.1)
scene.add_light(ambient)
plane.L2W[None] = t3.translate(0, -1, 0) @ t3.scale(2, 2, 2)
gui = ti.GUI('SSAO', buffer.res)
while gui.running:
gui.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
import taichi as ti
import taichi_three as t3
import numpy as np
ti.init(ti.cpu)
scene = t3.Scene()
obj1 = t3.readobj('assets/torus.obj', scale=0.8)
obj2 = t3.readobj('assets/cylinder.obj', scale=0.6)
model1 = t3.Model(t3.Mesh.from_obj(obj1))
model2 = t3.Model(t3.Mesh.from_obj(obj2))
scene.add_model(model1)
scene.add_model(model2)
camera = t3.Camera()
camera.ctl = t3.CameraCtl(pos=[1, 1, -1])
scene.add_camera(camera)
light = t3.Light([0.4, -1.5, 1.8])
scene.add_camera(light.make_shadow_camera())
scene.add_light(light)
gui = ti.GUI('Model', camera.res)
gui2 = ti.GUI('Depth map', light.shadow.res)
gui2.fps_limit = None
while gui.running:
gui.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
camera.from_mouse(gui)
model2.L2W[None] = t3.translate(0, 0.16 * ti.sin(gui.frame * 0.03), 0)
scene.render()
gui.set_image(camera.img)
gui2.set_image(light.shadow.img)
import taichi as ti
import taichi_three as t3
import numpy as np
import math, time
ti.init(ti.cpu)
scene = t3.Scene()
monkey = t3.Model(t3.readobj('assets/monkey.obj', scale=0.4))
torus = t3.Model(t3.readobj('assets/torus.obj', scale=0.6))
scene.add_model(monkey)
scene.add_model(torus)
scene.set_light_dir([0.4, -1.5, -1.8])
gui = ti.GUI('Transform', scene.res)
while gui.running:
gui.running = not gui.get_event(ti.GUI.ESCAPE)
scene.camera.from_mouse(gui)
monkey.L2W.matrix[None] = t3.rotationZ(angle=time.time())
torus.L2W.offset[None] = [0, math.cos(time.time()) * 0.5, 0]
scene.render()
gui.set_image(scene.img)
gui.show()
import taichi as ti
import taichi_three as t3
import numpy as np
import time
ti.init(ti.cpu)
scene = t3.Scene()
model = t3.Model(t3.Mesh.from_obj(t3.readobj('assets/torus.obj', scale=0.8)))
scene.add_model(model)
ball = t3.Model(t3.Mesh.from_obj(t3.readobj('assets/sphere.obj', scale=0.1)))
ball.material = t3.Material(
t3.BlinnPhong(emission=t3.Constant(t3.RGB(1.0, 1.0, 1.0)), ))
scene.add_model(ball)
camera = t3.Camera()
camera.ctl = t3.CameraCtl(pos=[0, 1.8, 1.8])
scene.add_camera(camera)
light = t3.PointLight(pos=[0, 1, 0])
scene.add_light(light)
ambient = t3.AmbientLight(0.2)
scene.add_light(ambient)
gui = ti.GUI('Point light', camera.res)
while gui.running:
gui.get_event(None)
gui.running = not gui.is_pressed(ti.GUI.ESCAPE)
camera.from_mouse(gui)
light.pos[None].y = ti.cos(time.time())
ball.L2W[None] = t3.translate(light.pos[None].value)
scene.render()
gui.set_image(camera.img)
