def sideunitshelf( w, d, h, legw, legd ):
shelfframe = ( irit.box( ( legd + 0.001, legd - 0.019, h - 0.015 ), w - 2 * legd - 0.002, d - 2 * legd + 0.038, 0.015 ) - irit.box( ( legd + 0.04, legd + 0.03, h - 0.1 ), w - 2 * legd - 0.08, d - 2 * legd - 0.06, h + 0.5 ) - irit.box( ( legd + 0.03, legd + 0.02, h - 0.005 ), w - 2 * legd - 0.05, d - 2 * legd - 0.04, h + 0.5 ) )
irit.attrib( shelfframe, "ptexture", woodtext )
irit.attrib( shelfframe, "rgb", woodclr )
shelfglass = irit.box( ( legd + 0.032, legd + 0.022, h - 0.003 ), w - 2 * legd - 0.064, d - 2 * legd - 0.044, 0.003 )
irit.attrib( shelfglass, "transp", irit.GenRealObject(0.3) )
retval = irit.list( shelfframe, shelfglass )
return retval
def squareunitbars( w, d, h, legw, legd ):
fbar = irit.box( ( legw, 0, 0 ), w - 2 * legw, legd, legw )
sbar = irit.box( ( 0, legd, 0 ), legd, d - 2 * legd, legw )
barframe = irit.list( fbar, sbar, fbar * irit.ty( d - legd ), sbar * irit.tx( w - legd ) )
retval = irit.list( barframe * irit.tz( 0.1 ), barframe * irit.tz( h - 0.1 ) )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def snakepiece(clr, xrot, ypos, zpos):
retval = (irit.box((0, 0, (-0.1)), 1, 1.1, 1.1) - irit.box(
(0, (-1), (-2)), 2, 3, 2) * irit.rx(45) * irit.tx((-0.5)))
retval = retval * irit.sc(1.0 / math.sqrt(2)) * irit.rx(
(-225)) * irit.trans(((-1) / (2.0 * math.sqrt(2)), 1, 0.5))
retval = retval * irit.rx(xrot) * irit.ty(ypos) * irit.tz(zpos)
irit.color(retval, clr)
return retval
def squareunitlegs( w, d, h, legw, legd ):
grooved = ( legw - legd )
lleg = ( irit.box( ( 0, 0, 0 ), legw, legd, h ) - irit.box( ( legw/3, (-0.01 ), 0.1 ), legw/3, 0.02, h - 0.3 ) - irit.box( ( (-0.01 ), legd/3, 0.1 ), 0.02, legd/3, h - 0.3 ) - irit.box( ( legw - grooved, legd - 0.02, 0.2 ), 0.1, 0.1, h - 0.3 ) )
rleg = ( irit.box( ( 0, 0, 0 ), legw, legd, h ) - irit.box( ( legw/3, (-0.01 ), 0.1 ), legw/3, 0.02, h - 0.3 ) - irit.box( ( legw - 0.01, legd/3, 0.1 ), 0.02, legd/3, h - 0.3 ) - irit.box( ( grooved, legd - 0.02, 0.2 ), (-0.1 ), 0.1, h - 0.3 ) )
retval = irit.list( lleg, rleg * irit.tx( w - legw ), lleg * irit.rz( 180 ) * irit.tx( w ) * irit.ty( d ), rleg * irit.rz( 180 ) * irit.tx( legw ) * irit.ty( d ) )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def centerunitwalls( w, d, h, legw, legd ):
backwall = irit.box( ( legd, d - legd - 0.018, 0.2 ), w - 2 * legd, 0.002, h - 0.3 )
leftwall = irit.box( ( legd + 0.001, legd, 0.2 ), 0.002, d - 2 * legd, h - 0.3 )
rightwall = irit.box( ( w - legd - 0.003, legd, 0.2 ), 0.002, d - 2 * legd, h - 0.3 )
bottomwall = irit.box( ( legd, legd, 0.2 - 0.015 ), w - 2 * legd, d - 2 * legd, 0.015 )
retval = irit.list( backwall, leftwall, rightwall, bottomwall )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def cornerunitbars( w, h, legw, legd ):
sbar = irit.box( ( legw, 0, 0 ), w - 2 * legw, legd, legw )
lbar = irit.box( ( legd, 0, 0 ), 2 * w - legd - legw, legd, legw )
arcbar1 = irit.arc( ( w, 0, 0 ), ( w, w, 0 ), ( 2 * w, w, 0 ) )
arcbar2 = irit.offset( arcbar1, (-legd ), 0.1, 0 )
arcbar = irit.list( irit.extrude( arcbar1 + (-arcbar2 ) + irit.ctlpt( irit.E3, w, 0, 0 ), ( 0, 0, legw ), 0 ), irit.ruledsrf( arcbar1, arcbar2 ), irit.ruledsrf( arcbar1, arcbar2 ) * irit.tz( legw ) )
barframe = irit.list( arcbar, sbar, sbar * irit.tx( w ) * irit.rz( 90 ) * irit.tx( 2 * w ), lbar * irit.rz( 90 ) * irit.tx( legd ), lbar * irit.tx( legw - legd ) * irit.ty( 2 * w - legd ) )
retval = irit.list( barframe * irit.tz( 0.1 ), barframe * irit.tz( h - 0.1 ) )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def centerunitinterior( w, d, h, legw, legd ):
intwidth = w/3
vertwalls = irit.list( irit.box( ( intwidth, 0.01, 0.2 ), 0.01, d - 0.01 - legd, h - 0.2 ),\
irit.box( ( intwidth * 2, 0.01, 0.2 ), 0.01, d - 0.01 - legd, h - 0.2 ) )
shelfs = irit.list( irit.box( ( legd, 0.01, h * 0.55 ), intwidth - legd, d - 0.01 - legd, 0.01 ),\
irit.box( ( intwidth * 2 + 0.01, 0.01, h * 0.45 ), intwidth - legd - 0.01, d - 0.01 - legd, 0.01 ),\
irit.box( ( intwidth * 2 + 0.01, 0.01, h * 0.65 ), intwidth - legd - 0.01, d - 0.01 - legd, 0.01 ) )
retval = irit.list( vertwalls, shelfs )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def centerunitdoors( w, d, h, legw, legd ):
intwidth = w/3
leftdoor = irit.box( ( legw + 0.002, 0, 0.202 ), intwidth - legw + 0.0096, 0.01, h - 0.204 - legw )
rot_z1 = ( irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, 100 ) )
irit.attrib( leftdoor, "animation", irit.list( irit.tx( (-legw ) ), rot_z1, irit.tx( legw ) ) )
rightdoor = irit.box( ( intwidth * 2 + 0.002, 0, 0.202 ), intwidth - legw - 0.004, 0.01, h - 0.204 - legw )
rot_z2 = ( \
irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, (-100 ) ) )
irit.attrib( rightdoor, "animation", irit.list( irit.tx( (-w ) + legw ), rot_z2, irit.tx( w - legw ) ) )
retval = irit.list( leftdoor, rightdoor )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def dominos(path, scl, piecetimestep):
retval = irit.nil()
animtime = 0
dominopiece = irit.box(
(-0.01, -0.006, 0), 0.02, 0.006, 0.05) * irit.sc(scl)
rot_x = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 80 ) ) )
crvdomain = irit.pdomain(path)
t = irit.FetchRealObject(irit.nth(crvdomain, 1))
dpath = irit.cderive(path)
while (t < irit.FetchRealObject(irit.nth(crvdomain, 2))):
d = irit.Fetch3TupleObject(
irit.coerce(irit.ceval(dpath, t), irit.POINT_TYPE))
dlen = math.sqrt(DotProd(d, d))
rot_x = irit.creparam(rot_x, animtime, animtime + piecetimestep)
irit.attrib(dominopiece, "animation", irit.list(rot_x))
irit.setname(irit.getattr(dominopiece, "animation"), 0, "rot_x")
dp = dominopiece * irit.rz(
-math.atan2(d[0], d[1]) * 180 / math.pi) * irit.trans(
irit.Fetch3TupleObject(
irit.coerce(irit.ceval(path, t), irit.VECTOR_TYPE)))
irit.snoc(dp, retval)
t = t + 0.04 * scl / dlen
animtime = animtime + piecetimestep * 0.6
return retval
def cornerunitlegs( w, h, legw, legd ):
grooved = ( legw - legd )
lleg = ( irit.box( ( 0, 0, 0 ), legw, legd, h ) - irit.box( ( legw/3, (-0.01 ), 0.1 ), legw/3, 0.02, h - 0.3 ) - irit.box( ( (-0.01 ), legd/3, 0.1 ), 0.02, legd/3, h - 0.3 ) - irit.box( ( legd, legd - 0.02, 0.2 ), 0.1, 0.1, h - 0.3 ) )
sleg = ( irit.box( ( 0, 0, 0 ), legw, legd, h ) - irit.box( ( legw/3, (-0.01 ), 0.1 ), legw/3, 0.02, h - 0.3 ) - irit.box( ( (-0.1 ), legd - 0.02, 0.2 ), 0.2, 0.1, h - 0.3 ) )
rleg = ( irit.box( ( 0, 0, 0 ), legw, legd, h ) - irit.box( ( legw/3, (-0.01 ), 0.1 ), legw/3, 0.02, h - 0.3 ) - irit.box( ( legw - 0.01, legd/3, 0.1 ), 0.02, legd/3, h - 0.3 ) - irit.box( ( grooved, legd - 0.02, 0.2 ), (-0.1 ), 0.1, h - 0.3 ) )
cleg = ( irit.box( ( 0, 0, 0 ), legw, legw, h ) - irit.box( ( legd, legd, 0.2 ), 0.1, 0.1, h - 0.3 ) )
retval = irit.list( lleg, sleg * irit.tx( w - legw ), sleg * irit.tx( w ) * irit.rz( 90 ) * irit.tx( 2 * w ), rleg * irit.rz( 90 ) * irit.tx( 2 * w ) * irit.ty( 2 * w - legw ), cleg * irit.rz( (-90 ) ) * irit.ty( w * 2 ) )
irit.attrprop( retval, "ptexture", woodtext )
irit.attrprop( retval, "rgb", woodclr )
return retval
def sideunitwalls( w, d, h, legw, legd ):
backwall = irit.box( ( legd, d - legd - 0.018, 0.2 ), w - 2 * legd, 0.002, h - 0.3 )
irit.attrib( backwall, "ptexture", woodtext )
irit.attrib( backwall, "rgb", woodclr )
leftwall = irit.box( ( legd + 0.001, legd, 0.2 ), 0.002, d - 2 * legd, h - 0.3 )
rightwall = irit.box( ( w - legd - 0.003, legd, 0.2 ), 0.002, d - 2 * legd, h - 0.3 )
irit.attrib( leftwall, "transp", irit.GenRealObject(0.3 ))
irit.attrib( rightwall, "transp", irit.GenRealObject(0.3 ))
frontdoorframe = ( irit.box( ( legw + 0.001, 0, 0.201 ), w - 2 * legw - 0.002, 0.015, h - 0.302 ) - irit.box( ( legw + 0.03, (-0.1 ), 0.23 ), w - 2 * legw - 0.062, 0.5, h - 0.362 ) - irit.box( ( legw + 0.02, 0.01, 0.22 ), w - 2 * legw - 0.04, 0.1, h - 0.34 ) )
irit.attrib( frontdoorframe, "ptexture", woodtext )
irit.attrib( frontdoorframe, "rgb", woodclr )
frontdoorglass = irit.box( ( legw + 0.021, 0.011, 0.221 ), w - 2 * legw - 0.042, 0.003, h - 0.342 )
irit.attrib( frontdoorglass, "transp", irit.GenRealObject(0.3) )
frontdoor = irit.list( frontdoorframe, frontdoorglass )
rot_z = ( irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, 100 ) )
irit.attrib( frontdoor, "animation", irit.list( irit.tx( (-legw ) ), rot_z, irit.tx( legw ) ) )
retval = irit.list( backwall, leftwall, rightwall, frontdoor )
return retval
def cubeat(x, y, z):
retval = irit.box((x - size / 2.0, y - size / 2.0, z - size / 2.0), size,
size, size)
irit.attrib(
retval, "rgb",
irit.GenStrObject(
str(int(irit.random(64, 255))) + "," +
str(int(irit.random(64, 255))) + "," +
str(int(irit.random(64, 255)))))
return retval
def centerunitdrawer( w, d, h, legw, drawerelev ):
drawerw = w/3
drawerh = ( ( h - 0.204 - legw )/3 - 0.01 )
drawerbox = ( irit.box( ( drawerw, 0, drawerelev ), drawerw, d - legw, drawerh ) - irit.box( ( drawerw + 0.01, 0.01, drawerelev + 0.01 ), drawerw - 0.02, d - legw - 0.02, drawerh ) )
mov_y = ( irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, (-d ) + legw + 0.05 ) )
irit.attrib( drawerbox, "animation", irit.list( mov_y ) )
irit.attrib( drawerbox, "ptexture", woodtext )
irit.attrib( drawerbox, "rgb", woodclr )
retval = irit.list( drawerbox )
return retval
def cornerunitwalls( w, h, legw, legd ):
lwall = irit.box( ( legd, 0, 0.2 ), 2 * w - 2 * legd, 0.002, h - 0.3 )
irit.attrib( lwall, "ptexture", woodtext )
irit.attrib( lwall, "rgb", woodclr )
swall = irit.box( ( legd, 0, 0.2 ), w - 2 * legd, 0.002, h - 0.3 )
irit.attrib( swall, "transp", irit.GenRealObject(0.3 ))
arcbar1 = irit.arc( ( w, 0, 0 ), ( w, w, 0 ), ( 2 * w, w, 0 ) )
arcbar2 = irit.offset( arcbar1, irit.GenRealObject(-0.03 ), 0.1, 0 )
arcbar = irit.list( irit.extrude( arcbar1 + (-arcbar2 ) + irit.ctlpt( irit.E3, w, 0, 0 ), ( 0, 0, 0.03 ), 0 ), irit.ruledsrf( arcbar1, arcbar2 ), irit.ruledsrf( arcbar1, arcbar2 ) * irit.tz( 0.03 ) )
rdoorframe = irit.list( irit.box( ( w, 0, 0.2 ), 0.03, 0.03, h - 0.3 ),\
irit.box( ( 2 * w - 0.03, w - 0.03, 0.2 ), 0.03, 0.03, h - 0.3 ),\
arcbar * irit.tz( 0.2 ), arcbar * irit.tz( h - 0.1 - 0.03 ) )
irit.attrib( rdoorframe, "ptexture", woodtext )
irit.attrib( rdoorframe, "rgb", woodclr )
rdoorglass = irit.extrude( irit.offset( arcbar1, irit.GenRealObject(-0.02 ), 0.1, 0 ) + (-irit.offset( arcbar1, irit.GenRealObject(-0.03 ), 0.1, 0 ) ) + \
irit.ctlpt( irit.E3, w - 0.02, 0, 0 ), ( 0, 0, h - 0.3 - 0.04 ), 0 ) * irit.tz( 0.22 )
irit.attrib( rdoorglass, "transp", irit.GenRealObject(0.3 ))
rdoor = irit.list( rdoorframe, rdoorglass )
rot_z = ( \
irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, 130 ) )
irit.attrib( rdoor, "animation", irit.list( irit.tx( (-w ) ), rot_z, irit.tx( w ) ) )
retval = irit.list( lwall * irit.ty( 2 * w ), swall * irit.rz( 90 ) * irit.tx( 2 * w ) * irit.ty( w ), lwall * irit.rz( 90 ), swall, rdoor )
return retval
trap1 = irit.poly(
irit.list(
irit.point((-1), (-1), 1) * irit.sc(sclfctr),
irit.point((-1), 1, 1) * irit.sc(sclfctr), irit.point((-1), 1, 1),
irit.point((-1), (-1), 1)), 0)
trap2 = trap1 * irit.rz(180)
prim1 = irit.list(sqr1, sqr2, trap1, trap2)
prim2 = prim1 * irit.rx(90)
prim3 = prim1 * irit.rx((-90))
baseunitaux = irit.list(prim1, prim2, prim3,
trap1 * irit.rx(90) * irit.ry((-90)),
trap2 * irit.rx((-90)) * irit.ry(90))
baseunit = irit.list(baseunitaux, baseunitaux * irit.ty(2.35),
irit.box(
((-0.15), 1, (-0.5)), 0.3, 0.35, 1)) * irit.sc(0.5)
irit.free(baseunitaux)
baseunit1 = baseunit
irit.color(baseunit1, irit.RED)
baseunit2 = baseunit * irit.tx(1.175)
irit.color(baseunit2, irit.GREEN)
baseunit3 = baseunit * irit.rx(180) * irit.rz(90)
irit.color(baseunit3, irit.CYAN)
baseunit4 = baseunit3 * irit.ty(1.175)
irit.color(baseunit4, irit.MAGENTA)
irit.free(baseunit)
t = irit.time(1)
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.scale((0.5, 0.5, 0.5)))
save_res = irit.GetResolution()
#
# Try it with coplanar false for fun.
#
# irit.iritstate( "coplanar", false );
#
psort = irit.iritstate("polysort", irit.GenRealObject(0))
t1 = irit.box(((-2), (-0.35), 0), 4, 0.7, 0.4)
irit.SetResolution(80)
t2 = irit.cylin((0, 0, 0), (0, 0, 0.4), 1.4, 3)
s1 = t1 * t2
irit.free(t1)
irit.free(t2)
irit.view(irit.list(irit.GetViewMatrix(), s1), irit.ON)
irit.SetResolution(40)
t3 = irit.cylin((0, 0, 0), (0, 0, 0.4), 0.9, 3)
s2 = (s1 + t3)
irit.free(t3)
irit.free(s1)
irit.view(s2, irit.ON)
irit.SetResolution(80)
irit.view(s4, irit.ON)
irit.SetResolution(64)
t4 = irit.sphere((0, 0, 0), 1)
s5 = (t4 - s4)
irit.free(s4)
irit.free(t4)
final = irit.convex(s5)
irit.free(s5)
irit.printf("total time = %f\n", irit.list(irit.time(0)))
# In Seconds
irit.interact(final)
irit.save("solid4", final)
# Now make the box cut out of it:
t5 = irit.box(((-0.01), (-0.01), (-0.01)), 1.5, 1.5, 1.5)
cut = (final - t5)
cut = irit.convex(cut)
irit.free(final)
irit.free(t5)
irit.save("solid4c", cut)
irit.free(cut)
irit.SetResolution(save_res)
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Model from "Partitioning Polyhedral Objects into Nonintersecting parts' # by mark Segal and Carlo H. Sequin, IEE CG&A, January 1988, pp 53-67. # save_mat = irit.GetViewMatrix() b1 = irit.box((0.2, 0.2, 0.2), 0.8, 0.8, 0.8) b2 = irit.box((0.2, 0.2, (-0.2)), 0.8, 0.8, (-0.8)) b3 = irit.box((0.2, (-0.2), 0.2), 0.8, (-0.8), 0.8) b4 = irit.box((0.2, (-0.2), (-0.2)), 0.8, (-0.8), (-0.8)) b5 = irit.box(((-0.2), 0.2, 0.2), (-0.8), 0.8, 0.8) b6 = irit.box(((-0.2), 0.2, (-0.2)), (-0.8), 0.8, (-0.8)) b7 = irit.box(((-0.2), (-0.2), 0.2), (-0.8), (-0.8), 0.8) b8 = irit.box(((-0.2), (-0.2), (-0.2)), (-0.8), (-0.8), (-0.8)) cubes = b1 ^ b2 ^ b3 ^ b4 ^ b5 ^ b6 ^ b7 ^ b8 irit.free(b1) irit.free(b2) irit.free(b3) irit.free(b4) irit.free(b5) irit.free(b6) irit.free(b7) irit.free(b8)
x = irit.FetchRealObject(irit.coord( pt, 1 ))
y = irit.FetchRealObject(irit.coord( pt, 2 ))
z = irit.FetchRealObject(irit.coord( pt, 3 ))
pt = irit.teval( tv, x, y, z )
v = math.floor( i/float(usize) )
u = i - v * usize
srf = irit.seditpt( srf, pt, u, v )
i = i + 1
irit.attrib( srf, "color", clr )
retval = srf
return retval
#
# Properly orient the Teapot in the parametric space of the Trivariate
#
prmdomain = irit.box( ( 0, 0, 0 ), 0.5, 1, 1 )
irit.attrib( prmdomain, "transp", irit.GenRealObject(0.8) )
teapot = teapotorig * irit.sc( 0.13 ) * irit.rz( 90 ) * irit.rx( 90 ) * irit.sx( (-1 ) ) * irit.trans( ( 0, 0.5, 0.5 ) )
all = irit.list( prmdomain, teapot ) * irit.rz( 90 ) * irit.ry( 40 ) * irit.rx( 40 )
interact( irit.list( all, irit.GetViewMatrix() ) )
irit.save( "warp1trv", all )
#
# Warp the teapot, one surface at a time, after some surface refinement.
#
warpedteapot = irit.nil( )
i = 1
while ( i <= irit.SizeOf( teapot ) ):
import irit
#
#
# Yet another simple 3D mechanical object.
#
# Created by Gershon Elber, Sep 89
#
save_mat = irit.GetViewMatrix()
save_res = irit.GetResolution()
irit.SetResolution(16)
irit.SetViewMatrix(irit.GetViewMatrix() * irit.trans(
(0, (-0.3), 0)) * irit.scale((0.8, 0.8, 0.8)))
b1 = irit.box(((-0.6), (-0.3), 0), 1.2, 0.6, 0.6)
c1 = irit.cylin((0, (-0.25), 0.59), (0, 0.5, 0), 0.55, 3)
s1 = (b1 + c1)
irit.color(s1, irit.YELLOW)
irit.free(b1)
irit.free(c1)
irit.view(irit.list(irit.GetViewMatrix(), s1), irit.ON)
b2 = irit.box(((-0.4), (-0.4), (-0.1)), 0.8, 0.8, 0.35)
irit.view(b2, irit.OFF)
s2 = (s1 - b2)
irit.free(s1)
irit.free(b2)
irit.color(s2, irit.YELLOW)
irit.view(s2, irit.ON)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Yet another cube puzzle.
#
# Gershon Elber, Jan 1999
#
stick1 = (irit.box(((-0.5), 0, (-3)), 1, 1, 6) - irit.box(
((-1), (-0.5), 1), 2, 1, 1))
irit.attrib(stick1, "rgb", irit.GenStrObject("255, 0, 0"))
stick2 = (irit.box(((-0.5), 0, (-3)), 1, (-1), 6) - irit.box(
((-1), (-0.5), (-2)), 2, 1, 3))
irit.attrib(stick2, "rgb", irit.GenStrObject("255, 100, 0"))
stick3 = (irit.box(((-3), (-0.5), (-1)), 6, 1, 1) - irit.box(
((-2), (-1), (-0.5)), 1.75, 2, 1) - irit.box(
(0.25, (-1), (-0.5)), 1.75, 2, 1) - irit.box(
((-0.5), 0, (-1)), 1, 2, 2))
irit.attrib(stick3, "rgb", irit.GenStrObject("255, 0, 100"))
stick4 = stick3 * irit.ry(180)
irit.attrib(stick4, "rgb", irit.GenStrObject("255, 100, 100"))
stick5 = (irit.box((0, (-3), (-0.5)), 1, 6, 1) - irit.box((0.5, (-2), (-1)),
(-1), 4, 2))
s1 = irit.sphere((0.2, 0.2, 0.8), 0.18)
irit.color(s1, irit.YELLOW)
s2 = irit.sphere((0.75, 0.25, 0.16667), 0.12) * irit.sz(3)
irit.color(s2, irit.MAGENTA)
c1 = irit.maxedgelen( irit.triangl( irit.cylin( ( 0.15, 0.85, 0.01 ), ( 0, 0, 0.98 ), 0.1, 3 ), 1 ),\
0.2 )
irit.color(c1, irit.CYAN)
c2 = irit.maxedgelen( irit.triangl( irit.cylin( ( 0.85, 0.85, 0.01 ), ( 0, 0, 0.98 ), 0.1, 3 ), 1 ),\
0.2 )
irit.color(c2, irit.CYAN)
genie = irit.list( teapotorig * irit.sc( 0.15 ) * irit.ry( (-90 ) ) * irit.trans( ( 0.5, 0.4, 0.47 ) ), s1, s2, c1,\
c2 )
b = irit.box((0, 0, 0), 1, 1, 1)
irit.attrib(b, "transp", irit.GenRealObject(0.5))
irit.interact(irit.list(irit.GetAxes(), b, genie))
wgenie = warpobj(genie, tv)
irit.interact(irit.list(teapot, wgenie, tv))
irit.save("genitpot", irit.list(teapot, wgenie, tv))
# ############################################################################
irit.SetViewMatrix(save_mat2)
irit.SetResolution(save_res)
irit.free(teapotorig)
irit.snoc(p * irit.tx(0), retval)
i = i + 1
retval = irit.mergepoly(retval)
return retval
# ############################################################################
t = irit.time(1)
save_mat = irit.GetViewMatrix()
save_res = irit.GetResolution()
irit.SetResolution(12)
b1 = irit.box(((-0.5), (-0.2), 0), 1, 0.4, 0.15)
b1 = putrgbonvertices(b1, irit.GenStrObject("255,255,0"))
b2 = irit.box(((-0.25), (-0.3), 0.1), 0.5, 0.6, 0.5)
b2 = putrgbonvertices(b2, irit.GenStrObject("0,255,0"))
m1 = (b1 - b2)
irit.free(b1)
irit.free(b2)
irit.interact(irit.list(irit.GetViewMatrix(), m1))
c1 = irit.sphere((0, 0, 0.2), 0.18)
c1 = putrgbonvertices(c1, irit.GenStrObject("0,255,255"))
irit.view(c1, irit.OFF)
m2 = (m1 - c1)
retval = 1
else:
retval = x * factor(x - 1)
return retval
#
# Interact with Axes(), possible in a middle of expression (returns o).
#
def aint(o):
irit.interact(irit.list(o, irit.GetAxes()))
retval = o
return retval
b = irit.box(((-3), (-2), (-1)), 6, 4, 2)
t = 3.14
irit.save( "functn1", irit.list( irit.GenRealObject(math.sqrt( irit.sqr( t * 3.14 ) )) , \
irit.GenRealObject(irit.sqr( 2 )), \
irit.GenRealObject(irit.sqr( 2 ) + irit.sqr( 2 )), \
irit.GenRealObject(factor( 3 )), \
irit.GenRealObject(factor( 10 )), \
irit.GenRealObject(factor( 15 )), \
aint( b ), \
aint( irit.cone( ( 0, 0, (-1 ) ), ( 0, 0, 4 ), 2, 1 ) ) ) )
irit.free(b)
# import math import irit # # # A test of intersection of two cubes. Assumes double precision floating point. # # Gershon Elber, April 94. # length = 1 angle = 10 b1 = irit.box( ( (-length )/2.0, (-length )/2.0, (-length )/2.0 ), length, length, length ) b2 = irit.box( ( 0, (-length )/2.0, (-length )/2.0 ), length, length, length ) * irit.rotx( angle ) irit.attrib( b1, "width", irit.GenRealObject(0.0001 )) irit.attrib( b2, "width", irit.GenRealObject(0.0001 )) b12a = b1 * b2 irit.attrib( b12a, "width", irit.GenRealObject(0.01) ) irit.interact( b12a ) angle = 1 b1 = irit.box( ( (-length )/2.0, (-length )/2.0, (-length )/2.0 ), length, length, length ) b2 = irit.box( ( 0, (-length )/2.0, (-length )/2.0 ), length, length, length ) * irit.rotx( angle ) irit.attrib( b1, "width", irit.GenRealObject(0.0001 )) irit.attrib( b2, "width", irit.GenRealObject(0.0001 )) b12b = b1 * b2 irit.attrib( b12b, "width", irit.GenRealObject(0.01 )) irit.interact( b12b )
irit.free(prof3a)
irit.free(prof4)
irit.free(prof4a)
leg1 = irit.surfrev(cross1 * irit.ry((-90)))
leg2 = irit.surfrev(cross2 * irit.ry((-90)))
irit.free(cross1)
irit.free(cross2)
legs = irit.list(leg1, leg1 * irit.tx(80), leg2 * irit.trans((0, 190, 0)),
leg2 * irit.trans((80, 190, 0)))
irit.attrib(legs, "rgb", irit.GenStrObject("244,164,96"))
irit.free(leg1)
irit.free(leg2)
skel = irit.list( irit.box( ( (-1 ), (-1 ), 25 ), 80, 2, 20 ),\
irit.box( ( (-1 ), (-1 ), 25 ), 2, 190, 20 ),\
irit.box( ( (-1 ), 189, 25 ), 80, 2, 20 ),\
irit.box( ( 79, (-1 ), 25 ), 2, 190, 20 ),\
irit.box( ( (-1 ), 90, 25 ), 80, 2, 20 ) )
irit.attrib(skel, "rgb", irit.GenStrObject("255,255,100"))
irit.viewobj(skel)
cover = irit.box((0, 0, 45), 80, 190, 1)
irit.attrib(cover, "rgb", irit.GenStrObject("244,164,96"))
backcross = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, 75 ), \
irit.ctlpt( irit.E3, 15, 0, 75 ), \
irit.ctlpt( irit.E3, 30, 0, 95 ), \
irit.ctlpt( irit.E3, 50, 0, 95 ), \
irit.ctlpt( irit.E3, 65, 0, 75 ), \
p = irit.coord( pl, i )
j = 0
while ( j <= irit.SizeOf( p ) - 1 ):
h = irit.pattrib( p, j, "hcurv", irit.nil( ) )
mean = mean + h
n = n + 1
j = j + 1
i = i + 1
retval = mean/float(n)
return retval
# ############################################################################
irit.SetResolution( 30 )
b1 = irit.box( ( (-0.3 ), (-0.3 ), 0 ), 0.6, 0.6, 0.15 )
c1 = irit.cylin( ( 0, 0, 0.1 ), ( 0, 0, 0.65 ), 0.14, 3 )
s1 = irit.sphere( ( 0, 0, 0.65 ), 0.3 )
t1 = irit.torus( ( 0, 0, 0.7 ), ( 0, 0, 1 ), 0.3, 0.15 )
obj = irit.maxedgelen( irit.triangl( b1 + c1 + s1 - t1, 1 ), 0.1 )
irit.free( b1 )
irit.free( c1 )
irit.free( s1 )
irit.free( t1 )
crvtrobj = irit.pcrvtr( obj, 1, 0 )
irit.free( obj )
crvtrobjrgb = gauss2rgb( crvtrobj, 15 )
# Simple (and not so simple) 3D puzzles animated using animation curves.
#
# Gershon Elber, January 1994
#
save_mat = irit.GetViewMatrix()
# ############################################################################
# StickStar
#
sqrt2 = math.sqrt(2)
eps = 0.015
rad = 0.3
len = (rad + eps) * 2
itemaux1 = irit.box(
((-rad) / sqrt2, (-rad) / sqrt2,
(-len)), rad * 2 / sqrt2, rad * 2 / sqrt2, len * 2) * irit.rz(45)
itemaux2 = (
itemaux1 * irit.tx(rad) - itemaux1 * irit.rotx(90) * irit.tz(rad + eps) -
itemaux1 * irit.rotx(90) * irit.tz((-rad) - eps)) * irit.tx(eps / 2)
diag = (len + eps)
diagpoly = irit.poly(
irit.list((diag, diag, 0), ((-diag), diag, 0), ((-diag), 0, diag),
(diag, 0, diag)), irit.FALSE)
item1 = (itemaux2 - diagpoly - diagpoly * irit.sy((-1)) - diagpoly * irit.sz(
(-1)) - diagpoly * irit.sz((-1)) * irit.sy((-1)))
item1 = irit.convex(item1)
irit.color(item1, irit.RED)
item2 = item1 * irit.sx((-1))
irit.color(item2, irit.MAGENTA)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Intersection of two boxes:
#
# Created by Gershon Elber, Jan. 89
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(save_mat * irit.scale((0.15, 0.15, 0.15)))
b1 = irit.box(((-3), (-2), (-1)), 6, 4, 2)
b2 = irit.box(((-4), (-3), (-2)), 2, 2, 4)
a1 = (b2 + b1)
irit.interact(irit.list(irit.GetViewMatrix(), a1))
a2 = b2 * b1
irit.interact(a2)
a3 = (b2 - b1)
irit.interact(a3)
a4 = (b1 - b2)
irit.interact(a4)
icrv = irit.iritstate("intercrv", irit.GenIntObject(1))
a5 = b2 * b1
irit.snoc(pt, ptl)
t = t + dt
retval = ptl
return retval
#
# Basic box shape.
#
# Top square bump
# Top feed
# Bottom Drawers
# Top Drawer
# Botton Step
# Back doors
base = (irit.box((0, 0, 0), 8, 5, 7) + irit.box(
(5.5, 0.5, 6), 2.25, 4, 1.5) - irit.box(
(6.8, 2, 7.35), 2, 1, 1) - irit.box(
(1, 0.5, 6), 4.4, 4, 1.5) - irit.box(
(0.4, (-0.1), (-0.1)), 6.9, 5, 3.075) - irit.box(
(3.5, (-0.1), 2.98), 3.8, 5, 1.5) - irit.box(
(7.6, 0.5, (-0.1)), 0.5, 3.7, 0.5) - irit.box(
(7.9, 0.51, (-0.1)), 1, 3.68, 6.5) - irit.box(
(0.01, (-0.11), 2.95), 7.98, 5, 0.05))
base = base / irit.box((0.6, 0.5, 1), 7, 4, 4) / irit.box(
(7.8, 0.6, 0.5), 1, 3.5, 5.8) / irit.box((0.1, 0.05, 0.05), 0.2, 4.9, 6.9)
tmpbody = irit.box((3, (-0.1), 6.1), 2, 0.2, 0.05)
z = 6.2
while (z <= 6.5):
