def textgeom3daux(ply, wdth, dpth):
retval = irit.nil()
if (irit.ThisObject(ply) == irit.CURVE_TYPE):
retval = irit.extrude((-ply), (0, 0, dpth), 0)
if (irit.ThisObject(ply) == irit.POLY_TYPE):
retval = irit.extrude(
irit.ruledsrf(
irit.offset(ply, irit.GenRealObject(-wdth / 2.0), 0, 0),
irit.offset(ply, irit.GenRealObject(wdth / 2.0), 0, 0)),
(0, 0, dpth), 3)
return retval
def offsetcrvlist( clst, ofst ):
retval = irit.nil( )
i = 1
while ( i <= irit.SizeOf( clst ) ):
irit.snoc( irit.offset( irit.nth( clst, i ), irit.GenRealObject(ofst), 1e-006, 1 ), retval )
i = i + 1
return retval
def cmpoffalltols(crv, fname, dist, tol, steps):
if (do_offset_compare):
irit.logfile(fname + "_" + "offset")
irit.logfile(1)
t = tol
irit.printf("# offset (%s)", irit.list(fname))
i = 0
while (i <= steps):
c = irit.offset(crv, dist, t, 0)
computeerror(crv, irit.abs(dist), c)
t = t * math.sqrt(0.1)
i = i + 1
irit.logfile(fname + "_" + "offseti")
irit.logfile(1)
t = tol
irit.printf("# offseti (%s)", irit.list(fname))
i = 0
while (i <= steps):
c = irit.offset(crv, dist, t, 1)
computeerror(crv, irit.abs(dist), c)
t = t * math.sqrt(0.1)
i = i + 1
t = tol
irit.printf("# aoffset (%s)", irit.list(fname))
irit.logfile(fname + "_" + "aoffset")
irit.logfile(1)
i = 0
while (i <= steps):
c = irit.aoffset(crv, dist, t, 0, 0)
computeerror(crv, irit.abs(dist), c)
t = t * math.sqrt(0.1)
i = i + 1
t = tol
irit.printf("# loffset (%s)", irit.list(fname))
irit.logfile(fname + "_" + "loffset")
irit.logfile(1)
i = 0
while (i <= steps):
c = irit.offset(crv, dist, t, 1)
c = irit.loffset(crv, dist, 300, irit.SizeOf(c), 4)
computeerror(crv, irit.abs(dist), c)
t = t * math.sqrt(0.1)
i = i + 1
irit.logfile(0)
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 cmpoffalltols(crv, header, fname, dist, tol, steps):
i = 0
while (i <= steps):
irit.printf("\n\n%s: tolerance = %lf, dist = %lf",
irit.list(header, tol, dist))
c1 = irit.offset(crv, irit.GenRealObject(dist), tol, 0)
c2 = irit.offset(crv, irit.GenRealObject(dist), tol, 1)
c3 = irit.aoffset(crv, irit.GenRealObject(dist), tol, 0, 0)
c4 = irit.loffset(crv, dist, 300, irit.SizeOf(c2), 4)
irit.attrib(c1, "dash", irit.GenStrObject("[0.1 0.01] 0"))
irit.color(c1, irit.RED)
irit.attrib(c2, "dash", irit.GenStrObject("[0.01 0.01] 0"))
irit.color(c2, irit.GREEN)
irit.attrib(c3, "dash", irit.GenStrObject("[0.2 0.01 0.05 0.01] 0"))
irit.color(c3, irit.YELLOW)
irit.attrib(c4, "dash", irit.GenStrObject("[0.1 0.1 0.01 0.01] 0"))
irit.color(c4, irit.CYAN)
irit.save(fname + "_" + str(i + 1), irit.list(crv, c1, c2, c3, c4))
compareoffset(crv, abs(dist), c1, c2, c3, c4)
tol = tol * math.sqrt(0.1)
i = i + 1
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
def buildoffsetvisibilitymap( c, step, ofst ):
retval = irit.nil( )
co = irit.offset( c, irit.GenRealObject(ofst), 1e-006, 1 )
tmin = irit.nth( irit.pdomain( co ), 1 )
tmax = irit.nth( irit.pdomain( co ), 2 )
t = tmin
while ( t <= tmax ):
pt = irit.coerce( irit.ceval( co, irit.FetchRealObject(t) ), irit.POINT_TYPE ) * \
irit.tz( 1 )
crvs = irit.cvisible( c, irit.Fetch3TupleObject(pt) , 1e-005 )
crvdmn = cnvrtcrvs2domains( crvs, t )
irit.attrib( crvdmn, "width", irit.GenRealObject(0.01) )
irit.attrib( crvdmn, "gray", irit.GenRealObject(0.5) )
irit.attrib( crvdmn, "rgb", irit.GenStrObject("128, 128, 255" ))
irit.snoc( crvdmn, retval )
t = t + step
return retval
trns = irit.trans(((-7.95), 0, (-4.18)))
irit.attrib(backdoor2, "animation", irit.list(trns, rot_y, trns ^ (-1)))
irit.free(rot_y)
irit.free(trns)
#
# Front door
#
frontdoor = irit.poly(
irit.list((0, 0.1, 1), (0, 0.4, 1), irit.point(0, 0.4, 1.3),
irit.point(0, 4.6, 1.3), irit.point(0, 4.6, 1),
irit.point(0, 4.9, 1), irit.point(0, 4.9, 6.5),
irit.point(0, 0.1, 6.5)), irit.FALSE)
base = base / irit.extrude(frontdoor * irit.tx((-0.1)), (0.25, 0, 0), 3)
frontdoor = irit.extrude(
irit.offset(frontdoor * irit.ry(90), irit.GenRealObject(0.05), 0.1, 0) *
irit.ry((-90)), (0.03, 0, 0), 3)
tmpbody = irit.box(((-0.1), 1, 4), 1, 3, 1)
y = 1
while (y <= 4):
tmpbody = tmpbody ^ irit.box(((-0.1), y, 2), 1, 0.07, 1)
y = y + 0.2
frontdoor = frontdoor / tmpbody
frontdoor = irit.list( frontdoor + irit.box( ( 0.01, 2, 5.5 ), 0.3, 1, 0.4 ) - irit.box( ( (-0.1 ), 2.1, 5.55 ), 0.3, 0.8, 0.3 ),\
irit.box( ( 0, 2.12, 5.7 ), 0.02, 0.76, 0.13 ) )
#
# Front tray
irit.interact(irit.list(p, irit.GetAxes()))
irit.viewstate("drawvnrml", 0)
#
# reverse surface ( flip normals ).
#
q = irit.gpolygon((-sb), 1)
if (display == 1):
irit.viewstate("drawvnrml", 1)
irit.interact(irit.list(q, irit.GetAxes()))
irit.viewstate("drawvnrml", 0)
#
# Offset approximation by translation of srf/crv in normal direction.
#
cbo = irit.offset(cb, irit.GenRealObject(0.1), 0.1, 0)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), cb, cbo))
sbo = irit.offset(sb, irit.GenRealObject(0.2), 0.1, 0)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), sb, sbo))
#
# Surface and Curve evaluation.
#
irit.save(
"bezier2",
irit.list(irit.ceval(cb, 0), irit.ceval(cb, 0.1), irit.ceval(cb, 0.3),
irit.ceval(cb, 0.5), irit.ceval(cb, 0.9), irit.ceval(cb, 1),
step = 0.01
ofst = -0.01
j = 1
while ( j <= irit.SizeOf( crvs ) ):
c = irit.coerce( irit.nth( crvs, j ), irit.KV_OPEN )
irit.attrib( c, "rgb", irit.GenStrObject("0,255,128") )
irit.attrib( c, "gray", irit.GenRealObject(0.5) )
irit.awidth( c, 0.02 )
co = irit.offset( c, irit.GenRealObject(ofst), 0.001, 1 )
dms = buildoffsetvisibilitymap( c, step, ofst )
irit.attrib( dms, "rgb", irit.GenStrObject("128, 128, 255" ))
views = computeviews( c, dms, "" )
viewptcurves = irit.nil( )
i = 1
while ( i <= irit.SizeOf( views ) ):
t = irit.FetchRealObject(irit.nth( views, i ) * step)
pt = irit.coerce( irit.ceval( co, t ), irit.POINT_TYPE ) * irit.tz( 1 )
v = offsetcrvlist( irit.cvisible( c, irit.Fetch3TupleObject(pt), 0.0001 ), 1/100.0 + i/130 )
irit.attrib( v, "dash", irit.nth( dashlist, i ) )
irit.awidth( v, 0.009 )
rgb = randrgb( )
pt = pt * irit.sz( 0.01 )
irit.attrib( v, "rgb", irit.GenStrObject(rgb ))
irit.attrib( pt, "rgb", irit.GenStrObject(rgb ))
irit.color(ns, irit.GREEN)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), s, ns))
irit.save("nrml2srf", irit.list(irit.GetAxes(), s, ns, dus, dvs))
#
# Compute two surfaces, one is an offset approximation to the surface and
# the other is just a translation. Then compute the distance square scalar
# surface between them and the original surface. With the data below both
# Should have a distance square of 3 (if exact, the offset is obviously not).
#
s1 = s * irit.trans((1, (-1), 1))
irit.color(s1, irit.GREEN)
s2 = irit.offset(s, irit.GenRealObject(math.sqrt(3)), 1, 0)
irit.color(s2, irit.YELLOW)
dlevel = irit.iritstate("dumplevel", irit.GenRealObject(255))
distsqr1 = irit.symbdprod(irit.symbdiff(s, s1), irit.symbdiff(s, s1))
distsqr2 = irit.symbdprod(irit.symbdiff(s, s2), irit.symbdiff(s, s2))
dlevel = irit.iritstate("dumplevel", dlevel)
irit.save("dist1sqr", irit.list(distsqr1, distsqr2))
irit.free(s)
irit.free(s1)
irit.free(s2)
irit.free(distsqr1)
irit.free(distsqr2)
s2 = subdivtodepth(tsrf1a, 8, irit.vector(0, 0.01, 0), irit.vector(0.01, 0, 0))
irit.interact(s2)
irit.save("trimsrf5", irit.list(s1, s2))
s1 = subdivtodepth(tsrf3a, 4, irit.vector(0, 0.04, 0), irit.vector(0.02, 0, 0))
irit.interact(s1)
s2 = subdivtodepth(tsrf3a, 8, irit.vector(0, 0.01, 0),
irit.vector(0.005, 0, 0))
irit.interact(s2)
irit.save("trimsrf6", irit.list(s1, s2))
offtsrf3a = irit.offset(tsrf3a, irit.GenRealObject(0.3), 1, 0)
irit.interact(irit.list(offtsrf3a, tsrf3a))
irit.save(
"trimsrf7",
irit.list(offtsrf3a, tsrf3a, irit.seval(tsrf1a, 0.5, 0.5),
irit.stangent(tsrf1a, irit.ROW, 0.5, 0.5, 1),
irit.stangent(tsrf1a, irit.COL, 0.5, 0.5, 1),
irit.snormal(tsrf1a, 0.5, 0.5), irit.seval(tsrf3a, 0.5, 0.5),
irit.stangent(tsrf3a, irit.ROW, 0.5, 0.5, 1),
irit.stangent(tsrf3a, irit.COL, 0.5, 0.5, 1),
irit.snormal(tsrf3a, 0.5, 0.5)))
irit.interact(irit.strimsrf(tsrf1a))
irit.interact(irit.ctrimsrf(tsrf1a, 1))
irit.interact(irit.ctrimsrf(tsrf3a, 0))
irit.viewstate( "pllnaprx", 1 )
irit.viewstate( "pllnaprx", 1 )
# ############################################################################
c0 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, (-1 ), 3 ), \
irit.ctlpt( irit.E2, (-0.3 ), 0 ), \
irit.ctlpt( irit.E2, 0.3, 0 ), \
irit.ctlpt( irit.E2, 1, 3 ) ), irit.list( irit.KV_OPEN ) )
irit.view( c0, irit.ON )
i = (-5 )
while ( i <= 5 ):
if ( i != 0 ):
ofst = 0.15 * i
ofsttrim = abs( ofst ) * 0.999
co = irit.offset( c0, irit.GenRealObject(ofst), 0.0001, 0 )
none = irit.toffset( c0, co, irit.list( 1, 15, ofsttrim, 0.001 ) )
irit.color( none, i + 6 )
irit.viewobj( none )
i = i + 1
c0off1 = none * irit.tx( 0 )
irit.pause( )
irit.view( c0, irit.ON )
i = (-5 )
while ( i <= 5 ):
if ( i != 0 ):
ofst = 0.15 * i
ofsttrim = abs( ofst ) * 0.99
co = irit.offset( c0, irit.GenRealObject(ofst), 0.001, 0 )
none = irit.toffset( c0, co, irit.list( 2, 0.01, ofsttrim, 1e-008 ) )
irit.free( dms )
irit.free( crvsdm )
irit.free( vdir )
irit.free( crvse3 )
# ############################################################################
#
# View point almost on the boundary from inside (art gallery guards)
#
res = irit.nil( )
i = 1
while ( i <= irit.SizeOf( crvs ) ):
c = irit.nth( crvs, i )
co = irit.offset( c, irit.GenRealObject(-0.0001 ), 1e-006, 0 )
tmin = irit.FetchRealObject( irit.nth( irit.pdomain( co ), 1 ) )
tmax = irit.FetchRealObject( irit.nth( irit.pdomain( co ), 2 ) )
dt = 0.06
t = tmin
while ( t <= tmax ):
pt = irit.coerce( irit.ceval( co, t ), irit.POINT_TYPE )
irit.adwidth( pt, 3 )
irit.color( pt, irit.CYAN )
vc = irit.cvisible( c, irit.Fetch3TupleObject( pt * irit.tz( 1 ) ), 1e-005 )
irit.adwidth( vc, 3 )
irit.color( vc, irit.YELLOW )
if ( t == 0.12 or t == 0.36 or t == 0.6 or t == 0.84 ):
irit.snoc( irit.list( pt, vc, c ) * irit.ty( i * 1.6 ) * irit.tx( t * 7 ), res )
irit.view( irit.list( pt, vc, c ), irit.ON )
t = t + dt
irit.ctlpt( irit.E3, 1, (-0.5 ), 0.1 ), \
irit.ctlpt( irit.E3, 1, (-0.2 ), 0.2 ), \
irit.ctlpt( irit.E3, 1.1, 0.3, 0 ), \
irit.ctlpt( irit.E3, 1, 0.6, 0.1 ), \
irit.ctlpt( irit.E3, 0.9, 1, 0 ) ), irit.list( irit.KV_OPEN ) )
s2 = irit.sfromcrvs( irit.list( c1, c2, c3, c4, c5 ), 3,\
irit.KV_OPEN )
ref_knots = irit.list( 0.2, 0.2667, 0.4, 0.4667, 0.5333, 0.6,\
0.7333, 0.8 )
s2r = irit.srefine( irit.srefine( s2, irit.ROW, 0, ref_knots ), irit.COL, 0,\
ref_knots )
irit.free(ref_knots)
s2o = irit.offset(s2r, irit.GenRealObject(0.3), 10, 0)
irit.color(s2o, irit.GREEN)
irit.SetResolution(20)
#
# Computing self intersection by a Boolean operation with itself - Parametric.
#
dummy = irit.iritstate("intercrv", irit.GenRealObject(1))
dummy = irit.iritstate("uvboolean", irit.GenRealObject(1))
s2ointer = (s2o + s2o)
irit.color(s2ointer, irit.RED)
irit.attrib(s2ointer, "dwidth", irit.GenRealObject(3))
paramdomain = irit.poly(irit.list((0, 0, 0), (0, 1, 0), (1, 1, 0), (1, 0, 0)),
irit.FALSE)
minsize = 0.01
body = irit.sfromcrvs( irit.list( c2 * irit.sc( minsize ) * irit.tz( 0.05 ), c2 * irit.sc( 0.7 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.8 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.9 ), c2, c2 * irit.tz( 2 ), c2 * irit.tz( 2.2 ), c1 * irit.tz( 2.2 ), c1 * irit.tz( 2 ), c1 * irit.tz( 0.4 ), c1 * irit.sc( 0.5 ) * irit.tz( 0.2 ), c1 * irit.sc( minsize ) * irit.tz( 0.2 ) ), 3, irit.KV_OPEN )
handaxis = irit.crefine( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0.3, 0, 0.1 ), \
irit.ctlpt( irit.E3, 0.5, 0, 0.5 ), \
irit.ctlpt( irit.E3, 0.5, 0, 0.8 ), \
irit.ctlpt( irit.E3, 0, 0, 0.8 ) ), irit.list( irit.KV_OPEN ) ), 0, irit.list( 0.1, 0.23, 0.43, 0.57 ) )
handle = irit.swpsclsrf( c1 * irit.sx( 0.7 ), handaxis * irit.sc( 1.5 ), irit.GenRealObject(0.15), irit.list( 0, 1, 0 ), 1 ) * irit.trans( ( 1, 0, 0.4 ) )
cup = irit.list( body, handle )
irit.color( cup, irit.WHITE )
irit.save( "cup", cup )
irit.interact( cup )
bodyin = irit.sregion( body, irit.ROW, 0.6, 1 )
irit.color( bodyin, irit.RED )
bodyout = irit.sregion( body, irit.ROW, 0, 0.6 )
irit.color( bodyout, irit.GREEN )
irit.interact( irit.list( bodyout, bodyin ) )
handleout = handle
irit.color( handleout, irit.RED )
handlein = irit.offset( handleout, irit.GenRealObject(0.05), 0.05, 0 )
irit.color( handlein, irit.GREEN )
irit.interact( irit.list( handleout, handlein ) )
createcubicbezier(349, 234, 349, 214, 429, 194) +
createcubicbezier(429, 194, 509, 174, 409, 194) +
createcubicbezier(409, 194, 309, 214, 309, 234) +
createcubicbezier(309, 234, 309, 254, 369, 264) +
createcubicbezier(369, 264, 429, 274, 429, 294) +
createcubicbezier(429, 294, 429, 314, 359, 334) +
createcubicbezier(359, 334, 289, 354, 379, 334))
c3p = irit.cnvrtcrvtopolygon((-c3), 128, 0)
irit.free(c3)
t1 = irit.poly( irit.list( ( 354, 359, 0 ),
( 439, 359, 0 ),
( 379, 479, 0 ),
( 314, 349, 0 ) ), irit.TRUE ) * \
irit.sc( 0.001 )
t2 = irit.offset(t1, irit.GenRealObject(0.0065), 0, 0)
t3 = irit.offset(t1, irit.GenRealObject(-0.0065), 0, 0)
techlist = irit.nil()
i = 0
while (i <= irit.SizeOf(t2) - 1):
irit.snoc(irit.coord(t2, i), techlist)
i = i + 1
i = irit.SizeOf(t3) - 1
while (i >= 0):
irit.snoc(irit.coord(t3, i), techlist)
i = i + (-1)
tech = irit.poly(techlist, irit.FALSE)
irit.free(t1)
irit.free(t2)
irit.free(t3)
def outlinechar(char):
ochar = irit.offset(char, irit.GenRealObject(-0.02), 0, 0)
retval = (irit.extrude(char, (0, 0, 1), 3) -
irit.extrude(ochar, (0, 0, 1.2), 3) * irit.tz((-0.1)))
return retval
irit.free(crv1a)
irit.free(crv2a)
irit.free(crv1b)
irit.free(crv2b)
# ############################################################################
crv = irit.cbezier( irit.list( irit.ctlpt( irit.E1, (-0.2 ) ), \
irit.ctlpt( irit.E2, 0.25, 1.2 ), \
irit.ctlpt( irit.E2, 0.75, 0.7 ), \
irit.ctlpt( irit.E2, 1.3, 0.05 ) ) )
crv1 = (-crv)
crv2a = irit.offset(crv1, irit.GenRealObject((-0.8)), 1, 0)
crv2b = irit.offset(crv1, irit.GenRealObject((-0.18)), 1, 0)
irit.save(
"dist2ff3",
irit.list(testccdistfunc(crv1, crv2a, irit.nil()),
testccdistfunc(crv1, crv2a, irit.list(0.5)),
testccdistfunc(crv1, crv2b, irit.nil()),
testccdistfunc(crv1, crv2b, irit.list(0.5))))
irit.free(crv)
irit.free(crv1)
irit.free(crv2a)
irit.free(crv2b)
# ############################################################################
#
# Few examples of text warping through surfaces using the textwarp function.
#
# Gershon Elber, Jan 2003.
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-2 ), 0 ), \
irit.ctlpt( irit.E2, (-1 ), 1 ), \
irit.ctlpt( irit.E2, 0, (-1 ) ), \
irit.ctlpt( irit.E2, 1, 0 ) ) )
c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E1, (-0 ) ), \
irit.ctlpt( irit.E1, (-1.8 ) ), \
irit.ctlpt( irit.E1, (-0 ) ) ) )
s1 = irit.sreparam( irit.ruledsrf( c1, irit.offset( c1, irit.GenRealObject(-0.4 ), 0.02, 0 ) ), irit.COL, 0,\
6 )
irit.color( s1, irit.RED )
t1 = irit.textwarp( s1, "computer graphics", 0.09, 0.25, 0.75, 0 )
irit.color( t1, irit.CYAN )
irit.adwidth( t1, 2 )
irit.interact( irit.list( t1, s1 ) )
t1 = irit.textwarp( s1, "computer graphics", 0.1, 0.25, 0.75, 1 )
irit.color( t1, irit.CYAN )
irit.adwidth( t1, 2 )
irit.interact( irit.list( t1, s1 ) )
s2 = irit.sreparam( irit.ruledsrf( c1, irit.offset( c1, c2, 0.01, 0 ) ), irit.COL, 0,\
6 )
