¶ñXíä(™€:¬èYŽ'û Ý'î,Dª„ß)(ÏîÙ1ÿÊËaïÚˆÞîE¦›‹æŒ)è[ÿ¿L7ƒ("’оG×Q>3fÊè‰ A“×ó«ò<ðYàÌëž6U X¤Ca
ÑÇ%¬€}V…êÃ
ͳ ¼¶ìz}»^Aïú'L7EJsÆôv/Äü“M7…ÄÄ)XÏ2Kù°áà&l8°I°E0ÈÄ4šEAø[<¸òÚ ®Áµç_“ysL°ï凱oÏ×R;_³U¡x|š”^@ ËV,l~R¸-m •ÉçœfVô.gº½ ¬Zÿ$ BF)„ÄG. a„˜h%5ô7´Þ¯ï* èÎÍ7¤6|ÚòIñSšAHatÍŸCöAa4Ô™7>
•ÍrĨg±èé^Øþºjý“èÛõ
úv½œÛõ)„¤ÃÔÑñ˜d›Ü%C¤¬½)†‰&‘×Xažø±¡ÒG• ’fÏ:”RJB%" ~-¸/ôõ{ÖÁ‰j„Šj}2êY.V2³¨(¥“ôyùÄ«ø »õê•1ЩKœ_Ü÷_~geû¦1|Zò¹ðú»±ðº»Ÿ§êT"êç‰ÍÑÐ$…êEòɨgùèé^ØŽŽ¦%£OBŠ‡ªœQT+* iÈg K)%¡’P7þh¨n$Ô/Ÿsš] Ý^!âô¥t’q# DÌÿ½z½é&dF’hùdÿÎøT^@àHyÕBõþBó,(_mÂd”ÒIˆþì'ݦ›P( A☧x&§êàÑ( uË'£žõüDé$Ä,Ðô €z‰#ŸÏô¨d Pîé<æìtË'£žõ¤§{!zL7‚BH&èÊ'Å3}J9RÜÓyʦÒ<‚CœF“BŠ gBJF
žßàQ½yàu¦Öœ|Ù<<¶ñXíg-Ê‚ZE@Ý8ÑÐ5½zj„ À^F= !¤08æd…KT‡´çE¤\VØ>5Ð)0ÏRJÙS»¨›=˱×~Ÿê½ paóF= !¤@L séÐ+;d‰Ø\Ö( Ö=Uå¦õ ˆŽ€ªÊç}lÂcQ>s ¶P7Ëz>ƒe=Ÿ1Ý B!±ˆ’,Wx´´>–¬á ‘¯ QòÉþf €B),î^ü,{RëL#¿oÆ|mß׺&ŸO³P@ !„”s]@‹o*›ZÑ)8اx
(!„Â2uôDì9þËÈýÊ<ý¦ŒbkoqõÉ'ųXP@ !„ÔJ]õñËçäËæá¾û7lA%„BH%pË'ųØP@ !„–©c&L·‚™Ám :³Ý÷À&¦ÙK ”B©8SÇT{Òþ·.ÃMŸ[Nñ,–mÛìC!¤°lݽÍtJÏìËg™nBf ÝŽ±g^eºD
(!„BÉ•ZOÅI!„Bò‡J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Br…J!„Brå?xï4·ø tc IEND®B`‚ rgl/man/play3d.Rd 0000644 0001762 0000144 00000012031 14146472047 013302 0 ustar ligges users \name{play3d}
\alias{play3d}
\alias{movie3d}
\title{ Play animation of RGL scene }
\description{
\code{play3d} calls a function repeatedly, passing it the elapsed
time in seconds, and using the result of the function to
reset the viewpoint. \code{movie3d} does the same, but
records each frame to a file to make a movie.
}
\usage{
play3d(f, duration = Inf, dev = cur3d(), ..., startTime = 0)
movie3d(f, duration, dev = cur3d(), ..., fps = 10,
movie = "movie", frames = movie, dir = tempdir(),
convert = NULL, clean = TRUE, verbose = TRUE,
top = !rgl.useNULL(), type = "gif", startTime = 0,
webshot = TRUE)
}
\arguments{
\item{f}{ A function returning a list that may be passed to \code{\link{par3d}} }
\item{duration}{ The duration of the animation }
\item{dev}{ Which RGL device to select }
\item{\dots}{ Additional parameters to pass to \code{f}. }
\item{startTime}{ Initial time at which to start the animation }
\item{fps}{ Number of frames per second }
\item{movie}{ The base of the output filename, not including .gif }
\item{frames}{ The base of the name for each frame }
\item{dir}{ A directory in which to create temporary files for each frame of the movie }
\item{convert}{ How to convert to a GIF movie; see Details }
\item{clean}{ If \code{convert} is \code{NULL} or \code{TRUE}, whether to delete the individual frames }
\item{verbose}{ Whether to report the \code{convert} command and the output filename }
\item{top}{ Whether to call \code{\link{rgl.bringtotop}} before each frame }
\item{type}{ What type of movie to create. See Details. }
\item{webshot}{ Whether to use the \pkg{webshot2} package
for snapshots of frames. See \code{\link{snapshot3d}}.}
}
\details{
The function \code{f} will be called in a loop with the first argument
being the \code{startTime} plus the time in seconds since the start
(where the start is measured after all arguments have been evaluated).
\code{play3d} is likely to place a high load
on the CPU; if this is a problem, calls to \code{\link{Sys.sleep}}
should be made within the function to release time to other processes.
\code{play3d} will run for the specified \code{duration} (in seconds), but
can be interrupted by pressing \code{ESC} while the RGL window has the focus.
\code{movie3d} saves each frame to disk in a filename of the form \file{framesXXX.png}, where
XXX is the frame number, starting from 0.
If \code{convert} is \code{NULL} (the default) and the
\pkg{\link[magick]{magick}} package is installed, it will be used
to convert the frames to a GIF movie (or other format if supported). If
\pkg{\link[magick]{magick}} is not installed or
\code{convert} is \code{TRUE}, \code{movie3d} will attempt
to use the external \command{ImageMagick} program to convert the
frames to a movie.
The newer \command{magick} executable is tried
first, then \command{convert} if that fails.
The \code{type} argument will be passed to \command{ImageMagick} to use as a file extension
to choose the file type.
Finally, \code{convert} can be a template for a command to
execute in the standard shell (wildcards are allowed). The template is
converted to a command using \cr
\code{\link{sprintf}(convert, fps, frames, movie, type, duration, dir)} \cr
For example, \code{convert = TRUE}
uses the template \code{"magick -delay 1x\%d \%s*.png \%s.\%s"}. All work
is done in the directory \code{dir}, so paths should not be needed in
the command. (Note that \code{\link{sprintf}} does not require all
arguments to be used, and supports formats that use them in an
arbitrary order.)
The \code{top = TRUE} default is designed to work around an OpenGL limitation:
in some implementations, \code{\link{rgl.snapshot}} will fail if the window
is not topmost.
As of \pkg{rgl} version 0.94, the \code{dev} argument is not needed: the
function \code{f} can specify its device, as \code{\link{spin3d}} does,
for example. However, if \code{dev} is specified, it will be selected
as the current device as each update is played.
As of \pkg{rgl} version 0.95.1476, \code{f} can
include multiple values in a \code{"subscene"}
component, and \code{par3d()} will be called
for each of them.
}
\value{
\code{play3d} is called for the side effect of its repeated calls to \code{f}.
It returns \code{NULL} invisibly.
\code{movie3d} is also normally called for the side effect
of producing the output movie. It invisibly returns
}
\author{ Duncan Murdoch, based on code by Michael Friendly }
\seealso{ \code{\link{spin3d}} and \code{\link{par3dinterp}} return functions suitable
to use as \code{f}. See \code{demo(flag)} for an example that modifies the
scene in \code{f}.}
\examples{
open3d()
plot3d( cube3d(col = "green") )
M <- par3d("userMatrix")
if (!rgl.useNULL())
play3d( par3dinterp(time = (0:2)*0.5, userMatrix = list(M,
rotate3d(M, pi/2, 1, 0, 0),
rotate3d(M, pi/2, 0, 1, 0) ) ),
duration = 2 )
\dontrun{
movie3d( spin3d(), duration = 5 )
}
}
\keyword{ dplot }
rgl/man/spin3d.Rd 0000644 0001762 0000144 00000004121 14100762641 013277 0 ustar ligges users \name{spin3d}
\alias{spin3d}
\title{ Create a function to spin a scene at a fixed rate }
\description{
This creates a function to use with \code{\link{play3d}} to
spin an RGL scene at a fixed rate.
}
\usage{
spin3d(axis = c(0, 0, 1), rpm = 5,
dev = cur3d(), subscene = par3d("listeners", dev = dev))
}
\arguments{
\item{axis}{ The desired axis of rotation }
\item{rpm}{ The rotation speed in rotations per minute }
\item{dev}{ Which RGL device to use }
\item{subscene}{ Which subscene to use }
}
\value{
A function with header \code{function(time, base = M)}, where \code{M}
is the result of \code{par3d("userMatrix")} at the time the function
is created. This function
calculates and returns a list containing \code{userMatrix} updated by
spinning the base matrix for \code{time} seconds at \code{rpm} revolutions per
minute about the specified \code{axis}.
}
\note{
Prior to \pkg{rgl} version 0.95.1476, the
\code{subscene} argument defaulted to the
current subscene, and any additional entries would
be ignored by \code{\link{play3d}}. The current
default value of \code{par3d("listeners", dev = dev)} means that all subscenes that share
mouse responses will also share modifications
by this function.
}
\author{ Duncan Murdoch }
\seealso{ \code{\link{play3d}} to play the animation }
\examples{
# Spin one object
open3d()
plot3d(oh3d(col = "lightblue", alpha = 0.5))
if (!rgl.useNULL())
play3d(spin3d(axis = c(1, 0, 0), rpm = 30), duration = 2)
# Show spinning sprites, and rotate the whole view
open3d()
spriteid <- NULL
spin1 <- spin3d(rpm = 4.5 ) # the scene spinner
spin2 <- spin3d(rpm = 9 ) # the sprite spinner
f <- function(time) {
par3d(skipRedraw = TRUE) # stops intermediate redraws
on.exit(par3d(skipRedraw = FALSE)) # redraw at the end
pop3d(id = spriteid) # delete the old sprite
cubeid <- shade3d(cube3d(), col = "red")
spriteid <<- sprites3d(0:1, 0:1, 0:1, shape = cubeid,
userMatrix = spin2(time,
base = spin1(time)$userMatrix)$userMatrix)
spin1(time)
}
if (!rgl.useNULL())
play3d(f, duration = 2)
}
\keyword{ dplot }
rgl/man/rgl.open.Rd 0000644 0001762 0000144 00000006517 14100762641 013636 0 ustar ligges users \name{rgl.open}
\title{Low level window interface}
\alias{rgl.open}
\alias{rgl.close}
\alias{rgl.cur}
\alias{rgl.set}
\alias{rgl.quit}
\alias{rgl.antialias}
\alias{rgl.dev.list}
\description{
3D real-time rendering system.
}
\usage{
rgl.open(useNULL = rgl.useNULL()) # open new device
rgl.close() # close current device
rgl.cur() # returns active device ID
rgl.dev.list() # returns all device IDs
rgl.set(which, silent = FALSE) # set device as active
rgl.quit() # shutdown RGL device system
}
\arguments{
\item{useNULL}{whether to open the \dQuote{null} device}
\item{which}{device ID}
\item{silent}{whether to suppress update of window titles}
}
\details{
The RGL device design is oriented towards the R device metaphor. If you send
scene management instructions, and there's no device open, it will be opened
automatically.
Opened devices automatically get the current device focus. The focus may be
changed by using \code{rgl.set()}.
\code{rgl.quit()} shuts down the RGL subsystem and all open devices,
detaches the package including the shared library and additional system libraries.
The \code{rgl.open()} function attempts to open a new RGL window.
If the \code{"rgl.antialias"} option is set, it will be used to
select the requested antialiasing. (See \code{\link{open3d}} for
more description of antialiasing and an alternative way to set the
value.)
If \code{useNULL} is \code{TRUE}, RGL will use a \dQuote{null}
device. This device records objects as they are plotted, but
displays nothing. It is intended for use with \code{\link{rglwidget}}
and similar functions.
If \code{rgl.open()} fails (e.g. because X windows is not running, or its
\code{DISPLAY} variable is not set properly), then you can retry the initialization
by calling \code{\link{rgl.init}()}. Do not do this when windows have
already been successfully opened: they will be orphaned, with no way to
remove them other than closing R. In fact, it's probably a good idea not to do this
at all: quitting R and restarting it is a better solution.
This package also includes a higher level interface which is described
in the \link{r3d} help topic. That interface is designed to act more like
classic 2D R graphics. We recommend that you avoid mixing
\code{rgl.*} and \code{*3d} calls.
}
\value{
\code{rgl.open}, \code{rgl.close} and \code{rgl.set} are called for their side effects
and return no useful value. Similarly \code{rgl.quit} is not designed
to return useful values; in fact, users shouldn't call it at all!
\code{rgl.cur} returns the currently active devices, or \code{0} if none is
active; \code{rgl.dev.list} returns a vector of all open devices. Both functions name
the items according to the type of device: \code{null} for a hidden null device,
\code{wgl} for a Windows device, and \code{glX} for an X windows device.
}
\seealso{
\link{r3d},
\code{\link{rgl.init}},
\code{\link{rgl.clear}},
\code{\link{rgl.pop}},
\code{\link{rgl.viewpoint}},
\code{\link{rgl.light}},
\code{\link{rgl.bg}},
\code{\link{rgl.bbox}},
\code{\link{rgl.points}},
\code{\link{rgl.lines}},
\code{\link{rgl.triangles}},
\code{\link{rgl.quads}},
\code{\link{rgl.texts}},
\code{\link{rgl.surface}},
\code{\link{rgl.spheres}},
\code{\link{rgl.sprites}},
\code{\link{rgl.snapshot}},
\code{\link{rgl.useNULL}}
}
\keyword{dynamic}
rgl/man/writeWebGL.Rd 0000644 0001762 0000144 00000005227 14100762641 014122 0 ustar ligges users \name{writeWebGL}
\alias{writeWebGL}
\title{
Write scene to HTML (obsolete)
}
\description{
Obsolete function to write the current scene to a collection of files that contain WebGL code to reproduce
it in a browser. Please use \code{\link{rglwidget}} instead.
}
\usage{
writeWebGL(dir = "webGL", filename = file.path(dir, "index.html"),
template = system.file(file.path("WebGL", "template.html"), package = "rgl"),
prefix = "",
snapshot = TRUE, commonParts = TRUE, reuse = NULL,
font = "Arial", width, height)
}
\arguments{
\item{dir}{
Where to write the files.
}
\item{filename}{
The filename to use for the main file.
}
\item{template}{
The template web page to which to write the Javascript for the scene. See Details below.
}
\item{prefix}{
An optional prefix to use on global identifiers in the scene; use different prefixes
for different scenes displayed on the same web page. If not blank, it should be a legal identifier
in Javascript and HTML.
}
\item{snapshot}{
Whether to include a snapshot of the scene, to be displayed in browsers that don't support WebGL, or
a specification of the snapshot to use. See
details below.
}
\item{commonParts}{
Whether to include parts that would be common to several
figures on the same page. Currently this includes
a reference to and copy of the \file{CanvasMatrix.js}
file in the output.
}
\item{reuse}{
Ignored.
}
\item{font}{
The font to use for text.
}
\item{width, height}{
The (optional) width and height in pixels of the image to display. If omitted,
the \code{par3d("windowRect")} dimensions will be used.
}
}
\details{
This obsolete function writes out a web page containing Javascript that reconstructs the scene in WebGL. It will
be formally deprecated in an upcoming release; you should use
\code{\link{rglwidget}} instead in any new code, and start
migrating old code there.
The remaining documentation has been removed to discourage
use of this function.
}
\value{
The \code{filename} is returned.
}
\author{
Duncan Murdoch.
}
\note{
If \code{commonParts} is \code{TRUE}, the output includes a binary copy of
the CanvasMatrix Javascript library.
Its source (including
the copyright notice and license for free use) is included in the file named by
\code{system.file("htmlwidgets/lib/CanvasMatrix.src.js", package = "rgl")}.
}
\seealso{
\code{\link{rglwidget}} should be used instead of \code{writeWebGL}. Other functions which are related:
\code{\link{scene3d}} saves a copy of a scene to an R variable; \code{\link{writeASY}},
\code{\link{writePLY}}, \code{\link{writeOBJ}} and \code{\link{writeSTL}}
write the scene to a file in various other formats.
}
rgl/man/facing3d.Rd 0000644 0001762 0000144 00000004227 14100762640 013563 0 ustar ligges users \name{facing3d}
\alias{facing3d}
\alias{projectDown}
\title{
Subset an object to parts facing in a particular direction
}
\description{
\code{facing3d} subsets an object by converting it to a triangle mesh,
then subsetting to those triangles that are counterclockwise
(for \code{front = TRUE}) when projected into a plane.
\code{projectDown} computes a projection that \dQuote{looks down} the specified direction.
}
\usage{
facing3d(obj, up = c(0, 0, 1),
P = projectDown(up),
front = TRUE, strict = TRUE)
projectDown(up)
}
\arguments{
\item{obj}{
An object that can be converted to a triangular mesh object.
}
\item{up}{
The direction that is to be considered \dQuote{up}. It may
be either a 3 vector in Euclidean coordinates or a 4 vector in
homogeneous coordinates.
}
\item{P}{
The projection to use for draping, a 4x4 matrix. See \code{\link{drape3d}} for details on how \code{P} is used.
}
\item{front}{
If \code{front = TRUE}, retains triangles that are counterclockwise after projection by \code{P}, otherwise
retains those that are clockwise.
}
\item{strict}{If \code{TRUE}, drops indeterminate triangles
(those that are annihilated by \code{P}).}
}
\details{
By default
the returned subset will be those triangles whose upper side
matches \code{front}. Change \code{up} or use an
arbitrary projection for different subsets.
\code{\link{drape3d}} and \code{\link{shadow3d}} project objects onto meshes; these functions can be used to
project only onto the top or front.
}
\value{
\code{facing3d} returns a mesh object made of those triangles which face in the
desired direction.
\code{projectDown} computes a 4x4 matrix. The first two
coordinates of \code{asEuclidean(x \%*\% projectDown(up))}
give a projection of \code{x} from above into a plane, where
\code{up} determines which direction is taken to be \dQuote{up}.
}
\seealso{\code{\link{drape3d}}, \code{\link{shadow3d}}}
\examples{
open3d()
d <- rnorm(3)
d <- d/sqrt(sum(d^2))
shade3d( facing3d( icosahedron3d(), up = d, strict = FALSE),
col = "yellow")
wire3d( facing3d( icosahedron3d(), up = d, front = FALSE),
col = "black")
# Show the direction:
arrow3d(-2*d , -d)
}
rgl/man/setupKnitr.Rd 0000644 0001762 0000144 00000011336 14100762641 014255 0 ustar ligges users \name{setupKnitr}
\alias{hook_rgl}
\alias{hook_webgl}
\alias{hook_rglchunk}
\alias{setupKnitr}
\title{
Displaying RGL scenes in \pkg{knitr} documents
}
\description{
These functions allow RGL graphics to be embedded in \pkg{knitr}
documents.
The simplest method is to run \code{setupKnitr(autoprint = TRUE)}
early in the document. That way RGL commands act a lot
like base graphics commands: plots will be automatically inserted
where appropriate, according to the \code{fig.keep} chunk option.
By default (\code{fig.keep = "high"}), only high-level plots
are kept, after low-level changes have been merged into them.
See the \pkg{knitr} documentation
\url{https://yihui.org/knitr/options/#plots} for more details. To suppress auto-printing, the RGL calls
can be wrapped in \code{\link{invisible}()}.
Similarly to \pkg{grid} graphics (used by \pkg{lattice}
and \pkg{ggplot2}), automatic inclusion requires the object
to be printed: only the last statement in a code block
in braces is automatically printed. Unlike those
packages, auto-printing is the only way to get this to
work: calling \code{\link{print}} explicitly doesn't
work.
Other functions allow embedding either as bitmaps (\code{hook_rgl} with format \code{"png"}),
fixed vector graphics (\code{hook_rgl} with format \code{"eps"}, \code{"pdf"} or
\code{"postscript"}), or interactive WebGL graphics (\code{hook_webgl}). \code{hook_rglchunk} is not normally invoked by the
user; it is the hook that supports automatic creation and
deletion of RGL scenes.
}
\note{The \code{setupKnitr(autoprint = TRUE)} method assumes
\emph{all} printing of RGL objects happens through
auto-printing of objects produced by the \code{\link{lowlevel}}
or \code{\link{highlevel}} functions. All RGL functions that
produce graphics do this, but functions in other packages that
call them may not return values appropriately.
If you have multiple calls to \code{setupKnitr()}, all
should have the same arguments. If any differ, a
warning will be issued, and the first set of arguments
will be used.
Mixing explicit calls
to \code{\link{rglwidget}} with auto-printing is likely to lead to failure of some
scenes to display. To avoid this, set \code{options(rgl.printRglwidget = FALSE)} before using such explicit calls. Similarly,
use that option before calling the \code{\link{example}} function
in a code chunk if the example prints RGL objects.
}
\usage{
setupKnitr(autoprint = FALSE,
rgl.newwindow = autoprint,
rgl.closewindows = autoprint)
hook_rgl(before, options, envir)
hook_webgl(before, options, envir)
hook_rglchunk(before, options, envir)
}
\arguments{
\item{autoprint}{If true, RGL commands
automatically plot (with low level plots suppressed by
the default value of the \code{fig.keep} chunk option.)}
\item{rgl.newwindow, rgl.closewindows}{Default values
for the \pkg{knitr} chunk options.}
\item{before, options, envir}{
Standard \pkg{knitr} hook function arguments.
}
}
\details{
The \code{setupKnitr()} function needs to be called once
at the start of the document to install the \pkg{knitr} hooks.
If it is called twice in the same session the second call
will override the first.
The following chunk options are supported:
\itemize{
\item \code{rgl.newwindow}: Whether to open a new window for the chunk. Default is set by \code{setupKnitr} argument.
\item \code{rgl.closewindows}: Whether
to close windows at the end of the chunk. Default is set by \code{setupKnitr} argument.
\item \code{rgl.margin} (default 100): number of pixels by which to indent the
WebGL window.
\item \code{snapshot}: Logical value: when autoprinting
in HTML, should a snapshot be used instead of the dynamic
WebGL display? Corresponds to \code{rglwidget(snapshot = TRUE, webgl = FALSE)}. Ignored in LaTeX, where a snapshot
will always be produced (unless \code{fig.keep} specifies
no figure at all).
\item \code{dpi}, \code{fig.retina}, \code{fig.width}, \code{fig.height}: standard \pkg{knitr} chunk
options used to set the size of the output.
\item \code{fig.keep}, \code{fig.hold}, \code{fig.beforecode}: standard \pkg{knitr} chunk options used to control the
display of plots.
\item \code{dev}: used by \code{hook_rgl} to set
the output format. May be \code{"eps"}, \code{"postscript"},
\code{"pdf"} or \code{"png"} (default: \code{"png"}).
\item \code{rgl.keepopen}: no longer used. Ignored
with a warning.
}
}
\value{
A string to be embedded into the output, or \code{NULL} if called
when no output is available.
}
\author{
The \code{hook*} functions are originally by Yihui Xie in the \pkg{knitr} package; and have been modified by
Duncan Murdoch. Some parts of the \code{setupKnitr} function
duplicate source code from \pkg{knitr}.
}
\keyword{ utilities }
rgl/man/as.tmesh3d.Rd 0000644 0001762 0000144 00000002550 14137472630 014062 0 ustar ligges users \name{as.tmesh3d}
\alias{as.tmesh3d}
\alias{as.tmesh3d.default}
\alias{as.tmesh3d.mesh3d}
\title{
Convert object to a triangular mesh
}
\description{
Converts the quads in a mesh version of an object to
triangles by splitting them up. Optionally drops any
point or segment components.
}
\usage{
as.tmesh3d(x, ...)
\method{as.tmesh3d}{default}(x, drop = FALSE, ...)
\method{as.tmesh3d}{mesh3d}(x, drop = FALSE, ...)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{x}{
An object from which to create a triangular mesh object.
}
\item{drop}{
If \code{TRUE}, drop any point or segment components.
}
\item{\dots}{
Ignored in the \code{mesh3d} method, passed to
\code{as.mesh3d} in the default method.
}
}
\details{
The default method simply calls \code{\link{as.mesh3d}(x, ...)}
and passes the result to the \code{"mesh3d"} method.
}
\note{
Older versions of \pkg{rgl} had a \code{"tmesh3d"} class
for meshes of triangles. That class is no longer used:
\code{as.tmesh3d} and \code{\link{tmesh3d}} both produce
\code{"mesh3d"} objects.
}
\value{
A \code{"mesh3d"} object containing no quads. If \code{drop = TRUE}, it will only contain triangles.
}
\author{
Duncan Murdoch
}
\seealso{
\code{as.triangles3d} to get just the coordinates.
}
\examples{
x <- cuboctahedron3d()
x # has quads and triangles
as.tmesh3d(x) # has only triangles
} rgl/man/persp3d.tri.Rd 0000644 0001762 0000144 00000010121 14100762641 014251 0 ustar ligges users \name{persp3d.triSht}
\alias{persp3d.triSht}
\alias{plot3d.triSht}
\alias{as.mesh3d.triSht}
\alias{persp3d.tri}
\alias{plot3d.tri}
\alias{as.mesh3d.tri}
\title{
Plot an interp or tripack Delaunay triangulation
}
\description{
The \code{\link[interp]{tri.mesh}()} functions in the
\pkg{interp} and \pkg{tripack} packages compute a Delaunay triangulation of a set
of points. These functions display it as a surface.
}
\usage{
\method{plot3d}{triSht}(x, z, ...)
\method{persp3d}{triSht}(x, z, ..., add = FALSE)
\method{as.mesh3d}{triSht}(x, z, col = "gray", coords = c("x", "y", "z"),
smooth = TRUE, normals = NULL, texcoords = NULL, ...)
\method{plot3d}{tri}(x, z, ...)
\method{persp3d}{tri}(x, z, ..., add = FALSE)
\method{as.mesh3d}{tri}(x, z, col = "gray", coords = c("x", "y", "z"),
smooth = TRUE, normals = NULL, texcoords = NULL, ...)
}
\arguments{
\item{x}{
A \code{"triSht"} or \code{"tri"} object, produced by the \code{\link[interp]{tri.mesh}()} function in the \pkg{interp} or \pkg{tripack} packages respectively.
}
\item{z}{
z coordinate values corresponding to each of the nodes in \code{x}.
}
\item{add}{
Whether to add surface to existing plot (\code{add = TRUE})
or create a new plot (\code{add = FALSE}, the default).
}
\item{col}{
Colors to apply to each vertex in the triangulation.
Will be recycled as needed.
}
\item{coords}{
See Details below.
}
\item{smooth}{
Whether to average normals at vertices for
a smooth appearance.
}
\item{normals}{
User-specified normals at each vertex. Requires \code{smooth = FALSE}.
}
\item{texcoords}{
Texture coordinates at each vertex.
}
\item{...}{
See Details below.
}
}
\details{
These functions construct a \code{\link{mesh3d}} object
corresponding to the triangulation in \code{x}. The
\code{plot3d} and \code{persp3d} methods plot it.
The \code{coords} parameter allows surfaces to be
plotted over any coordinate plane. It should be
a permutation of the column names \code{c("x", "y", "z")}.
The first will be used
as the x coordinate, the second as the y coordinate,
and the third as the z coordinate.
The \code{...} parameters in \code{plot3d.triSht} and \code{plot3d.tri}
are passed to \code{persp3d}; in \code{persp3d.triSht}
and \code{persp3d.tri} they are
passed to both \code{as.mesh3d} and \code{persp3d.mesh3d};
in \code{as.mesh3d.triSht} and \code{as.mesh3d.tri} they are used as material parameters
in a \code{\link{tmesh3d}} call.
\code{"tri"} objects may contain constraints. These appear
internally as extra nodes, representing either the inside
or outside of boundaries on the region being triangulated.
Each of these nodes should also have a \code{z} value, but
triangles corresponding entirely to constraint nodes will not
be drawn. In this way complex, non-convex regions can
be triangulated. See the second example below.
}
\note{
If there are duplicate points, the \code{tri.mesh()} functions
will optionally delete some of them. If you choose this option,
the \code{z} values must correspond to the nodes \emph{after}
deletion, not before.
}
\examples{
x <- rnorm(200, sd = 5)
y <- rnorm(200, sd = 5)
r <- sqrt(x^2 + y^2)
z <- 10 * sin(r)/r
col <- cm.colors(20)[1 + round(19*(z - min(z))/diff(range(z)))]
save <- NULL
if ((haveinterp <- requireNamespace("interp", quietly = TRUE))) {
save <- options(rgl.meshColorWarning = FALSE)
dxy <- interp::tri.mesh(x, y)
open3d()
persp3d(dxy, z, col = col, meshColor = "vertices")
}
if (haveinterp) {
open3d()
# Do it without smoothing and with a different orientation.
persp3d(dxy, z, col = col, coords = c("z", "x", "y"), smooth = FALSE)
}
if (requireNamespace("tripack", quietly = TRUE)) {
if (is.null(save))
save <- options(rgl.meshColorWarning = FALSE)
# Leave a circular hole around (3, 0)
theta <- seq(0, 2*pi, len = 30)[-1]
cx <- 2*cos(theta) + 3
cy <- 2*sin(theta)
keep <- (x - 3)^2 + y^2 > 4
dxy2 <- tripack::tri.mesh(x[keep], y[keep])
dxy2 <- tripack::add.constraint(dxy2, cx, cy)
z <- dxy2$x^2 - dxy2$y^2
col <- terrain.colors(20)[1 + round(19*(z - min(z))/diff(range(z)))]
open3d()
persp3d(dxy2, z, col = col)
}
options(save)
}
\keyword{graphics}
rgl/man/elementId2Prefix.Rd 0000644 0001762 0000144 00000001464 14100762640 015253 0 ustar ligges users \name{elementId2Prefix}
\alias{elementId2Prefix}
\title{
Use widget with old-style controls
}
\description{
The \code{\link{rglwidget}} control is designed to work in the
\pkg{htmlwidgets} framework. Older RGL web pages that
used \code{\link{writeWebGL}} or \pkg{knitr} used a different
method of linking the controls to the scene. This is a partial
bridge between the two systems. You should adopt the new system, not use this function.
}
\usage{
elementId2Prefix(elementId, prefix = elementId)
}
\arguments{
\item{elementId}{
An element identifier from a \code{\link{rglwidget}} call.
}
\item{prefix}{
The prefix to use in the old-style control.
}
}
\value{
This function generates Javascript code, so it should be
used in an \code{results = "asis"} block in a \pkg{knitr} document.
}
\author{
Duncan Murdoch
}
rgl/man/writeOBJ.Rd 0000644 0001762 0000144 00000011133 14145464133 013571 0 ustar ligges users \name{writeOBJ}
\alias{writeOBJ}
\alias{readOBJ}
\title{
Read and write Wavefront OBJ format files
}
\description{
\code{writeOBJ} writes OBJ files. This is a file format that
is commonly used in 3D graphics applications. It does not represent text,
but does represent points, lines, polygons (and many other types that
RGL doesn't support). \code{readOBJ} reads only some parts
of OBJ files.
}
\usage{
writeOBJ(con,
pointRadius = 0.005, pointShape = icosahedron3d(),
lineRadius = pointRadius, lineSides = 20,
pointsAsPoints = FALSE, linesAsLines = FALSE,
withNormals = TRUE, withTextures = TRUE,
separateObjects = TRUE,
ids = tagged3d(tags),
tags = NULL)
readOBJ(con, ...)
}
\arguments{
\item{con}{
A connection or filename.
}
\item{pointRadius, lineRadius}{
The radius of points and lines relative to the overall scale of the figure,
if they are converted to polyhedra.
}
\item{pointShape}{
A mesh shape to use for points if they are converted. It is scaled by the \code{pointRadius}.
}
\item{lineSides}{
Lines are rendered as cylinders with this many sides.
}
\item{pointsAsPoints, linesAsLines}{
Whether to convert points and lines to \dQuote{point} and \dQuote{line} records in the OBJ output.
}
\item{withNormals}{
Whether to output vertex normals for smooth shading.
}
\item{separateObjects}{
Whether to mark each RGL object as a separate object in the file.
}
\item{withTextures}{
Whether to output texture coordinates.
}
\item{ids}{
The identifiers (from \code{\link{ids3d}}) of the
objects to write. If \code{NULL}, try to write everything.
}
\item{tags}{
Alternate way to specify \code{ids}. Ignored if \code{ids} is
given.
}
\item{...}{
Additional arguments (typically just \code{material}) to pass to
\code{\link{tmesh3d}}.
}
}
\details{
The current \code{writeOBJ} implementation only outputs triangles, quads, planes, spheres,
points, line segments, line strips and surfaces. It does not output material
properties such as colors, since the OBJ format does not support the per-vertex
colors that RGL uses.
The \code{readOBJ} implementation can
read faces, normals, and textures coordinates, but ignores
material properties (including the specification of the texture
file to use). To read a file that uses a single texture,
specify it in the \code{material} argument, e.g.
\code{readOBJ("model.OBJ", material = list(color = "white", texture = "texture.png"))}. There is no support for files that use
multiple textures.
The defaults for \code{pointsAsPoints} and \code{linesAsLines} have been
chosen because Blender (\url{https://www.blender.org}) does not import
points or lines, only polygons. If you are exporting to other software you
may want to change them.
If present, texture coordinates are output by default, but the
textures themselves are not.
Individual RGL objects are output as separate objects in the file when
\code{separateObjects = TRUE}, the default.
The output file should be readable by Blender and Meshlab; the latter can write in
a number of other formats, including U3D, suitable for import into a PDF document.
}
\value{
\code{writeObj} invisibly returns the name of the connection to which the
data was written.
\code{readObj} returns a mesh object constructed
from the input file.
}
\references{
The file format was found at \url{http://www.martinreddy.net/gfx/3d/OBJ.spec}
on November 11, 2012.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{scene3d}} saves a copy of a scene to an R variable; \code{\link{rglwidget}}, \code{\link{writeASY}},
\code{\link{writePLY}} and \code{\link{writeSTL}}
write the scene to a file in various other formats.
}
\examples{
filename <- tempfile(fileext = ".obj")
open3d()
shade3d( icosahedron3d() )
writeOBJ(filename)
# The motivation for writing readObj() was to read a shape
# file of Comet 67P/Churyumov-Gerasimenko, from the ESA.
# The file no longer appears to be online, but may still be
# available on archive.org. Here was the original URL:
# cometurl <- "http://sci.esa.int/science-e/www/object/doc.cfm?fobjectid=54726"
# This code would read and display it:
# open3d()
# shade3d(readOBJ(url(cometurl),
# material = list(col = "gray")))
# Textures are used in a realistic hand image available from
# https://free3d.com/3d-model/freerealsichand-85561.html
# Thanks to Monte Shaffer for pointing this out.
# Decompress the files into the current directory, convert
# hand_mapNew.jpg to hand_mapNew.png, then use
\dontrun{
open3d()
shade3d(readOBJ("hand.OBJ", material = list(color = "white",
shininess = 1, texture = "hand_mapNew.png")))
}
}
\keyword{ graphics }
rgl/man/sprites.Rd 0000644 0001762 0000144 00000007601 14142256754 013607 0 ustar ligges users \name{sprites}
\alias{sprites3d}
\alias{particles3d}
\title{Add sprites}
\description{
Adds a sprite set shape node to the scene.
}
\usage{
sprites3d(x, y = NULL, z = NULL, radius = 1,
shapes = NULL, userMatrix,
fixedSize = FALSE,
adj = 0.5, pos = NULL, offset = 0.25, ...)
particles3d(x, y = NULL, z = NULL, radius = 1, ...)
}
\arguments{
\item{ x, y, z }{point coordinates. Any reasonable way of defining the
coordinates is acceptable. See the function \code{\link[grDevices]{xyz.coords}}
for details.}
\item{ radius }{vector or single value defining the sprite radius}
\item{ shapes }{\code{NULL} for a simple square, or a vector of
identifiers of shapes in the scene}
\item{ userMatrix }{if \code{shape} is not \code{NULL}, the transformation matrix
for the shapes}
\item{ fixedSize }{should sprites remain at a fixed size,
or resize with the scene?}
\item{ adj, pos, offset }{positioning arguments; see Details}
\item{ ... }{material properties when \code{shapes = NULL}, texture mapping is supported}
}
\details{
Simple sprites (used when \code{shapes} is \code{NULL}) are 1 by 1 squares
that are directed towards the viewpoint. Their primary use is for
fast (and faked) atmospherical effects, e.g. particles and clouds
using alpha blended textures. Particles are sprites using an alpha-blended
particle texture giving the illusion of clouds and gases.
The centre of each square will by default be at the
coordinates given by \code{x, y, z}. This may be adjusted
using the \code{adj} or \code{pos} parameters.
\code{adj} and \code{pos} are treated similarly to the same
parameters for \code{\link{text3d}}. \code{adj} has 3
entries, for adjustment to the \code{x}, \code{y} and
\code{z} coordinates respectively. For \code{x}, a value
of 0 puts the sprite to the right of the specified point,
0.5 centers it there, and 1 puts it to the left. The other
coordinates are similar. By default, each value is 0.5 and
the sprites are centered at the points given by \code{(x, y, z)}.
The \code{pos} parameter overrides \code{adj}. It should
be an integer or vector of integers (one per point),
interpreted as in \code{\link{text3d}} to position the
sprite relative to the \code{(x, y, z)} point: 0 is centered on it, 1 is below,
2 is to the left, 3 is above, 4 is to the right, 5 is in
front, and 6 is behind. \code{offset} is the
fraction of the sprite size to separate it from the point.
When \code{shapes} is not \code{NULL}, it should be a vector of
identifiers of objects to plot in the scene (e.g. as returned by
plotting functions or by \code{\link{ids3d}}). These objects will
be removed from the scene and duplicated as a sprite image in a
constant orientation, as specified by \code{userMatrix}. By default the
origin \code{(0, 0, 0)} will be plotted at the coordinates given by \code{(x, y, z)}, perhaps modified by \code{adj}
or \code{pos}.
The \code{userMatrix} argument is ignored for \code{shapes = NULL}. For
shapes, \code{sprites3d} defaults the matrix to \code{r3dDefaults$userMatrix}.
If any coordinate is \code{NA}, the sprite is not plotted.
The id values of the shapes may be retrieved after plotting
using \code{rgl.attrib(id, "ids")};
the user matrix is retrieved using \code{rgl.attrib(id, "usermatrix")}.
}
\value{
These functions are called for the side effect of displaying the sprites.
The shape ID of the displayed object is returned.
}
\examples{
open3d()
particles3d( rnorm(100), rnorm(100), rnorm(100), color = rainbow(100) )
# is the same as
sprites3d( rnorm(100), rnorm(100), rnorm(100), color = rainbow(100),
lit = FALSE, alpha = .2,
textype = "alpha", texture = system.file("textures/particle.png", package = "rgl") )
sprites3d( rnorm(10) + 6, rnorm(10), rnorm(10), shape = shade3d(tetrahedron3d(), col = "red") )
}
\seealso{
\code{\link{material3d}}, \code{\link{text3d}}
}
\keyword{dynamic}
rgl/man/bbox.Rd 0000644 0001762 0000144 00000005627 14100762640 013044 0 ustar ligges users \name{rgl.bbox}
\alias{rgl.bbox}
\alias{bbox3d}
\title{Set up bounding box decoration}
\description{
Set up the bounding box decoration.
}
\usage{
rgl.bbox(
xat = NULL, xlab = NULL, xunit = 0, xlen = 5,
yat = NULL, ylab = NULL, yunit = 0, ylen = 5,
zat = NULL, zlab = NULL, zunit = 0, zlen = 5,
marklen = 15.0, marklen.rel = TRUE, expand = 1,
draw_front = FALSE, ...)
bbox3d(xat = NULL, yat = NULL, zat = NULL,
xunit = "pretty", yunit = "pretty", zunit = "pretty",
expand = 1.03,
draw_front = FALSE, ...)
}
\arguments{
\item{xat, yat, zat}{vector specifying the tickmark positions}
\item{xlab, ylab, zlab}{character vector specifying the tickmark labeling}
\item{xunit, yunit, zunit}{value specifying the tick mark base for uniform tick mark layout}
\item{xlen, ylen, zlen}{value specifying the number of tickmarks}
\item{marklen}{value specifying the length of the tickmarks}
\item{marklen.rel}{logical, if TRUE tick mark length is calculated using 1/\code{marklen} * axis length, otherwise tick mark length is \code{marklen} in coordinate space}
\item{expand}{value specifying how much to expand the bounding box around the data}
\item{draw_front}{draw the front faces of the bounding box}
\item{ ... }{Material properties (or other \code{rgl.bbox} parameters
in the case of \code{bbox3d}). See \code{\link{rgl.material}} for details.}
}
\details{
Four different types of tick mark layouts are possible.
This description applies to the X axis; other axes are similar:
If \code{xat} is not \code{NULL}, the ticks are set up at custom positions.
If \code{xunit} is numeric but not zero, it defines the tick mark base. If
it is \code{"pretty"} (the default in \code{bbox3d}), ticks are set at \code{\link{pretty}}
locations.
If \code{xlen} is not zero, it specifies the number of ticks
(a suggestion if \code{xunit} is \code{"pretty"}).
The first color specifies the bounding box, while the second one specifies the tick mark and font color.
\code{bbox3d} defaults to \code{\link{pretty}} locations for the axis labels and a slightly larger
box, whereas \code{rgl.bbox} covers the exact range.
\code{\link{axes3d}} offers more flexibility in the specification of the axes, but
they are static, unlike those drawn by \code{\link{rgl.bbox}} and \code{\link{bbox3d}}.
}
\value{
This function is called for the side effect of setting the bounding box decoration.
A shape ID is returned to allow \code{\link{pop3d}} to delete it.
}
\examples{
rgl.open()
rgl.points(rnorm(100), rnorm(100), rnorm(100))
rgl.bbox(color = c("#333377", "white"), emission = "#333377",
specular = "#3333FF", shininess = 5, alpha = 0.8 )
open3d()
points3d(rnorm(100), rnorm(100), rnorm(100))
bbox3d(color = c("#333377", "black"), emission = "#333377",
specular = "#3333FF", shininess = 5, alpha = 0.8)
}
\seealso{
\code{\link{rgl.material}}, \code{\link{axes3d}}
}
\keyword{dynamic}
rgl/man/rgl.bringtotop.Rd 0000644 0001762 0000144 00000001624 14100762641 015056 0 ustar ligges users \name{rgl.bringtotop}
\alias{rgl.bringtotop}
\title{Assign focus to an RGL window }
\description{
'rgl.bringtotop' brings the current RGL window to the
front of the window stack (and gives it focus).}
\usage{
rgl.bringtotop(stay = FALSE)
}
\arguments{
\item{stay}{whether to make the window stay on top.}
}
\details{
If \code{stay} is \code{TRUE}, then the window will stay on top
of normal windows.
}
\author{ Ming Chen/Duncan Murdoch }
\note{not completely implemented for X11 graphics (stay not implemented;
window managers such as KDE may block this action
(set "Focus stealing prevention level" to None in Control Center/Window Behavior/Advanced)).
Not currently implemented under OS/X.}
#ifdef windows
\seealso{\code{\link[grDevices]{bringToTop}}}
#endif
\examples{
rgl.open()
rgl.points(rnorm(1000), rnorm(1000), rnorm(1000), color = heat.colors(1000))
rgl.bringtotop(stay = TRUE)
}
\keyword{ dynamic }
rgl/man/as.triangles3d.Rd 0000644 0001762 0000144 00000002476 14100762640 014732 0 ustar ligges users \name{as.triangles3d}
\alias{as.triangles3d}
\alias{as.triangles3d.rglId}
\title{
Convert an object to triangles
}
\description{
This generic and its methods extract or creates a matrix of coordinates
of triangles from an object, suitable for passing to \code{\link{triangles3d}}.
}
\usage{
as.triangles3d(obj, ...)
\method{as.triangles3d}{rglId}(obj,
attribute = c("vertices", "normals", "texcoords", "colors"),
subscene = NA,
...)
}
\arguments{
\item{obj}{
The object to convert.
}
\item{attribute}{Which attribute of an RGL object to extract?}
\item{subscene}{Which subscene is this object in?}
\item{\dots}{
Additional arguments used by the methods.
}
}
\details{
The method for \code{"rglId"} objects can extract several different
attributes, organizing them as it would organize the vertices for
the triangles.
}
\value{
An \code{n x 3} matrix containing the vertices of triangles making
up the object. Each successive 3 rows of the matrix corresponds to
a triangle.
If the attribute doesn't exist, \code{NULL} will be returned.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{as.mesh3d}} to also capture material properties.
}
\examples{
open3d()
x <- surface3d(x = 1:10, y = 1:10, z = rnorm(100), col = "red")
tri <- as.triangles3d(x)
open3d()
triangles3d(tri, col = "blue")
}
rgl/man/scene3d.Rd 0000644 0001762 0000144 00000010434 14100762641 013427 0 ustar ligges users \name{scene3d}
\alias{scene3d}
\alias{rglscene-class}
\alias{rglobject-class}
\alias{plot3d.rglscene}
\alias{plot3d.rglobject}
\alias{print.rglscene}
\alias{print.rglobject}
\title{
Saves the current scene to a variable, and displays such variables
}
\description{
This function saves a large part of the RGL state associated with the current
window to a variable.
}
\usage{
scene3d(minimal = TRUE)
\S3method{plot3d}{rglscene}(x, add = FALSE, ...)
\S3method{plot3d}{rglobject}(x, ...)
\S3method{print}{rglscene}(x, ...)
\S3method{print}{rglobject}(x, ...)
}
\arguments{
\item{minimal}{Should attributes be skipped if they currently have
no effect? See Details.}
\item{x}{An object of class \code{"rglscene"}}
\item{add}{Whether to open a new window, or add to the existing one.}
\item{...}{Additional parameters, currently ignored.}
}
\details{
The components saved are: the \code{\link{par3d}} settings, the \code{\link{material3d}}
settings, the \code{\link{bg3d}} settings, the lights and the objects in the scene.
In most cases, calling \code{\link{plot3d}} on that variable will
duplicate the scene. (There are likely to be small differences, mostly internal, but
some aspects of the scene are not currently available.) If textures are used,
the name of the texture will be saved, rather than the contents of the
texture file.
Other than saving the code
to recreate a scene, saving the result of \code{scene3d} to
a file will allow it to be reproduced later most accurately. In roughly decreasing order of fidelity,
\code{\link{writeWebGL}} (now obsolete), \code{\link{writePLY}}, \code{\link{writeOBJ}} and \code{\link{writeSTL}}
write the scene to a file in formats readable by other software.
If \code{minimal = TRUE} (the default), then attributes of objects
will not be saved if they currently have no effect on
the display, thereby reducing the file size.
Set \code{minimal = FALSE} if the scene is intended
to be used in a context where the appearance could be changed.
Currently this only affects the inclusion of normals; with
\code{minimal = TRUE} they are
omitted for objects when the material is not lit.
}
\value{
The \code{scene3d} function returns an object of class
\code{"rglscene"}. This is a list with some or all of the components:
\item{material}{The results returned from a \code{\link{material3d}} call.}
\item{rootSubscene}{A list containing information about
the main ("root") subscene. This may include:
\describe{
\item{id}{The scene id.}
\item{type}{"subscene"}
\item{par3d}{The \code{\link{par3d}} settings for the
subscene.}
\item{embeddings}{The \code{\link{subsceneInfo}()$embeddings} for the main subscene.}
\item{objects}{The ids for objects in the subscene.}
\item{subscenes}{A recursive list of child subscenes.}}}
\item{objects}{A list containing the RGL lights, background and objects in the scene.}
The objects in the \code{objects} component are of class
\code{"rglobject"}. They are lists containing some or all of the
components
\item{id}{The RGL identifier of the object in the original scene.}
\item{type}{A character variable identifying the type of object.}
\item{material}{Components of the material that differ from the scene material.}
\item{vertices, normals, etc.}{Any of the attributes of the object retrievable by \code{\link{rgl.attrib}}.}
\item{ignoreExtent}{A logical value indicating whether this object contributes to the bounding box.
Currently this may differ from the object in the original scene.}
\item{objects}{Sprites may contain other objects; they will be stored here as a list of \code{"rglobject"}s.}
Lights in the scene are stored similarly, mixed into the \code{objects} list.
The \code{plot3d} methods invisibly return a vector of RGL object ids
that were plotted. The \code{print} methods invisibly return the
object that was printed.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{rglwidget}}, \code{\link{writePLY}}, \code{\link{writeOBJ}} and \code{\link{writeSTL}}
write the scene to a file in various formats.
}
\examples{
open3d()
z <- 2 * volcano # Exaggerate the relief
x <- 10 * (1:nrow(z)) # 10 meter spacing (S to N)
y <- 10 * (1:ncol(z)) # 10 meter spacing (E to W)
persp3d(x, y, z, col = "green3", aspect = "iso")
s <- scene3d()
# Make it bigger
s$par3d$windowRect <- 1.5*s$par3d$windowRect
# and draw it again
plot3d(s)
}
\keyword{ graphics }
rgl/man/drape3d.Rd 0000644 0001762 0000144 00000005655 14100762640 013435 0 ustar ligges users \name{drape3d}
\alias{drape3d}
\alias{drape3d.default}
\alias{drape3d.mesh3d}
\title{
Drape lines over a scene.
}
\description{
Project a line onto the surface in a scene so that it appears to drape itself
onto the surface.
}
\usage{
drape3d(obj, ...)
\method{drape3d}{mesh3d}(obj, x, y = NULL, z = NULL, plot = TRUE,
up = c(0, 0, 1),
P = projectDown(up), ...)
\method{drape3d}{default}(obj, ...)
}
\arguments{
\item{obj}{
The object(s) upon which to drape lines.
}
\item{x,y,z}{Coordinates of the line segments
to be draped. Any reasonable way of defining the
coordinates is acceptable. See the function \code{\link[grDevices]{xyz.coords}} for details.
}
\item{plot}{
Should the result be plotted, or returned as a data frame?
}
\item{up}{
The direction to consider as \dQuote{up}.
}
\item{P}{
The projection to use for draping, a 4x4 matrix.
}
\item{\dots}{
For the \code{"mesh3d"} method, additional parameters to pass to \code{\link{segments3d}}
when drawing the draped lines.
For the \code{"default"} method, additional parameters to pass to the
\code{"mesh3d"} method.
}
}
\details{
The default method converts \code{obj} to a mesh
using \code{\link{as.mesh3d}}, then uses the \code{"mesh3d"}
method.
The current implementation constructs the segments to drape
across the surface using the same method as
\code{\link{lines3d}} uses: each successive point is
joined to the previous one. Use \code{NA} coordinates to
indicate breaks in the line.
The \code{P} matrix is used to project points to a plane as
follows: They are transformed by \code{P} in
homogeneous coordinates, then only first two (Euclidean)
coordinates are kept.
}
\value{
If \code{plot = TRUE},
plots the result and invisibly returns the object ID of the collection of segments.
If \code{plot = FALSE}, returns a matrix containing "x", "y" and "z"
values for the line(s)
(for use with \code{\link{segments3d}}),
}
\author{
George Helffrich and Duncan Murdoch
}
\seealso{\code{\link{shadow3d}}, \code{\link{facing3d}}}
\examples{
#
# volcano example taken from "persp"
#
z <- 2 * volcano # Exaggerate the relief
x <- 10 * (1:nrow(z)) # 10 meter spacing (S to N)
y <- 10 * (1:ncol(z)) # 10 meter spacing (E to W)
zlim <- range(z)
zlen <- zlim[2] - zlim[1] + 1
colorlut <- terrain.colors(zlen) # height color lookup table
col <- colorlut[ z - zlim[1] + 1 ] # assign colors to heights for each point
open3d()
id <- surface3d(x, y, z, color = col, polygon_offset = 1)
segs <- data.frame(x = range(x) + c(100, -100),
y = range(y) + c(150, -100), z = 325)
drape3d(id, segs, col = 'yellow', lwd = 3)
lines3d(segs, col='red', lwd=3)
p <- c(350, 205) # (x,y) of strike & dip reading
off <- 20*c(-1, +1) # X-marks-the-spot offset
segs <- data.frame(
x = c(p[1] + off, NA, p[1] + off),
y = c(p[2] + off, NA, p[2] - off),
z = rep(350, 5)
)
drape3d(id, segs, col = "yellow", lwd = 3)
}
rgl/man/as.mesh3d.ashape3d.Rd 0000644 0001762 0000144 00000006713 14100762640 015363 0 ustar ligges users \name{as.mesh3d.ashape3d}
\alias{as.mesh3d.ashape3d}
\title{
Convert alpha-shape surface of a cloud of points to
RGL mesh object
}
\description{
The \code{\link[alphashape3d:ashape3d]{alphashape3d::ashape3d}}
function computes the
3D \eqn{\alpha}-shape of a cloud of points. This is an approximation
to the visual outline of the cloud. It may include isolated
points, line segments, and triangular faces: this function
converts the triangular faces to an RGL \code{\link{tmesh3d}} object.
}
\usage{
\method{as.mesh3d}{ashape3d}(x,
alpha = x$alpha[1],
tri_to_keep = 2L,
col = "gray",
smooth = FALSE, normals = NULL,
texcoords = NULL, ...)
}
\arguments{
\item{x}{
An object of class \code{"ashape3d"}.
}
\item{alpha}{
Which \code{alpha} value stored in \code{x} should be converted?
}
\item{tri_to_keep}{
Which triangles to keep. Expert use only: see \code{triang}
entry in \bold{Value} section of \link[alphashape3d]{ashape3d}
for details.
}
\item{col}{
The surface colour.
}
\item{smooth}{
Whether to attempt to add normals to make the surface
look smooth. See the Details below.
}
\item{normals, texcoords}{
Normals and texture coordinates at each vertex can be specified.
}
\item{\dots}{
Additional arguments to pass to use as \code{\link{material3d}} properties on the resulting mesh.
}
}
\details{
Edelsbrunner and Mucke's (1994) \eqn{\alpha}-shape algorithm is
intended to compute a surface of a general cloud of points.
Unlike the convex hull, the cloud may have voids, isolated points, and other oddities. This function is designed to
work in the case where the surface is made up of
simple polygons.
If \code{smooth = TRUE}, this method attempts to orient all
of the triangles in the surface consistently and add normals
at each vertex by averaging the triangle normals.
However, for some point clouds, the \eqn{\alpha}-shape will contain
sheets of polygons with a few solid polyhedra embedded.
This does not allow a consistent definition of "inside"
and outside. If this is detected, a warning is issued
and the resulting mesh will likely contain boundaries
where the assumed orientation of triangles changes, resulting
in ugly dark lines through the shape. Larger values
of \code{alpha} in the call to \code{\link[alphashape3d:ashape3d]{alphashape3d::ashape3d}} may help.
Methods for \code{\link{plot3d}} and \code{\link{persp3d}}
are also defined: they call the \code{\link{as.mesh3d}} method and then plot the result.
}
\value{
A \code{"mesh3d"} object, suitable for plotting.
}
\references{
Edelsbrunner, H., Mucke, E. P. (1994). Three-Dimensional Alpha Shapes. ACM Transactions on Graphics, 13(1), pp.43-72.
Lafarge, T. and Pateiro-Lopez, B. (2017).
alphashape3d: Implementation of the 3D Alpha-Shape
for the Reconstruction of 3D Sets from a Point Cloud.
R package version 1.3.
}
\author{
Duncan Murdoch
}
\examples{
if (requireNamespace("alphashape3d", quietly = TRUE)) {
set.seed(123)
n <- 400 # 1000 gives a nicer result, but takes longer
xyz <- rbind(cbind(runif(n), runif(n), runif(n)),
cbind(runif(n/8, 1, 1.5),
runif(n/8, 0.25, 0.75),
runif(n/8, 0.25, 0.75)))
ash <- suppressMessages(alphashape3d::ashape3d(xyz, alpha = 0.2))
m <- as.mesh3d(ash, smooth = TRUE)
open3d()
mfrow3d(1, 2, sharedMouse = TRUE)
plot3d(xyz, size = 1)
plot3d(m, col = "red", alpha = 0.5)
points3d(xyz, size = 1)
}
} rgl/man/webGLcontrols.Rd 0000644 0001762 0000144 00000004765 14100762641 014701 0 ustar ligges users \name{webGLcontrols}
\alias{subsetSlider}
\alias{subsetSetter}
\alias{clipplaneSlider}
\alias{toggleButton}
\title{
Obsolete functions to write HTML/Javascript code to control a WebGL display
}
\description{
These functions write out HTML code to control WebGL displays on the same page. They are deprecated; most documentation has
now been removed.
}
\usage{
subsetSlider(subsets, labels = names(subsets),
fullset = Reduce(union, subsets),
subscenes = currentSubscene3d(), prefixes = "",
accumulate = FALSE, ...)
subsetSetter(subsets, subscenes = currentSubscene3d(), prefixes = "",
fullset = Reduce(union, subsets),
accumulate = FALSE)
clipplaneSlider(a=NULL, b=NULL, c=NULL, d=NULL,
plane = 1, clipplaneids, prefixes = "",
labels = signif(values[,1],3), ...)
toggleButton(subset, subscenes = currentSubscene3d(), prefixes = "",
label = deparse(substitute(subset)),
id = paste0(basename(tempfile("input"))), name = id)
}
\arguments{
\item{subsets}{A list of vectors of object identifiers; the slider or setter
will choose among them.}
\item{labels}{Labels to display corresponding to each subset. If \code{NULL},
numeric labels will be shown.}
\item{fullset}{Objects in the subscene which are not in \code{fullset}
will not be touched.}
\item{subscenes}{The subscenes to be controlled.}
\item{prefixes}{The prefixes of the WebGL scenes to be controlled.}
\item{accumulate}{If \code{TRUE}, the subsets will accumulate (by union)
as the value increases.}
\item{id}{The \code{id} of the input control that will be generated.}
\item{name}{The name of the input control that will be generated.}
\item{...}{Arguments to pass to \code{\link{propertySlider}}.}
\item{a,b,c,d}{The parameter values to change. Leave as \code{NULL}
to hold the parameter constant.}
\item{plane, clipplaneids}{The identifier of the particular clipplane
to modify.}
\item{subset}{The subset that the button should toggle.}
\item{label}{The button label.}
}
\value{
\code{subsetSetter} returns a length-one character vector
of class \code{"propertySetter"}.
The other functions
use \code{\link{cat}} to write their output and invisibly return the
\code{id} of the control that was generated.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{playwidget}} and \code{\link{toggleWidget}}
for a newer, preferred method of inserting controls
into a scene.
}
rgl/man/Buffer.Rd 0000644 0001762 0000144 00000030234 14145464133 013320 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/buffer.R
\name{Buffer}
\alias{Buffer}
\title{R6 Class for binary buffers in glTF files.}
\description{
These files typically have one buffer holding all the
binary data for a scene.
}
\section{Methods}{
\subsection{Public methods}{
\itemize{
\item \href{#method-new}{\code{Buffer$new()}}
\item \href{#method-load}{\code{Buffer$load()}}
\item \href{#method-saveOpenBuffer}{\code{Buffer$saveOpenBuffer()}}
\item \href{#method-getBuffer}{\code{Buffer$getBuffer()}}
\item \href{#method-setBuffer}{\code{Buffer$setBuffer()}}
\item \href{#method-openBuffer}{\code{Buffer$openBuffer()}}
\item \href{#method-writeBuffer}{\code{Buffer$writeBuffer()}}
\item \href{#method-closeBuffer}{\code{Buffer$closeBuffer()}}
\item \href{#method-closeBuffers}{\code{Buffer$closeBuffers()}}
\item \href{#method-getBufferview}{\code{Buffer$getBufferview()}}
\item \href{#method-addBufferView}{\code{Buffer$addBufferView()}}
\item \href{#method-openBufferview}{\code{Buffer$openBufferview()}}
\item \href{#method-setBufferview}{\code{Buffer$setBufferview()}}
\item \href{#method-getAccessor}{\code{Buffer$getAccessor()}}
\item \href{#method-setAccessor}{\code{Buffer$setAccessor()}}
\item \href{#method-readAccessor}{\code{Buffer$readAccessor()}}
\item \href{#method-addAccessor}{\code{Buffer$addAccessor()}}
\item \href{#method-dataURI}{\code{Buffer$dataURI()}}
\item \href{#method-as.list}{\code{Buffer$as.list()}}
\item \href{#method-clone}{\code{Buffer$clone()}}
}
}
\if{html}{\out{}}\preformatted{Buffer$new(json = NULL, binfile = NULL)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{json}}{list read from glTF file.}
\item{\code{binfile}}{optional External binary filename, or raw vector}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$load(uri, buf = 0)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{uri}}{Which file to load.}
\item{\code{buf}}{Which buffer number to load.}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$saveOpenBuffer(con, buf = 0)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{con}}{Output connection.}
\item{\code{buf}}{Buffer number.}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$getBuffer(buf, default = list(byteLength = 0))}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{buf}}{Buffer number.}
\item{\code{default}}{Default buffer object if `buf` not found.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
A list containing components described here:
\url{https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#reference-buffer}.
}
}
\if{html}{\out{}}\preformatted{Buffer$setBuffer(buf, buffer)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{buf}}{Buffer number.}
\item{\code{buffer}}{New value to insert.}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$openBuffer(buf)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{buf}}{Buffer number.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
An open binary connection.
}
}
\if{html}{\out{}}\preformatted{Buffer$writeBuffer(values, type, size, buf = 0)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{values}}{Values to write.}
\item{\code{type}}{Type to write.}
\item{\code{size}}{Byte size of each value.}
\item{\code{buf}}{Which buffer to write to.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
Byte offset of start of bytes written.
}
}
\if{html}{\out{}}\preformatted{Buffer$closeBuffer(buf)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{buf}}{The buffer number.}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$closeBuffers()}\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$getBufferview(bufv)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{bufv}}{bufferView number.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
A list containing components described here:
\url{https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#reference-bufferview}.
}
}
\if{html}{\out{}}\preformatted{Buffer$addBufferView(values, type, size, target = NULL, buf = 0)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{values}}{Values to put in the view.}
\item{\code{type}}{Type of values.}
\item{\code{size}}{Size of values in bytes.}
\item{\code{target}}{Optional target use for values.}
\item{\code{buf}}{Which buffer to write to.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
New bufferView number.
}
}
\if{html}{\out{}}\preformatted{Buffer$openBufferview(bufv)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{bufv}}{Which bufferView.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
A connection.
}
}
\if{html}{\out{}}\preformatted{Buffer$setBufferview(bufv, bufferView)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{bufv}}{bufferView number.}
\item{\code{bufferView}}{New value to insert.}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$getAccessor(acc)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{acc}}{Accessor number}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
A list containing components described here:
\url{https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#reference-accessor}
}
}
\if{html}{\out{}}\preformatted{Buffer$setAccessor(acc, accessor)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{acc}}{Accessor number.}
\item{\code{accessor}}{New value to insert.}
}
\if{html}{\out{
}}
}
}
\if{html}{\out{}}\preformatted{Buffer$readAccessor(acc)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{acc}}{Accessor number.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
A vector or array as specified in the accessor.
}
}
\if{html}{\out{}}\preformatted{Buffer$addAccessor(values, target = NULL, useDouble = FALSE)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{values}}{Values to write.}
\item{\code{target}}{Optional target use for values.}
\item{\code{useDouble}}{Whether to write doubles or singles.}
\item{\code{glTF}}{Whether this is for glTF use.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
New accessor number
}
}
\if{html}{\out{}}\preformatted{Buffer$dataURI(buf = 0)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{buf}}{Buffer to convert.}
}
\if{html}{\out{
}}
}
\subsection{Returns}{
String containing data URI.
}
}
\if{html}{\out{}}\preformatted{Buffer$as.list()}\if{html}{\out{
}}
}
\subsection{Returns}{
List suitable for writing using JSON.
}
}
\if{html}{\out{}}\preformatted{Buffer$clone(deep = FALSE)}\if{html}{\out{
}}
}
\subsection{Arguments}{
\if{html}{\out{}}
\describe{
\item{\code{deep}}{Whether to make a deep clone.}
}
\if{html}{\out{
}}
}
}
}
rgl/man/checkDeldir.Rd 0000644 0001762 0000144 00000000657 14145464133 014316 0 ustar ligges users \name{checkDeldir}
\alias{checkDeldir}
\title{
Check for a compatible version of deldir
}
\description{
Version 1.0-2 of \pkg{deldir} is not compatible with \pkg{rgl}.
This allows code to avoid trying to call it.
}
\usage{
checkDeldir(error = FALSE)
}
\arguments{
\item{error}{
If \code{TRUE}, stop with an error.
}
}
\value{
Returns \code{TRUE} if \pkg{deldir} is available in a compatible
version.
}
\examples{
checkDeldir()
}
rgl/man/all.equal.mesh3d.Rd 0000644 0001762 0000144 00000003434 14137472630 015153 0 ustar ligges users \name{all.equal.mesh3d}
\alias{all.equal.mesh3d}
\alias{compare_proxy.mesh3d}
\title{
Compare mesh3d objects in a meaningful way.
}
\description{
These functions allow comparison of mesh3d objects, ignoring
irrelevant differences.
\code{compare_proxy.mesh3d} can function as a \code{compare_proxy} method for the
\pkg{waldo} package, by stripping out \code{NULL} components
and ordering other components alphabetically by name.
\code{all.equal.mesh3d} compares mesh3d objects by using
\code{compare_proxy.mesh3d} to standardize them, then
using the regular \code{\link{all.equal}} function to
compare them.
}
\usage{
\method{all.equal}{mesh3d}(target, current, ...)
compare_proxy.mesh3d(x, path = "x")
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{target, current}{
Two mesh3d objects to compare.
}
\item{x}{
A single mesh3d object to standardize.
}
\item{path}{
The string to use in a \pkg{waldo} display of this object.
}
\item{\dots}{
Additional parameters to pass to \code{\link{all.equal}}.
}
}
\value{
\code{all.equal.mesh3d} returns \code{TRUE}, or a character
vector describing (some of) the differences.
\code{compare_proxy.mesh3d} returns a list containing two
components:
\describe{
\item{object}{a copy of \code{x} with
relevant components in alphabetical order.}
\item{path}{a modification of the path label for \code{x}}
}
}
\note{
\pkg{waldo} is not an installation requirement for \pkg{rgl}
and \pkg{rgl} will never cause it to be loaded.
The \code{compare_proxy.mesh3d} function will only be
registered as a method for \code{waldo::compare_proxy}
if you load \pkg{waldo} before \pkg{rgl}, as would normally
happen during testing using \pkg{testthat}, or if you load
it before calling \code{\link{mesh3d}},
as might happen if you are doing manual tests.
}
rgl/man/rgl.useNULL.Rd 0000644 0001762 0000144 00000001750 14100762641 014156 0 ustar ligges users \name{rgl.useNULL}
\alias{rgl.useNULL}
\title{
Report default use of null device
}
\description{
This function checks the \code{"rgl.useNULL"} option if present, or the
\env{RGL_USE_NULL} environment variable if it is not. If the value is
\code{TRUE} or a string which matches \dQuote{yes} or \dQuote{true}
in a case-insensitive test, \code{TRUE} is returned.
}
\usage{
rgl.useNULL()
}
\note{
This function is checked by the initialization code when the \pkg{rgl} package
is loaded. Thus if you want to run RGL on a system where there is no
graphics support, you should run \code{options(rgl.useNULL = TRUE)}
or set the environment variable \code{RGL_USE_NULL=TRUE} *before*
calling \code{library(rgl)} (or other code that
loads \pkg{rgl}), and it will not fail in its attempt at initialization.
}
\value{
A logical value indicating the current default for use of the null
device.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{open3d}} and \code{\link{rgl.open}}.
}
\examples{
rgl.useNULL()
}
rgl/man/attributes.Rd 0000644 0001762 0000144 00000005230 14100762640 014266 0 ustar ligges users \name{rgl.attrib}
\alias{rgl.attrib}
\title{
Get information about shapes
}
\description{
Retrieves information about the shapes in a scene.
}
\usage{
rgl.attrib(id, attrib, first = 1,
last = rgl.attrib.count(id, attrib))
}
\arguments{
\item{id}{
A shape identifier, as returned by \code{\link{ids3d}}.
}
\item{attrib}{
An attribute of a shape. Currently supported: one of \cr
\code{"vertices"}, \code{"normals"}, \code{"colors"}, \code{"texcoords"},
\code{"dim"}, \code{"texts"}, \code{"cex"}, \code{"adj"}, \code{"radii"},
\code{"centers"}, \code{"ids"}, \code{"usermatrix"}, \code{"types"},
\code{"flags"}, \code{"offsets"}, \code{"family"}, \code{"font"},
\code{"pos"}\cr
or unique prefixes
to one of those.
}
\item{first, last}{
Specify these to retrieve only those rows of the result.
}
}
\details{
If the identifier is not found or is not a shape that has the given attribute,
zero will be returned by \code{rgl.attrib.count}, and an empty matrix
will be returned by \code{rgl.attrib}.
The first four \code{attrib} names correspond to the usual OpenGL
properties; \code{"dim"} is used just for surfaces, defining the rows
and columns in the rectangular grid; \code{"cex"}, \code{"adj"},
\code{"family"}, \code{"font"} and \code{"pos"} apply only to text objects.
}
\value{
\code{rgl.attrib}
returns the values of the attribute. Attributes
are mostly real-valued, with the following sizes:
\tabular{lll}{
\code{"vertices"} \tab 3 values \tab x, y, z \cr
\code{"normals"} \tab 3 values \tab x, y, z \cr
\code{"centers"} \tab 3 values \tab x, y, z \cr
\code{"colors"} \tab 4 values \tab r, g, b, a \cr
\code{"texcoords"} \tab 2 values \tab s, t \cr
\code{"dim"} \tab 2 values \tab r, c \cr
\code{"cex"} \tab 1 value \tab cex \cr
\code{"adj"} \tab 2 values \tab x, y \cr
\code{"radii"} \tab 1 value \tab r \cr
\code{"ids"} \tab 1 value \tab id \cr
\code{"usermatrix"} \tab 4 values \tab x, y, z, w \cr
\code{"texts"} \tab 1 value \tab text \cr
\code{"types"} \tab 1 value \tab type \cr
\code{"flags"} \tab 1 value \tab flag \cr
\code{"family"} \tab 1 value \tab family \cr
\code{"font"} \tab 1 value \tab font \cr
\code{"pos"} \tab 1 value \tab pos \cr
}
The \code{"texts"}, \code{"types"} and \code{"family"}
attributes are character-valued; the \code{"flags"}
attribute is logical valued, with named rows.
These are returned as matrices with the row count equal to the count for the attribute,
and the columns as listed above.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{ids3d}}, \code{\link{rgl.attrib.info}}
}
\examples{
p <- plot3d(rnorm(100), rnorm(100), rnorm(100), type = "s", col = "red")
rgl.attrib(p["data"], "vertices", last = 10)
}
\keyword{ graphics }
rgl/man/propertyControl.Rd 0000644 0001762 0000144 00000004711 14145464133 015335 0 ustar ligges users \name{propertyControl}
\alias{subsetControl}
\alias{propertyControl}
\title{
Controls to use with playwidget()
}
\description{
These are setter functions to produce actions in a Shiny app,
or in an animation.
}
\usage{
subsetControl(value = 1, subsets, subscenes = NULL,
fullset = Reduce(union, subsets),
accumulate = FALSE)
propertyControl(value = 0, entries, properties,
objids = tagged3d(tags), tags, values = NULL,
param = seq_len(NROW(values)) - 1, interp = TRUE)
}
\arguments{
\item{value}{The value to use for input (typically \code{input$value}
in a Shiny app.)}
\item{subsets}{A list of vectors of object identifiers; the value will
choose among them.}
\item{fullset}{Objects in the subscene which are not in \code{fullset}
will not be touched.}
\item{subscenes}{The subscenes to be controlled. If \code{NULL}, the
root subscene.}
\item{accumulate}{If \code{TRUE}, the subsets will accumulate (by union)
as the value increases.}
\item{entries, properties, objids}{Which properties to set.}
\item{tags}{
Select objects with matching tags. Ignored
if \code{objids} is specified.
}
\item{values}{Values to set.}
\item{param}{Parameter values corresponding to the rows of \code{value}}
\item{interp}{Whether to use linear interpolation between \code{param}
values}
}
\details{
\code{subsetControl} produces data for \code{\link{playwidget}} to
display subsets of the object in one or more subscenes. This code will not
touch objects in the
subscenes if they
are not in \code{fullset}. \code{fullset} defaults to the union of
all the object ids mentioned in \code{subsets}, so by default if an id is
not mentioned in one of the subsets, it will not be controlled by the slider. If \code{value} is specified in R code, it will be a 1-based
index into the \code{subsets} list; when specified internally
in Javascript, 0-based indexing into the corresponding array
will be used.
\code{propertyControl} sets individual properties. Here the row
of \code{values} is determined by the position of \code{value}
in \code{param}.
}
\value{
These functions return controller data in a list of class
\code{"rglControl"}.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{subsetSetter}} for a way to embed a pure Javascript
control, and \code{\link{playwidget}} for a way to use these
in animations (including Shiny), \code{\link{rglShared}}
for linking using the \pkg{crosstalk} package.
}
rgl/man/rgl.pixels.Rd 0000644 0001762 0000144 00000002753 14100762641 014177 0 ustar ligges users \name{rgl.pixels}
\alias{rgl.pixels}
\title{ Extract pixel information from window }
\description{
This function extracts single components of the pixel information from the
topmost window.
}
\usage{
rgl.pixels(component = c("red", "green", "blue"),
viewport = par3d("viewport"), top = TRUE)
}
\arguments{
\item{component}{ Which component(s)? }
\item{viewport}{ Lower left corner and size of desired region. }
\item{top}{ Whether to bring window to top before reading. }
}
\details{
The possible components are \code{"red"}, \code{"green"}, \code{"blue"},
\code{"alpha"}, \code{"depth"}, and \code{"luminance"} (the sum of the three
colors). All are scaled from 0 to 1.
Note that the luminance is kept below 1 by truncating the sum; this is the
definition used for the \code{GL_LUMINANCE} component in OpenGL.
}
\value{
A vector, matrix or array containing the desired components. If one component
is requested, a vector or matrix will be returned depending on the size of
block requested (length 1 dimensions are dropped); if more, an array, whose last dimension
is the list of components.
}
\author{ Duncan Murdoch }
\seealso{ \code{\link{rgl.snapshot}} to write a copy to a file,
\code{demo("stereo")} for functions that make use of this to draw
a random dot stereogram and an anaglyph. }
\examples{
example(surface3d)
depth <- rgl.pixels(component = "depth")
if (length(depth) && is.matrix(depth)) # Protect against empty or single pixel windows
contour(depth)
}
\keyword{ dynamic }
rgl/man/as.mesh3d.default.Rd 0000644 0001762 0000144 00000010236 14137472630 015321 0 ustar ligges users \name{as.mesh3d}
\alias{as.mesh3d}
\alias{as.mesh3d.default}
\title{
Convert object to mesh object
}
\description{
The \code{as.mesh3d} generic function converts various objects
to \code{\link{mesh3d}} objects.
The default method takes takes a matrix of vertices
as input and (optionally) merges repeated vertices, producing a \code{\link{mesh3d}}
object as output. It will contain either triangles or quads or segments or points
according to the \code{type} argument.
If the generic is called without any argument, it will pass
all RGL ids from the current scene to the
\code{\link{as.mesh3d.rglId}} method.
}
\usage{
as.mesh3d(x, ...)
\method{as.mesh3d}{default}(x, y = NULL, z = NULL,
type = c("triangles", "quads", "segments", "points"),
smooth = FALSE,
tolerance = sqrt(.Machine$double.eps),
notEqual = NULL,
merge = TRUE,
...,
triangles)
}
\arguments{
\item{x, y, z}{
For the generic, \code{x} is the object to convert.
For the default method, \code{x}, \code{y} and \code{z} are
coordinates. Any reasonable way of defining the coordinates is
acceptable. See the function \code{\link{xyz.coords}} for details.
}
\item{type}{
What type of things should be in the mesh? Tries
this list in order until it finds one that works.
}
\item{smooth}{
If \code{TRUE}, \code{\link{addNormals}} will be called on the mesh
object to make it render smoothly.
}
\item{tolerance}{
The numerical tolerance to be used in \code{\link{all.equal}} to
determine whether two vertices should be merged.
}
\item{notEqual}{
If not \code{NULL}, an n by n matrix of logical values, where n is the
number of vertices as input. \code{TRUE} entries indicate that the
corresponding pair of vertices should not be merged even if they appear equal.
}
\item{merge}{
Should apparently equal vertices be merged?
}
\item{\dots}{
Material properties to pass to \code{\link{tmesh3d}} or \code{\link{qmesh3d}}.
}
\item{triangles}{
Deprecated. If present, \code{TRUE} indicates \code{type = "triangles"} and \code{FALSE} indicates \code{type = "quads"}.
}
}
\details{
The motivation for this function is the following problem: I was
asked whether RGL could render a surface made up of triangles or
quadrilaterals to look smooth. It can do that, but needs normals at
each vertex; they should be the average of the normals for each polygon
sharing that vertex. Then OpenGL will interpolate the normals across
the polygons and give the illusion of smoothness.
To do this, it needs to know which polygons share each vertex. If the
surface is described as a list of triangles or quadrilaterals, that
means identifying vertices that are in multiple polygons, and converting
the representation to a \code{"\link{mesh3d}"} object (which is a matrix of vertices
and a matrix of vertex numbers making up triangles or quads). Then the
\code{\link{addNormals}} function will add the normals.
Sometimes two polygons will share vertices (within numerical
tolerance) without the user wanting them to be considered internal to
the surface, or might want one sharp edge in an otherwise smooth
surface. This means I needed a way to declare that two vertices from
the original list of vertices in the triangles or quads are "not equal",
even when they test numerically equal. That's what the \code{notEqual} matrix specifies.
}
\value{
A \code{"\link{mesh3d}"} object with the same faces as in the
input, but (if \code{merge=TRUE}) with vertices that test equal to
within \code{tolerance} merged.
}
\author{
Duncan Murdoch
}
\examples{
xyz <- matrix(c(-1, -1, -1,
-1, 1, -1,
1, 1, -1,
1, -1, -1,
-1, 1, -1,
-1, 1, 1,
1, 1, 1,
1, 1, -1,
1, -1, -1,
1, 1, -1,
1, 1, 1,
1, -1, 1), byrow = TRUE, ncol = 3)
mesh <- as.mesh3d(xyz, type = "quads", col = "red")
mesh$vb
mesh$ib
open3d()
shade3d(mesh)
# Stop vertices 2 and 5 from being merged
notEQ <- matrix(FALSE, 12, 12)
notEQ[2, 5] <- TRUE
mesh <- as.mesh3d(xyz, type = "quads", notEqual = notEQ)
mesh$vb
mesh$ib
}
rgl/man/clipplaneControl.Rd 0000644 0001762 0000144 00000002611 14145464133 015415 0 ustar ligges users \name{clipplaneControl}
\alias{clipplaneControl}
\title{
Sets attributes of a clipping plane
}
\description{
This is a function to produce actions in a web display. A
\code{\link{playwidget}} or Shiny
input control (e.g. a \code{\link[shiny]{sliderInput}} control)
sets a value which controls attributes of one or more clipping
planes.
}
\usage{
clipplaneControl(a = NULL, b = NULL, c = NULL, d = NULL,
plane = 1, clipplaneids = tagged3d(tag), tag, ...)
}
\arguments{
\item{a, b, c, d}{
Parameter values for the clipping planes.
}
\item{plane}{
Which plane in the clipplane object?
}
\item{clipplaneids}{
The id of the clipplane object.
}
\item{tag}{
Select clipplane with matching tag. Ignored
if \code{clipplaneid} is specified.
}
\item{\dots}{
Other parameters passed to \code{\link{propertyControl}}.
}
}
\value{
A list of class \code{"rglControl"} of cleaned up parameter
values, to be used in an RGL widget.
}
\author{
Duncan Murdoch
}
\examples{
open3d()
saveopts <- options(rgl.useNULL = TRUE)
xyz <- matrix(rnorm(300), ncol = 3)
id <- plot3d(xyz, type="s", col = "blue", zlim = c(-3,3))["clipplanes"]
dvals <- c(3, -3)
widget <- rglwidget() \%>\%
playwidget(clipplaneControl(d = dvals, clipplaneids = id),
start = 0, stop = 1, step = 0.01,
rate = 0.5)
if (interactive() || in_pkgdown_example())
widget
options(saveopts)
}
rgl/man/open3d.Rd 0000644 0001762 0000144 00000006576 14145464133 013313 0 ustar ligges users \name{open3d}
\alias{open3d}
\alias{close3d}
\alias{cur3d}
\alias{set3d}
\alias{getr3dDefaults}
\alias{r3dDefaults}
\title{Work with RGL windows}
\description{
\code{open3d} opens a new RGL window; \code{cur3d} returns the device number of the current
window; \code{close3d} closes one or more windows.
}
\usage{
open3d(\dots, params = getr3dDefaults(),
useNULL = rgl.useNULL(), silent = FALSE)
close3d(dev = cur3d(), silent = TRUE)
cur3d()
set3d(dev, silent = FALSE)
getr3dDefaults(class = NULL, value = NULL)
r3dDefaults
}
\arguments{
\item{\dots}{arguments in \code{name = value} form, or a list of named
values. The names must come from the graphical
parameters described in \code{\link{par3d}}.}
\item{params}{a list of graphical parameters}
\item{useNULL}{whether to use the null graphics device}
\item{dev}{which device to close or use}
\item{silent}{whether report on what was done}
\item{class, value}{names of components to retrieve}
}
\details{
\code{open3d} opens a new RGL device, and sets the parameters as
requested. The \code{r3dDefaults} list returned by the
\code{getr3dDefaults} function will be used as default
values for parameters. As installed this sets the point of view to
'world coordinates' (i.e. x running from left to right, y from front
to back, z from bottom to top), the \code{mouseMode} to
\code{(zAxis, zoom, fov)}, and the field of view to 30 degrees. \code{useFreeType} defaults to \code{FALSE} on
Windows; on other systems it indicates the availability
of FreeType.
Users may create their own variable named \code{r3dDefaults} in the global
environment and it will override the installed one. If there
is a \code{bg} element in the list or the arguments, it should be
a list of arguments to pass to the \code{\link{bg3d}} function to
set the background.
The arguments to \code{open3d} may include \code{material}, a list
of material properties as in \code{\link{r3dDefaults}}, but note
that high level functions such as \code{\link{plot3d}} normally use
the \code{r3dDefaults} values in preference to this setting.
If \code{useNULL} is \code{TRUE}, RGL will use a \dQuote{null}
device. This device records objects as they are plotted, but
displays nothing. It is intended for use with \code{\link{rglwidget}}.
}
\value{
The \code{open3d} function returns the device that
was opened. If
\code{silent = TRUE}, it is returned invisibly.
The \code{cur3d} function returns the current device,
or the value 0 if there isn't one.
\code{set3d} returns the device number of the
previously active device.
The \code{close3d} function returns the new current
device, invisibly.
The \code{r3dDefaults} variable is a list containing default
settings. The \code{getr3dDefaults} function searches the user's
global environment for \code{r3dDefaults} and returns the
one in the RGL namespace if it was not found there.
The components of the list may include any settable \code{par3d}
parameter, or \code{"material"}, which should include a list
of default \code{\link{material3d}} properties, or \code{"bg"},
which is a
list of defaults to pass to the \code{\link{bg3d}} function.
}
\seealso{
\code{\link{rgl.useNULL}} for default usage of null device.
}
\examples{
r3dDefaults
open3d()
shade3d(cube3d(color = rainbow(6), meshColor = "faces"))
cur3d()
}
\keyword{dynamic}
rgl/man/extrude3d.Rd 0000644 0001762 0000144 00000002637 14100762640 014017 0 ustar ligges users \name{extrude3d}
\alias{extrude3d}
\title{
Generate extrusion mesh
}
\description{
Given a two-dimensional polygon, this generates a three-dimensional extrusion
of the shape by triangulating the polygon and creating a cylinder with
that shape as the end faces.
}
\usage{
extrude3d(x, y = NULL, thickness = 1, smooth = FALSE, ...)
}
\arguments{
\item{x, y}{
A polygon description in one of the forms supported by \code{\link{triangulate}}.
}
\item{thickness}{
The extrusion will have this thickness.
}
\item{smooth}{
logical; should normals be added so that the edges of the extrusion appear
smooth?
}
\item{\dots}{
Other parameters to pass to \code{\link{tmesh3d}} when constructing the
mesh.
}
}
\details{
The extrusion is always constructed with the polygon in the xy plane at
\code{z = 0} and another copy at \code{z = thickness}. Use
the transformation functions (e.g. \code{\link{rotate3d}}) to
obtain other orientations and placements.
}
\value{
A mesh object containing a triangulation of the polygon
for each face, and quadrilaterals for the sides.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{polygon3d}} for a simple polygon, \code{\link{triangulate}} for
the triangulation, \code{\link{turn3d}} for a solid of rotation.
}
\examples{
x <- c(1:10, 10:1)
y <- rev(c(rep(c(0, 2), 5), rep(c(1.5, -0.5), 5)))
plot(x, y, type = "n")
polygon(x, y)
open3d()
shade3d( extrude3d(x, y), col = "red" )
}
\keyword{ graphics }
rgl/man/shiny.Rd 0000644 0001762 0000144 00000003665 14100762641 013245 0 ustar ligges users \name{shiny}
\alias{rglwidgetOutput}
\alias{renderRglwidget}
\alias{playwidgetOutput}
\alias{renderPlaywidget}
\title{
Functions for integration of RGL widgets into
Shiny app
}
\description{
These functions allow an RGL scene to be embedded
in a Shiny app.
}
\usage{
rglwidgetOutput(outputId, width = "512px", height = "512px")
renderRglwidget(expr, env = parent.frame(), quoted = FALSE, outputArgs = list())
playwidgetOutput(outputId, width = "0px", height = "0px")
renderPlaywidget(expr, env = parent.frame(), quoted = FALSE, outputArgs = list())
}
\arguments{
\item{outputId}{
The name for the control.
}
\item{width, height}{
Width and height to display the control.
}
\item{expr}{An R expression returning
a \code{\link{rglwidget}} (for \code{renderRglwidget}) or a \code{\link{playwidget}} (for \code{renderPlaywidget}) as output.}
\item{env}{The environment in which to evaluate \code{expr}.}
\item{quoted}{Is the expression already quoted?}
\item{outputArgs}{A list containing arguments; see details below.}
}
\details{
Use \code{rglwidgetOutput} or \code{playwidgetOutput} as an output
object in a Shiny user
interface section; use \code{renderRglwidget} or \code{renderPlaywidget}
as the render
function in the server section.
In a dynamic R Markdown document with \code{runtime: shiny}, you
only call the render function, and may optionally pass \code{width}
and \code{height} to the output function by putting them in
a list in \code{outputArgs}. See the example below.
}
\value{
Used internally by Shiny.
}
\author{
Duncan Murdoch
}
\examples{
\dontrun{
# This could be used in a dynamic R Markdown document. See
# demo("shinyDemo") and demo("simpleShinyRgl") for Shiny apps.
inputPanel(
sliderInput("n", label = "n", min = 10, max = 100, value = 10, step = 10)
)
renderRglwidget({
n <- input$n
try(close3d())
plot3d(rnorm(n), rnorm(n), rnorm(n))
rglwidget()
}, outputArgs = list(width = "auto", height = "300px"))
}
}
rgl/man/arrow3d.Rd 0000644 0001762 0000144 00000006650 14100762640 013470 0 ustar ligges users \name{arrow3d}
\alias{arrow3d}
\title{
Draw an arrow
}
\description{
Draws various types of arrows in a scene.
}
\usage{
arrow3d(p0 = c(1, 1, 1), p1 = c(0, 0, 0),
barblen, s = 1/3, theta = pi/12,
type = c("extrusion", "lines", "flat", "rotation"),
n = 3, width = 1/3, thickness = 0.618 * width,
spriteOrigin = NULL,
plot = TRUE, ...)
}
\arguments{
\item{p0}{
The base of the arrow.
}
\item{p1}{
The head of the arrow.
}
\item{barblen}{
The length of the barbs (in display coordinates).
Default given by \code{s}.
}
\item{s}{
The length of the barbs as a fraction of line length. Ignored if \code{barblen} is present.
}
\item{theta}{
Opening angle of barbs
}
\item{type}{
Type of arrow to draw. Choose one from the list
of defaults. Can be abbreviated. See below.
}
\item{n}{
Number of barbs.
}
\item{width}{
Width of shaft as fraction of barb width.
}
\item{thickness}{
Thickness of shaft as fraction of barb width.
}
\item{spriteOrigin}{
If arrow is to be replicated as sprites, the origins relative
to which the sprites are drawn.
}
\item{plot}{
If \code{TRUE} (the default), plot the object;
otherwise return the computed data that
would be used to plot it.
}
\item{\dots}{
Material properties passed to \code{\link{polygon3d}}, \code{\link{shade3d}} or \code{\link{segments3d}}.
}
}
\details{
Four types of arrows can be drawn. The shapes
of all of them are affected by \code{p0}, \code{p1}, \code{barblen},
\code{s}, \code{theta}, material properties
in \code{...}, and \code{spriteOrigin}. Other parameters
only affect some of the types, as shown.
\describe{
\item{\code{"extrusion"}}{(default) A 3-dimensional
flat arrow, drawn with \code{\link{shade3d}}. Affected by \code{width}, \code{thickness} and
\code{smooth}.}
\item{\code{"lines"}}{Drawn with lines, similar to \code{\link{arrows}}, drawn with \code{\link{segments3d}}. Affected by \code{n}.}
\item{\code{"flat"}}{A flat arrow, drawn with \code{\link{polygon3d}}. Affected by \code{width} and \code{smooth}.}
\item{\code{"rotation"}}{A solid of rotation,
drawn with \code{\link{shade3d}}. Affected by
\code{n} and \code{width}.}
}
Normally this function draws just one arrow from
\code{p0} to \code{p1}, but
if \code{spriteOrigin} is given (in any form
that \code{\link{xyz.coords}(spriteOrigin)} can
handle), arrows will be drawn for each point
specified, with \code{p0} and \code{p1}
interpreted relative to those origins. The
arrows will be drawn as 3D sprites which will
maintain their orientation as the scene is rotated, so this is a good way to indicate
particular locations of interest in the scene.
}
\value{
If \code{plot = TRUE} (the default), this is
called mainly for the side effect of drawing
the arrow; invisibly returns the id(s) of
the objects drawn.
If \code{plot = FALSE}, the data that would be
used in the plot (not including material
properties) is returned.
}
\author{
Design based on \code{heplots::arrow3d}, which contains modifications by Michael Friendly
to a function posted by Barry Rowlingson to R-help on 1/10/2010. Additions by Duncan Murdoch.
}
\examples{
xyz <- matrix(rnorm(300), ncol = 3)
plot3d(xyz)
arrow3d(xyz[1,], xyz[2,], type = "extrusion", col = "red")
arrow3d(xyz[3,], xyz[4,], type = "flat", col = "blue")
arrow3d(xyz[5,], xyz[6,], type = "rotation", col = "green")
arrow3d(xyz[7,], xyz[8,], type = "lines", col = "black")
arrow3d(spriteOrigin = xyz[9:12,], col = "purple")
} rgl/man/texts.Rd 0000644 0001762 0000144 00000006233 14142256754 013265 0 ustar ligges users \name{text3d}
\alias{text3d}
\alias{texts3d}
\title{Add text to plot}
\description{
Adds text to the scene. The text is positioned in 3D space.
Text is always oriented towards the camera.
}
\usage{
text3d(x, y = NULL, z = NULL, texts, adj = 0.5, pos = NULL, offset = 0.5,
usePlotmath = is.language(texts), ...)
texts3d(x, y = NULL, z = NULL, texts, adj = 0.5, pos = NULL, offset = 0.5,
usePlotmath = is.language(texts), ...)
}
\arguments{
\item{x, y, z}{point coordinates. Any reasonable way of defining the
coordinates is acceptable. See the function \code{\link[grDevices]{xyz.coords}}
for details.}
\item{texts}{text character vector to draw}
\item{adj}{ one value specifying the horizontal adjustment, or two,
specifying horizontal and vertical adjustment respectively, or three, specifying adjustment in all
three directions.}
\item{pos}{ a position specifier for the text. If specified, this
overrides any \code{adj} value given. Values of 0, 1, 2, 3, 4, 5, 6 respectively indicate positions at, below, to the left of, above, to the right of, in front of, and behind the specified coordinates.}
\item{offset}{ when \code{pos} is specified, this value gives the offset of the label from the specified coordinate in fractions of a character width.}
\item{ usePlotmath }{logical. Should \code{\link{plotmath3d}} be used for the text?}
\item{ ... }{In the other functions, additional parameters to pass to \code{rgl.texts}.}
}
\details{
The \code{adj} parameter determines the position of the text relative to the
specified coordinate. Use \code{adj = c(0, 0)} to place the left bottom corner at
\code{(x, y, z)}, \code{adj = c(0.5, 0.5)} to center the text there, and \code{adj = c(1, 1)}
to put the right top corner there. The optional second coordinate for vertical
adjustment defaults to \code{0.5}. Placement is done using the "advance" of
the string and the "ascent" of the font relative to the baseline, when these metrics
are known.
\code{text3d} and \code{texts3d} draw text using the \link{r3d}
conventions. These are synonyms; the former is singular to be
consistent with the classic 2-D graphics functions, and the latter is
plural to be consistent with all the other graphics primitives. Take
your choice!
If any coordinate or text is \code{NA}, that text is not plotted.
If \code{usePlotmath} is \code{TRUE}, the work will be done
by the \code{\link{plotmath3d}} function instead of \code{rgl.texts}. This is the default if the \code{texts}
parameter is \dQuote{language}, e.g. the result of
a call to \code{\link{expression}} or \code{\link{quote}}.
}
\value{
The text drawing functions return the object ID of the text object (or sprites, in case of \code{usePlotmath = TRUE})
invisibly.
}
\examples{
open3d()
famnum <- rep(1:3, 8)
family <- c("serif", "sans", "mono")[famnum]
font <- rep(rep(1:4, each = 3), 2)
cex <- rep(1:2, each = 12)
text3d(font, cex, famnum, text = paste(family, font), adj = 0.5,
color = "blue", family = family, font = font, cex = cex)
}
\seealso{
\code{\link{r3d}}, \code{\link{rgl.texts}}, \code{\link{plotmath3d}}, \code{\link{rglExtrafonts}} for adding fonts
}
\keyword{dynamic}
rgl/man/par3d.Rd 0000644 0001762 0000144 00000031555 14145464133 013127 0 ustar ligges users \name{par3d}
\alias{par3d}
\concept{activeSubscene}
\concept{antialias}
\concept{bbox}
\concept{cex}
\concept{family}
\concept{font}
\concept{fontname}
\concept{FOV}
\concept{ignoreExtent}
\concept{maxClipPlanes}
\concept{modelMatrix}
\concept{listeners}
\concept{mouseMode}
\concept{projMatrix}
\concept{scale}
\concept{skipRedraw}
\concept{useFreeType}
\concept{userMatrix}
\concept{userProjection}
\concept{viewport}
\concept{windowRect}
\concept{zoom}
\title{Set or query RGL parameters}
\description{
\code{par3d} can be used to set or query graphical parameters in RGL.
Parameters can be set by specifying them as arguments to \code{par3d} in
\code{name = value} form, or by passing them as a list of named
values.
}
\usage{
par3d(\dots, no.readonly = FALSE, dev = cur3d(),
subscene = currentSubscene3d(dev))
}
\arguments{
\item{\dots}{arguments in \code{name = value} form, or a list of tagged
values. The names must come from the graphical parameters described
below.}
\item{no.readonly}{logical; if \code{TRUE} and there are no other
arguments, only those parameters which can be set by a
subsequent \code{par3d()} call are returned.}
\item{dev}{integer; the RGL device.}
\item{subscene}{integer; the subscene.}
}
\details{
Parameters are queried by giving one or more character vectors to
\code{par3d}.
\code{par3d()} (no arguments) or \code{par3d(no.readonly = TRUE)} is used to
get \emph{all} the graphical parameters (as a named list).
By default, queries and modifications apply to the current subscene
on the current device; specify \code{dev} and/or \code{subscene} to
change this. Some parameters apply to the device as a whole;
these are marked in the list below.
}
\value{
When parameters are set, their former values are returned in an
invisible named list. Such a list can be passed as an argument to
\code{par3d} to restore the parameter values.
Use \code{par3d(no.readonly = TRUE)} for the full list of parameters
that can be restored.
When just one parameter is queried, its value is returned directly.
When two or more parameters are queried, the result is a list of
values, with the list names giving the parameters.
Note the inconsistency: setting one parameter returns a list, but
querying one parameter returns an object.
}
\section{Parameters}{
\emph{\bold{R.O.}} indicates \emph{\bold{read-only arguments}}: These
may only be used in queries, i.e., they do \emph{not} set anything.
\describe{
\item{\code{activeSubscene}}{\emph{\bold{R.O.}} integer. Used
with \code{\link{rgl.setMouseCallbacks}}: during a
callback, indicates the id of the subscene that was clicked.}
\item{\code{antialias}}{\emph{\bold{R.O.}} in \code{par3d}, may be
set in \code{open3d}. The (requested) number of hardware
antialiasing planes to use (with multisample antialiasing). The
OpenGL driver may not support the requested number, in which case
\code{par3d("antialias")} will report what was actually set. Applies to the whole device.}
\item{\code{cex}}{real. The default size for text.}
\item{\code{family}}{character. The default device independent family name; see \code{\link{rgl.texts}}.
Applies to the whole device.}
\item{\code{font}}{integer. The default font number (from 1 to 4; see \code{\link{rgl.texts}}).
Applies to the whole device.}
\item{\code{useFreeType}}{logical. Should FreeType fonts be used?
Applies to the whole device.}
\item{\code{fontname}}{\emph{\bold{R.O.}}; the system-dependent name of the current font.
Applies to the whole device.}
\item{\code{FOV}}{real. The field of view, from 0 to 179 degrees. This controls
the degree of parallax in the perspective view.
Isometric perspective corresponds to \code{FOV = 0}.}
\item{\code{ignoreExtent}}{logical. Set to \code{TRUE} so that subsequently plotted objects
will be ignored in calculating the bounding box of the scene. Applies to the
whole device.}
\item{\code{maxClipPlanes}}{\emph{\bold{R.O.}}; an integer giving the maximum
number of clip planes that can be defined in the current system. Applies to the whole device.}
\item{\code{modelMatrix}}{\emph{\bold{R.O.}}; a 4 by 4 matrix describing the position
of the user data. See the Note below.}
\item{\code{listeners}}{integer. A vector of subscene id values. If a subscene receives
a mouse event (see \code{mouseMode} just below), the same action will be carried out
on all subscenes in this list. (The subscene itself is normally listed as a listener.
If it is not listed, it will not respond to its own mouse events.)}
\item{\code{mouseMode}}{character. A vector of 5 strings describing
mouse actions. The 5 entries are named
\code{c("none", "left", "right", "middle", "wheel")}, corresponding to actions for no button,
the left, right or middle button, and the
mouse wheel.
Partial matching to action names is used. Possible values for the actions are:
\describe{
\item{\code{"none"}}{No action for this button.}
\item{\code{"trackball"}}{Mouse acts as a virtual trackball, rotating the scene.}
\item{\code{"xAxis"}}{Similar to \code{"trackball"}, but restricted to X axis rotation.}
\item{\code{"yAxis"}}{Y axis rotation.}
\item{\code{"zAxis"}}{Z axis rotation.}
\item{\code{"polar"}}{Mouse rotates the scene by moving in polar coordinates.}
\item{\code{"selecting"}}{Mouse is used for selection. This is not normally set by the
user, but is used internally by the \code{\link{select3d}} function.}
\item{\code{"zoom"}}{Mouse is used to zoom the display.}
\item{\code{"fov"}}{Mouse changes the field of view of the display.}
\item{\code{"user"}}{Used when a user handler is set by
\code{\link{rgl.setMouseCallbacks}}.}
}
Possible values for the last entry corresponding to the mouse wheel also include
\describe{
\item{\code{"pull"}}{Pulling on the mouse wheel increases magnification, i.e. \dQuote{pulls the scene closer}.}
\item{\code{"push"}}{Pulling on the mouse wheel decreases magnification, i.e. \dQuote{pushes the scene away}.}
\item{\code{"user2"}}{Used when a user handler is set by
\code{\link{rgl.setWheelCallback}}.}
}
A common default on Mac OSX is to convert a two finger drag on a trackpad to a mouse wheel rotation.
The first entry is for actions to take when
no mouse button is pressed. Legal values are the same
as for the mouse buttons.
The first entry was added after \pkg{rgl} version 0.106.8. For back compatibility, if the vector
of actions is less than 5 entries, \code{"none"}
will be added at the start of it.
}
\item{\code{observer}}{\emph{\bold{R.O.}}; the position of the observer relative to
the model. Set by \code{\link{observer3d}}. See the Note below.}
\item{\code{projMatrix}}{\emph{\bold{R.O.}}; a 4 by 4 matrix describing the current
projection of the scene.}
\item{\code{scale}}{real. A vector of 3 values indicating the amount by which to
rescale each axis before display. Set by \code{\link{aspect3d}}.}
\item{\code{skipRedraw}}{whether to update the display. Set to \code{TRUE} to suspend
updating while making multiple changes to the scene. See \code{demo(hist3d)} for an example.
Applies to the whole device.}
\item{\code{userMatrix}}{a 4 by 4 matrix describing user actions to
display the scene.}
\item{\code{userProjection}}{a 4 by 4 matrix describing
changes to the projection.}
\item{\code{viewport}}{real. A vector giving the dimensions of the
window in pixels. The entries are taken to be \code{c(x, y, width, height)} where
\code{c(x, y)} are the coordinates in pixels of the lower left corner within the window.}
\item{\code{zoom}}{real. A positive value indicating the current
magnification of the scene.}
\item{\code{bbox}}{\emph{\bold{R.O.}}; real. A vector of six values indicating the current values of the
bounding box of the scene (xmin, xmax, ymin, ymax, zmin, zmax)}
\item{\code{windowRect}}{integer. A vector of four values indicating the left, top, right and
bottom of the displayed window (in pixels). Applies to the whole device.}
}
}
\note{
The \code{"xAxis"}, \code{"yAxis"} and \code{"zAxis"} mouse modes rotate
relative to the coordinate system of the data, regardless of the current
orientation of the scene.
When multiple parameters are set, they are set in the order given. In some
cases this may lead to warnings and ignored values; for example, some font
families only support \code{cex = 1}, so changing both \code{cex} and
\code{family} needs to be done in the right order. For example, when using the
\code{"bitmap"} family on Windows, \code{par3d(family = "sans", cex = 2)}
will work, but \code{par3d(cex = 2, family = "sans")} will leave \code{cex}
at 1 (with a warning that the \code{"bitmap"} family only supports that size).
Although \code{par3d("viewport")} names the entries of the reported vector,
names are ignored when setting the viewport and entries must be specified
in the standard order.
In \pkg{rgl} versions 0.94.x the \code{modelMatrix} entry had a changed meaning;
before and after that it contains a copy of the OpenGL MODELVIEW matrix.
As of version 0.100.32, when changing the \code{"windowRect"} parameter, the
\code{"viewport"} for the root (or specified) subscene
is changed immediately. This fixes a bug where in earlier
versions it would only be changed when the window was redrawn, potentially after another command making use of the value.
Default values are not described here, as several of them
are changed by the \code{\link{r3dDefaults}} variable when
the window is opened by \code{\link{open3d}}.
}
\section{Rendering}{
The parameters returned by \code{par3d} are sufficient to determine where RGL would render
a point on the screen. Given a column vector \code{(x, y, z)} in a subscene \code{s},
it performs the equivalent of
the following operations:
\enumerate{
\item It converts the point to homogeneous coordinates by appending \code{w = 1}, giving
the vector \code{v = (x, y, z, 1)}.
\item It calculates the \code{M = par3d("modelMatrix")} as a product from right to left
of the following matrices:
\itemize{
\item A matrix to translate the centre of the bounding box to the origin.
\item A matrix to rescale according to \code{par3d("scale")}.
\item The \code{par3d("userMatrix")} as set by the user.
\item A matrix which may be set by mouse movements.
\item If \code{s} has the \code{"model"} set to \code{"modify"}, a similar collection of
matrices using parameters from the parent subscene.
}
\item It multiplies the point by \code{M} giving \code{u = M \%*\% v}.
\item It multiplies that point by a matrix based on the observer position
to translate the origin to the centre of the viewing region.
\item Using this location and information on the
normals (which have been similarly transformed), it performs lighting calculations.
\item It obtains the projection matrix \code{P = par3d("projMatrix")} based on the bounding box and field of view
or observer location, multiplies that by the \code{userProjection} matrix to give \code{P}. It multiplies the point
by it giving \code{P \%*\% u = (x2, y2, z2, w2)}.
\item It converts back to Euclidean coordinates by dividing the first 3 coordinates by \code{w2}.
\item The new value \code{z2/w2} represents the depth into the scene of the point. Depending
on what has already been plotted, this depth might be obscured, in which case nothing more is plotted.
\item If the point is not culled due to depth, the \code{x2} and \code{y2} values are used
to determine the point in the image. The \code{par3d("viewport")} values are used to translate
from the range \code{(-1, 1)} to pixel locations, and the point is plotted.
\item If hardware antialiasing is enabled, then the whole process is
repeated multiple times (at least conceptually) with different
locations in each pixel sampled to determine what is plotted there,
and then the images are combined into what is displayed.
}
See ?\link{matrices} for more information on homogeneous and Euclidean coordinates.
Note that many of these calculations are done on the graphics card using single precision;
you will likely see signs of rounding error if your scene requires more than 4 or 5
digit precision to distinguish values in any coordinate.
}
\seealso{
\code{\link{rgl.viewpoint}} to set \code{FOV} and \code{zoom}.
\code{\link{open3d}} for how to open a new window
with default settings for these parameters.
}
\references{
OpenGL Architecture Review Board (1997). OpenGL Programming Guide. Addison-Wesley.
}
\examples{
open3d()
shade3d(cube3d(color = rainbow(6), meshColor = "faces"))
save <- par3d(userMatrix = rotationMatrix(90*pi/180, 1, 0, 0))
highlevel() # To trigger display
save
par3d("userMatrix")
par3d(save)
highlevel()
par3d("userMatrix")
}
\keyword{dynamic}
rgl/man/tkspin3d.Rd 0000644 0001762 0000144 00000001370 14100762641 013641 0 ustar ligges users \name{tkspin3d}
\alias{tkspin3d}
\title{Create TCL/TK controller for RGL window}
\description{
This function creates a TCL/TK window containing buttons to spin and
resize one or more RGL windows.
}
\usage{
tkspin3d(dev = cur3d(), ...)
}
\arguments{
\item{dev}{A vector of one or more RGL device numbers to control }
\item{...}{Named parameters in that match named formal arguments
to \code{\link{tkspinControl}} are passed there, while others are passed to \code{\link[tcltk:TkWidgets]{tktoplevel}}}}
\author{ Ming Chen and Duncan Murdoch }
\seealso{ \code{\link{tkspinControl}}}
\examples{
if (interactive() && !in_pkgdown_example()) {
open3d()
points3d(rnorm(100), rnorm(100), rnorm(100), size=3)
axes3d()
box3d()
tkspin3d()
}
}
rgl/man/ellipse3d.Rd 0000644 0001762 0000144 00000006332 14100762640 013770 0 ustar ligges users \name{ellipse3d}
\alias{ellipse3d}
\alias{ellipse3d.default}
\alias{ellipse3d.lm}
\alias{ellipse3d.glm}
\alias{ellipse3d.nls}
\title{
Make an ellipsoid
}
\description{
A generic function and several methods
returning an ellipsoid or other outline of a confidence region
for three parameters.
}
\usage{
ellipse3d(x, \dots)
\method{ellipse3d}{default}(x, scale = c(1, 1, 1), centre = c(0, 0, 0), level = 0.95,
t = sqrt(qchisq(level, 3)), which = 1:3, subdivide = 3, smooth = TRUE, ...)
\method{ellipse3d}{lm}(x, which = 1:3, level = 0.95, t = sqrt(3 * qf(level,
3, x$df.residual)), ...)
\method{ellipse3d}{glm}(x, which = 1:3, level = 0.95, t, dispersion, ...)
\method{ellipse3d}{nls}(x, which = 1:3, level = 0.95, t = sqrt(3 * qf(level,
3, s$df[2])), ...)
}
\arguments{
\item{x}{
An object. In the default method the parameter \code{x} should be a
square positive definite matrix at least 3x3
in size. It will be treated as the correlation or covariance
of a multivariate normal distribution.
}
\item{\dots}{
Additional parameters to pass to the default method or to \code{\link{qmesh3d}}.
}
\item{scale}{
If \code{x} is a correlation matrix, then the standard deviations of each
parameter can be given in the scale parameter. This defaults to \code{c(1, 1, 1)},
so no rescaling will be done.
}
\item{centre}{
The centre of the ellipse will be at this position.
}
\item{level}{
The confidence level of a simultaneous confidence region. The default is
0.95, for a 95\% region. This is used to control the size of the ellipsoid.
}
\item{t}{
The size of the ellipse may also be controlled by specifying the value
of a t-statistic on its boundary. This defaults to the appropriate
value for the confidence region.
}
\item{which}{
This parameter selects which variables from the object will be
plotted. The default is the first 3.
}
\item{subdivide}{
This controls the number of subdivisions (see \code{\link{subdivision3d}})
used in constructing the ellipsoid. Higher numbers give a smoother shape.
}
\item{smooth}{
If \code{TRUE}, smooth interpolation of normals is used; if \code{FALSE},
a faceted ellipsoid will be displayed.
}
\item{dispersion}{
The value of dispersion to use. If specified, it is treated as fixed,
and chi-square limits for \code{t} are used. If missing, it is
taken from \code{summary(x)}.
}
}
\value{
A \code{\link{mesh3d}} object representing the ellipsoid.
}
\examples{
# Plot a random sample and an ellipsoid of concentration corresponding to a 95\%
# probability region for a
# trivariate normal distribution with mean 0, unit variances and
# correlation 0.8.
if (requireNamespace("MASS", quietly = TRUE)) {
Sigma <- matrix(c(10, 3, 0, 3, 2, 0, 0, 0, 1), 3, 3)
Mean <- 1:3
x <- MASS::mvrnorm(1000, Mean, Sigma)
open3d()
plot3d(x, box = FALSE)
plot3d( ellipse3d(Sigma, centre = Mean), col = "green", alpha = 0.5, add = TRUE)
}
# Plot the estimate and joint 90\% confidence region for the displacement and cylinder
# count linear coefficients in the mtcars dataset
data(mtcars)
fit <- lm(mpg ~ disp + cyl , mtcars)
open3d()
plot3d(ellipse3d(fit, level = 0.90), col = "blue", alpha = 0.5, aspect = TRUE)
}
\keyword{dplot}
rgl/man/readSTL.Rd 0000644 0001762 0000144 00000005547 14145464133 013416 0 ustar ligges users \name{readSTL}
\alias{readSTL}
\alias{writeSTL}
\title{
Read and write STL (stereolithography) format files
}
\description{
These functions read and write STL files. This is a simple file format that
is commonly used in 3D printing. It does not represent text,
only triangles. The \code{writeSTL} function converts some RGL object
types to triangles.
}
\usage{
readSTL(con, ascii = FALSE, plot = TRUE, ...)
writeSTL(con, ascii = FALSE,
pointRadius = 0.005,
pointShape = icosahedron3d(),
lineRadius = pointRadius,
lineSides = 20,
ids = tagged3d(tags),
tags = NULL)
}
\arguments{
\item{con}{
A connection or filename.
}
\item{ascii}{
Whether to use the ASCII format or the binary format.
}
\item{plot}{
On reading, should the object be plotted?
}
\item{\dots}{
If plotting, other parameters to pass to \code{\link{triangles3d}}
}
\item{pointRadius, lineRadius}{
The radius of points and lines relative to the overall scale of the figure.
}
\item{pointShape}{
A mesh shape to use for points. It is scaled by the \code{pointRadius}.
}
\item{lineSides}{
Lines are rendered as cylinders with this many sides.
}
\item{ids}{
The identifiers (from \code{\link{ids3d}}) of the
objects to write. If \code{NULL}, try to write everything.
}
\item{tags}{
Alternate way to specify \code{ids}. Ignored if \code{ids} is
given.
}
}
\details{
The current implementation is limited. For reading, it ignores normals
and color information. For writing, it only outputs triangles, quads, planes, spheres,
points, line segments, line strips and surfaces, and does not write color information.
Lines and points are rendered in an isometric scale: if your data scales vary, they
will look strange.
Since the STL format only allows one object per file, all RGL objects
are combined into a single object when output.
The output file is readable by Blender and Meshlab; the latter can write in
a number of other formats, including U3D, suitable for import into a PDF document.
}
\value{
\code{readSTL} invisibly returns the object id if \code{plot = TRUE}, or (visibly)
a matrix of vertices of the triangles if not.
\code{writeSTL} invisibly returns the name of the connection to which the
data was written.
}
\references{
The file format was found on Wikipedia on October 25, 2012. I learned
about the STL file format from David Smith's blog reporting on
Ian Walker's \code{r2stl} function.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{scene3d}} saves a copy of a scene to an R variable;
\code{\link{rglwidget}}, \code{\link{writeASY}}, \code{\link{writePLY}}, \code{\link{writeOBJ}} and \code{\link{writeSTL}}
write the scene to a file in various other formats.
}
\examples{
filename <- tempfile(fileext = ".stl")
open3d()
shade3d( icosahedron3d(col = "magenta") )
writeSTL(filename)
open3d()
readSTL(filename, col = "red")
}
\keyword{ graphics }
rgl/man/plot3d.Rd 0000644 0001762 0000144 00000010035 14145464133 013311 0 ustar ligges users \name{plot3d}
\alias{plot3d}
\alias{plot3d.default}
\alias{plot3d.mesh3d}
\title{3D scatterplot}
\description{
Draws a 3D scatterplot.
}
\usage{
plot3d(x, ...)
\method{plot3d}{default}(x, y, z,
xlab, ylab, zlab, type = "p",
col, size, lwd, radius,
add = FALSE, aspect = !add,
xlim = NULL, ylim = NULL, zlim = NULL,
forceClipregion = FALSE,
decorate = !add, ...)
\method{plot3d}{mesh3d}(x, xlab = "x", ylab = "y", zlab = "z", type = c("shade", "wire", "dots"),
add = FALSE, aspect = !add, ...)
}
\arguments{
\item{x, y, z}{vectors of points to be plotted. Any reasonable way of defining the
coordinates is acceptable. See the function \code{\link[grDevices]{xyz.coords}}
for details.}
\item{xlab, ylab, zlab}{labels for the coordinates.}
\item{type}{For the default method, a single character indicating the type of item to plot.
Supported types are: 'p' for points, 's' for spheres,
'l' for lines, 'h' for line segments
from \code{z = 0}, and 'n' for nothing. For the \code{mesh3d} method, one of
'shade', 'wire', or 'dots'. Partial matching is used.
}
\item{col}{the color to be used for plotted items.}
\item{size}{the size for plotted points.}
\item{lwd}{the line width for plotted items.}
\item{radius}{the radius of spheres: see Details below.}
\item{add}{whether to add the points to an existing plot.}
\item{aspect}{either a logical indicating whether to adjust the aspect ratio, or a new ratio.}
\item{xlim, ylim, zlim}{If not \code{NULL}, set clipping
limits for the plot.}
\item{forceClipregion}{Force a clipping region to be used,
whether or not limits are given.}
\item{decorate}{Whether to add bounding axes and other
decorations.}
\item{\dots}{additional parameters which will be passed to \code{\link{par3d}}, \code{\link{material3d}}
or \code{\link{decorate3d}}.}
}
\value{
\code{plot3d} is called for the side effect of drawing the plot; a vector
of object IDs is returned.
}
\details{
\code{plot3d} is a partial 3D analogue of plot.default.
Missing values in the data are skipped, as in standard graphics.
If \code{aspect} is \code{TRUE}, aspect ratios of \code{c(1, 1, 1)} are passed to
\code{\link{aspect3d}}. If \code{FALSE}, no aspect adjustment is done. In other
cases, the value is passed to \code{\link{aspect3d}}.
With \code{type = "s"}, spheres are drawn centered at the specified locations.
The radius may be controlled by \code{size} (specifying the size relative
to the plot display, with the default \code{size = 3} giving a radius
about 1/20 of the plot region) or \code{radius} (specifying it on the data scale
if an isometric aspect ratio is chosen, or on an average scale
if not).
}
\section{Clipping}{
If any of \code{xlim}, \code{ylim} or \code{zlim} are specified,
they should be length two vectors giving lower and upper
clipping limits for the corresponding coordinate. \code{NA}
limits will be ignored.
If any clipping limits are given, then the data will be
plotted in a newly created subscene within the current one;
otherwise plotting will take place directly in the current
subscene. This subscene is named \code{"clipregion"}
in the results. This may affect the appearance of transparent
objects if some are drawn in the \code{plot3d} call and others after,
as RGL will not attempt to depth-sort objects if they are
in different subscenes. It is best to draw all overlapping
transparent objects in the same subscene. See the example
in \code{\link{planes3d}}. It will also affect the use
of \code{\link{clipplanes3d}}; clipping planes need to be in the
same subscene as the objects being clipped.
Use \code{forceClipregion = TRUE} to force creation of this
subscene even without specifying limits.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{plot.default}},
\code{\link{open3d}}, \code{\link{par3d}}.
There are \code{\link{plot3d.function}} and \code{\link{plot3d.deldir}} methods for plotting surfaces.
}
\examples{
open3d()
x <- sort(rnorm(1000))
y <- rnorm(1000)
z <- rnorm(1000) + atan2(x, y)
plot3d(x, y, z, col = rainbow(1000))
}
\keyword{dynamic}
rgl/man/mesh3d.Rd 0000644 0001762 0000144 00000006272 14100762640 013272 0 ustar ligges users \name{mesh3d}
\alias{shape3d}
\alias{mesh3d}
\alias{qmesh3d}
\alias{tmesh3d}
\title{Construct 3D mesh objects}
\description{
Creates meshes containing points, segments, triangles and quads.
}
\usage{
mesh3d( x, y = NULL, z = NULL, vertices,
material = NULL,
normals = NULL, texcoords = NULL,
points = NULL, segments = NULL,
triangles = NULL, quads = NULL,
meshColor = c("vertices", "edges", "faces", "legacy"))
qmesh3d(vertices, indices, homogeneous = TRUE, material = NULL,
normals = NULL, texcoords = NULL,
meshColor = c("vertices", "edges", "faces", "legacy"))
tmesh3d(vertices, indices, homogeneous = TRUE, material = NULL,
normals = NULL, texcoords = NULL,
meshColor = c("vertices", "edges", "faces", "legacy"))
}
\arguments{
\item{x, y, z}{coordinates. Any reasonable way of defining the
coordinates is acceptable. See the function \code{\link[grDevices]{xyz.coords}}
for details.}
\item{vertices}{A 4 row matrix of homogeneous coordinates; takes
precedence over \code{x, y, z}.}
\item{material}{material properties for later rendering}
\item{normals}{normals at each vertex}
\item{texcoords}{texture coordinates at each vertex}
\item{points}{vector of indices of vertices to draw as points}
\item{segments}{2 x n matrix of indices of vertices to draw as
segments}
\item{triangles}{3 x n matrix of indices of vertices to draw
as triangles}
\item{quads}{4 x n matrix of indices of vertices to draw as quads}
\item{indices}{(obsolete) 3 or 4 x n matrix of vertex indices}
\item{homogeneous}{(obsolete) should \code{tmesh3d} and \code{qmesh3d} vertices be assumed to be homogeneous?}
\item{meshColor}{how should colours be interpreted? See details in \code{\link{shade3d}}.}
}
\details{
These functions create \code{mesh3d} objects, which consist of a matrix
of vertex coordinates together with a matrices of indices indicating how the vertices should be displayed, and
material properties.
The \code{"shape3d"} class is a general class for shapes that can be plotted
by \code{dot3d}, \code{wire3d} or \code{shade3d}.
The \code{"mesh3d"} class is a class of objects that form meshes: the vertices
are in member \code{vb}, as a 4 by \code{n} matrix using
homogeneous coordinates. Indices of these vertices are
contained in optional components \code{ip} for points,
\code{is} for line segments, \code{it} for triangles, and
\code{ib} for quads.
Individual meshes may have any combination of these.
The functions \code{tmesh3d} and \code{qmesh3d} are included
for back-compatibility; they produce meshes of triangles and
quads respectively.
}
\value{
Objects of class \code{c("mesh3d",
"shape3d")}.
See \code{\link{rgl.primitive}} for a discussion of texture coordinates.
}
\examples{
# generate a quad mesh object
vertices <- c(
-1.0, -1.0, 0,
1.0, -1.0, 0,
1.0, 1.0, 0,
-1.0, 1.0, 0
)
indices <- c( 1, 2, 3, 4 )
open3d()
wire3d( mesh3d(vertices = vertices, quads = indices) )
}
\seealso{
\code{\link{shade3d}}, \code{\link{shapelist3d}} for multiple shapes
}
\keyword{dynamic}
rgl/man/merge.mesh3d.Rd 0000644 0001762 0000144 00000002433 14100762640 014363 0 ustar ligges users \name{merge.mesh3d}
\alias{merge.mesh3d}
\title{
Merge RGL mesh objects
}
\description{
Attempts to merge \code{"mesh3d"} objects. Objects need
to be similar enough; see Details.
}
\usage{
\method{merge}{mesh3d}(x, y, ..., attributesMustMatch = FALSE)
}
\arguments{
\item{x, y}{
\code{"mesh3d"} objects to merge.
}
\item{\dots}{
Optional additional objects.
}
\item{attributesMustMatch}{ See Details.}
}
\details{
To allow objects to be merged, they need to be similar enough
in terms of having the same list of material properties,
normals, texture coordinates, etc.
If \code{attributesMustMatch} is \code{TRUE}, it is an error
to have attributes in one mesh but not in another, and
those attributes that only specify a single value must have equal
values in all meshes.
If \code{attributesMustMatch} is \code{FALSE}, any non-matching
attributes will be dropped from the final result.
}
\value{
A single \code{"mesh3d"} object merging the contents
of the arguments.
}
\author{
Duncan Murdoch
}
\examples{
open3d()
# Notice that the alpha setting for the cube is dropped, because
# the other shapes don't specify alpha.
shade3d(merge(cube3d(col="red", alpha = 0.5),
translate3d(tetrahedron3d(col="green"), 2, 0, 0),
translate3d(octahedron3d(col="blue"), 4, 0, 0)))
}
rgl/man/postscript.Rd 0000644 0001762 0000144 00000003626 14100762641 014322 0 ustar ligges users \name{rgl.postscript}
\alias{rgl.postscript}
\title{Export vector graphics}
\description{
Saves the screenshot to a file in PostScript or other vector graphics format.
}
\usage{
rgl.postscript( filename, fmt = "eps", drawText = TRUE )
}
\arguments{
\item{filename}{full path to filename.}
\item{fmt}{export format, currently supported: ps, eps, tex, pdf, svg, pgf }
\item{drawText}{logical, whether to draw text}
}
\details{
Animations can be created in a loop modifying the scene and saving
a screenshot to a file. (See example below)
This function is a wrapper for the GL2PS library by Christophe Geuzaine,
and has the same limitations as that library: not all OpenGL features
are supported, and some are only supported in some formats.
See the reference for full details.
}
\references{
GL2PS: an OpenGL to PostScript printing library by Christophe Geuzaine,
\url{http://www.geuz.org/gl2ps/}, version 1.4.0.
}
\author{ Christophe Geuzaine / Albrecht Gebhardt }
\examples{
# Create new files in tempdir
savedir <- setwd(tempdir())
x <- y <- seq(-10, 10, length = 20)
z <- outer(x, y, function(x, y) x^2 + y^2)
persp3d(x, y, z, col = 'lightblue')
title3d("Using LaTeX text", col = 'red', line = 3)
rgl.postscript("persp3da.ps", "ps", drawText = FALSE)
rgl.postscript("persp3da.pdf", "pdf", drawText = FALSE)
rgl.postscript("persp3da.tex", "tex")
pop3d()
title3d("Using ps/pdf text", col = 'red', line = 3)
rgl.postscript("persp3db.ps", "ps")
rgl.postscript("persp3db.pdf", "pdf")
rgl.postscript("persp3db.tex", "tex", drawText = FALSE)
setwd(savedir)
\dontrun{
#
# create a series of frames for an animation
#
rgl.open()
shade3d(oh3d(), color = "red")
rgl.viewpoint(0, 20)
for (i in 1:45) {
rgl.viewpoint(i, 20)
filename <- paste("pic", formatC(i, digits = 1, flag = "0"), ".eps", sep = "")
rgl.postscript(filename, fmt = "eps")
}
}
}
\seealso{
\code{\link{view3d}}, \code{\link{snapshot3d}}
}
\keyword{dynamic}
rgl/man/shade3d.Rd 0000644 0001762 0000144 00000011665 14145464133 013431 0 ustar ligges users \name{shade3d}
\alias{dot3d}
\alias{dot3d.mesh3d}
\alias{wire3d}
\alias{wire3d.mesh3d}
\alias{shade3d}
\alias{shade3d.mesh3d}
\title{Draw 3D mesh objects}
\description{
Draws 3D mesh objects in full, or just the edges, or just
the vertices.
}
\usage{
dot3d(x, ...) # draw dots at the vertices of an object
\method{dot3d}{mesh3d}(x, ...,
front = "points", back = "points")
wire3d(x, ...) # draw a wireframe object
\method{wire3d}{mesh3d}(x, ...,
front = "lines", back = "lines")
shade3d(x, ...) # draw a shaded object
\method{shade3d}{mesh3d}(x, override = TRUE,
meshColor = c("vertices", "edges", "faces", "legacy"),
texcoords = NULL, ...,
front = "filled", back = "filled")
}
\arguments{
\item{x}{a \code{mesh3d} object.}
\item{...}{additional rendering parameters, or for
\code{dots3d} and \code{wire3d}, parameters to pass
to \code{shade3d}}
\item{override}{should the parameters specified here override those stored in the object?}
\item{meshColor}{how should colours be interpreted? See details
below}
\item{texcoords}{texture coordinates at each vertex.}
\item{front, back}{Material properties for rendering.}
}
\details{
The \code{meshColor} argument controls how material colours and textures are interpreted. This parameter
was added in \pkg{rgl} version 0.100.1 (0.100.27 for \code{dot3d}). Possible values are:
\describe{
\item{\code{"vertices"}}{Colours and texture coordinates are applied by vertex, in the order
they appear in the \code{x$vb} matrix.}
\item{\code{"edges"}}{Colours are applied to each edge: first to the segments in the \code{x$is} matrix, then
the
3 edges of each triangle in the \code{x$it} matrix, then the 4
edges of each quad in the \code{x$ib} matrix. This mode
is only supported if both front and back materials are
\code{"lines"}, and the mesh contains no points.}
\item{\code{"faces"}}{Colours are applied to each face: first to the
triangles in the \code{it} matrix, then to the quads in the \code{ib}
matrix. Not compatible with meshes containing points or segments.}
\item{\code{"legacy"}}{Colours and textures are applied in the same way
as in \pkg{rgl} versions earlier than 0.100.1.}
}
Unique partial matches of these values will be recognized.
If colours are specified but \code{meshColor} is not
and \code{options(rgl.meshColorWarning = TRUE)},
a warning will be given that their
interpretation may have changed. In versions 0.100.1 to 0.100.26
of \pkg{rgl}, the default
was to give the warning; now the default is for no warning.
Note that since version 0.102.10, \code{meshColor =
"edges"} is only allowed when drawing lines (the
\code{wire3d} default), and it may draw
edges more than once. In general, if any rendering
draws twice at the same location, which copy is visible
depends on the order of drawing and the
\code{\link{material3d}("depth_test")}
setting.
Whether points, lines or solid faces are drawn is
determined in 3 steps:
\enumerate{
\item{If arguments \code{"front"} or \code{"back"} are
specified in the call, those are used.}
\item{If one or both of those arguments are not
specified, but the material properties are present in
the object, those are used.}
\item{If values are not specified in either of those
places, \code{shade3d} draws filled surfaces,
\code{wire3d} draws lines, and \code{dot3d} draws points.
}
}
Note: For some versions of rgl up to version 0.107.15,
rule 2 above was not respected.
}
\value{
\code{dot3d}, \code{wire3d}, and \code{shade3d} are called for their side effect
of drawing an object into the scene; they return an object ID (or vector of IDs) invisibly.
See \code{\link{rgl.primitive}} for a discussion of texture coordinates.
}
\examples{
# generate a quad mesh object
vertices <- c(
-1.0, -1.0, 0,
1.0, -1.0, 0,
1.0, 1.0, 0,
-1.0, 1.0, 0
)
indices <- c( 1, 2, 3, 4 )
open3d()
wire3d( mesh3d(vertices = vertices, quads = indices) )
# render 4 meshes vertically in the current view
open3d()
bg3d("gray")
l0 <- oh3d(tran = par3d("userMatrix"), color = "green" )
shade3d( translate3d( l0, -6, 0, 0 ))
l1 <- subdivision3d( l0 )
shade3d( translate3d( l1 , -2, 0, 0 ), color = "red", override = FALSE )
l2 <- subdivision3d( l1 )
shade3d( translate3d( l2 , 2, 0, 0 ), color = "red", override = TRUE )
l3 <- subdivision3d( l2 )
shade3d( translate3d( l3 , 6, 0, 0 ), color = "red" )
# render all of the Platonic solids
open3d()
shade3d( translate3d( tetrahedron3d(col = "red"), 0, 0, 0) )
shade3d( translate3d( cube3d(col = "green"), 3, 0, 0) )
shade3d( translate3d( octahedron3d(col = "blue"), 6, 0, 0) )
shade3d( translate3d( dodecahedron3d(col = "cyan"), 9, 0, 0) )
shade3d( translate3d( icosahedron3d(col = "magenta"), 12, 0, 0) )
}
\seealso{
\code{\link{mesh3d}}, \code{\link{par3d}}, \code{\link{shapelist3d}} for multiple shapes
}
\keyword{dynamic}
rgl/man/setUserShaders.Rd 0000644 0001762 0000144 00000010363 14100762641 015050 0 ustar ligges users \name{setUserShaders}
\alias{setUserShaders}
\title{
Set user-defined shaders for RGL objects.
}
\description{
Sets user-defined shaders (programs written in GLSL)
for customized display of RGL objects. Currently
only supported in WebGL displays, as the regular
displays do not support GLSL.
}
\usage{
setUserShaders(ids, vertexShader = NULL, fragmentShader = NULL,
attributes = NULL, uniforms = NULL,
scene = scene3d(minimal), minimal = TRUE)
}
\arguments{
\item{ids}{
Which objects should receive the shaders.
}
\item{vertexShader, fragmentShader}{
The vertex and fragment shader source code. If \code{NULL}, the
automatically generated shader will be used instead.
}
\item{attributes}{
A named list of \dQuote{attributes} to attach to each vertex.
}
\item{uniforms}{
A named list of \dQuote{uniforms}.
}
\item{scene}{
A \code{\link{scene3d}} object to modify.
}
\item{minimal}{
See \code{\link{scene3d}}.
}
}
\details{
Modern versions of OpenGL work with \dQuote{shaders},
programs written to run on the graphics processor. The
vertex shader does the calculations to move vertices and
set their intrinsic colours. The fragment shader
computes how each pixel in the display will be shown,
taking into account lighting, material properties, etc.
(More precisely, it does the computation for each \dQuote{fragment}; a fragment is a pixel within an object to display.
There may be many objects at a particular location, and
each will result in a fragment calculation unless culled
by z-buffering or being discarded in some other way.)
Normally the WebGL code automatically generates shaders
for each object. This function allows them to be written
by hand, for testing new features, hand optimization, etc.
Currently it is not easy to get copies of the default
shaders; they need to be obtained from a Javascript debugger
while displaying the scene.
}
\value{
A modified version of the \code{scene}.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{rglwidget}} for display of the scene in WebGL.
}
\examples{
open3d()
id <- shade3d(octahedron3d(), col = "red")
# For each triangle, set weights on the 3 vertices.
# This will be replicated to the appropriate size in Javascript.
wts <- diag(3)
# This leaves out the centres of each face
vs <- "
attribute vec3 aPos;
attribute vec4 aCol;
uniform mat4 mvMatrix;
uniform mat4 prMatrix;
varying vec4 vCol;
varying vec4 vPosition;
attribute vec3 aNorm;
uniform mat4 normMatrix;
varying vec3 vNormal;
attribute vec3 wts;
varying vec3 vwts;
void main(void) {
vPosition = mvMatrix * vec4(aPos, 1.);
gl_Position = prMatrix * vPosition;
vCol = aCol;
vNormal = normalize((normMatrix * vec4(aNorm, 1.)).xyz);
vwts = wts;
}
"
fs <- "
#ifdef GL_ES
precision highp float;
#endif
varying vec4 vCol; // carries alpha
varying vec4 vPosition;
varying vec3 vNormal;
uniform mat4 mvMatrix;
uniform vec3 emission;
uniform float shininess;
uniform vec3 ambient0;
uniform vec3 specular0; // light*material
uniform vec3 diffuse0;
uniform vec3 lightDir0;
uniform bool viewpoint0;
uniform bool finite0;
varying vec3 vwts;
uniform vec2 wtrange;
void main(void) {
float minwt = min(vwts.x, min(vwts.y, vwts.z));
if (minwt < wtrange.x || minwt > wtrange.y) discard;
vec3 eye = normalize(-vPosition.xyz);
vec3 lightdir;
vec4 colDiff;
vec3 halfVec;
vec4 lighteffect = vec4(emission, 0.);
vec3 col;
float nDotL;
vec3 n = normalize(vNormal);
n = -faceforward(n, n, eye);
colDiff = vec4(vCol.rgb * diffuse0, vCol.a);
lightdir = lightDir0;
if (!viewpoint0)
lightdir = (mvMatrix * vec4(lightdir, 1.)).xyz;
if (!finite0) {
halfVec = normalize(lightdir + eye);
} else {
lightdir = normalize(lightdir - vPosition.xyz);
halfVec = normalize(lightdir + eye);
}
col = ambient0;
nDotL = dot(n, lightdir);
col = col + max(nDotL, 0.) * colDiff.rgb;
col = col + pow(max(dot(halfVec, n), 0.), shininess) * specular0;
lighteffect = lighteffect + vec4(col, colDiff.a);
gl_FragColor = lighteffect;
}
"
x <- setUserShaders(id, vs, fs, attributes = list(wts=wts),
uniforms = list(wtrange = c(-0.01, 0.15)))
if (interactive() || in_pkgdown_example())
rglwidget(x)
}
rgl/man/rgl.init.Rd 0000644 0001762 0000144 00000005506 14137472630 013643 0 ustar ligges users \name{rgl.init}
\title{Initializing RGL}
\alias{rgl.init}
\description{
Initializing the RGL system.
}
\usage{
rgl.init(initValue = 0, onlyNULL = FALSE,
debug = getOption("rgl.debug", FALSE))
}
\arguments{
\item{initValue}{value for internal use only}
\item{onlyNULL}{only initialize the null (no display) device}
\item{debug}{enable some debugging messages}
}
\value{
Normally the user doesn't call \code{rgl.init} at all: it
is called when the package is loaded. It returns no
useful value.
}
\details{
If \code{useNULL} is \code{TRUE}, RGL will use a \dQuote{null}
device. This device records objects as they are plotted, but
displays nothing. It is intended for use with \code{\link{rglwidget}}
and similar functions.
Currently \code{debug} only controls messages printed by the OpenGL
library during initialization. In future \code{debug = TRUE} may
become more verbose.
For display within an OpenGL window in R, RGL requires the OpenGL
system to be installed and available. If there is a problem
initializing it, you may see the message
\verb{'rgl.init' failed, running with 'rgl.useNULL = TRUE'.} There
are several causes and remedies:
\itemize{
\item{On any system, the OpenGL libraries need to be present for RGL to be able to start an OpenGL device.}
\itemize{
\item{On macOS, you need to install XQuartz. It is available from
\url{https://www.xquartz.org}.}
\item{On Linux, you need to install Mesa 3D. One of these commands
may work, depending on your system:
\verb{
zypper source-install --build-deps-only Mesa # openSUSE/SLED/SLES
yum-builddep mesa # yum Fedora, OpenSuse(?)
dnf builddep mesa # dnf Fedora
apt-get build-dep mesa # Debian, Ubuntu and related
}
}
\item{Windows should have OpenGL installed by default.}
}
\item{On Unix-alike systems (macOS and Linux, for example), RGL
normally
uses the GLX system for creating displays. If the graphic is created
on a remote machine, it may need to use \dQuote{Indirect GLX} (IGLX). Due
to security concerns, this is often disabled by default. See
\url{https://www.x.org/wiki/Development/Security/Advisory-2014-12-09/}
for a discussion of the security issues, and
\url{https://unix.stackexchange.com/q/317954}
for ways to re-enable IGLX.}
\item{The \url{https://www.virtualgl.org} project is intended to
be a way to avoid IGLX, by rendering remotely and sending bitmaps
to the local machine. It's not a simple install...}
\item{If you don't need to see RGL displays on screen, you
can use the \dQuote{NULL device}. See \code{\link{rgl.useNULL}}.}
\item{If you can't build the \pkg{rgl} package with OpenGL
support, you can
disable it and use the NULL device. (This may happen automatically
during configuration, but you'll get a tested result if you
specify it explicitly.) See the instructions in the
\file{README} file in the source tarball.}
}
}
rgl/man/in_pkgdown_example.Rd 0000644 0001762 0000144 00000000532 14100762640 015752 0 ustar ligges users \name{in_pkgdown_example}
\alias{in_pkgdown_example}
\title{
Are we running in a \pkg{pkgdown} example?
}
\description{
This is mainly for internal use to decide whether results
should be automatically included in a \pkg{pkgdown} web
page.
}
\usage{
in_pkgdown_example()
}
\value{
\code{TRUE} or \code{FALSE}
}
\examples{
in_pkgdown_example()
}
rgl/man/addNormals.Rd 0000644 0001762 0000144 00000003054 14100762640 014166 0 ustar ligges users \name{addNormals}
\alias{addNormals}
\alias{addNormals.mesh3d}
\alias{addNormals.shapelist3d}
\title{
Add normal vectors to objects so they render more smoothly
}
\description{
This generic function adds normals at each of the vertices
of a polyhedron by averaging the normals of each incident face. This has the
effect of making the surface of the object appear smooth rather than faceted
when rendered.
}
\usage{
addNormals(x, ...)
\method{addNormals}{mesh3d}(x, angleWeighted = TRUE, ...)
}
\arguments{
\item{x}{An object to which to add normals.}
\item{\dots}{Additional parameters which will be passed to the methods.}
\item{angleWeighted}{See Details below.}
}
\details{
Currently methods are supplied for \code{\link[=mesh3d]{"mesh3d"}} and
\code{\link[=shapelist3d]{"shapelist3d"}} classes.
These methods work by averaging the normals on the faces incident at
each vertex. By default these are weighted according to the angle
in the polygon at that vertex.
If \code{angleWeighted = FALSE}, a slightly faster
but less accurate weighting by the triangle area is used.
Prior to \pkg{rgl} version 0.104.12 an incorrect weighting was used;
it can be partially reproduced by using \code{angleWeighted = NA},
but not all the bugs in that scheme will be kept.
}
\value{
A new object of the same class as \code{x}, with normals added.
}
\author{
Duncan Murdoch
}
\examples{
open3d()
y <- subdivision3d(tetrahedron3d(col = "red"), depth = 3)
shade3d(y) # No normals
y <- addNormals(y)
shade3d(translate3d(y, x = 1, y = 0, z = 0)) # With normals
}
\keyword{dynamic}
rgl/man/3dobjects.Rd 0000644 0001762 0000144 00000006510 14100762640 013762 0 ustar ligges users \name{points3d}
\alias{points3d}
\alias{lines3d}
\alias{segments3d}
\alias{triangles3d}
\alias{quads3d}
\title{Add primitive shape}
\description{
Adds a shape node to the current scene.
}
\usage{
points3d(x, y = NULL, z = NULL, ...)
lines3d(x, y = NULL, z = NULL, ...)
segments3d(x, y = NULL, z = NULL, ...)
triangles3d(x, y = NULL, z = NULL, ...)
quads3d(x, y = NULL, z = NULL, ...)
}
\arguments{
\item{x, y, z}{coordinates. Any reasonable way of defining the
coordinates is acceptable. See the function \code{\link[grDevices]{xyz.coords}}
for details.}
\item{ ... }{Material properties (see \code{\link{material3d}}).
For normals use \code{normals} and for
texture coordinates use \code{texcoords}; see \code{\link{rgl.primitive}}
for details.}
}
\details{
The functions \code{points3d}, \code{lines3d}, \code{segments3d},
\code{triangles3d} and \code{quads3d} add points, joined lines, line segments,
filled triangles or quadrilaterals to the plots. They correspond to the OpenGL types
\code{GL_POINTS, GL_LINE_STRIP, GL_LINES, GL_TRIANGLES} and \code{GL_QUADS} respectively.
Points are taken in pairs by \code{segments3d}, triplets as the vertices
of the triangles, and quadruplets for the quadrilaterals. Colors are applied vertex by vertex;
if different at each end of a line segment, or each vertex of a polygon, the colors
are blended over the extent of the object. Polygons
must be non-degenerate and quadrilaterals must be entirely
in one plane and convex, or the results are undefined.
These functions call the lower level functions \code{\link{rgl.points}}, \code{\link{rgl.linestrips}}.
The appearance of the new objects are defined by the material properties.
See \code{\link{rgl.material}} for details.
The two principal differences between the \code{rgl.*} functions and
the \code{*3d} functions are that the former set all unspecified
material properties to defaults, whereas the latter use current values
as defaults; the former make persistent changes to material properties
with each call, whereas the latter make temporary changes only for the
duration of the call.
}
\value{
Each function returns the integer object ID of the shape that
was added to the scene. These can be passed to \code{\link{pop3d}}
to remove the object from the scene.
}
\author{
Ming Chen and Duncan Murdoch
}
\examples{
# Show 12 random vertices in various ways.
M <- matrix(rnorm(36), 3, 12, dimnames = list(c('x', 'y', 'z'),
rep(LETTERS[1:4], 3)))
# Force 4-tuples to be convex in planes so that quads3d works.
for (i in c(1, 5, 9)) {
quad <- as.data.frame(M[, i + 0:3])
coeffs <- runif(2, 0, 3)
if (mean(coeffs) < 1) coeffs <- coeffs + 1 - mean(coeffs)
quad$C <- with(quad, coeffs[1]*(B - A) + coeffs[2]*(D - A) + A)
M[, i + 0:3] <- as.matrix(quad)
}
open3d()
# Rows of M are x, y, z coords; transpose to plot
M <- t(M)
shift <- matrix(c(-3, 3, 0), 12, 3, byrow = TRUE)
points3d(M)
lines3d(M + shift)
segments3d(M + 2*shift)
triangles3d(M + 3*shift, col = 'red')
quads3d(M + 4*shift, col = 'green')
text3d(M + 5*shift, texts = 1:12)
# Add labels
shift <- outer(0:5, shift[1, ])
shift[, 1] <- shift[, 1] + 3
text3d(shift,
texts = c('points3d', 'lines3d', 'segments3d',
'triangles3d', 'quads3d', 'text3d'),
adj = 0)
rgl.bringtotop()
}
\keyword{dynamic}
rgl/man/cylinder3d.Rd 0000644 0001762 0000144 00000011206 14100762640 014140 0 ustar ligges users \name{cylinder3d}
\alias{cylinder3d}
\encoding{UTF-8}
\title{
Create cylindrical or "tube" plots
}
\description{
This function converts a description of a space curve into a \code{\link[=mesh3d]{"mesh3d"}}
object forming a cylindrical tube around the curve.
}
\usage{
cylinder3d(center, radius = 1, twist = 0, e1 = NULL, e2 = NULL, e3 = NULL,
sides = 8, section = NULL, closed = 0,
rotationMinimizing = is.null(e2) && is.null(e3),
debug = FALSE, keepVars = FALSE)
}
\arguments{
\item{center}{An n by 3 matrix whose columns are the x, y and z coordinates of the space curve.}
\item{radius}{The radius of the cross-section of the tube at each point in the center.}
\item{twist}{The amount by which the polygon forming the tube is twisted at each point.}
\item{e1, e2, e3}{The local coordinates to use at each point on the space curve. These default to a rotation
minimizing frame or Frenet coordinates.}
\item{sides}{The number of sides in the polygon cross section.}
\item{section}{The polygon cross section as a two-column matrix, or \code{NULL}.}
\item{closed}{Whether to treat the first and last points of the space curve as identical,
and close the curve, or put caps on the ends. See the Details.}
\item{rotationMinimizing}{Use a rotation minimizing local
frame if \code{TRUE}, or a Frenet or user-specified frame if \code{FALSE}.}
\item{debug}{If \code{TRUE}, plot the local Frenet coordinates at each point.}
\item{keepVars}{If \code{TRUE}, return the local variables in attribute \code{"vars"}.}
}
\details{
The number of points in the space curve is determined by the vector lengths in \code{center},
after using \code{\link{xyz.coords}} to convert it to a list. The other arguments
\code{radius}, \code{twist}, \code{e1}, \code{e2}, and \code{e3} are extended to the same
length.
The \code{closed} argument controls how the ends of the cylinder are
handled. If \code{closed > 0}, it represents the number of points of
overlap in the coordinates. \code{closed == TRUE} is the same as
\code{closed = 1}. If \code{closed > 0} but the ends don't actually
match, a warning will be given and results will be somewhat
unpredictable.
Negative values of \code{closed} indicate that caps should be put on the
ends of the cylinder. If \code{closed == -1}, a cap will be put on the
end corresponding to \code{center[1, ]}. If \code{closed == -2}, caps
will be put on both ends.
If \code{section} is \code{NULL} (the default), a regular
\code{sides}-sided polygon is used, and \code{radius} measures the
distance from the center of the cylinder to each vertex. If not
\code{NULL}, \code{sides} is ignored (and set internally to
\code{nrow(section)}), and \code{radius} is used as a multiplier to
the vertex coordinates. \code{twist} specifies the rotation of the
polygon. Both \code{radius} and \code{twist} may be vectors, with
values recycled to the number of rows in \code{center}, while
\code{sides} and \code{section} are the same at every point along the
curve.
The three optional arguments \code{e1}, \code{e2}, and \code{e3}
determine the local coordinate system used to create the vertices at
each point in \code{center}. If missing, they are computed by simple
numerical approximations. \code{e1} should be the tangent coordinate,
giving the direction of the curve at the point. The cross-section of
the polygon will be orthogonal to \code{e1}. When \code{rotationMinimizing} is \code{TRUE}, \code{e2} and \code{e3} are chosen to give
a rotation minimizing frame (see Wang et al., 2008). When it is
\code{FALSE}, \code{e2} defaults to an
approximation to the normal or curvature vector; it is used as the
image of the \code{y} axis of the polygon cross-section. \code{e3}
defaults to an approximation to the binormal vector, to which the
\code{x} axis of the polygon maps. The vectors are orthogonalized and
normalized at each point.
}
\value{
A \code{\link[=mesh3d]{"mesh3d"}} object holding the cylinder, possibly with
attribute \code{"vars"} containing the local environment of the function.
}
\author{
Duncan Murdoch
}
\references{
Wang, W., Jüttler, B., Zheng, D. and Liu, Y. (2008).
Computation of rotation minimizing frames.
ACM Transactions on Graphics, Vol. 27, No. 1, Article 2.
}
\examples{
# A trefoil knot
open3d()
theta <- seq(0, 2*pi, len = 25)
knot <- cylinder3d(
center = cbind(
sin(theta) + 2*sin(2*theta),
2*sin(3*theta),
cos(theta) - 2*cos(2*theta)),
e1 = cbind(
cos(theta) + 4*cos(2*theta),
6*cos(3*theta),
sin(theta) + 4*sin(2*theta)),
radius = 0.8,
closed = TRUE)
shade3d(addNormals(subdivision3d(knot, depth = 2)), col = "green")
}
\keyword{ dynamic }
rgl/man/toggleWidget.Rd 0000644 0001762 0000144 00000003714 14145464133 014537 0 ustar ligges users \name{toggleWidget}
\alias{toggleWidget}
\title{
An HTML widget to toggle display of elements of a scene
}
\description{
This function produces a button in an HTML scene
that will toggle the display of items in the scene.
}
\usage{
toggleWidget(sceneId,
ids = tagged3d(tags), tags = NULL, hidden = integer(),
subscenes = NULL,
label,
...)
}
\arguments{
\item{sceneId}{
The HTML id of the RGL scene being controlled,
or an object as in \code{\link{playwidget}}.
}
\item{ids, hidden}{
The RGL id numbers of the objects to toggle. Those in \code{ids}
are initially shown; those in \code{hidden} are initially hidden.
}
\item{tags}{
Alternate way to specify \code{ids}. Ignored if \code{ids} is
given.
}
\item{subscenes}{
The subscenes in which to toggle the objects.
}
\item{label}{
The label to put on the button. The default is set
from the expression passed to \code{ids} or the value of \code{tags}.
}
\item{\dots}{
Additional arguments to pass to \code{\link{playwidget}}.
}
}
\details{
Like \code{\link{playwidget}}, this function is designed
to work within the \pkg{htmlwidgets} framework.
If the value is printed, the button will be inserted
into the output.
It is also designed to work with \pkg{magrittr}-style
pipes: the result of \code{\link{rglwidget}} or
other widgets can be piped into it to add it
to a display. It can also appear first in the
pipeline, if \code{sceneId} is set to \code{NA}.
}
\value{
A widget suitable for use in an \pkg{Rmarkdown}-generated web
page, or elsewhere.
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{toggleButton}} for the older style
of HTML control.
}
\examples{
theplot <- plot3d(rnorm(100), rnorm(100), rnorm(100), col = "red")
widget <- rglwidget(height = 300, width = 300) \%>\%
toggleWidget(theplot["data"],
hidden = theplot[c("xlab", "ylab", "zlab")],
label = "Points")
if (interactive() || in_pkgdown_example())
widget
}
rgl/man/figWidth.Rd 0000644 0001762 0000144 00000001242 14100762640 013644 0 ustar ligges users \name{figWidth}
\alias{figWidth}
\alias{figHeight}
\title{
Get R Markdown figure dimensions in pixels
}
\description{
In an R Markdown document, figure dimensions are normally
specified in inches; these are translated into pixel
dimensions when HTML output is requested and \code{\link{rglwidget}} is used. These functions reproduce that
translation.
}
\usage{
figWidth()
figHeight()
}
\value{
When used in an R Markdown document, these functions
return the requested current dimensions of figures in pixels. Outside such a document, \code{NULL}
is returned.
}
\author{
Duncan Murdoch
}
\examples{
# No useful return value outside of R Markdown:
figWidth()
figHeight()
}
rgl/man/shinyGetPar3d.Rd 0000644 0001762 0000144 00000007301 14100762641 014566 0 ustar ligges users \name{shinyGetPar3d}
\alias{shinyGetPar3d}
\alias{shinySetPar3d}
\alias{shinyResetBrush}
\title{
Communicate RGL parameters between R and Javascript in Shiny
}
\description{
These functions allow Shiny apps to read and write the \code{par3d}
settings that may have been modified by user interaction in the browser.
}
\usage{
shinyGetPar3d(parameters, session, subscene = currentSubscene3d(cur3d()), tag = "")
shinySetPar3d(..., session, subscene = currentSubscene3d(cur3d()))
shinyResetBrush(session, brush)
}
\arguments{
\item{parameters}{
A character vector naming the parameters to get.
}
\item{session}{
The Shiny session object.
}
\item{subscene}{
The subscene to which the parameters apply. Defaults to
the currently active subscene in the R session.
}
\item{tag}{
An arbitrary string or value which will be sent as part of the
response.
}
\item{...}{
A number of \code{name = value} pairs to be modified, or a
single named list of parameters. Entries named \code{tag}
or \code{subscene} will be ignored.
}
\item{brush}{The name of a Shiny input element corresponding to
the \code{shinyBrush} argument to \code{\link{rglwidget}}.}
}
\details{
Requesting information from the browser is a complicated process.
The \code{shinyGetPar3d} function doesn't return the requested value,
it just submits a request for the value to be returned later in
\code{input$par3d}, a reactive input. No action will result
except when a reactive observer depends on \code{input$par3d}.
See the example code below.
The \code{shinySetPar3d} function sends a message to the browser
asking it to change a particular parameter. The change will be
made immediately, without sending the full scene to the browser,
so should be reasonably fast.
}
\value{
These functions are called for their side effects, and don't return
useful values.
The side effect of \code{shinyGetPar3d} is to cause \code{input$par3d}
to be updated sometime later.
Besides the requested parameter values, \code{input$par3d} will
contain a copy of the \code{subscene} and \code{tag} arguments.
The side effect of \code{shinySetPar3d} is to send a message to the
browser to update its copy of the \code{par3d} parameters
immediately.
}
\note{
R and the browser don't maintain a perfect match between the way
parameters are stored internally. The browser version of parameters
will be returned by \code{shinyGetPar3d} and should be supplied to
\code{shinySetPar3d}.
}
\references{
\url{https://shiny.rstudio.com/articles/communicating-with-js.html}
describes the underlying mechanisms used by these two functions.
}
\seealso{The \code{\link{rglwidget}} argument \code{shinySelectionInput} allows information about mouse selections
to be returned to R.}
\author{
Duncan Murdoch
}
\examples{
if (interactive() && !in_pkgdown_example() && requireNamespace("shiny")) {
save <- options(rgl.useNULL = TRUE)
xyz <- matrix(rnorm(300), ncol = 3)
app = shiny::shinyApp(
ui = shiny::bootstrapPage(
shiny::actionButton("redraw", "Redraw"),
rglwidgetOutput("rglPlot")
),
server = function(input, output, session) {
# This waits until the user to click on the "redraw"
# button, then sends a request for the current userMatrix
shiny::observeEvent(input$redraw, {
shinyGetPar3d("userMatrix", session)
})
# This draws the plot whenever input$par3d changes,
# i.e. whenever a response to the request above is
# received.
output$rglPlot <- renderRglwidget({
if (length(rgl.dev.list())) close3d()
col <- sample(colors(), 1)
plot3d(xyz, col = col, type = "s", main = col)
par3d(userMatrix = input$par3d$userMatrix)
rglwidget()
})
})
shiny::runApp(app)
options(save)
}
}
rgl/man/ageControl.Rd 0000644 0001762 0000144 00000005177 14145464133 014214 0 ustar ligges users \name{ageControl}
\alias{ageControl}
\title{
Set attributes of vertices based on their age
}
\description{
This is a function to produce actions in response to
a \code{\link{playwidget}} or Shiny input control. The
mental model is that each of the vertices of some object has
a certain birth time; a control sets the current time, so that
vertices have ages depending on the control setting.
Attributes of those vertices can then be changed.
}
\usage{
ageControl(births, ages, objids = tagged3d(tags), tags, value = 0,
colors = NULL, alpha = NULL, radii = NULL, vertices = NULL,
normals = NULL, origins = NULL, texcoords = NULL,
x = NULL, y = NULL, z = NULL,
red = NULL, green = NULL, blue = NULL)
}
\arguments{
\item{births}{Numeric birth times of vertices.}
\item{ages}{Chosen ages at which the following attributes
will apply.}
\item{objids}{Object ids to which the changes apply.}
\item{tags}{
Alternate way to specify \code{objids}. Ignored if \code{objids} is
given.
}
\item{value}{Initial value; typically overridden by input.}
\item{colors, alpha, radii, vertices, normals, origins, texcoords}{
Attributes of the vertices that can be changed. There should be
one entry or row for each entry in \code{ages}.}
\item{x, y, z, red, green, blue}{These one-dimensional
components of vertices and colors are provided for convenience.}
}
\details{
All attributes must have the same number of entries (rows for the matrices)
as the ages vector. The births vector must have the same number of entries as
the number of vertices in the object.
Not all objects contain all attributes; if one is chosen that is
not a property of the corresponding object, a Javascript \code{alert()} will be
generated. (This restriction may be removed in the future by attempting
to add the attribute when it makes sense.)
If a \code{births} entry is \code{NA}, no change will be made to that
vertex.
}
\value{
A list of class \code{"rglControl"} of cleaned up parameter
values, to be used in an RGL widget.
}
\author{
Duncan Murdoch
}
\examples{
saveopts <- options(rgl.useNULL = TRUE)
theta <- seq(0, 4*pi, len=100)
xyz <- cbind(sin(theta), cos(theta), sin(theta/2))
lineid <- plot3d(xyz, type="l", alpha = 0, lwd = 5, col = "blue")["data"]
widget <- rglwidget() \%>\%
playwidget(ageControl(births = theta,
ages = c(-4*pi, -4*pi, 1-4*pi, 0, 0, 1),
objids = lineid,
alpha = c(0, 1, 0, 0, 1, 0)),
start = 0, stop = 4*pi,
step = 0.1, rate = 4)
if (interactive() || in_pkgdown_example())
widget
options(saveopts)
}
rgl/man/surface.Rd 0000644 0001762 0000144 00000007035 14100762641 013536 0 ustar ligges users \name{rgl.surface}
\title{Add surface (obsolete)}
\alias{rgl.surface}
\description{
Adds a surface to the current scene. The surface is defined by
a matrix defining the height of each grid point and two vectors
defining the grid.
}
\usage{
rgl.surface(x, z, y, coords = 1:3, ...,
normal_x = NULL, normal_y = NULL, normal_z = NULL,
texture_s = NULL, texture_t = NULL)
}
\arguments{
\item{ x }{
values corresponding to rows of \code{y}, or matrix of x coordinates
}
\item{ y }{
matrix of height values
}
\item{ z }{
values corresponding to columns of \code{y}, or matrix of z coordinates
}
\item{ coords }{
See details
}
\item{ ... }{Material and texture properties. See \code{\link{rgl.material}} for details.}
\item{normal_x, normal_y, normal_z}{
matrices of the same dimension as \code{y} giving the coordinates of normals at
each grid point}
\item{texture_s, texture_t}{
matrices of the same dimension as \code{z} giving the coordinates within the current texture
of each grid point}
}
\details{
Adds a surface mesh to the current scene. The surface is defined by
the matrix of height values in \code{y}, with rows corresponding
to the values in \code{x} and columns corresponding to the values in
\code{z}.
The \code{coords} parameter can be used to change the geometric
interpretation of \code{x}, \code{y}, and \code{z}. The first entry
of \code{coords} indicates which coordinate (\code{1 = X},
\code{2 = Y}, \code{3 = Z}) corresponds to the \code{x} parameter.
Similarly the second entry corresponds to the \code{y} parameter,
and the third entry to the \code{z} parameter. In this way
surfaces may be defined over any coordinate plane.
If the normals are not supplied, they will be calculated automatically based
on neighbouring points.
Texture coordinates run from 0 to 1 over each dimension of the texture bitmap.
If texture coordinates are not supplied, they will be calculated to
render the texture exactly once over the grid. Values greater than 1 can be
used to repeat the texture over the surface.
\code{rgl.surface} always draws the surface with the `front' upwards
(i.e. towards higher \code{y} values). This can be used to render
the top and bottom differently; see \code{\link{rgl.material}} and
the example below.
If the \code{x} or \code{z} argument is a matrix, then it must be of the same
dimension as \code{y}, and the values in the matrix will be used for the corresponding
coordinates. This is used to plot shapes such as cylinders
where y is not a function of x and z.
\code{NA} values in the height matrix are not drawn.
}
\note{
It is recommended to use \code{\link{surface3d}} instead
of \code{rgl.surface}; use of the \code{rgl.*} functions
is discouraged due to their side effects.
}
\value{
The object ID of the displayed surface is returned invisibly.
}
\examples{
#
# volcano example taken from "persp"
#
data(volcano)
y <- 2 * volcano # Exaggerate the relief
x <- 10 * (1:nrow(y)) # 10 meter spacing (S to N)
z <- 10 * (1:ncol(y)) # 10 meter spacing (E to W)
ylim <- range(y)
ylen <- ylim[2] - ylim[1] + 1
colorlut <- terrain.colors(ylen) # height color lookup table
col <- colorlut[ y - ylim[1] + 1 ] # assign colors to heights for each point
rgl.open()
rgl.surface(x, z, y, color = col, back = "lines")
}
\seealso{
\code{\link{rgl.material}}, \code{\link{surface3d}}, \code{\link{terrain3d}}.
See \code{\link{persp3d}} for a higher level interface.
}
\keyword{dynamic}
rgl/man/show2d.Rd 0000644 0001762 0000144 00000011374 14100762641 013315 0 ustar ligges users \name{show2d}
\alias{show2d}
\title{
Draw a 2D plot on a rectangle in a 3D scene
}
\description{
This function uses a bitmap of a standard 2D graphics plot
as a texture on a quadrilateral. Default arguments are
set up so that it will appear on the face of the bounding
box of the current 3D plot, but optional arguments allow
it to be placed anywhere in the scene.
}
\usage{
show2d(expression,
face = "z-", line = 0,
reverse = FALSE, rotate = 0,
x = NULL, y = NULL, z = NULL,
width = 480, height = 480,
filename = NULL,
ignoreExtent = TRUE,
color = "white", specular = "black", lit = FALSE,
texmipmap = TRUE, texminfilter = "linear.mipmap.linear",
expand = 1.03,
texcoords = matrix(c(0, 1, 1, 0, 0, 0, 1, 1), ncol = 2), ...)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{expression}{
Any plotting commands to produce a plot in standard graphics.
Ignored if \code{filename} is not \code{NULL}.
}
\item{face}{
A character string defining which face of the bounding
box to use. See Details below.
}
\item{line}{
How far out from the bounding box should the quadrilateral
be placed? Uses same convention as \code{\link{mtext3d}}:
not lines of text, but fraction of the bounding box size.
}
\item{reverse, rotate}{
Should the image be reversed or rotated? See Details below.
}
\item{x, y, z}{
Specific values to use to override \code{face}.
}
\item{width,height}{
Parameters to pass to \code{\link{png}} when creating the
bitmap. See Details below.
}
\item{filename}{
A \file{.png} file image to use as the texture.
}
\item{ignoreExtent}{
Whether the quadrilateral should be ignored when computing
the bounding box of the scene.
}
\item{color, specular, lit, texmipmap, texminfilter, \dots}{
Material properties to use for the quadrilateral.
}
\item{expand}{Amount by which the quadrilateral is
expanded outside the bounding box of the data.
}
\item{texcoords}{Coordinates on the image. Lower left
of the bitmap is \code{c(0,0)}, upper right is \code{c(1,1)}.}
}
\details{
The default arguments are chosen to make it easy to place
a 2D image on the face of the bounding box. If \code{x},
\code{y} and \code{z} are \code{NULL} (the defaults),
\code{face} will be used as a code for one of the
six faces of the bounding box. The first letter should
be \code{"x"}, \code{"y"} or \code{"z"}; this defines
the axis perpendicular to the desired face. If the
second letter is \code{"-"} or is missing, the face
will be chosen to be the face with the lower value
on that axis. Any other letter will use the opposite
face.
If any of \code{x}, \code{y} or \code{z} is given, the
specified value will be used to replace the value calculated
above. Usually four values should be given, corresponding to
the coordinates of the lower left, lower right, upper right
and upper left of the destination for the image before
\code{reverse} and \code{rotate} are used. Fewer values
can be used for one or two coordinates; \code{\link{cbind}}
will be used to put together all 3 coordinates into
a 4 by 3 matrix (which will be returned as an attribute
of the result).
The bitmap plot will by default be oriented so that it is
properly oriented when viewed from the
direction of the higher values of the perpendicular coordinate,
and its lower left corner is at the lower value of the two
remaining coordinates. The argument \code{reverse} causes
the orientation to be mirrored, and \code{rotate} causes it
to be rotated by multiples of 90 degrees. \code{rotate} should be an integer,
with \code{0} for no rotation, \code{1} for a 90 degree
counter-clockwise rotation, etc.
The \code{width} and \code{height} arguments control the shape
and resolution of the bitmap. The defaults give a square
bitmap, which is appropriate with the usual \code{c(1,1,1)}
aspect ratios (see \code{aspect3d}). Some tuning may be
needed to choose the resolution. The plot will look best when
displayed at its original size; shrinking it smaller tends to make
it look faded, while expanding it bigger will make it look
blurry. If \code{filename} is given, the width and height
will be taken from the file, and \code{width} and \code{height}
arguments will be ignored.
}
\value{
Invisibly returns the id value of the quadrilateral,
with the following attributes:
\item{value}{The value returned by \code{expression}.}
\item{xyz}{A 4 by 3 matrix giving the coordinates of the corners
as used in plotting.}
\item{texcoords}{A 4 by 2 matrix giving the texture coordinates
of the image.}
\item{filename}{The filename for the temporary file holding
the bitmap image.}
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{bgplot3d}} uses a plot as the background for the window.
}
\examples{
example(plot3d, ask = FALSE)
show2d({
par(mar=c(0,0,0,0))
plot(x, y, col = rainbow(1000), axes=FALSE)
})
} rgl/man/tkspinControl.Rd 0000644 0001762 0000144 00000002660 14100762641 014756 0 ustar ligges users \name{tkspinControl}
\alias{tkspinControl}
\title{Create a spin control in a TCL/TK window}
\description{
This function may be used to embed a spin control in a TCL/TK window.
}
\usage{
tkspinControl(base, dev = cur3d(),
continue=FALSE, speed=30, scale=100, ... )
}
\arguments{
\item{base}{The TCL/TK frame in which to insert this control. }
\item{dev}{A vector of one or more RGL device numbers to control. }
\item{continue}{Initial setting for continuous rotation checkbox. }
\item{speed}{Initial setting for speed slider. }
\item{scale}{Initial setting for scale slider. }
\item{...}{Additional parameters to pass to \code{\link[tcltk:TkWidgets]{tkframe}}}
}
\author{ Ming Chen and Duncan Murdoch }
\seealso{\code{\link{spin3d}}}
\examples{
if (interactive() && !in_pkgdown_example()) {
library(tcltk)
open3d()
win1 <- cur3d()
plot3d(rexp(100), rexp(100), rexp(100), size=3, col='green')
open3d()
win2 <- cur3d()
plot3d(rt(100,2), rt(100,2), rt(100, 2), size=3, col='yellow')
open3d()
win3 <- cur3d()
plot3d(rexp(100), rexp(100), rexp(100), size=3, col='red')
open3d()
win4 <- cur3d()
plot3d(rbinom(100,10,0.5), rbinom(100,10,0.5), rbinom(100,10,0.5), size=3, col='cyan')
base <- tktoplevel()
tkwm.title(base, "Spinners")
con1 <- tkspinControl(base, dev=c(win1,win2))
con2 <- tkspinControl(base, dev=c(win3,win4))
tkpack(con1, con2)
}
}
rgl/man/rgl.attrib.info.Rd 0000644 0001762 0000144 00000002566 14100762641 015114 0 ustar ligges users \name{rgl.attrib.info}
\alias{rgl.attrib.info}
\alias{rgl.attrib.count}
\title{
Get information about attributes of objects
}
\description{
These functions give information about the attributes of
RGL objects. \code{rgl.attrib.info} is the more
\dQuote{user-friendly} function; \code{rgl.attrib.count} is a
lower-level function more likely to be used in programming.
}
\usage{
rgl.attrib.info(id = ids3d("all", 0)$id, attribs = NULL, showAll = FALSE)
rgl.attrib.count(id, attrib)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{id}{
One or more RGL object ids.
}
\item{attribs}{
A character vector of one or more attribute names.
}
\item{showAll}{
Should attributes with zero entries be shown?
}
\item{attrib}{
A single attribute name.
}
}
\details{
See the first example below to get the full list of attribute
names.
}
\value{
A dataframe containing the following columns:
\item{id}{The id of the object.}
\item{attrib}{The full name of the attribute.}
\item{nrow, ncol}{The size of matrix that would be returned
by \code{\link{rgl.attrib}} for this attribute.}
}
\author{
Duncan Murdoch
}
\seealso{
\code{\link{rgl.attrib}} to obtain the attribute values.
}
\examples{
open3d()
id <- points3d(rnorm(100), rnorm(100), rnorm(100), col = "green")
rgl.attrib.info(id, showAll = TRUE)
rgl.attrib.count(id, "vertices")
merge(rgl.attrib.info(), ids3d("all"))
}
rgl/man/plot3d.formula.Rd 0000644 0001762 0000144 00000003146 14145464133 014762 0 ustar ligges users \name{plot3d.formula}
\alias{plot3d.formula}
\alias{persp3d.formula}
\title{
Methods for formulas
}
\description{
These functions provide a simple formula-based interface
to \code{\link{plot3d}} and \code{\link{persp3d}}.
}
\usage{
\method{plot3d}{formula}(x, data = NULL, xlab, ylab, zlab, ...)
\method{persp3d}{formula}(x, data = NULL, xlab, ylab, zlab, ...)
}
\arguments{
\item{x}{
A formula like \code{z ~ x + y}.
}
\item{data}{
An optional dataframe or list in which to find the components
of the formula.
}
\item{xlab, ylab, zlab}{
Optional axis labels to override the ones automatically
obtained from the formula.
}
\item{\dots}{
Additional arguments to pass to the default \code{plot3d}
method, or the \code{persp3d} method for \code{"deldir"}
objects.
}
}
\details{
Only simple formulas (the ones handled by the \code{\link{xyz.coords}} function) are supported: a single variable on the left hand side (which will be plotted on the Z axis),
and a sum of two variables on the right hand side (which
will be the X and Y axis variables in the plot.)
}
\note{
The \code{persp3d} method requires that the suggested package \pkg{deldir} is installed.
}
\value{
These functions are called for the side effect of drawing
the plots. The \code{plot3d} method draws a scatterplot. The \code{persp3d} method draws a surface plot.
Return values are as given by the \code{\link{plot3d.default}} method or the \code{\link{persp3d.deldir}}
methods.
}
\author{
Duncan Murdoch
}
\examples{
open3d()
mfrow3d(1, 2, sharedMouse = TRUE)
plot3d(mpg ~ wt + qsec, data = mtcars)
if (checkDeldir())
persp3d(mpg ~ wt + qsec, data = mtcars)
}
rgl/man/rgl-package.Rd 0000644 0001762 0000144 00000003541 14100762641 014261 0 ustar ligges users \name{rgl-package}
\title{3D visualization device system}
\alias{rgl-package}
\alias{rgl}
\alias{RGL}
\description{
3D real-time rendering system.
}
\details{
RGL is a 3D real-time rendering system for R.
Multiple windows are managed at a time. Windows
may be divided into \dQuote{subscenes}, where one has the current focus
that receives instructions from the R command-line.
The device design is oriented towards the R device metaphor. If you send
scene management instructions, and there's no device open, it will be opened
automatically.
Opened devices automatically get the current device focus. The focus may be
changed by using \code{\link{set3d}()} or \code{\link{useSubscene3d}()}.
RGL provides medium to high level functions for 3D interactive graphics, including
functions modelled on base graphics (\code{\link{plot3d}()}, etc.) as well as functions for
constructing geometric objects (\code{\link{cube3d}()}, etc.). Output
may be on screen using OpenGL, or to various standard 3D file formats including
WebGL, PLY, OBJ, STL as well as 2D image formats, including PNG, Postscript, SVG, PGF.
The \code{\link{open3d}()} function attempts to open a new RGL window,
using default settings specified by the user.
RGL also includes a lower level interface which is described
in the \link{rgl.open} help topic. We recommend that you avoid mixing
\code{rgl.*} and \code{*3d} calls.
See the first example below to display the ChangeLog.
}
\seealso{\link{r3d} for a description of the \code{*3d} interface;
\code{\link{par3d}} for a description of scene properties and the rendering
pipeline; \code{\link{rgl.useNULL}} for a description of how to
use RGL on a system with no graphics support.}
\examples{
if (!in_pkgdown_example())
file.show(system.file("NEWS", package = "rgl"))
example(surface3d)
example(plot3d)
}
\keyword{dynamic}
rgl/man/grid3d.Rd 0000644 0001762 0000144 00000004566 14100762640 013267 0 ustar ligges users \name{grid3d}
\alias{grid3d}
\title{Add a grid to a 3D plot }
\description{
This function adds a reference grid to an RGL plot.
}
\usage{
grid3d(side, at = NULL, col = "gray", lwd = 1, lty = 1, n = 5)
}
\arguments{
\item{side}{ Where to put the grid; see the Details section. }
\item{at}{ How to draw the grid; see the Details section. }
\item{col}{ The color of the grid lines. }
\item{lwd}{ The line width of the grid lines. (Currently only
\code{lty = 1} is supported.)}
\item{lty}{ The line type of the grid lines. }
\item{n}{ Suggested number of grid lines; see the Details section. }
}
\details{
This function is similar to \code{\link{grid}} in classic graphics,
except that it draws a 3D grid in the plot.
The grid is drawn in a plane perpendicular to the coordinate axes. The
first letter of the \code{side} argument specifies the direction of
the plane: \code{"x"}, \code{"y"} or \code{"z"} (or uppercase
versions) to specify the coordinate which is constant on the plane.
If \code{at = NULL} (the default), the grid is drawn at the limit of
the box around the data. If the second letter of the \code{side} argument
is \code{"-"} or is not present, it is the lower limit; if \code{"+"}
then at the upper limit. The grid lines are drawn at values
chosen by \code{\link{pretty}} with \code{n} suggested locations.
The default locations should match those chosen by \code{\link{axis3d}}
with \code{nticks = n}.
If \code{at} is a numeric vector, the grid lines are drawn at those values.
If \code{at} is a list, then the \code{"x"} component is used to
specify the x location, the \code{"y"} component specifies the y location, and
the \code{"z"} component specifies the z location. Missing components
are handled using the default as for \code{at = NULL}.
Multiple grids may be drawn by specifying multiple values for \code{side}
or for the component of \code{at} that specifies the grid location.
}
\note{
If the scene is resized, the grid will not be resized; use \code{\link{abclines3d}}
to draw grid lines that will automatically resize.
}
\value{ A vector or matrix of object ids is returned invisibly. }
\author{ Ben Bolker and Duncan Murdoch }
\seealso{ \code{\link{axis3d}} }
\examples{
x <- 1:10
y <- 1:10
z <- matrix(outer(x - 5, y - 5) + rnorm(100), 10, 10)
open3d()
persp3d(x, y, z, col = "red", alpha = 0.7, aspect = c(1, 1, 0.5))
grid3d(c("x", "y+", "z"))
}
\keyword{ dynamic }
rgl/DESCRIPTION 0000644 0001762 0000144 00000006631 14146502162 012553 0 ustar ligges users Package: rgl
Version: 0.108.3
Title: 3D Visualization Using OpenGL
Authors@R: c(person("Duncan", "Murdoch", role = c("aut", "cre"),
email = "murdoch.duncan@gmail.com"),
person("Daniel", "Adler", role = "aut",
email = "dadler@dyncall.org"),
person("Oleg", "Nenadic", role = "ctb"),
person("Simon", "Urbanek", role = "ctb"),
person("Ming", "Chen", role = "ctb"),
person("Albrecht", "Gebhardt", role = "ctb"),
person("Ben", "Bolker", role = "ctb"),
person("Gabor", "Csardi", role = "ctb"),
person("Adam", "Strzelecki", role = "ctb"),
person("Alexander", "Senger", role = "ctb"),
person("The R Core Team", role = c("ctb", "cph")),
person("Dirk","Eddelbuettel", role = "ctb"),
person("The authors of Shiny", role = "cph"),
person("The authors of knitr", role = "cph"),
person("Jeroen", "Ooms", role = "ctb"),
person("Yohann", "Demont", role = "ctb"),
person("Joshua", "Ulrich", role = "ctb"),
person("Xavier", "Fernandez i Marin", role = "ctb"),
person("George", "Helffrich", role = "ctb"),
person("Ivan", "Krylov", role = "ctb"),
person("Michael", "Sumner", role = "ctb"))
Depends: R (>= 3.3.0)
Suggests: MASS, rmarkdown, deldir (>= 1.0-4), orientlib, lattice,
misc3d, magick, plotrix (>= 3.7-3), tripack, interp,
alphashape3d, tcltk, js (>= 1.2), akima, webshot2, downlit (>=
0.4.0), pkgdown, extrafont, shiny, manipulateWidget (>= 0.9.0),
testthat, markdown, crosstalk
Imports: graphics, grDevices, stats, utils, htmlwidgets, htmltools,
knitr (>= 1.33), jsonlite (>= 0.9.20), magrittr, R6
Enhances: waldo
Description: Provides medium to high level functions for 3D interactive graphics, including
functions modelled on base graphics (plot3d(), etc.) as well as functions for
constructing representations of geometric objects (cube3d(), etc.). Output
may be on screen using OpenGL, or to various standard 3D file formats including
WebGL, PLY, OBJ, STL as well as 2D image formats, including PNG, Postscript, SVG, PGF.
License: GPL
URL: https://github.com/dmurdoch/rgl, https://dmurdoch.github.io/rgl/
SystemRequirements: OpenGL, GLU Library, XQuartz (on OSX), zlib
(optional), libpng (>=1.2.9, optional), FreeType (optional),
pandoc (>=1.14, needed for vignettes; if not present, markdown
package will be used)
BugReports: https://github.com/dmurdoch/rgl/issues
VignetteBuilder: knitr
Biarch: true
Additional_repositories: https://dmurdoch.github.io/drat
RoxygenNote: 7.1.2
NeedsCompilation: yes
Packaged: 2021-11-21 16:42:37 UTC; murdoch
Author: Duncan Murdoch [aut, cre],
Daniel Adler [aut],
Oleg Nenadic [ctb],
Simon Urbanek [ctb],
Ming Chen [ctb],
Albrecht Gebhardt [ctb],
Ben Bolker [ctb],
Gabor Csardi [ctb],
Adam Strzelecki [ctb],
Alexander Senger [ctb],
The R Core Team [ctb, cph],
Dirk Eddelbuettel [ctb],
The authors of Shiny [cph],
The authors of knitr [cph],
Jeroen Ooms [ctb],
Yohann Demont [ctb],
Joshua Ulrich [ctb],
Xavier Fernandez i Marin [ctb],
George Helffrich [ctb],
Ivan Krylov [ctb],
Michael Sumner [ctb]
Maintainer: Duncan Murdoch
Repository: CRAN
Date/Publication: 2021-11-21 17:40:02 UTC
rgl/build/ 0000755 0001762 0000144 00000000000 14146473374 012152 5 ustar ligges users rgl/build/vignette.rds 0000644 0001762 0000144 00000000504 14146473374 014510 0 ustar ligges users ‹ R]KÃ0m׺®õƒÉÀG ø¢/ý˜ˆ¢26ô5k¯5ئ%‰+{ó‡ë]šŒv"%79'·çÞ{È[ä8ÎÀñ]Œ ½ †!®1. ¿÷ðVwñ¼H
q\}fiYóˆ,ïÀ±”ËŠ
àÉFó}É«¥Aî¹AÅJN'º ¹þªRª ½1©—KÉxFæx…9¦2©aE$S MÖ Ö'Ïkkµá.nÉS©€ ú¢ÓÎA+Q;݇*r«eÇëp£Ý| |ÞP_ôecšõpo™!Ž´aœõíBf¢¥ZIçýŸyþ ƒkKsZ qíåÐþŒå`Lí÷2™£kû
¦POù£ØÔ¥@Ü/Š²Žm±ÓÝKûÆÐ4Íö°£$§ÒvdÉŸßþèçþóÏ« rgl/tests/ 0000755 0001762 0000144 00000000000 14145464133 012205 5 ustar ligges users rgl/tests/testthat/ 0000755 0001762 0000144 00000000000 14146502162 014041 5 ustar ligges users rgl/tests/testthat/test-obj.R 0000644 0001762 0000144 00000001265 14127571265 015730 0 ustar ligges users set.seed(123)
test_that("readOBJ works", {
# textured rectangular prism
obj_file <- "# geometric vertices
v 1 1 -0.125
v 1 -1 -0.125
v -1 -1 -0.125
v -1 1 -0.125
v 1 1 0.125
v 1 -1 0.125
v -1 -1 0.125
v -1 1 0.125
# texture coordinates
vt 0.025 1
vt 0.025 0
vt 0.425 0
vt 0.425 1
vt 0.575 1
vt 0.575 0
vt 0.975 0
vt 0.975 1
vt 0.52 0
vt 0.48 0
vt 0.48 1
vt 0.52 1
# Textured polygonal face element
f 1/1 2/2 3/3 4/4
f 5/5 8/8 7/7 6/6
f 6/9 7/10 3/11 2/12
f 7/9 8/10 4/11 3/12
f 8/9 5/10 1/11 4/12
f 5/9 6/10 2/11 1/12"
filename <- tempfile(fileext = ".obj")
writeLines(obj_file, filename)
mesh <- readOBJ(filename)
unlink(filename)
open3d()
shade3d(mesh)
expect_known_scene("obj")
})
rgl/tests/testthat/conversions.R 0000644 0001762 0000144 00000002446 14145464133 016546 0 ustar ligges users test_that("asEuclidean works", {
expect_equal(asEuclidean(c(1,2,3)), asEuclidean(matrix(c(1,2,3), ncol = 3)))
expect_equal(asEuclidean(c(1,2,3)), asEuclidean(matrix(c(1,2,3,1), ncol = 4)))
expect_equal(asEuclidean(c(1,2,3)), asEuclidean(c(2,4,6,2)))
expect_equal(dim(asEuclidean(1:24)), c(6,3))
})
test_that("asEuclidean2 works", {
expect_equal(asEuclidean2(c(1,2,3)), asEuclidean2(matrix(c(1,2,3), nrow = 3)))
expect_equal(asEuclidean2(c(1,2,3)), asEuclidean2(matrix(c(1,2,3,1), nrow = 4)))
expect_equal(asEuclidean2(c(1,2,3)), asEuclidean2(c(2,4,6,2)))
expect_equal(dim(asEuclidean2(1:24)), c(3,6))
})
test_that("asHomogeneous works", {
expect_equal(asHomogeneous(c(1,2,3)), asHomogeneous(matrix(c(1,2,3), ncol = 3)))
expect_equal(asHomogeneous(c(1,2,3)), asHomogeneous(matrix(c(1,2,3,1), ncol = 4)))
expect_equal(asHomogeneous(c(1,2,3)), asHomogeneous(c(1,2,3,1)))
expect_equal(dim(asHomogeneous(1:24)), c(8,4))
})
test_that("asHomogeneous2 works", {
expect_equal(asHomogeneous2(c(1,2,3)), asHomogeneous2(matrix(c(1,2,3), nrow = 3)))
expect_equal(asHomogeneous2(c(1,2,3)), asHomogeneous2(matrix(c(1,2,3,1), nrow = 4)))
expect_equal(asHomogeneous2(c(1,2,3)), asHomogeneous2(c(1,2,3,1)))
expect_equal(dim(asHomogeneous2(1:24)), c(4,8))
})
rgl/tests/testthat/test-tags.R 0000644 0001762 0000144 00000001041 14146424752 016103 0 ustar ligges users library(rgl)
test_that("tags work", {
material3d(tag = "hello")
expect_equal(material3d("tag"), "hello")
file <- normalizePath(system.file("textures/worldsmall.png", package = "rgl"))
material3d(texture = file)
expect_equal(material3d("texture"), file)
expect_equal(material3d("tag"), "hello")
open3d()
x <- points3d(1,2,3, tag = "hello2")
expect_equal(unclass(x), tagged3d("hello2"))
expect_equal(unclass(x), tagged3d("hello2", full = TRUE)$id)
expect_equal(tagged3d(ids = x), "hello2")
})
rgl/tests/testthat/test-subscenes.R 0000644 0001762 0000144 00000002577 14127571323 017152 0 ustar ligges users library(rgl)
test_that("subscenes work", {
# Show the Earth with a cutout by using clipplanes in subscenes
lat <- matrix(seq(90, -90, len = 50)*pi/180, 50, 50, byrow = TRUE)
long <- matrix(seq(-180, 180, len = 50)*pi/180, 50, 50)
r <- 6378.1 # radius of Earth in km
x <- r*cos(lat)*cos(long)
y <- r*cos(lat)*sin(long)
z <- r*sin(lat)
open3d()
obj <- surface3d(x, y, z, col = "white",
texture = system.file("textures/worldsmall.png", package = "rgl"),
specular = "black", axes = FALSE, box = FALSE, xlab = "", ylab = "", zlab = "",
normal_x = x, normal_y = y, normal_z = z)
cols <- c(rep("chocolate4", 4), rep("burlywood1", 4), "darkgoldenrod1")
rs <- c(6350, 5639, 4928.5, 4207, 3486,
(3486 + 2351)/2, 2351, (2351 + 1216)/2, 1216)
for (i in seq_along(rs))
obj <- c(obj, spheres3d(0, 0, col = cols[i], radius = rs[i]))
root <- currentSubscene3d()
newSubscene3d("inherit", "inherit", "inherit", copyShapes = TRUE, parent = root)
clipplanes3d(1, 0, 0, 0)
newSubscene3d("inherit", "inherit", "inherit", copyShapes = TRUE, parent = root)
clipplanes3d(0, 1, 0, 0)
newSubscene3d("inherit", "inherit", "inherit", copyShapes = TRUE, parent = root)
clipplanes3d(0, 0, 1, 0)
# Now delete the objects from the root subscene, to reveal the clipping planes
useSubscene3d(root)
delFromSubscene3d(obj)
expect_known_scene("subscenes")
})
rgl/tests/testthat/testdata/ 0000755 0001762 0000144 00000000000 14145464133 015656 5 ustar ligges users rgl/tests/testthat/testdata/qmesh3d.rds 0000644 0001762 0000144 00000002642 14145464133 017740 0 ustar ligges users ‹ íXAo 5žÝÙÝ̦ɒv‹è¡H•àH›•€d¡ ‰Šª©*nÅ»ã5õŒ{6›äÔ3?ñ¸´? NˆâqâØbÏøy<Þ™MÒ¦$ ml¿yö{~~ï{oæ‹uÏóÚ^§%ÿûrèÕ?9QýeùÛ’¿–×ñú²_{ízÞäp È;{ÐÖs¶â×°¤JÞÍÛ1FŸ + 7%”â°‘Zì˜}V)cÏ?qv÷y4vX*Â)I0âÔ:1î±: áðò«Znö:WuçY§mÍ» Š±ÐL—8a”q˜ šÎœš’ î Åc‚˜"Å“9E°,À1‚°DÏûbFyzy"m 3–Í@Ê”3³WgŒ&`,È6Ò! §,Ò×RF’ì>J2‚(A°ÿ@Ùz‰º–áƒlα==LaÚ—Ó˜¤1J5a#'$Ò“2ÌmŠ*4µ'ûåÂõ§Ùì~ŒÄƒ*%ÃŽ¹IÄ]Ž‘"^Úq2z±ä>›Nj/F<"`Ë`JÊHð3.š‡nWíïàÜ æc1Á Öá}Éâ
<•Œ_Ù~díÙÞÊåè+JXRZË»#Jáácqyiû@Nç’%÷ÅÖScÝ~2¦`„.'Ѭ´ C
lÝÅ cZØ ?ƒïÈè•kߣvn+üW¶Ÿûî¡ì ýuþŸQÝsM>hôþƒ_ÏûáËß?V|Fn%ýÄÚÄŠÜÑ¿' îhó—÷íí›ÚIù þøõKKÍ¥ç7~O®T(JÝöÓz m79½y³oÎý©ÌûÑ«¯.=×tà;v?#w•¾§Ôñ…ñ´iîÆÀëö’}Sóê¤R í^ šˆ!¡AßÞ ç¡U
¶Ó£š÷\F^µ7ô-³ÎVðªVðªçä8!Ð+±0ë$uÅÛ{‡"ÃñögdÌ?ÜÞ•)DlïÍÓ”âXB*¢Û r ÿײljÉ茑÷ƒj?ZÏ\^\s‰¿ûù=H$JÇŸ d%Œ÷)‘ª%˜?fso± +`cù¾I!çbùŒÞB'pYë)g_U)âIïà£P䮼Â3P”Ûr%ždeþíŠ 2pì¼H7 ×éÎxÌŒ¸IB¶¸#w2EŠ 'êLˤíO0,;'5Øåß-3k 8U¹/F7)IoS$k°QDïI‹•J<Â>Þ39+^Û±×8N)šàÓMëƒÄµJnþªó;*'òœ…N¹ÿ¨œ£rêEù»ÐÛÚ*˜ŽUwte ð6h1È ,B©> ó@ìye ^ðœ@¤Ezn×–¶ÇxæYxÇqñý¼}êê˜gTM/ø—év™•.Ò/2IÊ4)_v3¼Â ¨õ.Së60Ÿ÷ªþ°®^#ÎæI¨Ñyù›Ë›êÏ9d™:ò7| öv~¯¨qûæ:sØóÛ pìÆO$ÅëçRú ø²Oz"áòƒÄ”EY¥lŠŠÂÞ“6¥çX¾pBw ëNþ’;™ouMfëªï-±“_õ7])– ‘Š/=¶j{Ÿ(þwÃÿ†ÖÖÜí·®ÃèÍwÍè 3z¯fßp¾
ÎX¶W}«¥³ïâ Bbójñ//à¢ö rgl/tests/testthat/testdata/shade3detc.rds 0000644 0001762 0000144 00000003710 14145464133 020400 0 ustar ligges users ‹ í ËŽEpì±½ãÍf Y!mÞ‘8’ð:À"VA""Ê&·¤m·í&óbf¼œÂ•#?Ê/ ´{à'”BB H Ê8p t§æÑãž ×g厼Ý]]S]]]]USvç“yEQÊJ¥Dÿª´©.±?´Ãê“ôs„~JJE©ÓzîÅó~¡ÍE^}¬@™÷Ñ Á#Iðš_$4>”NPë]Çm!t@G éd1m…kÿÇQWn“CIL®#G 6
¿¬ŠŽ]—Ã]ô·*]âÏñ¬sc•r¬_5‘Ý é$ [–n9ÐAºÝC°jx°OÈhlBWsmÜêë Ó°A\—XfЯ»=bÒÕÓ²p
Ëòz0KDZBZ•&jÝ…¶KîápöÍ64;V7h>g[Äôn#Ó#H'è/2Y§ s ÞòúŽw·mèÖi× ¶ì °àLªI vâ0ÔMÀ؃Ø܈ œocÛëÝ6{7 ñ° Ëwþ|þŸÆ°ñ xPvú;}þˆï¾ôå7» /œ7qÕ613p%øüì6ÿôNœ¼¨äÅÛ]üýç;16SãWÎ<ÜM@»å'ÃyŒ«Éèâõ¾8ôïû×ÏJpÀ“Ò çÍâwD '†—)S_—¯)úá 7(àAGª¨Wi Ûá‰!íÐúÖzØ?ZÑÄq÷Èú5Pp£²~°(`ð\Àà9…óq.5€Jd[JCæùÇWVÖ·]+ ‘¦ƒœí•5êBÜ•õ¾mëØ &é+ï9Ôü¿êyØ 5˜£¡|Ïʱ1^€Ë`×xG¢®}| éš–ƒ?Øò"3^× eÍÄà×
«ïâ«VL–f5]ìl„.äAÇô«ÈslÖ¼íXŸ&!î]b_Çmm„Ru8‹ r>‰[^ä«n …æRÛ xÓ¶œÐáÆŒt¥Ù´Âé6‰Ù¶6¯SJaP… ¢ƒU:‘ÓV[ ;D9Xs0¾yVa²X|Ÿ¶.뾦#€Œºú-*±ˆéED—°×CŸå Þ¸bÏ9ØÖQ Ö ~Hx©øâO
Ñߣ¨Cל¦?LóÓÏ e63cvš~ÎÐÏYú9&ðweQM%‹TiXpæ±ÑÄí6uùa c5o. ϵtäB£®—>/¿ÓƒŸr£,ªU¹“¡Ñ ^v–_‹Æ%t
ó3"ý¼òy½¾eüN þÁŽ–WÿÞÜu£š]ËðóŽíÏ2
S— ˜ef™†B™†³Êø™†}Ž&F
G‚h`TúyÇ…ë“¿¼|å–Ó>??®|v4qT˜2©Ç£ OVótf¹†Âe–kÈ®g¹† çjJ SR_ ø÷ÊCï
J,Þ œþ…¢ÉÐüIÓël™{d¬E7¦*SËV™L©®â3ºwDLâá }Ðc—C¥‘â²’Ô‡y§u «o¶…¿^½t™ýËûëÕÊêKKgÙŽðµx‡öÚ¦;*PláóÁ}ÞÔ½¾1ìK¦=©¹vG7¼;V×KÜCënÂ
פÃTsbºSŽKÕiØÛG🠈ĖÿëÍØ|þ…£RÀPÌÔðÙPÃçuàü›aë°õ6´.ž[¯… !ÞëaëRØzcÈlª@" ŽeyëÉ«†É›Š*o9™íowþPæ‹D rgl/tests/testthat/testdata/obj.rds 0000644 0001762 0000144 00000003100 14145464133 017134 0 ustar ligges users ‹ í= 5tvgwovïƒÀ )Eh —pPÂ-Dœ‚DDÈE]ðîxwM<ãÁž½T©ùéhø t¹Š
*„("P
"¡¡$Ø3~žï|Ü&!$ÞiÎöó³ßóóó{ÏÞŽã´NKþweÕÝTÿdC•çäwF~-§ãôe¹òÊ…duC¡w 9 ƒ„,ý*†Ñ» 40¾ßÈ 7!”b¿›Îã™yꇺcÕÿ¶fwùtd‘˜SbÄ+±elìeu(¢ÝH¶jòãlѾN;×î†(ÀBä˜QÆ¡h4C°jJbØ'Œ¡é‰çÁ0DÂBÝî‹ åê労.DÀX<.ÎÌ\ß‚º ·±á~àCu¦ºú\ÄHßDaL%æßPº^À®Äø0žsœo EÐìËf@¢ E±– BiI1æy špj ÷³ Gñìf€Ä"&Æ–¹NÄuŽB!žéq#bôhÊ›l2°½ ñ)]zÊPLBЀ£ij¢ÉÑíª¹õþ¯Xûï‰ùHŒqˆõñ>›£õ 8*o»ÊÛQnÎö™„Þ¢…™¹Ü»¢:o3d›¶èh.I[l=Ö2–Í'ÏÀ”Ðåd:Ë4B|ŸY÷`†1Mu¬ÁµÈðÅ?× $µ¶ê?“;þµ°óï_Ý‘å½?žÿkXÖ¯ñ@WǚƷp]ŸNªb…îèïow¸~ÿºéNJw¼ñÛOŠîÞ£ŠþíoÞ 0JÜöãróf²¼zãÏWWê}÷Úù—ú5 èç3|ëä]RÆgFW«ÓÄŒÖ.%ùº¦Õ ¤p¤:Ú¼Z‡P92'†øÆûöf89Zã|xTí
àÚǺ}lÆå<¯<ïX1NHèd¾¥U¿*>¾ºµw$b l}@F ñ£]BÄÖÞ<Š(¤KEtë .Ýÿkq<Éñè¡ó‚ïr}¶Ï‚_³‰»ûá
d2Žß;Œ37Þ§DŠbôý€Í¾Â|pY Ì÷MY
d ½‚bN`³gŸ1≮aŸ£ÀÈYyfCa®Ê‘x gñ·+ÆȸKoŸàƒˆqpsNº31Ã>;¸&g2I
#êL² íŽ1 [•ìrŒ¯g‘ÕS”*×€Ø ÃK”DW)’9èhJoHeBo ¹„}¼gbVrxó†½ÂqDÑ/×,?$¶Võ•˜ìQÖëLeJìGÅœ5]_ˆmmL'—wte
°
Œ°ïËðn’6Rr;wS$ wkƒîù”š¯Õ*Qé Z›éÁL’…~Îø×ÖýlŽ|¡Ø'Ãq2WzÙvO÷¬² ¿ì¸ª²j¾*7zRþMtÿ¶|à}«Ê%˦ñ§Ý_
UfêZïÉ, .,›š.fne¨kÝv2SÍEÌ"ÔDåV:Ná;KX›( ¾¼™yk”“áÂÎÝ»w¿P<¡¼¿½=Ì—¿L&Ÿ¨ò¡n?´ð¾ü1‘ùç¯?z/ÿ¬û®Êu¸˜ÔCýé÷—š[»fÁ¿¶À)·À›ª }¡jev~]%a]IzÕ +Ti[³Â ËMŒï4”MÐäC› ɇ>-4ÉwÇ©/›äk¿lŒYvýMüŸ ê|ýšfþZHSúµ‰— «+‚I1ÉØd¤½ä%Ìä§1> 3Æ}“˜É,+Îrüy
…fñ^ˆå‚XàN<™›¥YVy®–äh='ËÑV +G£éÍ]úêÑÔNÁ ¬4uyÒ²DtµÌSŠÇUo¿êÕÛP½Í¤—
f7(’×ØÍ=s•Úƒçdö0pŠö0Po§SÎ桯÷Åçø7.©?k‘Ù"yüÍeL;ßon¾¬vÄ.«wè´3¦ÃÎàvåëyú2¹ðBQУ·”Ã)‹åOz"šáìz¦qáF=Mïôå–´.-'g '4§µFsrÌÉüŒS¥¶®zŠ–žÜ¢½éG„ì÷…ôG€¼j}/á(þ7Ãÿ†–>Ç´/n›ÚES»`j¯—Œu+Ö·Æ‹÷ŠÏ"ÅW×öƒÊ›W§ ¼ú¡ # rgl/tests/testthat/testdata/tmesh3d.rds 0000644 0001762 0000144 00000002631 14145464133 017741 0 ustar ligges users ‹ íXOoä4ÏL2ÓÌ´ ŠzÙÃ"!q„Ò]–ëÒ•X±jW«½gâɘ:qdg:mOË•O·Ø~€å„88!$qâ¸ÅNü '“L·Ð= ájûùÙïùù÷þ$O‡Žãt ¯#ÿ»²ën«r ž·åoKþ:Žç äsí½;y“Ý‘"ïýé@ælůeI•¼Ÿ·+Œ¿¸R@J(Åa+µØÇ7û¬R úNÿª¶»Ë£ ÆRNI‚o¥6‰© Ë£Xˆï(¿ªåf¯««^›óºÖ¸— ÍtˆF‡¢é Á©)ÉàžP œÀÐ)žÌ)‚e>Ž‰„%z<3’ÈÓËi[ˆ˜±lR¦œ™½¼ MŽ¡/È96Ò!t§,ÒÝ·RF’ì%A” ؤl½D]Ëði6çØ ž¥0 ÈaLÒ¥š°‘‰¤ s›†¢
M-ÄÉI¹pâ4› ÅH W)pÌM" s”ˆñÒŽ£”ѳˆ%Gl:¨ýñˆ€-ý)e(# XÀÍPT@4wÝžÚ[ßÿZíþ}1Ä'X»÷-‹×wÀU>1¸²qdíÙÝÊåè+JXRZË» ¥0yÎX\^Ú Ó¹dɱعÔ:6í'}`
FèqÍJ‹0¤ÀÖ[Ì0¦…
ò3¸u~ûyœ÷ºj~Ërÿ•mï§_¾&ŸÏÿxû¯qÓ¼¦ ´çzÿ ïÛ_ÕüEïé‹œÏÈø¡’X›X‘=ý{êŽ7_Þ··ok¯Ëw¡Íj.Í¿ÿòþ׊R·{Ù¬£
“ë›7ûnýweÞÏvÞYš×tà»r?#w•¾×Ôññ´icà?%û¦æÕ
2HÅ¥<
¯Î)tÎŒÇÐDßþ ç®U
¶Ó£÷ë
ŒêÓÐË4k+¸£Üqj9NÈ è”±¥Ó ¿-?~°{x&2 ï~IŽøÙî¾L!b÷pž¦Ç2¤"ºû)—áÿÃ,›Z2ú cì¼Pík®nÀ[×ê‰ÄÝÿê $%ŒãÏO³2Œ(‘ª%˜ÿ fs ²B–Ïù‰I!뱜£QÆ \Ö0åì›*E “ô ‡ -€"wåž‘¢<’+ñ$+óoOL —þ Á‹”q“p í3â$ Ùâ@îdŠ*
ò¦eÒv'–K
ö9ÆËÌê+NUk@î‹ÑéJÒGÉš lÑ'Òb¥Ò#$p‚MÎÊ×öÇ)E|½a³“Ô’›¿jÄüŽÊ~ þj‡,SBþæn…¸½ ··ßU7R¶ßЇ8§µ½`·~ú(^+—ÊËcVÆ”¾Hg¸üÐ0eQV)‡¢¢ kFÒ¦DŽ……ׄÓÆ•pr—àd¾Áµ™§¾£ˆšÜ*ÞtX~ *¾àØ0Ôö¾F ø †ÿ
6ÖÒÝ»÷Lï®éÝ1½Öº-çÛàŒe‡Õš¶Z»õ8¨"±yeø$Pd4à rgl/tests/testthat/testdata/transformations.rds 0000644 0001762 0000144 00000005154 14145464133 021626 0 ustar ligges users ‹ í[MŒ GîÝùñìÚ;lìËJÄÒòc'1ëe-ÒǬ ‰Ë›Xää险™é¸†îÞ?+BË…¤€¸ !9
ˆB>å€z‚ 9 Jdc"d,²²¼Æ±¶D„bªjêUw×tMï[8¶Ûêýê½zõ^uÕ«z¯§]ß VePÉà¿\Ìl#0AðA|â{@É*C7}~7½p±HØê5®a*Ö½%M¢ìiz%(=—h _×
դܮž×Ó¯ãPV„ò'‚öŒÓ¨"ã†n!Í‘rã̈•5ë
²E:U½W¸Øu¡.;¢s–f"— =̪mØšÑjjðÔ†îÁCF\ ¥É³Z™–Iýhhù÷½ÔS~±„Ñ¿úÀÍR\=ム\þÉâNŠ¿ó!©oOþ Ó!rÜnd fjºÉ†˜°³ìþº[9ýÕ°zÙµZ¹vñÒ™qÒ½k’úŸ5;éîàø>†ÝdíÃë}oó2¼{îÚÞSÏø —¨Ûí×ß5ö15¹¾cJÝdEÄâ#L–]A"K*ËÜk`
‹|Åè5¾û曈.Àp8<:ïß\XYÂ…c¶BXm3,òváîb Ü¥1ÎÅ ì-1öeññɉ™E×CæÄ×õŠ£9‹Ó8„¸3³–L¼¥jÆÄ3Þþ¿àyõ<Ø()&×_Buâ ŽÁ¾&’Ìô7A@Ð–í ¯-xÁ6>dè¸kr@~È´g]ô¼]ƒ-«`W\äÌñ²ÙÄuÆóšçè0YÃ-Ç~9Êq胨æhóÀÁZˆL‘pà–¨êñ7çV5¾]æt4ß² pC›t¶R±¹¹yݪÙó±&žTi¦n€eëAÐÎT4ÛŒ{0í ôBY D’äûLmáYCo 04œÀ5ŒCxÄ‚N5üsh†Ç,ºxÃŽ½ÉA-C«¢µ‘ñ‹D :üÑA¤sø9Ùš!þCVÀ£ø~ ß;ðMöÿÇñýñU|?"‰wƒ:d5ÙP.’ÃiÁT #³‚j5 òy"cWHß\1Ÿ«š ùÜ Ì‡Ó0xÜgCY]
lPI20ĈBhA<&,: àuÍj$i¤z³ýéénþ yØ ƒ4· ¶áýŠp‰Û¨l[MÚn¡¾$¡E”Õ'é‘Ñ"r½E¾@ËôHi™ÞÕÚù£Þaò1a”dµaep†/;Û˜ ¼Ôe¤arਸj6Ù{ºBCr—Ÿ½cšGhˆÕT …ú0¦žzñÅ2±)Ãßx£Ýo09†¥\“êKƒ]=¥‘õÑ1cT¦+vŒV9=ûýó‹?/áBZ¨¦Œi÷çÿ¥ÿÓ"ß'Y§k†ß"±Ð7üLÍC$yåÉ r<½Ês¥<£<À¡Ý ’ÍM8 55Èh‚J{‘^@Ž°'AhOz’ƒ ŠÜ¿5«ÕRK d—,&Õ-Ãê—~‰\O;Yà™þ$»2ºÇÞ¨D¿Œå×Û^|Gûc*ËùŽI¶Š6Wë†Ò™bÿüØd‡ÐÀ_þå3Ç²ß Õåý?¢rÀgí€Ïå˜ äfõœÏÛwõùÌn ås½Ðß÷_:GfÝ¿ñÀ$mwêÌOÂ|õÚÇoQümñz›ð?šú!mÏø¼ ボÊô¨ z¡ äY{núö>× v¯û7©üÙéTþßÇÛaþ…ï¾Iõÿ~d™¶¿4¼›Úg|hÇù zŸëeõÀWÁ.Ø» Gàƒ^hwwö1õí½ µùÑ+j™àOgNÐÇ¿Ò:K¦Ñd| ËÑiaíü‹/o¦Ãw2™Ê]?·LåÞ}iªCø€Àgr*kç_ýö´]çoUªçúÜ8ÁåÓ9Ò #•>ȱv)¾á«¿»ø_jJÄ•}åN ¾öã×—âðÒkGÚ1èË·+ÇáÊ>M‰Cܯ¥8<÷«óTß?zh<ý«ÿÙQŽÃ?<ÕŒCU†¬ˆ>ØPÅýjÇ ¹y¥ ‡gv¾WŠAõ½ÌŽÇá…?=Ô‰A c;q;%U°#"ë—ˆ÷r"°®7üÇ•4ßðyÀ=ð˜…ÀÎ ¡ ä!€CÀ‡Àõ :ȃ $$¼_¬ Ú=°b ‡@ Yì¸y õ ôA ö@? èƒ~€>hú q€Ä¬èyb Y ì ! C€}(€<è‡zЉÈC¢ ú€{ ÏêïîD`«zéÕíô±ïSé0 ß÷tw^Ý^&x±ü †þ…ßì¥ò ä_§ÃÉPÅüqB/;ã”ƸDèwVæŽüç ‹”ü¿¾òkJ3Lñ
Ÿ<*é’ñ”û Ÿ„Lñvú š€> ±aJdè' L¡ ÉÔ–û š€Üdˆ]£ ªIÈôȸZ¹ª x/ö5¿á?¡¤ý†/ûNF'ñÅzÙOð² Æ’ø"ÝŽ²9-"\%E¾HËôÈh™ ™]Þ^øßY¼½ð[î'7ö1ÿÃî·pª è߈¢øÍ>©¾
ÃÎptšßðWÌ7‰´PMýÓkCu˜ºþÏ=|,U Þiò÷r"°®7ü'•4ßð“¾Ü$öõ~ÀêoGÉž@ÛNÀR&éO²+£EyY –Ñ¢üzÛ‹_ĤÌww"°Uö;éÃn›a©¿Xâ%NÃýoøë¾îÃï÷¿á§ü†ŸW‚ þˆ"f£{¾g0öl\ÂŽwVÿ–¤ÙÝ(Æt<æmÚ¬e'„#.“ïï2}]d¨{ôD·‚s6º¥{¨?¡Ã‰IÞÃJÔ †É Û†cÏZ5i¦·çYòoµ™^V=¹mÛ8™å3t»ÃicW
Ž-=cÝ=¿ÚsŽmûKßý$ﶚ(8Ñ\·^äÜU£{ò+Þ“F°ç„|a•îôh¢;ez܉ ö—
[Ž Øv…qÊDýK„N¡wŠÇdukØ(î»á§Ã
#= ‚žO}J{vóÒ$/}‘—¦xioûe^ú/=c-#‘-Žm{3Ñ£uÑ“yqç${7?Íø?|ˆï{C rgl/tests/testthat/testdata/subscenes.rds 0000644 0001762 0000144 00000077127 14145464133 020400 0 ustar ligges users ‹ í}|Õöõ¥*ŠˆbW4ö.öš8GTì
, $tˆÒ{¯7!¤1xD¥÷z/ö.ßÜuöšL „ "óþßð~¾•ÓvY{fN¹¯žáóùÊúÊ—±þ¿œõg¹jÁÿ³A¼Ìú¯ªõ__y_% O»úvü³þ¬Ì6ùøï TÓÿ £IÑìZøw ê©ã*¨Ø$*::²ñ1sµœÓm9%ο}Güý×ÒËÅ6mxD•"Ê££ZFFÄ 3·85GºU>:2.Uª£ÿ9Û iúeåË:ÒZF´ˆŒ“J—1³QLtL,ÑšEÐëè¨6ŒSD‹†Q‘-™<=®Ud£¶Ñlvzd‹¨¸¸¨˜–’®×,ª¥å½å‘p×"&¦M3jicË*ß0¢ÑÛü;.ªS¤½}cþÙ$¦©üyv«˜¨–mÞŠhÙ&*":*‚ò«¹>*÷´6‘ Ú´t&;¶b²’•lÕªED+ɨŒŒ–Ö•Ô&2֙ѴH^°adËv…
Ïh ÙªM³·ZDĽ]4§Md Ý<+*îå؈–q"b y¬Ò*&ºcÓ˜–oÅ4iÉÜŠ-"b›F‘ËÓ›DÇD´‰jIʵ‰hª/Qܺƒ²%þ§ ÿÓãÚ6ŒkÙ2Rnï‹ uO÷ñVyؾ®œ×‘CfÙ Ì
Q˘–… ÆZ±k ÍÂN11-
ƒÖŽÙÚZUp-–9,6'Ϻš„
±QM›2Õ¸q4«Uhß,22Zs Ê yƒ¨mK—˜ø«l°¼ªãö/ñŸ±bkJ¼…çü¤Š+—|Ö³õ]rg‘ê¦è/Ô[ä>,×8ª…OS Ì./ÿýEsÕYëÂÂKanië™Uvm ºu¨øòÙeç!Er‚æ–=\¼ÎËäÄémÓëÌ}AzkÖ¾µúQå’ÏzÇ•gë-ÉÞ´ñ¤Õ+‘S\Ƭ{$ZÕÏ’ºò=H‘[ª¼\^e:ðŽö ÕØ~úVl‰[«P±³{ ¦+šy;–šÖ *oÍÇ~ ͼ}Òͼ=û‘Ö(NÑÀ[ÅÀ[}GôqqÖÐWøl)SŒþcõ·Ô¨Ó1®Md‹ÏF5ŒˆíX£–Õ…ÄÕ¨Ó¶U«èÈÖ#5"ºÆ#±Öãÿ¶6mš8tT¤åû*øo‘£ìH/âsíÈŽ¤\ê²CˆjÚ2&6òñm
ã•¢£,ÓZFƲ~¥1mã"Ÿ‹iÌGÖé1
ã"cÛÙ]È™-¬²èç"ÚÄF1Xg´Ši^4'îí¨Vµ#ÇF´gŽ%5¶H*Áœ–‘Úö¿âEØËÓÛEE¶okw¸Ž‡tù†
cluí£Z6Ži_Û’dª"ZDEó"*ߤ°Ó.×(’Íδ,¨ùraÏzz°fp¬Á¾¯ED‡G££Z½ a ÈQÓèºc…FW‰°\hYÇî³pó:/ìÓb#[EG4Š<±dñ7É‘¬€þ¢$"F… ËO¹gxWºoý'ChôÇ ××…¾¿?¾Ðë åÿ¨?.¹Ãð:a¯.Úö?î„ã%áuÂ^'ì¦N8ªe³ÈØ•Ò%ON'\Y0xm-²Ï±þ;ק;åó¬ÿηþ»À§;Û3Ñé•âRCyÇAk®~ ΈlÑ0²qck n¯.Ä4 Úwä"K£èˆ8.²”e|b›FÛ¿Poei ¾ÂÙ¼sôp±ïß =\ì åÞèÁç N¤ÞÿÐèáÈ)|¼z£oôà Nxôp‰ï¤Ž ÊQæ?0\êû÷ —zG¹7`ðy†©÷?<`8r¹!^*{oÀà
Ž;` ¥qÙ€¡ˆ-ÿ[Dÿã0B©*£š3 7ìYG<N‹kÛû:eeßå9³ï«ñŠu/ÅÕhÑ6¶qL£f5âÚµ¬ñ\ÇÚ5,ãjDµŒkSCNÄÕh Ý8®…5عU˦GYŽ´9ÏÒ yHÆ>b÷PÕŸÕà¸x+cVƒGÒýA¬?´Að5뵎O ë}w¹ÄºŸbY»/]ÕCñÙÎ
X˘ŒzÆ—CÎ ½[±rÝA »ö²îÁò°ûÛ]”Vó÷‘À§¢_Fþ ±wÛ…ÕîxøòþêÀz§×AûWçäëŸ_ íêÿšÄч}Nd>ë± åP.õP/í ]´Sì¦ ¶_ô“~“òBžÈy$¯ä™¼K ÌŽ½ê… _NvÈŽ¶3Û§½ ”k¶S¿å™mÚïA:öÕÅA9fÌš[‘ß¼ÓÚ <³ñÔÿÆ9õQïÅçÏ
ÚmÞtçYÁ´ztÜÄ`}U÷“)Áú*"éÁ ~ÕÔß>¨Wµx Q°½j}ó'¨;¤J>ë± åP.õP/í ]´Sì¦ ¶_ô“~“òBžÈy$¯ä™¼3ƒ+ïAzж”jÑ 80¥3Ú
ùìè×c-êõ~3%ó£ÙÍ‘ßÍ|õ;¯GyÛií÷fµq]šö* ?ßxlxhõÃøÛé¥G‘ße|wÍûW/+ð9¶+xê[® xì` ê
¼ñ;¤×Ncæïh7¸ìö"È|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3yg FJ|Fž{ôŽˆË@»á-#=¬âÄuHÍû Ð
Óоw?Ê{ÝÓå ´û
zÞýü"ØÑêêgOí×÷E£·oíâO×þ·ýù 5|Øg_ òü5 éÁÆ Ô Z£/x6¯#øþg
òG,ö!=òÁ3âÈ|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3yg Æ7½ õÇ_{Òã †ü±—N€¾Ñ¯OÕõoÊDþ°~ <¤.Òžhö=£Ã ¯ËÆ™H·©|ä½xI:xhvEÿ`}õÎ÷=ÀO÷ôíÈï[yu°žøs=àÐËf‡á»a·õÒGAyjÌ3g þØEã?né^¤ÇרœÈ|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3yg õým&öž}‰D^¹
èúÔ ûK6êÚ‡üá/=¹ƒ‹ü~µæ@^÷'/ƒ}í Ê¡][?‡Ñ3ã“Ãïž+*ÂßÏÖAþÐÈhä¼f(xÓ©Šæ»ÞÒ <å_½|&.C\ëëþ91õZU%ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’Wòló.qH —£±õcˆWÒî ÈO:ã^¤Wêç]Bá¨7þl]Ô“aÏ°æÏAÿÀøÛcô¥hÿΨ ”×½e*ül5:
|t{¸>øê»á7àßiàeDþaàØs0QþvšïË× F"ôA ò’ïOB~ò຾"(ù¬Çv”C¹ÔC½´ƒvÑN±›~Ø~ÑOúM È y"o䑼’gòÎ8¤Ès,E=‹üINœ|/ä'?_é #Fiù’ãÞÓíG¾öê
^8!èÙ{ùýÈÿþ7ƒþš¯÷üŽ?|tÿL?Wlø —üÑ¿õ _"Q?q\sÍkç[Pâi ÀϤ»ýP)¾GÐ>¥Éòø"(ù¬Çv”C¹ÔC½´ƒvÑN±›~Ø~ÑOúM È y"o䑼’gòÎ8L¹í{ÄiòK4>Ó ñM½óM Ÿéíµ¼ù‡Q>áà !ÏÿÝJ´ sÛ!Ø3¬L>ììw¨
Ò]êGû›ãà_›ÍÚÏ wVš7'Ø^¼v xÉdÍW®š¿Ì
šÏù÷¯”÷¾_©_Å Ýäiã‘ž2)Þ‰Ìg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“wÆaªî÷Ì©ýpŸšiË/ÔqòW€üÔŸ—£|Ò–N¨ŸÜ줇ü ·£pDÈtà€ Ó`_·ŠŸBï›kƒ‡vÛ¾/½>< 2¬ pôÀßáÂYx£I%Ujœ˜Ñ å)¿=
œ¼¶2xK{ò øœªt¿0uÖ·!EPòYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqH¿NÇ-½|wäOX?ç¦ }i×lB S·¬@ù¤»~‡¼¤«G ÿÓ¾¨7ê:¬˜ƒ":!ýÁ¸Íh>àðÑañÙÁ´êcêqé°ôs}ìæHðØi!øLžqŽÃˆW‘žrî…š÷K*#Ú¤©7=»5ä¥Wÿ%Þ‰Ìg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“wÆ!CúûŒÛ³Ñ>}.æ«fzU=™v÷‹À)_üˆú)z“ÁL [ò~A¿gŽ©úê
þø;à‡Wb½ÈŒ˜÷ üꔀñ‡ê·vü þíÇ@ÿééÀ +ª£Þ¤ço“#q½©©géçýô‡b4ÿq ?£Ü h—ñlù"(ù¬Çv”C¹ÔC½´ƒvÑN±›~Ø~ÑOúM È y"o䑼’gòÎ8d¶ ˆú™O/‚œŒU×BNÆEïCoú9¢ýÔþëÐnòû Pâa=®žp…BzìúÕh7äÏÉHÔ§3°áž©ð÷ݺçÀ¿Í‡GvJ gž’/Œü”¯üH§]”§¦í¹éô±h¾»œ†üÌK°n¡2›êþÀFÉg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“wÆ!Kͬ—0Ÿ53WuÓqª¢×_ÒÙƒüé÷ÃNsÊ a:þOߎzIwb kŽïù ä
»ùYÔï±q ô5ú+øxoÿ#ðo`Ý÷ÀǨ] ‚õTbù?¯‰O “oÿé©“õ:dz ý\Éèó¹æÿ]=¯Ìº< é¬VõýEPòYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqÈŽÁº²™ýØ ˆ_Ö\=nÈ<´ù‹þÔq vLm€q¼™úNìH®1i¯ Qø#c!·×…ÕQ¿ñµÁÇû ƒn¿ þypŒŽÇλ‘?)"ùS:.Bü¦_ÞéŒÎŒºé¬ÆIh—]%
üe7n\%ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’WòLÞ‡ ç\ÙL—þZÇ%0X· ð
0£ÚÙÐ3mL¤'¬‰ú/X‚t‚ñä0Ú#¿÷];`oäÚ àgüK´Ÿ?MCzlËYA;Õ„œ^à%%|=xLKÎAüÒ 8˜±N·Ï’uûìûë ½{4Ò95+p"óYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqÈ99»k|£@×ïØvdס~FÖ´Ÿžÿ8pJïÖ¨7qÇ
èKØüìyõ×h×çîs`w“IágüÏßÂÿÁ©‚ŸqÝv!¤¯ •Z«%üŸšÕ ¼¦/Y ^2»…‚¯¬ ‹5ß?ÍBýœiš¿Ü3±žd#óYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqÈÕó$3wÄ++u0Q¯ºÞ?ÉZ3í3k–‡¼ô7"?Ù$¤'›
{¥?¹?å}/ˆò¦o,]âõ|lÈ7€‡ñ ~E:¹ÚÃHO>ëÏjZbð•ñê ð”uánð”ý¡~þ䌿˜ûúdäçæ?_%ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’Wòló.q˜¡ŸŸæŒÛãQ?wìÔÏI»éì·š"n™ùZNúÂùÈŸzýoh—¶\Çcÿ°wÔ˜:Èﻶ=Ú5ýý6ø×å§óÀÇo>~=ÞVÉ º|²ù+xšÞêð“±èSÍãˆ÷ÁsNÕÍáàûvìǪÜï EùŒW^-‚Ìg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“w;2œ‘þêϸ¤‹Ž×Õc!?û›T`Ö5"?ã Ï©óP?å³&h?¡îyÈ -óþ~‚¾fï¿»¾v&xZ³‰öûý6àgâE¯£|ÊËz <½ÊçÀÌ«Qž]¾#â˜óÁ¨—;ùwð;£õǨ7c…¾Þm”|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^ɳͻÄ!OÆgy^ëu^ªãÑíS¤snª¨ãÑ^ïïfÄ.G»iOéçfêmû´]“+Aîè¤ßaÿráñðc÷tÄ¡kŠÞÿ ª×1•ÿ‹ ?±Ã³&xYX˜þrgÞ:ëõîìÐ.gKc”Ï8«™ŽÃªÐ>/,*܉Ìg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“w;zýÀÌk<íg|ù6ôä~U˜ÓòŠpÈÍùéŒÉ¿ÂžiS¢´ ïÿ ã±ûmçŸì–ý•¨ÖÀï®ÛÌxø¹Mï§ûÿ¬'š#ÁCÚ5ôž•4o3ëèxŒÙ†z¹7|£ù®7DÇášPÈÉëÝ,¼J>ë± åP.õP/í ]´Sì¦ ¶_ô“~“òBžÈy$¯ä™¼ÛqÐóT+ÝõgüñÒ¹`½ÙÌç¥Y›
Pž±çYÌiûFC^j®žß$U› yc h¥íN݇tTŒ~NtÓûÃjعšŸ„+o×ñ8ô3â”þ‚ŽGšÎÏÜ‚ëFeÏÏAyn=Ý~FÏ»P/¯^_ð—^%ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’WòLÞí8È:K^æ»:ÿ‚Wt\ÎÓû9™ñ¨—õÃFÔËØúÒÓϪ¹©Kô<)é†ÕÚÎz
zû/ÔûQú ‹êve¥øySˆŽÇ]OÛ«I•îÒ¼t~Jó4K¯gþt>ʳ7¦¢]nÌ: ‰UQ/¯õch'‡u QòYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%Ï6wÅÃ{^ùvœòç•×ŸûvœòþÜïšN;Nõx×›ºk>è—¸k½Ä[Ot×z¢·Þî®õvo?Ê]ûQÞ~»ök½ó î:Ïà÷q×y ï<œ»ÎÃyçEÝu^Ô;Oí®óÔÞûîzßÀ{ Ç]ïãx﫹ë}5ï}Nw½Ïé½ïì®÷½ï¸ë{ Þ÷2Üõ½ ï{2îúžŒ÷½%W}oÉû ™»¾G6³Ê‹}—[ª7B»‡¶< yù_Eúé_°Ÿ6ëŘߴžË[!ýÊ»=Çzñ/BÞkW>9õ_MÕq¾ò1ØÝ ýJ®éúú<Ǭ׾ìƒö¯¾á‡Üº½žD½—_ŃfÖK‹‡ ÿ¹?n†ÝO¬¹
í yi 캧œnÙ-wƒg¢ä‡I½0i&rÂDn˜è ½abG˜Ø&v†‰ÝaâG˜ø&~†‰ßaÂC˜ð&<… oaÂc˜ð&<‡ ïÚqÐ~˜O‡¬ ¾¶{oPžÙèf|M׌ªúò[öÕëýçŽ úeÆýŒsfÛU÷"¿}ýYA{Ìï^Ôkv¼÷# êquÇè]¾#
éö¿TDº]ÒVÈióÝ ÔÝžÌVýêßÞ° õ›Ü8õÂ/B¿lÖù¨ô>x›Þ$J¾’zJÚ)‘£D®=Jô*±C‰]JìTb·?”ø¥ÄO%~+áA /JxR› •ðª„g%¼‡I f…êø˜õ«]~¢Ö?À÷•7i Ë}ÿ;¿÷âÐå“GÁS·ýá¨ß}áLäô|[`˜ûÀSÏ Óر¯Æ7g£]52Ùû6ðÃú<Æ;±navݨÇåñÝÿÎ7!hßîòK ¿UÕK §Ñ{7£\ü¡_Jò•ÔSÒN‰ %r•èQ¢W‰ JìRb§»•ø¡Ä/%~*ñ[ JxQ“ޔð¨„W%<+á=Lâ0ëq}ÛþŽ|ðÝ8ßgvÍ ×¼-؈z½º D~ßkÁ߀§Û"àÛÝ×AÖCzÐ×MPoðÍ€ƒ~Š€œAƒ’Ðn`>/6`ëFðßßXŠò>wëýþ ™9(ÿ`AÔïqäw(WõZ\…~€÷‰}_H¾’zJÚ)‘£D®=Jô*±C‰]JìTb·?”ø¥ÄO%~+áA /JxR› •ðª„g^?a‡YÏèç˜}_tL>äC ~ùþ÷øæNðÛ/ì:¤= ~Ö|
»8¼º>ß:â¡õàsÄz~4ò±r¨?òÆàˆä gøÇXß0‡E½^‡|2FÇ1wÒîDº÷=¯ê~p,ô¼¿~:ÊyÝð¾'ÒO©§¤9Jä*Ñ£D¯;”Ø¥ÄN%v+ñC‰_JüTâ· ”ð¢„'%¼)áQ ¯Jxæ}&q˜õ’î÷ìç ýýhàðÛoÉ^¤Í×çT‡®Î#úêõþQkQ>f†¾^Ç]‚s²æxßå¨?¾Q%È _³<â3nìhð:¶ƒ>Ÿ7zUw ¯Ùñ:N†~Þ
ip Ò¯LöVºÿéö¥žGñ>a?Aä}!õ”´S"G‰\%z”èUb‡»”Ø©Än%~(ñK‰ŸJüVƒ^”ð¤„7%<*áÕ¾^„÷0‰Ã¬—uo÷¼/úœ3|ªpØ›OQåõ¹î±ah¾¿ü&\\ å ˜ùÌĶãÀkbºÞÿJ ³ r ü zú´„ ÿ«€ãÒô}:z:ÎÛš# ®ŽzCšèu à¼}ðyÊþ‘Èçý–vJä(‘«D½JìPb—;•ØÄ%~)ñS‰ßJxP‹ž”ð¦„G%¼Ú÷‰ð &q˜UOíþ’Ïú?ô>=¾¹þà¸ó°¿cúwÞ£y~÷gð5ásœ÷3“>þ¼&×ûLãè
»_‰öÉÕ0~4“ž¾ú&ÜŒóPfÂ'QÈ÷—¹ 8æ4¬g˜Ã‡™Ð7hÎJäó>aÂñ‘ýï i§DŽ¹Jô(Ñ«Ä%v)±S‰ÝJüPâ—?•ø„%¼(áI oJx´¯>G…÷0‰Ã¬úz\l£Ø_ð¾~ø ð=ÖÐççÊÎÑ<^®Ïk'í: œØ@ó<©ÕÏH§\ÝFc«Žà/¥î\È™´2 '~‡y–™øKúäKà¤çª¡]ê»Qšo5íÒéyÇÔ·õ¾ðÔzýêä×5V©ƒü)¿\¯ãŸS)ñ>Œ9±*ÖõÌ /åƒo^|^r\Áñ7ç[DŽ/ÙòyA^D®=Jô*±C‰]JìTb·?”ø¥ÄO%~+áA /JxR›}Ÿ°?á¸Kx“8ÌŠÐëöü‹ãLö§|nŸ‰ 0¯7SÕnà”ñÕ5ÿ=ïoÓ~¾í§o9„òôk°ßc¦W{ 8ý½1ˆË´¯D½´ X¿3'¿÷ ò'íÖç+“]¹¼OØŸpÜÅù çÛDÎ/8ŽbaßZ®=Jô*±C‰]JìTb·?”ø¥ÄO%~+áA /Jx²ãÏç$Ç w ïa‡Yô:‹=ïæü‚ã(ö¼/Rª§!=åý>ÄÔ¤ÏÀ×ôL½^’>6 ˜qÙ#¨ŸQ[¯ÿg¨ Ÿí[ 'ý±KÁ÷´O°Ÿg¦µl}©©ÑñθóùÈqÇÛœ—r]‚ÈyÇ›ìWùü O¢G‰^%v(±K‰JìV⇿”ø©Äo%<(áE O…÷‰ô' wq~"¼‡I f5Öëjö:çc w²ås„|¥<œÞûA”§oh ~2¦5™÷œ‰ò̘ktºA@Çç÷ÛÁÆ gèøÕ¿í§)} Ly¾7Òö}"ý Ç]œŸp Ïu("çÝœ_p Åþ‚÷…èQ¢W‰ JìRb§»•ø¡Ä/%~*ñ[ Jx±ãÍç"Ç gs>*¼‡I fEêõH{=ŠónÎ/8ŽbÁûbZ[ýüIOyéŒo¾Ayfš>ßšõà4 *ANV£~:>ÖñyB·2 ×óÈéßëû‹qæó㎯9åz
×ïˆ\¯à¼ŒãOö³|ž7Ñ«Ä%v)±S‰ÝJüPâ—?•ø„%¼Ø÷ ûŽ»8?á<^x“8Ìj¢×›íõ<®[p~Æq(û[>WÈ_FÇ·t ¦¿ò¬azŸ,û– Ÿ ǽÙu.@ùÞ?tœn‰ö™Õ÷£<}Î9Û÷ ûŽ»8?á<žë]\Ÿ%r=ŠónÎ/8ŽbaßZ¯;”Ø¥ÄN%v+ñC‰_JüTâ· ìøò9ÈñÇÕœrFx“8Ìjª×ííuZ®GqÞÍùÇQì/x_dÞ)ÒYïè}äìhírN×û“9Ï4o9wÿŽzÙŸ·ÒñøKϯ3·êsãŒ+Ÿ 'p<Íy'×g¸ŽÉun"×õ¸~ÁyÇ£ìwù|!b‡»”Ø©Än%~(ñK‰ŸJüVƒ}Ÿ°?ḋóÎã¹Þ%¼‡I f5Óû0öº7×÷¸ŽÁùÇ¥ìùœ!ŸÙwêz9·^¨ãðµ~ (·Únþ# <çô݃™¿ ñÐ=˜± ¿×é¡K0Ýôù=tN?GŸ¿óÐ ˜Öõô݃©ËóB ºyßxèäóÌCW ûÝìÿ=t r\æ¡+ãeÝœÇxè¼âUÓC÷ çý º¹ ã¡Këd º¹~é¡;ëÊ º¹Þï¡+p{ß³=trÌC— ÷-=tr?ÙCwà–Cuâ=t>u‡.Bž‹ñÐ ÈóJ ºyŽÌCW Ï÷yèä¹KÝëóÏ÷ÐE¸®E®é¡{pìÛzèä¹~Ý|ßÂCw ߃ñÐ ¸|{‡.ÂeûÆ{è \*ëŠ ºùž¥‡î@¾ÿê¡;ð+™§{èüòŠ×Èù²øSÂg~-¾Ãü÷Oýrú_£óû]¶òû ShßkxgÄ«Ç
? ~÷—×ë¸]±ÖWÿ —=ýP?:lÊ鯫ÆtÆVyþvœ¾Tó ›^ºÍoüðËíÈïÙb$âÕ;9
é¾Qå‘î—þ°û 5ÎL.’f9ë³=åQ>õQ?í¡}´×²_‰?>§ô—þ“òC¾È ùìwÙª"|÷Oýr‡»ñš[õ‡üyéÁûs Ô3ò¬JEû¾³>Cºç 5 çƒv÷¡~ç~ ‘ŽK?íäºQÖ} ´GYökþoé†ü.»®Õ¼ øLó5äwä÷ÿ¢&ê
üø7´üøb䉟 ¾†FÖBùЃúú vyû"i–‰O,p¶§<ʧ>K¸Ó ÚG{Å~û> –¿ñNÿ->”“ òEþÈ'ù%ßäÌ =gêZõ pä;uÀëðìʈ×ОWžÁåÒµžÛj£}¯7!Ýgê‰ &Ÿ?Öó~ò:‹¿èðùáö^à©oíiš÷Ä'‘?䥋Ã&wŽHš ußàgtƒ>À1•w"Ì“¯*gšå¬Ïö”Gù–¾§~ÚÑõboØïôÇö¯[Ï+
œþ“òC¾È ù$¿äÛâ r®¼òükîB;ÿÓo¡|Ü«Q>æónˆÓ¨«¿ƒ¼áç½ôà¤ÓP¯ÿœ²¨÷Qn;”[× äÈóSI¦ä>Vb¿êýåZÄgàBœñPC›v×¼¥Þz£»Ý »»?Ú_zÒþQÝÑ.¡â
¨ŸpS¨’´ßYnÕq¶§<Ê·ôùúií³ì
wØo÷¼è¯å¿ÏɇÅÏÉ—ÅŸròI~É7ùOª–‚ô„Àch7áÂ
H'†H|Ö7@þ¸ 5¡ôY?¼B5È4æM”[~@ÜߦÕïÁ k äó—×Ý€§Ú‡!ë2ÀçÈ Fþ˜¯‚?ÿ ŃÄäÕàoBÛEÈŸðýÀ¤ËÃüÎ4ËYŸí)ò-}¦S?í¡}´Wì·ü™âsúGé?ù ?ä‹ü‘O‹ßxá;ÄÉÿÄC¢|â€~H'/y ˜”[K·{ì>`B—[t\w_}£žÛyC » zx]ðy)ã(eëà—ôgJîc%ö«á+ÇL ôwë
>£¢^ÒióÁSòóúy>1t øøÕ\ž_4-å¬Ïö”gÉ7ú¨ŸöÐ>Ú+öÛã"úgùâôŸ| òEþÈ'ù%ßä?5÷v´K}ú2ÈI‰› ù“îí§Û
_¬å{ù µk£þØwÎA}Ëä[÷7äJ¿krÛûò(Ÿú¨ŸöÐ>ËÞ‡ýöü€ã"úKÿÉù!_ä|’_òMþ§íKÒØ|"ò§6[9Sö¾¢ÛÿÒEÇsD”'¨rË”ËýmJ¿gÊxÐä<‰óVŽ×9.âó™×å„Ú—j¾jŽ×ü¾¦ø.Gû´oEzê¯Q>í“Å3ío}Î4Ëú!ÒÞtÊ£|ê£~ÚCûh¯ØoÊ<ÓöOƶÿW‹Ÿ:>áËïä|ZüšN¾ÉzÚÝH§7¹qžž{/äL»¤ rÓ|¡<µu”Ol‡q… wëyä8Šãg™W*kžÿe~£d\§¤?Sr +‰¯Jñ™¨?ù =®œZÝ@ù´_0ÎVé7VG~úÀͳõ¼ÍNK9ë³=åQ>õQ?í¡}´—ëœ'Ó?úKÿɇÅO¼ðâäÏ⳿ä›üg,î‹tFw= HÿöJ燧zSj|?Lëþ† é÷Lk<ˆ´Ì“L® p=ÇšÇÂ/Žßq Ïkë:EyjrÒic–¡ÝôKM¤Ó{ÿ€tÆcï ‘ qÍ·EÓRÎúVû§¼ÔdS õÓ ÚG{-ûýlÿdükʸÂæƒü¯©º¿²ù$¿Ý1ž´ùÏÜrƒÆA_èü õzJFåÆÀé3ôzTÚ’*áÎ8óùÇqÇËœG¾wnÝ`}%ë]JæùÊšßÛ)k\‡´ÕŸÁo¹•Ø¯¦½ü8xK÷3ͯ ‚zTæsº Íœ[í2÷]R$-å¬Ïö”gÉ/}ñNý´‡öÑ^®×‰?¶ô—þ“û>XRE9ù³ø wòK¾ÉÖ¦ ¨—ÕGs3w$évßv„Üôô-@ñôîo”K¿gÊxдæIÐ/ë&×Õ·¸|ôl1q6¹+xàxžã>¿íû`ï7šÏúÏkÞÛÎE~Ö£ “e~€vY{ÞŠ/’–rÖ·Ú8åQ>õ%%ï)bçÝ´WÖiéí ý¥ÿäƒü/‹¿'Ÿä7«Oý'ÿÙó?A<²[¿vYsÏA:ó³iº}›h‰ë¤ù¼³Æˆ¯5>FšóF®§¼8~D¾ ¿{
ï ÿdž¯d~£d\§¤?Sr +‰¿Ê¼v¤æ÷ùÓ 'ûڑΞ´åÙ˦›EÒ×¾â¬oµyZ~ŧ>ê§=–}!boˆÃ~{Ý”þÑ_úÏq‘Åß缄?òiñîäÛâ éœÑYH稨—Ý' r²º^§ã§ý0åþ6¥ß3eçwÍó·‹ÀoNG\*gÒ…!Î4ËYŸí)ò©úi×£h¯Ø ôG9ý£¿ôŸ| ò%×QÏ"ü’oòŸ[ïÎÿ<Úç3tý[.Ñqœ®ã*Ï7öû [óDà¸W£œëŠ²¡šü”eÝWÉz—’y¾št¯^ÿ‘qJ?ÿ-äË}¬Ä~•m.C½œ”š¨—{w
ÊsÍw¦YÎúlOyÒ_õ)§~ÚCûh¯Øoï Ð?Ëßx§ÿäƒü°å}@>s ¬³Û|“ÿÜ?Ò4Ž© sÖGèvæR Üߦô{¦ŒMkž„vÉÏÿŽv²gÊú´É}˜¦þ3ÁKߨòHs 41y5Òœ÷r~ÀqŸï¼®s^[òÜ'j\ Ž8Ï8ýË"i–[õÃí)ò9¿ ~ÚCûh¯ØOlÿè/ý—y£Íù"r]Øü’o‹”Ïèù äϸîÔËmXÙïsÜì/¬~ ùÓsïA>ç…ÉKtÄuD®¯Ë¾“’}@%ûKJÖ}•¬'*™ç+™ß(×)éÏ”ÜÇJìW¹‹oÖü7®Šv3†&˜Î4ËYŸí)ò©úií£½ÜÇä>ý£¿ôßâCøÑóòEþȧÅo¼“o‹V@\fŒ¨rË Üߦô‹¦ŒMkž¹²~`N ƒö²ÞlÊ>ŒÉýÉf“ºÂOî“q`BÛEHs=ÈšÛÛãŽ{ø¼çu>C5CþŒU8«ò*Mö9Ó,g}¶§<Êç¼›ú¹NKû,{C öÓ Û?ú+ëŠ6 ä‡|‘?òI~É7ùÏ«7D§¿ésÆÉz~!~V¿Ž¸r¼Ëy ×G¸nÈõtî3Éþ«Š*?ñ}@%û JÖÙUêÓ—!_æùJæ7JÆu*GmB=¹•Ø¯òî¸ÆlܬÀ™f9ë³=åQ>õÉz›’uhÛ>Ú+öÛûÉ–Êé¯å¿éäƒü/òG>íû@ø&ÿy#z øaZ÷7ÒÒï™2 4eždÊú)ëj¦¬7›²/cÊþ¤ÙõÀZøÃsýÛãhö¾÷ ¸NÊõ!΋9 à8Èzþ£½} ´ÎÐü'wÖØ:Ó'å~Ÿ£¿`{Ê£üiŸ|SàÔO{hŸeo¸Ã~SÎ!ØþÑ_úO>Èù"äSžŸ6ß6ÿý\±ï é/Øs~Áy ×CÒÂë¡|â¡?µ]WÞ½ÜoíVù ŽCŒ Ê~¸’}X•TModÝWÉz—’y¾ÊÚ„ÃaÊ×i^õxBÉ}¬,û!'ï«IñÎ4ËYŸíe¾d˧>ê§=´öŠýö¹
úÇ}4î pÝ”ü/ÎÈ'ùµïƒ€~®Y~è¸èûÛ”~Ï”ñ )ó$3sße:ÙXÏ7ÓbžÊ>Œ)û“¦ìÛ›<Ïõî. 9W1æÉWáÒåa:²ÀuS®qžÌùÇEììû`ÍÇþ"iöRŸí)ò-}!Ný´‡öÑ^±Ÿþý+púKÿeýÝæ‡|‘?òI~É·\G…ñ¨7$Üçè¿ ÷C¸3¾Žûí ï}}”â~@ú Ü: ú~vÞÊWüýï”Wúûç‰Js?ᣄû!ÞWÒýPØ? }1ýô•¢€ŽþAûQØ?€ Gÿ <þAÇAžÿG÷:ý7úåû{ýƒßéÚ]=
œü8ú‡'Ÿä—|ÛüÛã¥GPß1^Òq( /!]Šñ’¶»p¼ñüuŒ—æxÅ¿ ^ ã%ÔwŒ— Ç1^2å¬/ëŽñÒŸè3úO`¼âô÷ÆK¦“_òmó_8 þù°˜ùü.aþ€|Çüùÿáü!Ü©¿˜ùƒrØOJ3qòUÂü!\øG;ëy¥œq:þ|ZÏ óiä >ó„Îù4ÊOá|ºÀ©ŸöΧµ½¥˜Oû|”b>íwòMþ¹¾!÷±c}I¯‡œÀúRì<öúü/f})(·4ëKá>_±ëK!’Žw–—b}I9õ³¾äsØ ôG9ýûëK¦“o›ÿc¯·¢½QúõV” ½ó
%çI‚ëŸÈçzèÑëXw,n½µHºp½U×?z½õ"ú¨ß±Þï´×±ÞêÿBœþ–°Þ®ùÓëÕ…ëšß#×[ ÷ 6éúGï? ÿoì?h?ŽÞ Ï%ì? íØ@úèýì³8ö tº„ýÊqêsì?„kû’ œöžÀþƒ)üø|9ö L'¿ä›üs|{ô~œì;Øûq²O-ûMÅìÇÁ^Ç~ üsìÇÁÿáÙz ãئþÒ(çJÚƒœ¿± g:åS_1ûqÊi¯e¸ÃŸ’öãÂü ½ §ù$¿GîÇîOëýÒbö§‘?íåÇQ_Ο”´?ôßØŸFy1ûÓ¨ÿ/îOûEŸÒú»?ÄŸ§%ìO‡_ñNþŽ·?í8¯z%œ×@½ÔÖM.Åy
ðPÂy
”ËùÃâÎk€‡Rœ×PEÒÇ?¯a:õQ?í)ἆrúç8¯âäƒüs^#ÞÉï‘ç5Ž}~ ý™)ûêÅ_òüÏóœÀù%øï8¿„zÅœ_B½cŸ_:TP$}ÜóK Ôçwê§=C^º¨Àio)Î/™N>Ž>¿¤ù;úü’æ›üÿó|ˆ§ã< ÊOÂy> ô{ç<_¸´7E^ˆSþ œçSœçù|Úÿ‹|N>J8Ïîä÷Èó|Óö%¡Üq¾(ã:Sú3û¼¦ã|+Ê ç[¡¿÷=žþç[¼N ç[‘ÿ7η²}S åS_1ç[Cœö¾5¿…OûSÚóš ž&%œoE»bÎ{ƒïbÎ{Cþ„êøÆ…ó¼7ÊKqÞ|sÞéÎ{ƒ7™7wÞ;Ü™vœ÷ö;ÛŸÄóÞñN>Èωž÷v¼ÿ þŠyÿéÞ€^¾PÂûàé¼ÿ œò,ù!N}Ô_Âû!Ly¯ÑùþCˆ“c¿ÿ çŽ÷ Âüsýœë†Ž÷´¼£ßBú$¼¤ù‘÷uþ…÷Âí ïùEŸrê?þû@Ë‹øG‹y ¨_Ž÷Èo¼ðíwò/û öûZ%¼ ‡üÞC|ÿÁûq(·Æ-àÇñ~ Òż Þ ïÇùœåŽ÷ãŠÈ£|¾WÂûqNûMyÏ=è_¸ø«œþó~œßÉŸãý8¿“oò_Âû¢ÐWø¾è·š'8ÞE¹ã}QÄû ¼/
¾Jñ¾(xK¸)4Ä™v¼/Z¤ýI|_4ÄÉGáû¢š/òG>õ¾è ¼?üc¿?}ðøïOë÷“ÿÅ÷§ÃéxÚ'úýN{ ïO›ûÿÎûÓ¦ðâ䳘÷§Qîøž ø òçaÔw|O q+æ{°Ëñ=à¿ð=ð ë%}O r ßð;ËYßñ=Ó)ßñ=å´§˜ï Ä;üq~OÀïôÿo|OÀ'üCŽãû(ç÷ ú ShWÂ÷5Pï_ø¾ê9¾¯>‹ù¾ê9¾¯yýg&‡8ÓŽïk„8Û—ð}§=Žïk(‡ýÎïkñ÷¾¯¢ùÕß/)ü¾†æßñ½ä;¾7ä:£ã{3¨ÿïoFÏû ß›Ašëç¥øÞŒé,w|oF‰Úù￨ûÿø}87gvÙƒëÎì:&én¾HÔïv^{¤»®~|v}ö`—6ú{:ñuôyÏ÷Ö E~§þ‘ßnÅN`l¾~®FOš9ÞlŽü: µSÎ8HZI¹’úJÚ+‘§,ùàIô)K?Ú‹=JìS–½H[ö‡µ?JüSâ¯ÿ•ÅPøQ—²øCZøT¿/|+òÿâ£
Àk³šëÀcÜáŠà÷ zÝªË 5ÀÏ_Fú£÷ôý׫ÂψWŸ+õ9¨¾óV£^¿A^ÿ¡ú»ýs; ^ÿÚ ¡]¿æ{!§o¹8¤{_Uõz|Ý r><ó_³ëoa¨÷þÕkn¿¸6Ê[]¤÷½Â Äz™ I+« |XõÁŸ´W–< % ù¢O‰~eÙÞ,ûoÙ‹tÿÜŽ/þ(Ë?´•ø¯„%ü(áK JøT¿¨/|+ò_7m&økµ[¿/ôÎæáo·;²ýàç*}n§ÏT=O ðÖ"ÔtÍ]ÀÁcê!È }þ`è€÷ÑnXùçÀ×°KõºÊÐú½Ó¡w·Ðõ X9{îGùÀg.‚=ýæõöj; õºç༩?² õÚµ~é&~ìCÛq´’r%õ•Õ þ‹<%ò•èS¢_Yö -ûÀ¿Ø«Ä~eùƒú⟕ø¯„%ü(‹/èþ”ð©„_%|+òÿú_z_»_ï³vYúüíÑK÷ãýÖå!ƒ^‰DùƒÁïð;u¿5²¾áhŽê¥Ÿs£-F»1×mEù˜Çüà{ôÞžH®~ê\Ÿ
y#j|¤ãuÙL´ œ¦×ÍìÁ{ÎfïÙûÝq,Ôz.fÞŒ>pØtÆÁJÃÏw3kÀo«>ø´ÚƒO‘§D¾}Jô+±G‰}JìUb¿”å PüUâ¿>”ÅŽ‹æK JøT¿'|+ò 1"1ØÎìdü ^º'N }¿|
ùƒf6ÃÎ
›#£v£|Ì
g£|\ÌZðâ¿t
êùó«"pþðŸp½îÇýßî‚>üöŸ9¾ñS¨?¶A$â3jÕ%¨7|ó À!=:A΀Õ)Ósî™h×¥y`ëþáÎ8HZI¹’úJÚ+‘§D¾}ÊÒ~Ä %ö)Ë^ Ø¯Ä %þ)ñW‰ÿJøP?@‹/Èþ”ð©„_%|+òßx|"üí<÷ðÔ³Að2°í½ðè÷ÃïQçWEùØ÷#þøó‘NX‰u3qs]¤'ŒÕç
“*¶F~Ò¥#€Ö?€vžzü'FÆêxÝ};ÒãÛâÜ»9úO½6¢*ö1ÍÁŸúýîÔó£¢ôýÓfÈG¬þpÈð$åʪ l§¤½²äK>Ò¢O‰~%ö(±O‰½JìWâÿ”ø«Äeñy¾”ð§„O%ü*á[‘ÿ¦‚‡.ƒ!ÝçWSûÿÝð7òüJð{ì"=M(¯Ïã$®¯ùŽÈE:yÐÏÀ‰Qx Äœ¸Y?—&þv¶Ngèõ‘‰•Véú"R†éxüªßÿdzÀÑ﯇þaý—!>ö›Íêè}âö ô2q´’r%õ•´W"OYò‘/ú”èWb²ì_–½¨'ö+ñG‰JüUâ¿>”ð£„/eñ½Â§²ø…^á[‘ÿæQ2ÎÌzþ
Õû à BzÌeÍQîÏÒó… çêó³ÉW&kÞWés)·nG¼R/Ç935ùQð™jÖ×é˜;!'%+8©ÿƒh7ñt½_’tÍ ä'ìÃz›9nÉÏH|JŸ \÷e¤{]£Ç`ŸÊŽC§º?•reÕ/Ò^‰<%ò•èS¢_Yö ^bŸ{•Ø¯,4jÿ”ø«,ÿÑNøP¾”ð§„O%ü*‹o”“ÿ×Ý?»êo÷êçÒˆ´YÈ _ñ~ð’ØR¯W%WÎÖ<Ö~ü¥Þ£ß+ž<½1ò§ä}‰öiÏ¥"ö¶Þ×K;çOäO©Ùr'ûžÔqyq%äN|H¯“M˜ ìH(³ rGï’÷*꽎8÷Y“ƒô{¬ qÆÁJ¥\I}%í•ÈS–|ð ú”èWbû”e/Ú‰ýJüQ⟕ø¯,>~”ð¥„?5"MŸ/~•ðÈÌ\=?þ(CGÔþŽÚú øóïÌD:é‚ðâ!= Om œÒQ[§ž§ÇIÓîÕýé´ÕOjüeƒÆá@ÎÔ ýÝš´Wä|îû_ï” €œä~ß {̃¼qQúû8à ùõû·Òû^ïgõ wÆAÒJÊ•ÔWã¢ôû"O‰|eé¢_‰=JìS–½#ö+ñG‰Êò(þ«Ôæzœ ü(áKYü¡\øT¯¾ùo ¢Ï
öì£Ï ²üŽùk“æãA= HN9„ü”ü—5ÿM?SÇã=Pszð(ú•Ø£Ä>%ö*Ë~´KOÐë"–È·üŠÿJøP?@áK JøT¯¾ù}v6üëýìø;,þø?îwý\žÐ)8éýÞèä–g¡|ê“ú¹4}R”æÙü•Å/âbñ ä_‘ÿ¸Èo‚ùfŸƒßákÒÀÿíþÈOJ~õRzÜŠü´r¿§ŸQõÓçÍ×üÎ9qÍŒMѸâcägî ö™ÓÊëü«·3žë9é·5N Öq˜\g Òý¨—8H??Ç4ÕãâÁwîC »5À9;VþK¹’úJÚ+‘§D¾}Jô+±G‰}JìUb¿”ø§,¡Çò_Ç㌲È~TJWøS§¾f*Ò·"ÿmš·ƒ¿ýÚh>G^¢Ï[&¨—µTŸOÏک㕪ßÿʺP?¿2ïÕqÉ8m%äL¿æjÄaJN&옴t>ÚMèý1pìö2¨?äî¨÷Á[ ‡;ã`¥Á‹U´ê¥½yJä+ѧD¿{”اÄ^%ö+ñGe5ïã•žŠ´ø¯,>Pßâò,¾€È·ø„^áW ߊü·}M¿ßÒÍPø7J=žÏÅ{gæÄÃÀó ¾ŸfN[¡Çõçí ï™íõ~TVïqh—ý|YŸèïyd/þNcÿz“õóK:.g¾ŽüŒoêë¸>Ù åi¿ÕF~
^³´îÇVz|6þQô«æÐ+õ}ÒýùfÊI+)WV}¤¥½²äw‘¯ÒŸ”s²Z¿{TÖÏ/‚W±W‰ýÊòÇÔþ)ñW‰ÿJøP?Ð#|)áO ŸJøU·"ÿíî¬ÿôk ý´^ÏLüRÏ—&×çÂÓÎÅ{Ofúi-4sžÖ|ÞÌ®]<æ\¦Ûåôí¨ÓICnN¸Þ§ÊžÏ%f}•†z™ \žÓ÷ëógÓBôõ‘ºcÚ'«¨çWº?ú ÎIš ^75ÜI+)WR_I{%ò”%_ÇAëS¢_‰=JìSb¯û•ø£Ä?%þ*ñ_ JøQ—þ”ð©„_%|+òßîûàgàåúüñ˜ûõþ„2žl‘ü©õs9}°~ÿ7óuý¾EÖš|ð–S®’æyY3ˆ¹O=„ö¹áŸC^î%†.o§ûçìŽ×£]Öµ1:®]BÓ¯Ûz“ç7Ayò¯x/Èô/Òýø°] ÿÃxß¿0;õ>µU”úJÚ+‘§D¾}Jô+±Gå´[Œr±W‰ýJüQ⟕ø¯,>/ü(áK Êâ(ü*á[‘ÿöcÁ¿cô:ÄØÓ»‚‡ ž¾R¯Ôãù©ë"?ã,½_–¹!ÚeG_¨ù û½æ»>·“»¿äϨ€qž™;ënÔË=_ïûäT½XÇ!sêg–}õÒ+>}Sún N Ÿc OÍB<†¿©Ï¿}4à¿3VþI¹’úJÚ+K x´äEŸýJìQ–}šm¯û•ø£Ä?%þ*ñ_ JøQ—þ”ð©„_eñ
yä¿Ã/¿A§ëùÙØ™§¤öúœê'À×´Á ¡^FÛQžUO¾³¸ëGÍûU!:aþcÎèø‰ŽÃ 4>¦Ëṵ̈̀UÇñæJ:®¢NoV é´{ëAÿ¤kõx !+VÇa¿ oõ⌃•J¹’úJÚ+K üùJô)Ñ¯Ä %ö)Ë^Èû•åòÅ?%þ*ñ_ JøQ—þ”ð©,~·"ÿ ’ôï
Šx|Ž{V÷2iÝ÷àeòƒÕàÿôf,ŒF~Ö ýû9/èóO¹ý+ ÝŒ=Ïž±ÿAäçUŒ×q™¹@çŸùôäüö§Žc?œ'23ê}ðô¼Ãà=m6ÞK7'
Çû%fâ= D£qÀ ß/‡áÏ¥\I}%í•ÈS"_‰>%ú•Ø£fœY[£¶W‰ýJüQ⟕ø¯„%ü(áKYüA¾ð©Æ=ûÒß('ÿ Ë<
MÌ@zܧú¼eòM™:cõ{ÀÓÇF½Ì*xoÌÌ.óžæÓÿ4êån»Móý…ÞÇÌ{BÏò"ôùÁ¼óô9Ð
_D:÷¹ŸQ/{ ֧ͬs«ÓÑ÷ÕÔ[3`ǤCï ø|ìÐ㈠?\í/‡ ®R®¤¾’öJä)‘¯DŸ²ôûÁ«¶GYöÅ^%ö+ñG‰JüU⿲ø€|‹ è¾”ð§„O%ü*á[‘ÿŽ•ƒƒV·Ž¯ŠïI™ÉnÏ“·] Þ¦¯¯ß̇å»÷nBûœ5º¿žq壚÷Óôûíy=êétâ#h—÷² ×Îðç }nOÍoNµî¨—õØOПqÌëÞÑï+¥Üþ:0ñ}9ïYæÈëyïÇ!Î8Xi ”+©¯¤½y*ãÚf(·ô!^¢_‰=ʲí,{Q.ö+ñG‰JüU–ÿ:žš%ü(áK JøT¯¾ùï}=üôSð2¾æYÀäî8çiN©² õÒ«á}3³Á\ ‡ºzý4ç}žgFršï[ßÑ8]?÷òè÷¹óÞ©¥ã5¹Sõù—œ{Ê ^V£Á›¡’u &7¦ÔÕïs$ŽÙŒz#ol‡¸õ|ç
ã ÓJÊ•ÔWV{ø?u²Þ_ùJô)Ñ¯Ä %ö)±WYö£\üQ⟕ø¯„%ü(‹/ ð§„O%ü*á[‘ÿŽr¾h°OïËŒ—sÉÞ‡ßSª_ ¿Óeß3SöѲ#亖ýƒzÝ×Ì“uÓ×qìþAŸÃ8vÿ ×õDŸýÅõš÷£û”‹¿Jüwö(/¡@;á»°øûã%Ô³Æ hg PÏOèx<ÑOó qÚ9ÆKH;ÆKˆc ã%”[ã èµÆC_Âx ~J}%íOd¼„´c¼¤ã¡ýQ⟕øï /Ao ã%ÄcÐÄt ù?zþ€ñmIóÔwÌ ÀS1óä[ão`áüãóâæ_Šùê—0€%Ì À‡è+aþ ׳Åþ’æã˜? ß1 3 ’ÿŖQþ7æÓÿýù4Ò%̧ƒåÿd> ¾µ½Îù4°óièu̧Gϧõ÷òÈ¿c} | {}é ÒÇ__Òß8õ%ð›Yö c} õþÅõ%ÄCä+ѧDÿ ¬/Á¿âÖ— ·p} |•z}©˜õV¤e}ð﬷jÞ ×[uúﯷ¢¾c½(ë«v JXo…ÿ¥_oÕû£ŽõVÍáz+ÒŬ·"ÿèõÖ,Ès¬·¢Þ‘ëÅì?€ãï?ès‘…ûú xáþƒ>™“$ó„Þø åÉê6 {ÿá
ä {ÿåÅì?@žù'²ÿ€|ñ§„ý}.³ûÈ?rÿáøûqšGÇ~ êeœ·Ã'¼ ÷¢Æ£öãô¼£„ý8ÔsìljC)öãP¯ôûqú÷³ ûq½ ”ýÊ’öãüA¯ó¥9¯¡ã¡Ï+8Ïkhž>¯ 3¯Þ†òŒçðý°bÎkà}µày
Ôwœ×€<Çy
Ó‡bÎk í8¯üRœ× ¿boqç54ÿÚßҜ׀žÂó8<¯úäÿ?8¿¤qüë{~I¯G }~I¯÷•þü’^ßûç—tÚ>¿¤o¨˜óKç—P~äù¥pžåŽó|¨WÌy>GŸçC:mÐf¤å|ó< Úù#ñ ™¿qžõKsž|ˆ=Îó|:>öy>Ý^ü+é< äsžåÇ:Ïç8ß
ÿŠ9ß
¾“.h€z…ç[±Žå<ߊrÇùV”OûE¿Ï çEƒç[i¯èqÓä÷ñ]PçùVÈ/æ|+ÊOà|+â"íç[Q_ô)Ñ¯Ä %ö)9«ÄþRœoÕólÇùV”s¾é#Ï·:Î{#]xÞ[?¶„óÞÀÎ{#žioë÷ã
Ï{·€œÉ>ý]GÇyo¤KqÞrJ8ï
K8ï´è+æ¼7ìSboIç½ÑÞò zÿéyïÿðý”Ÿ¼÷ 4_V9ø9öû½‘.áýÄOìu¾ÿ ÞŠyÿzKñþÒŽ÷ PŸüŸ„÷4¾9G¿¤÷Û&¤ ƒœSø>ø{”اÄ^%ö;ßBù ¼„x9ÞBþ‘ï9ÞƒŸ=ô ïÛÞ †~¯¿O6ê|½¾úÞÓøԛൄ÷ã §ïÇ…8ãPÌûqàÑñ~ Ðñ~œŽÇÝwh ÿ½÷ã.æý8ä ¿Jø¶ß+æ}Qøíx_ùŽ÷E‘ÿ7ÞE{Çû¢@y_3ø¾(ø ¾ùà‰¿/ªûIÇû¢àÁj|Çû¢àAô)y_U‰=¥y_Tãß_úŽ|_ôo¼?vG¿?½XŠ÷§Ñ¾ôïO €Üîê~Åñþt¼3ÿâûÓhWÂûÓÐóÞŸFý#ߟ.á{È/Å÷À³ã{à[Þ¿/î{H~O@÷¤„ï .Å|OÀ¤ÿÆ÷ôwM ßÐXø=ÄÁñ=Íwá÷P^Ì÷PÞãªë>Þ÷Šù¾ü§Ç@à?ø¾† Xø}
Ô“ïW÷}
ÄåÃs磼˜ïk -ßÏ~_£H þÆ÷5ÀŸãûsô÷5`¿”ø÷w¾¯zÇú¾F1ß›Ÿ%|oFóSø½`1ß›AZ¾×bÊ÷[‚ß›A\ŠùÞ Òò=˜Ò|o&܇b¾7 ¬öÈ/á{3àÛñ½ðYÌ÷f Çñ½´s|oõ„ ç÷f>Þ÷f¼ï/¹âûK*ok å¡ p~ßÌÃSC/-ðÐXKgÓÃS‹36éßñðã›ú;( žZÌýü~Ý€Õp ÄÃSŒ9Ïèó€ žZÌŽnãóðÔcV}ÞÙÃS‹™1×(O=fÔÖ¿Çâá©Åôkêy蜺 Óïá©Ç)7ësú žZLi…ßòðcòhýÞ˜‡§Óõïçyxjq|#ý pO-Ž|¬\ˆ‡§ ŸÑ¬ÀÃS=;ö5=<õØñÃß•‡§ ½îøgZññðÔcO9÷èá©Eé¯=<Åh_} žz´æsá žz”õ
O1&ÖßýòðÔ¢¬{xŠQöƒ<<Å(û£ žb”ó žb̨½6ÞÃS™1ׄxxêQÎWzxŠQÎ{xŠQÎß{xŠ1·Ú Ÿ‡.@ý~–‡§g¼9°ÀC ~×ÃSŒyµþ
ñÐ8ô2Ÿ‡.@ý½O5êïÿxxjÑç+_Öç+{Øúã,ë?ëïJÁïo–ÓùåƒùÕt¾ï/뿪(+ï þ&K™ü£#ÿ褫•âóU6àÄëB¬Œü]ªh<7¢ ˆ|¼òûÍîŒtŸ§ð©ùüž
0„Ëÿ°ìAÓò»>ûZ|ß ü.°Í×£¼IüT^~ÍKÎÊ mP ?ÝóöÙÁüÐIHÇ×I Ê ýàŽ%Aý¡ }rYPNh¯‚IA9¡}‡Þ‹zýE£Þ€À¯H¬½\ã˜
f”|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^ɳͻŽC ½ÉÎàc-ƒþ¦rÒÓš Ä´¡ø´|`òÓøIûÀ¤‚zIqßõÊà' £ú
ê š¼í>øöÈ _:&Xßèx×9À¾wΖÃRðÓ
ƸWñ“Fâ\|úИxÖ:`Êo‚í)/E½©ýnBzú•ø©'#ýâŽh—þæEQòYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%Ïäq0ß|õ̇
€É ÿÓWÏC:ÿë!wfè3ˆßŒnfGݽé¿à“xÉñø‰¸@b‚õ‡ì¸ØjÁgð¯çµ¸NŒ±W7Azâ˜lð0íÉø9Ÿæ5rË>¾òöã'ÍŒOb’Q>«óø #pÎXÈ1Ï)ƒzæ+øɆB”|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3yg æ·Ç§Qó k‹ôSð)ÍÀ¼i#ÿó—V!ýÙèŸÐ~öàÔû´ë!ÈÿøMü´d ë›Ó‘?e5>% ö1°ãEýà÷ …¸žŒä/ÂÏô “âÁKâ ðöÉáW5¿q÷¿9 c€s»¤ƒŸyg@½/îÇOEóË¿…ôü·ËûŠ ä³ ÛQåRõÒÚE;ÅnúaûE?é7y /䉼‘GòJžÉ;ã°ø¡è[|ñl¤¿iºå__„Ÿx|õt
à—®+€œÚŸBß܇uÜÍå&äÎ|r/Ò™ W£~ÒÌû‘ŽŸˆOI#ý>ÒvÜ€tn‹[á÷§•Ê"=gðÓàãóeø$²1??
g,¼G±E*ñüzñKóÍÆNÈ_|¦`62ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’WòLÞ‡å7á§
Ë}¸N˺lA½¥ÑÀ%ƒêú7¾ ù_ýú4ê/¸v)ÊçîÂ'ÿfÁÈÏý~òSŸÃŽ¦ãykŒû ?…bd|ÿ(ÒŸ¬¿ |Í™´|}Qí-”/¬¾ü|û$ê-Þ± <.½¹ ê/»:<.[¨ŸûËCBŠ óYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqXïïÀª%øi…Àª‡ž®|ôtÈY¾ÿÝÞÀO`–(üU`ÑwÛ!gþŽÞÈÿ¬õóÉ+øtw`Úä0Ô둈Ÿ¬4ãÎÊ1rÂ"mÛ æ݇ŸÔ3¾s‹æÿZý|[úÔ$¿æy3øY1¡3Ú¯\x Ú¯„ç…±êçYEPòYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqX7×Dýu½!íúšH¯™u¿®w>9 XùHeèYöÝ@ ï Bú«/
è÷î÷@`To`ÆÌßç‹à_òˇy3°`|vÛƒðwA:~º×øfÞ9àséü”€±â|òÝXõø ”¯)ÿpmý‘àoÝ#)¨¿.÷Ú"(ù¬Çv”C¹ÔC½´ƒvÑN±›~Ø~ÑOúM È y"o䑼’gòÎ8l’çئkwAïÆð_ wÃe¯ ×½ŸH ¬¹ùY´[Ù¿=ä.ò5ò?±¸ z
pö&üw »òTà€K1¾3RB0¾0>ùáNøÿyFü_tVOð¶äçÏÁçŠêWíþ ¸¶ö
¨·þ™\´Ûð5~‚ÅظløÚT?©`#óYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqØܶ‚Æ_F ¶à'6·EévooÑò~?åkΛ€üs¿@»¥7GùW~‹ø~¶Ÿpä>}&ÒwêñÊä¥U—@µÑÀùÕç!ñu·#NË~ ¥ùêXéµCñ„Ɔš5ïmv€·‚¯·ÍWéyÍæ·WAÉg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“wÆa«î÷[~בּ[G]oV¢n7óÌÀÆ©Í wÝûÑ»jÃZ”/[õ#Ò_ÿù ðóùºSžÖ?APŽ±øõðwÅnüô´±îÒ3¿i 'm©4
¸um{àöz_¡|Ç;Q¨¿S}ˆö;'`|Yˆ’ÏzlG9”K=ÔK;hí»é‡íý¤ßä¼'òF É+y&ïŒÃn= ìZ|ôìºë ŸÛ§AÞö¯†Cþ¶ÊøÄK`ó/ëPÓ£!Í¡7 où#ç£ü«ŽÚŽÀ·# gd*~úØȺ¿R°¾1ï1½Ž±ä‰Ÿ¿êšíÀõ~ ¯‚%û‘ÞZy3pÛϳ5¿½:£|ç§zþ½«ß¤pàÏ£üEPòYí(‡r©‡zií¢b7ý°ý¢Ÿô›<òDÞÈ#y%ÏäqØóð”ï9M?Çv7Âü4°«ÎbäïØXú·Ÿ>ù[Ö¾ƒzo\…öëî-ƒü~2&°hãB¤ÍÙ/ ý¨½w€—ì_„_¼^/h·±4d7ø[ýD üßxÚÄksòÀœúÛÿúSÇ!¹£æ{× ð½{Î÷³çŽ3M'2ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’WòLÞ‡½2.Þ{µ®·§ƒ ì~CëÙ¹jâ½ýÀM·5?Ø|¶ 9ëßÂOPV^¯Ÿ“ß\³ífw¸ é1甇¿9ôüj~ƒ—µß;ðÓÀÆšÛ#Ó Ÿ€¯-‘°Ïض?eiì8ˆëÏØ5i¨ŽÃ/±àkÏzý¼Ùû<~bËFæ³ ÛQåRõÒÚE;ÅnúaûE?é7y /䉼‘GòJžÉ;ã°ï-ý ÛwucÈÙÛú ´ßóì}HïÊÓãµ ùÓÛ"Bîæô·Q¾¡ù : ?ï .¾?˜sYôŒ½¸6üÍYˆŸö3¨Lø¹lĤ×êëÂ(x褷ž{åÛGéõî_œžv÷×Ï›=ûËé8¬ÁOû^¼X9‘ù¬Çv”C¹ÔC½´ƒvÑN±›~Ø~ÑOúM È y"o䑼’gòÎ8ì×ó¤Àþ
oêø,S ~ßÐýîÞÏU8øÏûéýwé~‚È|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3yg èçg`ÿ|}ß쯌Ÿˆì]Y
í÷Ü4ù»ÎÁOÞ¶ÂþN`Ëǯ¡|ÓUùÀÕ/l.¹` Úvó¯!ðcÑ•àaÆ9 ™ø©.c¹ oë¾Øÿ7߆Ÿà2¶Ý®ûå ¾Cþî›oB½½U°gì‹BÇ¡Ó:¿\]%ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’WòLÞ‡2<}@Ç)¿Ž_LÄ}ÏLü¤s`×Ðeh·£Ò{Èߢ×57}ýŒ¶kÅ:m§Ìû?ŠŸÆ Œo§Ÿ3¬G\>;ü\q;~¢ÍX áCùæ¾UÛƯ ;|‹ú»sV÷NHCùþêúùwಡñÀ±EÉg=¶£ Ê¥ ê¥ ´‹vŠÝôÃö‹~Òoò@^Èy#ä•<“wÆáàz_øÀ·gè¸ÜÚ é}{ö!½÷¶Í¿Û7ù;¢nAzk ŽD
nÑýÛšG2`ßs)ä¶g"òÇ ÆO3~®Îž±¢~*ÞX¿þø½yÍã: ¿6EþÎÙz_bϵxÎû.Ü??em ¯ûÛƒWÝ¥œÈ|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3yg êõƒÀÁ—Gê8õëýûŸøEÇãÃ×€»_ªˆü O!½5óÔ/õîAz]gɯx æÊþŠÿ.ܯFÞcÏÂï¯.Ç~¥±b‰^÷ÞðÀð˹ÙHoÝ Ä]g}z{:âz4öµ»åû×ûãË`=Î8øaxQ”|Öc;Ê¡\ê¡^ÚA»h§ØM?l¿è'ý&ä…<‘7òH^É3y·ã 穃ÃïÒõ¾i‡xïÿPëßk®Óqþp5â·có‡áл¾"ò ºUFzÍ‚:(_‚Ÿ„Ì}eòý¯LÔ~µß‚¸|õÚ¦ ^c¥ïEð±¡ý=: \üíÍq½»Ô!Ôß“±
åû2Àóg¡üà£z¾vpAcU%ŸõØŽr(—z¨—vÐ.Ú)vÓÛ/úI¿Éy!Oä<’WòLÞí8È:ËÁ<=o?pHï¯ìOn‚ü½å¾Køå;~Í€][¿-£í¢Ÿ“k¶
Ðñ¸ëyàÜ·Ïúõ9#oà'ÚÏöK}ðûB|*ÎØ0ìäoyö-ð³=>ù»ê÷Gþž¯/Ô¼.þVó\
x;Øx‘ŽËžŸÍ"(ù¬Çv”C¹ÔC½´ƒvÑN±›~Ø~ÑOúM È y"o䑼’gònÇÁ‹‡»âá=¯”ÓŽSþ¼òúó"vœòþÜïšN;Nõx×›ºk>è—¸k½Ä[Ot×z¢·Þî®õvo?Ê]ûQÞ~»ök½ó î:Ïà÷q×y ï<œ»ÎÃyçEÝu^Ô;Oí®óÔÞûîzßÀ{ Ç]ïãx﫹ë}5ï}Nw½Ïé½ïì®÷½ï¸ë{ Þ÷2Üõ½ ï{2îúžŒ÷½%W}oÉû ™»¾Göñ£í¿†œ†Up æ·Þug0~ù:c}9¿KíÇQ¿ûeÙH÷è‡ýæüÞ#Ö›ÐS£Ê\ §õíŹüÑ¡¨7pÂ2wàã;ðî°gÀ€«‘ßÿ¬¿å÷ù ûoù½®| é7…ünŒEýÎ MQ¿ÝÃKÍÿÄzm~í SÁ#QòC¥^¨´ 9¡"7Tô„ŠÞP±#Tì
;CÅîPñ#Tü
?CÅïPá!Tx žB…·Pá1Tx
žC…÷ì8h?ñ_ô
ê HÒëZ#Æ
Ê
ø/ú!('0aœ^'›¸ôÞ`û@jrê¥U'hO`êáªAyé±¹—~‡ÞHo €Üô:ñh?ý÷š¨?mÁyHO= óƒÀä¸n)OÎ &?š½ ÛŸEû1íõù¥!i ·çùxþZ-Öór¢äRÏv†È1D®!z Ñkˆ †Øeˆ†Ømˆ †øeˆŸ†øm†ðbO†ðf†ðjφð *qÈ¢ÏÅ
øt&øõî?SnoéUß YCâÁSî¼{ÀÇÇ#j Ý'
BýYŸÞ‚zæ
QÏ|=DãÓ{ '°§ðÓ¼ÀYqf®‰G½¼‡¾æÜÿäg¬Û
yiÍ‘NJ =#O×ëJ–?¦ø”|CêÒÎ9†È5D!z
±Ã» ±Ó»
ñÿ ñÓ¿
áÁ^ áÉÞ áÑ^
áÙÞC%ùôý ô<¤,kƒtæ5áo^¹ˆË¬Çþ/³+L~v¥ GÏÝ÷ÚÍ{ ãËÀmþ@zþõ#Po~›Éh?¿>Îi¾X‹õ¼À¼Ÿô8ïó ½ž=÷ mÇœêåÑ>·NÇ)³.òs ùÓVa}<˜3õx?%ßz†´3DŽ!r
Ñcˆ^Cì0Ä.Cì4ÄnCü0Ä/Cü4ÄoCx0„Cx2„7Cx4„WCx6„÷P‰C~ý Þà7½ƒ ¼å½©à`C,üÿìíW‘?oX=ð· a#¤~–^¥¿ü&ä ä/®8ñXüÀ,ÈY|ƒÞùfö'_wx øÕ‚;Pþe‚^¯çeÏÏÄOfçÖæß‚ñl »ÝÝHóºá}O¤ŸRÏv†È1D®!z Ñkˆ †Øeˆ†Ømˆ †øeˆŸ†øm†ðbO†ðf†ðjφð *qÈÿP÷{Áç€ßéï§Aþg_n…ßó¯À:h૳
”Óc ø\òð&´[ÚJŸ ZöÊ«H/ÛÕéå7œ‡ôòsõüsY*æÃ¥û1~ ,Ù\ ñ]Ü ç9‹ÖéþãËkõþÿ<ßÔ› ó:ß~vð>a?Aä}!õ igˆ Cä¢Ç½†Øaˆ]†ØiˆÝ†øaˆ_†øiˆß†ð`/†ðdo†ðh¯öõ"¼‡J ò{éþ>Ø_ãfßs*â|Fà‹AŸ¯f.?‹s°X:Ÿ,,ï‰s²?]‡v«*s€¿ÕeîC½U;õOÙ?ù< ßÒÎ9†È5D!z
±Ã» ±Ó»
ñÿ ñÓ¿
áÁ^ áÉÞ áÑ^íûDx•8ä÷ÓãÁ` ù\ ÿ Õàcñè%àiÙK1šÇœÕˆãªOƒ÷5_†œµãôyÔuQ ¨·nöÅ:=A_çëÎí¹kÏÖçÌVÓû–+ç5Þåýâ¿ÔwÚýì5ˆßü‹>Eš÷ ûŽŸˆì/x_H;Cä"×=†è5ÄCì2ÄNCì6ÄCü2ÄOCü6„Cx1„'Cx3„GûúàsTx•8äÔãb{ Åþ‚÷Å×KS€KçÏÑqXó 汯^÷\»®Òëg,Bzã¥ú¼Ë&ß:ðµ©Îi6Õü éãt 6t¼ùëVëqÚš9Õ‘¿ÊÐë§Ëd¡þ’«°g_|~rœÁq$‘ý&ŸäAä"×=†è5ÄCì2ÄNCì6ÄCü2ÄOCü6„Cx1„'Cx3„Gû>a"¼‡J òëy’5®Ôï°ÿäs‚|,ß|éÕOŸ Ÿ=S×uÏ!½iÿÙÁ@
òŸ‡¼ÍåkŒý¼nǺv`sù_u½†• oãú½”õ‰z\°fõÔ[™ ÇÛË*—C{Þ'ìO8î⼂Èqû Þ"ǹ†è1D¯!vb—!vb·!~â—!~â·!<‹!<›}=ð¹Éñ…ð *qÈ ªçÖüâ}øÉqû Þ+·_¾Ö&<‡ô†ýÝ.xûŸÍño‚Ç-¯Ý
y[¶íï[¯¼õ¶ž¥×Ѷ`ûΪÿÓCÐSð Î 6E>9ëëêó«×B>¯>/9®àø›ó-"Ç—ìGù¼ /"×=†è5ÄCì2ÄNCì6ÄCü2ÄOCü6„Cx1„'Cx³ïö' w üazý 8ÿ‚ g²?åsƒü¬_ßGÇá¾ Ò›gž¶ü¼õ·nÁû{mîCù¶Oú#[²>·¿íkQkûžˆ×–Æ!s9¬ÿ6æÞ
ùk·õC=Þ'ìO8îâü„óm"ç G±¿à}!r
Ñcˆ^Cì0Ä.Cì4ÄnCü0Ä/Cü4ÄoCx0„Cx²ãÏç$Ç w üz%8œ_p Åþ‚÷ÅÆ_[ê84¦yô.øÛÖà1”o¯× ‘þ„ã.ÎO8çz×g‰\â¼›ó Ž£Ø_Ø÷…Ökˆ †Øeˆ†Ømˆ †øeˆŸ†ømv|ù äxãjÎ?¹N#¼‡J òÇéuûà:-xåzçÝœ_XãÄýï‹Môzàî
s
4ÿóÁïÞr=¿÷µ™ÈߪÏS9»§=z»jîõ;ãÊç Ç OsÞÉõ®cr›Èu=®_pžÆñ(û]>_È£Øaˆ]†ØiˆÝ†øaˆ_†øiˆß†ðPxŸH"¼ÙóÎã¹Þ%¼‡J òÇ?3þΪx'üãúÞŠgt¿kÍ“Ïq)û_>gÈçîo±ß Ø{'ÎÕö•Ñïõîkð´Æ°¶:N):¿:Ò»¯o´ïéO¬ñôXóäs ¿d³¾>¸.Ì} "×i¥ž=ï9†Èµû Þb‡!vb§!vâ‡!~â§!~Ûñäs㎣…GCxµ×/…÷P‰C¾_ïoÙû‹Òß‚Ÿ\â¼›ó k<¾Ù_ì® ÷ù÷ÌþíöõˆæËšð î7* |ˆ‚ž} UA½½m¿—8¢¾uߣ¾Õ?B¾5ŽD>ç™k¿‚ôÒV‘ž÷–>çÌý ¢äRÏvö¼Mä¢Ç½†Øaˆ]†ØiˆÝ†øaˆ_†øiˆß†ð`÷'“=?á<žë]Â3÷OB%ù~½?Ü ?\_Ù«
üæºço §²?æsÇòõ÷}y‹ ü'7ÊýŽòýÛšAþþ'nÓõäýxÞ'ìO8îâüÄš/C ×»¸.Ìý“i Î_Dî_p–ëQ"Çž_p Åþ‚÷…Øeˆ†Ømˆ †øeˆŸ†øm?ç8 นóK®Ã¯öº¾ð *qÈ÷ë}à@ áÍà…û«*À—Ž?œws~Áqû Þû›}ƒ8 xrø;ú–ŽKÏË‘¿W—"qãóÍê !ÏG¢œóJ®¿p’ëù_´ùõ§Çæ‚/¢äÛëá\÷ãúçq¢Ç½öó‡<‹†Ømˆ †øeˆŸ…÷‰ô' wq~Ây¼ðh¯öþ‰ð *qÈO¸{#ø ìi ¾™ô:pUóûuüb~¿uúï‚¢äRÏ^§9ö¼›ó Ñk÷¼/ÄNCì6ÄCü²ãÅçûŽ“9ŸÞìõIáÕž
á=T⟠ÏK÷»Á ÷õ¸ÁuZ®GqÞÍùÇQÖsUó-÷ÅÁ¯@ÎÁAš·ƒÇ›'ÔãóŒý>ÇÇœGr½…ë’\¿ç>÷ƒy¾€ÈýTîq}œë€\ï༎ãWöÓ| ‰†Ømˆ †øeß'â·=îâü„óx®wq]˜û'ÜgÞC%ù úaÂqç'œÇs½‹ëÂÜ?á>#÷ã…÷P‰ƒ·ÅÃ{^!íšç•×Ÿ£žkúso¼ ~Ü2Þõæƒîšzë%.[/ñÖ5Ÿ.YOôÖÛݵÞîíG¹k?ÊÛ¯u×~wžÁ]ç¼ó>Ðëšó>Þy8èuÍy8Ｈ»Î‹zç©ÝužÚ{ßÀ]ïxïã¸ë} ï}5w½¯æ½Ïé®÷9½÷Ýõ¾³÷= w}Àû^†»¾—á}OÆ]ß“ñ¾·äªï-yß#s×÷ÈŒƒ‡xè"<ˆï`zèÌ×ûñ º› ð{è <ðÃyÊCᛓ} º÷§>§â~ ø_éýß²wËó_ø=t Kóyè Ü0êA%rªã”Ÿl<–þÒÚs¬vnó§Hùš¿ÃÀ#ˬw¬tióK‹ÇkWZùÿTÿ‰ú[Z ‹Ô[yI;ß10ä8å'Š!Sîñê—VîßÕ{²x(¶|é=ú¼E1¨ŽÀcÕ;^û_ÚvGÖÿ§íO–_'¤ï«wð»ÐêóJ…écå «Þ‰Ê9žüÕ[Z{NTþ‰æŸ(oEóç¶Àïþ‹øùI’ë6<9~æ
ùÙWJ 9Núßj¬z'ªïxíOTÿ“?JŸ¯ü1þéý_°3p
0þéýŸ°Sî“Ò`ÈqÒÿVûcÕ;Q}Çk¢úÿž¤ ùñó“$×mxrü”qV@Æ]Žô±òUïDå Oþ‰ê-='*ÿDóO”·¢ù2)Õx¬zÇk¢õKÛîÈúÿ´ýÉòë„ôÉ<½8<^ù‰bÈß”[Z;ÿmþ®½ÿÈ YÇ
Ⱥ–Õ1ðÈòcÕ?^~iñxíJ+ÿŸê?QKËc‘z²Îu_' ¯üdã±ô—Öžcµs›?EÊe ÄC— ìzè”}ôÿ q.Àÿ•Þÿ-{åœÉê?Ö÷?i·œÃòÐ%(ç=t Ê9Þ‚ê_’s²ô¸Ý¾"(çÜ=t Ê{ ºå=)]‚ò ¡‡.AyÏÖC· ~ÝC— |§ÁC· þŽ‰‡nAý Ý‚ú;X º}¾òe}¾²‡?βþ³þ®4×Âr:¿|0¿šÎ÷ýeýWeå}•,,Ótä ¤ÚÁ„Oÿsü Yæ°ˆ9S•j,•oÓ±U¤ü}z‹ˆ6‘±QÑL·‹ŒmÕ(2NÒÅDÇÄ2U©Md‡F11±™Q®qT ùó´F‘--Q,9eLl‹ˆh&+G5µ2" ïÐƪÅ*M¢£ZµŠl¬
.GƒËJñ±M£ãÚÆ6‰hDc+Y91
›G6j£ý/¤¬’Pô½Šˆ(C
qšEÆZÎøÊV“*EŠ¯¾¿æÝ÷Üq׌±¸|תÊE—3ùŽñïÈèB×?‹.T–76·n oýa,yé¥ð fU«ÄC%ª._‚êòTË?šò†ü#ÂaC•÷uIºÊ” «L¡®SÅc±wI™#b^é_¼K*ÄF4ŽŠ*þ¶(î>¨Ú$"®Í˱-ãZEÄF¶lÔ±¤B.èRÞgû¼âdܹ§•¤Ë»!\{CTõy7Äɸ!²T| º¼Âµ7Ä9>ï†87DzLIº¼Âµ7Ĺ¾¼!jÕzì®jºú†•ÆžN⃸5.x¨DÕÿî
1%´$]Þ
áÚ¢šÏ»!NÆ
1qQIº¼Âµ7Äy>ï†87Dâ›%éòn×Þçû¼âdÜ£7–¤Ë»!\{C\à;á¢æ·×úŸ¸!vÞwŸ
â´Ë/ñýÇ7Äàuy7„«nˆò¾Ââ¢#ÂpF£àÖ_tDKÜU Äü“àVŒiÒ$.²Í)‹p‘H–/1’§iSÚ--žñ³,~ Œ•’ôKNé”y4ùÿ÷I¿ìT“~4ùÿ7I¯è ýÌ#è© Õ´Y›S TV¶{Ë“„Ř^Î÷¯õ¶ÎÞé˜çJ*–ÜS•|Ž¤]TdûV1Qv×S±IT˨6‘Ǹ(N·â¯#ZÂõpº¯ðz8ÃwÄMØ0¢ÑÛMccÚ¶l|Ì!ØÝÿWÚ!Xyc™l* ‰ÇŽÐ¿= :êÂ.üw²‡/NnÊ·ŒiüÍL<ÛŠºoóxú
kŠ^,GŒ\*ê¡ ›Ä4uJ²’q"¢u% /Žk¡”—Såã^N厺œjá_ ´YÏ(ô Ex*WôzÓ‰rÑQ¼òË5ûœ—¡ð}
ï2ü߸ ‹X^•–ßq—ý×Ýö_÷ØÝkÿuŸý×ýö_ð¯;o·ÿºÃþëNû/[ò¶¼; ¥Ø-î°¥Üqg16—;¯•ccbÚÔiÛ0Îb´p” Ï 0¸Á @W·Ôü?xïöùð¢ rgl/tests/testthat/testdata/mergeVertices.rds 0000644 0001762 0000144 00000004417 14145464133 021202 0 ustar ligges users ‹ í Mo$5¶ú#Ê'a¤¤‘öÊ0 #!
¤ ‰Ñ¢ ¤9LÜÝú¢ª’L†KÎðC@œ¹gÄ. ¸ •V¬vµÒ®PN{„µ«üêÃ]nWuW%Ð užŸýêùùùÙ~¯\ã5M«kÍýÛ ÙÆeö‡" ^¥¿5ú«iMmÂù¿l‰fWYñæ‰i1 ’GÒÅ[AR4Ð~WÙ@«O ÷¤¥! =â3JpÈkBþw{à t’Tã±0r¥¥Y͈ÝjØóÚÕ`¨†Sò9Qt¡®YOàs2±Ç‰®Ba×6ld8»zm Æ ™ ‚-@uÏÁÝ=Ác:6‰çÛâø‚·K,Ú{Ú#® Ï´mZé»vÄ«ÙA݇÷Èc µ~Ѓlß ðìSŽM,ÿ²|‚ ‚€ÿ*ÓõPé¼ ù{.N¢‡ 5‰c"‡,µ$ »É24H•±±µ ?¸ØÃŽ¿ûÀDÞÃt‰=èæ
ñ>p‘å9Èõ¸êØÆáÀ¶ Øý¾‡¡´e"w@@—zß°‘O,Ð@ÃGƒÐDƒ©;ÇxóñŸÆ_÷ö:^[˜Oï+ Z]ƒ©òzdWI;Jð¬¯íð!²l+Ö KÇ®ƒ * Û¶Ú>;{”$°ÅÚ \Æ,~tôA s.ìÆ!½žds»¡‚>4Ä ÒÞèYa®Îê×ÓdÚüé _ QxüÛÓÿkgÕór ƒôDOÓ=áíÇí¦æa£GL-T1+nòßï n{å—×vrˆ›—îÉê¿ÿÆàñ‰¤þî?\K•0qëd˘4“âêõ?_ú/SïíëÏÕór Sò‹Ú %oA+£©ÓÀŒV„”|…Óò;HjJ5¹yÕ Aæ0š1¤¾] L¸áäöÈðJûj:ç¯s¯k çÑP‹×–ZFû²ýñ…õ{‡žÍõ÷HÇEîáúÝB¼õ{{Žc`“.©ÈXÃ¥Ëÿ‹¾ßO´Ñ‚6ÚÚw,}Ÿ¨xÖ5q#ilýõ#ØÈÀ²]üö#?^Æ BE³° ô ¦½çá»v–,ÝîxØݶ%“Öw‘ï¬Eǵ?I—x‰³{.:€ÊÕMѬ²’÷铸ëÇûïœ×EÑr©ï|àØn´á&éf§cGÍ «g lSN‘S…Lb€5ûñ¦Ýèbxl‰J°åbüA¼³êŒ’ù°÷™èÑ›qÞ7õ @Gã#ª±XèUD»°ïE{V0y“†=ïbÇ@]\ Íž$¢Võ§•ŒQŒÐ~ò9³Âíj™ç™}=Åù/Iö¹:o¦™ðAæ¨;ð2T,b³ƒ{=ºÕGŒÝa2y¢ ×5~\ ÆÁ Ñ~ÏUL‹B\™Ì ˜çŽƒž˜+Âd£;AÖÀ`ÎbðÌF˜!Ìüö¼è·
oÝÉ޹ŚʉÞ|µ º±±µuãfôÕP FÓV|à¬ÇûÚ;°‹{» W•‹õâ>'ߣò•‹ø¸òåŸW?Eû+>ŸWÞé¡ òKX˜Ð– º¬=^æt%7¤~Gí±›êŽL•…á¿~þùïYð‡íí XuÚüåþý,øŸÏ>;Ê‚ÐS†g•6¿½téZü•“Oøs J¦Z3,o²rqjE.=8Ž5x
Pë@iñ »rüÏ?Ü¡ÜT@}Þúqñ 1G¥1BG9—ŸwŽ=ü²Íš¬nV «–ç¬øŸúÑ;嘦™|™’òøô‘qƒn" ³h7Šf°ë“n\µ?1
#hLàÇÑé<
`Md šŽh) Ë4’ˆc‚ìèb(ªXÕçõÓ=Ô+-¢˜$À?Þ˜$ü˜$™48¡è¸EÑaÜB執^'•/¯\yõtÚÏOªŸJÖÉ’#”EŠ£¬HCI¨"ŠSŠ,¦=I#
€'œîœÂSˆ .‰Ë$•
ˆËøi˜ÏPŸÙ»×R"‚“t“² nÜtÖÓiò•|t:ªNšTü§r§;'N½ÿПÏ
À‰òŒáöìŒá”Îʉ¼ª‹ËªŠÚª‹éª‹øÊK‰¿ió•0‚ºW•‹õk\„²z Yû*(ã#¶S”^”_+–G5ªÞ¨¢QY´)¶#â2>²vUQnÑ·E}•G¤“%•þTüŠŽç´ÑWŸªøWmo>êm”ð餴èöŒÎsO+jŸXc¾ªLoô¼[ùöèÛ¸)ÑCYú)+•õ=ÀŸ-)ßn^°·38J¶ö2ßßn׿þú ÍHáJø݆rI#¨+àš ô“~¯"¦ã“4T9›?qþŒÊ'ü FÅ_Ù¾²?C6ôŒVŠ{ø͹ÿÞFP
V¦m{?ïß#îïI1Xõx U §íû«¢ôEû[uÊ+Àêí‚7çäôj¬ïÙÖ´Ù Öìkv‚uÑN°ž —«^Qàªr±þª¡¬^ÅGÖ¾
Êøˆí¥—õO+–GôÏUþ»Ì/“á2>2\ÆGÖ®L>¿ªý†¢òˆt²¤ÒŸŠ_Ññœ6úªõSÿsé§ÎN°*³¬RaÑ4;Á:4;Á/ÍN°f0 OåëY~%ƒÏñ“,”…M2( ß$pv‚5;Áš`eBY:’À¢é¢ž` I`Q{¨Ú “ÉYý´H•u‚uVéHe©z{›`)O°ZZ|‚µ¤ /Ãð&Èzæ-ª#Ô\›XÍA“Ëgà`²n–ä`Êî’N™Mk´ÙŒ4“…ð’BÝ»Øê‹øXbìÿä‰ks•'š‹ZÚ Ù]Ì×Þ³z‘f|a÷Í7Ù¿¼§+ÍÍ /_¾ÆFD„òª•7BÙ† §
[zwxÓñЧ¬1#×”–çìâøîë¾=ðS7tÂ;B³-i…ZNÂršÓ²ÒœCæ] /SÛ »ÚÛôÔHÛ[ˆ$î+/Oš!×w…bf†çà S’σä/½ ånF¹W¢Ü(÷R”Ûˆr7287$½_vmÛ¿—¾x5}okC\%Ù: Ýqû°x µ‘a rgl/tests/testthat/testdata/r3d.rds 0000644 0001762 0000144 00000013527 14145464133 017070 0 ustar ligges users ‹ í] |“EÚO›ô
‚€°
béI»
ozº«°®Tt9Ò6m9jZŠWYt×k]TÑ…EeÅUP@KI@¡”£ -méé•–¶@zÑRŽ~™ÿ›I2¡¡è¢ ß·ïë¯>ïæ™çšyg&O&¼ÓýE"‘§Hâaý¿Øz+ @þg„³þõ³þyˆ$"?+õ= —õ6€s½üÁÆÿ¹iÂÇãêAô÷=*ðNQ(•òd·¥¼ _»œkNïE.÷W\¤‹µ©‰.,Œr¥B-—iÝ–v§ÆÕ-‰R®Ó¹ð «®¾œÛ¹šîR'ñtÂ^j™J®³1
£…I¥FKL™ž&£^+zÚO2U¢B®¦ÐW—.Oš¯”Ñf¾r•B§ShÔ6ì§KS¨Þ[=²ÅB§ÒhôiTKŠVc—%I”%Í£÷:ÅB¹]{f2½MѤÚnû¦kjýl™Z¯)2*?€ÄúªR ½|~¾Vî ³Ò)ô³B•"]%K·ôFÚ:’ôrs™,•)#
åê GCÿdyº>m¶J¦›Ç–èå:êf …î LK—i q H×(³R5êÙš”œ–z«dÚT¥oŠR#Ó+Ô4b½,• ¢xt½ˆl[ÿû¸ô¿¯n~¢.I®–Û ïÛœx}EôQ™d WÎãÈI¦g?è±u‘Z£vDPkí»D™RI+j4*G§eÐâôùVŒE.›Ýɳ>)4^ZEjš#"Šäd%eóÊL“Ë•| àƒØõ‘>ôçÙ¸ó$õýœ ÿk^ÜñªÏI;ÃÙ[ÎK»«·•S>z=Õ›çòMQ*ÁÝŸB¨C/ó Š“*[ˆI±Äöw…š+íS:ÑY¼»ëzùŒuåÄ<ƒÅMýŒ
l 1׳«{‡ÉO¯þõ^$¼ÑSÇ
¿ªÞVNùz”g×{-{¢¿ß5cŠaLy]©•½×vÑ„y¤$¶áå±€ÞdÙŸE²}öõN“ãÑr(v^ ö6ú%¾šm½‘Ž ya••ý›š€û¾ïM˜Œ½Gí7ì7d¡”oçlà8›ãD.kœÎ:Š s‹G7úÝ÷&déôrUàdE¢V¦Í
Œ·.!ºÀ„ùééJ¹Ê:¥Ê”QZëôÿ€^Ÿâ¤Ã›êŠ’ëSk o£óšëB"ŽìIº (RÕUž¬•eÒ«T-Ã@Jþhm)OÒ;Ö_/]’Ì>]úf(ä™é}Áuš¤%‰‰»ºL…:Y“9Õ*ɾ©’©J:ˆ$)ŽE[œ$§ÍzY-ˆ×ÊåO8VV_ÂIötíSÉÄ(éTʬ{£Tå“Öˆ9ŒY]È'Ø×,<¼ÎÛG+OWÊ’ä?
vÿ¸Fágƒˆ>r «Ÿ¶g†Œ ²îö¶ÝØd÷r³Æy*èNFâ´ÿð²nBh…¿\•(ON¶.óöÍ‹&‘Ø£sÝÃ%)e:º‡ó¤} MUÚ×z[xE¼[ ÉÀǶiðwzú¸ºtBO¶‰hâm«¦†’Î0ÂÆ302ŽQ± ŒfaL c£ÇÂø(½a Œ g`, c&00:‚Q,ŒŒd`D'°0<ša1 eaH,ƒãÄ:8ždeÈ–Ìå._¾Êz#P
ôj*rŸk œf݉ëUóµÉš¤´@]†:pJÖÔ@ë6,P¡Öém¹(] uÛ§W$)夫S]„ØÒo̧ fGémß^OÒîšé/—„”ý£²Çý†Šss‰·†Cz#ñ¾Ã²àvB7ö.Ì&Ôøf6ðÅô:®ü¥ÏÀß:q½‰ÐšÎ e¯lCû–÷
A‹|Æ#š'>›(%ô»i߀¯"W7‡àKË‚Q~ªl ¡†®Ìè3?»|'£ÃA›æ¡þ€ùCb‡Á2w1ô×& z Õ¢©Dž¡óÒFØYønèÿáã Ä^CsØa”·ö]}¥Â.ñJ ô5®> ;‡| »ê I5û=þŠmŸáëÕ°#i5ôÏøòÍúîý+|Á×Êõ#|R§½ ·%áøš:¤°÷ľrð•—=umY·ù©µÄ_îHø,ø½âÁ?¡ü_-ÃQÞVs íš!ŸëˆÉ€ 9Ð/•›ïŸaÓiÈ=ðéø]àÃï.GûÂI£Ïê>G»5}Nž n¾Î¯« §xÚÇ°çLÚ<øS©@–«Ò? |¡òø×jW" ¦•á~üm°GŸ §:ûß×0>q²$€oçˆA¼ ‹~8%òŽ$ Ý—³çÃÞ경ЛwÇ]°ç›6Øa8›óWر1ŠCüÚ‡U Îe5Ïž
{rKýÇ“z£HÕz›‡´¡}û¬}hW»î3´»òÆzØ×>4ö›çK`ß‘œbð_¸'ú: º|þÉ?O¦Ë(oOšùfñ\Â/ ò‚ßËÖÁžÓac ¯î£+ðïxt ÚYF=?w.ÕBîѦ.ðWJ.¿«D»-#aÇ Oè©ýD‚v•2¬ †¶þ/Áÿœ¹CÀWrä#ØQ°+þžöœnäã‘Œö¦þøfƒk?ǧå°goÃX´»’> í¶xrÛvÕ¯&n?ì2´SZ ½ýŠ gÏb~ÝjÞð
ôXÊaoóÔ.øU¹p%üyñú7 øê/cû`í“I=÷ÞóX︖.Ì Ý|@¾¸»dú|“*ú…í ýbZlã¹:Õï±PäØÊ-q÷¯NÏÍžM\çμ€¡Ê5<÷ èiÛ»vË#¡5›7ƒVåç#”MÍhoêÇ/éeÆOŸyK—¢ý‘%K@é†}wÿþàÛt+–n)O…‹¿h<ìñ¡ñ¢ñ£ñ¤ñ¥ñ¦ñ§ýAû‡öí?ÚŸ´iÓþ§ãÁb³ç‰ÚãñÕˆðÇ0r$hÎàÁ y+WÂþü„Ø[d+/))¿'mõ?Žúª)â0p øjmüu §ÞÖ®ñ»ïŸ³;wo‚8Ütô¬?mãþ·¿•Zg‡æ'ŸÖë³ |çU„šÖ¯7Z>s&êOØÆßñãÇM„ =zô Mî¶ñ½mÈàÕ¸íC‡‚ÒñCÇ _t¼ÑñGÇ# Ÿt¼ÒñkÎÈ ¥ã›Žw:þéó`±Ù!PžÒù³± [FûüJç[:ÿÒù˜ÎÏt¾¦ó7Ïéüž?` (ÿéz@׺^Ü$‰I
ôf¤n>êHør )wýhc?ÅDÓÛ ôä£G"½‘‰ '»Äœ ŠD®´Ý$¥.¾†îëûXå|^©[ ×PáápOH¹ )w!å.¤ÜÑNH¹Ã.!å.¤Ü RîBÊÐ_%åþ3÷‚î~>ÆœØð·5êþ °¯J¦—“SëgÈÉáû!ioœó° C—%Ï¥g>´²d…‚žìH’«õŽÓçÝ QOQ,''ŸWÁ>1µ !ö'Gˆm'mM\N_ur˜ {N; prX89ì …“Ãö±!œ N T ÿ•TôßqrØ\C¼5Ô
ò¹Ð³¾žC¨¥è6àÒNò»mw<é:£høPRÏ u¿‘ЖÜy„JE“[½Ö£+L„ÖMx‰”.®ZOÚª¸7@ ÿzõæűÙïè¾ÖÑJÈëlÑ¢þ̽ü×5yÉó¡ç…Ùào›Ç½SsW:ì6í؈v5“¤}g ÚUG!
ʵÍzõ/”…ƒZ n@»q>ü¬ ̧ :þ°´øž‘&ø9·vµåßF°!÷› Ô7lÊ„ Ûz!U¦#>g×ßÚùÝjе_EBÏ+plÂp©O4ìÞ¦Âït
•“‘.1œ»oâœãs/ìµL ƒü®ÊÉð§t:>^sß—Z`Gã{cøþ˜õâRòÄI´_U8ÅÛÇ>©äéпÿaüÕ…ïBÎÑW’x=ò¾ˆGý½±h¿¿é%®8ÄŒvg¥ûÑ®aÞiÄ¡|Ñ‚¥âiƒ]s7‚–oh‡ õŠÅà7%xðþ•ûÀïs5« g÷‹À¯¿M Eý¥ÕWÀÿñúuˆã¾™³w¦r-3€O.hGûóÿ.Í÷ñéÞÒŠ(/¼ûï°³zÓr"×è]Fø¸ÆGùôcý·Â¯Ê§?ByG_^NÝžð»¡ßƒ¨o½oä®?¼±àmØÓ¼ñ ôU?VŠò¯~Š8Öd<ùiŸÂ¯ÂÄÙWʧÿ*&6ÂþCƒÍà?•½–ï‡;Ã`wuíógP ‡Þ’¬u°ßë®ûÐ~Ëþ‹à+}m ÚWÜq |?ÁK äŽ=ô&g¼oä·>
»Ì—‘ 7” ›q;úoÜEØ÷—ýfðuŽ¾
úÛ%#aÿ¾ÄØ[ qÏå‡ ]j° =ïnÝ„~lšÈ?—æ¼LÈizfâíˆûA¤‘¸–=H›ZJ çûm¨zk†7"î¹ï]†}Õ«ùôêž±ü× e?nŒ•lÍãÓ›üåç+Ï@ŽeçeØWZº~›+¿>3ã%´óúýÛÀM?l€ý§üù4æ¡—K×cUø:k¨EÚÍP8…?ÞdZö êOˆ'CÓó|š¿åO|Ú§v³ ôâûKAׯãíiyB_×GCÞ1ñ!øßvo ú+ïÓþÀäˆ ÷ÃÜXø{Q¾ öœz rŠN!=b8t§ö,mòÜ‚!¯ ·Ig¡½!€O—˜ˆþªkœÇû ÇÛJæG®Ógp±ŒO‡ï¸iHî|âϵnBþÇДþhƒ%ümÛ7 ®9ñ?‚ÏEà/š²ú*¾äÓMUÑ›àß¹ƒ2ØeQ}‹vu¾PÞqŸÆÜúÌ{ßø%ì5Š–Ô@îFÁßMG n[Ï!.¾¨‚¼Æ‰÷ÀýóiªmEÐ[»8 r'ëÁ—_„qf°|òWðå,SCþÙ–”ïØ: Ô<#ý{ôßQßt|9ïÏò6Ж\%ôí:ÔK¢šÑ®âdôTÍÆ×oSŸÎ<¿ýÈ1&öí
zúcþøAój䶿ÿª²&þÜ* ÞŽçkàOy×8è3¿úê[ƤÀŽ†mqÙ kFߎòqo¡¼:c á“ŠŸ Šö›y>?=ðiŸƒÐß´_“q‡;£Ð®S= òÛŸjBü¾ˆÙ?Leï@~.wí«ïâ÷õ_ÃþÊ—«Áß”‚¯¹öË`sç7¨ßfšÊÇ1€ƒ •{_C}þcGÑŸ›žž{ÎîÆüfhŸò5êOKøômÁ¢_–ɧÛО«yãQؽ1ëðwŒäŸ÷·KÐ/Ò1°s{ˆ v7×~þSõü×w–.܃E°«Xñ0ü?Ýÿï¼_kÊÑ®ŸŠÈ7z/œùå»ý@ëkàŸáØ£@®éŽCÛüâ' ÆøTÈëê7 õÍfþkÇË»ƒýEÒ˜ÂIað '…»½„“Â.ñN
ß\T8),\7á%œ¾É¨pRX ½i©pRø:O
)v!Å>!ÅŽz!Å.¤Ø RìBŠP!Å.¤ØIýÍ”bÿo<)ì+rœî+b·´~z«'êT¥ý¬ðÕo±fCäøGqˆÅ±Ï¾Ó`á#ÚSÀàBotùõêý©òz*ï©}7ÚüëÕ7à#ŽÄ5CN¯ >úÜÈOv½¹ãÓ¦Í!:mÔà†öÄçZNq7>HnLøîä*³ÖH‰ªë¤†Di½?UŽ;þ_däº=&ç{'a—ÉÖÇ:ÕªdÊîçÞî§ÚÞÖ‰Õ1U^c²
9&Û~¢kþ,Cäâ±HäŒ#¤Ã Í5Yo¤ƒ«ºn-Çk¤·œ{“0J3öi#ÊÇ„‘Αœý"pÿ§±;“:„ßIoýÿtw"´å¹Gˆ<î¢h&á3,IlŸCpS0v/FÉ~•/÷Ê&´fÅßDh÷öoå:vžÆ`9¿ú
áç
æ,"|\à |zåöæ#å†FÏÁD wv„èžã×$áŸy> Ù
©hæî—ÿ<¸øiQäæú§Åÿ /‘‡ôÿX y˜Î«`~õ×ÕôÜóÝEßv“)r¼1£»ÖÏ ?
³Ä%ܾ|ζ ¦›èîž‚«6ÄŽ~Þ¿ª™sÏ
Ûðë'lÃ…m¸°
Ûð«¶áŒù¿B*G¬H¦,x-˜Êùµ`^D› ôô±µaÞ>õss@Þ"ÇÇ’^"—ÅCÉ¿…Žß©Š\® fðÄ÷þ¥Oœtc:qóM¸îÞcÛí¾ÜŒÃkŽ;?þi
µãmp
µµÃÝŒ_kÿ+^ÙÙcNÐ_ÄŽò ØTf¾:Ùín$4†üw½»‰ýlŽ+ußC7ü#˜Èíõ l·¿1äß²zÕÛÿƒ9÷šs¬·.=Mîøù`Š&Uϼ 0•?a÷#©uä8…ë N½{ N⫆“ý•ÔîÂæE^+ìºy³ãÍ6;~<ɿи›ÙO˜(„aøc2–ûP˃Bìw¡ö»0û]¸ý.È~7Þ~Üd±ï{k5}ûâG7+·ý_•'+7}¿æÿ ”OÉ
~ rgl/tests/testthat/test-mesh3d.R 0000644 0001762 0000144 00000002301 14127571241 016323 0 ustar ligges users test_that("ensureMatrix works", {
expect_equal(dim(ensureMatrix(1, nrow=1)), c(1,1))
})
test_that("mesh3d works", {
expect_s3_class(mesh3d(1:3, 1:3, 4, triangles=1:3), "mesh3d")
})
test_that("tmesh3d works", {
open3d()
m <- tmesh3d(rbind(1, 2, 1:3), 1:3, homogeneous=FALSE)
expect_s3_class(m, "mesh3d")
expect_named(m, c("vb", "it", "material",
"normals", "texcoords", "meshColor"),
ignore.order = TRUE)
shade3d(m)
expect_known_scene("tmesh3d")
})
test_that("qmesh3d works", {
open3d()
m <- qmesh3d(rbind(1, 2, 1:4), 1:4, homogeneous=FALSE)
expect_s3_class(m, "mesh3d")
expect_named(m, c("vb", "ib", "material",
"normals", "texcoords", "meshColor"),
ignore.order = TRUE)
shade3d(m)
expect_known_scene("qmesh3d")
})
test_that("shade3d, wire3d and dot3d work", {
open3d()
mesh <- cuboctahedron3d(col = "red")
shade3d(mesh)
wire3d(translate3d(mesh, 1,1,1))
dot3d(translate3d(mesh, 2,2,2))
expect_known_scene("shade3detc")
})
test_that("transformations work", {
open3d()
mesh <- cuboctahedron3d(col = "red")
shade3d(translate3d(mesh, 1,2,3))
shade3d(rotate3d(mesh, 35, 1,2,3))
shade3d(scale3d(mesh, 1,2,3))
expect_known_scene("transformations")
})
rgl/tests/testthat/test-r3d.R 0000644 0001762 0000144 00000000723 14127571302 015634 0 ustar ligges users set.seed(123)
test_that("3D sprites work", {
open3d()
particles3d( rnorm(100), rnorm(100), rnorm(100), color = rainbow(100) )
# is the same as
sprites3d( rnorm(100), rnorm(100), rnorm(100), color = rainbow(100),
lit = FALSE, alpha = .2,
textype = "alpha", texture = system.file("textures/particle.png", package = "rgl") )
sprites3d( rnorm(10) + 6, rnorm(10), rnorm(10), shape = shade3d(tetrahedron3d(), col = "red") )
expect_known_scene("r3d")
})
rgl/tests/testthat/test-as.mesh3d.R 0000644 0001762 0000144 00000000465 14127571212 016734 0 ustar ligges users test_that("mergeVertices works", {
open3d()
(mesh1 <- cuboctahedron3d(col = rainbow(14), meshColor = "face"))
id <- shade3d(mesh1)
(mesh2 <- as.mesh3d(id))
shade3d(translate3d(mesh2, 3, 0, 0))
(mesh3 <- mergeVertices(mesh2))
shade3d(translate3d(mesh3, 6, 0, 0))
expect_known_scene("mergeVertices")
})
rgl/tests/boundary.R 0000644 0001762 0000144 00000000540 14145464133 014152 0 ustar ligges users library(rgl)
# WORKING
x <- cube3d()
b <- getBoundary3d(x)
open3d(); shade3d(b)
x <- cube3d()
x$ib <- x$ib[,-(1:2)]
b <- getBoundary3d(x)
open3d(); shade3d(x, alpha=0.2, col = "blue"); shade3d(b)
x <- cube3d()
x$ib <- x$ib[,-(1:2)]
b <- getBoundary3d(x, sorted = TRUE, simplify = FALSE)
open3d(); shade3d(x, alpha=0.2, col = "blue"); shade3d(b)
rgl/tests/bbox3dtests.R 0000644 0001762 0000144 00000003154 14145464133 014577 0 ustar ligges users # Tests of bbox3d improvements
library(rgl)
x <- cube3d(col="red", front="culled", back="filled"); open3d(); shade3d(x); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=FALSE,draw_front=TRUE); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=TRUE); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=TRUE, front="lines", back = "lines"); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=TRUE, front="lines", back = "lines"); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=TRUE, front="lines", back = "filled"); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=FALSE, front="lines", back = "lines"); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=FALSE, front="filled", back = "culled"); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=FALSE, front="culled", back = "filled"); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=FALSE,draw_front=FALSE); rglwidget()
open3d();points3d(1:10, 11:20, 21:30); bbox3d(col="red", lit=TRUE,draw_front=FALSE); rglwidget()
example(bbox3d); rglwidget()
open3d(); spheres3d(rnorm(10), rnorm(10), rnorm(10),
radius = runif(10), color = rainbow(10)); rglwidget()
open3d(); spheres3d(rnorm(10), rnorm(10), rnorm(10),
radius = runif(10), color = rainbow(10),
front = "lines", back="culled"); rglwidget()
rgl/tests/indices.R 0000644 0001762 0000144 00000001045 14145464133 013746 0 ustar ligges users library(rgl)
tet <- tetrahedron3d()
open3d()
segments3d(t(tet$vb[1:3,]), indices = c(1,2,1,3,1,4,2,3,2,4,3,4))
open3d()
text3d(t(tet$vb[1:3,]), text=1:4)
triangles3d(t(tet$vb[1:3,]), indices = c(1,2,3,1,4,2,1,3,4,2,4,3),
col = "red")
# This displayed a triangle for the red quad (issue #154)
quad <- cbind(x = c(-1, 1, 1, -1),
y = c( 0, 0, 0, 0),
z = c(-1, -1, 1, 1))/2
open3d()
triangles3d(quad, alpha = 0.5, col = "red", indices=c(1,2,3,1,3,4))
triangles3d(quad+1, col = "blue", indices=c(1,2,3,1,3,4))
rgl/tests/testthat.R 0000644 0001762 0000144 00000000224 14100762641 014162 0 ustar ligges users if (require(testthat)) {
library(rgl)
options(rgl.useNULL = TRUE)
test_check("rgl")
} else
warning("'testthat' package is needed for tests")
rgl/configure.ac 0000644 0001762 0000144 00000016053 14145447077 013346 0 ustar ligges users ##
## This file is part of RGL
##
## Process configure.ac with autoconf to produce a configure script.
## NB: the files in src/build/autoconf may need updating for a new
## version of autoconf
##
##
##
AC_PREREQ([2.69])
## ---[ VERSION ]-------------------------------------------------------------
AC_INIT
AC_CONFIG_AUX_DIR(src/build/autoconf)
## pick up compiler as will be used by R CMD INSTALL/SHLIB
if test -n "${R_HOME}"; then
CC=`${R_HOME}/bin/R CMD config CC`
CFLAGS=`${R_HOME}/bin/R CMD config CFLAGS`
fi
AC_PROG_CPP
AC_PROG_CC
if test `uname` = "Darwin" ; then
darwin="yes"
## we want the *build* cputype and not the host one.
cmd=`echo $CC $CFLAGS | grep -E 'x86_64|ppc64|-m64'`
if test -n "$cmd"; then
have_64bit="yes"
else
have_64bit="no"
fi
else
darwin="no"
fi
## --- LibPNG ----------------------------------------------------------------
AC_ARG_ENABLE([libpng],
[ --disable-libpng compile without PNG image support]
)
AC_ARG_ENABLE([libpng-config],
[ --disable-libpng-config disable libpng-config test and configuration]
)
AC_ARG_ENABLE([libpng-dynamic],
[ --disable-libpng-dynamic disable dynamic libpng linkage, force static version linkage (only with --enable-libpng-config)]
)
if test "x$enable_libpng" != "xno"; then
if test "x$enable_libpng_config" != "xno"; then
AC_CHECK_PROG([HAVE_LIBPNG_CONFIG],[libpng-config],[yes],[no])
fi
if test "x$HAVE_LIBPNG_CONFIG" = "xyes" ; then
AC_MSG_NOTICE([using libpng-config])
CPPFLAGS="${CPPFLAGS} -DHAVE_PNG_H `libpng-config --I_opts`"
if test "x$enable_libpng_dynamic" != "xno"; then
AC_MSG_NOTICE([using libpng dynamic linkage])
LIBS="${LIBS} `libpng-config --ldflags`"
else
AC_MSG_NOTICE([using libpng static linkage])
LIBS="${LIBS} `libpng-config --static --L_opts`/libpng.a"
fi
else
AC_MSG_CHECKING([libpng])
save_LIBS="${LIBS}"
save_CPPFLAGS="${CPPFLAGS}"
AC_CHECK_HEADERS(png.h)
AC_CHECK_LIB(png, png_read_update_info)
if test "${ac_cv_header_png_h}"; then
if test "${ac_cv_lib_png_png_read_update_info}"; then
CPPFLAGS="${CPPFLAGS} -DHAVE_PNG_H"
LIBS="${LIBS} -lpng"
AC_MSG_NOTICE([libpng header and lib found])
if test "x$enable_libpng_dynamic" != "xno"; then
AC_MSG_NOTICE([using libpng dynamic linkage])
else
AC_MSG_NOTICE([using libpng static linkage])
fi
else
LIBS=${save_LIBS}
CPPFLAGS=${save_CPPFLAGS}
AC_MSG_NOTICE([libpng header and lib not found])
fi
fi
fi
fi
# ---[ OpenGL enabled?]---------------------------------------------------------------
AC_ARG_ENABLE([opengl],
[ --disable-opengl compile without OpenGL support]
)
NULL_CPPFLAGS="${CPPFLAGS} -DRGL_NO_OPENGL"
NULL_LIBS="${LIBS}"
# ---[ X11 ]------------------------------------------------------------------
if test "x$enable_opengl" != "xno"; then
AC_PATH_X
if test x$no_x = xyes ; then
AC_MSG_WARN([X11 not found, continuing without OpenGL support.])
enable_opengl=no
else
if test -n "${x_includes}"; then
CPPFLAGS="${CPPFLAGS} -I${x_includes}"
fi
if test -n "${x_libraries}"; then
LIBS="${LIBS} -L${x_libraries} -lX11"
else
LIBS="${LIBS} -lX11"
fi
if test $darwin = yes; then
CPPFLAGS="${CPPFLAGS} -DDarwin"
if test -e /System/Library/Frameworks/GLKit.framework ; then
LIBS="-framework GLKit ${LIBS}"
fi
# X11 must come *after* the OpenGL stuff
CPPFLAGS="${CPPFLAGS} -I/opt/X11/include"
fi
AC_CHECK_FUNC(XAllocClassHint, [], [enable_opengl=no])
fi
fi
if test "x$enable_opengl" != "xno"; then
## --- OpenGL ----------------------------------------------------------------
AC_ARG_WITH(gl-includes,
[ --with-gl-includes=DIR specify location of OpenGL headers],
[CPPFLAGS="${CPPFLAGS} -I${withval}"]
)
if test $darwin != yes; then
AC_CHECK_HEADERS(GL/gl.h GL/glu.h)
if test "x$ac_cv_header_GL_gl_h" = xno; then
AC_MSG_WARN(missing required header GL/gl.h, continuing without OpenGL)
enable_opengl=no
fi
if test "x$ac_cv_header_GL_glu_h" = xno; then
AC_MSG_WARN(missing required header GL/glu.h, continuing without OpenGL)
enable_opengl=no
fi
fi
fi
if test "x$enable_opengl" != "xno"; then
AC_ARG_WITH(gl-libs,
[ --with-gl-libs=DIR specify location of OpenGL libs],
[LDFLAGS="${LDFLAGS} -L${withval}"
L_LIB="-L${withval}"]
)
AC_ARG_WITH(gl-libname,
[ --with-gl-libname=NAME specify Library name (defaults to "GL")],
[lGL=${withval}], [lGL=GL]
)
AC_CHECK_LIB($lGL, glEnd)
this=`eval echo '${'$as_ac_Lib'}'`
if test "x$this" != xyes; then
AC_MSG_WARN(missing required library ${lGL}, continuing without OpenGL)
enable_opengl=no
else
AC_CHECK_FUNC(glEnd, [], [enable_opengl=no])
fi
fi
if test "x$enable_opengl" != "xno"; then
AC_ARG_WITH(glu-libname,
[ --with-glu-libname=NAME specify GLU Library name (defaults to "GLU")],
[lGLU=${withval}], [lGLU=GLU]
)
AC_CHECK_LIB($lGLU, gluErrorString)
this=`eval echo '${'$as_ac_Lib'}'`
if test "x$this" != xyes; then
AC_MSG_WARN(missing required library ${lGLU}, continuing without OpenGL)
enable_opengl=no
else
AC_CHECK_FUNC(gluErrorString, [], [enable_opengl=no])
fi
fi
if test "x$enable_opengl" != "xno"; then
if test x$L_LIB != x; then
LIBS="${L_LIB} ${LIBS}"
fi
## --- FTGL ------------------------------------------------------------------
AC_ARG_ENABLE([ftgl],
[ --disable-ftgl compile without FTGL font support]
)
if test "x$enable_ftgl" != "xno"; then
if test "x$darwin" = "xyes"; then
AC_MSG_NOTICE([Darwin, so ensuring /opt/X11/bin is at the head of the PATH...])
PATH=/opt/X11/bin:${PATH}
fi
## new pkg-config bit
AC_CHECK_PROG([HAVE_PKG_CONFIG],[pkg-config],[yes],[no])
if test "x$HAVE_PKG_CONFIG" = "xyes" -a "x`pkg-config freetype2 --cflags`" != "x"; then
CPPFLAGS="${CPPFLAGS} -DHAVE_FREETYPE -Iext/ftgl `pkg-config freetype2 --cflags`"
LIBS="${LIBS} `pkg-config freetype2 --static --libs`"
AC_MSG_NOTICE([using Freetype and FTGL])
else
AC_CHECK_PROG([HAVE_FREETYPE_CONFIG],[freetype-config],[yes],[no])
if test "x$HAVE_FREETYPE_CONFIG" = "xyes"; then
CPPFLAGS="${CPPFLAGS} -DHAVE_FREETYPE -Iext/ftgl `freetype-config --cflags`"
LIBS="${LIBS} `freetype-config --static --libs`"
AC_MSG_NOTICE([using Freetype and FTGL])
else
AC_MSG_NOTICE([compiling without FTGL support])
fi
fi
else
AC_MSG_NOTICE([compiling without FTGL support])
fi
fi
if test "x$enable_opengl" = "xno"; then
AC_MSG_NOTICE([compiling without OpenGL support])
HIDE_IF_NO_OPENGL="#"
RGL_NO_OPENGL=TRUE
else
HIDE_IF_NO_OPENGL=""
RGL_NO_OPENGL=FALSE
fi
## --- Output ----------------------------------------------------------------
AC_SUBST(CPPFLAGS)
AC_SUBST(LIBS)
AC_SUBST(NULL_CPPFLAGS)
AC_SUBST(NULL_LIBS)
AC_SUBST(HIDE_IF_NO_OPENGL)
AC_SUBST(RGL_NO_OPENGL)
AC_CONFIG_FILES([R/noOpenGL.R src/useNULL/Makevars])
AC_CONFIG_FILES([src/Makevars])
AC_OUTPUT
rgl/src/ 0000755 0001762 0000144 00000000000 14146473375 011643 5 ustar ligges users rgl/src/COPYING.GL2PS 0000644 0001762 0000144 00000001611 14100762641 013506 0 ustar ligges users
GL2PS LICENSE
Version 2, November 2003
Permission to use, copy, and distribute this software and its
documentation for any purpose with or without fee is hereby granted,
provided that the copyright notice appear in all copies and that both
that copyright notice and this permission notice appear in supporting
documentation.
Permission to modify and distribute modified versions of this software
is granted, provided that:
1) the modifications are licensed under the same terms as this
software;
2) you make available the source code of any modifications that you
distribute, either on the same media as you distribute any executable
or other form of this software, or via a mechanism generally accepted
in the software development community for the electronic transfer of
data.
This software is provided "as is" without express or implied warranty.
rgl/src/win32lib.cpp 0000644 0001762 0000144 00000004462 14137472630 013777 0 ustar ligges users #include "config.h"
#ifdef RGL_W32
// ---------------------------------------------------------------------------
// W32 Library Implementation
// ---------------------------------------------------------------------------
#include "lib.h"
#include "win32gui.h"
#include "NULLgui.h"
#include
#include "assert.h"
#include "R.h"
using namespace rgl;
// ---------------------------------------------------------------------------
// GUI Factory
// ---------------------------------------------------------------------------
Win32GUIFactory* gpWin32GUIFactory = NULL;
NULLGUIFactory* gpNULLGUIFactory = NULL;
// ---------------------------------------------------------------------------
GUIFactory* rgl::getGUIFactory(bool useNULLDevice)
{
if (useNULLDevice)
return (GUIFactory*) gpNULLGUIFactory;
else if (gpWin32GUIFactory)
return (GUIFactory*) gpWin32GUIFactory;
else
error("wgl device not initialized");
}
// ---------------------------------------------------------------------------
const char * rgl::GUIFactoryName(bool useNULLDevice)
{
return useNULLDevice ? "null" : "wgl";
}
// ---------------------------------------------------------------------------
// printMessage
// ---------------------------------------------------------------------------
void rgl::printMessage( const char* string ) {
warning("RGL: %s\n", string);
}
// ---------------------------------------------------------------------------
// getTime
// ---------------------------------------------------------------------------
double rgl::getTime() {
return ( (double) ::GetTickCount() ) * ( 1.0 / 1000.0 );
}
// ---------------------------------------------------------------------------
// init
// ---------------------------------------------------------------------------
bool rgl::init(bool useNULLDevice)
{
if (!useNULLDevice)
gpWin32GUIFactory = new Win32GUIFactory();
gpNULLGUIFactory = new NULLGUIFactory();
return true;
}
// ---------------------------------------------------------------------------
// quit
// ---------------------------------------------------------------------------
void rgl::quit()
{
delete gpWin32GUIFactory;
gpWin32GUIFactory = NULL;
delete gpNULLGUIFactory;
gpNULLGUIFactory = NULL;
}
// ---------------------------------------------------------------------------
#endif // RGL_W32
rgl/src/config.h 0000644 0001762 0000144 00000001166 14100762641 013250 0 ustar ligges users #ifndef RGL_CONFIG_H
#define RGL_CONFIG_H
#ifdef RGL_NO_OPENGL
#undef RGL_OSX
#undef RGL_X11
#undef RGL_W32
#else
// ---------------------------------------------------------------------------
// Platform detection
// ---------------------------------------------------------------------------
#if defined(__APPLE__)
# define GL_SILENCE_DEPRECATION
# define RGL_OSX 1
# define RGL_X11 1
#else
# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define RGL_W32 1
# else
# define RGL_X11 1
# endif
#endif
// ---------------------------------------------------------------------------
#endif
#endif //RGL_CONFIG_H
rgl/src/devicemanager.cpp 0000644 0001762 0000144 00000007573 14100762641 015140 0 ustar ligges users // C++ source
// This file is part of RGL.
//
#include
#include
#include "DeviceManager.h"
#include "types.h"
#include "assert.h"
#include "lib.h"
using namespace rgl;
DeviceManager::DeviceManager(bool in_useNULLDevice)
: newID(1), devices(), current( devices.end() ), useNULLDevice(in_useNULLDevice)
{ }
DeviceManager::~DeviceManager()
{
std::vector disposeList;
{
for( Container::const_iterator i = devices.begin(), end = devices.end() ; i!=end ; ++i ) {
disposeList.push_back(*i);
}
}
// disploseList. devices.begin(), devices.end() );
for (std::vector::iterator i = disposeList.begin(); i != disposeList.end() ; ++ i ) {
// remove manager from listeners
(*i)->removeDisposeListener(this);
// close device
(*i)->close();
}
}
bool DeviceManager::openDevice(bool useNULL)
{
Device* pDevice = new Device(newID, useNULL);
if ( pDevice->open() ) {
++newID;
pDevice->addDisposeListener(this);
devices.insert( devices.end(), pDevice );
setCurrent( pDevice->getID() );
return true;
} else {
delete pDevice;
return false;
}
}
Device* DeviceManager::getCurrentDevice()
{
if ( current != devices.end() )
return *current;
else
return NULL;
}
Device* DeviceManager::getAnyDevice()
{
Device* pDevice = getCurrentDevice();
if (pDevice == NULL) {
if (openDevice(useNULLDevice))
pDevice = getCurrentDevice();
}
return pDevice;
}
Device* DeviceManager::getDevice(int id)
{
for (Container::iterator i = devices.begin() ; i != devices.end() ; ++i ) {
if ( (*i)->getID() == id )
return *i;
}
return NULL;
}
bool DeviceManager::setCurrent(int id, bool silent)
{
char buffer[64];
Container::iterator i;
for (i = devices.begin() ; i != devices.end() ; ++ i ) {
if ( (*i)->getID() == id )
break;
}
if ( i != devices.end() ) {
if ( !silent && current != devices.end() ) {
sprintf(buffer, "RGL device %d", (*current)->getID() );
(*current)->setName(buffer);
}
current = i;
if ( !silent ) {
sprintf(buffer, "RGL device %d [Focus]", (*current)->getID() );
(*current)->setName(buffer);
}
return true;
} else
return false;
}
int DeviceManager::getCurrent() {
if ( current != devices.end() )
return (*current)->getID();
else
return 0;
}
int DeviceManager::getDeviceCount() {
int result = 0;
for (Container::iterator i = devices.begin(); i != devices.end() ; ++i, ++result);
return result;
}
void DeviceManager::getDeviceIds(int *buffer, int bufsize) {
int count = 0;
for (Container::iterator i = devices.begin(); i != devices.end() && count < bufsize; ++i, ++count) {
*(buffer++) = (*i)->getID();
}
}
/**
* Device disposed handler
**/
void DeviceManager::notifyDisposed(Disposable* disposed)
{
Container::iterator pos = std::find( devices.begin(), devices.end(), static_cast( disposed ) );
assert( pos != devices.end() );
if ( pos == current ) {
if ( devices.size() == 1 )
current = devices.end();
else
nextDevice();
}
devices.erase(pos);
}
void DeviceManager::nextDevice()
{
if ( current != devices.end() ) {
// cycle to next
Iterator next = ++current;
if ( next == devices.end() )
next = devices.begin();
setCurrent( (*next)->getID() );
} else {
// ignore: no devices
}
}
void DeviceManager::previousDevice()
{
if ( current != devices.end() ) {
// cycle to previous
Iterator prev = current;
if (prev == devices.begin() )
prev = devices.end();
--prev;
setCurrent( (*prev)->getID() );
} else {
// ignore: no devices
}
}
bool DeviceManager::createTestWindow()
{
bool result = false;
Device* pDevice = new Device(newID, false);
if ( pDevice ) {
if ( pDevice->hasWindow() )
result = true;
pDevice->close();
delete pDevice;
}
return result;
}
rgl/src/glgui.cpp 0000644 0001762 0000144 00000014433 14142256754 013457 0 ustar ligges users // C++ source
// This file is part of RGL.
//
#include
#ifdef HAVE_FREETYPE
#include "FTGL/ftgl.h"
#include "R.h"
#endif
#include "types.h"
#include "glgui.h"
#include "gl2ps.h"
#include "opengl.h"
#include "RenderContext.h"
#include "subscene.h"
#include "platform.h"
using namespace rgl;
//
// CLASS
// GLFont
//
GLboolean GLFont::justify(double twidth, double theight,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {
#ifndef RGL_NO_OPENGL
GLdouble pos1[4], pos2[4];
double basex = 0.0, basey = 0.0, basez = 0.5, scaling = 1.0;
GLboolean valid;
gl2ps_centering = GL2PS_TEXT_BL;
if (pos) {
double offset = adjx, w = width("m");
switch(pos) {
case 0:
case 1:
case 3:
case 5:
case 6:
adjx = 0.5;
break;
case 2:
adjx = 1.0 + w*offset/twidth;
break;
case 4:
adjx = -w*offset/twidth;
break;
}
switch(pos) {
case 0:
case 2:
case 4:
case 5:
case 6:
adjy = 0.5;
break;
case 1:
adjy = 1.0 + offset;
break;
case 3:
adjy = -offset;
break;
}
switch(pos) {
case 0:
case 1:
case 2:
case 3:
case 4:
adjz = 0.5;
break;
case 5:
adjz = 1.0 + offset;
break;
case 6:
adjz = -offset;
break;
}
}
if (adjx > 0) {
if (rc.gl2psActive > GL2PS_NONE) scaling = GL2PS_SCALING;
if ( adjx > 0.25 && rc.gl2psActive == GL2PS_POSITIONAL) {
if (adjx < 0.75) {
basex = 0.5;
gl2ps_centering = GL2PS_TEXT_B;
} else {
basex = 1.0;
gl2ps_centering = GL2PS_TEXT_BR;
}
}
}
if ((adjx != basex) || (adjy != basey) || (adjz != basez)) {
glGetDoublev(GL_CURRENT_RASTER_POSITION, pos1);
pos1[0] = pos1[0] - scaling*twidth*(adjx-basex);
pos1[1] = pos1[1] - scaling*theight*(adjy-basey);
pos1[2] = pos1[2] - scaling*theight*(adjz-basez)/1000.0;
GLint pviewport[4] = {rc.subscene->pviewport.x,
rc.subscene->pviewport.y,
rc.subscene->pviewport.width,
rc.subscene->pviewport.height};
GLdouble modelMatrix[16], projMatrix[16];
rc.subscene->modelMatrix.getData(modelMatrix);
rc.subscene->projMatrix.getData(projMatrix);
gluUnProject( pos1[0], pos1[1], pos1[2], modelMatrix, projMatrix, pviewport, pos2, pos2 + 1, pos2 + 2);
glRasterPos3dv(pos2);
}
glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
return valid;
#else
return 0;
#endif
}
//
// CLASS
// GLBitmapFont
//
GLBitmapFont::~GLBitmapFont() {
delete [] widths;
#ifndef RGL_NO_OPENGL
if (nglyph) glDeleteLists(listBase+GL_BITMAP_FONT_FIRST_GLYPH, nglyph);
#endif
}
double GLBitmapFont::width(const char* text) {
double result = 0.0;
for(int i=0; text[i]; i++) {
int c;
if ((int)(text[i]) >= (int)firstGlyph && (c = (int)(text[i]) - (int)firstGlyph) < (int)nglyph)
result += widths[(int)c];
}
return result;
}
double GLBitmapFont::width(const wchar_t* text) {
double result = 0.0;
for(int i=0; text[i]; i++) {
wchar_t c;
if ((int)text[i] >= (int)firstGlyph && (c = (int)(text[i]) - (int)firstGlyph) < (int)nglyph)
result += widths[c];
}
return result;
}
double GLBitmapFont::height() {
return ascent;
}
bool GLBitmapFont::valid(const char* text) {
for (int i=0; text[i]; i++)
if ((int)text[i] < (int)firstGlyph || (int)text[i] - (int)firstGlyph >= (int)nglyph)
return false;
return true;
}
void GLBitmapFont::draw(const char* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {
#ifndef RGL_NO_OPENGL
if (justify(width(text), height(), adjx, adjy, adjz, pos, rc)) {
if (rc.gl2psActive == GL2PS_NONE) {
glListBase(listBase);
glCallLists(length, GL_UNSIGNED_BYTE, text);
} else
gl2psTextOpt(text, GL2PS_FONT, static_cast(GL2PS_FONTSIZE*cex), gl2ps_centering, 0.0);
}
#endif
}
void GLBitmapFont::draw(const wchar_t* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {
#ifndef RGL_NO_OPENGL
if (justify(width(text), height(), adjx, adjy, adjz, pos, rc)) {
GLenum type = sizeof(wchar_t) == 4 ? GL_UNSIGNED_INT :
sizeof(wchar_t) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE ;
if (rc.gl2psActive == GL2PS_NONE) {
glListBase(listBase);
glCallLists(length, type, text);
}
// gl2ps doesn't support wchar_t? Should convert?
}
#endif
}
#ifdef HAVE_FREETYPE
GLFTFont::GLFTFont(const char* in_family, int in_style, double in_cex, const char* in_fontname)
: GLFont(in_family, in_style, in_cex, in_fontname, true)
{
font=new FTGLPixmapFont(fontname);
if (font->Error()) {
errmsg = "Cannot create Freetype font";
delete font;
font = NULL;
} else {
unsigned int size = static_cast(16*cex + 0.5);
if (size<1) { size=1; }
if (!font->FaceSize(size)) {
errmsg = "Cannot create Freetype font of requested size";
delete font;
font = NULL;
}
}
/* font->CharMap(ft_encoding_unicode);
if (font->Error()) {
error("Cannot set unicode encoding.");
}*/
}
GLFTFont::~GLFTFont()
{
if (font) delete font;
}
double GLFTFont::width(const char* text) {
return font->Advance(text);
}
double GLFTFont::width(const wchar_t* text) {
return font->Advance(text);
}
double GLFTFont::height() {
return font->Ascender();
}
void GLFTFont::draw(const char* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {
if ( justify( width(text), height(), adjx, adjy, adjz, pos, rc ) ) {
if (rc.gl2psActive == GL2PS_NONE)
font->Render(text);
else
gl2psTextOpt(text, GL2PS_FONT, static_cast(GL2PS_FONTSIZE*cex), gl2ps_centering, 0.0);
}
}
void GLFTFont::draw(const wchar_t* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {
if ( justify( width(text), height(), adjx, adjy, adjz, pos, rc ) ) {
if (rc.gl2psActive == GL2PS_NONE)
font->Render(text);
}
}
#endif
rgl/src/pretty.c 0000644 0001762 0000144 00000014624 14100762641 013330 0 ustar ligges users /* This file is taken from the R sources, r61744 of src/appl/pretty.c, with minimal changes */
#include "pretty.h"
#include
#include
#include
#include
/*
* R : A Computer Language for Statistical Data Analysis
* Copyright (C) 1995-2012 The R Core Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, a copy is available at
* http://www.r-project.org/Licenses/
*/
/* Pretty Intervals
* ----------------
* Constructs m "pretty" values which cover the given interval *lo <= *up
* m ~= *ndiv + 1 (i.e., ndiv := approximate number of INTERVALS)
*
* It is not quite clear what should happen for *lo = *up;
* S itself behaves quite funilly, then.
*
* In my opinion, a proper 'pretty' should always ensure
* *lo < *up, and hence *ndiv >=1 in the result.
* However, in S and here, we allow *lo == *up, and *ndiv = 0.
* Note however, that we are NOT COMPATIBLE to S. [Martin M.]
*
* NEW (0.63.2): ns, nu are double (==> no danger of integer overflow)
*
* We determine
* if the interval (up - lo) is ``small'' [<==> i_small == TRUE, below].
* For the ``i_small'' situation, there is a parameter shrink_sml,
* the factor by which the "scale" is shrunk. ~~~~~~~~~~
* It is advisable to set it to some (smaller) integer power of 2,
* since this enables exact floating point division.
*/
/* Leave out all the R includes that we can
#ifdef HAVE_CONFIG_H
#include
#endif
#ifdef ENABLE_NLS
#include
#define _(String) gettext (String)
#else
#define _(String) (String)
#endif
#include
#include
#include
#include
#include
#ifdef DEBUGpr
# include
#endif
#ifdef HAVE_VISIBILITY_ATTRIBUTE
# define attribute_hidden __attribute__ ((visibility ("hidden")))
#else
# define attribute_hidden
#endif
*/
/* non-API, used by rgl */
double R_pretty0(double *lo, double *up, int *ndiv, int min_n,
double shrink_sml, double high_u_fact[],
int eps_correction, int return_bounds)
{
/* From version 0.65 on, we had rounding_eps := 1e-5, before, r..eps = 0
* 1e-7 is consistent with seq.default() */
#define rounding_eps 1e-7
#define h high_u_fact[0]
#define h5 high_u_fact[1]
double dx, cell, unit, base, U;
double ns, nu;
int k;
Rboolean i_small;
dx = *up - *lo;
/* cell := "scale" here */
if(dx == 0 && *up == 0) { /* up == lo == 0 */
cell = 1;
i_small = TRUE;
} else {
cell = fmax2(fabs(*lo),fabs(*up));
/* U = upper bound on cell/unit */
U = (1 + (h5 >= 1.5*h+.5)) ? 1/(1+h) : 1.5/(1+h5);
/* added times 3, as several calculations here */
i_small = dx < cell * U * imax2(1,*ndiv) * DBL_EPSILON *3;
}
/*OLD: cell = FLT_EPSILON+ dx / *ndiv; FLT_EPSILON = 1.192e-07 */
if(i_small) {
if(cell > 10)
cell = 9 + cell/10;
cell *= shrink_sml;
if(min_n > 1) cell /= min_n;
} else {
cell = dx;
if(*ndiv > 1) cell /= *ndiv;
}
if(cell < 20*DBL_MIN) {
/* warning(_("Internal(pretty()): very small range.. corrected")); */
cell = 20*DBL_MIN;
} else if(cell * 10 > DBL_MAX) {
/* warning(_("Internal(pretty()): very large range.. corrected")); */
cell = .1*DBL_MAX;
}
base = pow(10., floor(log10(cell))); /* base <= cell < 10*base */
/* unit : from { 1,2,5,10 } * base
* such that |u - cell| is small,
* favoring larger (if h > 1, else smaller) u values;
* favor '5' more than '2' if h5 > h (default h5 = .5 + 1.5 h) */
unit = base;
if((U = 2*base)-cell < h*(cell-unit)) { unit = U;
if((U = 5*base)-cell < h5*(cell-unit)) { unit = U;
if((U =10*base)-cell < h*(cell-unit)) unit = U; }}
/* Result: c := cell, u := unit, b := base
* c in [ 1, (2+ h) /(1+h) ] b ==> u= b
* c in ( (2+ h)/(1+h), (5+2h5)/(1+h5)] b ==> u= 2b
* c in ( (5+2h)/(1+h), (10+5h) /(1+h) ] b ==> u= 5b
* c in ((10+5h)/(1+h), 10 ) b ==> u=10b
*
* ===> 2/5 *(2+h)/(1+h) <= c/u <= (2+h)/(1+h) */
ns = floor(*lo/unit+rounding_eps);
nu = ceil (*up/unit-rounding_eps);
#ifdef DEBUGpr
REprintf("pretty(lo=%g,up=%g,ndiv=%d,min_n=%d,shrink=%g,high_u=(%g,%g),"
"eps=%d)\n\t dx=%g; is.small:%d. ==> cell=%g; unit=%g\n",
*lo, *up, *ndiv, min_n, shrink_sml, h, h5,
eps_correction, dx, (int)i_small, cell, unit);
#endif
if(eps_correction && (eps_correction > 1 || !i_small)) {
if(*lo != 0.0) *lo *= (1- DBL_EPSILON); else *lo = -DBL_MIN;
if(*up != 0.0) *up *= (1+ DBL_EPSILON); else *up = +DBL_MIN;
}
#ifdef DEBUGpr
if(ns*unit > *lo)
REprintf("\t ns= %.0f -- while(ns*unit > *lo) ns--;\n", ns);
#endif
while(ns*unit > *lo + rounding_eps*unit) ns--;
#ifdef DEBUGpr
if(nu*unit < *up)
REprintf("\t nu= %.0f -- while(nu*unit < *up) nu++;\n", nu);
#endif
while(nu*unit < *up - rounding_eps*unit) nu++;
k = (int)(0.5 + nu - ns);
if(k < min_n) {
/* ensure that nu - ns == min_n */
#ifdef DEBUGpr
REprintf("\tnu-ns=%.0f-%.0f=%d SMALL -> ensure nu-ns= min_n=%d\n",
nu,ns, k, min_n);
#endif
k = min_n - k;
if(ns >= 0.) {
nu += k/2;
ns -= k/2 + k%2;/* ==> nu-ns = old(nu-ns) + min_n -k = min_n */
} else {
ns -= k/2;
nu += k/2 + k%2;
}
*ndiv = min_n;
}
else {
*ndiv = k;
}
if(return_bounds) { /* if()'s to ensure that result covers original range */
if(ns * unit < *lo) *lo = ns * unit;
if(nu * unit > *up) *up = nu * unit;
} else {
*lo = ns;
*up = nu;
}
#ifdef DEBUGpr
REprintf("\t ns=%.0f ==> lo=%g\n", ns, *lo);
REprintf("\t nu=%.0f ==> up=%g ==> ndiv = %d\n", nu, *up, *ndiv);
#endif
return unit;
#undef h
#undef h5
}
/*
attribute_hidden
void R_pretty(double *lo, double *up, int *ndiv, int *min_n,
double *shrink_sml, double *high_u_fact, int *eps_correction)
{
R_pretty0(lo, up, ndiv,
*min_n, *shrink_sml, high_u_fact, *eps_correction, 1);
}
*/
rgl/src/Color.cpp 0000644 0001762 0000144 00000012633 14100762641 013415 0 ustar ligges users #include "Color.h"
#include "types.h"
using namespace std;
#include
#include // for memcpy
using namespace rgl;
//
// COLOR UTILS
//
//
// FUNCTION
// HexCharToNibble
//
static u8 HexCharToNibble(char c) {
u8 nibble = 0;
if ((c >= '0') && (c <= '9'))
nibble = c - '0';
else if (( c >= 'A') && (c <= 'F'))
nibble = (c - 'A') + 10;
else if (( c >= 'a') && (c <= 'f'))
nibble = (c - 'a') + 10;
return nibble;
}
//
// FUNCTION
// StringToRGB8
//
static void StringToRGB8(const char* string, u8* colorptr) {
char* strptr = (char*) string;
int cnt = 0;
if (( *strptr++ == '#') && (cnt < 3)) {
char c;
while( (c = *strptr++) != '\0' ) {
u8 component;
component = static_cast(HexCharToNibble(c) << 4);
if ( (c = *strptr++) == '\0')
break;
component |= HexCharToNibble(c);
*colorptr++ = component; cnt++;
}
}
for(int i=cnt;i<3;i++)
*colorptr++ = 0x00;
}
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Color
//
//
Color::Color()
{
data[0] = 1.0f;
data[1] = 1.0f;
data[2] = 1.0f;
data[3] = 1.0f;
}
Color::Color(float red, float green, float blue, float alpha)
{
data[0] = red;
data[1] = green;
data[2] = blue;
data[3] = alpha;
}
Color::Color(u8 red, u8 green, u8 blue, u8 alpha)
{
data[0] = ((float)red)/255.0f;
data[1] = ((float)green)/255.0f;
data[2] = ((float)blue)/255.0f;
data[3] = ((float)alpha)/255.0f;
}
Color::Color(const char* string)
{
u8 tmp[4];
tmp[3] = 255;
StringToRGB8(string, tmp);
for (int i=0;i<4;i++)
data[i] = ((float)tmp[i])/255.0f;
}
void Color::set3iv(int* color)
{
data[0] = ((float)color[0])/255.0f;
data[1] = ((float)color[1])/255.0f;
data[2] = ((float)color[2])/255.0f;
data[3] = 1.0f;
}
// TODO: move to rendergl.cpp
#include "opengl.h"
void Color::useClearColor() const
{
#ifndef RGL_NO_OPENGL
glClearColor(data[0],data[1],data[2], data[3]);
#endif
}
void Color::useColor() const
{
#ifndef RGL_NO_OPENGL
glColor4fv(data);
#endif
}
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// ColorArray
//
ColorArray::ColorArray()
{
arrayptr = NULL;
ncolor = 0;
nalpha = 0;
}
ColorArray::ColorArray( Color& bg, Color &fg )
{
ncolor = 2;
nalpha = 2;
arrayptr = (u8*) realloc( NULL, sizeof(u8) * 4 * ncolor);
arrayptr[0] = bg.getRedub();
arrayptr[1] = bg.getBlueub();
arrayptr[2] = bg.getGreenub();
arrayptr[3] = bg.getAlphaub();
arrayptr[4] = fg.getRedub();
arrayptr[5] = fg.getBlueub();
arrayptr[6] = fg.getGreenub();
arrayptr[7] = fg.getAlphaub();
hint_alphablend = ( (bg.getAlphaub() < 255) || (fg.getAlphaub() < 255) ) ? true : false;
}
ColorArray::ColorArray( ColorArray& src ) {
ncolor = src.ncolor;
nalpha = src.nalpha;
hint_alphablend = src.hint_alphablend;
if (ncolor > 0) {
arrayptr = (u8*) realloc( NULL, sizeof(u8) * 4 * ncolor);
memcpy( arrayptr, src.arrayptr, sizeof(u8) * 4 * ncolor);
} else {
arrayptr = NULL;
}
}
ColorArray::~ColorArray() {
if (arrayptr)
free(arrayptr);
}
void ColorArray::set( int in_ncolor, char** in_color, int in_nalpha, double* in_alpha)
{
ncolor = getMax(in_ncolor, in_nalpha);
nalpha = in_nalpha;
u8* ptr = arrayptr = (u8*) realloc( arrayptr, sizeof(u8) * 4 * ncolor);
hint_alphablend = false;
for (unsigned int i=0;i 0) {
u8 alpha = (u8) ( clamp( (float) in_alpha[i%in_nalpha], 0.0f, 1.0f) * 255.0f );
if (alpha < 255)
hint_alphablend = true;
ptr[3] = alpha;
} else
ptr[3] = 0xFF;
ptr += 4;
}
}
void ColorArray::set( int in_ncolor, int* in_color, int in_nalpha, double* in_alpha)
{
ncolor = getMax(in_ncolor, in_nalpha);
nalpha = in_nalpha;
u8* ptr = arrayptr = (u8*) realloc( arrayptr, sizeof(u8) * 4 * ncolor);
hint_alphablend = false;
for (unsigned int i=0;i 0) {
u8 alpha = (u8) ( clamp( (float) in_alpha[i%in_nalpha], 0.0f, 1.0f) * 255.0f );
if (alpha < 255)
hint_alphablend = true;
ptr[3] = alpha;
} else
ptr[3] = 0xFF;
ptr += 4;
}
}
unsigned int ColorArray::getLength() const
{
return ncolor;
}
bool ColorArray::hasAlpha() const
{
return hint_alphablend;
}
void ColorArray::useArray() const
{
#ifndef RGL_NO_OPENGL
glColorPointer(4, GL_UNSIGNED_BYTE, 0, (const GLvoid*) arrayptr );
#endif
}
void ColorArray::useColor(int index) const
{
#ifndef RGL_NO_OPENGL
glColor4ubv( (const GLubyte*) &arrayptr[ index * 4] );
#endif
}
Color ColorArray::getColor(int index) const
{
return Color( arrayptr[index*4], arrayptr[index*4+1], arrayptr[index*4+2], arrayptr[index*4+3] );
}
void ColorArray::recycle(unsigned int newsize)
{
if (ncolor != newsize) {
if (ncolor > 1) {
if (newsize > 0) {
arrayptr = (u8*) realloc(arrayptr, sizeof(u8)*4*newsize);
for(unsigned int i=ncolor;i
#include
#endif
// ---------------------------------------------------------------------------
#ifdef RGL_W32
#include
#include
#include
#include
#include
#endif
// ---------------------------------------------------------------------------
#ifdef RGL_X11
#include
#include
#endif
#endif // RGL_NO_OPENGL
// ---------------------------------------------------------------------------
#endif // RGL_OPENGL_H
rgl/src/TextSet.cpp 0000644 0001762 0000144 00000010461 14142256754 013745 0 ustar ligges users #include "TextSet.h"
#include "glgui.h"
#include "R.h"
#include "BBoxDeco.h"
#include "subscene.h"
#ifdef HAVE_FREETYPE
#include
#endif
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// TextSet
//
// INTERNAL TEXTS STORAGE
// texts are copied to a buffer without null byte
// a separate length buffer holds string lengths in order
//
TextSet::TextSet(Material& in_material, int in_ntexts, char** in_texts, double *in_center,
double in_adjx, double in_adjy, double in_adjz,
int in_ignoreExtent, FontArray& in_fonts,
int in_npos,
const int* in_pos)
: Shape(in_material, in_ignoreExtent), textArray(in_ntexts, in_texts),
npos(in_npos)
{
int i;
material.lit = false;
material.colorPerVertex(false);
adjx = in_adjx;
adjy = in_adjy;
adjz = in_adjz;
// init vertex array
vertexArray.alloc(in_ntexts);
fonts = in_fonts;
#ifdef HAVE_FREETYPE
blended = true;
#endif
for (i=0;ivalid(textArray[i].text))
error("text %d contains unsupported character", i+1);
}
pos = new int[npos];
for (i=0; i= 0) {
Subscene* subscene = renderContext->subscene;
bboxdeco = subscene->get_bboxdeco();
}
GLFont* font;
Vertex pt = vertexArray[index];
if (bboxdeco)
pt = bboxdeco->marginVecToDataVec(pt, renderContext, &material);
if (!pt.missing()) {
GLboolean valid;
material.useColor(index);
glRasterPos3f( pt.x, pt.y, pt.z );
glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
if (valid) {
font = fonts[index % fonts.size()];
if (font) {
String text = textArray[index];
font->draw( text.text, text.length, adjx, adjy, adjz,
pos[index % npos], *renderContext );
}
}
}
#endif
}
void TextSet::drawEnd(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
material.endUse(renderContext);
Shape::drawEnd(renderContext);
#endif
}
int TextSet::getAttributeCount(AABox& bbox, AttribID attrib)
{
switch (attrib) {
case FAMILY:
case FONT:
case CEX: return static_cast(fonts.size());
case TEXTS:
case VERTICES: return textArray.size();
case ADJ: return 1;
case POS: return pos[0] ? npos : 0;
}
return Shape::getAttributeCount(bbox, attrib);
}
void TextSet::getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result)
{
int n = getAttributeCount(bbox, attrib);
if (first + count < n) n = first + count;
if (first < n) {
switch(attrib) {
case VERTICES:
while (first < n) {
*result++ = vertexArray[first].x;
*result++ = vertexArray[first].y;
*result++ = vertexArray[first].z;
first++;
}
return;
case CEX:
while (first < n)
*result++ = fonts[first++]->cex;
return;
case FONT:
while (first < n)
*result++ = fonts[first++]->style;
return;
case ADJ:
*result++ = adjx;
*result++ = adjy;
*result++ = adjz;
return;
case POS:
while (first < n)
*result++ = pos[first++];
return;
}
Shape::getAttribute(bbox, attrib, first, count, result);
}
}
String TextSet::getTextAttribute(AABox& bbox, AttribID attrib, int index)
{
int n = getAttributeCount(bbox, attrib);
if (index < n) {
switch (attrib) {
case TEXTS:
return textArray[index];
case FAMILY:
char* family = fonts[index]->family;
return String(static_cast(strlen(family)), family);
}
}
return Shape::getTextAttribute(bbox, attrib, index);
}
rgl/src/gl2ps.h 0000644 0001762 0000144 00000020644 14100762641 013034 0 ustar ligges users /*
* GL2PS, an OpenGL to PostScript Printing Library
* Copyright (C) 1999-2017 C. Geuzaine
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of either:
*
* a) the GNU Library General Public License as published by the Free
* Software Foundation, either version 2 of the License, or (at your
* option) any later version; or
*
* b) the GL2PS License as published by Christophe Geuzaine, either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See either
* the GNU Library General Public License or the GL2PS License for
* more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library in the file named "COPYING.LGPL";
* if not, write to the Free Software Foundation, Inc., 51 Franklin
* Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* You should have received a copy of the GL2PS License with this
* library in the file named "COPYING.GL2PS"; if not, I will be glad
* to provide one.
*
* For the latest info about gl2ps and a full list of contributors,
* see http://www.geuz.org/gl2ps/.
*
* Please report all bugs and problems to .
*/
#ifndef __GL2PS_H__
#define __GL2PS_H__
#ifndef RGL_NO_OPENGL
#include
#include
/* Define GL2PSDLL at compile time to build a Windows DLL */
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
# if defined(_MSC_VER)
# pragma warning(disable:4115)
# pragma warning(disable:4127)
# pragma warning(disable:4996)
# endif
# if !defined(NOMINMAX)
# define NOMINMAX
# include
# undef NOMINMAX
# else
# include
# endif
# if defined(GL2PSDLL)
# if defined(GL2PSDLL_EXPORTS)
# define GL2PSDLL_API __declspec(dllexport)
# else
# define GL2PSDLL_API __declspec(dllimport)
# endif
# else
# define GL2PSDLL_API
# endif
#else
# define GL2PSDLL_API
#endif
#if defined(__APPLE__) || defined(HAVE_OPENGL_GL_H)
#define GL_SILENCE_DEPRECATION
# include
#else
# include
#endif
/* Support for compressed PostScript/PDF/SVG and for embedded PNG
images in SVG */
#if defined(HAVE_ZLIB) || defined(HAVE_LIBZ)
# define GL2PS_HAVE_ZLIB
# if defined(HAVE_LIBPNG) || defined(HAVE_PNG)
# define GL2PS_HAVE_LIBPNG
# endif
#endif
#if defined(HAVE_NO_VSNPRINTF)
# define GL2PS_HAVE_NO_VSNPRINTF
#endif
/* Version number */
#define GL2PS_MAJOR_VERSION 1
#define GL2PS_MINOR_VERSION 4
#define GL2PS_PATCH_VERSION 0
#define GL2PS_EXTRA_VERSION ""
#define GL2PS_VERSION (GL2PS_MAJOR_VERSION + \
0.01 * GL2PS_MINOR_VERSION + \
0.0001 * GL2PS_PATCH_VERSION)
#define GL2PS_COPYRIGHT "(C) 1999-2017 C. Geuzaine"
/* Output file formats (the values and the ordering are important!) */
#define GL2PS_PS 0
#define GL2PS_EPS 1
#define GL2PS_TEX 2
#define GL2PS_PDF 3
#define GL2PS_SVG 4
#define GL2PS_PGF 5
/* Sorting algorithms */
#define GL2PS_NO_SORT 1
#define GL2PS_SIMPLE_SORT 2
#define GL2PS_BSP_SORT 3
/* Message levels and error codes */
#define GL2PS_SUCCESS 0
#define GL2PS_INFO 1
#define GL2PS_WARNING 2
#define GL2PS_ERROR 3
#define GL2PS_NO_FEEDBACK 4
#define GL2PS_OVERFLOW 5
#define GL2PS_UNINITIALIZED 6
/* Options for gl2psBeginPage */
#define GL2PS_NONE 0
#define GL2PS_DRAW_BACKGROUND (1<<0)
#define GL2PS_SIMPLE_LINE_OFFSET (1<<1)
#define GL2PS_SILENT (1<<2)
#define GL2PS_BEST_ROOT (1<<3)
#define GL2PS_OCCLUSION_CULL (1<<4)
#define GL2PS_NO_TEXT (1<<5)
#define GL2PS_LANDSCAPE (1<<6)
#define GL2PS_NO_PS3_SHADING (1<<7)
#define GL2PS_NO_PIXMAP (1<<8)
#define GL2PS_USE_CURRENT_VIEWPORT (1<<9)
#define GL2PS_COMPRESS (1<<10)
#define GL2PS_NO_BLENDING (1<<11)
#define GL2PS_TIGHT_BOUNDING_BOX (1<<12)
#define GL2PS_NO_OPENGL_CONTEXT (1<<13)
/* Arguments for gl2psEnable/gl2psDisable */
#define GL2PS_POLYGON_OFFSET_FILL 1
#define GL2PS_POLYGON_BOUNDARY 2
#define GL2PS_LINE_STIPPLE 3
#define GL2PS_BLEND 4
/* Arguments for gl2psLineCap/Join */
#define GL2PS_LINE_CAP_BUTT 0
#define GL2PS_LINE_CAP_ROUND 1
#define GL2PS_LINE_CAP_SQUARE 2
#define GL2PS_LINE_JOIN_MITER 0
#define GL2PS_LINE_JOIN_ROUND 1
#define GL2PS_LINE_JOIN_BEVEL 2
/* Text alignment (o=raster position; default mode is BL):
+---+ +---+ +---+ +---+ +---+ +---+ +-o-+ o---+ +---o
| o | o | | o | | | | | | | | | | | |
+---+ +---+ +---+ +-o-+ o---+ +---o +---+ +---+ +---+
C CL CR B BL BR T TL TR */
#define GL2PS_TEXT_C 1
#define GL2PS_TEXT_CL 2
#define GL2PS_TEXT_CR 3
#define GL2PS_TEXT_B 4
#define GL2PS_TEXT_BL 5
#define GL2PS_TEXT_BR 6
#define GL2PS_TEXT_T 7
#define GL2PS_TEXT_TL 8
#define GL2PS_TEXT_TR 9
typedef GLfloat GL2PSrgba[4];
typedef GLfloat GL2PSxyz[3];
typedef struct {
GL2PSxyz xyz;
GL2PSrgba rgba;
} GL2PSvertex;
/* Primitive types */
#define GL2PS_NO_TYPE -1
#define GL2PS_TEXT 1
#define GL2PS_POINT 2
#define GL2PS_LINE 3
#define GL2PS_QUADRANGLE 4
#define GL2PS_TRIANGLE 5
#define GL2PS_PIXMAP 6
#define GL2PS_IMAGEMAP 7
#define GL2PS_IMAGEMAP_WRITTEN 8
#define GL2PS_IMAGEMAP_VISIBLE 9
#define GL2PS_SPECIAL 10
#if defined(__cplusplus)
extern "C" {
#endif
GL2PSDLL_API GLint gl2psBeginPage(const char *title, const char *producer,
GLint viewport[4], GLint format, GLint sort,
GLint options, GLint colormode,
GLint colorsize, GL2PSrgba *colormap,
GLint nr, GLint ng, GLint nb, GLint buffersize,
FILE *stream, const char *filename);
GL2PSDLL_API GLint gl2psEndPage(void);
GL2PSDLL_API GLint gl2psSetOptions(GLint options);
GL2PSDLL_API GLint gl2psGetOptions(GLint *options);
GL2PSDLL_API GLint gl2psBeginViewport(GLint viewport[4]);
GL2PSDLL_API GLint gl2psEndViewport(void);
GL2PSDLL_API GLint gl2psText(const char *str, const char *fontname,
GLshort fontsize);
GL2PSDLL_API GLint gl2psTextOpt(const char *str, const char *fontname,
GLshort fontsize, GLint align, GLfloat angle);
GL2PSDLL_API GLint gl2psTextOptColor(const char *str, const char *fontname,
GLshort fontsize, GLint align, GLfloat angle,
GL2PSrgba color);
GL2PSDLL_API GLint gl2psSpecial(GLint format, const char *str);
GL2PSDLL_API GLint gl2psSpecialColor(GLint format, const char *str, GL2PSrgba rgba);
GL2PSDLL_API GLint gl2psDrawPixels(GLsizei width, GLsizei height,
GLint xorig, GLint yorig,
GLenum format, GLenum type, const void *pixels);
GL2PSDLL_API GLint gl2psEnable(GLint mode);
GL2PSDLL_API GLint gl2psDisable(GLint mode);
GL2PSDLL_API GLint gl2psPointSize(GLfloat value);
GL2PSDLL_API GLint gl2psLineCap(GLint value);
GL2PSDLL_API GLint gl2psLineJoin(GLint value);
GL2PSDLL_API GLint gl2psLineWidth(GLfloat value);
GL2PSDLL_API GLint gl2psBlendFunc(GLenum sfactor, GLenum dfactor);
/* referenced in the documentation, but not fully documented */
GL2PSDLL_API GLint gl2psForceRasterPos(GL2PSvertex *vert);
GL2PSDLL_API void gl2psAddPolyPrimitive(GLshort type, GLshort numverts,
GL2PSvertex *verts, GLint offset,
GLfloat ofactor, GLfloat ounits,
GLushort pattern, GLint factor,
GLfloat width, GLint linecap,
GLint linejoin, char boundary);
/* undocumented */
GL2PSDLL_API GLint gl2psDrawImageMap(GLsizei width, GLsizei height,
const GLfloat position[3],
const unsigned char *imagemap);
GL2PSDLL_API const char *gl2psGetFileExtension(GLint format);
GL2PSDLL_API const char *gl2psGetFormatDescription(GLint format);
GL2PSDLL_API GLint gl2psGetFileFormat();
#if defined(__cplusplus)
}
#endif
#endif
#endif /* __GL2PS_H__ */
rgl/src/ABCLineSet.h 0000644 0001762 0000144 00000002035 14100762641 013650 0 ustar ligges users #ifndef ABCLINESET_H
#define ABCLINESET_H
#include "scene.h"
#include "geom.h"
#include "Shape.h"
#include "PrimitiveSet.h"
#include
namespace rgl {
class ABCLineSet : public LineSet {
private: /* Use parametrization (x,y,z) + s*(a,b,c) */
int nLines;
ARRAY base; /* (x,y,z) */
ARRAY direction; /* (a,b,c) */
public:
ABCLineSet(Material& in_material, int in_nbase, double* in_base, int in_ndir, double* in_dir);
/**
* tell type.
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "abclines", buflen); };
/**
* overload to update segments first.
*/
virtual AABox& getBoundingBox(Subscene* subscene);
/**
* overload to update segments first.
*/
virtual void renderBegin(RenderContext* renderContext);
/**
* update mesh
*/
void updateSegments(const AABox& sceneBBox);
/**
* update then get attributes
*/
void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
};
} // namespace rgl
#endif // PLANESET_H
rgl/src/OpenGL/ 0000755 0001762 0000144 00000000000 14100762641 012752 5 ustar ligges users rgl/src/OpenGL/gl.h 0000644 0001762 0000144 00000006446 14100762641 013537 0 ustar ligges users #ifndef __gl_h_
#define __gl_h_
/* This is extracted from gl.h, part of OpenGL. The following is the
* original license statement from that file.
*/
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
*/
#include
typedef uint32_t GLbitfield;
typedef uint8_t GLboolean;
typedef uint32_t GLenum;
typedef float GLfloat;
typedef int32_t GLint;
typedef int16_t GLshort;
typedef int32_t GLsizei;
typedef uint32_t GLuint;
typedef uint16_t GLushort;
typedef double GLdouble;
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************/
/* AttribMask */
#define GL_DEPTH_BUFFER_BIT 0x00000100
#define GL_COLOR_BUFFER_BIT 0x00004000
/* BeginMode */
#define GL_POINTS 0x0000
#define GL_LINES 0x0001
#define GL_LINE_STRIP 0x0003
#define GL_TRIANGLES 0x0004
#define GL_QUADS 0x0007
/* Boolean */
#define GL_TRUE 1
#define GL_FALSE 0
/* ClipPlaneName */
#define GL_CLIP_PLANE0 0x3000
/* ErrorCode */
#define GL_NO_ERROR 0
/* PixelFormat */
#define GL_ALPHA 0x1906
#define GL_RGB 0x1907
#define GL_RGBA 0x1908
#define GL_LUMINANCE 0x1909
#define GL_LUMINANCE_ALPHA 0x190A
/* TextureMagFilter */
#define GL_NEAREST 0x2600
#define GL_LINEAR 0x2601
/* TextureMinFilter */
#define GL_NEAREST_MIPMAP_NEAREST 0x2700
#define GL_LINEAR_MIPMAP_NEAREST 0x2701
#define GL_NEAREST_MIPMAP_LINEAR 0x2702
#define GL_LINEAR_MIPMAP_LINEAR 0x2703
/*************************************************************/
#ifdef __cplusplus
}
#endif
#endif /* __gl_h_ */
rgl/src/geom.cpp 0000644 0001762 0000144 00000007731 14100762641 013271 0 ustar ligges users #include "geom.h"
#include "R.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// AABox
//
AABox::AABox()
{
invalidate();
}
void AABox::invalidate(void)
{
vmax = Vertex( -FLT_MAX, -FLT_MAX, -FLT_MAX );
vmin = Vertex( FLT_MAX, FLT_MAX, FLT_MAX );
}
void AABox::operator += (const Vertex& v)
{
if (!ISNAN(v.x)) {
vmin.x = getMin(vmin.x, v.x);
vmax.x = getMax(vmax.x, v.x);
}
if (!ISNAN(v.y)) {
vmin.y = getMin(vmin.y, v.y);
vmax.y = getMax(vmax.y, v.y);
}
if (!ISNAN(v.z)) {
vmin.z = getMin(vmin.z, v.z);
vmax.z = getMax(vmax.z, v.z);
}
}
void AABox::operator += (const AABox& aabox)
{
if (aabox.isValid()) {
*this += aabox.vmin;
*this += aabox.vmax;
}
}
void AABox::operator += (const Sphere& sphere)
{
*this += sphere.center - Vertex(sphere.radius,sphere.radius,sphere.radius);
*this += sphere.center + Vertex(sphere.radius,sphere.radius,sphere.radius);
}
bool AABox::operator < (const AABox& that) const
{
return true;
}
bool AABox::isValid(void) const
{
return ((vmax.x >= vmin.x) && (vmax.y >= vmin.y) && (vmax.z >= vmin.z)) ? true : false;
}
Vertex AABox::getCenter(void) const
{
return Vertex( (vmax + vmin) * 0.5f );
}
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Sphere
//
Sphere::Sphere(const AABox& bbox)
{
Vertex hdiagonal( (bbox.vmax - bbox.vmin) * 0.5f );
center = bbox.getCenter();
radius = hdiagonal.getLength();
}
Sphere::Sphere(const AABox& bbox, const Vertex& s)
{
Vertex hdiagonal( ((bbox.vmax - bbox.vmin) * 0.5f).scale(s) );
center = bbox.getCenter();
radius = hdiagonal.getLength();
}
Sphere::Sphere(const float in_radius)
: center(0.0f, 0.0f, 0.0f), radius(in_radius)
{
}
Sphere::Sphere(const Vertex& in_center, const float in_radius)
: center(in_center), radius(in_radius)
{
}
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Frustum
//
//
// setup frustum to enclose the space given by a bounding sphere,
// field-of-view angle and window size.
//
// window size is used to provide aspect ratio.
//
//
void Frustum::enclose(float sphere_radius, float fovangle, int width, int height)
{
float s=0.5, t=1.0;
if (fovangle != 0.0) {
float fovradians = math::deg2rad(fovangle/2.0f);
s = math::sin(fovradians);
t = math::tan(fovradians);
ortho = false;
} else {
ortho = true;
}
distance = sphere_radius / s;
znear = distance - sphere_radius;
zfar = znear + sphere_radius*2.0f;
float hlen = t * znear;
// hold aspect ratio 1:1
float hwidth, hheight;
bool inside = false;
if (inside) {
// inside bounding sphere: fit to max(winsize)
if (width >= height) {
hwidth = hlen;
hheight = hlen * ( (float)height ) / ( (float)width );
} else {
hwidth = hlen * ( (float)width ) / ( (float)height );
hheight = hlen;
}
} else {
// outside(in front of) bounding sphere: fit to min(winsize)
if (width >= height) {
hwidth = hlen * ( (float)width ) / ( (float)height );
hheight = hlen;
} else {
hwidth = hlen;
hheight = hlen * ( (float)height ) / ( (float)width );
}
}
left = -hwidth;
right = hwidth;
bottom = -hheight;
top = hheight;
}
Matrix4x4 Frustum::getMatrix()
{
double data[16];
memset(data, 0, sizeof(data));
if (ortho) {
data[0] = 2/(right - left);
data[5] = 2/(top - bottom);
data[10] = -2/(zfar - znear);
data[12] = -(right + left)/(right - left);
data[13] = -(top + bottom)/(top - bottom);
data[14] = -(zfar + znear)/(zfar - znear);
data[15] = 1;
} else {
data[0] = 2*znear/(right - left);
data[5] = 2*znear/(top - bottom);
data[8] = (right + left)/(right - left);
data[9] = (top + bottom)/(top - bottom);
data[10] = -(zfar + znear)/(zfar - znear);
data[11] = -1;
data[14] = -2*zfar*znear/(zfar - znear);
}
return Matrix4x4(data);
}
rgl/src/PlaneSet.h 0000644 0001762 0000144 00000002151 14100762641 013511 0 ustar ligges users #ifndef PLANESET_H
#define PLANESET_H
#include "scene.h"
#include "geom.h"
#include "Shape.h"
#include "PrimitiveSet.h"
#include
namespace rgl {
class PlaneSet : public TriangleSet {
private: /* Use parametrization ax + by + cz + d = 0 */
int nPlanes;
ARRAY normal; /* (a,b,c) */
ARRAY offset; /* d */
public:
PlaneSet(Material& in_material, int in_nnormal, double* in_normal, int in_noffset, double* in_offset);
// ~PlaneSet();
/**
* tell type.
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "planes", buflen); };
/**
* overload to update triangles first.
*/
virtual AABox& getBoundingBox(Subscene* subscene);
/**
* overload to update triangles first.
*/
virtual void renderBegin(RenderContext* renderContext);
/**
* update mesh
*/
void updateTriangles(const AABox& sceneBBox);
/**
* update then get attributes
*/
int getAttributeCount(AABox& bbox, AttribID attrib);
void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
};
} // namespace rgl
#endif // PLANESET_H
rgl/src/par3d.cpp 0000644 0001762 0000144 00000047522 14146464151 013362 0 ustar ligges users /* Avoid conflict with Rinternals.h */
// #undef DEBUG
#include "R.h"
#include "Rversion.h"
#include "DeviceManager.h"
#include "rglview.h"
#include "api.h"
/* These defines are not in the installed version of R */
#define _
#define streql(s, t) (!strcmp((s), (t)))
#include
#include
namespace rgl {
void getObserver(double* ddata, Subscene* subscene);
void setObserver(bool automatic, double* ddata, RGLView* rglview, Subscene* subscene);
}
using namespace rgl;
/* These two are currently exposed, because observer3d uses them. */
void rgl::getObserver(double* ddata, Subscene* subscene)
{
UserViewpoint* userviewpoint = subscene->getUserViewpoint();
Vertex res = userviewpoint->getObserver();
ddata[0] = res.x;
ddata[1] = res.y;
ddata[2] = res.z;
}
void rgl::setObserver(bool automatic, double* ddata, RGLView* rglview, Subscene* subscene)
{
UserViewpoint* userviewpoint = subscene->getUserViewpoint();
userviewpoint->setObserver(automatic, Vertex(static_cast(ddata[0]),
static_cast(ddata[1]),
static_cast(ddata[2])));
rglview->update();
}
/* These functions used to be in api.h and api.c, but are only accessed from par3d, so
have been made static */
static void getZoom(double* zoom, Subscene* subscene)
{
UserViewpoint* userviewpoint = subscene->getUserViewpoint();
*zoom = userviewpoint->getZoom();
CHECKGLERROR;
}
static void setZoom(double* zoom, RGLView* rglview, Subscene* subscene)
{
UserViewpoint* userviewpoint = subscene->getUserViewpoint();
userviewpoint->setZoom(static_cast(*zoom) );
rglview->update();
CHECKGLERROR;
}
static void getFOV(double* fov, Subscene* subscene)
{
UserViewpoint* userviewpoint = subscene->getUserViewpoint();
*fov = userviewpoint->getFOV();
CHECKGLERROR;
}
static void setFOV(double* fov, RGLView* rglview, Subscene* sub)
{
UserViewpoint* userviewpoint = sub->getUserViewpoint();
userviewpoint->setFOV(static_cast(*fov));
rglview->update();
CHECKGLERROR;
}
static void getIgnoreExtent(int* ignoreExtent, Device* device)
{
*ignoreExtent = device->getIgnoreExtent();
CHECKGLERROR;
}
static void setIgnoreExtent(int* ignoreExtent, Device* device)
{
device->setIgnoreExtent(*ignoreExtent);
CHECKGLERROR;
}
static void getSkipRedraw(int* skipRedraw, Device* device)
{
*skipRedraw = device->getSkipRedraw();
CHECKGLERROR;
}
static void setSkipRedraw(int* skipRedraw, Device* device)
{
device->setSkipRedraw(*skipRedraw);
CHECKGLERROR;
}
static void getMouseMode(int *button, int* mode, Subscene* subscene)
{
*mode = static_cast( subscene->getMouseMode(*button) );
CHECKGLERROR;
}
static void setMouseMode(int* button, int* mode, RGLView* rglview, Subscene* subscene)
{
subscene->setMouseMode(*button, (MouseModeID)(*mode));
if (*button == bnNOBUTTON)
rglview->windowImpl->watchMouse(subscene->getRootSubscene()->mouseNeedsWatching());
CHECKGLERROR;
}
static void getUserMatrix(double* userMatrix, Subscene* subscene)
{
subscene->getUserMatrix(userMatrix);
CHECKGLERROR;
}
static void setUserMatrix(double* userMatrix, RGLView* rglview, Subscene* subscene)
{
subscene->setUserMatrix(userMatrix);
rglview->update();
CHECKGLERROR;
}
static void getUserProjection(double* userProjection, Subscene* subscene)
{
subscene->getUserProjection(userProjection);
CHECKGLERROR;
}
static void setUserProjection(double* userProjection, RGLView* rglview, Subscene* subscene)
{
subscene->setUserProjection(userProjection);
rglview->update();
CHECKGLERROR;
}
static void getPosition(double* position, Subscene* subscene)
{
subscene->getPosition(position);
CHECKGLERROR;
}
static void setPosition(double* position, RGLView* rglview, Subscene* subscene)
{
subscene->setPosition(position);
rglview->update()
CHECKGLERROR;
}
static void getScale(double* scale, Subscene* subscene)
{
subscene->getScale(scale);
}
static void setScale(double* scale, RGLView* rglview, Subscene* subscene)
{
subscene->setScale(scale);
rglview->update();
CHECKGLERROR;
}
static void setViewport(double* viewport, Device* device, RGLView* rglview, Subscene* subscene)
{
subscene = subscene->getMaster(EM_VIEWPORT);
int left, top, right, bottom;
double x, y, width, height;
if (subscene->getEmbedding(EM_VIEWPORT) == EMBED_REPLACE) {
device->getWindowRect(&left, &top, &right, &bottom);
width = right - left;
height = bottom - top;
bottom = 0;
left = 0;
} else {
left = subscene->getParent()->pviewport.x;
bottom = subscene->getParent()->pviewport.y;
width = subscene->getParent()->pviewport.width;
height = subscene->getParent()->pviewport.height;
}
x = (viewport[0]-left)/width;
y = (viewport[1]-bottom)/height;
width = viewport[2]/width;
height = viewport[3]/height;
subscene->setViewport(x, y, width, height);
rglview->update();
}
static void getViewport(int* viewport, Subscene* subscene)
{
viewport[0] = subscene->pviewport.x;
viewport[1] = subscene->pviewport.y;
viewport[2] = subscene->pviewport.width;
viewport[3] = subscene->pviewport.height;
CHECKGLERROR;
}
static void getWindowRect(int* rect, Device* device)
{
device->getWindowRect(rect, rect+1, rect+2, rect+3);
CHECKGLERROR;
}
static void setWindowRect(int* rect, Device* dev)
{
dev->setWindowRect(rect[0], rect[1], rect[2], rect[3]);
CHECKGLERROR;
}
static void getBoundingbox(double* bboxvec, Subscene* subscene)
{
const AABox& bbox = subscene->getBoundingBox();
bboxvec[0] = bbox.vmin.x;
bboxvec[1] = bbox.vmax.x;
bboxvec[2] = bbox.vmin.y;
bboxvec[3] = bbox.vmax.y;
bboxvec[4] = bbox.vmin.z;
bboxvec[5] = bbox.vmax.z;
CHECKGLERROR;
}
/* font access functions. These are only used from par3d */
static char* getFamily(RGLView* rglview)
{
const char* f = rglview->getFontFamily();
char* result;
result = R_alloc(strlen(f)+1, 1);
strcpy(result, f);
CHECKGLERROR;
return result;
}
static bool setFamily(const char *family, RGLView* rglview)
{
rglview->setFontFamily(family);
CHECKGLERROR;
return true;
}
static int getFont(RGLView* rglview)
{
int result = rglview->getFontStyle();
CHECKGLERROR;
return result;
}
static bool setFont(int font, RGLView* rglview)
{
rglview->setFontStyle(font);
CHECKGLERROR;
return true;
}
static double getCex(RGLView* rglview)
{
double result = rglview->getFontCex();
CHECKGLERROR;
return result;
}
static bool setCex(double cex, RGLView* rglview)
{
rglview->setFontCex(cex);
CHECKGLERROR;
return true;
}
static int getUseFreeType(RGLView* rglview)
{
int result = (int) rglview->getFontUseFreeType();
CHECKGLERROR;
return result;
}
static bool setUseFreeType(bool useFreeType, RGLView* rglview)
{
rglview->setFontUseFreeType(useFreeType);
CHECKGLERROR;
return true;
}
static char* getFontname(RGLView* rglview)
{
char* result = NULL;
const char* f = rglview->getFontname();
result = R_alloc(strlen(f)+1, 1);
strcpy(result, f);
CHECKGLERROR;
return result;
}
static int getAntialias(RGLView* rglview)
{
return rglview->windowImpl->getAntialias();
}
static int getMaxClipPlanes(RGLView* rglview)
{
return rglview->windowImpl->getMaxClipPlanes();
}
static double getGlVersion()
{
#ifndef RGL_NO_OPENGL
const char* version = (const char*)glGetString(GL_VERSION);
if (version) return atof(version);
else
#endif
return R_NaReal;
}
static int activeSubscene(RGLView* rglview)
{
return rglview->getActiveSubscene();
}
/* par3d implementation based on R's par implementation
*
* Main functions:
* par3d(.)
* Specify(.) [ par(what = value) ]
* Query(.) [ par(what) ]
*/
static void par_error(const char *what)
{
error(_("invalid value specified for rgl parameter \"%s\""), what);
}
static void lengthCheck(const char *what, SEXP v, int n)
{
if (length(v) != n)
error(_("parameter \"%s\" has the wrong length"), what);
}
static void dimCheck(const char *what, SEXP v, int r, int c)
{
SEXP dim = coerceVector(getAttrib(v, R_DimSymbol), INTSXP);
if (length(dim) != 2 || INTEGER(dim)[0] != r || INTEGER(dim)[1] != c)
error(_("parameter \"%s\" has the wrong dimension"), what);
}
#ifdef UNUSED
static void nonnegIntCheck(int x, const char *s)
{
if (x == NA_INTEGER || x < 0)
par_error(s);
}
static void posIntCheck(int x, const char *s)
{
if (x == NA_INTEGER || x <= 0)
par_error(s);
}
static void naIntCheck(int x, const char *s)
{
if (x == NA_INTEGER)
par_error(s);
}
#endif
static void posRealCheck(double x, const char *s)
{
if (!R_FINITE(x) || x <= 0)
par_error(s);
}
#ifdef UNUSED
static void nonnegRealCheck(double x, const char *s)
{
if (!R_FINITE(x) || x < 0)
par_error(s);
}
static void naRealCheck(double x, const char *s)
{
if (!R_FINITE(x))
par_error(s);
}
#endif
static void BoundsCheck(double x, double a, double b, const char *s)
{
/* Check if a <= x <= b */
if (!R_FINITE(x) || (R_FINITE(a) && x < a) || (R_FINITE(b) && x > b))
par_error(s);
}
/* These modes must match the definitions of mmTRACKBALL etc in rglview.h ! */
namespace rgl {
const char* mouseModes[] = {"none", "trackball", "xAxis", "yAxis", "zAxis", "polar", "selecting", "zoom", "fov", "user",
"push", "pull", "user2"};
const char* viewportlabels[] = {"x", "y", "width", "height"};
}
#define mmLAST 10
#define wmLAST 13
/* At R 2.6.0, the type of the first arg to psmatch changed to const char *. Conditionally cast
to char * if we're in an old version */
#if defined(R_VERSION) && R_VERSION < R_Version(2, 6, 0)
#define OLDCAST (char *)
#else
#define OLDCAST
#endif
static void Specify(Device* dev, RGLView* rglview, Subscene* sub, const char *what, SEXP value)
{
/* Do NOT forget to update ../R/par3d.R */
/* if you ADD a NEW par !!
*/
SEXP x;
double v;
int iv;
int success = 1;
if (streql(what, "FOV")) {
lengthCheck(what, value, 1); v = asReal(value);
BoundsCheck(v, 0.0, 179.0, what);
setFOV(&v, rglview, sub);
}
else if (streql(what, "ignoreExtent")) {
lengthCheck(what, value, 1); iv = asLogical(value);
setIgnoreExtent(&iv, dev);
}
else if (streql(what, "mouseMode")) {
PROTECT(value = coerceVector(value, STRSXP));
if (length(value) > 5) par_error(what);
for (int i=bnNOBUTTON; i<=bnWHEEL && i < length(value); i++) {
if (STRING_ELT(value, i) != NA_STRING) {
success = 0;
/* check exact first, then partial */
for (int mode = 0; mode < (i != bnWHEEL ? mmLAST : wmLAST) ; mode++) {
if (psmatch(OLDCAST mouseModes[mode], CHAR(STRING_ELT(value, i)), (Rboolean)TRUE)) {
setMouseMode(&i, &mode, rglview, sub);
success = 1;
break;
}
}
if (!success) {
for (int mode = 0; mode < (i != 4 ? mmLAST : wmLAST) ; mode++) {
if (psmatch(OLDCAST mouseModes[mode], CHAR(STRING_ELT(value, i)), (Rboolean)FALSE)) {
setMouseMode(&i, &mode, rglview, sub);
success = 1;
break;
}
}
}
if (!success) par_error(what);
}
}
UNPROTECT(1);
}
else if (streql(what, "listeners")) {
x = coerceVector(value, INTSXP);
rglview->setMouseListeners(sub, length(x), INTEGER(x));
}
else if (streql(what, "skipRedraw")) {
lengthCheck(what, value, 1); iv = asLogical(value);
setSkipRedraw(&iv, dev);
}
else if (streql(what, "userMatrix")) {
dimCheck(what, value, 4, 4);
x = coerceVector(value, REALSXP);
setUserMatrix(REAL(x), rglview, sub);
}
else if (streql(what, "userProjection")) {
dimCheck(what, value, 4, 4);
x = coerceVector(value, REALSXP);
setUserProjection(REAL(x), rglview, sub);
}
else if (streql(what, "scale")) {
lengthCheck(what, value, 3);
x = coerceVector(value, REALSXP);
setScale(REAL(x), rglview, sub);
}
else if (streql(what, "viewport")) {
lengthCheck(what, value, 4);
x = coerceVector(value, REALSXP);
setViewport(REAL(x), dev, rglview, sub);
}
else if (streql(what, "zoom")) {
lengthCheck(what, value, 1); v = asReal(value);
posRealCheck(v, what);
setZoom(&v, rglview, sub);
}
else if (streql(what, ".position")) {
lengthCheck(what, value, 2);
x = coerceVector(value, REALSXP);
setPosition(REAL(x), rglview, sub);
}
else if (streql(what, "windowRect")) {
lengthCheck(what, value, 4);
x = coerceVector(value, INTSXP);
setWindowRect(INTEGER(x), dev);
}
else if (streql(what, "family")) {
lengthCheck(what, value, 1);
x = coerceVector(value, STRSXP);
if (!setFamily(CHAR(STRING_ELT(x, 0)), rglview)) success = 0;
}
else if (streql(what, "font")) {
lengthCheck(what, value, 1);
x=coerceVector(value, INTSXP);
if (INTEGER(x)[0] < 1 || INTEGER(x)[0] > 5) { par_error(what); }
if (!setFont(INTEGER(x)[0], rglview)) success = 0;
}
else if (streql(what, "cex")) {
lengthCheck(what, value, 1);
x=coerceVector(value, REALSXP);
if (REAL(x)[0] <= 0) { par_error(what); }
if (!setCex(REAL(x)[0],rglview)) success = 0;
}
else if (streql(what, "useFreeType")) {
lengthCheck(what, value, 1);
PROTECT(x=coerceVector(value, LGLSXP));
#ifndef HAVE_FREETYPE
if (LOGICAL(x)[0] && strcmp( dev->getDevtype(), "null" ))
warning("FreeType not supported in this build");
#endif
if (!setUseFreeType(LOGICAL(x)[0], rglview)) success = 0;
UNPROTECT(1);
}
else warning(_("parameter \"%s\" cannot be set"), what);
if (!success) par_error(what);
return;
}
/* Do NOT forget to update ../R/par3d.R */
/* if you ADD a NEW par !! */
static SEXP Query(Device* dev, RGLView* rglview, Subscene* sub, const char *what)
{
SEXP value, names;
int i, mode, success = 1;
char* buf;
value = R_NilValue;
if (streql(what, "FOV")) {
PROTECT(value = allocVector(REALSXP, 1));
getFOV(REAL(value), sub);
}
else if (streql(what, "ignoreExtent")) {
PROTECT(value = allocVector(LGLSXP, 1));
getIgnoreExtent(LOGICAL(value), dev);
}
else if (streql(what, "modelMatrix")) {
PROTECT(value = allocMatrix(REALSXP, 4, 4));
sub->modelMatrix.getData(REAL(value));
}
else if (streql(what, "mouseMode")) {
PROTECT(value = allocVector(STRSXP, 5));
for (i=0; i<5; i++) {
getMouseMode(&i, &mode, sub);
if (mode < 0 || mode > wmLAST) mode = 0;
SET_STRING_ELT(value, i, mkChar(mouseModes[mode]));
}
PROTECT(names = allocVector(STRSXP, 5));
SET_STRING_ELT(names, 0, mkChar("none"));
SET_STRING_ELT(names, 1, mkChar("left"));
SET_STRING_ELT(names, 2, mkChar("right"));
SET_STRING_ELT(names, 3, mkChar("middle"));
SET_STRING_ELT(names, 4, mkChar("wheel"));
value = namesgets(value, names);
UNPROTECT(2); /* names and old values */
PROTECT(value);
}
else if (streql(what, "observer")) {
PROTECT(value = allocVector(REALSXP, 3));
rgl::getObserver(REAL(value), sub);
}
else if (streql(what, "projMatrix")) {
PROTECT(value = allocMatrix(REALSXP, 4, 4));
sub->projMatrix.getData(REAL(value));
}
else if (streql(what, "listeners")) {
PROTECT(value = allocVector(INTSXP, sub->mouseListeners.size()));
sub->getMouseListeners(length(value), INTEGER(value));
}
else if (streql(what, "skipRedraw")) {
PROTECT(value = allocVector(LGLSXP, 1));
getSkipRedraw(LOGICAL(value), dev);
}
else if (streql(what, "userMatrix")) {
PROTECT(value = allocMatrix(REALSXP, 4, 4));
getUserMatrix(REAL(value), sub);
}
else if (streql(what, "userProjection")) {
PROTECT(value = allocMatrix(REALSXP, 4, 4));
getUserProjection(REAL(value), sub);
}
else if (streql(what, "scale")) {
PROTECT(value = allocVector(REALSXP, 3));
getScale(REAL(value), sub);
}
else if (streql(what, "viewport")) {
PROTECT(value = allocVector(INTSXP, 4));
getViewport(INTEGER(value), sub);
PROTECT(names = allocVector(STRSXP, 4));
for (i=0; i<4; i++)
SET_STRING_ELT(names, i, mkChar(viewportlabels[i]));
value = namesgets(value, names);
UNPROTECT(2);
PROTECT(value);
}
else if (streql(what, "zoom")) {
PROTECT(value = allocVector(REALSXP, 1));
getZoom(REAL(value), sub);
}
else if (streql(what, "bbox")) {
PROTECT(value = allocVector(REALSXP, 6));
getBoundingbox(REAL(value), sub);
}
else if (streql(what, ".position")) {
PROTECT(value = allocVector(REALSXP, 2));
getPosition(REAL(value), sub);
}
else if (streql(what, "windowRect")) {
PROTECT(value = allocVector(INTSXP, 4));
getWindowRect(INTEGER(value), dev);
}
else if (streql(what, "family")) {
buf = getFamily(rglview);
if (buf) {
value = mkString(buf);
}
PROTECT(value);
}
else if (streql(what, "font")) {
PROTECT(value = allocVector(INTSXP, 1));
INTEGER(value)[0] = getFont(rglview);
success = INTEGER(value)[0] >= 0;
}
else if (streql(what, "cex")) {
PROTECT(value = allocVector(REALSXP, 1));
REAL(value)[0] = getCex(rglview);
success = REAL(value)[0] >= 0;
}
else if (streql(what, "useFreeType")) {
int useFreeType = getUseFreeType(rglview);
PROTECT(value = allocVector(LGLSXP, 1));
if (useFreeType < 0) {
LOGICAL(value)[0] = false;
success = 0;
} else {
LOGICAL(value)[0] = (bool)useFreeType;
}
}
else if (streql(what, "fontname")) {
buf = getFontname(rglview);
if (buf) {
value = mkString(buf);
}
PROTECT(value);
}
else if (streql(what, "antialias")) {
PROTECT(value = allocVector(INTSXP, 1));
INTEGER(value)[0] = getAntialias(rglview);
}
else if (streql(what, "maxClipPlanes")) {
PROTECT(value = allocVector(INTSXP, 1));
INTEGER(value)[0] = getMaxClipPlanes(rglview);
}
else if (streql(what, "glVersion")) {
PROTECT(value = allocVector(REALSXP, 1));
REAL(value)[0] = getGlVersion();
}
else if (streql(what, "activeSubscene")) {
PROTECT(value = allocVector(INTSXP, 1));
INTEGER(value)[0] = activeSubscene(rglview);
} else
PROTECT(value);
UNPROTECT(1);
if (! success) error(_("unknown error getting rgl parameter \"%s\""), what);
return value;
}
namespace rgl {
extern DeviceManager* deviceManager;
}
SEXP rgl::rgl_par3d(SEXP device, SEXP subscene, SEXP args)
{
Device* dev;
if (!deviceManager || !(dev = deviceManager->getDevice(asInteger(device))))
error(_("rgl device %d cannot be found"), asInteger(device));
RGLView* rglview = dev->getRGLView();
Scene* scene = rglview->getScene();
Subscene* sub = scene->getSubscene(asInteger(subscene));
if (!sub)
error(_("rgl subscene %d cannot be found"), asInteger(subscene));
SEXP value;
int nargs;
nargs = length(args);
if (isNewList(args)) {
SEXP oldnames, newnames, tag, val;
int i;
PROTECT(newnames = allocVector(STRSXP, nargs));
PROTECT(value = allocVector(VECSXP, nargs));
PROTECT(oldnames = getAttrib(args, R_NamesSymbol));
for (i = 0 ; i < nargs ; i++) {
if (oldnames != R_NilValue)
tag = STRING_ELT(oldnames, i);
else
tag = R_NilValue;
val = VECTOR_ELT(args, i);
if (tag != R_NilValue && CHAR(tag)[0]) {
SET_VECTOR_ELT(value, i, Query(dev, rglview, sub, CHAR(tag)));
SET_STRING_ELT(newnames, i, tag);
Specify(dev, rglview, sub, CHAR(tag), val);
CHECKGLERROR;
}
else if (isString(val) && length(val) > 0) {
tag = STRING_ELT(val, 0);
if (tag != R_NilValue && CHAR(tag)[0]) {
SET_VECTOR_ELT(value, i, Query(dev, rglview, sub, CHAR(tag)));
SET_STRING_ELT(newnames, i, tag);
CHECKGLERROR;
}
}
else {
SET_VECTOR_ELT(value, i, R_NilValue);
SET_STRING_ELT(newnames, i, R_BlankString);
}
}
setAttrib(value, R_NamesSymbol, newnames);
UNPROTECT(3);
}
else {
error(_("invalid parameter passed to par3d()"));
return R_NilValue/* -Wall */;
}
return value;
}
rgl/src/rglview.cpp 0000644 0001762 0000144 00000032125 14137472630 014022 0 ustar ligges users // C++ source
// This file is part of RGL.
//
#ifdef __sun
#include
#else
#include
#endif
#include
#include "rglview.h"
#include "opengl.h"
#include "lib.h"
#include "rglmath.h"
#include "pixmap.h"
#include "fps.h"
#include "gl2ps.h"
#include "R.h" // for error()
using namespace rgl;
RGLView::RGLView(Scene* in_scene)
: View(0,0,256,256,0), autoUpdate(false)
{
scene = in_scene;
flags = 0;
renderContext.rect.x = 0;
renderContext.rect.y = 0; // size is set elsewhere
activeSubscene = 0;
}
RGLView::~RGLView()
{
}
void RGLView::show()
{
fps.init( getTime() );
}
void RGLView::hide()
{
autoUpdate=false;
}
void RGLView::setWindowImpl(WindowImpl* impl) {
View::setWindowImpl(impl);
#if defined HAVE_FREETYPE
renderContext.font = impl->getFont("sans", 1, 1, true);
#else
renderContext.font = impl->fonts[0];
#endif
}
Scene* RGLView::getScene() {
return scene;
}
void RGLView::resize(int in_width, int in_height) {
View::resize(in_width, in_height);
renderContext.rect.width = in_width;
renderContext.rect.height = in_height;
update();
if (activeSubscene) {
Subscene* subscene = scene->getSubscene(activeSubscene);
if (subscene && subscene->drag)
captureLost();
}
}
void RGLView::paint(void) {
double last = renderContext.time;
double t = getTime();
double dt = (last != 0.0f) ? last - t : 0.0f;
renderContext.time = t;
renderContext.deltaTime = dt;
/* This doesn't do any actual plotting, but it calculates matrices etc.,
and may call user callbacks */
int saveRedraw = windowImpl->setSkipRedraw(1);
scene->update(&renderContext);
windowImpl->setSkipRedraw(saveRedraw);
#ifndef RGL_NO_OPENGL
/* This section does the OpenGL plotting */
if (windowImpl->beginGL()) {
SAVEGLERROR;
Subscene* subscene = scene->getCurrentSubscene();
scene->render(&renderContext);
glViewport(0,0, width, height);
if (subscene) {
if (flags & FSHOWFPS && subscene->getSelectState() == msNONE)
fps.render(renderContext.time, &renderContext );
}
glFinish();
windowImpl->endGL();
SAVEGLERROR;
}
#endif
}
//////////////////////////////////////////////////////////////////////////////
//
// user input
//
// NB: This code has to deal with three conflicting descriptions of pixel locations.
// The calls to buttonPress, buttonRelease, etc. are given in OS window-relative
// coordinates, which count mouseX from the left, mouseY down from the top.
// These are translated into the OpenGL convention which counts Y up from the bottom,
// or subscene-relative coordinates, up from the bottom of the viewport.
// We use RGLView::translateCoords to go from OS window-relative to OpenGL window-relative,
// and Subscene::translateCoords to go from OpenGL window-relative to viewport-relative.
void RGLView::keyPress(int key)
{
switch(key) {
case GUI_KeyF1:
flags ^= FSHOWFPS;
windowImpl->update();
break;
case GUI_KeyESC:
Subscene* subscene = scene->getCurrentSubscene();
if (subscene)
subscene->setSelectState(msABORT);
break;
}
}
void RGLView::buttonPress(int button, int mouseX, int mouseY)
{
ModelViewpoint* modelviewpoint = scene->getCurrentSubscene()->getModelViewpoint();
if ( modelviewpoint->isInteractive() ) {
translateCoords(&mouseX, &mouseY);
Subscene* subscene = scene->whichSubscene(mouseX, mouseY);
subscene->translateCoords(&mouseX, &mouseY);
subscene->drag = button;
activeSubscene = subscene->getObjID();
windowImpl->captureMouse(this);
subscene->buttonBegin(button ,mouseX, mouseY);
View::update();
}
}
void RGLView::buttonRelease(int button, int mouseX, int mouseY)
{
Subscene* subscene;
if (activeSubscene
&& (subscene = scene->getSubscene(activeSubscene))) {
windowImpl->releaseMouse();
subscene->drag = 0;
subscene->buttonEnd(button);
View::update();
}
// Rprintf("release happened, activeSubscene=0\n");
activeSubscene = 0;
}
void RGLView::mouseMove(int mouseX, int mouseY)
{
if (activeSubscene) {
translateCoords(&mouseX, &mouseY);
Subscene* subscene = scene->getSubscene(activeSubscene);
if (!subscene) {
buttonRelease(0, mouseX, mouseY);
return;
}
subscene->translateCoords(&mouseX, &mouseY);
int vwidth = subscene->pviewport.width,
vheight = subscene->pviewport.height;
mouseX = clamp(mouseX, 0, vwidth-1);
mouseY = clamp(mouseY, 0, vheight-1);
if (windowImpl->beginGL()) {
subscene->buttonUpdate(subscene->drag, mouseX, mouseY);
windowImpl->endGL();
View::update();
}
} else {
ModelViewpoint* modelviewpoint = scene->getCurrentSubscene()->getModelViewpoint();
if ( modelviewpoint->isInteractive() ) {
translateCoords(&mouseX, &mouseY);
Subscene* subscene = scene->whichSubscene(mouseX, mouseY);
if (subscene && subscene->getMouseMode(bnNOBUTTON) != mmNONE) {
subscene->translateCoords(&mouseX, &mouseY);
subscene->drag = bnNOBUTTON;
subscene->buttonUpdate(bnNOBUTTON, mouseX, mouseY);
View::update();
}
}
}
}
void RGLView::wheelRotate(int dir, int mouseX, int mouseY)
{
Subscene* subscene = NULL;
ModelViewpoint* modelviewpoint = scene->getCurrentSubscene()->getModelViewpoint();
if ( modelviewpoint->isInteractive() ) {
translateCoords(&mouseX, &mouseY);
subscene = scene->whichSubscene(mouseX, mouseY);
}
if (!subscene)
subscene = scene->getCurrentSubscene();
subscene->wheelRotate(dir);
View::update();
}
void RGLView::captureLost()
{
if (activeSubscene) {
Subscene* subscene = scene->getSubscene(activeSubscene);
if (subscene) {
subscene->buttonEnd(subscene->drag);
subscene->drag = 0;
}
}
}
//
// snapshot
//
bool RGLView::snapshot(PixmapFileFormatID formatID, const char* filename)
{
bool success = false;
if ( (formatID < PIXMAP_FILEFORMAT_LAST) && (pixmapFormat[formatID])) {
// alloc pixmap memory
Pixmap snapshot;
if (snapshot.init(RGB24, width, height, 8)) {
#ifndef RGL_NO_OPENGL
paint();
if ( windowImpl->beginGL() ) {
// read back buffer
glPushAttrib(GL_PIXEL_MODE_BIT);
glReadBuffer(GL_BACK);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0,0,width,height,GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*) snapshot.data);
glPopAttrib();
windowImpl->endGL();
} else
#else
warning("this build of rgl does not support snapshots");
#endif
snapshot.clear();
success = snapshot.save( pixmapFormat[formatID], filename );
} else error("unable to create pixmap");
} else error("pixmap save format not supported in this build");
return success;
}
bool RGLView::pixels( int* ll, int* size, int component, double* result )
{
bool success = false;
#ifndef RGL_NO_OPENGL
GLenum format[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA,
GL_DEPTH_COMPONENT, GL_LUMINANCE};
paint();
if ( windowImpl->beginGL() ) {
/*
* Some OSX systems appear to have a glReadPixels
* bug causing segfaults when reading the depth component.
* Read those column by column.
*/
bool bycolumn = format[component] == GL_DEPTH_COMPONENT;
int n = bycolumn ? size[1] : size[0]*size[1];
GLfloat* buffer = (GLfloat*) R_alloc(n, sizeof(GLfloat));
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
// read front buffer
glPushAttrib(GL_PIXEL_MODE_BIT);
glReadBuffer(GL_BACK);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
if (bycolumn) {
for(int ix=0; ixendGL();
}
#endif
return success;
}
void RGLView::getUserMatrix(double* dest)
{
Subscene* subscene = NULL;
if (activeSubscene)
subscene = scene->getSubscene(activeSubscene);
if (!subscene)
subscene = scene->getCurrentSubscene();
ModelViewpoint* modelviewpoint = subscene->getModelViewpoint();
modelviewpoint->getUserMatrix(dest);
}
void RGLView::setUserMatrix(double* src)
{
Subscene* subscene = NULL;
if (activeSubscene)
subscene = scene->getSubscene(activeSubscene);
if (!subscene)
subscene = scene->getCurrentSubscene();
subscene->setUserMatrix(src);
View::update();
}
void RGLView::getScale(double* dest)
{
Subscene* subscene = NULL;
if (activeSubscene)
subscene = scene->getSubscene(activeSubscene);
if (!subscene)
subscene = scene->getCurrentSubscene();
ModelViewpoint* modelviewpoint = subscene->getModelViewpoint();
modelviewpoint->getScale(dest);
}
void RGLView::setScale(double* src)
{
Subscene* subscene = NULL;
if (activeSubscene)
subscene = scene->getSubscene(activeSubscene);
if (!subscene)
subscene = scene->getCurrentSubscene();
subscene->setScale(src);
View::update();
}
void RGLView::setDefaultFont(const char* family, int style, double cex, bool useFreeType)
{
GLFont* font = View::windowImpl->getFont(family, style, cex, useFreeType);
if (!font)
error("font not available");
renderContext.font = font;
}
const char* RGLView::getFontFamily() const
{
if (!renderContext.font)
error("font not available");
return renderContext.font->family;
}
void RGLView::setFontFamily(const char *family)
{
setDefaultFont(family, getFontStyle(), getFontCex(), getFontUseFreeType());
}
int RGLView::getFontStyle() const
{
if (!renderContext.font)
error("font not available");
return renderContext.font->style;
}
void RGLView::setFontStyle(int style)
{
setDefaultFont(getFontFamily(), style, getFontCex(), getFontUseFreeType());
}
double RGLView::getFontCex() const
{
if (!renderContext.font)
error("font not available");
return renderContext.font->cex;
}
void RGLView::setFontCex(double cex)
{
setDefaultFont(getFontFamily(), getFontStyle(), cex, getFontUseFreeType());
}
const char* RGLView::getFontname() const
{
if (!renderContext.font)
error("font not available");
return renderContext.font->fontname;
}
bool RGLView::getFontUseFreeType() const
{
if (!renderContext.font)
error("font not available");
return renderContext.font->useFreeType;
}
void RGLView::setFontUseFreeType(bool useFreeType)
{
setDefaultFont(getFontFamily(), getFontStyle(), getFontCex(), useFreeType);
}
void RGLView::getPosition(double* dest)
{
Subscene* subscene = NULL;
if (activeSubscene)
subscene = scene->getSubscene(activeSubscene);
if (!subscene)
subscene = scene->getCurrentSubscene();
ModelViewpoint* modelviewpoint = subscene->getModelViewpoint();
modelviewpoint->getPosition(dest);
}
void RGLView::setPosition(double* src)
{
Subscene* subscene = NULL;
if (activeSubscene)
subscene = scene->getSubscene(activeSubscene);
if (!subscene)
subscene = scene->getCurrentSubscene();
ModelViewpoint* modelviewpoint = subscene->getModelViewpoint();
modelviewpoint->setPosition(src);
}
bool RGLView::postscript(int formatID, const char* filename, bool drawText)
{
bool success = false;
std::FILE *fp = fopen(filename, "wb");
#ifndef RGL_NO_OPENGL
char *oldlocale = setlocale(LC_NUMERIC, "C");
GLint buffsize = 0, state = GL2PS_OVERFLOW;
GLint vp[4];
GLint options = GL2PS_SILENT | GL2PS_SIMPLE_LINE_OFFSET | GL2PS_NO_BLENDING |
GL2PS_OCCLUSION_CULL | GL2PS_BEST_ROOT;
if (!drawText) options |= GL2PS_NO_TEXT;
if (windowImpl->beginGL()) {
glGetIntegerv(GL_VIEWPORT, vp);
while( state == GL2PS_OVERFLOW ){
buffsize += 1024*1024;
gl2psBeginPage ( filename, "Generated by rgl", vp,
formatID, GL2PS_BSP_SORT, options,
GL_RGBA, 0, NULL, 0, 0, 0, buffsize,
fp, filename );
if ( drawText ) {
// signal gl2ps for text
scene->invalidateDisplaylists();
if (formatID == GL2PS_PS || formatID == GL2PS_EPS ||
formatID == GL2PS_TEX || formatID == GL2PS_PGF)
renderContext.gl2psActive = GL2PS_POSITIONAL;
else
renderContext.gl2psActive = GL2PS_LEFT_ONLY;
}
// redraw:
scene->render(&renderContext);
glFinish();
if ( drawText ) {
scene->invalidateDisplaylists();
renderContext.gl2psActive = GL2PS_NONE;
}
success = true;
state = gl2psEndPage();
}
windowImpl->endGL();
}
setlocale(LC_NUMERIC, oldlocale);
#else
warning("this build of rgl does not support postscript");
#endif
fclose(fp);
return success;
}
void RGLView::setMouseListeners(Subscene* sub, unsigned int n, int* ids)
{
sub->clearMouseListeners();
for (unsigned int i=0; igetSubscene(ids[i]);
if (subscene)
sub->addMouseListener(subscene);
}
}
rgl/src/subscene.h 0000644 0001762 0000144 00000024443 14142256754 013626 0 ustar ligges users #ifndef SUBSCENE_H
#define SUBSCENE_H
#include "Shape.h"
#include "ClipPlane.h"
#include "Viewpoint.h"
#include "Background.h"
#include "BBoxDeco.h"
#include "Light.h"
#include
namespace rgl {
enum Embedding { EMBED_INHERIT=1, EMBED_MODIFY, EMBED_REPLACE };
enum Embedded { EM_VIEWPORT = 0, EM_PROJECTION, EM_MODEL, EM_MOUSEHANDLERS};
enum ButtonID {bnNOBUTTON = 0, bnLEFT, bnRIGHT, bnMIDDLE, bnWHEEL};
enum MouseModeID {mmNONE = 0, mmTRACKBALL, mmXAXIS, mmYAXIS, mmZAXIS, mmPOLAR,
mmSELECTING, mmZOOM, mmFOV, mmUSER, wmPUSH, wmPULL, wmUSER2};
enum MouseSelectionID {msNONE=1, msCHANGING, msDONE, msABORT};
typedef void (*userControlPtr)(void *userData, int mouseX, int mouseY);
typedef void (*userControlEndPtr)(void *userData);
typedef void (*userCleanupPtr)(void **userData);
typedef void (*userWheelPtr)(void *userData, int dir);
typedef void (Subscene::*viewControlPtr)(int mouseX,int mouseY);
typedef void (Subscene::*viewControlEndPtr)();
typedef void (Subscene::*viewWheelPtr)(int dir);
class Subscene : public SceneNode {
/* Subscenes do their own projection. They can inherit, modify or replace the
viewport, projection and model matrices. The root viewport always replaces them,
since it doesn't have anything to inherit.
*/
private:
void setupViewport(RenderContext* rctx);
void setupProjMatrix(RenderContext* rctx, const Sphere& viewSphere);
void setupModelMatrix(RenderContext* rctx, Vertex center);
void setupModelViewMatrix(RenderContext* rctx, Vertex center);
void setDefaultMouseMode();
void disableLights(RenderContext* rctx);
void setupLights(RenderContext* rctx);
void newEmbedding();
/* These lists contain pointers to lights and shapes, but don't actually manage them: the Scene does that. */
std::vector lights;
std::vector shapes;
std::vector unsortedShapes;
std::vector zsortShapes;
std::vector clipPlanes;
/* Subscenes form a tree; this is the parent subscene. The root has a NULL parent. */
Subscene* parent;
/* Here are the children */
std::vector subscenes;
UserViewpoint* userviewpoint;
ModelViewpoint* modelviewpoint;
/**
* bounded background
**/
Background* background;
/**
* bounded decorator
**/
BBoxDeco* bboxdeco;
/**
* How is this subscene embedded in its parent?
**/
Embedding do_viewport, do_projection, do_model, do_mouseHandlers;
/**
* This viewport on the (0,0) to (1,1) scale
**/
Rect2d viewport;
public:
Subscene(Embedding in_viewport, Embedding in_projection, Embedding in_model,
Embedding in_mouseHandlers, bool in_ignoreExtent);
virtual ~Subscene( );
bool add(SceneNode* node);
void addBackground(Background* newbackground);
void addBBoxDeco(BBoxDeco* bboxdeco);
void addShape(Shape* shape);
void addLight(Light* light);
void addSubscene(Subscene* subscene);
void addBBox(const AABox& bbox, bool changes);
void intersectClipplanes(void);
/**
* hide shape or light or bboxdeco
**/
void hideShape(int id);
void hideLight(int id);
void hideBBoxDeco(int id);
void hideBackground(int id);
Subscene* hideSubscene(int id, Subscene* current);
void hideViewpoint(int id);
/**
* recursive search for subscene; could return self, or NULL if not found
**/
Subscene* getSubscene(int id);
Subscene* whichSubscene(int id); /* which subscene holds this */
Subscene* whichSubscene(int mouseX, int mouseY); /* coordinates are pixels within the window */
/* And here is the root */
Subscene* getRootSubscene();
/**
* get parent, or NULL for the root
**/
Subscene* getParent() const { return parent; }
/**
* get children
**/
size_t getChildCount() const { return subscenes.size(); }
Subscene* getChild(int which) const { return subscenes[which]; }
/**
* obtain bounding box
**/
const AABox& getBoundingBox() const { return data_bbox; }
/**
* get the bbox
*/
BBoxDeco* get_bboxdeco();
/**
* get a bbox
*/
BBoxDeco* get_bboxdeco(int id);
/**
* get the background
*/
Background* get_background() const { return background; }
/**
* get a background
*/
Background* get_background(int id);
/**
* obtain subscene's axis-aligned bounding box.
**/
const AABox& getBoundingBox();
/**
* get information about stacks
*/
int get_id_count(TypeID type, bool recursive);
int get_ids(TypeID type, int* ids, char** types, bool recursive);
virtual int getAttributeCount(AABox& bbox, AttribID attrib);
virtual void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
virtual String getTextAttribute(AABox& bbox, AttribID attrib, int index);
/* Update matrices etc. in preparation for rendering */
void update(RenderContext* renderContext);
/* load the matrices into OpenGL */
void loadMatrices();
/* Do the OpenGL rendering */
void render(RenderContext* renderContext, bool opaquePass);
void renderClipplanes(RenderContext* renderContext);
void disableClipplanes(RenderContext* renderContext);
void renderUnsorted(RenderContext* renderContext);
void renderZsort(RenderContext* renderContext);
/**
* Get and set flag to ignore elements in bounding box
**/
int getIgnoreExtent(void) const { return (int) ignoreExtent; }
void setIgnoreExtent(int in_ignoreExtent);
void setEmbedding(int which, Embedding value); /* which is 0=viewport, 1=projection, 2=model */
Embedding getEmbedding(Embedded which);
Subscene* getMaster(Embedded which);
void setUserMatrix(double* src);
void setUserProjection(double* src);
void setScale(double* src);
void setViewport(double x, double y, double width, double height); /* Sets relative (i.e. [0,1]x[0,1]) viewport size */
void setPosition(double* src);
void getUserMatrix(double* dest);
void getUserProjection(double* dest);
void getScale(double* dest);
void getPosition(double* dest);
double* getMousePosition();
void clearMouseListeners();
void addMouseListener(Subscene* sub);
void deleteMouseListener(Subscene* sub);
void getMouseListeners(size_t max, int* ids);
float getDistance(const Vertex& v) const;
// Translate from OpenGL window-relative coordinates (relative to bottom left corner of window) to
// viewport relative (relative to bottom left corner of viewport)
void translateCoords(int* mouseX, int* mouseY) const { *mouseX = *mouseX - pviewport.x; *mouseY = *mouseY - pviewport.y; }
UserViewpoint* getUserViewpoint();
ModelViewpoint* getModelViewpoint();
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "subscene", buflen); };
Background* get_background();
/* This vector lists other subscenes that will be controlled
by mouse actions on this one. We need to delete
those entries if the subscene is deleted! */
std::vector mouseListeners;
// These are set after rendering the scene
Vec4 Zrow;
Vec4 Wrow;
Matrix4x4 modelMatrix, projMatrix;
Rect2 pviewport; // viewport in pixels
/**
* mouse support
*/
void buttonBegin(int button, int mouseX, int mouseY);
void buttonUpdate(int button, int mouseX, int mouseY);
void buttonEnd(int button);
MouseModeID needsBegin;
bool mouseNeedsWatching();
void wheelRotate(int dir);
MouseModeID getMouseMode(int button);
void setMouseMode(int button, MouseModeID mode);
void setMouseCallbacks(int button, userControlPtr begin, userControlPtr update,
userControlEndPtr end, userCleanupPtr cleanup, void** user);
void getMouseCallbacks(int button, userControlPtr *begin, userControlPtr *update,
userControlEndPtr *end, userCleanupPtr *cleanup, void** user);
void setWheelCallback(userWheelPtr wheel, void* user);
void getWheelCallback(userWheelPtr *wheel, void** user);
// o DRAG FEATURE: mouseSelection
int drag;
double mousePosition[4];
void mouseSelectionBegin(int mouseX,int mouseY);
void mouseSelectionUpdate(int mouseX,int mouseY);
void mouseSelectionEnd();
MouseSelectionID getSelectState();
void setSelectState(MouseSelectionID state);
private:
/**
* compute bounding-box
**/
void calcDataBBox();
/**
* shrink bounding-box when something has been removed
**/
void shrinkBBox();
/**
* bounding box of subscene
**/
AABox data_bbox;
bool ignoreExtent;
bool bboxChanges;
/**
* mouse support
*/
viewControlPtr ButtonBeginFunc[5], ButtonUpdateFunc[5];
viewControlEndPtr ButtonEndFunc[5];
viewWheelPtr WheelRotateFunc;
viewControlPtr getButtonBeginFunc(int button);
viewControlPtr getButtonUpdateFunc(int button);
viewControlEndPtr getButtonEndFunc(int button);
MouseModeID mouseMode[5];
MouseSelectionID selectState;
void noneBegin(int mouseX, int mouseY) {};
void noneUpdate(int mouseX, int mouseY) {};
void noneEnd() {};
// o DRAG FEATURE: adjustDirection
void polarBegin(int mouseX, int mouseY);
void polarUpdate(int mouseX, int mouseY);
void polarEnd();
void trackballBegin(int mouseX, int mouseY);
void trackballUpdate(int mouseX, int mouseY);
void trackballEnd();
void oneAxisBegin(int mouseX, int mouseY);
void oneAxisUpdate(int mouseX, int mouseY);
void wheelRotateNone(int dir) {};
void wheelRotatePull(int dir);
void wheelRotatePush(int dir);
PolarCoord camBase, dragBase, dragCurrent;
Vertex rotBase, rotCurrent, axis[3];
// o DRAG FEATURE: adjustZoom
void adjustZoomBegin(int mouseX, int mouseY);
void adjustZoomUpdate(int mouseX, int mouseY);
void adjustZoomEnd();
int zoomBaseY;
// o DRAG FEATURE: adjustFOV (field of view)
void adjustFOVBegin(int mouseX, int mouseY);
void adjustFOVUpdate(int mouseX, int mouseY);
void adjustFOVEnd();
int fovBaseY;
// o DRAG FEATURE: user supplied callback
void userBegin(int mouseX, int mouseY);
void userUpdate(int mouseX, int mouseY);
void userEnd();
bool busy;
int activeButton;
void* wheelData;
userWheelPtr wheelCallback;
void userWheel(int dir);
void* userData[15];
userControlPtr beginCallback[5], updateCallback[5];
userControlEndPtr endCallback[5];
userCleanupPtr cleanupCallback[5];
};
} // namespace rgl
#endif // SUBSCENE_H
rgl/src/ClipPlane.h 0000644 0001762 0000144 00000002446 14100762641 013654 0 ustar ligges users #ifndef CLIPPLANE_H
#define CLIPPLANE_H
#include "geom.h"
#include "Shape.h"
#include "PrimitiveSet.h"
#include
namespace rgl {
class ClipPlaneSet : public Shape {
private: /* Use parametrization ax + by + cz + d = 0 */
int nPlanes;
GLenum firstPlane;
ARRAY normal; /* (a,b,c) */
ARRAY offset; /* d */
public:
ClipPlaneSet(Material& in_material, int in_nnormal, double* in_normal, int in_noffset, double* in_offset);
// ~PlaneSet();
static int num_planes; // clip plane count for drawing; set to 0 initially, incremented
// as each plane is added or drawn.
/**
* tell type.
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "clipplanes", buflen); };
virtual void renderBegin(RenderContext* renderContext);
virtual void drawPrimitive(RenderContext* renderContext, int index);
virtual int getElementCount(void) { return nPlanes; }
virtual int getAttributeCount(AABox& bbox, AttribID attrib);
virtual void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
void enable(bool show); // after it has been drawn, this enables it or disables it
bool isClipPlane(void) { return true; }
void intersectBBox(AABox& bbox);
};
} // namespace rgl
#endif // CLIPPLANE_H
rgl/src/select.cpp 0000644 0001762 0000144 00000001170 14100762641 013610 0 ustar ligges users // C++ source
// This file is part of RGL.
//
#include "select.h"
#include
using namespace rgl;
void SELECT::render(double* position)
{
#ifndef RGL_NO_OPENGL
GLdouble llx, lly, urx, ury;
llx = *position;
lly = *(position+1);
urx = *(position+2);
ury = *(position+3);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f,1.0f,0.0f,1.0f,0.0f,1.0f);
glColor3f(0.5f,0.5f,0.5f);
glLineWidth(2.0);
glBegin(GL_LINE_LOOP);
glVertex2d(llx, lly);
glVertex2d(llx, ury);
glVertex2d(urx, ury);
glVertex2d(urx, lly);
glEnd();
#endif
}
rgl/src/pretty.h 0000644 0001762 0000144 00000000471 14100762641 013330 0 ustar ligges users #ifndef RGL_PRETTY_H
#define RGL_PRETTY_H
#ifdef __cplusplus
extern "C" {
#endif
double R_pretty0(double *lo, double *up, int *ndiv, int min_n,
double shrink_sml, double high_u_fact[],
int eps_correction, int return_bounds);
#ifdef __cplusplus
}
#endif
#endif /* RGL_API_H */
rgl/src/Texture.cpp 0000644 0001762 0000144 00000015414 14145464133 014003 0 ustar ligges users
#include "Texture.h"
#include "pixmap.h"
#include "config.h"
#include "platform.h"
#include "RenderContext.h"
using namespace std;
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Texture
//
Texture::Texture(
const char* in_filename
, Type in_type
, bool in_mipmap
, unsigned int in_minfilter
, unsigned int in_magfilter
, bool in_envmap)
{
texName = 0;
pixmap = new Pixmap();
type = in_type;
mipmap = in_mipmap;
envmap = in_envmap;
magfilter = (in_magfilter) ? GL_LINEAR : GL_NEAREST;
if (mipmap) {
switch(in_minfilter) {
case 0:
minfilter = GL_NEAREST;
break;
case 1:
minfilter = GL_LINEAR;
break;
case 2:
minfilter = GL_NEAREST_MIPMAP_NEAREST;
break;
case 3:
minfilter = GL_NEAREST_MIPMAP_LINEAR;
break;
case 4:
minfilter = GL_LINEAR_MIPMAP_NEAREST;
break;
default:
minfilter = GL_LINEAR_MIPMAP_LINEAR;
break;
}
} else {
switch(in_minfilter) {
case 0:
minfilter = GL_NEAREST;
break;
default:
minfilter = GL_LINEAR;
break;
}
}
filename = new char [1 + strlen(in_filename)];
memcpy(filename, in_filename, 1 + strlen(in_filename));
if ( !pixmap->load(filename) ) {
delete pixmap;
pixmap = NULL;
}
}
Texture::~Texture()
{
#ifndef RGL_NO_OPENGL
if (texName) {
glDeleteTextures(1, &texName);
}
#endif
if (pixmap)
delete pixmap;
if (filename)
delete[] filename;
}
bool Texture::isValid() const
{
return (pixmap) ? true : false;
}
void Texture::getParameters(Type *out_type, bool *out_mipmap,
unsigned int *out_minfilter, unsigned int *out_magfilter,
bool *out_envmap, int buflen, char *out_filename)
{
*out_type = type;
*out_mipmap = mipmap;
switch(minfilter) {
case GL_NEAREST:
*out_minfilter = 0;
break;
case GL_LINEAR:
*out_minfilter = 1;
break;
case GL_NEAREST_MIPMAP_NEAREST:
*out_minfilter = 2;
break;
case GL_NEAREST_MIPMAP_LINEAR:
*out_minfilter = 3;
break;
case GL_LINEAR_MIPMAP_NEAREST:
*out_minfilter = 4;
break;
case GL_LINEAR_MIPMAP_LINEAR:
*out_minfilter = 5;
break;
default:
*out_minfilter = 6;
break;
}
*out_magfilter = (magfilter == GL_LINEAR) ? 1 : 0;
*out_envmap = envmap;
strncpy(out_filename, filename, buflen);
}
#ifndef MODERN_OPENGL
#ifndef RGL_NO_OPENGL
static unsigned int texsize(unsigned int s)
{
return 1U << msb(s-1);
}
#include "lib.h"
static void printGluErrorMessage(GLint error)
{
const GLubyte* gluError;
char buf[256];
gluError = gluErrorString (error);
sprintf(buf, "GLU Library Error : %s", (const char*) gluError);
printMessage(buf);
}
#endif
#endif
void Texture::init(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
glGenTextures(1, &texName);
glBindTexture(GL_TEXTURE_2D, texName);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minfilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magfilter);
GLint internalFormat = 0;
GLenum format = 0;
GLint ualign;
unsigned int bytesperpixel = 0;
switch(type)
{
case ALPHA:
internalFormat = GL_ALPHA;
break;
case LUMINANCE:
internalFormat = GL_LUMINANCE;
break;
case LUMINANCE_ALPHA:
internalFormat = GL_LUMINANCE_ALPHA;
break;
case RGB:
internalFormat = GL_RGB;
break;
case RGBA:
internalFormat = GL_RGBA;
break;
}
switch(pixmap->typeID)
{
case GRAY8:
ualign = 1;
bytesperpixel = 1;
switch(internalFormat)
{
case GL_LUMINANCE:
format = GL_LUMINANCE;
break;
case GL_ALPHA:
format = GL_ALPHA;
break;
case GL_LUMINANCE_ALPHA:
format = GL_LUMINANCE;
break;
}
break;
case RGB24:
ualign = 1;
format = GL_RGB;
bytesperpixel = 3;
break;
case RGB32:
ualign = 2;
format = GL_RGB;
bytesperpixel = 4;
break;
case RGBA32:
ualign = 2;
format = GL_RGBA;
bytesperpixel = 4;
break;
default: // INVALID
return;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, ualign);
GLenum gl_type = GL_UNSIGNED_BYTE;
GLint glTexSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &glTexSize );
#ifdef MODERN_OPENGL
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, pixmap->width, pixmap->height, 0, format, gl_type , pixmap->data);
if (mipmap)
glGenerateMipmap(GL_TEXTURE_2D);
#else
unsigned int maxSize = static_cast(glTexSize);
if (mipmap) {
int gluError = gluBuild2DMipmaps(GL_TEXTURE_2D, internalFormat, pixmap->width, pixmap->height, format, gl_type, pixmap->data);
if (gluError)
printGluErrorMessage(gluError);
} else {
unsigned int width = texsize(pixmap->width);
unsigned int height = texsize(pixmap->height);
if ( (width > maxSize) || (height > maxSize) ) {
char buf[256];
sprintf(buf, "GL Library : Maximum texture size of %dx%d exceeded.\n(Perhaps enabling mipmapping could help.)", maxSize,maxSize);
printMessage(buf);
} else if ( (pixmap->width != width) || ( pixmap->height != height) ) {
char* data = new char[width * height * bytesperpixel];
int gluError = gluScaleImage(format, pixmap->width, pixmap->height, gl_type, pixmap->data, width, height, gl_type, data);
if (gluError)
printGluErrorMessage(gluError);
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, gl_type , data);
delete[] data;
} else {
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, pixmap->width, pixmap->height, 0, format, gl_type , pixmap->data);
}
}
#endif /* not MODERN_OPENGL */
if (envmap) {
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
}
#endif
if (pixmap) {
delete pixmap;
pixmap = NULL;
}
}
void Texture::beginUse(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
if (!texName) {
init(renderContext);
}
glPushAttrib(GL_TEXTURE_BIT|GL_ENABLE_BIT|GL_CURRENT_BIT);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBindTexture(GL_TEXTURE_2D, texName);
if (type == ALPHA) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
}
#endif
}
void Texture::endUse(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
glPopAttrib();
#endif
}
rgl/src/glgui.h 0000644 0001762 0000144 00000012052 14142256754 013117 0 ustar ligges users #ifndef GL_GUI_H
#define GL_GUI_H
// C++ header
// This file is part of rgl
#include "opengl.h"
#include
#ifdef HAVE_FREETYPE
#include "FTGL/ftgl.h"
#endif
#include "RenderContext.h"
namespace rgl {
// CLASS
// GLFont
//
class GLFont
{
public:
GLFont(const char* in_family, int in_style, double in_cex,
const char* in_fontname, bool in_useFreeType):
style(in_style), cex(in_cex), useFreeType(in_useFreeType)
{
family = new char[strlen(in_family) + 1];
memcpy(family, in_family, strlen(in_family) + 1);
fontname = new char[strlen(in_fontname) + 1];
memcpy(fontname, in_fontname, strlen(in_fontname) + 1);
};
virtual ~GLFont()
{
delete [] family;
delete [] fontname;
}
virtual void draw(const char* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) = 0;
virtual void draw(const wchar_t* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) = 0;
virtual double width(const char* text) = 0;
virtual double width(const wchar_t* text) = 0;
virtual double height() = 0;
virtual bool valid(const char* text) { return true; };
// justify returns false if justification puts the text outside the viewport
GLboolean justify(double width, double height,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc);
char* family;
int style;
double cex;
char* fontname;
bool useFreeType;
int gl2ps_centering;
private:
GLFont(const GLFont &);
GLFont &operator=(const GLFont &);
};
#define GL_BITMAP_FONT_FIRST_GLYPH 32
#define GL_BITMAP_FONT_LAST_GLYPH 127
#define GL_BITMAP_FONT_COUNT (GL_BITMAP_FONT_LAST_GLYPH-GL_BITMAP_FONT_FIRST_GLYPH+1)
#define GL2PS_FONT "Helvetica"
#define GL2PS_FONTSIZE 12
#define GL2PS_SCALING 0.8
#define GL2PS_NONE 0
#define GL2PS_LEFT_ONLY 1
#define GL2PS_POSITIONAL 2
//
// CLASS
// GLBitmapFont
//
class GLBitmapFont : public GLFont
{
public:
// Most initialization of this object is done by the system-specific driver
GLBitmapFont(const char* in_family, int in_style, double in_cex, const char* in_fontname):
GLFont(in_family, in_style, in_cex, in_fontname, false) {};
~GLBitmapFont();
void draw(const char* text, int length,
double adjx, double adjy, double adjz,
int draw, const RenderContext& rc);
void draw(const wchar_t* text, int length,
double adjx, double adjy, double adjz,
int draw, const RenderContext& rc);
double width(const char* text);
double width(const wchar_t* text);
double height();
bool valid(const char* text);
GLuint listBase;
GLuint firstGlyph;
GLuint nglyph;
unsigned int* widths;
unsigned int ascent;
};
//
// CLASS
// GLFTFont
//
class GLFTFont : public GLFont
{
public:
GLFTFont(const char* in_family, int in_style, double in_cex, const char* in_fontname);
~GLFTFont();
#ifdef HAVE_FREETYPE
void draw(const char* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc);
void draw(const wchar_t* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc);
double width(const char* text);
double width(const wchar_t* text);
double height();
FTFont *font;
const char *errmsg;
#endif
};
//
// CLASS
// NULLFont
//
class NULLFont : public GLFont
{
public:
NULLFont(const char* in_family, int in_style, double in_cex, bool useFreeType):
GLFont(in_family, in_style, in_cex, "NULL", useFreeType) {};
void draw(const char* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {};
void draw(const wchar_t* text, int length,
double adjx, double adjy, double adjz,
int pos, const RenderContext& rc) {};
double width(const char* text) {return 0.0;};
double width(const wchar_t* text) {return 0.0;};
double height() {return 0.0;};
};
/**
* FontArray
**/
typedef std::vector FontArray;
/* The macros below are taken from the R internationalization code, which
is marked
Copyright (C) 1995-1999, 2000-2007 Free Software Foundation, Inc.
*/
/* Pathname support.
ISSLASH(C) tests whether C is a directory separator character.
IS_ABSOLUTE_PATH(P) tests whether P is an absolute path. If it is not,
it may be concatenated to a directory pathname.
*/
#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__
/* Win32, Cygwin, OS/2, DOS */
# define ISSLASH(C) ((C) == '/' || (C) == '\\')
# define HAS_DEVICE(P) \
((((P)[0] >= 'A' && (P)[0] <= 'Z') || ((P)[0] >= 'a' && (P)[0] <= 'z')) \
&& (P)[1] == ':')
# define IS_ABSOLUTE_PATH(P) (ISSLASH ((P)[0]) || HAS_DEVICE (P))
#else
/* Unix */
# define ISSLASH(C) ((C) == '/')
# define IS_ABSOLUTE_PATH(P) ISSLASH ((P)[0])
#endif
} // namespace rgl
#endif /* GL_GUI_H */
rgl/src/gui.cpp 0000644 0001762 0000144 00000022462 14137472630 013132 0 ustar ligges users // C++ source
// This file is part of RGL.
//
// ---------------------------------------------------------------------------
#include "gui.h"
#include "lib.h"
#include "R.h"
using namespace rgl;
// ---------------------------------------------------------------------------
// WindowImpl common code
// ---------------------------------------------------------------------------
void WindowImpl::getFonts(FontArray& outfonts, int nfonts, char** family, int* style,
double* cex, bool useFreeType)
{
GLFont* font;
outfonts.resize(nfonts);
for (int i = 0; i < nfonts; i++) {
font = getFont(*(family++), *(style++), *(cex++), useFreeType);
outfonts[i] = font;
}
}
int WindowImpl::setSkipRedraw(int in_skipRedraw)
{
int result = 0;
if (window) {
result = window->getSkipRedraw();
window->setSkipRedraw(in_skipRedraw, 0);
}
return result;
}
// ---------------------------------------------------------------------------
// View Implementation
// ---------------------------------------------------------------------------
View::View()
: baseX(0)
, baseY(0)
, width(0)
, height(0)
, flags(0)
, windowImpl(0)
{ }
// ---------------------------------------------------------------------------
View::View(int inBaseX, int inBaseY, int inWidth, int inHeight, int inFlags)
: baseX(inBaseX)
, baseY(inBaseY)
, width(inWidth)
, height(inHeight)
, flags(inFlags)
, windowImpl(0)
{
}
// ---------------------------------------------------------------------------
View::~View()
{
if ((windowImpl) && (flags & WINDOW_IMPL_OWNER)) {
windowImpl->unbind();
windowImpl->destroy();
windowImpl = 0;
}
}
// ---------------------------------------------------------------------------
void View::setSize(int inWidth, int inHeight)
{
if ((windowImpl) && (flags & WINDOW_IMPL_OWNER)) {
int left, top, right, bottom;
windowImpl->getWindowRect(&left, &top, &right, &bottom);
windowImpl->setWindowRect(left, top, left+inWidth, top+inHeight);
} else
resize(inWidth, inHeight);
}
// ---------------------------------------------------------------------------
void View::setLocation(int inBaseX, int inBaseY)
{
if ((windowImpl) && (flags & WINDOW_IMPL_OWNER)) {
int left, top, right, bottom;
windowImpl->getWindowRect(&left, &top, &right, &bottom);
windowImpl->setWindowRect(inBaseX, inBaseY, inBaseX + left-right, inBaseY + bottom-top);
} else
relocate(inBaseX, inBaseY);
}
// ---------------------------------------------------------------------------
void View::update(void)
{
if (windowImpl)
windowImpl->update();
}
// ---------------------------------------------------------------------------
void View::setWindowImpl(WindowImpl* inWindowImpl)
{
windowImpl = inWindowImpl;
}
// ---------------------------------------------------------------------------
void View::show(void)
{
}
// ---------------------------------------------------------------------------
void View::hide(void)
{
}
// ---------------------------------------------------------------------------
void View::paint(void)
{
}
// ---------------------------------------------------------------------------
void View::resize(int inWidth, int inHeight)
{
width = inWidth;
height = inHeight;
}
// ---------------------------------------------------------------------------
void View::relocate(int inBaseX, int inBaseY)
{
baseX = inBaseX;
baseY = inBaseY;
}
// ---------------------------------------------------------------------------
void View::keyPress(int code)
{
}
// ---------------------------------------------------------------------------
void View::keyRelease(int code)
{
}
// ---------------------------------------------------------------------------
void View::buttonPress(int button, int mouseX, int mouseY)
{
}
// ---------------------------------------------------------------------------
void View::buttonRelease(int button, int mouseX, int mouseY)
{
}
// ---------------------------------------------------------------------------
void View::mouseMove(int mouseX, int mouseY)
{
}
// ---------------------------------------------------------------------------
void View::wheelRotate(int direction, int mouseX, int mouseY)
{
}
// ---------------------------------------------------------------------------
void View::captureLost()
{
}
// ---------------------------------------------------------------------------
// Window Implementation
// ---------------------------------------------------------------------------
Window::Window(View* in_child, GUIFactory* factory)
: View(0,0,in_child->width, in_child->height,WINDOW_IMPL_OWNER)
, child(in_child)
, title("untitled")
{
skipRedraw = false;
if (!factory){
return;
}
windowImpl = factory->createWindowImpl(this);
if (!windowImpl) {
return;
}
if (child)
child->setWindowImpl(windowImpl);
}
// ---------------------------------------------------------------------------
Window::~Window()
{
if (child) {
delete child;
}
fireNotifyDisposed();
}
// ---------------------------------------------------------------------------
void Window::setWindowImpl(WindowImpl* impl)
{
View::setWindowImpl(impl);
if (child)
child->setWindowImpl(impl);
}
// ---------------------------------------------------------------------------
void Window::setTitle(const char* in_title)
{
if (windowImpl)
windowImpl->setTitle(in_title);
}
// ---------------------------------------------------------------------------
void Window::update(void)
{
windowImpl->update();
}
// ---------------------------------------------------------------------------
void Window::setVisibility(bool state)
{
if (state)
windowImpl->show();
else
windowImpl->hide();
}
// ---------------------------------------------------------------------------
void Window::bringToTop(int stay)
{
windowImpl->bringToTop(stay);
}
// ---------------------------------------------------------------------------
void Window::getWindowRect(int *in_left, int *in_top, int *in_width, int *in_height)
{
windowImpl->getWindowRect(in_left, in_top, in_width, in_height);
}
// ---------------------------------------------------------------------------
void Window::setWindowRect(int left, int top, int right, int bottom)
{
right = getMax(right, left + 1);
bottom = getMax(bottom, top + 1);
resize(right-left, bottom-top); // In case message never gets sent, e.g. Xvfb
windowImpl->setWindowRect(left, top, right, bottom);
}
// ---------------------------------------------------------------------------
int Window::getSkipRedraw(void)
{
return (int)skipRedraw;
}
// ---------------------------------------------------------------------------
void Window::setSkipRedraw(int in_skipRedraw, int doUpdate)
{
skipRedraw = (bool)in_skipRedraw;
if (!skipRedraw && doUpdate) update();
}
// ---------------------------------------------------------------------------
void Window::show(void)
{
if (child)
child->show();
}
// ---------------------------------------------------------------------------
void Window::hide(void)
{
if (child)
child->hide();
}
// ---------------------------------------------------------------------------
void Window::resize(int in_width, int in_height)
{
if (child)
child->resize(in_width,in_height);
}
// ---------------------------------------------------------------------------
void Window::paint(void)
{
if (child)
child->paint();
}
// ---------------------------------------------------------------------------
void Window::notifyDestroy(void)
{
if (child) {
delete child;
child = NULL;
}
fireNotifyDisposed();
}
// ---------------------------------------------------------------------------
void Window::buttonPress(int button, int mouseX, int mouseY)
{
if (child)
child->buttonPress(button, mouseX, mouseY);
}
// ---------------------------------------------------------------------------
void Window::buttonRelease(int button, int mouseX, int mouseY)
{
if (child)
child->buttonRelease(button, mouseX, mouseY);
}
// ---------------------------------------------------------------------------
void Window::mouseMove(int mouseX, int mouseY)
{
if (child)
child->mouseMove(mouseX, mouseY);
}
// ---------------------------------------------------------------------------
void Window::keyPress(int code)
{
if (child)
child->keyPress(code);
}
// ---------------------------------------------------------------------------
void Window::wheelRotate(int dir, int mouseX, int mouseY)
{
if (child)
child->wheelRotate(dir, mouseX, mouseY);
}
// ---------------------------------------------------------------------------
void Window::on_close()
{
windowImpl->destroy();
}
// ---------------------------------------------------------------------------
void Window::getFonts(FontArray& outfonts, int nfonts, char** family, int* style,
double* cex, bool useFreeType)
{
windowImpl->getFonts(outfonts, nfonts, family, style, cex, useFreeType);
}
// ---------------------------------------------------------------------------
int WindowImpl::getAntialias()
{
#ifndef RGL_NO_OPENGL
if (beginGL()) {
int result;
glGetIntegerv(GL_SAMPLES, &result);
endGL();
CHECKGLERROR;
return result;
}
#endif
return 1;
}
int WindowImpl::getMaxClipPlanes()
{
#ifndef RGL_NO_OPENGL
int result;
glGetError();
glGetIntegerv(GL_MAX_CLIP_PLANES, &result);
if (glGetError() == GL_NO_ERROR)
return result;
else
#endif
return 6;
}
rgl/src/pixmap.cpp 0000644 0001762 0000144 00000004734 14100762641 013640 0 ustar ligges users // C++ source
// This file is part of RGL.
//
#include
#include "pixmap.h"
using namespace std;
#include "lib.h"
// PNG FORMAT IMPLEMENTATION
using namespace rgl;
#ifdef HAVE_PNG_H
#include "pngpixmap.h"
namespace rgl {
PNGPixmapFormat png;
}
#endif
// PIXMAP FORMAT TABLE
PixmapFormat* rgl::pixmapFormat[PIXMAP_FILEFORMAT_LAST] =
{
// PNG FORMAT
#ifdef HAVE_PNG_H
&png,
#else
NULL,
#endif
};
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Pixmap
//
Pixmap::Pixmap()
{
typeID = INVALID;
width = 0;
height = 0;
bits_per_channel = 0;
data = NULL;
bytesperrow = 0;
}
Pixmap::~Pixmap()
{
if (data)
delete[] data;
}
bool Pixmap::init(PixmapTypeID in_typeID, int in_width, int in_height, int in_bits_per_channel)
{
if (data)
delete data;
typeID = in_typeID;
width = in_width;
height = in_height;
bits_per_channel = in_bits_per_channel;
int channels;
if (typeID == RGB24)
channels = 3;
else if (typeID == RGBA32)
channels = 4;
else if (typeID == GRAY8)
channels = 1;
else
return false;
bytesperrow = ( (channels * bits_per_channel) >> 3 ) * width;
data = new unsigned char [ bytesperrow * height ];
if (data)
return true;
else
return false;
}
void Pixmap::clear()
{
if (data)
memset(data, 0, bytesperrow * height);
}
bool Pixmap::load(const char* filename)
{
bool success = false;
std::FILE* file = NULL;
file = fopen(filename, "rb");
if (!file) {
char buffer[256];
sprintf(buffer, "Pixmap load: unable to open file '%s' for reading", filename);
printMessage(buffer);
return false;
}
bool support = false;
for(int i=0;icheckSignature(file) ) ) {
support = true;
success = format->load(file, this);
break;
}
}
if (!support) {
printMessage("Pixmap load: file format unsupported");
}
if (!success) {
printMessage("Pixmap load: failed");
}
fclose(file);
return success;
}
bool Pixmap::save(PixmapFormat* format, const char* filename)
{
std::FILE* file = NULL;
file = fopen(filename, "wb");
if (!file) {
char buffer[256];
sprintf(buffer, "Pixmap save: unable to open file '%s' for writing", filename);
printMessage(buffer);
return false;
}
bool success = format->save(file, this);
fclose(file);
return success;
}
rgl/src/assert.h 0000644 0001762 0000144 00000001626 14137472630 013313 0 ustar ligges users /*
* assert.hpp
* Based on assert.h from MinGW, which had the following notice:
* This file has no copyright assigned and is placed in the Public Domain.
* This file is a part of the mingw-runtime package.
* No warranty is given; refer to the file DISCLAIMER within the package.
*
* Define the assert macro for debug output.
*
*/
/* We should be able to include this file multiple times to allow the assert
macro to be enabled/disabled for different parts of code. So don't add a
header guard. */
#undef assert
#ifdef __cplusplus
extern "C" {
#endif
/*
#ifdef NDEBUG
* If not debugging, standard assert does nothing; ours always
* does the same.
#define assert(x) ((void)0)
#else
*/
void rgl_assert (const char*, const char*, int);
/*
* Definition of the assert macro.
*/
#define assert(e) ((e) ? (void)0 : rgl_assert(#e, __FILE__, __LINE__))
#ifdef __cplusplus
}
#endif
rgl/src/ABCLineSet.cpp 0000644 0001762 0000144 00000006144 14100762641 014210 0 ustar ligges users #include
#include "ABCLineSet.h"
#include "R.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// PlaneSet
//
ABCLineSet::ABCLineSet(Material& in_material, int in_nbase, double* in_base, int in_ndir, double* in_dir)
:
LineSet(in_material,true, false/* true */),
nLines(max(in_nbase, in_ndir)),
base(in_nbase, in_base),
direction(in_ndir, in_dir)
{
/* We'll set up 1 segment per line. Each segment has 2 vertices, and each vertex
gets 3 color components and 1 alpha component. */
ARRAY colors(3*nLines);
ARRAY alphas(nLines);
if (material.colors.getLength() > 1) {
material.colors.recycle(nLines);
for (int i=0; i vertices(6*nLines);
for (int i=0; igetBoundingBox());
return LineSet::getBoundingBox(subscene);
}
void ABCLineSet::renderBegin(RenderContext* renderContext)
{
updateSegments(renderContext->subscene->getBoundingBox());
invalidateDisplaylist();
LineSet::renderBegin(renderContext);
}
void ABCLineSet::updateSegments(const AABox& sceneBBox)
{
double bbox[2][3] = { {sceneBBox.vmin.x, sceneBBox.vmin.y, sceneBBox.vmin.z},
{sceneBBox.vmax.x, sceneBBox.vmax.y, sceneBBox.vmax.z} };
double x[2][3];
for (int elem = 0; elem < nLines; elem++) {
Vertex bv = base.getRecycled(elem);
double b[3] = { bv.x, bv.y, bv.z };
Vertex dv = direction.getRecycled(elem);
double d[3] = { dv.x, dv.y, dv.z };
// Rprintf("bbox min=%f %f %f max=%f %f %f\n", bbox[0][0], bbox[0][1], bbox[0][2],
// bbox[1][0], bbox[1][1], bbox[1][2]);
double smin = R_NegInf, smax = R_PosInf;
for (int i=0; i<3; i++) { // which coordinate
if (d[i] != 0) {
double s[2];
for (int j=0; j<2; j++) // which limit
s[j] = (bbox[j][i] - b[i])/d[i];
smin = max(smin, min(s[0], s[1]));
smax = min(smax, max(s[0], s[1]));
}
}
if (smin <= smax) {
for (int k=0; k<3; k++) {
x[0][k] = b[k] + smin*d[k];
x[1][k] = b[k] + smax*d[k];
}
setVertex(2*elem + 0, x[0]);
setVertex(2*elem + 1, x[1]);
} else {
double missing[3] = {NA_REAL, NA_REAL, NA_REAL};
setVertex(2*elem + 0, missing);
setVertex(2*elem + 1, missing);
}
}
}
void ABCLineSet::getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result)
{
updateSegments(bbox);
LineSet::getAttribute(bbox, attrib, first, count, result);
}
rgl/src/lib.h 0000644 0001762 0000144 00000000750 14100762641 012547 0 ustar ligges users #ifndef RGL_LIB_H
#define RGL_LIB_H
// ---------------------------------------------------------------------------
namespace rgl {
// ---------------------------------------------------------------------------
bool init(bool onlyNULLDevice);
const char * GUIFactoryName(bool useNULLDevice);
void quit();
void printMessage(const char* string);
double getTime();
// ---------------------------------------------------------------------------
} // namespace rgl
#endif // RGL_LIB_H
rgl/src/Light.cpp 0000644 0001762 0000144 00000005011 14100762641 013376 0 ustar ligges users #include "Light.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Light
//
Light::Light( PolarCoord in_position, Vertex in_finposition,
bool in_viewpoint, bool in_posisfinite,
Color in_ambient, Color in_diffuse, Color in_specular )
: SceneNode(LIGHT),
finposition(in_finposition),
ambient(in_ambient),
diffuse(in_diffuse),
specular(in_specular),
id(GL_FALSE),
viewpoint(in_viewpoint),
posisfinite(in_posisfinite)
{
if (posisfinite) {
position[0] = finposition.x;
position[1] = finposition.y;
position[2] = finposition.z;
position[3] = 1.0f;
} else {
Vertex v(0.0f, 0.0f, 1.0f);
v.rotateX( -in_position.phi );
v.rotateY( in_position.theta );
position[0] = v.x;
position[1] = v.y;
position[2] = v.z;
position[3] = 0.0f;
}
}
void Light::setup(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
glLightfv(id, GL_AMBIENT, ambient.data );
glLightfv(id, GL_DIFFUSE, diffuse.data );
glLightfv(id, GL_SPECULAR, specular.data );
glLightfv(id, GL_POSITION, position );
glLightf(id, GL_SPOT_EXPONENT, 0.0f);
glLightf(id, GL_SPOT_CUTOFF, 180.0f);
glLightf(id, GL_CONSTANT_ATTENUATION, 1.0f);
glLightf(id, GL_LINEAR_ATTENUATION, 0.0f);
glLightf(id, GL_QUADRATIC_ATTENUATION, 0.0f);
glEnable(id);
#endif
}
int Light::getAttributeCount(AABox& bbox, AttribID attrib)
{
switch (attrib) {
case COLORS: return 3;
case VERTICES: return 1;
case FLAGS: return 2;
}
return 0;
}
void Light::getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result)
{
int n = getAttributeCount(bbox, attrib);
if (first + count < n) n = first + count;
if (first < n) {
switch (attrib) {
case COLORS: {
while (first < n) {
Color color;
switch(first) {
case 0: color = ambient; break;
case 1: color = diffuse; break;
case 2: color = specular;break;
}
*result++ = color.data[0];
*result++ = color.data[1];
*result++ = color.data[2];
*result++ = color.data[3];
first++;
}
return;
}
case VERTICES: {
*result++ = position[0];
*result++ = position[1];
*result++ = position[2];
return;
}
case FLAGS: {
if (first == 0)
*result++ = (double) viewpoint;
*result++ = (double) posisfinite;
return;
}
}
}
}
rgl/src/BBoxDeco.h 0000644 0001762 0000144 00000004724 14145464133 013437 0 ustar ligges users #ifndef BBOX_DECO_H
#define BBOX_DECO_H
#include "SceneNode.h"
//
// CLASS
// BBoxDeco
//
#include "rglmath.h"
#include "geom.h"
#include "RenderContext.h"
#include "String.h"
#include "Material.h"
namespace rgl {
enum {
AXIS_CUSTOM, // "custom"
AXIS_LENGTH, // "fixednum"
AXIS_UNIT, // "fixedstep"
AXIS_PRETTY, // "pretty"
AXIS_USER, // "user"
AXIS_NONE // "none"
};
struct AxisInfo {
AxisInfo();
AxisInfo(int in_nticks, double* in_values, char** in_texts, int xlen, float xunit);
AxisInfo(AxisInfo& from);
~AxisInfo();
void draw(RenderContext* renderContext, Vertex4& v, Vertex4& dir, Matrix4x4& modelview,
Vertex& marklen, String& string);
int getNticks(float low, float high);
double getTick(float low, float high, int index); /* double since it might be NA_REAL */
int mode;
int nticks;
float* ticks;
StringArray textArray;
int len;
float unit;
};
typedef void (*userAxisPtr)(void *userData, int axis, int edge[3]);
class BBoxDeco : public SceneNode
{
public:
BBoxDeco(Material& in_material=defaultMaterial, AxisInfo& xaxis=defaultAxis, AxisInfo& yaxis=defaultAxis, AxisInfo& zaxis=defaultAxis, float marklen=15.0, bool marklen_fract=true,
float in_expand=1.0, bool in_front=false);
void render(RenderContext* renderContext);
AABox getBoundingBox(const AABox& boundingBox) const;
Vertex getMarkLength(const AABox& boundingBox) const;
int getAttributeCount(AABox& bbox, AttribID attrib);
void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
String getTextAttribute(AABox& bbox, AttribID attrib, int index);
Material* getMaterial() { return &material; }
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "bboxdeco", buflen); };
Vec3 marginVecToDataVec(Vec3 marginvec, RenderContext* renderContext, Material* material);
Vec3 marginNormalToDataNormal(Vec3 marginvec, RenderContext* renderContext, Material* material);
void setAxisCallback(userAxisPtr fn, void * user, int axis);
void getAxisCallback(userAxisPtr *fn, void ** user, int axis);
private:
struct BBoxDecoImpl;
Material material;
AxisInfo xaxis, yaxis, zaxis;
float marklen_value;
bool marklen_fract;
float expand;
bool draw_front;
#ifndef RGL_NO_OPENGL
bool axisBusy;
#endif
userAxisPtr axisCallback[3];
void* axisData[3];
static Material defaultMaterial;
static AxisInfo defaultAxis;
};
} // namespace rgl
#endif // BBOX_DECO_H
rgl/src/gl2ps.c 0000644 0001762 0000144 00000577365 14100762641 013050 0 ustar ligges users /*
* GL2PS, an OpenGL to PostScript Printing Library
* Copyright (C) 1999-2017 C. Geuzaine
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of either:
*
* a) the GNU Library General Public License as published by the Free
* Software Foundation, either version 2 of the License, or (at your
* option) any later version; or
*
* b) the GL2PS License as published by Christophe Geuzaine, either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See either
* the GNU Library General Public License or the GL2PS License for
* more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library in the file named "COPYING.LGPL";
* if not, write to the Free Software Foundation, Inc., 51 Franklin
* Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* You should have received a copy of the GL2PS License with this
* library in the file named "COPYING.GL2PS"; if not, I will be glad
* to provide one.
*
* For the latest info about gl2ps and a full list of contributors,
* see http://www.geuz.org/gl2ps/.
*
* Please report all bugs and problems to .
*/
#ifdef RGL_NO_OPENGL
typedef int make_iso_compiler_happy;
#else
#include "gl2ps.h"
#include
#include
#include
#include
#include
#include
#if defined(GL2PS_HAVE_ZLIB)
#include
#endif
#if defined(GL2PS_HAVE_LIBPNG)
#include
#endif
/*********************************************************************
*
* Private definitions, data structures and prototypes
*
*********************************************************************/
/* Magic numbers (assuming that the order of magnitude of window
coordinates is 10^3) */
#define GL2PS_EPSILON 5.0e-3F
#define GL2PS_ZSCALE 1000.0F
#define GL2PS_ZOFFSET 5.0e-2F
#define GL2PS_ZOFFSET_LARGE 20.0F
#define GL2PS_ZERO(arg) (fabs(arg) < 1.e-20)
/* BSP tree primitive comparison */
#define GL2PS_COINCIDENT 1
#define GL2PS_IN_FRONT_OF 2
#define GL2PS_IN_BACK_OF 3
#define GL2PS_SPANNING 4
/* 2D BSP tree primitive comparison */
#define GL2PS_POINT_COINCIDENT 0
#define GL2PS_POINT_INFRONT 1
#define GL2PS_POINT_BACK 2
/* Internal feedback buffer pass-through tokens */
#define GL2PS_BEGIN_OFFSET_TOKEN 1
#define GL2PS_END_OFFSET_TOKEN 2
#define GL2PS_BEGIN_BOUNDARY_TOKEN 3
#define GL2PS_END_BOUNDARY_TOKEN 4
#define GL2PS_BEGIN_STIPPLE_TOKEN 5
#define GL2PS_END_STIPPLE_TOKEN 6
#define GL2PS_POINT_SIZE_TOKEN 7
#define GL2PS_LINE_CAP_TOKEN 8
#define GL2PS_LINE_JOIN_TOKEN 9
#define GL2PS_LINE_WIDTH_TOKEN 10
#define GL2PS_BEGIN_BLEND_TOKEN 11
#define GL2PS_END_BLEND_TOKEN 12
#define GL2PS_SRC_BLEND_TOKEN 13
#define GL2PS_DST_BLEND_TOKEN 14
#define GL2PS_IMAGEMAP_TOKEN 15
#define GL2PS_DRAW_PIXELS_TOKEN 16
#define GL2PS_TEXT_TOKEN 17
typedef enum {
T_UNDEFINED = -1,
T_CONST_COLOR = 1,
T_VAR_COLOR = 1<<1,
T_ALPHA_1 = 1<<2,
T_ALPHA_LESS_1 = 1<<3,
T_VAR_ALPHA = 1<<4
} GL2PS_TRIANGLE_PROPERTY;
typedef GLfloat GL2PSplane[4];
typedef struct _GL2PSbsptree2d GL2PSbsptree2d;
struct _GL2PSbsptree2d {
GL2PSplane plane;
GL2PSbsptree2d *front, *back;
};
typedef struct {
GLint nmax, size, incr, n;
char *array;
} GL2PSlist;
typedef struct _GL2PSbsptree GL2PSbsptree;
struct _GL2PSbsptree {
GL2PSplane plane;
GL2PSlist *primitives;
GL2PSbsptree *front, *back;
};
typedef struct {
GL2PSvertex vertex[3];
int prop;
} GL2PStriangle;
typedef struct {
GLshort fontsize;
char *str, *fontname;
/* Note: for a 'special' string, 'alignment' holds the format
(PostScript, PDF, etc.) of the special string */
GLint alignment;
GLfloat angle;
} GL2PSstring;
typedef struct {
GLsizei width, height;
/* Note: for an imagemap, 'type' indicates if it has already been
written to the file or not, and 'format' indicates if it is
visible or not */
GLenum format, type;
GLfloat zoom_x, zoom_y;
GLfloat *pixels;
} GL2PSimage;
typedef struct _GL2PSimagemap GL2PSimagemap;
struct _GL2PSimagemap {
GL2PSimage *image;
GL2PSimagemap *next;
};
typedef struct {
GLshort type, numverts;
GLushort pattern;
char boundary, offset, culled;
GLint factor, linecap, linejoin;
GLfloat width, ofactor, ounits;
GL2PSvertex *verts;
union {
GL2PSstring *text;
GL2PSimage *image;
} data;
} GL2PSprimitive;
typedef struct {
#if defined(GL2PS_HAVE_ZLIB)
Bytef *dest, *src, *start;
uLongf destLen, srcLen;
#else
int dummy;
#endif
} GL2PScompress;
typedef struct{
GL2PSlist* ptrlist;
int gsno, fontno, imno, shno, maskshno, trgroupno;
int gsobjno, fontobjno, imobjno, shobjno, maskshobjno, trgroupobjno;
} GL2PSpdfgroup;
typedef struct {
/* General */
GLint format, sort, options, colorsize, colormode, buffersize;
GLint lastlinecap, lastlinejoin;
char *title, *producer, *filename;
GLboolean boundary, blending;
GLfloat *feedback, lastlinewidth;
GLint viewport[4], blendfunc[2], lastfactor;
GL2PSrgba *colormap, lastrgba, threshold, bgcolor;
GLushort lastpattern;
GL2PSvertex lastvertex;
GL2PSlist *primitives, *auxprimitives;
FILE *stream;
GL2PScompress *compress;
GLboolean header;
GL2PSvertex rasterpos;
GLboolean forcerasterpos;
/* BSP-specific */
GLint maxbestroot;
/* Occlusion culling-specific */
GLboolean zerosurfacearea;
GL2PSbsptree2d *imagetree;
GL2PSprimitive *primitivetoadd;
/* PDF-specific */
int streamlength;
GL2PSlist *pdfprimlist, *pdfgrouplist;
int *xreflist;
int objects_stack; /* available objects */
int extgs_stack; /* graphics state object number */
int font_stack; /* font object number */
int im_stack; /* image object number */
int trgroupobjects_stack; /* xobject numbers */
int shader_stack; /* shader object numbers */
int mshader_stack; /* mask shader object numbers */
/* for image map list */
GL2PSimagemap *imagemap_head;
GL2PSimagemap *imagemap_tail;
} GL2PScontext;
typedef struct {
void (*printHeader)(void);
void (*printFooter)(void);
void (*beginViewport)(GLint viewport[4]);
GLint (*endViewport)(void);
void (*printPrimitive)(void *data);
void (*printFinalPrimitive)(void);
const char *file_extension;
const char *description;
} GL2PSbackend;
/* The gl2ps context. gl2ps is not thread safe (we should create a
local GL2PScontext during gl2psBeginPage) */
static GL2PScontext *gl2ps = NULL;
/* Need to forward-declare this one */
static GLint gl2psPrintPrimitives(void);
/*********************************************************************
*
* Utility routines
*
*********************************************************************/
static void gl2psMsg(GLint level, const char *fmt, ...)
{
/* Avoid R check complaints: GL2PS_SILENT is always set
va_list args;
if(!(gl2ps->options & GL2PS_SILENT)){
switch(level){
case GL2PS_INFO : fprintf(stderr, "GL2PS info: "); break;
case GL2PS_WARNING : fprintf(stderr, "GL2PS warning: "); break;
case GL2PS_ERROR : fprintf(stderr, "GL2PS error: "); break;
}
va_start(args, fmt);
vfprintf(stderr, fmt, args);
va_end(args);
fprintf(stderr, "\n");
}
*/
/* if(level == GL2PS_ERROR) exit(1); */
}
static void *gl2psMalloc(size_t size)
{
void *ptr;
if(!size) return NULL;
ptr = malloc(size);
if(!ptr){
gl2psMsg(GL2PS_ERROR, "Couldn't allocate requested memory");
return NULL;
}
return ptr;
}
static void *gl2psRealloc(void *ptr, size_t size)
{
void *orig = ptr;
if(!size) return NULL;
ptr = realloc(orig, size);
if(!ptr){
gl2psMsg(GL2PS_ERROR, "Couldn't reallocate requested memory");
free(orig);
return NULL;
}
return ptr;
}
static void gl2psFree(void *ptr)
{
if(!ptr) return;
free(ptr);
}
static int gl2psWriteBigEndian(unsigned long data, int bytes)
{
int i;
int size = sizeof(unsigned long);
for(i = 1; i <= bytes; ++i){
fputc(0xff & (data >> (size - i) * 8), gl2ps->stream);
}
return bytes;
}
/* zlib compression helper routines */
#if defined(GL2PS_HAVE_ZLIB)
static void gl2psSetupCompress(void)
{
gl2ps->compress = (GL2PScompress*)gl2psMalloc(sizeof(GL2PScompress));
gl2ps->compress->src = NULL;
gl2ps->compress->start = NULL;
gl2ps->compress->dest = NULL;
gl2ps->compress->srcLen = 0;
gl2ps->compress->destLen = 0;
}
static void gl2psFreeCompress(void)
{
if(!gl2ps->compress)
return;
gl2psFree(gl2ps->compress->start);
gl2psFree(gl2ps->compress->dest);
gl2ps->compress->src = NULL;
gl2ps->compress->start = NULL;
gl2ps->compress->dest = NULL;
gl2ps->compress->srcLen = 0;
gl2ps->compress->destLen = 0;
}
static int gl2psAllocCompress(unsigned int srcsize)
{
gl2psFreeCompress();
if(!gl2ps->compress || !srcsize)
return GL2PS_ERROR;
gl2ps->compress->srcLen = srcsize;
gl2ps->compress->destLen = (int)ceil(1.001 * gl2ps->compress->srcLen + 12);
gl2ps->compress->src = (Bytef*)gl2psMalloc(gl2ps->compress->srcLen);
gl2ps->compress->start = gl2ps->compress->src;
gl2ps->compress->dest = (Bytef*)gl2psMalloc(gl2ps->compress->destLen);
return GL2PS_SUCCESS;
}
static void *gl2psReallocCompress(unsigned int srcsize)
{
if(!gl2ps->compress || !srcsize)
return NULL;
if(srcsize < gl2ps->compress->srcLen)
return gl2ps->compress->start;
gl2ps->compress->srcLen = srcsize;
gl2ps->compress->destLen = (int)ceil(1.001 * gl2ps->compress->srcLen + 12);
gl2ps->compress->src = (Bytef*)gl2psRealloc(gl2ps->compress->src,
gl2ps->compress->srcLen);
gl2ps->compress->start = gl2ps->compress->src;
gl2ps->compress->dest = (Bytef*)gl2psRealloc(gl2ps->compress->dest,
gl2ps->compress->destLen);
return gl2ps->compress->start;
}
static int gl2psWriteBigEndianCompress(unsigned long data, int bytes)
{
int i;
int size = sizeof(unsigned long);
for(i = 1; i <= bytes; ++i){
*gl2ps->compress->src = (Bytef)(0xff & (data >> (size-i) * 8));
++gl2ps->compress->src;
}
return bytes;
}
static int gl2psDeflate(void)
{
/* For compatibility with older zlib versions, we use compress(...)
instead of compress2(..., Z_BEST_COMPRESSION) */
return compress(gl2ps->compress->dest, &gl2ps->compress->destLen,
gl2ps->compress->start, gl2ps->compress->srcLen);
}
#endif
static int gl2psPrintf(const char* fmt, ...)
{
int ret;
va_list args;
#if defined(GL2PS_HAVE_ZLIB)
static char buf[1024];
char *bufptr = buf;
GLboolean freebuf = GL_FALSE;
unsigned int oldsize = 0;
#if !defined(GL2PS_HAVE_NO_VSNPRINTF)
/* Try writing the string to a 1024 byte buffer. If it is too small to fit,
keep trying larger sizes until it does. */
int bufsize = sizeof(buf);
#endif
if(gl2ps->options & GL2PS_COMPRESS){
va_start(args, fmt);
#if defined(GL2PS_HAVE_NO_VSNPRINTF)
ret = vsprintf(buf, fmt, args);
#else
ret = vsnprintf(bufptr, bufsize, fmt, args);
#endif
va_end(args);
#if !defined(GL2PS_HAVE_NO_VSNPRINTF)
while(ret >= (bufsize - 1) || ret < 0){
/* Too big. Allocate a new buffer. */
bufsize *= 2;
if(freebuf == GL_TRUE) gl2psFree(bufptr);
bufptr = (char *)gl2psMalloc(bufsize);
freebuf = GL_TRUE;
va_start(args, fmt);
ret = vsnprintf(bufptr, bufsize, fmt, args);
va_end(args);
}
#endif
oldsize = gl2ps->compress->srcLen;
gl2ps->compress->start = (Bytef*)gl2psReallocCompress(oldsize + ret);
memcpy(gl2ps->compress->start + oldsize, bufptr, ret);
if(freebuf == GL_TRUE) gl2psFree(bufptr);
ret = 0;
}
else{
#endif
va_start(args, fmt);
ret = vfprintf(gl2ps->stream, fmt, args);
va_end(args);
#if defined(GL2PS_HAVE_ZLIB)
}
#endif
return ret;
}
static void gl2psPrintGzipHeader(void)
{
#if defined(GL2PS_HAVE_ZLIB)
char tmp[10] = {'\x1f', '\x8b', /* magic numbers: 0x1f, 0x8b */
8, /* compression method: Z_DEFLATED */
0, /* flags */
0, 0, 0, 0, /* time */
2, /* extra flags: max compression */
'\x03'}; /* OS code: 0x03 (Unix) */
if(gl2ps->options & GL2PS_COMPRESS){
gl2psSetupCompress();
/* add the gzip file header */
fwrite(tmp, 10, 1, gl2ps->stream);
}
#endif
}
static void gl2psPrintGzipFooter(void)
{
#if defined(GL2PS_HAVE_ZLIB)
int n;
uLong crc, len;
char tmp[8];
if(gl2ps->options & GL2PS_COMPRESS){
if(Z_OK != gl2psDeflate()){
gl2psMsg(GL2PS_ERROR, "Zlib deflate error");
}
else{
/* determine the length of the header in the zlib stream */
n = 2; /* CMF+FLG */
if(gl2ps->compress->dest[1] & (1<<5)){
n += 4; /* DICTID */
}
/* write the data, without the zlib header and footer */
fwrite(gl2ps->compress->dest+n, gl2ps->compress->destLen-(n+4),
1, gl2ps->stream);
/* add the gzip file footer */
crc = crc32(0L, gl2ps->compress->start, gl2ps->compress->srcLen);
for(n = 0; n < 4; ++n){
tmp[n] = (char)(crc & 0xff);
crc >>= 8;
}
len = gl2ps->compress->srcLen;
for(n = 4; n < 8; ++n){
tmp[n] = (char)(len & 0xff);
len >>= 8;
}
fwrite(tmp, 8, 1, gl2ps->stream);
}
gl2psFreeCompress();
gl2psFree(gl2ps->compress);
gl2ps->compress = NULL;
}
#endif
}
/* The list handling routines */
static void gl2psListRealloc(GL2PSlist *list, GLint n)
{
if(!list){
gl2psMsg(GL2PS_ERROR, "Cannot reallocate NULL list");
return;
}
if(n <= 0) return;
if(!list->array){
list->nmax = n;
list->array = (char*)gl2psMalloc(list->nmax * list->size);
}
else{
if(n > list->nmax){
list->nmax = ((n - 1) / list->incr + 1) * list->incr;
list->array = (char*)gl2psRealloc(list->array,
list->nmax * list->size);
}
}
}
static GL2PSlist *gl2psListCreate(GLint n, GLint incr, GLint size)
{
GL2PSlist *list;
if(n < 0) n = 0;
if(incr <= 0) incr = 1;
list = (GL2PSlist*)gl2psMalloc(sizeof(GL2PSlist));
list->nmax = 0;
list->incr = incr;
list->size = size;
list->n = 0;
list->array = NULL;
gl2psListRealloc(list, n);
return list;
}
static void gl2psListReset(GL2PSlist *list)
{
if(!list) return;
list->n = 0;
}
static void gl2psListDelete(GL2PSlist *list)
{
if(!list) return;
gl2psFree(list->array);
gl2psFree(list);
}
static void gl2psListAdd(GL2PSlist *list, void *data)
{
if(!list){
gl2psMsg(GL2PS_ERROR, "Cannot add into unallocated list");
return;
}
list->n++;
gl2psListRealloc(list, list->n);
memcpy(&list->array[(list->n - 1) * list->size], data, list->size);
}
static int gl2psListNbr(GL2PSlist *list)
{
if(!list)
return 0;
return list->n;
}
static void *gl2psListPointer(GL2PSlist *list, GLint idx)
{
if(!list){
gl2psMsg(GL2PS_ERROR, "Cannot point into unallocated list");
return NULL;
}
if((idx < 0) || (idx >= list->n)){
gl2psMsg(GL2PS_ERROR, "Wrong list index in gl2psListPointer");
return NULL;
}
return &list->array[idx * list->size];
}
static void gl2psListSort(GL2PSlist *list,
int (*fcmp)(const void *a, const void *b))
{
if(!list)
return;
qsort(list->array, list->n, list->size, fcmp);
}
static void gl2psListAction(GL2PSlist *list, void (*action)(void *data))
{
GLint i;
for(i = 0; i < gl2psListNbr(list); i++){
(*action)(gl2psListPointer(list, i));
}
}
static void gl2psListActionInverse(GL2PSlist *list, void (*action)(void *data))
{
GLint i;
for(i = gl2psListNbr(list); i > 0; i--){
(*action)(gl2psListPointer(list, i-1));
}
}
#if defined(GL2PS_HAVE_LIBPNG)
static void gl2psListRead(GL2PSlist *list, int index, void *data)
{
if((index < 0) || (index >= list->n))
gl2psMsg(GL2PS_ERROR, "Wrong list index in gl2psListRead");
memcpy(data, &list->array[index * list->size], list->size);
}
static void gl2psEncodeBase64Block(unsigned char in[3], unsigned char out[4], int len)
{
static const char cb64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
out[0] = cb64[ in[0] >> 2 ];
out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ];
out[2] = (len > 1) ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '=';
out[3] = (len > 2) ? cb64[ in[2] & 0x3f ] : '=';
}
static void gl2psListEncodeBase64(GL2PSlist *list)
{
unsigned char *buffer, in[3], out[4];
int i, n, index, len;
n = list->n * list->size;
buffer = (unsigned char*)gl2psMalloc(n * sizeof(unsigned char));
memcpy(buffer, list->array, n * sizeof(unsigned char));
gl2psListReset(list);
index = 0;
while(index < n) {
len = 0;
for(i = 0; i < 3; i++) {
if(index < n){
in[i] = buffer[index];
len++;
}
else{
in[i] = 0;
}
index++;
}
if(len) {
gl2psEncodeBase64Block(in, out, len);
for(i = 0; i < 4; i++)
gl2psListAdd(list, &out[i]);
}
}
gl2psFree(buffer);
}
#endif
/* Helpers for rgba colors */
static GLboolean gl2psSameColor(GL2PSrgba rgba1, GL2PSrgba rgba2)
{
if(!GL2PS_ZERO(rgba1[0] - rgba2[0]) ||
!GL2PS_ZERO(rgba1[1] - rgba2[1]) ||
!GL2PS_ZERO(rgba1[2] - rgba2[2]))
return GL_FALSE;
return GL_TRUE;
}
static GLboolean gl2psVertsSameColor(const GL2PSprimitive *prim)
{
int i;
for(i = 1; i < prim->numverts; i++){
if(!gl2psSameColor(prim->verts[0].rgba, prim->verts[i].rgba)){
return GL_FALSE;
}
}
return GL_TRUE;
}
static GLboolean gl2psSameColorThreshold(int n, GL2PSrgba rgba[],
GL2PSrgba threshold)
{
int i;
if(n < 2) return GL_TRUE;
for(i = 1; i < n; i++){
if(fabs(rgba[0][0] - rgba[i][0]) > threshold[0] ||
fabs(rgba[0][1] - rgba[i][1]) > threshold[1] ||
fabs(rgba[0][2] - rgba[i][2]) > threshold[2])
return GL_FALSE;
}
return GL_TRUE;
}
static void gl2psSetLastColor(GL2PSrgba rgba)
{
int i;
for(i = 0; i < 3; ++i){
gl2ps->lastrgba[i] = rgba[i];
}
}
static GLfloat gl2psGetRGB(GL2PSimage *im, GLuint x, GLuint y,
GLfloat *red, GLfloat *green, GLfloat *blue)
{
GLsizei width = im->width;
GLsizei height = im->height;
GLfloat *pixels = im->pixels;
GLfloat *pimag;
/* OpenGL image is from down to up, PS image is up to down */
switch(im->format){
case GL_RGBA:
pimag = pixels + 4 * (width * (height - 1 - y) + x);
break;
case GL_RGB:
default:
pimag = pixels + 3 * (width * (height - 1 - y) + x);
break;
}
*red = *pimag; pimag++;
*green = *pimag; pimag++;
*blue = *pimag; pimag++;
return (im->format == GL_RGBA) ? *pimag : 1.0F;
}
/* Helper routines for pixmaps */
static GL2PSimage *gl2psCopyPixmap(GL2PSimage *im)
{
int size;
GL2PSimage *image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
image->width = im->width;
image->height = im->height;
image->format = im->format;
image->type = im->type;
image->zoom_x = im->zoom_x;
image->zoom_y = im->zoom_y;
switch(image->format){
case GL_RGBA:
size = image->height * image->width * 4 * sizeof(GLfloat);
break;
case GL_RGB:
default:
size = image->height * image->width * 3 * sizeof(GLfloat);
break;
}
image->pixels = (GLfloat*)gl2psMalloc(size);
memcpy(image->pixels, im->pixels, size);
return image;
}
static void gl2psFreePixmap(GL2PSimage *im)
{
if(!im)
return;
gl2psFree(im->pixels);
gl2psFree(im);
}
#if defined(GL2PS_HAVE_LIBPNG)
#if !defined(png_jmpbuf)
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
#endif
static void gl2psUserWritePNG(png_structp png_ptr, png_bytep data, png_size_t length)
{
unsigned int i;
GL2PSlist *png = (GL2PSlist*)png_get_io_ptr(png_ptr);
for(i = 0; i < length; i++)
gl2psListAdd(png, &data[i]);
}
static void gl2psUserFlushPNG(png_structp png_ptr)
{
(void) png_ptr; /* not used */
}
static void gl2psConvertPixmapToPNG(GL2PSimage *pixmap, GL2PSlist *png)
{
png_structp png_ptr;
png_infop info_ptr;
unsigned char *row_data;
GLfloat dr, dg, db;
int row, col;
if(!(png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)))
return;
if(!(info_ptr = png_create_info_struct(png_ptr))){
png_destroy_write_struct(&png_ptr, NULL);
return;
}
if(setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return;
}
png_set_write_fn(png_ptr, (void *)png, gl2psUserWritePNG, gl2psUserFlushPNG);
png_set_compression_level(png_ptr, Z_DEFAULT_COMPRESSION);
png_set_IHDR(png_ptr, info_ptr, pixmap->width, pixmap->height, 8,
PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
png_write_info(png_ptr, info_ptr);
row_data = (unsigned char*)gl2psMalloc(3 * pixmap->width * sizeof(unsigned char));
for(row = 0; row < pixmap->height; row++){
for(col = 0; col < pixmap->width; col++){
gl2psGetRGB(pixmap, col, row, &dr, &dg, &db);
row_data[3*col] = (unsigned char)(255. * dr);
row_data[3*col+1] = (unsigned char)(255. * dg);
row_data[3*col+2] = (unsigned char)(255. * db);
}
png_write_row(png_ptr, (png_bytep)row_data);
}
gl2psFree(row_data);
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, &info_ptr);
}
#endif
/* Helper routines for text strings */
static GLint gl2psAddText(GLint type, const char *str, const char *fontname,
GLshort fontsize, GLint alignment, GLfloat angle,
GL2PSrgba color)
{
GLfloat pos[4];
GL2PSprimitive *prim;
GLboolean valid;
if(!gl2ps || !str || !fontname) return GL2PS_UNINITIALIZED;
if(gl2ps->options & GL2PS_NO_TEXT) return GL2PS_SUCCESS;
if (gl2ps->forcerasterpos) {
pos[0] = gl2ps->rasterpos.xyz[0];
pos[1] = gl2ps->rasterpos.xyz[1];
pos[2] = gl2ps->rasterpos.xyz[2];
pos[3] = 1.f;
}
else {
glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
if(GL_FALSE == valid) return GL2PS_SUCCESS; /* the primitive is culled */
glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);
}
prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
prim->type = (GLshort)type;
prim->boundary = 0;
prim->numverts = 1;
prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex));
prim->verts[0].xyz[0] = pos[0];
prim->verts[0].xyz[1] = pos[1];
prim->verts[0].xyz[2] = pos[2];
prim->culled = 0;
prim->offset = 0;
prim->ofactor = 0.0;
prim->ounits = 0.0;
prim->pattern = 0;
prim->factor = 0;
prim->width = 1;
prim->linecap = 0;
prim->linejoin = 0;
if (color) {
memcpy(prim->verts[0].rgba, color, 4 * sizeof(float));
}
else {
if (gl2ps->forcerasterpos) {
prim->verts[0].rgba[0] = gl2ps->rasterpos.rgba[0];
prim->verts[0].rgba[1] = gl2ps->rasterpos.rgba[1];
prim->verts[0].rgba[2] = gl2ps->rasterpos.rgba[2];
prim->verts[0].rgba[3] = gl2ps->rasterpos.rgba[3];
}
else {
glGetFloatv(GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba);
}
}
prim->data.text = (GL2PSstring*)gl2psMalloc(sizeof(GL2PSstring));
prim->data.text->str = (char*)gl2psMalloc((strlen(str)+1)*sizeof(char));
strcpy(prim->data.text->str, str);
prim->data.text->fontname = (char*)gl2psMalloc((strlen(fontname)+1)*sizeof(char));
strcpy(prim->data.text->fontname, fontname);
prim->data.text->fontsize = fontsize;
prim->data.text->alignment = alignment;
prim->data.text->angle = angle;
gl2ps->forcerasterpos = GL_FALSE;
/* If no OpenGL context, just add directly to primitives */
if (gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) {
gl2psListAdd(gl2ps->primitives, &prim);
}
else {
gl2psListAdd(gl2ps->auxprimitives, &prim);
glPassThrough(GL2PS_TEXT_TOKEN);
}
return GL2PS_SUCCESS;
}
static GL2PSstring *gl2psCopyText(GL2PSstring *t)
{
GL2PSstring *text = (GL2PSstring*)gl2psMalloc(sizeof(GL2PSstring));
text->str = (char*)gl2psMalloc((strlen(t->str)+1)*sizeof(char));
strcpy(text->str, t->str);
text->fontname = (char*)gl2psMalloc((strlen(t->fontname)+1)*sizeof(char));
strcpy(text->fontname, t->fontname);
text->fontsize = t->fontsize;
text->alignment = t->alignment;
text->angle = t->angle;
return text;
}
static void gl2psFreeText(GL2PSstring *text)
{
if(!text)
return;
gl2psFree(text->str);
gl2psFree(text->fontname);
gl2psFree(text);
}
/* Helpers for blending modes */
static GLboolean gl2psSupportedBlendMode(GLenum sfactor, GLenum dfactor)
{
/* returns TRUE if gl2ps supports the argument combination: only two
blending modes have been implemented so far */
if( (sfactor == GL_SRC_ALPHA && dfactor == GL_ONE_MINUS_SRC_ALPHA) ||
(sfactor == GL_ONE && dfactor == GL_ZERO) )
return GL_TRUE;
return GL_FALSE;
}
static void gl2psAdaptVertexForBlending(GL2PSvertex *v)
{
/* Transforms vertex depending on the actual blending function -
currently the vertex v is considered as source vertex and his
alpha value is changed to 1.0 if source blending GL_ONE is
active. This might be extended in the future */
if(!v || !gl2ps)
return;
if(gl2ps->options & GL2PS_NO_BLENDING || !gl2ps->blending){
v->rgba[3] = 1.0F;
return;
}
switch(gl2ps->blendfunc[0]){
case GL_ONE:
v->rgba[3] = 1.0F;
break;
default:
break;
}
}
static void gl2psAssignTriangleProperties(GL2PStriangle *t)
{
/* int i; */
t->prop = T_VAR_COLOR;
/* Uncommenting the following lines activates an even more fine
grained distinction between triangle types - please don't delete,
a remarkable amount of PDF handling code inside this file depends
on it if activated */
/*
t->prop = T_CONST_COLOR;
for(i = 0; i < 3; ++i){
if(!GL2PS_ZERO(t->vertex[0].rgba[i] - t->vertex[1].rgba[i]) ||
!GL2PS_ZERO(t->vertex[1].rgba[i] - t->vertex[2].rgba[i])){
t->prop = T_VAR_COLOR;
break;
}
}
*/
if(!GL2PS_ZERO(t->vertex[0].rgba[3] - t->vertex[1].rgba[3]) ||
!GL2PS_ZERO(t->vertex[1].rgba[3] - t->vertex[2].rgba[3])){
t->prop |= T_VAR_ALPHA;
}
else{
if(t->vertex[0].rgba[3] < 1)
t->prop |= T_ALPHA_LESS_1;
else
t->prop |= T_ALPHA_1;
}
}
static void gl2psFillTriangleFromPrimitive(GL2PStriangle *t, GL2PSprimitive *p,
GLboolean assignprops)
{
t->vertex[0] = p->verts[0];
t->vertex[1] = p->verts[1];
t->vertex[2] = p->verts[2];
if(GL_TRUE == assignprops)
gl2psAssignTriangleProperties(t);
}
static void gl2psInitTriangle(GL2PStriangle *t)
{
int i;
GL2PSvertex vertex = { {-1.0F, -1.0F, -1.0F}, {-1.0F, -1.0F, -1.0F, -1.0F} };
for(i = 0; i < 3; i++)
t->vertex[i] = vertex;
t->prop = T_UNDEFINED;
}
/* Miscellaneous helper routines */
static void gl2psResetLineProperties(void)
{
gl2ps->lastlinewidth = 0.;
gl2ps->lastlinecap = gl2ps->lastlinejoin = 0;
}
static GL2PSprimitive *gl2psCopyPrimitive(GL2PSprimitive *p)
{
GL2PSprimitive *prim;
if(!p){
gl2psMsg(GL2PS_ERROR, "Trying to copy an empty primitive");
return NULL;
}
prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
prim->type = p->type;
prim->numverts = p->numverts;
prim->boundary = p->boundary;
prim->offset = p->offset;
prim->ofactor = p->ofactor;
prim->ounits = p->ounits;
prim->pattern = p->pattern;
prim->factor = p->factor;
prim->culled = p->culled;
prim->width = p->width;
prim->linecap = p->linecap;
prim->linejoin = p->linejoin;
prim->verts = (GL2PSvertex*)gl2psMalloc(p->numverts*sizeof(GL2PSvertex));
memcpy(prim->verts, p->verts, p->numverts * sizeof(GL2PSvertex));
switch(prim->type){
case GL2PS_PIXMAP :
prim->data.image = gl2psCopyPixmap(p->data.image);
break;
case GL2PS_TEXT :
case GL2PS_SPECIAL :
prim->data.text = gl2psCopyText(p->data.text);
break;
default:
break;
}
return prim;
}
static GLboolean gl2psSamePosition(GL2PSxyz p1, GL2PSxyz p2)
{
if(!GL2PS_ZERO(p1[0] - p2[0]) ||
!GL2PS_ZERO(p1[1] - p2[1]) ||
!GL2PS_ZERO(p1[2] - p2[2]))
return GL_FALSE;
return GL_TRUE;
}
/*********************************************************************
*
* 3D sorting routines
*
*********************************************************************/
static GLfloat gl2psComparePointPlane(GL2PSxyz point, GL2PSplane plane)
{
return (plane[0] * point[0] +
plane[1] * point[1] +
plane[2] * point[2] +
plane[3]);
}
static GLfloat gl2psPsca(GLfloat *a, GLfloat *b)
{
return (a[0]*b[0] + a[1]*b[1] + a[2]*b[2]);
}
static void gl2psPvec(GLfloat *a, GLfloat *b, GLfloat *c)
{
c[0] = a[1]*b[2] - a[2]*b[1];
c[1] = a[2]*b[0] - a[0]*b[2];
c[2] = a[0]*b[1] - a[1]*b[0];
}
static GLfloat gl2psNorm(GLfloat *a)
{
return (GLfloat)sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]);
}
static void gl2psGetNormal(GLfloat *a, GLfloat *b, GLfloat *c)
{
GLfloat norm;
gl2psPvec(a, b, c);
if(!GL2PS_ZERO(norm = gl2psNorm(c))){
c[0] = c[0] / norm;
c[1] = c[1] / norm;
c[2] = c[2] / norm;
}
else{
/* The plane is still wrong despite our tests in gl2psGetPlane.
Let's return a dummy value for now (this is a hack: we should
do more intelligent tests in GetPlane) */
c[0] = c[1] = 0.0F;
c[2] = 1.0F;
}
}
static void gl2psGetPlane(GL2PSprimitive *prim, GL2PSplane plane)
{
GL2PSxyz v = {0.0F, 0.0F, 0.0F}, w = {0.0F, 0.0F, 0.0F};
switch(prim->type){
case GL2PS_TRIANGLE :
case GL2PS_QUADRANGLE :
v[0] = prim->verts[1].xyz[0] - prim->verts[0].xyz[0];
v[1] = prim->verts[1].xyz[1] - prim->verts[0].xyz[1];
v[2] = prim->verts[1].xyz[2] - prim->verts[0].xyz[2];
w[0] = prim->verts[2].xyz[0] - prim->verts[0].xyz[0];
w[1] = prim->verts[2].xyz[1] - prim->verts[0].xyz[1];
w[2] = prim->verts[2].xyz[2] - prim->verts[0].xyz[2];
if((GL2PS_ZERO(v[0]) && GL2PS_ZERO(v[1]) && GL2PS_ZERO(v[2])) ||
(GL2PS_ZERO(w[0]) && GL2PS_ZERO(w[1]) && GL2PS_ZERO(w[2]))){
plane[0] = plane[1] = 0.0F;
plane[2] = 1.0F;
plane[3] = -prim->verts[0].xyz[2];
}
else{
gl2psGetNormal(v, w, plane);
plane[3] =
- plane[0] * prim->verts[0].xyz[0]
- plane[1] * prim->verts[0].xyz[1]
- plane[2] * prim->verts[0].xyz[2];
}
break;
case GL2PS_LINE :
v[0] = prim->verts[1].xyz[0] - prim->verts[0].xyz[0];
v[1] = prim->verts[1].xyz[1] - prim->verts[0].xyz[1];
v[2] = prim->verts[1].xyz[2] - prim->verts[0].xyz[2];
if(GL2PS_ZERO(v[0]) && GL2PS_ZERO(v[1]) && GL2PS_ZERO(v[2])){
plane[0] = plane[1] = 0.0F;
plane[2] = 1.0F;
plane[3] = -prim->verts[0].xyz[2];
}
else{
if(GL2PS_ZERO(v[0])) w[0] = 1.0F;
else if(GL2PS_ZERO(v[1])) w[1] = 1.0F;
else w[2] = 1.0F;
gl2psGetNormal(v, w, plane);
plane[3] =
- plane[0] * prim->verts[0].xyz[0]
- plane[1] * prim->verts[0].xyz[1]
- plane[2] * prim->verts[0].xyz[2];
}
break;
case GL2PS_POINT :
case GL2PS_PIXMAP :
case GL2PS_TEXT :
case GL2PS_SPECIAL :
case GL2PS_IMAGEMAP:
plane[0] = plane[1] = 0.0F;
plane[2] = 1.0F;
plane[3] = -prim->verts[0].xyz[2];
break;
default :
gl2psMsg(GL2PS_ERROR, "Unknown primitive type in BSP tree");
plane[0] = plane[1] = plane[3] = 0.0F;
plane[2] = 1.0F;
break;
}
}
static void gl2psCutEdge(GL2PSvertex *a, GL2PSvertex *b, GL2PSplane plane,
GL2PSvertex *c)
{
GL2PSxyz v;
GLfloat sect, psca;
v[0] = b->xyz[0] - a->xyz[0];
v[1] = b->xyz[1] - a->xyz[1];
v[2] = b->xyz[2] - a->xyz[2];
if(!GL2PS_ZERO(psca = gl2psPsca(plane, v)))
sect = -gl2psComparePointPlane(a->xyz, plane) / psca;
else
sect = 0.0F;
c->xyz[0] = a->xyz[0] + v[0] * sect;
c->xyz[1] = a->xyz[1] + v[1] * sect;
c->xyz[2] = a->xyz[2] + v[2] * sect;
c->rgba[0] = (1 - sect) * a->rgba[0] + sect * b->rgba[0];
c->rgba[1] = (1 - sect) * a->rgba[1] + sect * b->rgba[1];
c->rgba[2] = (1 - sect) * a->rgba[2] + sect * b->rgba[2];
c->rgba[3] = (1 - sect) * a->rgba[3] + sect * b->rgba[3];
}
static void gl2psCreateSplitPrimitive(GL2PSprimitive *parent, GL2PSplane plane,
GL2PSprimitive *child, GLshort numverts,
GLshort *index0, GLshort *index1)
{
GLshort i;
if(parent->type == GL2PS_IMAGEMAP){
child->type = GL2PS_IMAGEMAP;
child->data.image = parent->data.image;
}
else{
if(numverts > 4){
gl2psMsg(GL2PS_WARNING, "%d vertices in polygon", numverts);
numverts = 4;
}
switch(numverts){
case 1 : child->type = GL2PS_POINT; break;
case 2 : child->type = GL2PS_LINE; break;
case 3 : child->type = GL2PS_TRIANGLE; break;
case 4 : child->type = GL2PS_QUADRANGLE; break;
default: child->type = GL2PS_NO_TYPE; break;
}
}
child->boundary = 0; /* FIXME: not done! */
child->culled = parent->culled;
child->offset = parent->offset;
child->ofactor = parent->ofactor;
child->ounits = parent->ounits;
child->pattern = parent->pattern;
child->factor = parent->factor;
child->width = parent->width;
child->linecap = parent->linecap;
child->linejoin = parent->linejoin;
child->numverts = numverts;
child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
for(i = 0; i < numverts; i++){
if(index1[i] < 0){
child->verts[i] = parent->verts[index0[i]];
}
else{
gl2psCutEdge(&parent->verts[index0[i]], &parent->verts[index1[i]],
plane, &child->verts[i]);
}
}
}
static void gl2psAddIndex(GLshort *index0, GLshort *index1, GLshort *nb,
GLshort i, GLshort j)
{
GLint k;
for(k = 0; k < *nb; k++){
if((index0[k] == i && index1[k] == j) ||
(index1[k] == i && index0[k] == j)) return;
}
index0[*nb] = i;
index1[*nb] = j;
(*nb)++;
}
static GLshort gl2psGetIndex(GLshort i, GLshort num)
{
return (i < num - 1) ? i + 1 : 0;
}
static GLint gl2psTestSplitPrimitive(GL2PSprimitive *prim, GL2PSplane plane)
{
GLint type = GL2PS_COINCIDENT;
GLshort i, j;
GLfloat d[5];
for(i = 0; i < prim->numverts; i++){
d[i] = gl2psComparePointPlane(prim->verts[i].xyz, plane);
}
if(prim->numverts < 2){
return 0;
}
else{
for(i = 0; i < prim->numverts; i++){
j = gl2psGetIndex(i, prim->numverts);
if(d[j] > GL2PS_EPSILON){
if(type == GL2PS_COINCIDENT) type = GL2PS_IN_BACK_OF;
else if(type != GL2PS_IN_BACK_OF) return 1;
if(d[i] < -GL2PS_EPSILON) return 1;
}
else if(d[j] < -GL2PS_EPSILON){
if(type == GL2PS_COINCIDENT) type = GL2PS_IN_FRONT_OF;
else if(type != GL2PS_IN_FRONT_OF) return 1;
if(d[i] > GL2PS_EPSILON) return 1;
}
}
}
return 0;
}
static GLint gl2psSplitPrimitive(GL2PSprimitive *prim, GL2PSplane plane,
GL2PSprimitive **front, GL2PSprimitive **back)
{
GLshort i, j, in = 0, out = 0, in0[5], in1[5], out0[5], out1[5];
GLint type;
GLfloat d[5];
type = GL2PS_COINCIDENT;
for(i = 0; i < prim->numverts; i++){
d[i] = gl2psComparePointPlane(prim->verts[i].xyz, plane);
}
switch(prim->type){
case GL2PS_POINT :
if(d[0] > GL2PS_EPSILON) type = GL2PS_IN_BACK_OF;
else if(d[0] < -GL2PS_EPSILON) type = GL2PS_IN_FRONT_OF;
else type = GL2PS_COINCIDENT;
break;
default :
for(i = 0; i < prim->numverts; i++){
j = gl2psGetIndex(i, prim->numverts);
if(d[j] > GL2PS_EPSILON){
if(type == GL2PS_COINCIDENT) type = GL2PS_IN_BACK_OF;
else if(type != GL2PS_IN_BACK_OF) type = GL2PS_SPANNING;
if(d[i] < -GL2PS_EPSILON){
gl2psAddIndex(in0, in1, &in, i, j);
gl2psAddIndex(out0, out1, &out, i, j);
type = GL2PS_SPANNING;
}
gl2psAddIndex(out0, out1, &out, j, -1);
}
else if(d[j] < -GL2PS_EPSILON){
if(type == GL2PS_COINCIDENT) type = GL2PS_IN_FRONT_OF;
else if(type != GL2PS_IN_FRONT_OF) type = GL2PS_SPANNING;
if(d[i] > GL2PS_EPSILON){
gl2psAddIndex(in0, in1, &in, i, j);
gl2psAddIndex(out0, out1, &out, i, j);
type = GL2PS_SPANNING;
}
gl2psAddIndex(in0, in1, &in, j, -1);
}
else{
gl2psAddIndex(in0, in1, &in, j, -1);
gl2psAddIndex(out0, out1, &out, j, -1);
}
}
break;
}
if(type == GL2PS_SPANNING){
*back = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
*front = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
gl2psCreateSplitPrimitive(prim, plane, *back, out, out0, out1);
gl2psCreateSplitPrimitive(prim, plane, *front, in, in0, in1);
}
return type;
}
static void gl2psDivideQuad(GL2PSprimitive *quad,
GL2PSprimitive **t1, GL2PSprimitive **t2)
{
*t1 = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
*t2 = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
(*t1)->type = (*t2)->type = GL2PS_TRIANGLE;
(*t1)->numverts = (*t2)->numverts = 3;
(*t1)->culled = (*t2)->culled = quad->culled;
(*t1)->offset = (*t2)->offset = quad->offset;
(*t1)->ofactor = (*t2)->ofactor = quad->ofactor;
(*t1)->ounits = (*t2)->ounits = quad->ounits;
(*t1)->pattern = (*t2)->pattern = quad->pattern;
(*t1)->factor = (*t2)->factor = quad->factor;
(*t1)->width = (*t2)->width = quad->width;
(*t1)->linecap = (*t2)->linecap = quad->linecap;
(*t1)->linejoin = (*t2)->linejoin = quad->linejoin;
(*t1)->verts = (GL2PSvertex*)gl2psMalloc(3 * sizeof(GL2PSvertex));
(*t2)->verts = (GL2PSvertex*)gl2psMalloc(3 * sizeof(GL2PSvertex));
(*t1)->verts[0] = quad->verts[0];
(*t1)->verts[1] = quad->verts[1];
(*t1)->verts[2] = quad->verts[2];
(*t1)->boundary = ((quad->boundary & 1) ? 1 : 0) | ((quad->boundary & 2) ? 2 : 0);
(*t2)->verts[0] = quad->verts[0];
(*t2)->verts[1] = quad->verts[2];
(*t2)->verts[2] = quad->verts[3];
(*t2)->boundary = ((quad->boundary & 4) ? 2 : 0) | ((quad->boundary & 8) ? 4 : 0);
}
static int gl2psCompareDepth(const void *a, const void *b)
{
const GL2PSprimitive *q, *w;
GLfloat dq = 0.0F, dw = 0.0F, diff;
int i;
q = *(const GL2PSprimitive* const*)a;
w = *(const GL2PSprimitive* const*)b;
for(i = 0; i < q->numverts; i++){
dq += q->verts[i].xyz[2];
}
dq /= (GLfloat)q->numverts;
for(i = 0; i < w->numverts; i++){
dw += w->verts[i].xyz[2];
}
dw /= (GLfloat)w->numverts;
diff = dq - dw;
if(diff > 0.){
return -1;
}
else if(diff < 0.){
return 1;
}
else{
return 0;
}
}
static int gl2psTrianglesFirst(const void *a, const void *b)
{
const GL2PSprimitive *q, *w;
q = *(const GL2PSprimitive* const*)a;
w = *(const GL2PSprimitive* const*)b;
return (q->type < w->type ? 1 : -1);
}
static GLint gl2psFindRoot(GL2PSlist *primitives, GL2PSprimitive **root)
{
GLint i, j, count, best = 1000000, idx = 0;
GL2PSprimitive *prim1, *prim2;
GL2PSplane plane;
GLint maxp;
if(!gl2psListNbr(primitives)){
gl2psMsg(GL2PS_ERROR, "Cannot fint root in empty primitive list");
return 0;
}
*root = *(GL2PSprimitive**)gl2psListPointer(primitives, 0);
if(gl2ps->options & GL2PS_BEST_ROOT){
maxp = gl2psListNbr(primitives);
if(maxp > gl2ps->maxbestroot){
maxp = gl2ps->maxbestroot;
}
for(i = 0; i < maxp; i++){
prim1 = *(GL2PSprimitive**)gl2psListPointer(primitives, i);
gl2psGetPlane(prim1, plane);
count = 0;
for(j = 0; j < gl2psListNbr(primitives); j++){
if(j != i){
prim2 = *(GL2PSprimitive**)gl2psListPointer(primitives, j);
count += gl2psTestSplitPrimitive(prim2, plane);
}
if(count > best) break;
}
if(count < best){
best = count;
idx = i;
*root = prim1;
if(!count) return idx;
}
}
/* if(index) gl2psMsg(GL2PS_INFO, "GL2PS_BEST_ROOT was worth it: %d", index); */
return idx;
}
else{
return 0;
}
}
static void gl2psFreeImagemap(GL2PSimagemap *list)
{
GL2PSimagemap *next;
while(list != NULL){
next = list->next;
gl2psFree(list->image->pixels);
gl2psFree(list->image);
gl2psFree(list);
list = next;
}
}
static void gl2psFreePrimitive(void *data)
{
GL2PSprimitive *q;
q = *(GL2PSprimitive**)data;
gl2psFree(q->verts);
if(q->type == GL2PS_TEXT || q->type == GL2PS_SPECIAL){
gl2psFreeText(q->data.text);
}
else if(q->type == GL2PS_PIXMAP){
gl2psFreePixmap(q->data.image);
}
gl2psFree(q);
}
static void gl2psAddPrimitiveInList(GL2PSprimitive *prim, GL2PSlist *list)
{
GL2PSprimitive *t1, *t2;
if(prim->type != GL2PS_QUADRANGLE){
gl2psListAdd(list, &prim);
}
else{
gl2psDivideQuad(prim, &t1, &t2);
gl2psListAdd(list, &t1);
gl2psListAdd(list, &t2);
gl2psFreePrimitive(&prim);
}
}
static void gl2psFreeBspTree(GL2PSbsptree **tree)
{
if(*tree){
if((*tree)->back) gl2psFreeBspTree(&(*tree)->back);
if((*tree)->primitives){
gl2psListAction((*tree)->primitives, gl2psFreePrimitive);
gl2psListDelete((*tree)->primitives);
}
if((*tree)->front) gl2psFreeBspTree(&(*tree)->front);
gl2psFree(*tree);
*tree = NULL;
}
}
static GLboolean gl2psGreater(GLfloat f1, GLfloat f2)
{
if(f1 > f2) return GL_TRUE;
else return GL_FALSE;
}
static GLboolean gl2psLess(GLfloat f1, GLfloat f2)
{
if(f1 < f2) return GL_TRUE;
else return GL_FALSE;
}
static void gl2psBuildBspTree(GL2PSbsptree *tree, GL2PSlist *primitives)
{
GL2PSprimitive *prim, *frontprim = NULL, *backprim = NULL;
GL2PSlist *frontlist, *backlist;
GLint i, idx;
tree->front = NULL;
tree->back = NULL;
tree->primitives = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
idx = gl2psFindRoot(primitives, &prim);
gl2psGetPlane(prim, tree->plane);
gl2psAddPrimitiveInList(prim, tree->primitives);
frontlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
backlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
for(i = 0; i < gl2psListNbr(primitives); i++){
if(i != idx){
prim = *(GL2PSprimitive**)gl2psListPointer(primitives,i);
switch(gl2psSplitPrimitive(prim, tree->plane, &frontprim, &backprim)){
case GL2PS_COINCIDENT:
gl2psAddPrimitiveInList(prim, tree->primitives);
break;
case GL2PS_IN_BACK_OF:
gl2psAddPrimitiveInList(prim, backlist);
break;
case GL2PS_IN_FRONT_OF:
gl2psAddPrimitiveInList(prim, frontlist);
break;
case GL2PS_SPANNING:
gl2psAddPrimitiveInList(backprim, backlist);
gl2psAddPrimitiveInList(frontprim, frontlist);
gl2psFreePrimitive(&prim);
break;
}
}
}
if(gl2psListNbr(tree->primitives)){
gl2psListSort(tree->primitives, gl2psTrianglesFirst);
}
if(gl2psListNbr(frontlist)){
gl2psListSort(frontlist, gl2psTrianglesFirst);
tree->front = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree));
gl2psBuildBspTree(tree->front, frontlist);
}
else{
gl2psListDelete(frontlist);
}
if(gl2psListNbr(backlist)){
gl2psListSort(backlist, gl2psTrianglesFirst);
tree->back = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree));
gl2psBuildBspTree(tree->back, backlist);
}
else{
gl2psListDelete(backlist);
}
gl2psListDelete(primitives);
}
static void gl2psTraverseBspTree(GL2PSbsptree *tree, GL2PSxyz eye, GLfloat epsilon,
GLboolean (*compare)(GLfloat f1, GLfloat f2),
void (*action)(void *data), int inverse)
{
GLfloat result;
if(!tree) return;
result = gl2psComparePointPlane(eye, tree->plane);
if(GL_TRUE == compare(result, epsilon)){
gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse);
if(inverse){
gl2psListActionInverse(tree->primitives, action);
}
else{
gl2psListAction(tree->primitives, action);
}
gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse);
}
else if(GL_TRUE == compare(-epsilon, result)){
gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse);
if(inverse){
gl2psListActionInverse(tree->primitives, action);
}
else{
gl2psListAction(tree->primitives, action);
}
gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse);
}
else{
gl2psTraverseBspTree(tree->front, eye, epsilon, compare, action, inverse);
gl2psTraverseBspTree(tree->back, eye, epsilon, compare, action, inverse);
}
}
static void gl2psRescaleAndOffset(void)
{
GL2PSprimitive *prim;
GLfloat minZ, maxZ, rangeZ, scaleZ;
GLfloat factor, units, area, dZ, dZdX, dZdY, maxdZ;
int i, j;
if(!gl2psListNbr(gl2ps->primitives))
return;
/* get z-buffer range */
prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, 0);
minZ = maxZ = prim->verts[0].xyz[2];
for(i = 1; i < prim->numverts; i++){
if(prim->verts[i].xyz[2] < minZ) minZ = prim->verts[i].xyz[2];
if(prim->verts[i].xyz[2] > maxZ) maxZ = prim->verts[i].xyz[2];
}
for(i = 1; i < gl2psListNbr(gl2ps->primitives); i++){
prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, i);
for(j = 0; j < prim->numverts; j++){
if(prim->verts[j].xyz[2] < minZ) minZ = prim->verts[j].xyz[2];
if(prim->verts[j].xyz[2] > maxZ) maxZ = prim->verts[j].xyz[2];
}
}
rangeZ = (maxZ - minZ);
/* rescale z-buffer coordinate in [0,GL2PS_ZSCALE], to make it of
the same order of magnitude as the x and y coordinates */
scaleZ = GL2PS_ZERO(rangeZ) ? GL2PS_ZSCALE : (GL2PS_ZSCALE / rangeZ);
/* avoid precision loss (we use floats!) */
if(scaleZ > 100000.F) scaleZ = 100000.F;
/* apply offsets */
for(i = 0; i < gl2psListNbr(gl2ps->primitives); i++){
prim = *(GL2PSprimitive**)gl2psListPointer(gl2ps->primitives, i);
for(j = 0; j < prim->numverts; j++){
prim->verts[j].xyz[2] = (prim->verts[j].xyz[2] - minZ) * scaleZ;
}
if((gl2ps->options & GL2PS_SIMPLE_LINE_OFFSET) &&
(prim->type == GL2PS_LINE)){
if(gl2ps->sort == GL2PS_SIMPLE_SORT){
prim->verts[0].xyz[2] -= GL2PS_ZOFFSET_LARGE;
prim->verts[1].xyz[2] -= GL2PS_ZOFFSET_LARGE;
}
else{
prim->verts[0].xyz[2] -= GL2PS_ZOFFSET;
prim->verts[1].xyz[2] -= GL2PS_ZOFFSET;
}
}
else if(prim->offset && (prim->type == GL2PS_TRIANGLE)){
factor = prim->ofactor;
units = prim->ounits;
area =
(prim->verts[1].xyz[0] - prim->verts[0].xyz[0]) *
(prim->verts[2].xyz[1] - prim->verts[1].xyz[1]) -
(prim->verts[2].xyz[0] - prim->verts[1].xyz[0]) *
(prim->verts[1].xyz[1] - prim->verts[0].xyz[1]);
if(!GL2PS_ZERO(area)){
dZdX =
((prim->verts[2].xyz[1] - prim->verts[1].xyz[1]) *
(prim->verts[1].xyz[2] - prim->verts[0].xyz[2]) -
(prim->verts[1].xyz[1] - prim->verts[0].xyz[1]) *
(prim->verts[2].xyz[2] - prim->verts[1].xyz[2])) / area;
dZdY =
((prim->verts[1].xyz[0] - prim->verts[0].xyz[0]) *
(prim->verts[2].xyz[2] - prim->verts[1].xyz[2]) -
(prim->verts[2].xyz[0] - prim->verts[1].xyz[0]) *
(prim->verts[1].xyz[2] - prim->verts[0].xyz[2])) / area;
maxdZ = (GLfloat)sqrt(dZdX * dZdX + dZdY * dZdY);
}
else{
maxdZ = 0.0F;
}
dZ = factor * maxdZ + units;
prim->verts[0].xyz[2] += dZ;
prim->verts[1].xyz[2] += dZ;
prim->verts[2].xyz[2] += dZ;
}
}
}
/*********************************************************************
*
* 2D sorting routines (for occlusion culling)
*
*********************************************************************/
static GLint gl2psGetPlaneFromPoints(GL2PSxyz a, GL2PSxyz b, GL2PSplane plane)
{
GLfloat n;
plane[0] = b[1] - a[1];
plane[1] = a[0] - b[0];
n = (GLfloat)sqrt(plane[0]*plane[0] + plane[1]*plane[1]);
plane[2] = 0.0F;
if(!GL2PS_ZERO(n)){
plane[0] /= n;
plane[1] /= n;
plane[3] = -plane[0]*a[0]-plane[1]*a[1];
return 1;
}
else{
plane[0] = -1.0F;
plane[1] = 0.0F;
plane[3] = a[0];
return 0;
}
}
static void gl2psFreeBspImageTree(GL2PSbsptree2d **tree)
{
if(*tree){
if((*tree)->back) gl2psFreeBspImageTree(&(*tree)->back);
if((*tree)->front) gl2psFreeBspImageTree(&(*tree)->front);
gl2psFree(*tree);
*tree = NULL;
}
}
static GLint gl2psCheckPoint(GL2PSxyz point, GL2PSplane plane)
{
GLfloat pt_dis;
pt_dis = gl2psComparePointPlane(point, plane);
if(pt_dis > GL2PS_EPSILON) return GL2PS_POINT_INFRONT;
else if(pt_dis < -GL2PS_EPSILON) return GL2PS_POINT_BACK;
else return GL2PS_POINT_COINCIDENT;
}
static void gl2psAddPlanesInBspTreeImage(GL2PSprimitive *prim,
GL2PSbsptree2d **tree)
{
GLint ret = 0;
GLint i;
GLint offset = 0;
GL2PSbsptree2d *head = NULL, *cur = NULL;
if((*tree == NULL) && (prim->numverts > 2)){
/* don't cull if transparent
for(i = 0; i < prim->numverts - 1; i++)
if(prim->verts[i].rgba[3] < 1.0F) return;
*/
head = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
for(i = 0; i < prim->numverts-1; i++){
if(!gl2psGetPlaneFromPoints(prim->verts[i].xyz,
prim->verts[i+1].xyz,
head->plane)){
if(prim->numverts-i > 3){
offset++;
}
else{
gl2psFree(head);
return;
}
}
else{
break;
}
}
head->back = NULL;
head->front = NULL;
for(i = 2+offset; i < prim->numverts; i++){
ret = gl2psCheckPoint(prim->verts[i].xyz, head->plane);
if(ret != GL2PS_POINT_COINCIDENT) break;
}
switch(ret){
case GL2PS_POINT_INFRONT :
cur = head;
for(i = 1+offset; i < prim->numverts-1; i++){
if(cur->front == NULL){
cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
}
if(gl2psGetPlaneFromPoints(prim->verts[i].xyz,
prim->verts[i+1].xyz,
cur->front->plane)){
cur = cur->front;
cur->front = NULL;
cur->back = NULL;
}
}
if(cur->front == NULL){
cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
}
if(gl2psGetPlaneFromPoints(prim->verts[i].xyz,
prim->verts[offset].xyz,
cur->front->plane)){
cur->front->front = NULL;
cur->front->back = NULL;
}
else{
gl2psFree(cur->front);
cur->front = NULL;
}
break;
case GL2PS_POINT_BACK :
for(i = 0; i < 4; i++){
head->plane[i] = -head->plane[i];
}
cur = head;
for(i = 1+offset; i < prim->numverts-1; i++){
if(cur->front == NULL){
cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
}
if(gl2psGetPlaneFromPoints(prim->verts[i+1].xyz,
prim->verts[i].xyz,
cur->front->plane)){
cur = cur->front;
cur->front = NULL;
cur->back = NULL;
}
}
if(cur->front == NULL){
cur->front = (GL2PSbsptree2d*)gl2psMalloc(sizeof(GL2PSbsptree2d));
}
if(gl2psGetPlaneFromPoints(prim->verts[offset].xyz,
prim->verts[i].xyz,
cur->front->plane)){
cur->front->front = NULL;
cur->front->back = NULL;
}
else{
gl2psFree(cur->front);
cur->front = NULL;
}
break;
default:
gl2psFree(head);
return;
}
(*tree) = head;
}
}
static GLint gl2psCheckPrimitive(GL2PSprimitive *prim, GL2PSplane plane)
{
GLint i;
GLint pos;
pos = gl2psCheckPoint(prim->verts[0].xyz, plane);
for(i = 1; i < prim->numverts; i++){
pos |= gl2psCheckPoint(prim->verts[i].xyz, plane);
if(pos == (GL2PS_POINT_INFRONT | GL2PS_POINT_BACK)) return GL2PS_SPANNING;
}
if(pos & GL2PS_POINT_INFRONT) return GL2PS_IN_FRONT_OF;
else if(pos & GL2PS_POINT_BACK) return GL2PS_IN_BACK_OF;
else return GL2PS_COINCIDENT;
}
static GL2PSprimitive *gl2psCreateSplitPrimitive2D(GL2PSprimitive *parent,
GLshort numverts,
GL2PSvertex *vertx)
{
GLint i;
GL2PSprimitive *child = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
if(parent->type == GL2PS_IMAGEMAP){
child->type = GL2PS_IMAGEMAP;
child->data.image = parent->data.image;
}
else {
switch(numverts){
case 1 : child->type = GL2PS_POINT; break;
case 2 : child->type = GL2PS_LINE; break;
case 3 : child->type = GL2PS_TRIANGLE; break;
case 4 : child->type = GL2PS_QUADRANGLE; break;
default: child->type = GL2PS_NO_TYPE; break; /* FIXME */
}
}
child->boundary = 0; /* FIXME: not done! */
child->culled = parent->culled;
child->offset = parent->offset;
child->ofactor = parent->ofactor;
child->ounits = parent->ounits;
child->pattern = parent->pattern;
child->factor = parent->factor;
child->width = parent->width;
child->linecap = parent->linecap;
child->linejoin = parent->linejoin;
child->numverts = numverts;
child->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
for(i = 0; i < numverts; i++){
child->verts[i] = vertx[i];
}
return child;
}
static void gl2psSplitPrimitive2D(GL2PSprimitive *prim,
GL2PSplane plane,
GL2PSprimitive **front,
GL2PSprimitive **back)
{
/* cur will hold the position of the current vertex
prev will hold the position of the previous vertex
prev0 will hold the position of the vertex number 0
v1 and v2 represent the current and previous vertices, respectively
flag is set if the current vertex should be checked against the plane */
GLint cur = -1, prev = -1, i, v1 = 0, v2 = 0, flag = 1, prev0 = -1;
/* list of vertices that will go in front and back primitive */
GL2PSvertex *front_list = NULL, *back_list = NULL;
/* number of vertices in front and back list */
GLshort front_count = 0, back_count = 0;
for(i = 0; i <= prim->numverts; i++){
v1 = i;
if(v1 == prim->numverts){
if(prim->numverts < 3) break;
v1 = 0;
v2 = prim->numverts - 1;
cur = prev0;
}
else if(flag){
cur = gl2psCheckPoint(prim->verts[v1].xyz, plane);
if(i == 0){
prev0 = cur;
}
}
if(((prev == -1) || (prev == cur) || (prev == 0) || (cur == 0)) &&
(i < prim->numverts)){
if(cur == GL2PS_POINT_INFRONT){
front_count++;
front_list = (GL2PSvertex*)gl2psRealloc(front_list,
sizeof(GL2PSvertex)*front_count);
front_list[front_count-1] = prim->verts[v1];
}
else if(cur == GL2PS_POINT_BACK){
back_count++;
back_list = (GL2PSvertex*)gl2psRealloc(back_list,
sizeof(GL2PSvertex)*back_count);
back_list[back_count-1] = prim->verts[v1];
}
else{
front_count++;
front_list = (GL2PSvertex*)gl2psRealloc(front_list,
sizeof(GL2PSvertex)*front_count);
front_list[front_count-1] = prim->verts[v1];
back_count++;
back_list = (GL2PSvertex*)gl2psRealloc(back_list,
sizeof(GL2PSvertex)*back_count);
back_list[back_count-1] = prim->verts[v1];
}
flag = 1;
}
else if((prev != cur) && (cur != 0) && (prev != 0)){
if(v1 != 0){
v2 = v1-1;
i--;
}
front_count++;
front_list = (GL2PSvertex*)gl2psRealloc(front_list,
sizeof(GL2PSvertex)*front_count);
gl2psCutEdge(&prim->verts[v2], &prim->verts[v1],
plane, &front_list[front_count-1]);
back_count++;
back_list = (GL2PSvertex*)gl2psRealloc(back_list,
sizeof(GL2PSvertex)*back_count);
back_list[back_count-1] = front_list[front_count-1];
flag = 0;
}
prev = cur;
}
*front = gl2psCreateSplitPrimitive2D(prim, front_count, front_list);
*back = gl2psCreateSplitPrimitive2D(prim, back_count, back_list);
gl2psFree(front_list);
gl2psFree(back_list);
}
static GLint gl2psAddInBspImageTree(GL2PSprimitive *prim, GL2PSbsptree2d **tree)
{
GLint ret = 0;
GL2PSprimitive *frontprim = NULL, *backprim = NULL;
/* FIXME: until we consider the actual extent of text strings and
pixmaps, never cull them. Otherwise the whole string/pixmap gets
culled as soon as the reference point is hidden */
if(prim->type == GL2PS_PIXMAP ||
prim->type == GL2PS_TEXT ||
prim->type == GL2PS_SPECIAL){
return 1;
}
if(*tree == NULL){
if((prim->type != GL2PS_IMAGEMAP) && (GL_FALSE == gl2ps->zerosurfacearea)){
gl2psAddPlanesInBspTreeImage(gl2ps->primitivetoadd, tree);
}
return 1;
}
else{
switch(gl2psCheckPrimitive(prim, (*tree)->plane)){
case GL2PS_IN_BACK_OF: return gl2psAddInBspImageTree(prim, &(*tree)->back);
case GL2PS_IN_FRONT_OF:
if((*tree)->front != NULL) return gl2psAddInBspImageTree(prim, &(*tree)->front);
else return 0;
case GL2PS_SPANNING:
gl2psSplitPrimitive2D(prim, (*tree)->plane, &frontprim, &backprim);
ret = gl2psAddInBspImageTree(backprim, &(*tree)->back);
if((*tree)->front != NULL){
if(gl2psAddInBspImageTree(frontprim, &(*tree)->front)){
ret = 1;
}
}
gl2psFree(frontprim->verts);
gl2psFree(frontprim);
gl2psFree(backprim->verts);
gl2psFree(backprim);
return ret;
case GL2PS_COINCIDENT:
if((*tree)->back != NULL){
gl2ps->zerosurfacearea = GL_TRUE;
ret = gl2psAddInBspImageTree(prim, &(*tree)->back);
gl2ps->zerosurfacearea = GL_FALSE;
if(ret) return ret;
}
if((*tree)->front != NULL){
gl2ps->zerosurfacearea = GL_TRUE;
ret = gl2psAddInBspImageTree(prim, &(*tree)->front);
gl2ps->zerosurfacearea = GL_FALSE;
if(ret) return ret;
}
if(prim->type == GL2PS_LINE) return 1;
else return 0;
}
}
return 0;
}
static void gl2psAddInImageTree(void *data)
{
GL2PSprimitive *prim = *(GL2PSprimitive **)data;
gl2ps->primitivetoadd = prim;
if(prim->type == GL2PS_IMAGEMAP && prim->data.image->format == GL2PS_IMAGEMAP_VISIBLE){
prim->culled = 1;
}
else if(!gl2psAddInBspImageTree(prim, &gl2ps->imagetree)){
prim->culled = 1;
}
else if(prim->type == GL2PS_IMAGEMAP){
prim->data.image->format = GL2PS_IMAGEMAP_VISIBLE;
}
}
/* Boundary construction */
static void gl2psAddBoundaryInList(GL2PSprimitive *prim, GL2PSlist *list)
{
GL2PSprimitive *b;
GLshort i;
GL2PSxyz c;
c[0] = c[1] = c[2] = 0.0F;
for(i = 0; i < prim->numverts; i++){
c[0] += prim->verts[i].xyz[0];
c[1] += prim->verts[i].xyz[1];
}
c[0] /= prim->numverts;
c[1] /= prim->numverts;
for(i = 0; i < prim->numverts; i++){
if(prim->boundary & (GLint)pow(2., i)){
b = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
b->type = GL2PS_LINE;
b->offset = prim->offset;
b->ofactor = prim->ofactor;
b->ounits = prim->ounits;
b->pattern = prim->pattern;
b->factor = prim->factor;
b->culled = prim->culled;
b->width = prim->width;
b->linecap = prim->linecap;
b->linejoin = prim->linejoin;
b->boundary = 0;
b->numverts = 2;
b->verts = (GL2PSvertex*)gl2psMalloc(2 * sizeof(GL2PSvertex));
#if 0 /* FIXME: need to work on boundary offset... */
v[0] = c[0] - prim->verts[i].xyz[0];
v[1] = c[1] - prim->verts[i].xyz[1];
v[2] = 0.0F;
norm = gl2psNorm(v);
v[0] /= norm;
v[1] /= norm;
b->verts[0].xyz[0] = prim->verts[i].xyz[0] +0.1*v[0];
b->verts[0].xyz[1] = prim->verts[i].xyz[1] +0.1*v[1];
b->verts[0].xyz[2] = prim->verts[i].xyz[2];
v[0] = c[0] - prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0];
v[1] = c[1] - prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1];
norm = gl2psNorm(v);
v[0] /= norm;
v[1] /= norm;
b->verts[1].xyz[0] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0] +0.1*v[0];
b->verts[1].xyz[1] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1] +0.1*v[1];
b->verts[1].xyz[2] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[2];
#else
b->verts[0].xyz[0] = prim->verts[i].xyz[0];
b->verts[0].xyz[1] = prim->verts[i].xyz[1];
b->verts[0].xyz[2] = prim->verts[i].xyz[2];
b->verts[1].xyz[0] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[0];
b->verts[1].xyz[1] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[1];
b->verts[1].xyz[2] = prim->verts[gl2psGetIndex(i, prim->numverts)].xyz[2];
#endif
b->verts[0].rgba[0] = 0.0F;
b->verts[0].rgba[1] = 0.0F;
b->verts[0].rgba[2] = 0.0F;
b->verts[0].rgba[3] = 0.0F;
b->verts[1].rgba[0] = 0.0F;
b->verts[1].rgba[1] = 0.0F;
b->verts[1].rgba[2] = 0.0F;
b->verts[1].rgba[3] = 0.0F;
gl2psListAdd(list, &b);
}
}
}
static void gl2psBuildPolygonBoundary(GL2PSbsptree *tree)
{
GLint i;
GL2PSprimitive *prim;
if(!tree) return;
gl2psBuildPolygonBoundary(tree->back);
for(i = 0; i < gl2psListNbr(tree->primitives); i++){
prim = *(GL2PSprimitive**)gl2psListPointer(tree->primitives, i);
if(prim->boundary) gl2psAddBoundaryInList(prim, tree->primitives);
}
gl2psBuildPolygonBoundary(tree->front);
}
/*********************************************************************
*
* Feedback buffer parser
*
*********************************************************************/
GL2PSDLL_API void gl2psAddPolyPrimitive(GLshort type, GLshort numverts,
GL2PSvertex *verts, GLint offset,
GLfloat ofactor, GLfloat ounits,
GLushort pattern, GLint factor,
GLfloat width, GLint linecap,
GLint linejoin,char boundary)
{
GL2PSprimitive *prim;
prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
prim->type = type;
prim->numverts = numverts;
prim->verts = (GL2PSvertex*)gl2psMalloc(numverts * sizeof(GL2PSvertex));
memcpy(prim->verts, verts, numverts * sizeof(GL2PSvertex));
prim->boundary = boundary;
prim->offset = (char)offset;
prim->ofactor = ofactor;
prim->ounits = ounits;
prim->pattern = pattern;
prim->factor = factor;
prim->width = width;
prim->linecap = linecap;
prim->linejoin = linejoin;
prim->culled = 0;
/* FIXME: here we should have an option to split stretched
tris/quads to enhance SIMPLE_SORT */
gl2psListAdd(gl2ps->primitives, &prim);
}
static GLint gl2psGetVertex(GL2PSvertex *v, GLfloat *p)
{
GLint i;
v->xyz[0] = p[0];
v->xyz[1] = p[1];
v->xyz[2] = p[2];
if(gl2ps->colormode == GL_COLOR_INDEX && gl2ps->colorsize > 0){
i = (GLint)(p[3] + 0.5);
v->rgba[0] = gl2ps->colormap[i][0];
v->rgba[1] = gl2ps->colormap[i][1];
v->rgba[2] = gl2ps->colormap[i][2];
v->rgba[3] = gl2ps->colormap[i][3];
return 4;
}
else{
v->rgba[0] = p[3];
v->rgba[1] = p[4];
v->rgba[2] = p[5];
v->rgba[3] = p[6];
return 7;
}
}
static void gl2psParseFeedbackBuffer(GLint used)
{
char flag;
GLushort pattern = 0;
GLboolean boundary;
GLint i, sizeoffloat, count, v, vtot, offset = 0, factor = 0, auxindex = 0;
GLint lcap = 0, ljoin = 0;
GLfloat lwidth = 1.0F, psize = 1.0F, ofactor = 1.0F, ounits = 1.0F;
GLfloat *current;
GL2PSvertex vertices[3];
GL2PSprimitive *prim;
GL2PSimagemap *node;
current = gl2ps->feedback;
boundary = gl2ps->boundary = GL_FALSE;
while(used > 0){
if(GL_TRUE == boundary) gl2ps->boundary = GL_TRUE;
switch((GLint)*current){
case GL_POINT_TOKEN :
current ++;
used --;
i = gl2psGetVertex(&vertices[0], current);
current += i;
used -= i;
gl2psAddPolyPrimitive(GL2PS_POINT, 1, vertices, 0, 0.0, 0.0,
pattern, factor, psize, lcap, ljoin, 0);
break;
case GL_LINE_TOKEN :
case GL_LINE_RESET_TOKEN :
current ++;
used --;
i = gl2psGetVertex(&vertices[0], current);
current += i;
used -= i;
i = gl2psGetVertex(&vertices[1], current);
current += i;
used -= i;
gl2psAddPolyPrimitive(GL2PS_LINE, 2, vertices, 0, 0.0, 0.0,
pattern, factor, lwidth, lcap, ljoin, 0);
break;
case GL_POLYGON_TOKEN :
count = (GLint)current[1];
current += 2;
used -= 2;
v = vtot = 0;
while(count > 0 && used > 0){
i = gl2psGetVertex(&vertices[v], current);
gl2psAdaptVertexForBlending(&vertices[v]);
current += i;
used -= i;
count --;
vtot++;
if(v == 2){
if(GL_TRUE == boundary){
if(!count && vtot == 2) flag = 1|2|4;
else if(!count) flag = 2|4;
else if(vtot == 2) flag = 1|2;
else flag = 2;
}
else
flag = 0;
gl2psAddPolyPrimitive(GL2PS_TRIANGLE, 3, vertices, offset, ofactor,
ounits, pattern, factor, 1, lcap, ljoin,
flag);
vertices[1] = vertices[2];
}
else
v ++;
}
break;
case GL_BITMAP_TOKEN :
case GL_DRAW_PIXEL_TOKEN :
case GL_COPY_PIXEL_TOKEN :
current ++;
used --;
i = gl2psGetVertex(&vertices[0], current);
current += i;
used -= i;
break;
case GL_PASS_THROUGH_TOKEN :
switch((GLint)current[1]){
case GL2PS_BEGIN_OFFSET_TOKEN :
offset = 1;
current += 2;
used -= 2;
ofactor = current[1];
current += 2;
used -= 2;
ounits = current[1];
break;
case GL2PS_END_OFFSET_TOKEN :
offset = 0;
ofactor = 0.0;
ounits = 0.0;
break;
case GL2PS_BEGIN_BOUNDARY_TOKEN : boundary = GL_TRUE; break;
case GL2PS_END_BOUNDARY_TOKEN : boundary = GL_FALSE; break;
case GL2PS_END_STIPPLE_TOKEN : pattern = 0; factor = 0; break;
case GL2PS_BEGIN_BLEND_TOKEN : gl2ps->blending = GL_TRUE; break;
case GL2PS_END_BLEND_TOKEN : gl2ps->blending = GL_FALSE; break;
case GL2PS_BEGIN_STIPPLE_TOKEN :
current += 2;
used -= 2;
pattern = (GLushort)current[1];
current += 2;
used -= 2;
factor = (GLint)current[1];
break;
case GL2PS_SRC_BLEND_TOKEN :
current += 2;
used -= 2;
gl2ps->blendfunc[0] = (GLint)current[1];
break;
case GL2PS_DST_BLEND_TOKEN :
current += 2;
used -= 2;
gl2ps->blendfunc[1] = (GLint)current[1];
break;
case GL2PS_POINT_SIZE_TOKEN :
current += 2;
used -= 2;
psize = current[1];
break;
case GL2PS_LINE_CAP_TOKEN :
current += 2;
used -= 2;
lcap = (GLint)current[1];
break;
case GL2PS_LINE_JOIN_TOKEN :
current += 2;
used -= 2;
ljoin = (GLint)current[1];
break;
case GL2PS_LINE_WIDTH_TOKEN :
current += 2;
used -= 2;
lwidth = current[1];
break;
case GL2PS_IMAGEMAP_TOKEN :
prim = (GL2PSprimitive *)gl2psMalloc(sizeof(GL2PSprimitive));
prim->type = GL2PS_IMAGEMAP;
prim->boundary = 0;
prim->numverts = 4;
prim->verts = (GL2PSvertex *)gl2psMalloc(4 * sizeof(GL2PSvertex));
prim->culled = 0;
prim->offset = 0;
prim->ofactor = 0.0;
prim->ounits = 0.0;
prim->pattern = 0;
prim->factor = 0;
prim->width = 1;
node = (GL2PSimagemap*)gl2psMalloc(sizeof(GL2PSimagemap));
node->image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
node->image->type = 0;
node->image->format = 0;
node->image->zoom_x = 1.0F;
node->image->zoom_y = 1.0F;
node->next = NULL;
if(gl2ps->imagemap_head == NULL)
gl2ps->imagemap_head = node;
else
gl2ps->imagemap_tail->next = node;
gl2ps->imagemap_tail = node;
prim->data.image = node->image;
current += 2; used -= 2;
i = gl2psGetVertex(&prim->verts[0], ¤t[1]);
current += i; used -= i;
node->image->width = (GLint)current[2];
current += 2; used -= 2;
node->image->height = (GLint)current[2];
prim->verts[0].xyz[0] = prim->verts[0].xyz[0] - (int)(node->image->width / 2) + 0.5F;
prim->verts[0].xyz[1] = prim->verts[0].xyz[1] - (int)(node->image->height / 2) + 0.5F;
for(i = 1; i < 4; i++){
for(v = 0; v < 3; v++){
prim->verts[i].xyz[v] = prim->verts[0].xyz[v];
prim->verts[i].rgba[v] = prim->verts[0].rgba[v];
}
prim->verts[i].rgba[v] = prim->verts[0].rgba[v];
}
prim->verts[1].xyz[0] = prim->verts[1].xyz[0] + node->image->width;
prim->verts[2].xyz[0] = prim->verts[1].xyz[0];
prim->verts[2].xyz[1] = prim->verts[2].xyz[1] + node->image->height;
prim->verts[3].xyz[1] = prim->verts[2].xyz[1];
sizeoffloat = sizeof(GLfloat);
v = 2 * sizeoffloat;
vtot = node->image->height + node->image->height *
((node->image->width - 1) / 8);
node->image->pixels = (GLfloat*)gl2psMalloc(v + vtot);
node->image->pixels[0] = prim->verts[0].xyz[0];
node->image->pixels[1] = prim->verts[0].xyz[1];
for(i = 0; i < vtot; i += sizeoffloat){
current += 2; used -= 2;
if((vtot - i) >= 4)
memcpy(&(((char*)(node->image->pixels))[i + v]), &(current[2]), sizeoffloat);
else
memcpy(&(((char*)(node->image->pixels))[i + v]), &(current[2]), vtot - i);
}
current++; used--;
gl2psListAdd(gl2ps->primitives, &prim);
break;
case GL2PS_DRAW_PIXELS_TOKEN :
case GL2PS_TEXT_TOKEN :
if(auxindex < gl2psListNbr(gl2ps->auxprimitives))
gl2psListAdd(gl2ps->primitives,
gl2psListPointer(gl2ps->auxprimitives, auxindex++));
else
gl2psMsg(GL2PS_ERROR, "Wrong number of auxiliary tokens in buffer");
break;
}
current += 2;
used -= 2;
break;
default :
gl2psMsg(GL2PS_WARNING, "Unknown token in buffer");
current ++;
used --;
break;
}
}
gl2psListReset(gl2ps->auxprimitives);
}
/*********************************************************************
*
* PostScript routines
*
*********************************************************************/
static void gl2psWriteByte(unsigned char byte)
{
unsigned char h = byte / 16;
unsigned char l = byte % 16;
gl2psPrintf("%x%x", h, l);
}
static void gl2psPrintPostScriptPixmap(GLfloat x, GLfloat y, GL2PSimage *im)
{
GLuint nbhex, nbyte, nrgb, nbits;
GLuint row, col, ibyte, icase;
GLfloat dr = 0., dg = 0., db = 0., fgrey;
unsigned char red = 0, green = 0, blue = 0, b, grey;
GLuint width = (GLuint)im->width;
GLuint height = (GLuint)im->height;
/* FIXME: should we define an option for these? Or just keep the
8-bit per component case? */
int greyscale = 0; /* set to 1 to output greyscale image */
int nbit = 8; /* number of bits per color compoment (2, 4 or 8) */
if((width <= 0) || (height <= 0)) return;
gl2psPrintf("gsave\n");
gl2psPrintf("%.2f %.2f translate\n", x, y);
gl2psPrintf("%.2f %.2f scale\n", width * im->zoom_x, height * im->zoom_y);
if(greyscale){ /* greyscale */
gl2psPrintf("/picstr %d string def\n", width);
gl2psPrintf("%d %d %d\n", width, height, 8);
gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
gl2psPrintf("{ currentfile picstr readhexstring pop }\n");
gl2psPrintf("image\n");
for(row = 0; row < height; row++){
for(col = 0; col < width; col++){
gl2psGetRGB(im, col, row, &dr, &dg, &db);
fgrey = (0.30F * dr + 0.59F * dg + 0.11F * db);
grey = (unsigned char)(255. * fgrey);
gl2psWriteByte(grey);
}
gl2psPrintf("\n");
}
nbhex = width * height * 2;
gl2psPrintf("%%%% nbhex digit :%d\n", nbhex);
}
else if(nbit == 2){ /* color, 2 bits for r and g and b; rgbs following each other */
nrgb = width * 3;
nbits = nrgb * nbit;
nbyte = nbits / 8;
if((nbyte * 8) != nbits) nbyte++;
gl2psPrintf("/rgbstr %d string def\n", nbyte);
gl2psPrintf("%d %d %d\n", width, height, nbit);
gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n");
gl2psPrintf("false 3\n");
gl2psPrintf("colorimage\n");
for(row = 0; row < height; row++){
icase = 1;
col = 0;
b = 0;
for(ibyte = 0; ibyte < nbyte; ibyte++){
if(icase == 1) {
if(col < width) {
gl2psGetRGB(im, col, row, &dr, &dg, &db);
}
else {
dr = dg = db = 0;
}
col++;
red = (unsigned char)(3. * dr);
green = (unsigned char)(3. * dg);
blue = (unsigned char)(3. * db);
b = red;
b = (unsigned char)(b<<2) + green;
b = (unsigned char)(b<<2) + blue;
if(col < width) {
gl2psGetRGB(im, col, row, &dr, &dg, &db);
}
else {
dr = dg = db = 0;
}
col++;
red = (unsigned char)(3. * dr);
green = (unsigned char)(3. * dg);
blue = (unsigned char)(3. * db);
b = (unsigned char)(b<<2) + red;
gl2psWriteByte(b);
b = 0;
icase++;
}
else if(icase == 2) {
b = green;
b = (unsigned char)(b<<2) + blue;
if(col < width) {
gl2psGetRGB(im, col, row, &dr, &dg, &db);
}
else {
dr = dg = db = 0;
}
col++;
red = (unsigned char)(3. * dr);
green = (unsigned char)(3. * dg);
blue = (unsigned char)(3. * db);
b = (unsigned char)(b<<2) + red;
b = (unsigned char)(b<<2) + green;
gl2psWriteByte(b);
b = 0;
icase++;
}
else if(icase == 3) {
b = blue;
if(col < width) {
gl2psGetRGB(im, col, row, &dr, &dg, &db);
}
else {
dr = dg = db = 0;
}
col++;
red = (unsigned char)(3. * dr);
green = (unsigned char)(3. * dg);
blue = (unsigned char)(3. * db);
b = (unsigned char)(b<<2) + red;
b = (unsigned char)(b<<2) + green;
b = (unsigned char)(b<<2) + blue;
gl2psWriteByte(b);
b = 0;
icase = 1;
}
}
gl2psPrintf("\n");
}
}
else if(nbit == 4){ /* color, 4 bits for r and g and b; rgbs following each other */
nrgb = width * 3;
nbits = nrgb * nbit;
nbyte = nbits / 8;
if((nbyte * 8) != nbits) nbyte++;
gl2psPrintf("/rgbstr %d string def\n", nbyte);
gl2psPrintf("%d %d %d\n", width, height, nbit);
gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n");
gl2psPrintf("false 3\n");
gl2psPrintf("colorimage\n");
for(row = 0; row < height; row++){
col = 0;
icase = 1;
for(ibyte = 0; ibyte < nbyte; ibyte++){
if(icase == 1) {
if(col < width) {
gl2psGetRGB(im, col, row, &dr, &dg, &db);
}
else {
dr = dg = db = 0;
}
col++;
red = (unsigned char)(15. * dr);
green = (unsigned char)(15. * dg);
gl2psPrintf("%x%x", red, green);
icase++;
}
else if(icase == 2) {
blue = (unsigned char)(15. * db);
if(col < width) {
gl2psGetRGB(im, col, row, &dr, &dg, &db);
}
else {
dr = dg = db = 0;
}
col++;
red = (unsigned char)(15. * dr);
gl2psPrintf("%x%x", blue, red);
icase++;
}
else if(icase == 3) {
green = (unsigned char)(15. * dg);
blue = (unsigned char)(15. * db);
gl2psPrintf("%x%x", green, blue);
icase = 1;
}
}
gl2psPrintf("\n");
}
}
else{ /* 8 bit for r and g and b */
nbyte = width * 3;
gl2psPrintf("/rgbstr %d string def\n", nbyte);
gl2psPrintf("%d %d %d\n", width, height, 8);
gl2psPrintf("[ %d 0 0 -%d 0 %d ]\n", width, height, height);
gl2psPrintf("{ currentfile rgbstr readhexstring pop }\n");
gl2psPrintf("false 3\n");
gl2psPrintf("colorimage\n");
for(row = 0; row < height; row++){
for(col = 0; col < width; col++){
gl2psGetRGB(im, col, row, &dr, &dg, &db);
red = (unsigned char)(255. * dr);
gl2psWriteByte(red);
green = (unsigned char)(255. * dg);
gl2psWriteByte(green);
blue = (unsigned char)(255. * db);
gl2psWriteByte(blue);
}
gl2psPrintf("\n");
}
}
gl2psPrintf("grestore\n");
}
static void gl2psPrintPostScriptImagemap(GLfloat x, GLfloat y,
GLsizei width, GLsizei height,
const unsigned char *imagemap){
int i, size;
if((width <= 0) || (height <= 0)) return;
size = height + height * (width - 1) / 8;
gl2psPrintf("gsave\n");
gl2psPrintf("%.2f %.2f translate\n", x, y);
gl2psPrintf("%d %d scale\n%d %d\ntrue\n", width, height,width, height);
gl2psPrintf("[ %d 0 0 -%d 0 %d ] {<", width, height);
for(i = 0; i < size; i++){
gl2psWriteByte(*imagemap);
imagemap++;
}
gl2psPrintf(">} imagemask\ngrestore\n");
}
static void gl2psPrintPostScriptHeader(void)
{
time_t now;
/* Since compression is not part of the PostScript standard,
compressed PostScript files are just gzipped PostScript files
("ps.gz" or "eps.gz") */
gl2psPrintGzipHeader();
time(&now);
if(gl2ps->format == GL2PS_PS){
gl2psPrintf("%%!PS-Adobe-3.0\n");
}
else{
gl2psPrintf("%%!PS-Adobe-3.0 EPSF-3.0\n");
}
gl2psPrintf("%%%%Title: %s\n"
"%%%%Creator: GL2PS %d.%d.%d%s, %s\n"
"%%%%For: %s\n"
"%%%%CreationDate: %s"
"%%%%LanguageLevel: 3\n"
"%%%%DocumentData: Clean7Bit\n"
"%%%%Pages: 1\n",
gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
gl2ps->producer, ctime(&now));
if(gl2ps->format == GL2PS_PS){
gl2psPrintf("%%%%Orientation: %s\n"
"%%%%DocumentMedia: Default %d %d 0 () ()\n",
(gl2ps->options & GL2PS_LANDSCAPE) ? "Landscape" : "Portrait",
(gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[3] :
(int)gl2ps->viewport[2],
(gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[2] :
(int)gl2ps->viewport[3]);
}
gl2psPrintf("%%%%BoundingBox: %d %d %d %d\n"
"%%%%EndComments\n",
(gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[1] :
(int)gl2ps->viewport[0],
(gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[0] :
(int)gl2ps->viewport[1],
(gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[3] :
(int)gl2ps->viewport[2],
(gl2ps->options & GL2PS_LANDSCAPE) ? (int)gl2ps->viewport[2] :
(int)gl2ps->viewport[3]);
/* RGB color: r g b C (replace C by G in output to change from rgb to gray)
Grayscale: r g b G
Font choose: size fontname FC
Text string: (string) x y size fontname S??
Rotated text string: (string) angle x y size fontname S??R
Point primitive: x y size P
Line width: width W
Line start: x y LS
Line joining last point: x y L
Line end: x y LE
Flat-shaded triangle: x3 y3 x2 y2 x1 y1 T
Smooth-shaded triangle: x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 ST */
gl2psPrintf("%%%%BeginProlog\n"
"/gl2psdict 64 dict def gl2psdict begin\n"
"/tryPS3shading %s def %% set to false to force subdivision\n"
"/rThreshold %g def %% red component subdivision threshold\n"
"/gThreshold %g def %% green component subdivision threshold\n"
"/bThreshold %g def %% blue component subdivision threshold\n",
(gl2ps->options & GL2PS_NO_PS3_SHADING) ? "false" : "true",
gl2ps->threshold[0], gl2ps->threshold[1], gl2ps->threshold[2]);
gl2psPrintf("/BD { bind def } bind def\n"
"/C { setrgbcolor } BD\n"
"/G { 0.082 mul exch 0.6094 mul add exch 0.3086 mul add neg 1.0 add setgray } BD\n"
"/W { setlinewidth } BD\n"
"/LC { setlinecap } BD\n"
"/LJ { setlinejoin } BD\n");
gl2psPrintf("/FC { findfont exch /SH exch def SH scalefont setfont } BD\n"
"/SW { dup stringwidth pop } BD\n"
"/S { FC moveto show } BD\n"
"/SBC{ FC moveto SW -2 div 0 rmoveto show } BD\n"
"/SBR{ FC moveto SW neg 0 rmoveto show } BD\n"
"/SCL{ FC moveto 0 SH -2 div rmoveto show } BD\n"
"/SCC{ FC moveto SW -2 div SH -2 div rmoveto show } BD\n"
"/SCR{ FC moveto SW neg SH -2 div rmoveto show } BD\n"
"/STL{ FC moveto 0 SH neg rmoveto show } BD\n"
"/STC{ FC moveto SW -2 div SH neg rmoveto show } BD\n"
"/STR{ FC moveto SW neg SH neg rmoveto show } BD\n");
/* rotated text routines: same nameanem with R appended */
gl2psPrintf("/FCT { FC translate 0 0 } BD\n"
"/SR { gsave FCT moveto rotate show grestore } BD\n"
"/SBCR{ gsave FCT moveto rotate SW -2 div 0 rmoveto show grestore } BD\n"
"/SBRR{ gsave FCT moveto rotate SW neg 0 rmoveto show grestore } BD\n"
"/SCLR{ gsave FCT moveto rotate 0 SH -2 div rmoveto show grestore} BD\n");
gl2psPrintf("/SCCR{ gsave FCT moveto rotate SW -2 div SH -2 div rmoveto show grestore} BD\n"
"/SCRR{ gsave FCT moveto rotate SW neg SH -2 div rmoveto show grestore} BD\n"
"/STLR{ gsave FCT moveto rotate 0 SH neg rmoveto show grestore } BD\n"
"/STCR{ gsave FCT moveto rotate SW -2 div SH neg rmoveto show grestore } BD\n"
"/STRR{ gsave FCT moveto rotate SW neg SH neg rmoveto show grestore } BD\n");
gl2psPrintf("/P { newpath 0.0 360.0 arc closepath fill } BD\n"
"/LS { newpath moveto } BD\n"
"/L { lineto } BD\n"
"/LE { lineto stroke } BD\n"
"/T { newpath moveto lineto lineto closepath fill } BD\n");
/* Smooth-shaded triangle with PostScript level 3 shfill operator:
x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STshfill */
gl2psPrintf("/STshfill {\n"
" /b1 exch def /g1 exch def /r1 exch def /y1 exch def /x1 exch def\n"
" /b2 exch def /g2 exch def /r2 exch def /y2 exch def /x2 exch def\n"
" /b3 exch def /g3 exch def /r3 exch def /y3 exch def /x3 exch def\n"
" gsave << /ShadingType 4 /ColorSpace [/DeviceRGB]\n"
" /DataSource [ 0 x1 y1 r1 g1 b1 0 x2 y2 r2 g2 b2 0 x3 y3 r3 g3 b3 ] >>\n"
" shfill grestore } BD\n");
/* Flat-shaded triangle with middle color:
x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 Tm */
gl2psPrintf(/* stack : x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 */
"/Tm { 3 -1 roll 8 -1 roll 13 -1 roll add add 3 div\n" /* r = (r1+r2+r3)/3 */
/* stack : x3 y3 g3 b3 x2 y2 g2 b2 x1 y1 g1 b1 r */
" 3 -1 roll 7 -1 roll 11 -1 roll add add 3 div\n" /* g = (g1+g2+g3)/3 */
/* stack : x3 y3 b3 x2 y2 b2 x1 y1 b1 r g b */
" 3 -1 roll 6 -1 roll 9 -1 roll add add 3 div" /* b = (b1+b2+b3)/3 */
/* stack : x3 y3 x2 y2 x1 y1 r g b */
" C T } BD\n");
/* Split triangle in four sub-triangles (at sides middle points) and call the
STnoshfill procedure on each, interpolating the colors in RGB space:
x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STsplit
(in procedure comments key: (Vi) = xi yi ri gi bi) */
gl2psPrintf("/STsplit {\n"
" 4 index 15 index add 0.5 mul\n" /* x13 = (x1+x3)/2 */
" 4 index 15 index add 0.5 mul\n" /* y13 = (y1+y3)/2 */
" 4 index 15 index add 0.5 mul\n" /* r13 = (r1+r3)/2 */
" 4 index 15 index add 0.5 mul\n" /* g13 = (g1+g3)/2 */
" 4 index 15 index add 0.5 mul\n" /* b13 = (b1+b3)/2 */
" 5 copy 5 copy 25 15 roll\n");
/* at his point, stack = (V3) (V13) (V13) (V13) (V2) (V1) */
gl2psPrintf(" 9 index 30 index add 0.5 mul\n" /* x23 = (x2+x3)/2 */
" 9 index 30 index add 0.5 mul\n" /* y23 = (y2+y3)/2 */
" 9 index 30 index add 0.5 mul\n" /* r23 = (r2+r3)/2 */
" 9 index 30 index add 0.5 mul\n" /* g23 = (g2+g3)/2 */
" 9 index 30 index add 0.5 mul\n" /* b23 = (b2+b3)/2 */
" 5 copy 5 copy 35 5 roll 25 5 roll 15 5 roll\n");
/* stack = (V3) (V13) (V23) (V13) (V23) (V13) (V23) (V2) (V1) */
gl2psPrintf(" 4 index 10 index add 0.5 mul\n" /* x12 = (x1+x2)/2 */
" 4 index 10 index add 0.5 mul\n" /* y12 = (y1+y2)/2 */
" 4 index 10 index add 0.5 mul\n" /* r12 = (r1+r2)/2 */
" 4 index 10 index add 0.5 mul\n" /* g12 = (g1+g2)/2 */
" 4 index 10 index add 0.5 mul\n" /* b12 = (b1+b2)/2 */
" 5 copy 5 copy 40 5 roll 25 5 roll 15 5 roll 25 5 roll\n");
/* stack = (V3) (V13) (V23) (V13) (V12) (V23) (V13) (V1) (V12) (V23) (V12) (V2) */
gl2psPrintf(" STnoshfill STnoshfill STnoshfill STnoshfill } BD\n");
/* Gouraud shaded triangle using recursive subdivision until the difference
between corner colors does not exceed the thresholds:
x3 y3 r3 g3 b3 x2 y2 r2 g2 b2 x1 y1 r1 g1 b1 STnoshfill */
gl2psPrintf("/STnoshfill {\n"
" 2 index 8 index sub abs rThreshold gt\n" /* |r1-r2|>rth */
" { STsplit }\n"
" { 1 index 7 index sub abs gThreshold gt\n" /* |g1-g2|>gth */
" { STsplit }\n"
" { dup 6 index sub abs bThreshold gt\n" /* |b1-b2|>bth */
" { STsplit }\n"
" { 2 index 13 index sub abs rThreshold gt\n" /* |r1-r3|>rht */
" { STsplit }\n"
" { 1 index 12 index sub abs gThreshold gt\n" /* |g1-g3|>gth */
" { STsplit }\n"
" { dup 11 index sub abs bThreshold gt\n" /* |b1-b3|>bth */
" { STsplit }\n"
" { 7 index 13 index sub abs rThreshold gt\n"); /* |r2-r3|>rht */
gl2psPrintf(" { STsplit }\n"
" { 6 index 12 index sub abs gThreshold gt\n" /* |g2-g3|>gth */
" { STsplit }\n"
" { 5 index 11 index sub abs bThreshold gt\n" /* |b2-b3|>bth */
" { STsplit }\n"
" { Tm }\n" /* all colors sufficiently similar */
" ifelse }\n"
" ifelse }\n"
" ifelse }\n"
" ifelse }\n"
" ifelse }\n"
" ifelse }\n"
" ifelse }\n"
" ifelse }\n"
" ifelse } BD\n");
gl2psPrintf("tryPS3shading\n"
"{ /shfill where\n"
" { /ST { STshfill } BD }\n"
" { /ST { STnoshfill } BD }\n"
" ifelse }\n"
"{ /ST { STnoshfill } BD }\n"
"ifelse\n");
gl2psPrintf("end\n"
"%%%%EndProlog\n"
"%%%%BeginSetup\n"
"/DeviceRGB setcolorspace\n"
"gl2psdict begin\n"
"%%%%EndSetup\n"
"%%%%Page: 1 1\n"
"%%%%BeginPageSetup\n");
if(gl2ps->options & GL2PS_LANDSCAPE){
gl2psPrintf("%d 0 translate 90 rotate\n",
(int)gl2ps->viewport[3]);
}
gl2psPrintf("%%%%EndPageSetup\n"
"mark\n"
"gsave\n"
"1.0 1.0 scale\n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
gl2psPrintf("%g %g %g C\n"
"newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n"
"closepath fill\n",
gl2ps->bgcolor[0], gl2ps->bgcolor[1], gl2ps->bgcolor[2],
(int)gl2ps->viewport[0], (int)gl2ps->viewport[1], (int)gl2ps->viewport[2],
(int)gl2ps->viewport[1], (int)gl2ps->viewport[2], (int)gl2ps->viewport[3],
(int)gl2ps->viewport[0], (int)gl2ps->viewport[3]);
}
}
static void gl2psPrintPostScriptColor(GL2PSrgba rgba)
{
if(!gl2psSameColor(gl2ps->lastrgba, rgba)){
gl2psSetLastColor(rgba);
gl2psPrintf("%g %g %g C\n", rgba[0], rgba[1], rgba[2]);
}
}
static void gl2psResetPostScriptColor(void)
{
gl2ps->lastrgba[0] = gl2ps->lastrgba[1] = gl2ps->lastrgba[2] = -1.;
}
static void gl2psEndPostScriptLine(void)
{
int i;
if(gl2ps->lastvertex.rgba[0] >= 0.){
gl2psPrintf("%g %g LE\n", gl2ps->lastvertex.xyz[0], gl2ps->lastvertex.xyz[1]);
for(i = 0; i < 3; i++)
gl2ps->lastvertex.xyz[i] = -1.;
for(i = 0; i < 4; i++)
gl2ps->lastvertex.rgba[i] = -1.;
}
}
static void gl2psParseStipplePattern(GLushort pattern, GLint factor,
int *nb, int array[10])
{
int i, n;
int on[8] = {0, 0, 0, 0, 0, 0, 0, 0};
int off[8] = {0, 0, 0, 0, 0, 0, 0, 0};
char tmp[16];
/* extract the 16 bits from the OpenGL stipple pattern */
for(n = 15; n >= 0; n--){
tmp[n] = (char)(pattern & 0x01);
pattern >>= 1;
}
/* compute the on/off pixel sequence */
n = 0;
for(i = 0; i < 8; i++){
while(n < 16 && !tmp[n]){ off[i]++; n++; }
while(n < 16 && tmp[n]){ on[i]++; n++; }
if(n >= 15){ i++; break; }
}
/* store the on/off array from right to left, starting with off
pixels. The PostScript specification allows for at most 11
elements in the on/off array, so we limit ourselves to 5 on/off
couples (our longest possible array is thus [on4 off4 on3 off3
on2 off2 on1 off1 on0 off0]) */
*nb = 0;
for(n = i - 1; n >= 0; n--){
array[(*nb)++] = factor * on[n];
array[(*nb)++] = factor * off[n];
if(*nb == 10) break;
}
}
static int gl2psPrintPostScriptDash(GLushort pattern, GLint factor, const char *str)
{
int len = 0, i, n, array[10];
if(pattern == gl2ps->lastpattern && factor == gl2ps->lastfactor)
return 0;
gl2ps->lastpattern = pattern;
gl2ps->lastfactor = factor;
if(!pattern || !factor){
/* solid line */
len += gl2psPrintf("[] 0 %s\n", str);
}
else{
gl2psParseStipplePattern(pattern, factor, &n, array);
len += gl2psPrintf("[");
for(i = 0; i < n; i++){
if(i) len += gl2psPrintf(" ");
len += gl2psPrintf("%d", array[i]);
}
len += gl2psPrintf("] 0 %s\n", str);
}
return len;
}
static void gl2psPrintPostScriptPrimitive(void *data)
{
int newline;
GL2PSprimitive *prim;
prim = *(GL2PSprimitive**)data;
if((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) return;
/* Every effort is made to draw lines as connected segments (i.e.,
using a single PostScript path): this is the only way to get nice
line joins and to not restart the stippling for every line
segment. So if the primitive to print is not a line we must first
finish the current line (if any): */
if(prim->type != GL2PS_LINE) gl2psEndPostScriptLine();
switch(prim->type){
case GL2PS_POINT :
gl2psPrintPostScriptColor(prim->verts[0].rgba);
gl2psPrintf("%g %g %g P\n",
prim->verts[0].xyz[0], prim->verts[0].xyz[1], 0.5 * prim->width);
break;
case GL2PS_LINE :
if(!gl2psSamePosition(gl2ps->lastvertex.xyz, prim->verts[0].xyz) ||
!gl2psSameColor(gl2ps->lastrgba, prim->verts[0].rgba) ||
gl2ps->lastlinewidth != prim->width ||
gl2ps->lastlinecap != prim->linecap ||
gl2ps->lastlinejoin != prim->linejoin ||
gl2ps->lastpattern != prim->pattern ||
gl2ps->lastfactor != prim->factor){
/* End the current line if the new segment does not start where
the last one ended, or if the color, the width or the
stippling have changed (multi-stroking lines with changing
colors is necessary until we use /shfill for lines;
unfortunately this means that at the moment we can screw up
line stippling for smooth-shaded lines) */
gl2psEndPostScriptLine();
newline = 1;
}
else{
newline = 0;
}
if(gl2ps->lastlinewidth != prim->width){
gl2ps->lastlinewidth = prim->width;
gl2psPrintf("%g W\n", gl2ps->lastlinewidth);
}
if(gl2ps->lastlinecap != prim->linecap){
gl2ps->lastlinecap = prim->linecap;
gl2psPrintf("%d LC\n", gl2ps->lastlinecap);
}
if(gl2ps->lastlinejoin != prim->linejoin){
gl2ps->lastlinejoin = prim->linejoin;
gl2psPrintf("%d LJ\n", gl2ps->lastlinejoin);
}
gl2psPrintPostScriptDash(prim->pattern, prim->factor, "setdash");
gl2psPrintPostScriptColor(prim->verts[0].rgba);
gl2psPrintf("%g %g %s\n", prim->verts[0].xyz[0], prim->verts[0].xyz[1],
newline ? "LS" : "L");
gl2ps->lastvertex = prim->verts[1];
break;
case GL2PS_TRIANGLE :
if(!gl2psVertsSameColor(prim)){
gl2psResetPostScriptColor();
gl2psPrintf("%g %g %g %g %g %g %g %g %g %g %g %g %g %g %g ST\n",
prim->verts[2].xyz[0], prim->verts[2].xyz[1],
prim->verts[2].rgba[0], prim->verts[2].rgba[1],
prim->verts[2].rgba[2], prim->verts[1].xyz[0],
prim->verts[1].xyz[1], prim->verts[1].rgba[0],
prim->verts[1].rgba[1], prim->verts[1].rgba[2],
prim->verts[0].xyz[0], prim->verts[0].xyz[1],
prim->verts[0].rgba[0], prim->verts[0].rgba[1],
prim->verts[0].rgba[2]);
}
else{
gl2psPrintPostScriptColor(prim->verts[0].rgba);
gl2psPrintf("%g %g %g %g %g %g T\n",
prim->verts[2].xyz[0], prim->verts[2].xyz[1],
prim->verts[1].xyz[0], prim->verts[1].xyz[1],
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
}
break;
case GL2PS_QUADRANGLE :
gl2psMsg(GL2PS_WARNING, "There should not be any quad left to print");
break;
case GL2PS_PIXMAP :
gl2psPrintPostScriptPixmap(prim->verts[0].xyz[0], prim->verts[0].xyz[1],
prim->data.image);
break;
case GL2PS_IMAGEMAP :
if(prim->data.image->type != GL2PS_IMAGEMAP_WRITTEN){
gl2psPrintPostScriptColor(prim->verts[0].rgba);
gl2psPrintPostScriptImagemap(prim->data.image->pixels[0],
prim->data.image->pixels[1],
prim->data.image->width, prim->data.image->height,
(const unsigned char*)(&(prim->data.image->pixels[2])));
prim->data.image->type = GL2PS_IMAGEMAP_WRITTEN;
}
break;
case GL2PS_TEXT :
gl2psPrintPostScriptColor(prim->verts[0].rgba);
gl2psPrintf("(%s) ", prim->data.text->str);
if(prim->data.text->angle != 0.0)
gl2psPrintf("%g ", prim->data.text->angle);
gl2psPrintf("%g %g %d /%s ",
prim->verts[0].xyz[0], prim->verts[0].xyz[1],
prim->data.text->fontsize, prim->data.text->fontname);
switch(prim->data.text->alignment){
case GL2PS_TEXT_C:
gl2psPrintf(prim->data.text->angle != 0.0 ? "SCCR\n" : "SCC\n");
break;
case GL2PS_TEXT_CL:
gl2psPrintf(prim->data.text->angle != 0.0 ? "SCLR\n" : "SCL\n");
break;
case GL2PS_TEXT_CR:
gl2psPrintf(prim->data.text->angle != 0.0 ? "SCRR\n" : "SCR\n");
break;
case GL2PS_TEXT_B:
gl2psPrintf(prim->data.text->angle != 0.0 ? "SBCR\n" : "SBC\n");
break;
case GL2PS_TEXT_BR:
gl2psPrintf(prim->data.text->angle != 0.0 ? "SBRR\n" : "SBR\n");
break;
case GL2PS_TEXT_T:
gl2psPrintf(prim->data.text->angle != 0.0 ? "STCR\n" : "STC\n");
break;
case GL2PS_TEXT_TL:
gl2psPrintf(prim->data.text->angle != 0.0 ? "STLR\n" : "STL\n");
break;
case GL2PS_TEXT_TR:
gl2psPrintf(prim->data.text->angle != 0.0 ? "STRR\n" : "STR\n");
break;
case GL2PS_TEXT_BL:
default:
gl2psPrintf(prim->data.text->angle != 0.0 ? "SR\n" : "S\n");
break;
}
break;
case GL2PS_SPECIAL :
/* alignment contains the format for which the special output text
is intended */
if(prim->data.text->alignment == GL2PS_PS ||
prim->data.text->alignment == GL2PS_EPS)
gl2psPrintf("%s\n", prim->data.text->str);
break;
default :
break;
}
}
static void gl2psPrintPostScriptFooter(void)
{
gl2psPrintf("grestore\n"
"showpage\n"
"cleartomark\n"
"%%%%PageTrailer\n"
"%%%%Trailer\n"
"end\n"
"%%%%EOF\n");
gl2psPrintGzipFooter();
}
static void gl2psPrintPostScriptBeginViewport(GLint viewport[4])
{
GLint idx;
GLfloat rgba[4];
int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
glRenderMode(GL_FEEDBACK);
if(gl2ps->header){
gl2psPrintPostScriptHeader();
gl2ps->header = GL_FALSE;
}
gl2psResetPostScriptColor();
gl2psResetLineProperties();
gl2psPrintf("gsave\n"
"1.0 1.0 scale\n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
}
else{
glGetIntegerv(GL_INDEX_CLEAR_VALUE, &idx);
rgba[0] = gl2ps->colormap[idx][0];
rgba[1] = gl2ps->colormap[idx][1];
rgba[2] = gl2ps->colormap[idx][2];
rgba[3] = 1.0F;
}
gl2psPrintf("%g %g %g C\n"
"newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n"
"closepath fill\n",
rgba[0], rgba[1], rgba[2],
x, y, x+w, y, x+w, y+h, x, y+h);
}
gl2psPrintf("newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto\n"
"closepath clip\n",
x, y, x+w, y, x+w, y+h, x, y+h);
}
static GLint gl2psPrintPostScriptEndViewport(void)
{
GLint res;
res = gl2psPrintPrimitives();
gl2psPrintf("grestore\n");
return res;
}
static void gl2psPrintPostScriptFinalPrimitive(void)
{
/* End any remaining line, if any */
gl2psEndPostScriptLine();
}
/* definition of the PostScript and Encapsulated PostScript backends */
static GL2PSbackend gl2psPS = {
gl2psPrintPostScriptHeader,
gl2psPrintPostScriptFooter,
gl2psPrintPostScriptBeginViewport,
gl2psPrintPostScriptEndViewport,
gl2psPrintPostScriptPrimitive,
gl2psPrintPostScriptFinalPrimitive,
"ps",
"Postscript"
};
static GL2PSbackend gl2psEPS = {
gl2psPrintPostScriptHeader,
gl2psPrintPostScriptFooter,
gl2psPrintPostScriptBeginViewport,
gl2psPrintPostScriptEndViewport,
gl2psPrintPostScriptPrimitive,
gl2psPrintPostScriptFinalPrimitive,
"eps",
"Encapsulated Postscript"
};
/*********************************************************************
*
* LaTeX routines
*
*********************************************************************/
static void gl2psPrintTeXHeader(void)
{
char name[256];
time_t now;
int i;
if(gl2ps->filename && strlen(gl2ps->filename) < 256){
for(i = (int)strlen(gl2ps->filename) - 1; i >= 0; i--){
if(gl2ps->filename[i] == '.'){
strncpy(name, gl2ps->filename, i);
name[i] = '\0';
break;
}
}
if(i <= 0) strcpy(name, gl2ps->filename);
}
else{
strcpy(name, "untitled");
}
time(&now);
fprintf(gl2ps->stream,
"%% Title: %s\n"
"%% Creator: GL2PS %d.%d.%d%s, %s\n"
"%% For: %s\n"
"%% CreationDate: %s",
gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
gl2ps->producer, ctime(&now));
fprintf(gl2ps->stream,
"\\setlength{\\unitlength}{1pt}\n"
"\\begin{picture}(0,0)\n"
"\\includegraphics{%s}\n"
"\\end{picture}%%\n"
"%s\\begin{picture}(%d,%d)(0,0)\n",
name, (gl2ps->options & GL2PS_LANDSCAPE) ? "\\rotatebox{90}{" : "",
(int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
}
static void gl2psPrintTeXPrimitive(void *data)
{
GL2PSprimitive *prim;
prim = *(GL2PSprimitive**)data;
switch(prim->type){
case GL2PS_TEXT :
fprintf(gl2ps->stream, "\\fontsize{%d}{0}\n\\selectfont",
prim->data.text->fontsize);
fprintf(gl2ps->stream, "\\put(%g,%g)",
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
if(prim->data.text->angle != 0.0)
fprintf(gl2ps->stream, "{\\rotatebox{%g}", prim->data.text->angle);
fprintf(gl2ps->stream, "{\\makebox(0,0)");
switch(prim->data.text->alignment){
case GL2PS_TEXT_C:
fprintf(gl2ps->stream, "{");
break;
case GL2PS_TEXT_CL:
fprintf(gl2ps->stream, "[l]{");
break;
case GL2PS_TEXT_CR:
fprintf(gl2ps->stream, "[r]{");
break;
case GL2PS_TEXT_B:
fprintf(gl2ps->stream, "[b]{");
break;
case GL2PS_TEXT_BR:
fprintf(gl2ps->stream, "[br]{");
break;
case GL2PS_TEXT_T:
fprintf(gl2ps->stream, "[t]{");
break;
case GL2PS_TEXT_TL:
fprintf(gl2ps->stream, "[tl]{");
break;
case GL2PS_TEXT_TR:
fprintf(gl2ps->stream, "[tr]{");
break;
case GL2PS_TEXT_BL:
default:
fprintf(gl2ps->stream, "[bl]{");
break;
}
fprintf(gl2ps->stream, "\\textcolor[rgb]{%g,%g,%g}{{%s}}",
prim->verts[0].rgba[0], prim->verts[0].rgba[1], prim->verts[0].rgba[2],
prim->data.text->str);
if(prim->data.text->angle != 0.0)
fprintf(gl2ps->stream, "}");
fprintf(gl2ps->stream, "}}\n");
break;
case GL2PS_SPECIAL :
/* alignment contains the format for which the special output text
is intended */
if (prim->data.text->alignment == GL2PS_TEX)
fprintf(gl2ps->stream, "%s\n", prim->data.text->str);
break;
default :
break;
}
}
static void gl2psPrintTeXFooter(void)
{
fprintf(gl2ps->stream, "\\end{picture}%s\n",
(gl2ps->options & GL2PS_LANDSCAPE) ? "}" : "");
}
static void gl2psPrintTeXBeginViewport(GLint viewport[4])
{
(void) viewport; /* not used */
glRenderMode(GL_FEEDBACK);
gl2psResetLineProperties();
if(gl2ps->header){
gl2psPrintTeXHeader();
gl2ps->header = GL_FALSE;
}
}
static GLint gl2psPrintTeXEndViewport(void)
{
return gl2psPrintPrimitives();
}
static void gl2psPrintTeXFinalPrimitive(void)
{
}
/* definition of the LaTeX backend */
static GL2PSbackend gl2psTEX = {
gl2psPrintTeXHeader,
gl2psPrintTeXFooter,
gl2psPrintTeXBeginViewport,
gl2psPrintTeXEndViewport,
gl2psPrintTeXPrimitive,
gl2psPrintTeXFinalPrimitive,
"tex",
"LaTeX text"
};
/*********************************************************************
*
* PDF routines
*
*********************************************************************/
static int gl2psPrintPDFCompressorType(void)
{
#if defined(GL2PS_HAVE_ZLIB)
if(gl2ps->options & GL2PS_COMPRESS){
return fprintf(gl2ps->stream, "/Filter [/FlateDecode]\n");
}
#endif
return 0;
}
static int gl2psPrintPDFStrokeColor(GL2PSrgba rgba)
{
int i, offs = 0;
gl2psSetLastColor(rgba);
for(i = 0; i < 3; ++i){
if(GL2PS_ZERO(rgba[i]))
offs += gl2psPrintf("%.0f ", 0.);
else if(rgba[i] < 1e-4 || rgba[i] > 1e6) /* avoid %e formatting */
offs += gl2psPrintf("%f ", rgba[i]);
else
offs += gl2psPrintf("%g ", rgba[i]);
}
offs += gl2psPrintf("RG\n");
return offs;
}
static int gl2psPrintPDFFillColor(GL2PSrgba rgba)
{
int i, offs = 0;
for(i = 0; i < 3; ++i){
if(GL2PS_ZERO(rgba[i]))
offs += gl2psPrintf("%.0f ", 0.);
else if(rgba[i] < 1e-4 || rgba[i] > 1e6) /* avoid %e formatting */
offs += gl2psPrintf("%f ", rgba[i]);
else
offs += gl2psPrintf("%g ", rgba[i]);
}
offs += gl2psPrintf("rg\n");
return offs;
}
static int gl2psPrintPDFLineWidth(GLfloat lw)
{
if(GL2PS_ZERO(lw))
return gl2psPrintf("%.0f w\n", 0.);
else if(lw < 1e-4 || lw > 1e6) /* avoid %e formatting */
return gl2psPrintf("%f w\n", lw);
else
return gl2psPrintf("%g w\n", lw);
}
static int gl2psPrintPDFLineCap(GLint lc)
{
if(gl2ps->lastlinecap == lc)
return 0;
else
return gl2psPrintf("%d J\n", lc);
}
static int gl2psPrintPDFLineJoin(GLint lj)
{
if(gl2ps->lastlinejoin == lj)
return 0;
else
return gl2psPrintf("%d j\n", lj);
}
static void gl2psPutPDFText(GL2PSstring *text, int cnt, GLfloat x, GLfloat y)
{
GLfloat rad, crad, srad;
if(text->angle == 0.0F){
gl2ps->streamlength += gl2psPrintf
("BT\n"
"/F%d %d Tf\n"
"%f %f Td\n"
"(%s) Tj\n"
"ET\n",
cnt, text->fontsize, x, y, text->str);
}
else{
rad = (GLfloat)(3.141593F * text->angle / 180.0F);
srad = (GLfloat)sin(rad);
crad = (GLfloat)cos(rad);
gl2ps->streamlength += gl2psPrintf
("BT\n"
"/F%d %d Tf\n"
"%f %f %f %f %f %f Tm\n"
"(%s) Tj\n"
"ET\n",
cnt, text->fontsize, crad, srad, -srad, crad, x, y, text->str);
}
}
static void gl2psPutPDFSpecial(int prim, int sec, GL2PSstring *text)
{
gl2ps->streamlength += gl2psPrintf("/GS%d%d gs\n", prim, sec);
gl2ps->streamlength += gl2psPrintf("%s\n", text->str);
}
static void gl2psPutPDFImage(GL2PSimage *image, int cnt, GLfloat x, GLfloat y)
{
gl2ps->streamlength += gl2psPrintf
("q\n"
"%d 0 0 %d %f %f cm\n"
"/Im%d Do\n"
"Q\n",
(int)(image->zoom_x * image->width), (int)(image->zoom_y * image->height),
x, y, cnt);
}
static void gl2psPDFstacksInit(void)
{
gl2ps->objects_stack = 7 /* FIXED_XREF_ENTRIES */ + 1;
gl2ps->extgs_stack = 0;
gl2ps->font_stack = 0;
gl2ps->im_stack = 0;
gl2ps->trgroupobjects_stack = 0;
gl2ps->shader_stack = 0;
gl2ps->mshader_stack = 0;
}
static void gl2psPDFgroupObjectInit(GL2PSpdfgroup *gro)
{
if(!gro)
return;
gro->ptrlist = NULL;
gro->fontno = gro->gsno = gro->imno = gro->maskshno = gro->shno
= gro->trgroupno = gro->fontobjno = gro->imobjno = gro->shobjno
= gro->maskshobjno = gro->gsobjno = gro->trgroupobjno = -1;
}
/* Build up group objects and assign name and object numbers */
static void gl2psPDFgroupListInit(void)
{
int i;
GL2PSprimitive *p = NULL;
GL2PSpdfgroup gro;
int lasttype = GL2PS_NO_TYPE;
GL2PSrgba lastrgba = {-1.0F, -1.0F, -1.0F, -1.0F};
GLushort lastpattern = 0;
GLint lastfactor = 0;
GLfloat lastwidth = 1;
GLint lastlinecap = 0;
GLint lastlinejoin = 0;
GL2PStriangle lastt, tmpt;
int lastTriangleWasNotSimpleWithSameColor = 0;
if(!gl2ps->pdfprimlist)
return;
gl2ps->pdfgrouplist = gl2psListCreate(500, 500, sizeof(GL2PSpdfgroup));
gl2psInitTriangle(&lastt);
for(i = 0; i < gl2psListNbr(gl2ps->pdfprimlist); ++i){
p = *(GL2PSprimitive**)gl2psListPointer(gl2ps->pdfprimlist, i);
switch(p->type){
case GL2PS_PIXMAP:
gl2psPDFgroupObjectInit(&gro);
gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
gro.imno = gl2ps->im_stack++;
gl2psListAdd(gro.ptrlist, &p);
gl2psListAdd(gl2ps->pdfgrouplist, &gro);
break;
case GL2PS_TEXT:
gl2psPDFgroupObjectInit(&gro);
gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
gro.fontno = gl2ps->font_stack++;
gl2psListAdd(gro.ptrlist, &p);
gl2psListAdd(gl2ps->pdfgrouplist, &gro);
break;
case GL2PS_LINE:
if(lasttype != p->type || lastwidth != p->width ||
lastlinecap != p->linecap || lastlinejoin != p->linejoin ||
lastpattern != p->pattern || lastfactor != p->factor ||
!gl2psSameColor(p->verts[0].rgba, lastrgba)){
gl2psPDFgroupObjectInit(&gro);
gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
gl2psListAdd(gro.ptrlist, &p);
gl2psListAdd(gl2ps->pdfgrouplist, &gro);
}
else{
gl2psListAdd(gro.ptrlist, &p);
}
lastpattern = p->pattern;
lastfactor = p->factor;
lastwidth = p->width;
lastlinecap = p->linecap;
lastlinejoin = p->linejoin;
lastrgba[0] = p->verts[0].rgba[0];
lastrgba[1] = p->verts[0].rgba[1];
lastrgba[2] = p->verts[0].rgba[2];
break;
case GL2PS_POINT:
if(lasttype != p->type || lastwidth != p->width ||
!gl2psSameColor(p->verts[0].rgba, lastrgba)){
gl2psPDFgroupObjectInit(&gro);
gro.ptrlist = gl2psListCreate(1,2,sizeof(GL2PSprimitive*));
gl2psListAdd(gro.ptrlist, &p);
gl2psListAdd(gl2ps->pdfgrouplist, &gro);
}
else{
gl2psListAdd(gro.ptrlist, &p);
}
lastwidth = p->width;
lastrgba[0] = p->verts[0].rgba[0];
lastrgba[1] = p->verts[0].rgba[1];
lastrgba[2] = p->verts[0].rgba[2];
break;
case GL2PS_TRIANGLE:
gl2psFillTriangleFromPrimitive(&tmpt, p, GL_TRUE);
lastTriangleWasNotSimpleWithSameColor =
!(tmpt.prop & T_CONST_COLOR && tmpt.prop & T_ALPHA_1) ||
!gl2psSameColor(tmpt.vertex[0].rgba, lastt.vertex[0].rgba);
if(lasttype == p->type && tmpt.prop == lastt.prop &&
lastTriangleWasNotSimpleWithSameColor){
/* TODO Check here for last alpha */
gl2psListAdd(gro.ptrlist, &p);
}
else{
gl2psPDFgroupObjectInit(&gro);
gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
gl2psListAdd(gro.ptrlist, &p);
gl2psListAdd(gl2ps->pdfgrouplist, &gro);
}
lastt = tmpt;
break;
case GL2PS_SPECIAL:
gl2psPDFgroupObjectInit(&gro);
gro.ptrlist = gl2psListCreate(1, 2, sizeof(GL2PSprimitive*));
gl2psListAdd(gro.ptrlist, &p);
gl2psListAdd(gl2ps->pdfgrouplist, &gro);
break;
default:
break;
}
lasttype = p->type;
}
}
static void gl2psSortOutTrianglePDFgroup(GL2PSpdfgroup *gro)
{
GL2PStriangle t;
GL2PSprimitive *prim = NULL;
if(!gro)
return;
if(!gl2psListNbr(gro->ptrlist))
return;
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
if(prim->type != GL2PS_TRIANGLE)
return;
gl2psFillTriangleFromPrimitive(&t, prim, GL_TRUE);
if(t.prop & T_CONST_COLOR && t.prop & T_ALPHA_LESS_1){
gro->gsno = gl2ps->extgs_stack++;
gro->gsobjno = gl2ps->objects_stack ++;
}
else if(t.prop & T_CONST_COLOR && t.prop & T_VAR_ALPHA){
gro->gsno = gl2ps->extgs_stack++;
gro->gsobjno = gl2ps->objects_stack++;
gro->trgroupno = gl2ps->trgroupobjects_stack++;
gro->trgroupobjno = gl2ps->objects_stack++;
gro->maskshno = gl2ps->mshader_stack++;
gro->maskshobjno = gl2ps->objects_stack++;
}
else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_1){
gro->shno = gl2ps->shader_stack++;
gro->shobjno = gl2ps->objects_stack++;
}
else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_LESS_1){
gro->gsno = gl2ps->extgs_stack++;
gro->gsobjno = gl2ps->objects_stack++;
gro->shno = gl2ps->shader_stack++;
gro->shobjno = gl2ps->objects_stack++;
}
else if(t.prop & T_VAR_COLOR && t.prop & T_VAR_ALPHA){
gro->gsno = gl2ps->extgs_stack++;
gro->gsobjno = gl2ps->objects_stack++;
gro->shno = gl2ps->shader_stack++;
gro->shobjno = gl2ps->objects_stack++;
gro->trgroupno = gl2ps->trgroupobjects_stack++;
gro->trgroupobjno = gl2ps->objects_stack++;
gro->maskshno = gl2ps->mshader_stack++;
gro->maskshobjno = gl2ps->objects_stack++;
}
}
/* Main stream data */
static void gl2psPDFgroupListWriteMainStream(void)
{
int i, j, lastel, count;
GL2PSprimitive *prim = NULL, *prev = NULL;
GL2PSpdfgroup *gro;
GL2PStriangle t;
if(!gl2ps->pdfgrouplist)
return;
count = gl2psListNbr(gl2ps->pdfgrouplist);
for(i = 0; i < count; ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
lastel = gl2psListNbr(gro->ptrlist) - 1;
if(lastel < 0)
continue;
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
switch(prim->type){
case GL2PS_POINT:
gl2ps->streamlength += gl2psPrintf("1 J\n");
gl2ps->streamlength += gl2psPrintPDFLineWidth(prim->width);
gl2ps->streamlength += gl2psPrintPDFStrokeColor(prim->verts[0].rgba);
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2ps->streamlength +=
gl2psPrintf("%f %f m %f %f l\n",
prim->verts[0].xyz[0], prim->verts[0].xyz[1],
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
}
gl2ps->streamlength += gl2psPrintf("S\n");
gl2ps->streamlength += gl2psPrintf("0 J\n");
break;
case GL2PS_LINE:
/* We try to use as few paths as possible to draw lines, in
order to get nice stippling even when the individual segments
are smaller than the stipple */
gl2ps->streamlength += gl2psPrintPDFLineWidth(prim->width);
gl2ps->streamlength += gl2psPrintPDFLineCap(prim->linecap);
gl2ps->streamlength += gl2psPrintPDFLineJoin(prim->linejoin);
gl2ps->streamlength += gl2psPrintPDFStrokeColor(prim->verts[0].rgba);
gl2ps->streamlength += gl2psPrintPostScriptDash(prim->pattern, prim->factor, "d");
/* start new path */
gl2ps->streamlength +=
gl2psPrintf("%f %f m\n",
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
for(j = 1; j <= lastel; ++j){
prev = prim;
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
if(!gl2psSamePosition(prim->verts[0].xyz, prev->verts[1].xyz)){
/* the starting point of the new segment does not match the
end point of the previous line, so we end the current
path and start a new one */
gl2ps->streamlength +=
gl2psPrintf("%f %f l\n",
prev->verts[1].xyz[0], prev->verts[1].xyz[1]);
gl2ps->streamlength +=
gl2psPrintf("%f %f m\n",
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
}
else{
/* the two segements are connected, so we just append to the
current path */
gl2ps->streamlength +=
gl2psPrintf("%f %f l\n",
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
}
}
/* end last path */
gl2ps->streamlength +=
gl2psPrintf("%f %f l\n",
prim->verts[1].xyz[0], prim->verts[1].xyz[1]);
gl2ps->streamlength += gl2psPrintf("S\n");
break;
case GL2PS_TRIANGLE:
gl2psFillTriangleFromPrimitive(&t, prim, GL_TRUE);
gl2psSortOutTrianglePDFgroup(gro);
/* No alpha and const color: Simple PDF draw orders */
if(t.prop & T_CONST_COLOR && t.prop & T_ALPHA_1){
gl2ps->streamlength += gl2psPrintPDFFillColor(t.vertex[0].rgba);
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE);
gl2ps->streamlength
+= gl2psPrintf("%f %f m\n"
"%f %f l\n"
"%f %f l\n"
"h f\n",
t.vertex[0].xyz[0], t.vertex[0].xyz[1],
t.vertex[1].xyz[0], t.vertex[1].xyz[1],
t.vertex[2].xyz[0], t.vertex[2].xyz[1]);
}
}
/* Const alpha < 1 and const color: Simple PDF draw orders
and an extra extended Graphics State for the alpha const */
else if(t.prop & T_CONST_COLOR && t.prop & T_ALPHA_LESS_1){
gl2ps->streamlength += gl2psPrintf("q\n"
"/GS%d gs\n",
gro->gsno);
gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba);
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE);
gl2ps->streamlength
+= gl2psPrintf("%f %f m\n"
"%f %f l\n"
"%f %f l\n"
"h f\n",
t.vertex[0].xyz[0], t.vertex[0].xyz[1],
t.vertex[1].xyz[0], t.vertex[1].xyz[1],
t.vertex[2].xyz[0], t.vertex[2].xyz[1]);
}
gl2ps->streamlength += gl2psPrintf("Q\n");
}
/* Variable alpha and const color: Simple PDF draw orders
and an extra extended Graphics State + Xobject + Shader
object for the alpha mask */
else if(t.prop & T_CONST_COLOR && t.prop & T_VAR_ALPHA){
gl2ps->streamlength += gl2psPrintf("q\n"
"/GS%d gs\n"
"/TrG%d Do\n",
gro->gsno, gro->trgroupno);
gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba);
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2psFillTriangleFromPrimitive(&t, prim, GL_FALSE);
gl2ps->streamlength
+= gl2psPrintf("%f %f m\n"
"%f %f l\n"
"%f %f l\n"
"h f\n",
t.vertex[0].xyz[0], t.vertex[0].xyz[1],
t.vertex[1].xyz[0], t.vertex[1].xyz[1],
t.vertex[2].xyz[0], t.vertex[2].xyz[1]);
}
gl2ps->streamlength += gl2psPrintf("Q\n");
}
/* Variable color and no alpha: Shader Object for the colored
triangle(s) */
else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_1){
gl2ps->streamlength += gl2psPrintf("/Sh%d sh\n", gro->shno);
}
/* Variable color and const alpha < 1: Shader Object for the
colored triangle(s) and an extra extended Graphics State
for the alpha const */
else if(t.prop & T_VAR_COLOR && t.prop & T_ALPHA_LESS_1){
gl2ps->streamlength += gl2psPrintf("q\n"
"/GS%d gs\n"
"/Sh%d sh\n"
"Q\n",
gro->gsno, gro->shno);
}
/* Variable alpha and color: Shader Object for the colored
triangle(s) and an extra extended Graphics State
+ Xobject + Shader object for the alpha mask */
else if(t.prop & T_VAR_COLOR && t.prop & T_VAR_ALPHA){
gl2ps->streamlength += gl2psPrintf("q\n"
"/GS%d gs\n"
"/TrG%d Do\n"
"/Sh%d sh\n"
"Q\n",
gro->gsno, gro->trgroupno, gro->shno);
}
break;
case GL2PS_PIXMAP:
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2psPutPDFImage(prim->data.image, gro->imno, prim->verts[0].xyz[0],
prim->verts[0].xyz[1]);
}
break;
case GL2PS_TEXT:
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2ps->streamlength += gl2psPrintPDFFillColor(prim->verts[0].rgba);
gl2psPutPDFText(prim->data.text, gro->fontno, prim->verts[0].xyz[0],
prim->verts[0].xyz[1]);
}
break;
case GL2PS_SPECIAL:
lastel = gl2psListNbr(gro->ptrlist) - 1;
if(lastel < 0)
continue;
for(j = 0; j <= lastel; ++j){
prim = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2psPutPDFSpecial(i, j, prim->data.text);
}
default:
break;
}
}
}
/* Graphics State names */
static int gl2psPDFgroupListWriteGStateResources(void)
{
GL2PSpdfgroup *gro;
int offs = 0;
int i;
offs += fprintf(gl2ps->stream,
"/ExtGState\n"
"<<\n"
"/GSa 7 0 R\n");
for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
if(gro->gsno >= 0)
offs += fprintf(gl2ps->stream, "/GS%d %d 0 R\n", gro->gsno, gro->gsobjno);
}
offs += fprintf(gl2ps->stream, ">>\n");
return offs;
}
/* Main Shader names */
static int gl2psPDFgroupListWriteShaderResources(void)
{
GL2PSpdfgroup *gro;
int offs = 0;
int i;
offs += fprintf(gl2ps->stream,
"/Shading\n"
"<<\n");
for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
if(gro->shno >= 0)
offs += fprintf(gl2ps->stream, "/Sh%d %d 0 R\n", gro->shno, gro->shobjno);
if(gro->maskshno >= 0)
offs += fprintf(gl2ps->stream, "/TrSh%d %d 0 R\n", gro->maskshno, gro->maskshobjno);
}
offs += fprintf(gl2ps->stream,">>\n");
return offs;
}
/* Images & Mask Shader XObject names */
static int gl2psPDFgroupListWriteXObjectResources(void)
{
int i;
GL2PSprimitive *p = NULL;
GL2PSpdfgroup *gro;
int offs = 0;
offs += fprintf(gl2ps->stream,
"/XObject\n"
"<<\n");
for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
if(!gl2psListNbr(gro->ptrlist))
continue;
p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
switch(p->type){
case GL2PS_PIXMAP:
gro->imobjno = gl2ps->objects_stack++;
if(GL_RGBA == p->data.image->format) /* reserve one object for image mask */
gl2ps->objects_stack++;
offs += fprintf(gl2ps->stream, "/Im%d %d 0 R\n", gro->imno, gro->imobjno);
case GL2PS_TRIANGLE:
if(gro->trgroupno >=0)
offs += fprintf(gl2ps->stream, "/TrG%d %d 0 R\n", gro->trgroupno, gro->trgroupobjno);
break;
default:
break;
}
}
offs += fprintf(gl2ps->stream,">>\n");
return offs;
}
/* Font names */
static int gl2psPDFgroupListWriteFontResources(void)
{
int i;
GL2PSpdfgroup *gro;
int offs = 0;
offs += fprintf(gl2ps->stream, "/Font\n<<\n");
for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
if(gro->fontno < 0)
continue;
gro->fontobjno = gl2ps->objects_stack++;
offs += fprintf(gl2ps->stream, "/F%d %d 0 R\n", gro->fontno, gro->fontobjno);
}
offs += fprintf(gl2ps->stream, ">>\n");
return offs;
}
static void gl2psPDFgroupListDelete(void)
{
int i;
GL2PSpdfgroup *gro = NULL;
if(!gl2ps->pdfgrouplist)
return;
for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist,i);
gl2psListDelete(gro->ptrlist);
}
gl2psListDelete(gl2ps->pdfgrouplist);
gl2ps->pdfgrouplist = NULL;
}
/* Print 1st PDF object - file info */
static int gl2psPrintPDFInfo(void)
{
int offs;
time_t now;
struct tm *newtime;
time(&now);
newtime = gmtime(&now);
offs = fprintf(gl2ps->stream,
"1 0 obj\n"
"<<\n"
"/Title (%s)\n"
"/Creator (GL2PS %d.%d.%d%s, %s)\n"
"/Producer (%s)\n",
gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
gl2ps->producer);
if(!newtime){
offs += fprintf(gl2ps->stream,
">>\n"
"endobj\n");
return offs;
}
offs += fprintf(gl2ps->stream,
"/CreationDate (D:%d%02d%02d%02d%02d%02d)\n"
">>\n"
"endobj\n",
newtime->tm_year+1900,
newtime->tm_mon+1,
newtime->tm_mday,
newtime->tm_hour,
newtime->tm_min,
newtime->tm_sec);
return offs;
}
/* Create catalog and page structure - 2nd and 3th PDF object */
static int gl2psPrintPDFCatalog(void)
{
return fprintf(gl2ps->stream,
"2 0 obj\n"
"<<\n"
"/Type /Catalog\n"
"/Pages 3 0 R\n"
">>\n"
"endobj\n");
}
static int gl2psPrintPDFPages(void)
{
return fprintf(gl2ps->stream,
"3 0 obj\n"
"<<\n"
"/Type /Pages\n"
"/Kids [6 0 R]\n"
"/Count 1\n"
">>\n"
"endobj\n");
}
/* Open stream for data - graphical objects, fonts etc. PDF object 4 */
static int gl2psOpenPDFDataStream(void)
{
int offs = 0;
offs += fprintf(gl2ps->stream,
"4 0 obj\n"
"<<\n"
"/Length 5 0 R\n" );
offs += gl2psPrintPDFCompressorType();
offs += fprintf(gl2ps->stream,
">>\n"
"stream\n");
return offs;
}
/* Stream setup - Graphics state, fill background if allowed */
static int gl2psOpenPDFDataStreamWritePreface(void)
{
int offs;
offs = gl2psPrintf("/GSa gs\n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
offs += gl2psPrintPDFFillColor(gl2ps->bgcolor);
offs += gl2psPrintf("%d %d %d %d re\n",
(int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
(int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
offs += gl2psPrintf("f\n");
}
return offs;
}
/* Use the functions above to create the first part of the PDF*/
static void gl2psPrintPDFHeader(void)
{
int offs = 0;
gl2ps->pdfprimlist = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*));
gl2psPDFstacksInit();
gl2ps->xreflist = (int*)gl2psMalloc(sizeof(int) * gl2ps->objects_stack);
#if defined(GL2PS_HAVE_ZLIB)
if(gl2ps->options & GL2PS_COMPRESS){
gl2psSetupCompress();
}
#endif
gl2ps->xreflist[0] = 0;
offs += fprintf(gl2ps->stream, "%%PDF-1.4\n");
gl2ps->xreflist[1] = offs;
offs += gl2psPrintPDFInfo();
gl2ps->xreflist[2] = offs;
offs += gl2psPrintPDFCatalog();
gl2ps->xreflist[3] = offs;
offs += gl2psPrintPDFPages();
gl2ps->xreflist[4] = offs;
offs += gl2psOpenPDFDataStream();
gl2ps->xreflist[5] = offs; /* finished in gl2psPrintPDFFooter */
gl2ps->streamlength = gl2psOpenPDFDataStreamWritePreface();
}
/* The central primitive drawing */
static void gl2psPrintPDFPrimitive(void *data)
{
GL2PSprimitive *prim = *(GL2PSprimitive**)data;
if((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled)
return;
prim = gl2psCopyPrimitive(prim); /* deep copy */
gl2psListAdd(gl2ps->pdfprimlist, &prim);
}
/* close stream and ... */
static int gl2psClosePDFDataStream(void)
{
int offs = 0;
#if defined(GL2PS_HAVE_ZLIB)
if(gl2ps->options & GL2PS_COMPRESS){
if(Z_OK != gl2psDeflate())
gl2psMsg(GL2PS_ERROR, "Zlib deflate error");
else
fwrite(gl2ps->compress->dest, gl2ps->compress->destLen, 1, gl2ps->stream);
gl2ps->streamlength += gl2ps->compress->destLen;
offs += gl2ps->streamlength;
gl2psFreeCompress();
}
#endif
offs += fprintf(gl2ps->stream,
"endstream\n"
"endobj\n");
return offs;
}
/* ... write the now known length object */
static int gl2psPrintPDFDataStreamLength(int val)
{
return fprintf(gl2ps->stream,
"5 0 obj\n"
"%d\n"
"endobj\n", val);
}
/* Put the info created before in PDF objects */
static int gl2psPrintPDFOpenPage(void)
{
int offs;
/* Write fixed part */
offs = fprintf(gl2ps->stream,
"6 0 obj\n"
"<<\n"
"/Type /Page\n"
"/Parent 3 0 R\n"
"/MediaBox [%d %d %d %d]\n",
(int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
(int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
if(gl2ps->options & GL2PS_LANDSCAPE)
offs += fprintf(gl2ps->stream, "/Rotate -90\n");
offs += fprintf(gl2ps->stream,
"/Contents 4 0 R\n"
"/Resources\n"
"<<\n"
"/ProcSet [/PDF /Text /ImageB /ImageC] %%/ImageI\n");
return offs;
/* End fixed part, proceeds in gl2psPDFgroupListWriteVariableResources() */
}
static int gl2psPDFgroupListWriteVariableResources(void)
{
int offs = 0;
/* a) Graphics States for shader alpha masks*/
offs += gl2psPDFgroupListWriteGStateResources();
/* b) Shader and shader masks */
offs += gl2psPDFgroupListWriteShaderResources();
/* c) XObjects (Images & Shader Masks) */
offs += gl2psPDFgroupListWriteXObjectResources();
/* d) Fonts */
offs += gl2psPDFgroupListWriteFontResources();
/* End resources and page */
offs += fprintf(gl2ps->stream,
">>\n"
">>\n"
"endobj\n");
return offs;
}
/* Standard Graphics State */
static int gl2psPrintPDFGSObject(void)
{
return fprintf(gl2ps->stream,
"7 0 obj\n"
"<<\n"
"/Type /ExtGState\n"
"/SA false\n"
"/SM 0.02\n"
"/OP false\n"
"/op false\n"
"/OPM 0\n"
"/BG2 /Default\n"
"/UCR2 /Default\n"
"/TR2 /Default\n"
">>\n"
"endobj\n");
}
/* Put vertex' edge flag (8bit) and coordinates (32bit) in shader stream */
static int gl2psPrintPDFShaderStreamDataCoord(GL2PSvertex *vertex,
int (*action)(unsigned long data, int size),
GLfloat dx, GLfloat dy,
GLfloat xmin, GLfloat ymin)
{
int offs = 0;
unsigned long imap;
GLfloat diff;
double dmax = ~1UL;
char edgeflag = 0;
/* FIXME: temp bux fix for 64 bit archs: */
if(sizeof(unsigned long) == 8) dmax = dmax - 2048.;
offs += (*action)(edgeflag, 1);
/* The Shader stream in PDF requires to be in a 'big-endian'
order */
if(GL2PS_ZERO(dx * dy)){
offs += (*action)(0, 4);
offs += (*action)(0, 4);
}
else{
diff = (vertex->xyz[0] - xmin) / dx;
if(diff > 1)
diff = 1.0F;
else if(diff < 0)
diff = 0.0F;
imap = (unsigned long)(diff * dmax);
offs += (*action)(imap, 4);
diff = (vertex->xyz[1] - ymin) / dy;
if(diff > 1)
diff = 1.0F;
else if(diff < 0)
diff = 0.0F;
imap = (unsigned long)(diff * dmax);
offs += (*action)(imap, 4);
}
return offs;
}
/* Put vertex' rgb value (8bit for every component) in shader stream */
static int gl2psPrintPDFShaderStreamDataRGB(GL2PSvertex *vertex,
int (*action)(unsigned long data, int size))
{
int offs = 0;
unsigned long imap;
double dmax = ~1UL;
/* FIXME: temp bux fix for 64 bit archs: */
if(sizeof(unsigned long) == 8) dmax = dmax - 2048.;
imap = (unsigned long)((vertex->rgba[0]) * dmax);
offs += (*action)(imap, 1);
imap = (unsigned long)((vertex->rgba[1]) * dmax);
offs += (*action)(imap, 1);
imap = (unsigned long)((vertex->rgba[2]) * dmax);
offs += (*action)(imap, 1);
return offs;
}
/* Put vertex' alpha (8/16bit) in shader stream */
static int gl2psPrintPDFShaderStreamDataAlpha(GL2PSvertex *vertex,
int (*action)(unsigned long data, int size),
int sigbyte)
{
int offs = 0;
unsigned long imap;
double dmax = ~1UL;
/* FIXME: temp bux fix for 64 bit archs: */
if(sizeof(unsigned long) == 8) dmax = dmax - 2048.;
if(sigbyte != 8 && sigbyte != 16)
sigbyte = 8;
sigbyte /= 8;
imap = (unsigned long)((vertex->rgba[3]) * dmax);
offs += (*action)(imap, sigbyte);
return offs;
}
/* Put a triangles raw data in shader stream */
static int gl2psPrintPDFShaderStreamData(GL2PStriangle *triangle,
GLfloat dx, GLfloat dy,
GLfloat xmin, GLfloat ymin,
int (*action)(unsigned long data, int size),
int gray)
{
int i, offs = 0;
GL2PSvertex v;
if(gray && gray != 8 && gray != 16)
gray = 8;
for(i = 0; i < 3; ++i){
offs += gl2psPrintPDFShaderStreamDataCoord(&triangle->vertex[i], action,
dx, dy, xmin, ymin);
if(gray){
v = triangle->vertex[i];
offs += gl2psPrintPDFShaderStreamDataAlpha(&v, action, gray);
}
else{
offs += gl2psPrintPDFShaderStreamDataRGB(&triangle->vertex[i], action);
}
}
return offs;
}
static void gl2psPDFRectHull(GLfloat *xmin, GLfloat *xmax,
GLfloat *ymin, GLfloat *ymax,
GL2PStriangle *triangles, int cnt)
{
int i, j;
*xmin = triangles[0].vertex[0].xyz[0];
*xmax = triangles[0].vertex[0].xyz[0];
*ymin = triangles[0].vertex[0].xyz[1];
*ymax = triangles[0].vertex[0].xyz[1];
for(i = 0; i < cnt; ++i){
for(j = 0; j < 3; ++j){
if(*xmin > triangles[i].vertex[j].xyz[0])
*xmin = triangles[i].vertex[j].xyz[0];
if(*xmax < triangles[i].vertex[j].xyz[0])
*xmax = triangles[i].vertex[j].xyz[0];
if(*ymin > triangles[i].vertex[j].xyz[1])
*ymin = triangles[i].vertex[j].xyz[1];
if(*ymax < triangles[i].vertex[j].xyz[1])
*ymax = triangles[i].vertex[j].xyz[1];
}
}
}
/* Writes shaded triangle
gray == 0 means write RGB triangles
gray == 8 8bit-grayscale (for alpha masks)
gray == 16 16bit-grayscale (for alpha masks) */
static int gl2psPrintPDFShader(int obj, GL2PStriangle *triangles,
int size, int gray)
{
int i, offs = 0, vertexbytes, done = 0;
GLfloat xmin, xmax, ymin, ymax;
switch(gray){
case 0:
vertexbytes = 1+4+4+1+1+1;
break;
case 8:
vertexbytes = 1+4+4+1;
break;
case 16:
vertexbytes = 1+4+4+2;
break;
default:
gray = 8;
vertexbytes = 1+4+4+1;
break;
}
gl2psPDFRectHull(&xmin, &xmax, &ymin, &ymax, triangles, size);
offs += fprintf(gl2ps->stream,
"%d 0 obj\n"
"<< "
"/ShadingType 4 "
"/ColorSpace %s "
"/BitsPerCoordinate 32 "
"/BitsPerComponent %d "
"/BitsPerFlag 8 "
"/Decode [%f %f %f %f 0 1 %s] ",
obj,
(gray) ? "/DeviceGray" : "/DeviceRGB",
(gray) ? gray : 8,
xmin, xmax, ymin, ymax,
(gray) ? "" : "0 1 0 1");
#if defined(GL2PS_HAVE_ZLIB)
if(gl2ps->options & GL2PS_COMPRESS){
gl2psAllocCompress(vertexbytes * size * 3);
for(i = 0; i < size; ++i)
gl2psPrintPDFShaderStreamData(&triangles[i],
xmax-xmin, ymax-ymin, xmin, ymin,
gl2psWriteBigEndianCompress, gray);
if(Z_OK == gl2psDeflate() && 23 + gl2ps->compress->destLen < gl2ps->compress->srcLen){
offs += gl2psPrintPDFCompressorType();
offs += fprintf(gl2ps->stream,
"/Length %d "
">>\n"
"stream\n",
(int)gl2ps->compress->destLen);
offs += gl2ps->compress->destLen * fwrite(gl2ps->compress->dest,
gl2ps->compress->destLen,
1, gl2ps->stream);
done = 1;
}
gl2psFreeCompress();
}
#endif
if(!done){
/* no compression, or too long after compression, or compress error
-> write non-compressed entry */
offs += fprintf(gl2ps->stream,
"/Length %d "
">>\n"
"stream\n",
vertexbytes * 3 * size);
for(i = 0; i < size; ++i)
offs += gl2psPrintPDFShaderStreamData(&triangles[i],
xmax-xmin, ymax-ymin, xmin, ymin,
gl2psWriteBigEndian, gray);
}
offs += fprintf(gl2ps->stream,
"\nendstream\n"
"endobj\n");
return offs;
}
/* Writes a XObject for a shaded triangle mask */
static int gl2psPrintPDFShaderMask(int obj, int childobj)
{
int offs = 0, len;
offs += fprintf(gl2ps->stream,
"%d 0 obj\n"
"<<\n"
"/Type /XObject\n"
"/Subtype /Form\n"
"/BBox [ %d %d %d %d ]\n"
"/Group \n<<\n/S /Transparency /CS /DeviceRGB\n"
">>\n",
obj,
(int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
(int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
len = (childobj>0)
? (int)strlen("/TrSh sh\n") + (int)log10((double)childobj)+1
: (int)strlen("/TrSh0 sh\n");
offs += fprintf(gl2ps->stream,
"/Length %d\n"
">>\n"
"stream\n",
len);
offs += fprintf(gl2ps->stream,
"/TrSh%d sh\n",
childobj);
offs += fprintf(gl2ps->stream,
"endstream\n"
"endobj\n");
return offs;
}
/* Writes a Extended graphics state for a shaded triangle mask if
simplealpha ist true the childobj argument is ignored and a /ca
statement will be written instead */
static int gl2psPrintPDFShaderExtGS(int obj, int childobj)
{
int offs = 0;
offs += fprintf(gl2ps->stream,
"%d 0 obj\n"
"<<\n",
obj);
offs += fprintf(gl2ps->stream,
"/SMask << /S /Alpha /G %d 0 R >> ",
childobj);
offs += fprintf(gl2ps->stream,
">>\n"
"endobj\n");
return offs;
}
/* a simple graphics state */
static int gl2psPrintPDFShaderSimpleExtGS(int obj, GLfloat alpha)
{
int offs = 0;
offs += fprintf(gl2ps->stream,
"%d 0 obj\n"
"<<\n"
"/ca %g"
">>\n"
"endobj\n",
obj, alpha);
return offs;
}
/* Similar groups of functions for pixmaps and text */
static int gl2psPrintPDFPixmapStreamData(GL2PSimage *im,
int (*action)(unsigned long data, int size),
int gray)
{
int x, y, shift;
GLfloat r, g, b, a;
if(im->format != GL_RGBA && gray)
return 0;
if(gray && gray != 8 && gray != 16)
gray = 8;
gray /= 8;
shift = (sizeof(unsigned long) - 1) * 8;
for(y = 0; y < im->height; ++y){
for(x = 0; x < im->width; ++x){
a = gl2psGetRGB(im, x, y, &r, &g, &b);
if(im->format == GL_RGBA && gray){
(*action)((unsigned long)(a * 255) << shift, gray);
}
else{
(*action)((unsigned long)(r * 255) << shift, 1);
(*action)((unsigned long)(g * 255) << shift, 1);
(*action)((unsigned long)(b * 255) << shift, 1);
}
}
}
switch(gray){
case 0: return 3 * im->width * im->height;
case 1: return im->width * im->height;
case 2: return 2 * im->width * im->height;
default: return 3 * im->width * im->height;
}
}
static int gl2psPrintPDFPixmap(int obj, int childobj, GL2PSimage *im, int gray)
{
int offs = 0, done = 0, sigbytes = 3;
if(gray && gray !=8 && gray != 16)
gray = 8;
if(gray)
sigbytes = gray / 8;
offs += fprintf(gl2ps->stream,
"%d 0 obj\n"
"<<\n"
"/Type /XObject\n"
"/Subtype /Image\n"
"/Width %d\n"
"/Height %d\n"
"/ColorSpace %s \n"
"/BitsPerComponent 8\n",
obj,
(int)im->width, (int)im->height,
(gray) ? "/DeviceGray" : "/DeviceRGB" );
if(GL_RGBA == im->format && gray == 0){
offs += fprintf(gl2ps->stream,
"/SMask %d 0 R\n",
childobj);
}
#if defined(GL2PS_HAVE_ZLIB)
if(gl2ps->options & GL2PS_COMPRESS){
gl2psAllocCompress((int)(im->width * im->height * sigbytes));
gl2psPrintPDFPixmapStreamData(im, gl2psWriteBigEndianCompress, gray);
if(Z_OK == gl2psDeflate() && 23 + gl2ps->compress->destLen < gl2ps->compress->srcLen){
offs += gl2psPrintPDFCompressorType();
offs += fprintf(gl2ps->stream,
"/Length %d "
">>\n"
"stream\n",
(int)gl2ps->compress->destLen);
offs += gl2ps->compress->destLen * fwrite(gl2ps->compress->dest, gl2ps->compress->destLen,
1, gl2ps->stream);
done = 1;
}
gl2psFreeCompress();
}
#endif
if(!done){
/* no compression, or too long after compression, or compress error
-> write non-compressed entry */
offs += fprintf(gl2ps->stream,
"/Length %d "
">>\n"
"stream\n",
(int)(im->width * im->height * sigbytes));
offs += gl2psPrintPDFPixmapStreamData(im, gl2psWriteBigEndian, gray);
}
offs += fprintf(gl2ps->stream,
"\nendstream\n"
"endobj\n");
return offs;
}
static int gl2psPrintPDFText(int obj, GL2PSstring *s, int fontnumber)
{
int offs = 0;
offs += fprintf(gl2ps->stream,
"%d 0 obj\n"
"<<\n"
"/Type /Font\n"
"/Subtype /Type1\n"
"/Name /F%d\n"
"/BaseFont /%s\n"
"/Encoding /MacRomanEncoding\n"
">>\n"
"endobj\n",
obj, fontnumber, s->fontname);
return offs;
}
/* Write the physical objects */
static int gl2psPDFgroupListWriteObjects(int entryoffs)
{
int i,j;
GL2PSprimitive *p = NULL;
GL2PSpdfgroup *gro;
int offs = entryoffs;
GL2PStriangle *triangles;
int size = 0;
if(!gl2ps->pdfgrouplist)
return offs;
for(i = 0; i < gl2psListNbr(gl2ps->pdfgrouplist); ++i){
gro = (GL2PSpdfgroup*)gl2psListPointer(gl2ps->pdfgrouplist, i);
if(!gl2psListNbr(gro->ptrlist))
continue;
p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, 0);
switch(p->type){
case GL2PS_POINT:
break;
case GL2PS_LINE:
break;
case GL2PS_TRIANGLE:
size = gl2psListNbr(gro->ptrlist);
triangles = (GL2PStriangle*)gl2psMalloc(sizeof(GL2PStriangle) * size);
for(j = 0; j < size; ++j){
p = *(GL2PSprimitive**)gl2psListPointer(gro->ptrlist, j);
gl2psFillTriangleFromPrimitive(&triangles[j], p, GL_TRUE);
}
if(triangles[0].prop & T_VAR_COLOR){
gl2ps->xreflist[gro->shobjno] = offs;
offs += gl2psPrintPDFShader(gro->shobjno, triangles, size, 0);
}
if(triangles[0].prop & T_ALPHA_LESS_1){
gl2ps->xreflist[gro->gsobjno] = offs;
offs += gl2psPrintPDFShaderSimpleExtGS(gro->gsobjno, triangles[0].vertex[0].rgba[3]);
}
if(triangles[0].prop & T_VAR_ALPHA){
gl2ps->xreflist[gro->gsobjno] = offs;
offs += gl2psPrintPDFShaderExtGS(gro->gsobjno, gro->trgroupobjno);
gl2ps->xreflist[gro->trgroupobjno] = offs;
offs += gl2psPrintPDFShaderMask(gro->trgroupobjno, gro->maskshno);
gl2ps->xreflist[gro->maskshobjno] = offs;
offs += gl2psPrintPDFShader(gro->maskshobjno, triangles, size, 8);
}
gl2psFree(triangles);
break;
case GL2PS_PIXMAP:
gl2ps->xreflist[gro->imobjno] = offs;
offs += gl2psPrintPDFPixmap(gro->imobjno, gro->imobjno+1, p->data.image, 0);
if(p->data.image->format == GL_RGBA){
gl2ps->xreflist[gro->imobjno+1] = offs;
offs += gl2psPrintPDFPixmap(gro->imobjno+1, -1, p->data.image, 8);
}
break;
case GL2PS_TEXT:
gl2ps->xreflist[gro->fontobjno] = offs;
offs += gl2psPrintPDFText(gro->fontobjno,p->data.text,gro->fontno);
break;
case GL2PS_SPECIAL :
/* alignment contains the format for which the special output text
is intended */
if(p->data.text->alignment == GL2PS_PDF)
offs += fprintf(gl2ps->stream, "%s\n", p->data.text->str);
break;
default:
break;
}
}
return offs;
}
/* All variable data has been written at this point and all required
functioninality has been gathered, so we can write now file footer
with cross reference table and trailer */
static void gl2psPrintPDFFooter(void)
{
int i, offs;
gl2psPDFgroupListInit();
gl2psPDFgroupListWriteMainStream();
offs = gl2ps->xreflist[5] + gl2ps->streamlength;
offs += gl2psClosePDFDataStream();
gl2ps->xreflist[5] = offs;
offs += gl2psPrintPDFDataStreamLength(gl2ps->streamlength);
gl2ps->xreflist[6] = offs;
gl2ps->streamlength = 0;
offs += gl2psPrintPDFOpenPage();
offs += gl2psPDFgroupListWriteVariableResources();
gl2ps->xreflist = (int*)gl2psRealloc(gl2ps->xreflist,
sizeof(int) * (gl2ps->objects_stack + 1));
gl2ps->xreflist[7] = offs;
offs += gl2psPrintPDFGSObject();
gl2ps->xreflist[8] = offs;
gl2ps->xreflist[gl2ps->objects_stack] =
gl2psPDFgroupListWriteObjects(gl2ps->xreflist[8]);
/* Start cross reference table. The file has to been opened in
binary mode to preserve the 20 digit string length! */
fprintf(gl2ps->stream,
"xref\n"
"0 %d\n"
"%010d 65535 f \n", gl2ps->objects_stack, 0);
for(i = 1; i < gl2ps->objects_stack; ++i)
fprintf(gl2ps->stream, "%010d 00000 n \n", gl2ps->xreflist[i]);
fprintf(gl2ps->stream,
"trailer\n"
"<<\n"
"/Size %d\n"
"/Info 1 0 R\n"
"/Root 2 0 R\n"
">>\n"
"startxref\n%d\n"
"%%%%EOF\n",
gl2ps->objects_stack, gl2ps->xreflist[gl2ps->objects_stack]);
/* Free auxiliary lists and arrays */
gl2psFree(gl2ps->xreflist);
gl2psListAction(gl2ps->pdfprimlist, gl2psFreePrimitive);
gl2psListDelete(gl2ps->pdfprimlist);
gl2psPDFgroupListDelete();
#if defined(GL2PS_HAVE_ZLIB)
if(gl2ps->options & GL2PS_COMPRESS){
gl2psFreeCompress();
gl2psFree(gl2ps->compress);
gl2ps->compress = NULL;
}
#endif
}
/* PDF begin viewport */
static void gl2psPrintPDFBeginViewport(GLint viewport[4])
{
int offs = 0;
GLint idx;
GLfloat rgba[4];
int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
glRenderMode(GL_FEEDBACK);
gl2psResetLineProperties();
if(gl2ps->header){
gl2psPrintPDFHeader();
gl2ps->header = GL_FALSE;
}
offs += gl2psPrintf("q\n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
}
else{
glGetIntegerv(GL_INDEX_CLEAR_VALUE, &idx);
rgba[0] = gl2ps->colormap[idx][0];
rgba[1] = gl2ps->colormap[idx][1];
rgba[2] = gl2ps->colormap[idx][2];
rgba[3] = 1.0F;
}
offs += gl2psPrintPDFFillColor(rgba);
offs += gl2psPrintf("%d %d %d %d re\n"
"W\n"
"f\n",
x, y, w, h);
}
else{
offs += gl2psPrintf("%d %d %d %d re\n"
"W\n"
"n\n",
x, y, w, h);
}
gl2ps->streamlength += offs;
}
static GLint gl2psPrintPDFEndViewport(void)
{
GLint res;
res = gl2psPrintPrimitives();
gl2ps->streamlength += gl2psPrintf("Q\n");
return res;
}
static void gl2psPrintPDFFinalPrimitive(void)
{
}
/* definition of the PDF backend */
static GL2PSbackend gl2psPDF = {
gl2psPrintPDFHeader,
gl2psPrintPDFFooter,
gl2psPrintPDFBeginViewport,
gl2psPrintPDFEndViewport,
gl2psPrintPDFPrimitive,
gl2psPrintPDFFinalPrimitive,
"pdf",
"Portable Document Format"
};
/*********************************************************************
*
* SVG routines
*
*********************************************************************/
static void gl2psSVGGetCoordsAndColors(int n, GL2PSvertex *verts,
GL2PSxyz *xyz, GL2PSrgba *rgba)
{
int i, j;
for(i = 0; i < n; i++){
xyz[i][0] = verts[i].xyz[0];
xyz[i][1] = gl2ps->viewport[3] - verts[i].xyz[1];
xyz[i][2] = 0.0F;
for(j = 0; j < 4; j++)
rgba[i][j] = verts[i].rgba[j];
}
}
static void gl2psSVGGetColorString(GL2PSrgba rgba, char str[32])
{
int r = (int)(255. * rgba[0]);
int g = (int)(255. * rgba[1]);
int b = (int)(255. * rgba[2]);
int rc = (r < 0) ? 0 : (r > 255) ? 255 : r;
int gc = (g < 0) ? 0 : (g > 255) ? 255 : g;
int bc = (b < 0) ? 0 : (b > 255) ? 255 : b;
sprintf(str, "#%2.2x%2.2x%2.2x", rc, gc, bc);
}
static void gl2psPrintSVGHeader(void)
{
int x, y, width, height;
char col[32];
time_t now;
time(&now);
if (gl2ps->options & GL2PS_LANDSCAPE){
x = (int)gl2ps->viewport[1];
y = (int)gl2ps->viewport[0];
width = (int)gl2ps->viewport[3];
height = (int)gl2ps->viewport[2];
}
else{
x = (int)gl2ps->viewport[0];
y = (int)gl2ps->viewport[1];
width = (int)gl2ps->viewport[2];
height = (int)gl2ps->viewport[3];
}
/* Compressed SVG files (.svgz) are simply gzipped SVG files */
gl2psPrintGzipHeader();
gl2psPrintf("\n");
gl2psPrintf("\n",
width, height, x, y, width, height);
gl2psPrintf("%s \n", gl2ps->title);
gl2psPrintf("\n");
gl2psPrintf("Creator: GL2PS %d.%d.%d%s, %s\n"
"For: %s\n"
"CreationDate: %s",
GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION, GL2PS_PATCH_VERSION,
GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT, gl2ps->producer, ctime(&now));
gl2psPrintf(" \n");
gl2psPrintf("\n");
gl2psPrintf(" \n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
gl2psSVGGetColorString(gl2ps->bgcolor, col);
gl2psPrintf("\n");
}
static void gl2psPrintSVGSmoothTriangle(GL2PSxyz xyz[3], GL2PSrgba rgba[3])
{
int i;
GL2PSxyz xyz2[3];
GL2PSrgba rgba2[3];
char col[32];
/* Apparently there is no easy way to do Gouraud shading in SVG
without explicitly pre-defining gradients, so for now we just do
recursive subdivision */
if(gl2psSameColorThreshold(3, rgba, gl2ps->threshold)){
gl2psSVGGetColorString(rgba[0], col);
gl2psPrintf("width, pixmap->height);
gl2psPrintf("transform=\"matrix(%g,0,0,%g,%g,%g)\"\n",
pixmap->zoom_x, pixmap->zoom_y, x, y);
gl2psPrintf("xlink:href=\"data:image/png;base64,");
for(i = 0; i < gl2psListNbr(png); i++){
gl2psListRead(png, i, &c);
gl2psPrintf("%c", c);
}
gl2psPrintf("\"/>\n");
gl2psListDelete(png);
#else
(void) x; (void) y; (void) pixmap; /* not used */
gl2psMsg(GL2PS_WARNING, "GL2PS must be compiled with PNG support in "
"order to embed images in SVG streams");
#endif
}
static void gl2psPrintSVGPrimitive(void *data)
{
GL2PSprimitive *prim;
GL2PSxyz xyz[4];
GL2PSrgba rgba[4];
char col[32];
char lcap[7], ljoin[7];
int newline;
prim = *(GL2PSprimitive**)data;
if((gl2ps->options & GL2PS_OCCLUSION_CULL) && prim->culled) return;
/* We try to draw connected lines as a single path to get nice line
joins and correct stippling. So if the primitive to print is not
a line we must first finish the current line (if any): */
if(prim->type != GL2PS_LINE) gl2psEndSVGLine();
gl2psSVGGetCoordsAndColors(prim->numverts, prim->verts, xyz, rgba);
switch(prim->type){
case GL2PS_POINT :
gl2psSVGGetColorString(rgba[0], col);
gl2psPrintf("\n",
xyz[0][0], xyz[0][1], 0.5 * prim->width);
break;
case GL2PS_LINE :
if(!gl2psSamePosition(gl2ps->lastvertex.xyz, prim->verts[0].xyz) ||
!gl2psSameColor(gl2ps->lastrgba, prim->verts[0].rgba) ||
gl2ps->lastlinewidth != prim->width ||
gl2ps->lastlinecap != prim->linecap ||
gl2ps->lastlinejoin != prim->linejoin ||
gl2ps->lastpattern != prim->pattern ||
gl2ps->lastfactor != prim->factor){
/* End the current line if the new segment does not start where
the last one ended, or if the color, the width or the
stippling have changed (we will need to use multi-point
gradients for smooth-shaded lines) */
gl2psEndSVGLine();
newline = 1;
}
else{
newline = 0;
}
gl2ps->lastvertex = prim->verts[1];
gl2psSetLastColor(prim->verts[0].rgba);
gl2ps->lastlinewidth = prim->width;
gl2ps->lastlinecap = prim->linecap;
gl2ps->lastlinejoin = prim->linejoin;
gl2ps->lastpattern = prim->pattern;
gl2ps->lastfactor = prim->factor;
if(newline){
gl2psSVGGetColorString(rgba[0], col);
gl2psPrintf("width);
switch (prim->linecap){
case GL2PS_LINE_CAP_BUTT:
sprintf (lcap, "%s", "butt");
break;
case GL2PS_LINE_CAP_ROUND:
sprintf (lcap, "%s", "round");
break;
case GL2PS_LINE_CAP_SQUARE:
sprintf (lcap, "%s", "square");
break;
}
switch (prim->linejoin){
case GL2PS_LINE_JOIN_MITER:
sprintf (ljoin, "%s", "miter");
break;
case GL2PS_LINE_JOIN_ROUND:
sprintf (ljoin, "%s", "round");
break;
case GL2PS_LINE_JOIN_BEVEL:
sprintf (ljoin, "%s", "bevel");
break;
}
gl2psPrintf("stroke-linecap=\"%s\" stroke-linejoin=\"%s\" ",
lcap, ljoin);
if(rgba[0][3] < 1.0F) gl2psPrintf("stroke-opacity=\"%g\" ", rgba[0][3]);
gl2psPrintSVGDash(prim->pattern, prim->factor);
gl2psPrintf("points=\"%g,%g ", xyz[0][0], xyz[0][1]);
}
else{
gl2psPrintf("%g,%g ", xyz[0][0], xyz[0][1]);
}
break;
case GL2PS_TRIANGLE :
gl2psPrintSVGSmoothTriangle(xyz, rgba);
break;
case GL2PS_QUADRANGLE :
gl2psMsg(GL2PS_WARNING, "There should not be any quad left to print");
break;
case GL2PS_PIXMAP :
gl2psPrintSVGPixmap(xyz[0][0], xyz[0][1], prim->data.image);
break;
case GL2PS_TEXT :
gl2psSVGGetColorString(prim->verts[0].rgba, col);
gl2psPrintf("data.text->fontsize);
if(prim->data.text->angle != 0.0)
gl2psPrintf("transform=\"rotate(%g, %g, %g)\" ",
-prim->data.text->angle, xyz[0][0], xyz[0][1]);
switch(prim->data.text->alignment){
case GL2PS_TEXT_C:
gl2psPrintf("text-anchor=\"middle\" dy=\"%d\" ",
prim->data.text->fontsize / 2);
break;
case GL2PS_TEXT_CL:
gl2psPrintf("text-anchor=\"start\" dy=\"%d\" ",
prim->data.text->fontsize / 2);
break;
case GL2PS_TEXT_CR:
gl2psPrintf("text-anchor=\"end\" dy=\"%d\" ",
prim->data.text->fontsize / 2);
break;
case GL2PS_TEXT_B:
gl2psPrintf("text-anchor=\"middle\" dy=\"0\" ");
break;
case GL2PS_TEXT_BR:
gl2psPrintf("text-anchor=\"end\" dy=\"0\" ");
break;
case GL2PS_TEXT_T:
gl2psPrintf("text-anchor=\"middle\" dy=\"%d\" ",
prim->data.text->fontsize);
break;
case GL2PS_TEXT_TL:
gl2psPrintf("text-anchor=\"start\" dy=\"%d\" ",
prim->data.text->fontsize);
break;
case GL2PS_TEXT_TR:
gl2psPrintf("text-anchor=\"end\" dy=\"%d\" ",
prim->data.text->fontsize);
break;
case GL2PS_TEXT_BL:
default: /* same as GL2PS_TEXT_BL */
gl2psPrintf("text-anchor=\"start\" dy=\"0\" ");
break;
}
if(!strcmp(prim->data.text->fontname, "Times-Roman"))
gl2psPrintf("font-family=\"Times\">");
else if(!strcmp(prim->data.text->fontname, "Times-Bold"))
gl2psPrintf("font-family=\"Times\" font-weight=\"bold\">");
else if(!strcmp(prim->data.text->fontname, "Times-Italic"))
gl2psPrintf("font-family=\"Times\" font-style=\"italic\">");
else if(!strcmp(prim->data.text->fontname, "Times-BoldItalic"))
gl2psPrintf("font-family=\"Times\" font-style=\"italic\" font-weight=\"bold\">");
else if(!strcmp(prim->data.text->fontname, "Helvetica-Bold"))
gl2psPrintf("font-family=\"Helvetica\" font-weight=\"bold\">");
else if(!strcmp(prim->data.text->fontname, "Helvetica-Oblique"))
gl2psPrintf("font-family=\"Helvetica\" font-style=\"oblique\">");
else if(!strcmp(prim->data.text->fontname, "Helvetica-BoldOblique"))
gl2psPrintf("font-family=\"Helvetica\" font-style=\"oblique\" font-weight=\"bold\">");
else if(!strcmp(prim->data.text->fontname, "Courier-Bold"))
gl2psPrintf("font-family=\"Courier\" font-weight=\"bold\">");
else if(!strcmp(prim->data.text->fontname, "Courier-Oblique"))
gl2psPrintf("font-family=\"Courier\" font-style=\"oblique\">");
else if(!strcmp(prim->data.text->fontname, "Courier-BoldOblique"))
gl2psPrintf("font-family=\"Courier\" font-style=\"oblique\" font-weight=\"bold\">");
else
gl2psPrintf("font-family=\"%s\">", prim->data.text->fontname);
gl2psPrintf("%s \n", prim->data.text->str);
break;
case GL2PS_SPECIAL :
/* alignment contains the format for which the special output text
is intended */
if(prim->data.text->alignment == GL2PS_SVG)
gl2psPrintf("%s\n", prim->data.text->str);
break;
default :
break;
}
}
static void gl2psPrintSVGFooter(void)
{
gl2psPrintf(" \n");
gl2psPrintf(" \n");
gl2psPrintGzipFooter();
}
static void gl2psPrintSVGBeginViewport(GLint viewport[4])
{
GLint idx;
char col[32];
GLfloat rgba[4];
int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
glRenderMode(GL_FEEDBACK);
gl2psResetLineProperties();
if(gl2ps->header){
gl2psPrintSVGHeader();
gl2ps->header = GL_FALSE;
}
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
}
else{
glGetIntegerv(GL_INDEX_CLEAR_VALUE, &idx);
rgba[0] = gl2ps->colormap[idx][0];
rgba[1] = gl2ps->colormap[idx][1];
rgba[2] = gl2ps->colormap[idx][2];
rgba[3] = 1.0F;
}
gl2psSVGGetColorString(rgba, col);
gl2psPrintf("viewport[3] - y,
x + w, gl2ps->viewport[3] - y,
x + w, gl2ps->viewport[3] - (y + h),
x, gl2ps->viewport[3] - (y + h));
gl2psPrintf("shape-rendering=\"crispEdges\"/>\n");
}
gl2psPrintf("\n", x, y, w, h);
gl2psPrintf(" \n");
gl2psPrintf("\n", x, y, w, h);
}
static GLint gl2psPrintSVGEndViewport(void)
{
GLint res;
res = gl2psPrintPrimitives();
gl2psPrintf(" \n");
return res;
}
static void gl2psPrintSVGFinalPrimitive(void)
{
/* End any remaining line, if any */
gl2psEndSVGLine();
}
/* definition of the SVG backend */
static GL2PSbackend gl2psSVG = {
gl2psPrintSVGHeader,
gl2psPrintSVGFooter,
gl2psPrintSVGBeginViewport,
gl2psPrintSVGEndViewport,
gl2psPrintSVGPrimitive,
gl2psPrintSVGFinalPrimitive,
"svg",
"Scalable Vector Graphics"
};
/*********************************************************************
*
* PGF routines
*
*********************************************************************/
static void gl2psPrintPGFColor(GL2PSrgba rgba)
{
if(!gl2psSameColor(gl2ps->lastrgba, rgba)){
gl2psSetLastColor(rgba);
fprintf(gl2ps->stream, "\\color[rgb]{%f,%f,%f}\n", rgba[0], rgba[1], rgba[2]);
}
}
static void gl2psPrintPGFHeader(void)
{
time_t now;
time(&now);
fprintf(gl2ps->stream,
"%% Title: %s\n"
"%% Creator: GL2PS %d.%d.%d%s, %s\n"
"%% For: %s\n"
"%% CreationDate: %s",
gl2ps->title, GL2PS_MAJOR_VERSION, GL2PS_MINOR_VERSION,
GL2PS_PATCH_VERSION, GL2PS_EXTRA_VERSION, GL2PS_COPYRIGHT,
gl2ps->producer, ctime(&now));
fprintf(gl2ps->stream, "\\begin{pgfpicture}\n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
gl2psPrintPGFColor(gl2ps->bgcolor);
fprintf(gl2ps->stream,
"\\pgfpathrectanglecorners{"
"\\pgfpoint{%dpt}{%dpt}}{\\pgfpoint{%dpt}{%dpt}}\n"
"\\pgfusepath{fill}\n",
(int)gl2ps->viewport[0], (int)gl2ps->viewport[1],
(int)gl2ps->viewport[2], (int)gl2ps->viewport[3]);
}
}
static void gl2psPrintPGFDash(GLushort pattern, GLint factor)
{
int i, n, array[10];
if(pattern == gl2ps->lastpattern && factor == gl2ps->lastfactor)
return;
gl2ps->lastpattern = pattern;
gl2ps->lastfactor = factor;
if(!pattern || !factor){
/* solid line */
fprintf(gl2ps->stream, "\\pgfsetdash{}{0pt}\n");
}
else{
gl2psParseStipplePattern(pattern, factor, &n, array);
fprintf(gl2ps->stream, "\\pgfsetdash{");
for(i = 0; i < n; i++) fprintf(gl2ps->stream, "{%dpt}", array[i]);
fprintf(gl2ps->stream, "}{0pt}\n");
}
}
static const char *gl2psPGFTextAlignment(int align)
{
switch(align){
case GL2PS_TEXT_C : return "center";
case GL2PS_TEXT_CL : return "west";
case GL2PS_TEXT_CR : return "east";
case GL2PS_TEXT_B : return "south";
case GL2PS_TEXT_BR : return "south east";
case GL2PS_TEXT_T : return "north";
case GL2PS_TEXT_TL : return "north west";
case GL2PS_TEXT_TR : return "north east";
case GL2PS_TEXT_BL :
default : return "south west";
}
}
static void gl2psPrintPGFPrimitive(void *data)
{
GL2PSprimitive *prim;
prim = *(GL2PSprimitive**)data;
switch(prim->type){
case GL2PS_POINT :
/* Points in openGL are rectangular */
gl2psPrintPGFColor(prim->verts[0].rgba);
fprintf(gl2ps->stream,
"\\pgfpathrectangle{\\pgfpoint{%fpt}{%fpt}}"
"{\\pgfpoint{%fpt}{%fpt}}\n\\pgfusepath{fill}\n",
prim->verts[0].xyz[0]-0.5*prim->width,
prim->verts[0].xyz[1]-0.5*prim->width,
prim->width,prim->width);
break;
case GL2PS_LINE :
gl2psPrintPGFColor(prim->verts[0].rgba);
if(gl2ps->lastlinewidth != prim->width){
gl2ps->lastlinewidth = prim->width;
fprintf(gl2ps->stream, "\\pgfsetlinewidth{%fpt}\n", gl2ps->lastlinewidth);
}
if(gl2ps->lastlinecap != prim->linecap){
gl2ps->lastlinecap = prim->linecap;
switch (prim->linecap){
case GL2PS_LINE_CAP_BUTT:
fprintf(gl2ps->stream, "\\pgfset%s\n", "buttcap");
break;
case GL2PS_LINE_CAP_ROUND:
fprintf(gl2ps->stream, "\\pgfset%s\n", "roundcap");
break;
case GL2PS_LINE_CAP_SQUARE:
fprintf(gl2ps->stream, "\\pgfset%s\n", "rectcap");
break;
}
}
if(gl2ps->lastlinejoin != prim->linejoin){
gl2ps->lastlinejoin = prim->linejoin;
switch (prim->linejoin){
case GL2PS_LINE_JOIN_MITER:
fprintf(gl2ps->stream, "\\pgfset%s\n", "miterjoin");
break;
case GL2PS_LINE_JOIN_ROUND:
fprintf(gl2ps->stream, "\\pgfset%s\n", "roundjoin");
break;
case GL2PS_LINE_JOIN_BEVEL:
fprintf(gl2ps->stream, "\\pgfset%s\n", "beveljoin");
break;
}
}
gl2psPrintPGFDash(prim->pattern, prim->factor);
fprintf(gl2ps->stream,
"\\pgfpathmoveto{\\pgfpoint{%fpt}{%fpt}}\n"
"\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n"
"\\pgfusepath{stroke}\n",
prim->verts[1].xyz[0], prim->verts[1].xyz[1],
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
break;
case GL2PS_TRIANGLE :
if(gl2ps->lastlinewidth != 0){
gl2ps->lastlinewidth = 0;
fprintf(gl2ps->stream, "\\pgfsetlinewidth{0.01pt}\n");
}
if(gl2ps->lastlinecap != prim->linecap){
gl2ps->lastlinecap = prim->linecap;
switch (prim->linecap){
case GL2PS_LINE_CAP_BUTT:
fprintf(gl2ps->stream, "\\pgfset%s\n", "buttcap");
break;
case GL2PS_LINE_CAP_ROUND:
fprintf(gl2ps->stream, "\\pgfset%s\n", "roundcap");
break;
case GL2PS_LINE_CAP_SQUARE:
fprintf(gl2ps->stream, "\\pgfset%s\n", "rectcap");
break;
}
}
if(gl2ps->lastlinejoin != prim->linejoin){
gl2ps->lastlinejoin = prim->linejoin;
switch (prim->linejoin){
case GL2PS_LINE_JOIN_MITER:
fprintf(gl2ps->stream, "\\pgfset%s\n", "miterjoin");
break;
case GL2PS_LINE_JOIN_ROUND:
fprintf(gl2ps->stream, "\\pgfset%s\n", "roundjoin");
break;
case GL2PS_LINE_JOIN_BEVEL:
fprintf(gl2ps->stream, "\\pgfset%s\n", "beveljoin");
break;
}
}
gl2psPrintPGFColor(prim->verts[0].rgba);
fprintf(gl2ps->stream,
"\\pgfpathmoveto{\\pgfpoint{%fpt}{%fpt}}\n"
"\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n"
"\\pgflineto{\\pgfpoint{%fpt}{%fpt}}\n"
"\\pgfpathclose\n"
"\\pgfusepath{fill,stroke}\n",
prim->verts[2].xyz[0], prim->verts[2].xyz[1],
prim->verts[1].xyz[0], prim->verts[1].xyz[1],
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
break;
case GL2PS_TEXT :
fprintf(gl2ps->stream, "{\n\\pgftransformshift{\\pgfpoint{%fpt}{%fpt}}\n",
prim->verts[0].xyz[0], prim->verts[0].xyz[1]);
if(prim->data.text->angle != 0.0)
fprintf(gl2ps->stream, "\\pgftransformrotate{%f}{", prim->data.text->angle);
fprintf(gl2ps->stream, "\\pgfnode{rectangle}{%s}{\\fontsize{%d}{0}\\selectfont",
gl2psPGFTextAlignment(prim->data.text->alignment),
prim->data.text->fontsize);
fprintf(gl2ps->stream, "\\textcolor[rgb]{%g,%g,%g}{{%s}}",
prim->verts[0].rgba[0], prim->verts[0].rgba[1],
prim->verts[0].rgba[2], prim->data.text->str);
fprintf(gl2ps->stream, "}{}{\\pgfusepath{discard}}}");
if(prim->data.text->angle != 0.0)
fprintf(gl2ps->stream, "}");
fprintf(gl2ps->stream, "\n");
break;
case GL2PS_SPECIAL :
/* alignment contains the format for which the special output text
is intended */
if (prim->data.text->alignment == GL2PS_PGF)
fprintf(gl2ps->stream, "%s\n", prim->data.text->str);
break;
default :
break;
}
}
static void gl2psPrintPGFFooter(void)
{
fprintf(gl2ps->stream, "\\end{pgfpicture}\n");
}
static void gl2psPrintPGFBeginViewport(GLint viewport[4])
{
GLint idx;
GLfloat rgba[4];
int x = viewport[0], y = viewport[1], w = viewport[2], h = viewport[3];
glRenderMode(GL_FEEDBACK);
gl2psResetLineProperties();
if(gl2ps->header){
gl2psPrintPGFHeader();
gl2ps->header = GL_FALSE;
}
fprintf(gl2ps->stream, "\\begin{pgfscope}\n");
if(gl2ps->options & GL2PS_DRAW_BACKGROUND){
if(gl2ps->colormode == GL_RGBA || gl2ps->colorsize == 0){
glGetFloatv(GL_COLOR_CLEAR_VALUE, rgba);
}
else{
glGetIntegerv(GL_INDEX_CLEAR_VALUE, &idx);
rgba[0] = gl2ps->colormap[idx][0];
rgba[1] = gl2ps->colormap[idx][1];
rgba[2] = gl2ps->colormap[idx][2];
rgba[3] = 1.0F;
}
gl2psPrintPGFColor(rgba);
fprintf(gl2ps->stream,
"\\pgfpathrectangle{\\pgfpoint{%dpt}{%dpt}}"
"{\\pgfpoint{%dpt}{%dpt}}\n"
"\\pgfusepath{fill}\n",
x, y, w, h);
}
fprintf(gl2ps->stream,
"\\pgfpathrectangle{\\pgfpoint{%dpt}{%dpt}}"
"{\\pgfpoint{%dpt}{%dpt}}\n"
"\\pgfusepath{clip}\n",
x, y, w, h);
}
static GLint gl2psPrintPGFEndViewport(void)
{
GLint res;
res = gl2psPrintPrimitives();
fprintf(gl2ps->stream, "\\end{pgfscope}\n");
return res;
}
static void gl2psPrintPGFFinalPrimitive(void)
{
}
/* definition of the PGF backend */
static GL2PSbackend gl2psPGF = {
gl2psPrintPGFHeader,
gl2psPrintPGFFooter,
gl2psPrintPGFBeginViewport,
gl2psPrintPGFEndViewport,
gl2psPrintPGFPrimitive,
gl2psPrintPGFFinalPrimitive,
"tex",
"PGF Latex Graphics"
};
/*********************************************************************
*
* General primitive printing routine
*
*********************************************************************/
/* Warning: the ordering of the backends must match the format
#defines in gl2ps.h */
static GL2PSbackend *gl2psbackends[] = {
&gl2psPS, /* 0 */
&gl2psEPS, /* 1 */
&gl2psTEX, /* 2 */
&gl2psPDF, /* 3 */
&gl2psSVG, /* 4 */
&gl2psPGF /* 5 */
};
static void gl2psComputeTightBoundingBox(void *data)
{
GL2PSprimitive *prim;
int i;
prim = *(GL2PSprimitive**)data;
for(i = 0; i < prim->numverts; i++){
if(prim->verts[i].xyz[0] < gl2ps->viewport[0])
gl2ps->viewport[0] = (GLint)prim->verts[i].xyz[0];
if(prim->verts[i].xyz[0] > gl2ps->viewport[2])
gl2ps->viewport[2] = (GLint)(prim->verts[i].xyz[0] + 0.5F);
if(prim->verts[i].xyz[1] < gl2ps->viewport[1])
gl2ps->viewport[1] = (GLint)prim->verts[i].xyz[1];
if(prim->verts[i].xyz[1] > gl2ps->viewport[3])
gl2ps->viewport[3] = (GLint)(prim->verts[i].xyz[1] + 0.5F);
}
}
static GLint gl2psPrintPrimitives(void)
{
GL2PSbsptree *root;
GL2PSxyz eye = {0.0F, 0.0F, 100.0F * GL2PS_ZSCALE};
GLint used = 0;
if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
used = glRenderMode(GL_RENDER);
}
if(used < 0){
gl2psMsg(GL2PS_INFO, "OpenGL feedback buffer overflow");
return GL2PS_OVERFLOW;
}
if(used > 0)
gl2psParseFeedbackBuffer(used);
gl2psRescaleAndOffset();
if(gl2ps->header){
if(gl2psListNbr(gl2ps->primitives) &&
(gl2ps->options & GL2PS_TIGHT_BOUNDING_BOX)){
gl2ps->viewport[0] = gl2ps->viewport[1] = 100000;
gl2ps->viewport[2] = gl2ps->viewport[3] = -100000;
gl2psListAction(gl2ps->primitives, gl2psComputeTightBoundingBox);
}
(gl2psbackends[gl2ps->format]->printHeader)();
gl2ps->header = GL_FALSE;
}
if(!gl2psListNbr(gl2ps->primitives)){
/* empty feedback buffer and/or nothing else to print */
return GL2PS_NO_FEEDBACK;
}
switch(gl2ps->sort){
case GL2PS_NO_SORT :
gl2psListAction(gl2ps->primitives, gl2psbackends[gl2ps->format]->printPrimitive);
gl2psListAction(gl2ps->primitives, gl2psFreePrimitive);
/* reset the primitive list, waiting for the next viewport */
gl2psListReset(gl2ps->primitives);
break;
case GL2PS_SIMPLE_SORT :
gl2psListSort(gl2ps->primitives, gl2psCompareDepth);
if(gl2ps->options & GL2PS_OCCLUSION_CULL){
gl2psListActionInverse(gl2ps->primitives, gl2psAddInImageTree);
gl2psFreeBspImageTree(&gl2ps->imagetree);
}
gl2psListAction(gl2ps->primitives, gl2psbackends[gl2ps->format]->printPrimitive);
gl2psListAction(gl2ps->primitives, gl2psFreePrimitive);
/* reset the primitive list, waiting for the next viewport */
gl2psListReset(gl2ps->primitives);
break;
case GL2PS_BSP_SORT :
root = (GL2PSbsptree*)gl2psMalloc(sizeof(GL2PSbsptree));
gl2psBuildBspTree(root, gl2ps->primitives);
if(GL_TRUE == gl2ps->boundary) gl2psBuildPolygonBoundary(root);
if(gl2ps->options & GL2PS_OCCLUSION_CULL){
gl2psTraverseBspTree(root, eye, -GL2PS_EPSILON, gl2psLess,
gl2psAddInImageTree, 1);
gl2psFreeBspImageTree(&gl2ps->imagetree);
}
gl2psTraverseBspTree(root, eye, GL2PS_EPSILON, gl2psGreater,
gl2psbackends[gl2ps->format]->printPrimitive, 0);
gl2psFreeBspTree(&root);
/* reallocate the primitive list (it's been deleted by
gl2psBuildBspTree) in case there is another viewport */
gl2ps->primitives = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*));
break;
}
gl2psbackends[gl2ps->format]->printFinalPrimitive();
return GL2PS_SUCCESS;
}
static GLboolean gl2psCheckOptions(GLint options, GLint colormode)
{
if (options & GL2PS_NO_OPENGL_CONTEXT) {
if (options & GL2PS_DRAW_BACKGROUND) {
gl2psMsg(GL2PS_ERROR, "Options GL2PS_NO_OPENGL_CONTEXT and "
"GL2PS_DRAW_BACKGROUND are incompatible.");
return GL_FALSE;
}
if (options & GL2PS_USE_CURRENT_VIEWPORT) {
gl2psMsg(GL2PS_ERROR, "Options GL2PS_NO_OPENGL_CONTEXT and "
"GL2PS_USE_CURRENT_VIEWPORT are incompatible.");
return GL_FALSE;
}
if ((options & GL2PS_NO_BLENDING) == GL2PS_NONE) {
gl2psMsg(GL2PS_ERROR, "Option GL2PS_NO_OPENGL_CONTEXT requires "
"option GL2PS_NO_BLENDING.");
return GL_FALSE;
}
if (colormode != GL_RGBA) {
gl2psMsg(GL2PS_ERROR, "Option GL2PS_NO_OPENGL_CONTEXT requires colormode "
"to be GL_RGBA.");
return GL_FALSE;
}
}
return GL_TRUE;
}
/*********************************************************************
*
* Public routines
*
*********************************************************************/
GL2PSDLL_API GLint gl2psBeginPage(const char *title, const char *producer,
GLint viewport[4], GLint format, GLint sort,
GLint options, GLint colormode,
GLint colorsize, GL2PSrgba *colormap,
GLint nr, GLint ng, GLint nb, GLint buffersize,
FILE *stream, const char *filename)
{
GLint idx;
int i;
if(gl2ps){
gl2psMsg(GL2PS_ERROR, "gl2psBeginPage called in wrong program state");
return GL2PS_ERROR;
}
gl2ps = (GL2PScontext*)gl2psMalloc(sizeof(GL2PScontext));
/* Validate options */
if (gl2psCheckOptions(options, colormode) == GL_FALSE) {
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
if(format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0]))){
gl2ps->format = format;
}
else {
gl2psMsg(GL2PS_ERROR, "Unknown output format: %d", format);
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
switch(sort){
case GL2PS_NO_SORT :
case GL2PS_SIMPLE_SORT :
case GL2PS_BSP_SORT :
gl2ps->sort = sort;
break;
default :
gl2psMsg(GL2PS_ERROR, "Unknown sorting algorithm: %d", sort);
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
if(stream){
gl2ps->stream = stream;
}
else{
gl2psMsg(GL2PS_ERROR, "Bad file pointer");
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
gl2ps->header = GL_TRUE;
gl2ps->forcerasterpos = GL_FALSE;
gl2ps->maxbestroot = 10;
gl2ps->options = options;
gl2ps->compress = NULL;
gl2ps->imagemap_head = NULL;
gl2ps->imagemap_tail = NULL;
if(gl2ps->options & GL2PS_USE_CURRENT_VIEWPORT){
glGetIntegerv(GL_VIEWPORT, gl2ps->viewport);
}
else{
for(i = 0; i < 4; i++){
gl2ps->viewport[i] = viewport[i];
}
}
if(!gl2ps->viewport[2] || !gl2ps->viewport[3]){
gl2psMsg(GL2PS_ERROR, "Incorrect viewport (x=%d, y=%d, width=%d, height=%d)",
gl2ps->viewport[0], gl2ps->viewport[1],
gl2ps->viewport[2], gl2ps->viewport[3]);
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
gl2ps->threshold[0] = nr ? 1.0F / (GLfloat)nr : 0.064F;
gl2ps->threshold[1] = ng ? 1.0F / (GLfloat)ng : 0.034F;
gl2ps->threshold[2] = nb ? 1.0F / (GLfloat)nb : 0.100F;
gl2ps->colormode = colormode;
gl2ps->buffersize = buffersize > 0 ? buffersize : 2048 * 2048;
for(i = 0; i < 3; i++){
gl2ps->lastvertex.xyz[i] = -1.0F;
}
for(i = 0; i < 4; i++){
gl2ps->lastvertex.rgba[i] = -1.0F;
gl2ps->lastrgba[i] = -1.0F;
}
gl2ps->lastlinewidth = -1.0F;
gl2ps->lastlinecap = 0;
gl2ps->lastlinejoin = 0;
gl2ps->lastpattern = 0;
gl2ps->lastfactor = 0;
gl2ps->imagetree = NULL;
gl2ps->primitivetoadd = NULL;
gl2ps->zerosurfacearea = GL_FALSE;
gl2ps->pdfprimlist = NULL;
gl2ps->pdfgrouplist = NULL;
gl2ps->xreflist = NULL;
/* get default blending mode from current OpenGL state (enabled by
default for SVG) */
if ((gl2ps->options & GL2PS_NO_BLENDING) == GL2PS_NONE) {
gl2ps->blending = (gl2ps->format == GL2PS_SVG) ? GL_TRUE
: glIsEnabled(GL_BLEND);
glGetIntegerv(GL_BLEND_SRC, &gl2ps->blendfunc[0]);
glGetIntegerv(GL_BLEND_DST, &gl2ps->blendfunc[1]);
}
else {
gl2ps->blending = GL_FALSE;
}
if(gl2ps->colormode == GL_RGBA){
gl2ps->colorsize = 0;
gl2ps->colormap = NULL;
if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
glGetFloatv(GL_COLOR_CLEAR_VALUE, gl2ps->bgcolor);
}
}
else if(gl2ps->colormode == GL_COLOR_INDEX){
if(!colorsize || !colormap){
gl2psMsg(GL2PS_ERROR, "Missing colormap for GL_COLOR_INDEX rendering");
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
gl2ps->colorsize = colorsize;
gl2ps->colormap = (GL2PSrgba*)gl2psMalloc(gl2ps->colorsize * sizeof(GL2PSrgba));
memcpy(gl2ps->colormap, colormap, gl2ps->colorsize * sizeof(GL2PSrgba));
glGetIntegerv(GL_INDEX_CLEAR_VALUE, &idx);
gl2ps->bgcolor[0] = gl2ps->colormap[idx][0];
gl2ps->bgcolor[1] = gl2ps->colormap[idx][1];
gl2ps->bgcolor[2] = gl2ps->colormap[idx][2];
gl2ps->bgcolor[3] = 1.0F;
}
else{
gl2psMsg(GL2PS_ERROR, "Unknown color mode in gl2psBeginPage");
gl2psFree(gl2ps);
gl2ps = NULL;
return GL2PS_ERROR;
}
if(!title){
gl2ps->title = (char*)gl2psMalloc(sizeof(char));
gl2ps->title[0] = '\0';
}
else{
gl2ps->title = (char*)gl2psMalloc((strlen(title)+1)*sizeof(char));
strcpy(gl2ps->title, title);
}
if(!producer){
gl2ps->producer = (char*)gl2psMalloc(sizeof(char));
gl2ps->producer[0] = '\0';
}
else{
gl2ps->producer = (char*)gl2psMalloc((strlen(producer)+1)*sizeof(char));
strcpy(gl2ps->producer, producer);
}
if(!filename){
gl2ps->filename = (char*)gl2psMalloc(sizeof(char));
gl2ps->filename[0] = '\0';
}
else{
gl2ps->filename = (char*)gl2psMalloc((strlen(filename)+1)*sizeof(char));
strcpy(gl2ps->filename, filename);
}
gl2ps->primitives = gl2psListCreate(500, 500, sizeof(GL2PSprimitive*));
gl2ps->auxprimitives = gl2psListCreate(100, 100, sizeof(GL2PSprimitive*));
if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
gl2ps->feedback = (GLfloat*)gl2psMalloc(gl2ps->buffersize * sizeof(GLfloat));
glFeedbackBuffer(gl2ps->buffersize, GL_3D_COLOR, gl2ps->feedback);
glRenderMode(GL_FEEDBACK);
}
else {
gl2ps->feedback = NULL;
gl2ps->buffersize = 0;
}
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psEndPage(void)
{
GLint res;
if(!gl2ps) return GL2PS_UNINITIALIZED;
res = gl2psPrintPrimitives();
if(res != GL2PS_OVERFLOW)
(gl2psbackends[gl2ps->format]->printFooter)();
fflush(gl2ps->stream);
gl2psListDelete(gl2ps->primitives);
gl2psListDelete(gl2ps->auxprimitives);
gl2psFreeImagemap(gl2ps->imagemap_head);
gl2psFree(gl2ps->colormap);
gl2psFree(gl2ps->title);
gl2psFree(gl2ps->producer);
gl2psFree(gl2ps->filename);
gl2psFree(gl2ps->feedback);
gl2psFree(gl2ps);
gl2ps = NULL;
return res;
}
GL2PSDLL_API GLint gl2psBeginViewport(GLint viewport[4])
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
(gl2psbackends[gl2ps->format]->beginViewport)(viewport);
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psEndViewport(void)
{
GLint res;
if(!gl2ps) return GL2PS_UNINITIALIZED;
res = (gl2psbackends[gl2ps->format]->endViewport)();
/* reset last used colors, line widths */
gl2psResetLineProperties();
return res;
}
GL2PSDLL_API GLint gl2psTextOptColor(const char *str, const char *fontname,
GLshort fontsize, GLint alignment, GLfloat angle,
GL2PSrgba color)
{
return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, alignment, angle,
color);
}
GL2PSDLL_API GLint gl2psTextOpt(const char *str, const char *fontname,
GLshort fontsize, GLint alignment, GLfloat angle)
{
return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, alignment, angle, NULL);
}
GL2PSDLL_API GLint gl2psText(const char *str, const char *fontname, GLshort fontsize)
{
return gl2psAddText(GL2PS_TEXT, str, fontname, fontsize, GL2PS_TEXT_BL, 0.0F,
NULL);
}
GL2PSDLL_API GLint gl2psSpecial(GLint format, const char *str)
{
return gl2psAddText(GL2PS_SPECIAL, str, "", 0, format, 0.0F, NULL);
}
GL2PSDLL_API GLint gl2psSpecialColor(GLint format, const char *str, GL2PSrgba rgba)
{
return gl2psAddText(GL2PS_SPECIAL, str, "", 0, format, 0.0F, rgba);
}
GL2PSDLL_API GLint gl2psDrawPixels(GLsizei width, GLsizei height,
GLint xorig, GLint yorig,
GLenum format, GLenum type,
const void *pixels)
{
int size, i;
const GLfloat *piv;
GLfloat pos[4], zoom_x, zoom_y;
GL2PSprimitive *prim;
GLboolean valid;
if(!gl2ps || !pixels) return GL2PS_UNINITIALIZED;
if((width <= 0) || (height <= 0)) return GL2PS_ERROR;
if(gl2ps->options & GL2PS_NO_PIXMAP) return GL2PS_SUCCESS;
if((format != GL_RGB && format != GL_RGBA) || type != GL_FLOAT){
gl2psMsg(GL2PS_ERROR, "gl2psDrawPixels only implemented for "
"GL_RGB/GL_RGBA, GL_FLOAT pixels");
return GL2PS_ERROR;
}
if (gl2ps->forcerasterpos) {
pos[0] = gl2ps->rasterpos.xyz[0];
pos[1] = gl2ps->rasterpos.xyz[1];
pos[2] = gl2ps->rasterpos.xyz[2];
pos[3] = 1.f;
/* Hardcode zoom factors (for now?) */
zoom_x = 1.f;
zoom_y = 1.f;
}
else {
glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
if(GL_FALSE == valid) return GL2PS_SUCCESS; /* the primitive is culled */
glGetFloatv(GL_CURRENT_RASTER_POSITION, pos);
glGetFloatv(GL_ZOOM_X, &zoom_x);
glGetFloatv(GL_ZOOM_Y, &zoom_y);
}
prim = (GL2PSprimitive*)gl2psMalloc(sizeof(GL2PSprimitive));
prim->type = GL2PS_PIXMAP;
prim->boundary = 0;
prim->numverts = 1;
prim->verts = (GL2PSvertex*)gl2psMalloc(sizeof(GL2PSvertex));
prim->verts[0].xyz[0] = pos[0] + xorig;
prim->verts[0].xyz[1] = pos[1] + yorig;
prim->verts[0].xyz[2] = pos[2];
prim->culled = 0;
prim->offset = 0;
prim->ofactor = 0.0;
prim->ounits = 0.0;
prim->pattern = 0;
prim->factor = 0;
prim->width = 1;
if (gl2ps->forcerasterpos) {
prim->verts[0].rgba[0] = gl2ps->rasterpos.rgba[0];
prim->verts[0].rgba[1] = gl2ps->rasterpos.rgba[1];
prim->verts[0].rgba[2] = gl2ps->rasterpos.rgba[2];
prim->verts[0].rgba[3] = gl2ps->rasterpos.rgba[3];
}
else {
glGetFloatv(GL_CURRENT_RASTER_COLOR, prim->verts[0].rgba);
}
prim->data.image = (GL2PSimage*)gl2psMalloc(sizeof(GL2PSimage));
prim->data.image->width = width;
prim->data.image->height = height;
prim->data.image->zoom_x = zoom_x;
prim->data.image->zoom_y = zoom_y;
prim->data.image->format = format;
prim->data.image->type = type;
gl2ps->forcerasterpos = GL_FALSE;
switch(format){
case GL_RGBA:
if(gl2ps->options & GL2PS_NO_BLENDING || !gl2ps->blending){
/* special case: blending turned off */
prim->data.image->format = GL_RGB;
size = height * width * 3;
prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat));
piv = (const GLfloat*)pixels;
for(i = 0; i < size; ++i, ++piv){
prim->data.image->pixels[i] = *piv;
if(!((i + 1) % 3))
++piv;
}
}
else{
size = height * width * 4;
prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat));
memcpy(prim->data.image->pixels, pixels, size * sizeof(GLfloat));
}
break;
case GL_RGB:
default:
size = height * width * 3;
prim->data.image->pixels = (GLfloat*)gl2psMalloc(size * sizeof(GLfloat));
memcpy(prim->data.image->pixels, pixels, size * sizeof(GLfloat));
break;
}
/* If no OpenGL context, just add directly to primitives */
if ((gl2ps->options & GL2PS_NO_OPENGL_CONTEXT) == GL2PS_NONE) {
gl2psListAdd(gl2ps->auxprimitives, &prim);
glPassThrough(GL2PS_DRAW_PIXELS_TOKEN);
}
else {
gl2psListAdd(gl2ps->primitives, &prim);
}
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psDrawImageMap(GLsizei width, GLsizei height,
const GLfloat position[3],
const unsigned char *imagemap){
int size, i;
int sizeoffloat = sizeof(GLfloat);
if(!gl2ps || !imagemap) return GL2PS_UNINITIALIZED;
if((width <= 0) || (height <= 0)) return GL2PS_ERROR;
size = height + height * ((width - 1) / 8);
glPassThrough(GL2PS_IMAGEMAP_TOKEN);
glBegin(GL_POINTS);
glVertex3f(position[0], position[1],position[2]);
glEnd();
glPassThrough((GLfloat)width);
glPassThrough((GLfloat)height);
for(i = 0; i < size; i += sizeoffloat){
const float *value = (const float*)imagemap;
glPassThrough(*value);
imagemap += sizeoffloat;
}
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psEnable(GLint mode)
{
GLint tmp;
GLfloat tmp2;
if(!gl2ps) return GL2PS_UNINITIALIZED;
switch(mode){
case GL2PS_POLYGON_OFFSET_FILL :
glPassThrough(GL2PS_BEGIN_OFFSET_TOKEN);
glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &tmp2);
glPassThrough(tmp2);
glGetFloatv(GL_POLYGON_OFFSET_UNITS, &tmp2);
glPassThrough(tmp2);
break;
case GL2PS_POLYGON_BOUNDARY :
glPassThrough(GL2PS_BEGIN_BOUNDARY_TOKEN);
break;
case GL2PS_LINE_STIPPLE :
glPassThrough(GL2PS_BEGIN_STIPPLE_TOKEN);
glGetIntegerv(GL_LINE_STIPPLE_PATTERN, &tmp);
glPassThrough((GLfloat)tmp);
glGetIntegerv(GL_LINE_STIPPLE_REPEAT, &tmp);
glPassThrough((GLfloat)tmp);
break;
case GL2PS_BLEND :
glPassThrough(GL2PS_BEGIN_BLEND_TOKEN);
break;
default :
gl2psMsg(GL2PS_WARNING, "Unknown mode in gl2psEnable: %d", mode);
return GL2PS_WARNING;
}
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psDisable(GLint mode)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
switch(mode){
case GL2PS_POLYGON_OFFSET_FILL :
glPassThrough(GL2PS_END_OFFSET_TOKEN);
break;
case GL2PS_POLYGON_BOUNDARY :
glPassThrough(GL2PS_END_BOUNDARY_TOKEN);
break;
case GL2PS_LINE_STIPPLE :
glPassThrough(GL2PS_END_STIPPLE_TOKEN);
break;
case GL2PS_BLEND :
glPassThrough(GL2PS_END_BLEND_TOKEN);
break;
default :
gl2psMsg(GL2PS_WARNING, "Unknown mode in gl2psDisable: %d", mode);
return GL2PS_WARNING;
}
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psPointSize(GLfloat value)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
glPassThrough(GL2PS_POINT_SIZE_TOKEN);
glPassThrough(value);
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psLineCap(GLint value)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
glPassThrough(GL2PS_LINE_CAP_TOKEN);
glPassThrough(value);
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psLineJoin(GLint value)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
glPassThrough(GL2PS_LINE_JOIN_TOKEN);
glPassThrough(value);
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psLineWidth(GLfloat value)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
glPassThrough(GL2PS_LINE_WIDTH_TOKEN);
glPassThrough(value);
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psBlendFunc(GLenum sfactor, GLenum dfactor)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
if(GL_FALSE == gl2psSupportedBlendMode(sfactor, dfactor))
return GL2PS_WARNING;
glPassThrough(GL2PS_SRC_BLEND_TOKEN);
glPassThrough((GLfloat)sfactor);
glPassThrough(GL2PS_DST_BLEND_TOKEN);
glPassThrough((GLfloat)dfactor);
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psSetOptions(GLint options)
{
if(!gl2ps) return GL2PS_UNINITIALIZED;
if(gl2psCheckOptions(options, gl2ps->colormode) == GL_FALSE) {
return GL2PS_ERROR;
}
gl2ps->options = options;
return GL2PS_SUCCESS;
}
GL2PSDLL_API GLint gl2psGetOptions(GLint *options)
{
if(!gl2ps) {
*options = 0;
return GL2PS_UNINITIALIZED;
}
*options = gl2ps->options;
return GL2PS_SUCCESS;
}
GL2PSDLL_API const char *gl2psGetFileExtension(GLint format)
{
if(format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0])))
return gl2psbackends[format]->file_extension;
else
return "Unknown format";
}
GL2PSDLL_API const char *gl2psGetFormatDescription(GLint format)
{
if(format >= 0 && format < (GLint)(sizeof(gl2psbackends) / sizeof(gl2psbackends[0])))
return gl2psbackends[format]->description;
else
return "Unknown format";
}
GL2PSDLL_API GLint gl2psGetFileFormat()
{
return gl2ps->format;
}
GL2PSDLL_API GLint gl2psForceRasterPos(GL2PSvertex *vert)
{
if(!gl2ps) {
return GL2PS_UNINITIALIZED;
}
gl2ps->forcerasterpos = GL_TRUE;
gl2ps->rasterpos.xyz[0] = vert->xyz[0];
gl2ps->rasterpos.xyz[1] = vert->xyz[1];
gl2ps->rasterpos.xyz[2] = vert->xyz[2];
gl2ps->rasterpos.rgba[0] = vert->rgba[0];
gl2ps->rasterpos.rgba[1] = vert->rgba[1];
gl2ps->rasterpos.rgba[2] = vert->rgba[2];
gl2ps->rasterpos.rgba[3] = vert->rgba[3];
return GL2PS_SUCCESS;
}
#endif
rgl/src/callbacks.cpp 0000644 0001762 0000144 00000017406 14137472630 014267 0 ustar ligges users #include "api.h"
#include "rglview.h"
#include "DeviceManager.h"
using namespace rgl;
namespace rgl {
extern DeviceManager* deviceManager;
}
/* These defines are not in the installed version of R */
#include "R.h"
#include
#include
static void userControl(void *userData, int mouseX, int mouseY)
{
SEXP fn = (SEXP)userData;
if (fn) {
// Rprintf("userControl called with mouseX=%d userData=%p\n", mouseX, userData);
eval(PROTECT(lang3(fn, PROTECT(ScalarInteger(mouseX)), PROTECT(ScalarInteger(mouseY)))), R_GlobalEnv);
UNPROTECT(3);
}
}
static void userControlEnd(void *userData)
{
SEXP fn = (SEXP)userData;
if (fn) {
eval(PROTECT(lang1(fn)), R_GlobalEnv);
UNPROTECT(1);
}
}
static void userCleanup(void **userData)
{
for (int i=0; i<3; i++) {
if (userData[i]) {
R_ReleaseObject((SEXP)userData[i]);
userData[i] = 0;
}
}
}
static void userWheel(void *wheelData, int dir)
{
SEXP fn = (SEXP)wheelData;
eval(PROTECT(lang2(fn, PROTECT(ScalarInteger(dir)))), R_GlobalEnv);
UNPROTECT(2);
}
SEXP rgl::rgl_setMouseCallbacks(SEXP button, SEXP begin, SEXP update, SEXP end,
SEXP dev, SEXP sub)
{
Device* device;
if (deviceManager && (device = deviceManager->getDevice(asInteger(dev)))) {
RGLView* rglview = device->getRGLView();
void* userData[3] = {0, 0, 0};
userControlPtr beginCallback, updateCallback;
userControlEndPtr endCallback;
userCleanupPtr cleanupCallback;
int b = asInteger(button);
if (b < 0 || b > 4) error("button must be 1=left, 2=right, 3=middle, 4=wheel, or 0 for no button");
Scene* scene = rglview->getScene();
Subscene* subscene = scene->getSubscene(asInteger(sub));
if (!subscene) error("subscene not found");
subscene->getMouseCallbacks(b, &beginCallback, &updateCallback, &endCallback,
&cleanupCallback, (void**)&userData);
if (isFunction(begin)) {
beginCallback = &userControl;
userData[0] = (void*)begin;
R_PreserveObject(begin);
} else if (begin == R_NilValue) beginCallback = 0;
else error("callback must be a function");
if (isFunction(update)) {
updateCallback = &userControl;
userData[1] = (void*)update;
R_PreserveObject(update);
} else if (update == R_NilValue) updateCallback = 0;
else error("callback must be a function");
if (isFunction(end)) {
endCallback = &userControlEnd;
userData[2] = (void*)end;
R_PreserveObject(end);
} else if (end == R_NilValue) endCallback = 0;
else error("callback must be a function");
rglview->captureLost();
// Rprintf("setting mouse callbacks\n");
subscene->setMouseCallbacks(b, beginCallback, updateCallback, endCallback,
&userCleanup, userData);
if (b == bnNOBUTTON)
rglview->windowImpl->watchMouse(subscene->getRootSubscene()->mouseNeedsWatching());
} else error("rgl device is not open");
return R_NilValue;
}
SEXP rgl::rgl_getMouseCallbacks(SEXP button, SEXP dev, SEXP sub)
{
Device* device;
if (deviceManager && (device = deviceManager->getDevice(asInteger(dev)))) {
RGLView* rglview = device->getRGLView();
void* userData[3] = {0, 0, 0};
userControlPtr beginCallback, updateCallback;
userControlEndPtr endCallback;
userCleanupPtr cleanupCallback;
int b = asInteger(button);
if (b < 0 || b > 4) error("button must be 1=left, 2=right, 3=middle, 4=wheel, or 0 for no button");
Scene* scene = rglview->getScene();
Subscene* subscene = scene->getSubscene(asInteger(sub));
if (!subscene) error("subscene not found");
subscene->getMouseCallbacks(b, &beginCallback, &updateCallback, &endCallback,
&cleanupCallback, (void**)&userData);
SEXP result;
PROTECT(result = allocVector(VECSXP, 3));
if (beginCallback == &userControl)
SET_VECTOR_ELT(result, 0, (SEXP)userData[0]);
if (updateCallback == &userControl)
SET_VECTOR_ELT(result, 1, (SEXP)userData[1]);
if (endCallback == &userControlEnd)
SET_VECTOR_ELT(result, 2, (SEXP)userData[2]);
UNPROTECT(1);
return result;
} else error("rgl device is not open");
return R_NilValue;
}
SEXP rgl::rgl_setWheelCallback(SEXP rotate, SEXP dev, SEXP sub)
{
Device* device;
if (deviceManager && (device = deviceManager->getDevice(asInteger(dev)))) {
RGLView* rglview = device->getRGLView();
void* wheelData = 0;
userWheelPtr wheelCallback;
if (isFunction(rotate)) {
wheelCallback = &userWheel;
wheelData = (void*)rotate;
R_PreserveObject(rotate);
} else if (rotate == R_NilValue) wheelCallback = 0;
else error("callback must be a function");
Scene* scene = rglview->getScene();
Subscene* subscene = scene->getSubscene(asInteger(sub));
if (!subscene) error("subscene not found");
subscene->setWheelCallback(wheelCallback, wheelData);
} else error("rgl device is not open");
return R_NilValue;
}
SEXP rgl::rgl_getWheelCallback(SEXP dev, SEXP sub)
{
Device* device;
SEXP result = R_NilValue;
if (deviceManager && (device = deviceManager->getDevice(asInteger(dev)))) {
RGLView* rglview = device->getRGLView();
void* wheelData = 0;
userWheelPtr wheelCallback;
Scene* scene = rglview->getScene();
Subscene* subscene = scene->getSubscene(asInteger(sub));
if (!subscene) error("subscene not found");
subscene->getWheelCallback(&wheelCallback, (void**)&wheelData);
if (wheelCallback == &userWheel)
result = (SEXP)wheelData;
} else error("rgl device is not open");
return result;
}
static void userAxis(void *axisData, int axis, int edge[3])
{
SEXP fn = (SEXP)axisData;
char margin[4] = " ";
int i, j = 1;
margin[0] = 'x' + axis;
for (i = 0; i < 3 && j < 3; i++) {
if (edge[i] == 1)
margin[j++] = '+';
else if (edge[i] == -1)
margin[j++] = '-';
}
margin[j] = 0;
// Rprintf("margin=%s\n", margin);
eval(PROTECT(lang2(fn, PROTECT(ScalarString(mkChar(margin))))), R_GlobalEnv);
UNPROTECT(2);
}
SEXP rgl::rgl_setAxisCallback(SEXP draw, SEXP dev, SEXP sub, SEXP axis)
{
Device* device;
if (deviceManager && (device = deviceManager->getDevice(asInteger(dev)))) {
RGLView* rglview = device->getRGLView();
void* axisData = 0;
userAxisPtr axisCallback;
if (isFunction(draw)) {
axisCallback = &userAxis;
axisData = (void*)draw;
R_PreserveObject(draw);
} else if (draw == R_NilValue) axisCallback = 0;
else error("callback must be a function");
Scene* scene = rglview->getScene();
Subscene* subscene = scene->getSubscene(asInteger(sub));
if (!subscene) error("subscene not found");
BBoxDeco* bboxdeco = subscene->get_bboxdeco();
if (!bboxdeco) error("no bbox decoration");
int a = asInteger(axis);
if (a < 0 || a > 2) error("axis must be 0=x, 1=y, or 2=z");
bboxdeco->setAxisCallback(axisCallback, axisData, a);
rglview->update();
} else error("rgl device is not open");
return R_NilValue;
}
SEXP rgl::rgl_getAxisCallback(SEXP dev, SEXP sub, SEXP axis)
{
Device* device;
SEXP result = R_NilValue;
if (deviceManager && (device = deviceManager->getDevice(asInteger(dev)))) {
RGLView* rglview = device->getRGLView();
void* axisData = 0;
userAxisPtr axisCallback;
Scene* scene = rglview->getScene();
Subscene* subscene = scene->getSubscene(asInteger(sub));
if (!subscene) error("subscene not found");
BBoxDeco* bboxdeco = subscene->get_bboxdeco();
if (!bboxdeco) error("bboxdeco not found");
bboxdeco->getAxisCallback(&axisCallback, (void**)&axisData, asInteger(axis));
if (axisCallback == &userAxis)
result = (SEXP)axisData;
} else error("rgl device is not open");
return result;
}
rgl/src/SpriteSet.h 0000644 0001762 0000144 00000003666 14142256754 013745 0 ustar ligges users #ifndef SPRITE_SET_H
#define SPRITE_SET_H
#include
#include "Shape.h"
#include "scene.h"
namespace rgl {
//
// SPRITESET
//
class SpriteSet : public Shape {
private:
ARRAY vertex;
ARRAY size;
ARRAY pos;
float offset;
public:
SpriteSet(Material& material, int nvertex, double* vertex, int nsize, double* size,
int ignoreExtent, int count = 0, Shape** shapelist = NULL, double* userMatrix = NULL,
bool fixedSize = false, Scene* scene = NULL, double* adj = NULL,
int npos = 0, int* pos = NULL, double offset = 0.0);
~SpriteSet();
/**
* overload
**/
virtual void render(RenderContext* renderContext);
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "sprites", buflen); };
virtual int getElementCount(void);
int getAttributeCount(AABox& bbox, AttribID attrib);
void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
String getTextAttribute(AABox& bbox, AttribID attrib, int index);
/**
* location of individual items
**/
virtual Vertex getPrimitiveCenter(int index);
/**
* begin sending items
**/
virtual void drawBegin(RenderContext* renderContext);
/**
* send one item
**/
virtual void drawPrimitive(RenderContext* renderContext, int index);
/**
* end sending items
**/
virtual void drawEnd(RenderContext* renderContext);
/**
* extract individual shape
*/
virtual Shape* get_shape(int id);
/**
* delete a shape
*/
void remove_shape(int id);
private:
GLdouble userMatrix[16]; /* Transformation for 3D sprites */
Matrix4x4 m; /* Modelview matrix cache */
Matrix4x4 p; /* Projection matrix cache */
#ifndef RGL_NO_OPENGL
bool doTex;
#endif
std::vector shapes;
bool fixedSize;
Scene* scene;
Vec3 adj;
void getAdj(int index);
};
} // namespace rgl
#endif // SPRITE_SET_H
rgl/src/assert.cpp 0000644 0001762 0000144 00000000351 14100762641 013632 0 ustar ligges users #include "R.h"
#include "assert.h"
void rgl_assert (const char* assertion, const char* file, int line)
{
error("Assertion failure: %s\nFile: %s\nLine: %d\nPlease report to rgl maintainer.",
assertion, file, line);
}
rgl/src/render.cpp 0000644 0001762 0000144 00000007041 14133075552 013617 0 ustar ligges users #include "render.h"
#include "opengl.h"
#include "R.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// SECTION: MATERIAL
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// VertexArray
//
VertexArray::VertexArray()
{
arrayptr = NULL;
}
VertexArray::~VertexArray()
{
if (arrayptr)
delete[] arrayptr;
}
void VertexArray::alloc(int in_nvertex)
{
if (arrayptr) {
delete[] arrayptr;
arrayptr = NULL;
}
nvertex = in_nvertex;
if (nvertex)
arrayptr = new float [nvertex*3];
}
void VertexArray::copy(int in_nvertex, double* vertices)
{
if (in_nvertex > nvertex) {
warning("Only %d values copied", nvertex);
in_nvertex = nvertex;
}
for(int i=0;i nvertex) {
warning("Only %d values copied", nvertex);
in_nvertex = nvertex;
}
for(int i=0;i
namespace rgl {
//
// ABSTRACT CLASS
// PrimitiveSet
//
class PrimitiveSet : public Shape {
public:
/**
* overloaded
**/
virtual void draw(RenderContext* renderContext);
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "primitive", buflen); }
/**
* overloaded
**/
virtual int getElementCount(void) { return nprimitives; }
int getAttributeCount(AABox& bbox, AttribID attrib);
void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
/**
* overloaded
**/
virtual Vertex getPrimitiveCenter(int item) { return getCenter(item); }
/**
* begin sending primitives
* interface
**/
virtual void drawBegin(RenderContext* renderContext);
/**
* send primitive
* interface
**/
virtual void drawPrimitive(RenderContext* renderContext, int index);
/**
* end sending primitives
* interface
**/
virtual void drawEnd(RenderContext* renderContext);
/**
* set a vertex
**/
const void setVertex(int index, double* v) { vertexArray.setVertex(index, v); }
/**
* setup all vertices
**/
void initPrimitiveSet(int in_nvertices, double* in_vertices,
int in_nindices = 0, int* in_indices = NULL);
protected:
/**
* abstract class constructor
**/
PrimitiveSet (
Material& in_material,
int in_nvertices,
double* vertex,
int in_type,
int in_nverticesperelement,
bool in_ignoreExtent,
int in_nindices,
int* in_indices,
bool in_bboxChange = false
);
PrimitiveSet(
Material& in_material,
int in_type,
int in_verticesperelement,
bool in_ignoreExtent,
bool in_bboxChange
);
~PrimitiveSet();
/**
* get primitive center point
**/
inline Vertex getCenter(int index)
{
Vertex accu;
int begin = index*nverticesperelement;
int end = begin+nverticesperelement;
for (int i = begin ; i < end ; ++i ) {
if (nindices)
accu += vertexArray[indices[i]];
else
accu += vertexArray[i];
}
return accu * ( 1.0f / ( (float) nverticesperelement ) );
}
// ---[ PRIMITIVE DRAW INTERFACE ]------------------------------------------
/**
* send all elements
* interface
**/
virtual void drawAll(RenderContext* renderContext);
void initPrimitiveSet (
int in_nvertices,
double* vertex,
int in_type,
int in_nverticesperelement,
bool in_ignoreExtent,
bool in_bboxChange
);
int type;
int nverticesperelement;
int nvertices;
int nprimitives;
VertexArray vertexArray, /* the vertices given by the user */
verticesTodraw; /* the margin vertices in data coords */
bool hasmissing; /* whether any vertices contain missing values */
int nindices;
unsigned int* indices;
};
//
// ABSTRACT CLASS
// FaceSet
//
class FaceSet : public PrimitiveSet
{
public:
/**
* overload
**/
virtual void drawBegin(RenderContext* renderContext);
/**
* overload
**/
virtual void drawEnd(RenderContext* renderContext);
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "faces", buflen); };
int getAttributeCount(AABox& bbox, AttribID attrib);
void getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result);
protected:
/**
* Constructor
**/
FaceSet(
Material& in_material,
int in_nvertex,
double* in_vertex,
double* in_normals,
double* in_texcoords,
int in_type,
int in_nverticesperelement,
bool in_ignoreExtent,
int in_nindices,
int* in_indices,
int in_useNormals,
int in_useTexcoords,
bool in_bboxChange = false
);
FaceSet(
Material& in_material,
int in_type,
int in_verticesperelement,
bool in_ignoreExtent,
bool in_bboxChange = false
);
/* (re-)set mesh */
void initFaceSet(int in_nvertex, double* in_vertex, double* in_normals, double* in_texcoords);
/* set up normals */
void initNormals(double* in_normals);
private:
NormalArray normalArray, normalsToDraw;
TexCoordArray texCoordArray;
};
//
// CLASS
// PointSet
//
class PointSet : public PrimitiveSet
{
public:
PointSet(Material& material, int nvertices, double* vertices, bool in_ignoreExtent, int nindices, int* indices,
bool bboxChange=false
);
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "points", buflen); };
};
//
// CLASS
// LineSet
//
class LineSet : public PrimitiveSet
{
public:
LineSet(Material& material, int nvertices, double* vertices, bool in_ignoreExtent,
int in_nindices, int* in_indices, bool in_bboxChange=false);
LineSet(Material& in_material, bool in_ignoreExtent, bool in_bboxChange);
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "lines", buflen); };
};
//
// CLASS
// TriangleSet
//
class TriangleSet : public FaceSet
{
public:
TriangleSet(Material& in_material, int in_nvertex, double* in_vertex, double* in_normals,
double* in_texcoords, bool in_ignoreExtent,
int in_nindices, int* in_indices, int in_useNormals, int in_useTexcoords, bool in_bboxChange = false)
: FaceSet(in_material,in_nvertex, in_vertex, in_normals, in_texcoords,
GL_TRIANGLES, 3, in_ignoreExtent, in_nindices, in_indices,
in_useNormals, in_useTexcoords, in_bboxChange)
{ }
TriangleSet(Material& in_material, bool in_ignoreExtent, bool in_bboxChange) :
FaceSet(in_material, GL_TRIANGLES, 3, in_ignoreExtent, in_bboxChange)
{ }
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "triangles", buflen); };
};
//
// CLASS
// QuadSet
//
class QuadSet : public FaceSet
{
public:
QuadSet(Material& in_material, int in_nvertex, double* in_vertex, double* in_normals,
double* in_texcoords, bool in_ignoreExtent, int in_nindices, int* in_indices,
int in_useNormals, int in_useTexcoords)
: FaceSet(in_material,in_nvertex,in_vertex, in_normals, in_texcoords,
GL_QUADS, 4, in_ignoreExtent, in_nindices, in_indices, in_useNormals, in_useTexcoords)
{ }
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "quads", buflen); };
};
//
// CLASS
// LineStripSet
//
class LineStripSet : public PrimitiveSet
{
public:
LineStripSet(Material& material, int in_nvertex, double* in_vertex, bool in_ignoreExtent,
int in_nindices, int* in_indices, bool in_bboxChange = false);
void drawPrimitive(RenderContext* renderContext, int index);
/**
* overloaded
**/
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "linestrip", buflen); };
};
} // namespace rgl
#endif // PRIMITIVE_SET_H
rgl/src/Viewpoint.h 0000644 0001762 0000144 00000004636 14100762641 013774 0 ustar ligges users #ifndef VIEWPOINT_H
#define VIEWPOINT_H
#include "SceneNode.h"
#include "render.h"
#include "geom.h"
namespace rgl {
class ModelViewpoint : public SceneNode
{
#define VIEWPOINT_MAX_ZOOM 10
public:
ModelViewpoint(PolarCoord position=PolarCoord(0.0f,15.0f), Vec3 in_scale=Vec3(1.0f, 1.0f, 1.0f), bool interactive=true);
ModelViewpoint(double* userMatrix, Vec3 in_scale=Vec3(1.0f, 1.0f, 1.0f), bool interactive=true);
PolarCoord& getPosition();
void setPosition(const PolarCoord& position);
void clearMouseMatrix();
void setupTransformation(RenderContext* rctx, Vertex center);
void setupOrientation(RenderContext* rctx) const;
bool isInteractive() const;
void updateMouseMatrix(Vertex dragStart,Vertex dragCurrent);
void updateMouseMatrix(PolarCoord newpos);
void mouseOneAxis(Vertex dragStart,Vertex dragCurrent,Vertex axis);
void mergeMouseMatrix();
void getUserMatrix(double* dest);
void setUserMatrix(double* src);
void getScale(double* dest);
void setScale(double* src);
void getPosition(double* dest);
void setPosition(double* src);
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "modelviewpoint", buflen); };
Vertex scale;
bool scaleChanged;
private:
PolarCoord position;
bool interactive;
public:
GLdouble userMatrix[16], mouseMatrix[16];
};
class UserViewpoint : public SceneNode
{
#define VIEWPOINT_MAX_ZOOM 10
public:
UserViewpoint(float fov=90.0f, float zoom=1.0f);
float getZoom(void) const;
void setZoom(const float zoom);
float getFOV(void) const;
void setFOV(const float in_fov);
void setupFrustum(RenderContext* rctx, const Sphere& viewvolumeSphere);
void setupProjMatrix(RenderContext* rctx, const Sphere& viewvolumeSphere);
Vertex getObserver();
void setObserver(bool automatic, Vertex in_eye);
void setupViewer(RenderContext* rctx);
virtual void getTypeName(char* buffer, int buflen) { strncpy(buffer, "userviewpoint", buflen); };
Frustum frustum;
void getUserProjection(double* dest);
void setUserProjection(double* src);
void clearUserProjection();
private:
float fov;
float zoom;
bool viewerInScene;
Vertex eye;
Matrix4x4 userProjection;
};
} // namespace rgl
#endif // VIEWPOINT_H
rgl/src/PlaneSet.cpp 0000644 0001762 0000144 00000014310 14100762641 014044 0 ustar ligges users #include
#include "PlaneSet.h"
#include "Viewpoint.h"
#include "R.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// PlaneSet
//
PlaneSet::PlaneSet(Material& in_material, int in_nnormal, double* in_normal, int in_noffset, double* in_offset)
:
TriangleSet(in_material,true, false/* true */),
nPlanes(max(in_nnormal, in_noffset)),
normal(in_nnormal, in_normal),
offset(in_noffset, in_offset)
{
/* We'll set up 4 triangles per plane, in case we need to render
a hexagon. Each triangle has 3 vertices (so 12 for the plane), and each vertex
gets 3 color components and 1 alpha component. */
ARRAY colors(36*nPlanes);
ARRAY alphas(12*nPlanes);
if (material.colors.getLength() > 1) {
material.colors.recycle(nPlanes);
for (int i=0; i vertices(36*nPlanes),
normals(36*nPlanes);
for (int i=0; igetBoundingBox());
return TriangleSet::getBoundingBox(subscene);
}
void PlaneSet::renderBegin(RenderContext* renderContext)
{
updateTriangles(renderContext->subscene->getBoundingBox());
invalidateDisplaylist();
TriangleSet::renderBegin(renderContext);
}
void PlaneSet::updateTriangles(const AABox& sceneBBox)
{
int perms[3][3] = { {0,0,1}, {1,2,2}, {2,1,0} };
double bbox[2][3] = { {sceneBBox.vmin.x, sceneBBox.vmin.y, sceneBBox.vmin.z},
{sceneBBox.vmax.x, sceneBBox.vmax.y, sceneBBox.vmax.z} };
double x[12][3];
for (int elem = 0; elem < nPlanes; elem++) {
Vertex Av = normal.getRecycled(elem);
double A[3] = { Av.x, Av.y, Av.z };
double d = offset.getRecycled(elem);
int nhits = 0;
int face1[12], face2[12]; /* to identify which faces of the cube we're on */
/* Find intersection of bbox edges with plane. Problem:
* there might be 3 edges all intersecting the plane
* at the same place, i.e. a vertex of the bbox. Need
* to fix this case.
*/
for (int i=0; i<3; i++)
for (int j=0; j<2; j++)
for (int k=0; k<2; k++) {
int u=perms[0][i], v=perms[1][i], w=perms[2][i];
if (A[w] != 0.0) {
double intersect = -(d + A[u]*bbox[j][u] + A[v]*bbox[k][v])/A[w];
if (bbox[0][w] <= intersect && intersect <= bbox[1][w]) {
x[nhits][u] = bbox[j][u];
x[nhits][v] = bbox[k][v];
x[nhits][w] = intersect;
/* Check for duplicate */
int dup = 0;
for (int l=0; l < nhits; l++) {
if (abs(x[l][0] - x[nhits][0]) <= 1.e-8*abs(x[l][0])
&& abs(x[l][1] - x[nhits][1]) <= 1.e-8*abs(x[l][1])
&& abs(x[l][2] - x[nhits][2]) <= 1.e-8*abs(x[l][2])) {
dup = 1;
break;
}
}
if (!dup) {
face1[nhits] = j + 2*u;
face2[nhits] = k + 2*v;
nhits++;
}
}
}
}
if (nhits > 3) {
/* Re-order the intersections so the triangles work */
for (int i=0; i i+1) {
for (int j=0; j<3; j++)
swap(x[i+1][j], x[which][j]);
swap(face1[i+1], face1[which]);
swap(face2[i+1], face2[which]);
}
}
}
if (nhits >= 3) {
/* Put in order so that the normal points out the FRONT of the faces */
Vec3 v0(static_cast(x[0][0] - x[1][0]),
static_cast(x[0][1] - x[1][1]),
static_cast(x[0][2] - x[1][2])),
v2(static_cast(x[2][0] - x[1][0]),
static_cast(x[2][1] - x[1][1]),
static_cast(x[2][2] - x[1][2])),
vx = v0.cross(v2);
bool reverse = vx*Av > 0;
for (int i=0; i
#include
#include "lib.h"
#include "DeviceManager.h"
#include "init.h"
#include "api.h"
/* libfreetype 2.6 defines a conflicting TYPEOF macro */
#ifdef TYPEOF
# undef TYPEOF
#endif
#include
#include
#include "R.h"
using namespace rgl;
//
// FUNCTION
// rgl_init
//
//
// GLOBAL: deviceManager pointer
//
namespace rgl{
DeviceManager* deviceManager = NULL;
int gInitValue;
void* gHandle;
SEXP rglNamespace;
bool rglDebug;
//
// FUNCTION
// rgl_init
//
// PARAMETERS
// ioptions - platform-specific options.
// Windows:
// [0] multiple-document-interface console handle (MDI)
// or 0 (SDI)
// MacOSX:
// [0] Formerly indicator of presence (1) or absence (0) of Carbon/Cocoa, now unused
//
#ifdef __cplusplus
extern "C" {
#endif
SEXP rgl_init(SEXP initValue, SEXP useNULL, SEXP in_namespace,
SEXP debug)
{
int success = 0;
bool useNULLDevice = asLogical(useNULL);
gInitValue = 0;
gHandle = NULL;
rglNamespace = in_namespace;
rglDebug = asLogical(debug);
if ( isNumeric(initValue) ) {
gInitValue = asInteger(initValue);
}
else if ( TYPEOF(initValue) == EXTPTRSXP ) {
gHandle = R_ExternalPtrAddr(initValue);
}
else if ( !isNull(initValue) )
{
return ScalarInteger( 0 );
}
/* Some systems write useless messages to stderr. We'll
* hide those
*/
int stderr_copy = STDERR_FILENO; /* suppress "maybe undefined" warning */
if (!rglDebug) {
int devNull =
#ifdef windows
open("nul", O_WRONLY);
#else
open("/dev/null", O_WRONLY);
#endif
R_FlushConsole();
stderr_copy = dup(STDERR_FILENO);
dup2(devNull, STDERR_FILENO);
}
if ( init(useNULLDevice) ) {
deviceManager = new DeviceManager(useNULLDevice);
}
if ( deviceManager && (useNULLDevice || deviceManager->createTestWindow()))
success = 1;
/* Restore STDERR */
if (!rglDebug) {
dup2(stderr_copy, STDERR_FILENO);
close(stderr_copy);
}
return(ScalarInteger(success));
}
#define FUNDEF(name, n) {#name, (DL_FUNC) &name, n}
#undef CHECK_ARGS
#ifdef CHECK_ARGS
R_NativePrimitiveArgType aI[1] = {INTSXP};
R_NativePrimitiveArgType aL[1] = {LGLSXP};
R_NativePrimitiveArgType aII[2] = {INTSXP, INTSXP};
R_NativePrimitiveArgType aLI[2] = {LGLSXP, INTSXP};
R_NativePrimitiveArgType aLL[2] = {LGLSXP, LGLSXP};
R_NativePrimitiveArgType aIII[3] = {INTSXP, INTSXP, INTSXP};
R_NativePrimitiveArgType aIIS[3] = {INTSXP, INTSXP, STRSXP};
R_NativePrimitiveArgType aIID[3] = {INTSXP, INTSXP, REALSXP};
R_NativePrimitiveArgType aLII[3] = {LGLSXP, INTSXP, INTSXP};
R_NativePrimitiveArgType aLIS[3] = {LGLSXP, INTSXP, STRSXP};
R_NativePrimitiveArgType aLID[3] = {LGLSXP, INTSXP, REALSXP};
R_NativePrimitiveArgType aIIDD[4] = {INTSXP, INTSXP, REALSXP, REALSXP};
R_NativePrimitiveArgType aLISD[4] = {LGLSXP, INTSXP, STRSXP, REALSXP};
R_NativePrimitiveArgType aIISI[4] = {INTSXP, INTSXP, STRSXP, INTSXP};
R_NativePrimitiveArgType aLIDD[4] = {LGLSXP, INTSXP, REALSXP, REALSXP};
R_NativePrimitiveArgType aIIIID[5] = {INTSXP, INTSXP, INTSXP, INTSXP, REALSXP};
R_NativePrimitiveArgType aIIIIS[5] = {INTSXP, INTSXP, INTSXP, INTSXP, STRSXP};
R_NativePrimitiveArgType aLIIIS[5] = {LGLSXP, INTSXP, INTSXP, INTSXP, STRSXP};
R_NativePrimitiveArgType aLIIID[5] = {LGLSXP, INTSXP, INTSXP, INTSXP, REALSXP};
R_NativePrimitiveArgType aLIISD[5] = {LGLSXP, INTSXP, INTSXP, STRSXP, REALSXP};
R_NativePrimitiveArgType aLIIDS[5] = {LGLSXP, INTSXP, INTSXP, REALSXP, STRSXP};
R_NativePrimitiveArgType aLIIIF[5] = {LGLSXP, INTSXP, INTSXP, INTSXP, SINGLESXP};
R_NativePrimitiveArgType aLIDDD[5] = {LGLSXP, INTSXP, REALSXP, REALSXP, REALSXP};
R_NativePrimitiveArgType aIIDDD[5] = {INTSXP, INTSXP, REALSXP, REALSXP, REALSXP};
R_NativePrimitiveArgType aIIDDID[6] = {INTSXP, INTSXP, REALSXP, REALSXP, INTSXP, REALSXP};
R_NativePrimitiveArgType aLIDDDDI[7] = {LGLSXP, INTSXP, REALSXP, REALSXP, REALSXP, REALSXP, INTSXP};
R_NativePrimitiveArgType aLIDDSDSDS[9] = {LGLSXP, INTSXP, REALSXP, REALSXP, STRSXP, REALSXP,
STRSXP, REALSXP, STRSXP};
R_NativePrimitiveArgType aIIDSDISIDI[10] = {INTSXP, INTSXP, REALSXP, STRSXP, REALSXP, INTSXP,
STRSXP, INTSXP, REALSXP, INTSXP};
R_NativePrimitiveArgType aIIDDDDDDDDIII[13] = {INTSXP, INTSXP, REALSXP, REALSXP, REALSXP, REALSXP,
REALSXP, REALSXP, REALSXP, REALSXP, INTSXP, INTSXP, INTSXP};
static const R_CMethodDef CEntries[] = {
{"rgl_dev_open", (DL_FUNC) &rgl_dev_open, 2, aLL},
{"rgl_dev_close", (DL_FUNC) &rgl_dev_close, 1, aL},
{"rgl_dev_setcurrent", (DL_FUNC) &rgl_dev_setcurrent, 2, aLI},
{"rgl_snapshot", (DL_FUNC) &rgl_snapshot, 3, aLIS},
{"rgl_postscript", (DL_FUNC) &rgl_postscript, 3, aLIS},
{"rgl_material", (DL_FUNC) &rgl_material, 4, aLISD},
{"rgl_getmaterial", (DL_FUNC) &rgl_getmaterial, 5, aLIISD},
{"rgl_getcolorcount", (DL_FUNC) &rgl_getcolorcount, 1, aI},
{"rgl_dev_bringtotop", (DL_FUNC) &rgl_dev_bringtotop, 2, aLL},
{"rgl_clear", (DL_FUNC) &rgl_clear, 2, aLI},
{"rgl_pop", (DL_FUNC) &rgl_pop, 2, aLI},
{"rgl_id_count", (DL_FUNC) &rgl_id_count, 3, aIII},
{"rgl_ids", (DL_FUNC) &rgl_ids, 4, aIISI},
{"rgl_viewpoint", (DL_FUNC) &rgl_viewpoint, 3, aLID},
{"rgl_getObserver", (DL_FUNC) &rgl_getObserver, 2, aID},
{"rgl_setObserver", (DL_FUNC) &rgl_setObserver, 2, aID},
{"rgl_attrib_count", (DL_FUNC) &rgl_attrib_count, 3, aIII},
{"rgl_attrib", (DL_FUNC) &rgl_attrib, 5, aIIIID},
{"rgl_text_attrib", (DL_FUNC) &rgl_text_attrib, 5, aIIIIS},
{"rgl_bg", (DL_FUNC) &rgl_bg, 3, aLID},
{"rgl_bbox", (DL_FUNC) &rgl_bbox, 9, aLIDDSDSDS},
{"rgl_light", (DL_FUNC) &rgl_light, 3, aIID},
{"rgl_pixels", (DL_FUNC) &rgl_pixels, 5, aLIIIF},
{"rgl_planes", (DL_FUNC) &rgl_planes, 4, aIIDD},
{"rgl_clipplanes", (DL_FUNC) &rgl_planes, 4, aIIDD},
{"rgl_abclines", (DL_FUNC) &rgl_abclines, 4, aIIDD},
{"rgl_primitive", (DL_FUNC) &rgl_primitive, 5, aIIDDD},
{"rgl_surface", (DL_FUNC) &rgl_surface, 13, aIIDDDDDDDDIII},
{"rgl_spheres", (DL_FUNC) &rgl_spheres, 5, aIIDDI},
{"rgl_texts", (DL_FUNC) &rgl_texts, 12, aIIDSDISIDIII},
{"rgl_sprites", (DL_FUNC) &rgl_sprites, 9, aIIDDIDDID},
{"rgl_newsubscene", (DL_FUNC) &rgl_newsubscene, 4, aIIII},
{"rgl_setsubscene", (DL_FUNC) &rgl_setsubscene, 1, aI},
{"rgl_getsubsceneid", (DL_FUNC) &rgl_getsubsceneid, 2, aII},
{"rgl_getsubsceneparent", (DL_FUNC) &rgl_getsubsceneparent, 1, aI},
{"rgl_getsubscenechildcount",(DL_FUNC) &rgl_getsubscenechildcount, 2, aII},
{"rgl_getsubscenechildren", (DL_FUNC) &rgl_getsubscenechildren, 2, aII},
{"rgl_gc", (DL_FUNC) &rgl_gc, 2, aII},
{"rgl_setEmbeddings", (DL_FUNC) &rgl_setEmbeddings, 2, aII},
{"rgl_getEmbeddings", (DL_FUNC) &rgl_getEmbeddings, 2, aII},
{"rgl_addtosubscene", (DL_FUNC) &rgl_addtosubscene, 3, aIII},
{"rgl_delfromsubscene", (DL_FUNC) &rgl_delfromsubscene, 3, aIII},
{"rgl_selectstate", (DL_FUNC) &rgl_selectstate, 5, aIILID},
{"rgl_setselectstate", (DL_FUNC) &rgl_setselectstate, 4, aIILI},
{"rgl_quit", (DL_FUNC) &rgl_quit, 1, aL},
{NULL, NULL, 0}
};
#else // don't CHECK_ARGS
static const R_CMethodDef CEntries[] = {
FUNDEF(rgl_dev_open, 2),
FUNDEF(rgl_dev_close, 1),
FUNDEF(rgl_dev_setcurrent, 2),
FUNDEF(rgl_snapshot, 3),
FUNDEF(rgl_postscript, 3),
FUNDEF(rgl_material, 4),
FUNDEF(rgl_getmaterial, 5),
FUNDEF(rgl_getcolorcount, 1),
FUNDEF(rgl_dev_bringtotop, 2),
FUNDEF(rgl_clear, 2),
FUNDEF(rgl_pop, 2),
FUNDEF(rgl_id_count, 3),
FUNDEF(rgl_ids, 4),
FUNDEF(rgl_viewpoint, 3),
FUNDEF(rgl_getObserver, 2),
FUNDEF(rgl_setObserver, 2),
FUNDEF(rgl_attrib_count, 3),
FUNDEF(rgl_attrib, 5),
FUNDEF(rgl_text_attrib, 5),
FUNDEF(rgl_bg, 3),
FUNDEF(rgl_bbox, 9),
FUNDEF(rgl_light, 3),
FUNDEF(rgl_pixels, 5),
FUNDEF(rgl_planes, 4),
FUNDEF(rgl_clipplanes, 4),
FUNDEF(rgl_abclines, 4),
FUNDEF(rgl_primitive, 5),
FUNDEF(rgl_surface, 13),
FUNDEF(rgl_spheres, 5),
FUNDEF(rgl_texts, 12),
FUNDEF(rgl_sprites, 9),
FUNDEF(rgl_newsubscene, 4),
FUNDEF(rgl_setsubscene, 1),
FUNDEF(rgl_getsubsceneid, 2),
FUNDEF(rgl_getsubsceneparent, 1),
FUNDEF(rgl_getsubscenechildcount, 2),
FUNDEF(rgl_getsubscenechildren, 2),
FUNDEF(rgl_gc, 2),
FUNDEF(rgl_setEmbeddings, 2),
FUNDEF(rgl_getEmbeddings, 2),
FUNDEF(rgl_addtosubscene, 3),
FUNDEF(rgl_delfromsubscene, 3),
FUNDEF(rgl_selectstate, 5),
FUNDEF(rgl_setselectstate, 4),
FUNDEF(rgl_quit, 1),
{NULL, NULL, 0}
};
#endif // CHECK_ARGS
static const R_CallMethodDef CallEntries[] = {
FUNDEF(rgl_init, 4),
FUNDEF(rgl_dev_getcurrent, 0),
FUNDEF(rgl_dev_list, 0),
FUNDEF(rgl_par3d, 3),
FUNDEF(rgl_setMouseCallbacks, 6),
FUNDEF(rgl_setWheelCallback, 3),
FUNDEF(rgl_setAxisCallback, 4),
FUNDEF(rgl_getMouseCallbacks, 3),
FUNDEF(rgl_getWheelCallback, 2),
FUNDEF(rgl_getAxisCallback, 3),
{NULL, NULL, 0}
};
static const R_ExternalMethodDef ExtEntries[] = {
{NULL, NULL, 0}
};
void attribute_visible R_init_rgl(DllInfo *dll)
{
R_registerRoutines(dll, CEntries, CallEntries, NULL, ExtEntries);
R_useDynamicSymbols(dll, FALSE);
R_forceSymbols(dll, TRUE);
}
#ifdef __cplusplus
}
#endif
// ---------------------------------------------------------------------------
} // namespace rgl
// ---------------------------------------------------------------------------
rgl/src/PointSet.cpp 0000644 0001762 0000144 00000001024 14145464133 014100 0 ustar ligges users #include "PrimitiveSet.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// PointSet
//
PointSet::PointSet(Material& in_material, int in_nvertices, double* in_vertices, bool in_ignoreExtent,
int in_nindices, int* in_indices, bool in_bboxChange)
: PrimitiveSet(in_material, in_nvertices, in_vertices, GL_POINTS, 1, in_ignoreExtent,
in_nindices, in_indices)
{
material.lit = false;
if (material.point_antialias) blended = true;
}
rgl/src/types.h 0000644 0001762 0000144 00000005627 14100762641 013155 0 ustar ligges users #ifndef RGL_TYPES_H
#define RGL_TYPES_H
#include
#include "pragma.h"
// C++ header file
// This file is part of RGL
//
namespace rgl {
//
//
// constants
//
//
#ifndef NULL
#define NULL 0UL
#endif
//
//
// fundamental data types
//
//
typedef unsigned char u8;
typedef long u32;
//
// memory management objects
//
class AutoDestroy
{
public:
AutoDestroy() { refcount = 0; }
virtual ~AutoDestroy() { }
void ref() { refcount++; }
void unref() { if ( !(--refcount) ) delete this; }
private:
int refcount;
};
template
class Ref
{
public:
Ref() : ptr(NULL) { }
Ref(T* in_ptr) : ptr(in_ptr) { if (ptr) ptr->ref(); }
Ref(const Ref& ref) : ptr(ref.ptr) { if (ptr) ptr->ref(); }
~Ref() { if (ptr) ptr->unref(); }
Ref& operator = (T* in_ptr) { if (ptr) ptr->unref(); ptr = in_ptr; if (ptr) ptr->ref(); return *this; }
T* operator -> () { return ptr; }
operator bool () { return (ptr) ? true : false; }
private:
T* ptr;
};
//
// CLASS
// DestroyHandler
//
class DestroyHandler
{
public:
virtual ~DestroyHandler();
virtual void notifyDestroy(void* userdata) = 0;
};
//
// mem copy
//
template
inline void copy(A* from, B* to, int size)
{
memcpy( (void*) to, (const void*) from, size*sizeof(A) );
}
//
// TEMPLATE
// ARRAY
//
template
struct ARRAY
{
int _size;
T* ptr;
inline int size()
{ return _size; }
inline ARRAY(int in_size) : _size(in_size), ptr(new T [_size])
{ }
template
inline ARRAY(int in_size, SRC* src) : _size(in_size), ptr(new T [_size])
{ copy(src, ptr,_size); }
inline ~ARRAY()
{ delete [] ptr; }
inline T& get(int index)
{ return ptr[index]; }
inline T& getRecycled(int index)
{ return ptr[index%_size]; };
};
//
// cast-copy doubles to floats
//
template<>
inline void copy(double* from, float* to, int size)
{
while(size--) {
*to = (float) *from;
from++; to++;
}
}
/**
* get most significant bit
* @param x unsigned value
* @return bit position between 1..32 or 0 if value was 0
**/
inline int msb(unsigned int x) {
if (x) {
int bit = sizeof(int)*8;
unsigned int mask = 1<<((sizeof(int)*8)-1);
while ( !(x & mask) ) {
--bit; mask >>= 1;
}
return bit;
} else
return 0;
}
// template T getMax(T a, T b) { return (a > b) ? a : b; }
// template T getMin(T a, T b) { return (a < b) ? a : b; }
inline int getMin(int a, int b) { return (a <= b) ? a : b; }
inline float getMin(float a, float b) { return (a <= b) ? a : b; }
inline int getMax(int a, int b) { return (a >= b) ? a : b; }
inline float getMax(float a, float b) { return (a >= b) ? a : b; }
inline float clamp(float v, float floor, float ceil) { return (vceil) ? ceil : v ); }
inline int clamp(int v, int floor, int ceil) { return (vceil) ? ceil : v ); }
} // namespace rgl
#endif /* RGL_TYPES_H */
rgl/src/select.h 0000644 0001762 0000144 00000000443 14100762641 013257 0 ustar ligges users #ifndef PLX_SELECT_H
#define PLX_SELECT_H
// C++ header file
// This file is part of RGL
#include "scene.h"
namespace rgl {
//
// Mouse selection rectangle
//
class SELECT
{
public:
inline SELECT() { };
void render(double* position);
};
} // namespace rgl
#endif // PLX_SELECT_H
rgl/src/PrimitiveSet.cpp 0000644 0001762 0000144 00000026015 14145464133 014766 0 ustar ligges users #include "PrimitiveSet.h"
#include "BBoxDeco.h"
#include "subscene.h"
#include "R.h"
using namespace rgl;
// ===[ PRIMITIVE SET ]=======================================================
PrimitiveSet::PrimitiveSet (
Material& in_material,
int in_type,
int in_nverticesperelement,
bool in_ignoreExtent,
bool in_bboxChange
) :
Shape(in_material, in_ignoreExtent, SHAPE, in_bboxChange)
{
type = in_type;
nverticesperelement = in_nverticesperelement;
nvertices = 0;
nindices = 0;
}
void PrimitiveSet::initPrimitiveSet(
int in_nvertices,
double* in_vertices,
int in_nindices,
int* in_indices
) {
nvertices = in_nvertices;
nindices = in_nindices;
if (nindices)
nprimitives = nindices / nverticesperelement;
else
nprimitives = nvertices / nverticesperelement;
vertexArray.alloc(nvertices);
hasmissing = false;
for(int i=0;i= 0) {
Subscene* subscene = renderContext->subscene;
bboxdeco = subscene->get_bboxdeco();
}
if (bboxdeco) {
invalidateDisplaylist();
verticesTodraw.alloc(vertexArray.size());
for (int i=0; i < vertexArray.size(); i++)
verticesTodraw.setVertex(i, bboxdeco->marginVecToDataVec(vertexArray[i], renderContext, &material) );
verticesTodraw.beginUse();
} else
vertexArray.beginUse();
SAVEGLERROR;
}
// ---------------------------------------------------------------------------
void PrimitiveSet::drawAll(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
if (!hasmissing) {
if (!nindices)
glDrawArrays(type, 0, nverticesperelement*nprimitives );
else
glDrawElements(type, nindices, GL_UNSIGNED_INT, indices);
} else {
bool missing = true;
for (int i=0; i= 0) {
Subscene* subscene = renderContext->subscene;
bboxdeco = subscene->get_bboxdeco();
}
if (bboxdeco) {
normalsToDraw.alloc(normalArray.size());
for (int i=0; i < normalArray.size(); i++)
normalsToDraw.setVertex(i, bboxdeco->marginNormalToDataNormal(normalArray[i], renderContext, &material) );
normalsToDraw.beginUse();
} else
normalArray.beginUse();
}
texCoordArray.beginUse();
}
// ---------------------------------------------------------------------------
void FaceSet::drawEnd(RenderContext* renderContext)
{
texCoordArray.endUse();
if (material.lit)
normalArray.endUse();
PrimitiveSet::drawEnd(renderContext);
}
int FaceSet::getAttributeCount(AABox& bbox, AttribID attrib)
{
switch (attrib) {
case NORMALS: return nvertices;
case TEXCOORDS: return texCoordArray.size();
}
return PrimitiveSet::getAttributeCount(bbox, attrib);
}
void FaceSet::getAttribute(AABox& bbox, AttribID attrib, int first, int count, double* result)
{
int n = getAttributeCount(bbox, attrib);
if (first + count < n) n = first + count;
if (first < n) {
switch (attrib) {
case NORMALS: {
if (normalArray.size() < n)
initNormals(NULL);
while (first < n) {
*result++ = normalArray[first].x;
*result++ = normalArray[first].y;
*result++ = normalArray[first].z;
first++;
}
return;
}
case TEXCOORDS: {
while (first < n) {
*result++ = texCoordArray[first].s;
*result++ = texCoordArray[first].t;
first++;
}
return;
}
}
PrimitiveSet::getAttribute(bbox, attrib, first, count, result);
}
}
rgl/src/Texture.h 0000644 0001762 0000144 00000002254 14145464133 013446 0 ustar ligges users #ifndef TEXTURE_H
#define TEXTURE_H
#include "pixmap.h"
#include "types.h"
namespace rgl {
//
// CLASS
// Texture
//
class RenderContext;
class Pixmap;
#include "opengl.h"
class Texture : public AutoDestroy
{
public:
enum Type { ALPHA = 1 , LUMINANCE, LUMINANCE_ALPHA, RGB, RGBA };
Texture(const char* in_filename
, Type type
, bool mipmap
, unsigned int minfilter
, unsigned int magfilter
, bool envmap);
virtual ~Texture();
bool isValid() const;
void beginUse(RenderContext* renderContext);
void endUse(RenderContext* renderContext);
bool is_envmap() const { return envmap; }
bool hasAlpha() const { return (type == ALPHA || type == LUMINANCE_ALPHA || type == RGBA ); }
void getParameters(Type *out_type, bool *out_mipmap, unsigned int *out_minfilter,
unsigned int *out_magfilter, bool *out_envmap, int bufsize, char *out_filename) ;
Pixmap* getPixmap() const { return pixmap; }
private:
void init(RenderContext* renderContext);
Pixmap* pixmap;
GLuint texName;
Type type;
bool mipmap;
GLenum minfilter;
GLenum magfilter;
bool envmap;
char* filename;
};
} // namespace rgl
#endif // TEXTURE_H
rgl/src/Surface.cpp 0000644 0001762 0000144 00000020160 14100762641 013721 0 ustar ligges users #include "Surface.h"
#include "Material.h"
using namespace rgl;
//////////////////////////////////////////////////////////////////////////////
//
// CLASS
// Surface
//
// in_coords permutes the coordinates to allow surfaces over arbitrary planes
// orientation is 1 to swap front and back
Surface::Surface(Material& in_material, int in_nx, int in_nz, double* in_x, double* in_z, double* in_y,
double* in_normal_x, double* in_normal_z, double* in_normal_y,
double* in_texture_s, double* in_texture_t,
int* in_coords, int in_orientation, int* in_flags, int in_ignoreExtent)
: Shape(in_material, in_ignoreExtent)
{
nx = in_nx;
nz = in_nz;
coords[0] = *(in_coords++);
coords[1] = *(in_coords++);
coords[2] = *(in_coords++);
orientation = in_orientation;
int nvertex = nx*nz;
material.colorPerVertex(true, nvertex);
vertexArray.alloc(nvertex);
if (material.texture)
texCoordArray.alloc(nvertex);
Vertex v;
float *x,*y,*z, *va[3];
va[0] = &(v.x);
va[1] = &(v.y);
va[2] = &(v.z);
x = va[coords[0]-1];
y = va[coords[1]-1];
z = va[coords[2]-1];
int xmat = in_flags[0];
int zmat = in_flags[1];
user_normals = in_flags[2];
user_textures = in_flags[3];
if (user_normals)
normalArray.alloc(nvertex);
int iy = 0;
for(int iz=0;izis_envmap() ) ) {
if (!user_textures) {
texCoordArray[iy].s = ((float)ix)/((float)(nx-1));
texCoordArray[iy].t = 1.0f - ((float)iz)/((float)(nz-1));
} else {
texCoordArray[iy].s = static_cast(in_texture_s[iy]);
texCoordArray[iy].t = static_cast(in_texture_t[iy]);
}
}
}
}
use_normal = user_normals || material.lit || ( material.texture && material.texture->is_envmap() );
if ( use_normal && !user_normals ) {
normalArray.alloc(nvertex);
iy = 0;
for(int iz=0;izis_envmap() ) );
if ((material.point_antialias && ( material.front == material.POINT_FACE
|| material.back == material.POINT_FACE))
|| (material.line_antialias && ( material.front == material.LINE_FACE
|| material.back == material.LINE_FACE))) blended = true;
}
Vertex Surface::getNormal(int ix, int iz)
{
int i = iz*nx + ix;
Vertex total(0.0f,0.0f,0.0f);
if (!vertexArray[i].missing()) {
// List the 8 surrounding vertices. Repat the 1st one to make looping simpler.
int ind[9];
int xv[9] = { 1, 1, 0, -1, -1, -1, 0, 1, 1 };
int zv[9] = { 0, -1, -1, -1, 0, 1, 1, 1, 0 };
int okay[9]; /* checks of surrounding vertices from right counterclockwise */
for (int j=0; j<8; j++) {
int xval = ix + xv[j], zval = iz + zv[j];
if (0 <= xval && xval < nx && 0 <= zval && zval < nz) {
ind[j] = i + xv[j] + zv[j]*nx;
okay[j] = !vertexArray[ind[j]].missing();
} else {
okay[j] = 0;
ind[j] = 0;
}
}
okay[8] = okay[0];
ind[8] = ind[0];
/* Estimate normal by averaging cross-product in successive triangular sectors */
for (int j=0; j<8; j++) {
if (okay[j] && okay[j+1] )
total += vertexArray.getNormal(i, ind[j], ind[j+1] );
}
total.normalize();
}
if (orientation) {
total.x = -total.x;
total.y = -total.y;
total.z = -total.z;
}
return total;
}
void Surface::draw(RenderContext* renderContext)
{
#ifndef RGL_NO_OPENGL
bool missing;
drawBegin(renderContext);
for(int iz=0;iz
#include "types.h"
#include "subscene.h"
namespace rgl {
class Scene {
public:
Scene();
~Scene();
// ---[ client services ]---------------------------------------------------
/**
* remove all nodes of the given type. This is always recursive through subscenes.
**/
bool clear(TypeID type);
/**
* add node to current subscene
**/
bool add(SceneNode* node);
/**
* remove specified node of given type, or last-added if id==0
**/
bool pop(TypeID stackTypeID, int id);
/**
* hide specified node in all subscenes
**/
void hide(int id);
/**
* get information about stacks
*/
int get_id_count(TypeID type);
void get_ids(TypeID type, int* ids, char** types);
/**
* get a SceneNode by id
*/
SceneNode* get_scenenode(int id);
SceneNode* get_scenenode(TypeID type, int id);
/**
* get information about particular shapes
**/
Shape* get_shape(int id);
/**
* get information about particular lights
**/
Light* get_light(int id);
/**
* get a background
*/
Background* get_background(int id);
/**
* get the bbox
*/
BBoxDeco* get_bboxdeco(int id);
/**
* get subscene
*/
Subscene* getSubscene(int id); /* get subscene by its id */
Subscene* whichSubscene(int id); /* get subscene holding this id */
Subscene* whichSubscene(int mouseX, int mouseY); /* get subscene by mouse coords */
/* coordinates are window-relative */
/**
* set/get the current subscene
**/
Subscene* setCurrentSubscene(Subscene* subscene); /* return previous one */
Subscene* getCurrentSubscene() const { return currentSubscene; }
const Subscene* getRootSubscene() const { return &rootSubscene; }
// ---[ grouping component ]-----------------------------------------------
/**
* obtain subscene's axis-aligned bounding box.
**/
const AABox& getBoundingBox() const { return currentSubscene->getBoundingBox(); }
// ---[ Renderable interface ]---------------------------------------------
/**
* update matrices etc.
*/
void update(RenderContext* renderContext);
/**
* do OpenGL plotting
*/
void render(RenderContext* renderContext);
// ---[ bindable component ]-----------------------------------------------
/**
* obtain bounded viewpoint
**/
UserViewpoint* getUserViewpoint();
ModelViewpoint* getModelViewpoint();
/**
* Get and set flag to ignore elements in bounding box
**/
int getIgnoreExtent(void) const { return doIgnoreExtent; }
void setIgnoreExtent(int in_ignoreExtent) { doIgnoreExtent = in_ignoreExtent; }
/**
* invalidate display lists so objects will be rendered again
**/
void invalidateDisplaylists();
Subscene rootSubscene;
private:
// Whether objects created in this scene should affect the bounding box or not
bool doIgnoreExtent;
void setupLightModel();
// --- [ Subscenes ]-------------------------------------------------------
Subscene* currentSubscene;
// ---[ nodes ]-----------------------------------------------------------
/**
* list of scene nodes. The scene owns them, the subscenes display a subset.
**/
std::vector nodes;
void deleteAll(std::vector list);
void removeReferences(SceneNode* node);
};
} // namespace rgl
#endif /* SCENE_H */
rgl/src/ext/ 0000755 0001762 0000144 00000000000 14100762641 012426 5 ustar ligges users rgl/src/ext/ftgl/ 0000755 0001762 0000144 00000000000 14100762641 013362 5 ustar ligges users rgl/src/ext/ftgl/config.h 0000644 0001762 0000144 00000000506 14100762641 015001 0 ustar ligges users /* In rgl, we don't run the FTGL configure script, and we don't have
RTTI. It appears as though the configure script is not needed for the
subset we use (except we need config.h, hence this file), and we can
use static_casts in place of dynamic_casts, hence the define below.
*/
#define dynamic_cast static_cast
rgl/src/ext/ftgl/FTGlyphContainer.h 0000644 0001762 0000144 00000011515 14100762641 016716 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __FTGlyphContainer__
#define __FTGlyphContainer__
#include
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include "FTGL/ftgl.h"
#include "FTVector.h"
class FTFace;
class FTGlyph;
class FTCharmap;
/**
* FTGlyphContainer holds the post processed FTGlyph objects.
*
* @see FTGlyph
*/
class FTGlyphContainer
{
typedef FTVector GlyphVector;
public:
/**
* Constructor
*
* @param face The Freetype face
*/
FTGlyphContainer(FTFace* face);
/**
* Destructor
*/
~FTGlyphContainer();
/**
* Sets the character map for the face.
*
* @param encoding the Freetype encoding symbol. See above.
* @return true if charmap was valid
* and set correctly
*/
bool CharMap(FT_Encoding encoding);
/**
* Get the font index of the input character.
*
* @param characterCode The character code of the requested glyph in the
* current encoding eg apple roman.
* @return The font index for the character.
*/
unsigned int FontIndex(const unsigned int characterCode) const;
/**
* Adds a glyph to this glyph list.
*
* @param glyph The FTGlyph to be inserted into the container
* @param characterCode The char code of the glyph NOT the glyph index.
*/
void Add(FTGlyph* glyph, const unsigned int characterCode);
/**
* Get a glyph from the glyph list
*
* @param characterCode The char code of the glyph NOT the glyph index
* @return An FTGlyph or null is it hasn't been
* loaded.
*/
const FTGlyph* const Glyph(const unsigned int characterCode) const;
/**
* Get the bounding box for a character.
* @param characterCode The char code of the glyph NOT the glyph index
*/
FTBBox BBox(const unsigned int characterCode) const;
/**
* Returns the kerned advance width for a glyph.
*
* @param characterCode glyph index of the character
* @param nextCharacterCode the next glyph in a string
* @return advance width
*/
float Advance(const unsigned int characterCode,
const unsigned int nextCharacterCode);
/**
* Renders a character
* @param characterCode the glyph to be Rendered
* @param nextCharacterCode the next glyph in the string. Used for kerning.
* @param penPosition the position to Render the glyph
* @param renderMode Render mode to display
* @return The distance to advance the pen position after Rendering
*/
FTPoint Render(const unsigned int characterCode,
const unsigned int nextCharacterCode,
FTPoint penPosition, int renderMode);
/**
* Queries the Font for errors.
*
* @return The current error code.
*/
FT_Error Error() const { return err; }
private:
/**
* The FTGL face
*/
FTFace* face;
/**
* The Character Map object associated with the current face
*/
FTCharmap* charMap;
/**
* A structure to hold the glyphs
*/
GlyphVector glyphs;
/**
* Current error code. Zero means no error.
*/
FT_Error err;
};
#endif // __FTGlyphContainer__
rgl/src/ext/ftgl/FTVectoriser.h 0000644 0001762 0000144 00000017227 14100762641 016123 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __FTVectoriser__
#define __FTVectoriser__
#include "FTGL/ftgl.h"
#include "FTContour.h"
#include "FTList.h"
#include "FTVector.h"
#ifndef CALLBACK
#define CALLBACK
#endif
/**
* FTTesselation captures points that are output by OpenGL's gluTesselator.
*/
class FTTesselation
{
public:
/**
* Default constructor
*/
FTTesselation(GLenum m)
: meshType(m)
{
pointList.reserve(128);
}
/**
* Destructor
*/
~FTTesselation()
{
pointList.clear();
}
/**
* Add a point to the mesh.
*/
void AddPoint(const FTGL_DOUBLE x, const FTGL_DOUBLE y,
const FTGL_DOUBLE z)
{
pointList.push_back(FTPoint(x, y, z));
}
/**
* The number of points in this mesh
*/
size_t PointCount() const { return pointList.size(); }
/**
*
*/
const FTPoint& Point(unsigned int index) const
{ return pointList[index]; }
/**
* Return the OpenGL polygon type.
*/
GLenum PolygonType() const { return meshType; }
private:
/**
* Points generated by gluTesselator.
*/
typedef FTVector PointVector;
PointVector pointList;
/**
* OpenGL primitive type from gluTesselator.
*/
GLenum meshType;
};
/**
* FTMesh is a container of FTTesselation's that make up a polygon glyph
*/
class FTMesh
{
typedef FTVector TesselationVector;
typedef FTList PointList;
public:
/**
* Default constructor
*/
FTMesh();
/**
* Destructor
*/
~FTMesh();
/**
* Add a point to the mesh
*/
void AddPoint(const FTGL_DOUBLE x, const FTGL_DOUBLE y,
const FTGL_DOUBLE z);
/**
* Create a combine point for the gluTesselator
*/
const FTGL_DOUBLE* Combine(const FTGL_DOUBLE x, const FTGL_DOUBLE y,
const FTGL_DOUBLE z);
/**
* Begin a new polygon
*/
void Begin(GLenum meshType);
/**
* End a polygon
*/
void End();
/**
* Record a gluTesselation error
*/
void Error(GLenum e) { err = e; }
/**
* The number of tesselations in the mesh
*/
size_t TesselationCount() const { return tesselationList.size(); }
/**
* Get a tesselation by index
*/
const FTTesselation* const Tesselation(size_t index) const;
/**
* Return the temporary point list. For testing only.
*/
const PointList& TempPointList() const { return tempPointList; }
/**
* Get the GL ERROR returned by the glu tesselator
*/
GLenum Error() const { return err; }
private:
/**
* The current sub mesh that we are constructing.
*/
FTTesselation* currentTesselation;
/**
* Holds each sub mesh that comprises this glyph.
*/
TesselationVector tesselationList;
/**
* Holds extra points created by gluTesselator. See ftglCombine.
*/
PointList tempPointList;
/**
* GL ERROR returned by the glu tesselator
*/
GLenum err;
};
const FTGL_DOUBLE FTGL_FRONT_FACING = 1.0;
const FTGL_DOUBLE FTGL_BACK_FACING = -1.0;
/**
* FTVectoriser class is a helper class that converts font outlines into
* point data.
*
* @see FTExtrudeGlyph
* @see FTOutlineGlyph
* @see FTPolygonGlyph
* @see FTContour
* @see FTPoint
*
*/
class FTVectoriser
{
public:
/**
* Constructor
*
* @param glyph The freetype glyph to be processed
*/
FTVectoriser(const FT_GlyphSlot glyph);
/**
* Destructor
*/
virtual ~FTVectoriser();
/**
* Build an FTMesh from the vector outline data.
*
* @param zNormal The direction of the z axis of the normal
* for this mesh
* FIXME: change the following for a constant
* @param outsetType Specify the outset type contour
* 0 : Original
* 1 : Front
* 2 : Back
* @param outsetSize Specify the outset size contour
*/
void MakeMesh(FTGL_DOUBLE zNormal = FTGL_FRONT_FACING, int outsetType = 0, float outsetSize = 0.0f);
/**
* Get the current mesh.
*/
const FTMesh* const GetMesh() const { return mesh; }
/**
* Get the total count of points in this outline
*
* @return the number of points
*/
size_t PointCount();
/**
* Get the count of contours in this outline
*
* @return the number of contours
*/
size_t ContourCount() const { return ftContourCount; }
/**
* Return a contour at index
*
* @return the number of contours
*/
const FTContour* const Contour(size_t index) const;
/**
* Get the number of points in a specific contour in this outline
*
* @param c The contour index
* @return the number of points in contour[c]
*/
size_t ContourSize(int c) const { return contourList[c]->PointCount(); }
/**
* Get the flag for the tesselation rule for this outline
*
* @return The contour flag
*/
int ContourFlag() const { return contourFlag; }
private:
/**
* Process the freetype outline data into contours of points
*
* @param front front outset distance
* @param back back outset distance
*/
void ProcessContours();
/**
* The list of contours in the glyph
*/
FTContour** contourList;
/**
* A Mesh for tesselations
*/
FTMesh* mesh;
/**
* The number of contours reported by Freetype
*/
short ftContourCount;
/**
* A flag indicating the tesselation rule for the glyph
*/
int contourFlag;
/**
* A Freetype outline
*/
FT_Outline outline;
};
#endif // __FTVectoriser__
rgl/src/ext/ftgl/FTFace.cpp 0000644 0001762 0000144 00000013436 14100762641 015165 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#include "config.h"
#include "FTFace.h"
#include "FTLibrary.h"
#include FT_TRUETYPE_TABLES_H
FTFace::FTFace(const char* fontFilePath, bool precomputeKerning)
: numGlyphs(0),
fontEncodingList(0),
kerningCache(0),
err(0)
{
const FT_Long DEFAULT_FACE_INDEX = 0;
ftFace = new FT_Face;
err = FT_New_Face(*FTLibrary::Instance().GetLibrary(), fontFilePath,
DEFAULT_FACE_INDEX, ftFace);
if(err)
{
delete ftFace;
ftFace = 0;
return;
}
numGlyphs = static_cast((*ftFace)->num_glyphs);
hasKerningTable = (FT_HAS_KERNING((*ftFace)) != 0);
if(hasKerningTable && precomputeKerning)
{
BuildKerningCache();
}
}
FTFace::FTFace(const unsigned char *pBufferBytes, size_t bufferSizeInBytes,
bool precomputeKerning)
: numGlyphs(0),
fontEncodingList(0),
kerningCache(0),
err(0)
{
const FT_Long DEFAULT_FACE_INDEX = 0;
ftFace = new FT_Face;
err = FT_New_Memory_Face(*FTLibrary::Instance().GetLibrary(),
(FT_Byte const *)pBufferBytes, (FT_Long)bufferSizeInBytes,
DEFAULT_FACE_INDEX, ftFace);
if(err)
{
delete ftFace;
ftFace = 0;
return;
}
numGlyphs = static_cast((*ftFace)->num_glyphs);
hasKerningTable = (FT_HAS_KERNING((*ftFace)) != 0);
if(hasKerningTable && precomputeKerning)
{
BuildKerningCache();
}
}
FTFace::~FTFace()
{
if(kerningCache)
{
delete[] kerningCache;
}
if(ftFace)
{
FT_Done_Face(*ftFace);
delete ftFace;
ftFace = 0;
}
}
bool FTFace::Attach(const char* fontFilePath)
{
err = FT_Attach_File(*ftFace, fontFilePath);
return !err;
}
bool FTFace::Attach(const unsigned char *pBufferBytes,
size_t bufferSizeInBytes)
{
FT_Open_Args open;
open.flags = FT_OPEN_MEMORY;
open.memory_base = (FT_Byte const *)pBufferBytes;
open.memory_size = (FT_Long)bufferSizeInBytes;
err = FT_Attach_Stream(*ftFace, &open);
return !err;
}
const FTSize& FTFace::Size(const unsigned int size, const unsigned int res)
{
charSize.CharSize(ftFace, size, res, res);
err = charSize.Error();
return charSize;
}
unsigned int FTFace::CharMapCount() const
{
return (*ftFace)->num_charmaps;
}
FT_Encoding* FTFace::CharMapList()
{
if(0 == fontEncodingList)
{
fontEncodingList = new FT_Encoding[CharMapCount()];
for(size_t i = 0; i < CharMapCount(); ++i)
{
fontEncodingList[i] = (*ftFace)->charmaps[i]->encoding;
}
}
return fontEncodingList;
}
FTPoint FTFace::KernAdvance(unsigned int index1, unsigned int index2)
{
float x, y;
if(!hasKerningTable || !index1 || !index2)
{
return FTPoint(0.0f, 0.0f);
}
if(kerningCache && index1 < FTFace::MAX_PRECOMPUTED
&& index2 < FTFace::MAX_PRECOMPUTED)
{
x = kerningCache[2 * (index2 * FTFace::MAX_PRECOMPUTED + index1)];
y = kerningCache[2 * (index2 * FTFace::MAX_PRECOMPUTED + index1) + 1];
return FTPoint(x, y);
}
FT_Vector kernAdvance;
kernAdvance.x = kernAdvance.y = 0;
err = FT_Get_Kerning(*ftFace, index1, index2, ft_kerning_unfitted,
&kernAdvance);
if(err)
{
return FTPoint(0.0f, 0.0f);
}
x = static_cast(kernAdvance.x) / 64.0f;
y = static_cast(kernAdvance.y) / 64.0f;
return FTPoint(x, y);
}
FT_GlyphSlot FTFace::Glyph(unsigned int index, FT_Int load_flags)
{
err = FT_Load_Glyph(*ftFace, index, load_flags);
if(err)
{
return NULL;
}
return (*ftFace)->glyph;
}
void FTFace::BuildKerningCache()
{
FT_Vector kernAdvance;
kernAdvance.x = 0;
kernAdvance.y = 0;
kerningCache = new float[FTFace::MAX_PRECOMPUTED
* FTFace::MAX_PRECOMPUTED * 2];
for(unsigned int j = 0; j < FTFace::MAX_PRECOMPUTED; j++)
{
for(unsigned int i = 0; i < FTFace::MAX_PRECOMPUTED; i++)
{
err = FT_Get_Kerning(*ftFace, i, j, ft_kerning_unfitted,
&kernAdvance);
if(err)
{
delete[] kerningCache;
kerningCache = NULL;
return;
}
kerningCache[2 * (j * FTFace::MAX_PRECOMPUTED + i)] =
static_cast(kernAdvance.x) / 64.0f;
kerningCache[2 * (j * FTFace::MAX_PRECOMPUTED + i) + 1] =
static_cast(kernAdvance.y) / 64.0f;
}
}
}
rgl/src/ext/ftgl/FTSize.cpp 0000644 0001762 0000144 00000005607 14100762641 015242 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#include "config.h"
#include "FTSize.h"
FTSize::FTSize()
: ftFace(0),
ftSize(0),
size(0),
xResolution(0),
yResolution(0),
err(0)
{}
FTSize::~FTSize()
{}
bool FTSize::CharSize(FT_Face* face, unsigned int pointSize, unsigned int xRes, unsigned int yRes)
{
if(size != pointSize || xResolution != xRes || yResolution != yRes)
{
err = FT_Set_Char_Size(*face, 0L, pointSize * 64, xResolution, yResolution);
if(!err)
{
ftFace = face;
size = pointSize;
xResolution = xRes;
yResolution = yRes;
ftSize = (*ftFace)->size;
}
}
return !err;
}
unsigned int FTSize::CharSize() const
{
return size;
}
float FTSize::Ascender() const
{
return ftSize == 0 ? 0.0f : static_cast(ftSize->metrics.ascender) / 64.0f;
}
float FTSize::Descender() const
{
return ftSize == 0 ? 0.0f : static_cast(ftSize->metrics.descender) / 64.0f;
}
float FTSize::Height() const
{
if(0 == ftSize)
{
return 0.0f;
}
if(FT_IS_SCALABLE((*ftFace)))
{
return ((*ftFace)->bbox.yMax - (*ftFace)->bbox.yMin) * ((float)ftSize->metrics.y_ppem / (float)(*ftFace)->units_per_EM);
}
else
{
return static_cast(ftSize->metrics.height) / 64.0f;
}
}
float FTSize::Width() const
{
if(0 == ftSize)
{
return 0.0f;
}
if(FT_IS_SCALABLE((*ftFace)))
{
return ((*ftFace)->bbox.xMax - (*ftFace)->bbox.xMin) * (static_cast(ftSize->metrics.x_ppem) / static_cast((*ftFace)->units_per_EM));
}
else
{
return static_cast(ftSize->metrics.max_advance) / 64.0f;
}
}
float FTSize::Underline() const
{
return 0.0f;
}
rgl/src/ext/ftgl/FTGL/ 0000755 0001762 0000144 00000000000 14100762641 014116 5 ustar ligges users rgl/src/ext/ftgl/FTGL/FTLayout.h 0000644 0001762 0000144 00000014545 14100762641 016007 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
* Copyright (c) 2008 Sean Morrison
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning This header is deprecated. Please use from now.
# include
#endif
#ifndef __FTLayout__
#define __FTLayout__
#ifdef __cplusplus
class FTLayoutImpl;
/**
* FTLayout is the interface for layout managers that render text.
*
* Specific layout manager classes are derived from this class. This class
* is abstract and deriving classes must implement the protected
* Render methods to render formatted text and
* BBox methods to determine the bounding box of output text.
*
* @see FTFont
* @see FTBBox
*/
class FTGL_EXPORT FTLayout
{
protected:
FTLayout();
private:
/**
* Internal FTGL FTLayout constructor. For private use only.
*
* @param pImpl Internal implementation object. Will be destroyed
* upon FTLayout deletion.
*/
FTLayout(FTLayoutImpl *pImpl);
/* Allow our internal subclasses to access the private constructor */
friend class FTSimpleLayout;
public:
/**
* Destructor
*/
virtual ~FTLayout();
/**
* Get the bounding box for a formatted string.
*
* @param string A char string.
* @param len The length of the string. If < 0 then all characters
* will be checked until a null character is encountered
* (optional).
* @param position The pen position of the first character (optional).
* @return The corresponding bounding box.
*/
virtual FTBBox BBox(const char* string, const int len = -1,
FTPoint position = FTPoint()) = 0;
/**
* Get the bounding box for a formatted string.
*
* @param string A wchar_t string.
* @param len The length of the string. If < 0 then all characters
* will be checked until a null character is encountered
* (optional).
* @param position The pen position of the first character (optional).
* @return The corresponding bounding box.
*/
virtual FTBBox BBox(const wchar_t* string, const int len = -1,
FTPoint position = FTPoint()) = 0;
/**
* Render a string of characters.
*
* @param string 'C' style string to be output.
* @param len The length of the string. If < 0 then all characters
* will be displayed until a null character is encountered
* (optional).
* @param position The pen position of the first character (optional).
* @param renderMode Render mode to display (optional)
*/
virtual void Render(const char *string, const int len = -1,
FTPoint position = FTPoint(),
int renderMode = FTGL::RENDER_ALL) = 0;
/**
* Render a string of characters.
*
* @param string wchar_t string to be output.
* @param len The length of the string. If < 0 then all characters
* will be displayed until a null character is encountered
* (optional).
* @param position The pen position of the first character (optional).
* @param renderMode Render mode to display (optional)
*/
virtual void Render(const wchar_t *string, const int len = -1,
FTPoint position = FTPoint(),
int renderMode = FTGL::RENDER_ALL) = 0;
/**
* Queries the Layout for errors.
*
* @return The current error code.
*/
virtual FT_Error Error() const;
private:
/**
* Internal FTGL FTLayout implementation object. For private use only.
*/
FTLayoutImpl *impl;
};
#endif //__cplusplus
FTGL_BEGIN_C_DECLS
/**
* FTGLlayout is the interface for layout managers that render text.
*/
struct _FTGLlayout;
typedef struct _FTGLlayout FTGLlayout;
/**
* Destroy an FTGL layout object.
*
* @param layout An FTGLlayout* object.
*/
FTGL_EXPORT void ftglDestroyLayout(FTGLlayout* layout);
/**
* Get the bounding box for a string.
*
* @param layout An FTGLlayout* object.
* @param string A char buffer
* @param bounds An array of 6 float values where the bounding box's lower
* left near and upper right far 3D coordinates will be stored.
*/
FTGL_EXPORT void ftglGetLayoutBBox(FTGLlayout *layout, const char* string,
float bounds[6]);
/**
* Render a string of characters.
*
* @param layout An FTGLlayout* object.
* @param string Char string to be output.
* @param mode Render mode to display.
*/
FTGL_EXPORT void ftglRenderLayout(FTGLlayout *layout, const char *string,
int mode);
/**
* Query a layout for errors.
*
* @param layout An FTGLlayout* object.
* @return The current error code.
*/
FTGL_EXPORT FT_Error ftglGetLayoutError(FTGLlayout* layout);
FTGL_END_C_DECLS
#endif /* __FTLayout__ */
rgl/src/ext/ftgl/FTGL/FTBuffer.h 0000644 0001762 0000144 00000006373 14100762641 015743 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2008 Sam Hocevar
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning Please use instead of .
# include
#endif
#ifndef __FTBuffer__
#define __FTBuffer__
#ifdef __cplusplus
/**
* FTBuffer is a helper class for pixel buffers.
*
* It provides the interface between FTBufferFont and FTBufferGlyph to
* optimise rendering operations.
*
* @see FTBufferGlyph
* @see FTBufferFont
*/
class FTGL_EXPORT FTBuffer
{
public:
/**
* Default constructor.
*/
FTBuffer();
/**
* Destructor
*/
~FTBuffer();
/**
* Get the pen's position in the buffer.
*
* @return The pen's position as an FTPoint object.
*/
inline FTPoint Pos() const
{
return pos;
}
/**
* Set the pen's position in the buffer.
*
* @param arg An FTPoint object with the desired pen's position.
*/
inline void Pos(FTPoint arg)
{
pos = arg;
}
/**
* Set the buffer's size.
*
* @param w The buffer's desired width, in pixels.
* @param h The buffer's desired height, in pixels.
*/
void Size(int w, int h);
/**
* Get the buffer's width.
*
* @return The buffer's width, in pixels.
*/
inline int Width() const { return width; }
/**
* Get the buffer's height.
*
* @return The buffer's height, in pixels.
*/
inline int Height() const { return height; }
/**
* Get the buffer's direct pixel buffer.
*
* @return A read-write pointer to the buffer's pixels.
*/
inline unsigned char *Pixels() const { return pixels; }
private:
/**
* Buffer's width and height.
*/
int width, height;
/**
* Buffer's pixel buffer.
*/
unsigned char *pixels;
/**
* Buffer's internal pen position.
*/
FTPoint pos;
};
#endif //__cplusplus
#endif // __FTBuffer__
rgl/src/ext/ftgl/FTGL/FTGLPolygonFont.h 0000644 0001762 0000144 00000006144 14100762641 017227 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
* Copyright (c) 2008 Sean Morrison
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning This header is deprecated. Please use from now.
# include
#endif
#ifndef __FTPolygonFont__
#define __FTPolygonFont__
#ifdef __cplusplus
/**
* FTPolygonFont is a specialisation of the FTFont class for handling
* tesselated Polygon Mesh fonts
*
* @see FTFont
*/
class FTGL_EXPORT FTPolygonFont : public FTFont
{
public:
/**
* Open and read a font file. Sets Error flag.
*
* @param fontFilePath font file path.
*/
FTPolygonFont(const char* fontFilePath);
/**
* Open and read a font from a buffer in memory. Sets Error flag.
* The buffer is owned by the client and is NOT copied by FTGL. The
* pointer must be valid while using FTGL.
*
* @param pBufferBytes the in-memory buffer
* @param bufferSizeInBytes the length of the buffer in bytes
*/
FTPolygonFont(const unsigned char *pBufferBytes,
size_t bufferSizeInBytes);
/**
* Destructor
*/
~FTPolygonFont();
protected:
/**
* Construct a glyph of the correct type.
*
* Clients must override the function and return their specialised
* FTGlyph.
*
* @param slot A FreeType glyph slot.
* @return An FT****Glyph or null on failure.
*/
virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
};
#define FTGLPolygonFont FTPolygonFont
#endif //__cplusplus
FTGL_BEGIN_C_DECLS
/**
* Create a specialised FTGLfont object for handling tesselated polygon
* mesh fonts.
*
* @param file The font file name.
* @return An FTGLfont* object.
*
* @see FTGLfont
*/
FTGL_EXPORT FTGLfont *ftglCreatePolygonFont(const char *file);
FTGL_END_C_DECLS
#endif // __FTPolygonFont__
rgl/src/ext/ftgl/FTGL/FTGLOutlineFont.h 0000644 0001762 0000144 00000006115 14100762641 017215 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
* Copyright (c) 2008 Sean Morrison
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning This header is deprecated. Please use from now.
# include
#endif
#ifndef __FTOutlineFont__
#define __FTOutlineFont__
#ifdef __cplusplus
/**
* FTOutlineFont is a specialisation of the FTFont class for handling
* Vector Outline fonts
*
* @see FTFont
*/
class FTGL_EXPORT FTOutlineFont : public FTFont
{
public:
/**
* Open and read a font file. Sets Error flag.
*
* @param fontFilePath font file path.
*/
FTOutlineFont(const char* fontFilePath);
/**
* Open and read a font from a buffer in memory. Sets Error flag.
* The buffer is owned by the client and is NOT copied by FTGL. The
* pointer must be valid while using FTGL.
*
* @param pBufferBytes the in-memory buffer
* @param bufferSizeInBytes the length of the buffer in bytes
*/
FTOutlineFont(const unsigned char *pBufferBytes,
size_t bufferSizeInBytes);
/**
* Destructor
*/
~FTOutlineFont();
protected:
/**
* Construct a glyph of the correct type.
*
* Clients must override the function and return their specialised
* FTGlyph.
*
* @param slot A FreeType glyph slot.
* @return An FT****Glyph or null on failure.
*/
virtual FTGlyph* MakeGlyph(FT_GlyphSlot slot);
};
#define FTGLOutlineFont FTOutlineFont
#endif //__cplusplus
FTGL_BEGIN_C_DECLS
/**
* Create a specialised FTGLfont object for handling vector outline fonts.
*
* @param file The font file name.
* @return An FTGLfont* object.
*
* @see FTGLfont
*/
FTGL_EXPORT FTGLfont *ftglCreateOutlineFont(const char *file);
FTGL_END_C_DECLS
#endif // __FTOutlineFont__
rgl/src/ext/ftgl/FTGL/FTPixmapGlyph.h 0000644 0001762 0000144 00000004726 14100762641 016774 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
* Copyright (c) 2008 Sean Morrison
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning This header is deprecated. Please use from now.
# include
#endif
#ifndef __FTPixmapGlyph__
#define __FTPixmapGlyph__
#ifdef __cplusplus
/**
* FTPixmapGlyph is a specialisation of FTGlyph for creating pixmaps.
*/
class FTGL_EXPORT FTPixmapGlyph : public FTGlyph
{
public:
/**
* Constructor
*
* @param glyph The Freetype glyph to be processed
*/
FTPixmapGlyph(FT_GlyphSlot glyph);
/**
* Destructor
*/
virtual ~FTPixmapGlyph();
/**
* Render this glyph at the current pen position.
*
* @param pen The current pen position.
* @param renderMode Render mode to display
* @return The advance distance for this glyph.
*/
virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
};
#endif //__cplusplus
FTGL_BEGIN_C_DECLS
/**
* Create a specialisation of FTGLglyph for creating pixmaps.
*
* @param glyph The Freetype glyph to be processed
* @return An FTGLglyph* object.
*/
FTGL_EXPORT FTGLglyph *ftglCreatePixmapGlyph(FT_GlyphSlot glyph);
FTGL_END_C_DECLS
#endif // __FTPixmapGlyph__
rgl/src/ext/ftgl/FTGL/FTPolyGlyph.h 0000644 0001762 0000144 00000006511 14100762641 016453 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
* Copyright (c) 2008 Sean Morrison
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning This header is deprecated. Please use from now.
# include
#endif
#ifndef __FTPolygonGlyph__
#define __FTPolygonGlyph__
#ifdef __cplusplus
/**
* FTPolygonGlyph is a specialisation of FTGlyph for creating tessellated
* polygon glyphs.
*/
class FTGL_EXPORT FTPolygonGlyph : public FTGlyph
{
public:
/**
* Constructor. Sets the Error to Invalid_Outline if the glyphs
* isn't an outline.
*
* @param glyph The Freetype glyph to be processed
* @param outset The outset distance
* @param useDisplayList Enable or disable the use of Display Lists
* for this glyph
* true turns ON display lists.
* false turns OFF display lists.
*/
FTPolygonGlyph(FT_GlyphSlot glyph, float outset, bool useDisplayList);
/**
* Destructor
*/
virtual ~FTPolygonGlyph();
/**
* Render this glyph at the current pen position.
*
* @param pen The current pen position.
* @param renderMode Render mode to display
* @return The advance distance for this glyph.
*/
virtual const FTPoint& Render(const FTPoint& pen, int renderMode);
};
#define FTPolyGlyph FTPolygonGlyph
#endif //__cplusplus
FTGL_BEGIN_C_DECLS
/**
* Create a specialisation of FTGLglyph for creating tessellated
* polygon glyphs.
*
* @param glyph The Freetype glyph to be processed
* @param outset outset contour size
* @param useDisplayList Enable or disable the use of Display Lists
* for this glyph
* true turns ON display lists.
* false turns OFF display lists.
* @return An FTGLglyph* object.
*/
FTGL_EXPORT FTGLglyph *ftglCreatePolygonGlyph(FT_GlyphSlot glyph, float outset,
int useDisplayList);
FTGL_END_C_DECLS
#endif // __FTPolygonGlyph__
rgl/src/ext/ftgl/FTGL/FTSimpleLayout.h 0000644 0001762 0000144 00000014720 14100762641 017154 0 ustar ligges users /*
* FTGL - OpenGL font library
*
* Copyright (c) 2001-2004 Henry Maddocks
* Copyright (c) 2008 Sam Hocevar
* Copyright (c) 2008 Sean Morrison
*
* 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, sublicense, 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 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 NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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.
*/
#ifndef __ftgl__
# warning This header is deprecated. Please use