1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.hgignore	Sun Nov 09 13:03:36 2014 +0200
     1.3 @@ -0,0 +1,6 @@
     1.4 +\.o$
     1.5 +\.d$
     1.6 +\.swp$
     1.7 +\.jpg$
     1.8 +\.png$
     1.9 +\.cubemap$

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/COPYING	Sun Nov 09 13:03:36 2014 +0200
     2.3 @@ -0,0 +1,674 @@
     2.4 +                    GNU GENERAL PUBLIC LICENSE
     2.5 +                       Version 3, 29 June 2007
     2.6 +
     2.7 + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
     2.8 + Everyone is permitted to copy and distribute verbatim copies
     2.9 + of this license document, but changing it is not allowed.
    2.10 +
    2.11 +                            Preamble
    2.12 +
    2.13 +  The GNU General Public License is a free, copyleft license for
    2.14 +software and other kinds of works.
    2.15 +
    2.16 +  The licenses for most software and other practical works are designed
    2.17 +to take away your freedom to share and change the works.  By contrast,
    2.18 +the GNU General Public License is intended to guarantee your freedom to
    2.19 +share and change all versions of a program--to make sure it remains free
    2.20 +software for all its users.  We, the Free Software Foundation, use the
    2.21 +GNU General Public License for most of our software; it applies also to
    2.22 +any other work released this way by its authors.  You can apply it to
    2.23 +your programs, too.
    2.24 +
    2.25 +  When we speak of free software, we are referring to freedom, not
    2.26 +price.  Our General Public Licenses are designed to make sure that you
    2.27 +have the freedom to distribute copies of free software (and charge for
    2.28 +them if you wish), that you receive source code or can get it if you
    2.29 +want it, that you can change the software or use pieces of it in new
    2.30 +free programs, and that you know you can do these things.
    2.31 +
    2.32 +  To protect your rights, we need to prevent others from denying you
    2.33 +these rights or asking you to surrender the rights.  Therefore, you have
    2.34 +certain responsibilities if you distribute copies of the software, or if
    2.35 +you modify it: responsibilities to respect the freedom of others.
    2.36 +
    2.37 +  For example, if you distribute copies of such a program, whether
    2.38 +gratis or for a fee, you must pass on to the recipients the same
    2.39 +freedoms that you received.  You must make sure that they, too, receive
    2.40 +or can get the source code.  And you must show them these terms so they
    2.41 +know their rights.
    2.42 +
    2.43 +  Developers that use the GNU GPL protect your rights with two steps:
    2.44 +(1) assert copyright on the software, and (2) offer you this License
    2.45 +giving you legal permission to copy, distribute and/or modify it.
    2.46 +
    2.47 +  For the developers' and authors' protection, the GPL clearly explains
    2.48 +that there is no warranty for this free software.  For both users' and
    2.49 +authors' sake, the GPL requires that modified versions be marked as
    2.50 +changed, so that their problems will not be attributed erroneously to
    2.51 +authors of previous versions.
    2.52 +
    2.53 +  Some devices are designed to deny users access to install or run
    2.54 +modified versions of the software inside them, although the manufacturer
    2.55 +can do so.  This is fundamentally incompatible with the aim of
    2.56 +protecting users' freedom to change the software.  The systematic
    2.57 +pattern of such abuse occurs in the area of products for individuals to
    2.58 +use, which is precisely where it is most unacceptable.  Therefore, we
    2.59 +have designed this version of the GPL to prohibit the practice for those
    2.60 +products.  If such problems arise substantially in other domains, we
    2.61 +stand ready to extend this provision to those domains in future versions
    2.62 +of the GPL, as needed to protect the freedom of users.
    2.63 +
    2.64 +  Finally, every program is threatened constantly by software patents.
    2.65 +States should not allow patents to restrict development and use of
    2.66 +software on general-purpose computers, but in those that do, we wish to
    2.67 +avoid the special danger that patents applied to a free program could
    2.68 +make it effectively proprietary.  To prevent this, the GPL assures that
    2.69 +patents cannot be used to render the program non-free.
    2.70 +
    2.71 +  The precise terms and conditions for copying, distribution and
    2.72 +modification follow.
    2.73 +
    2.74 +                       TERMS AND CONDITIONS
    2.75 +
    2.76 +  0. Definitions.
    2.77 +
    2.78 +  "This License" refers to version 3 of the GNU General Public License.
    2.79 +
    2.80 +  "Copyright" also means copyright-like laws that apply to other kinds of
    2.81 +works, such as semiconductor masks.
    2.82 +
    2.83 +  "The Program" refers to any copyrightable work licensed under this
    2.84 +License.  Each licensee is addressed as "you".  "Licensees" and
    2.85 +"recipients" may be individuals or organizations.
    2.86 +
    2.87 +  To "modify" a work means to copy from or adapt all or part of the work
    2.88 +in a fashion requiring copyright permission, other than the making of an
    2.89 +exact copy.  The resulting work is called a "modified version" of the
    2.90 +earlier work or a work "based on" the earlier work.
    2.91 +
    2.92 +  A "covered work" means either the unmodified Program or a work based
    2.93 +on the Program.
    2.94 +
    2.95 +  To "propagate" a work means to do anything with it that, without
    2.96 +permission, would make you directly or secondarily liable for
    2.97 +infringement under applicable copyright law, except executing it on a
    2.98 +computer or modifying a private copy.  Propagation includes copying,
    2.99 +distribution (with or without modification), making available to the
   2.100 +public, and in some countries other activities as well.
   2.101 +
   2.102 +  To "convey" a work means any kind of propagation that enables other
   2.103 +parties to make or receive copies.  Mere interaction with a user through
   2.104 +a computer network, with no transfer of a copy, is not conveying.
   2.105 +
   2.106 +  An interactive user interface displays "Appropriate Legal Notices"
   2.107 +to the extent that it includes a convenient and prominently visible
   2.108 +feature that (1) displays an appropriate copyright notice, and (2)
   2.109 +tells the user that there is no warranty for the work (except to the
   2.110 +extent that warranties are provided), that licensees may convey the
   2.111 +work under this License, and how to view a copy of this License.  If
   2.112 +the interface presents a list of user commands or options, such as a
   2.113 +menu, a prominent item in the list meets this criterion.
   2.114 +
   2.115 +  1. Source Code.
   2.116 +
   2.117 +  The "source code" for a work means the preferred form of the work
   2.118 +for making modifications to it.  "Object code" means any non-source
   2.119 +form of a work.
   2.120 +
   2.121 +  A "Standard Interface" means an interface that either is an official
   2.122 +standard defined by a recognized standards body, or, in the case of
   2.123 +interfaces specified for a particular programming language, one that
   2.124 +is widely used among developers working in that language.
   2.125 +
   2.126 +  The "System Libraries" of an executable work include anything, other
   2.127 +than the work as a whole, that (a) is included in the normal form of
   2.128 +packaging a Major Component, but which is not part of that Major
   2.129 +Component, and (b) serves only to enable use of the work with that
   2.130 +Major Component, or to implement a Standard Interface for which an
   2.131 +implementation is available to the public in source code form.  A
   2.132 +"Major Component", in this context, means a major essential component
   2.133 +(kernel, window system, and so on) of the specific operating system
   2.134 +(if any) on which the executable work runs, or a compiler used to
   2.135 +produce the work, or an object code interpreter used to run it.
   2.136 +
   2.137 +  The "Corresponding Source" for a work in object code form means all
   2.138 +the source code needed to generate, install, and (for an executable
   2.139 +work) run the object code and to modify the work, including scripts to
   2.140 +control those activities.  However, it does not include the work's
   2.141 +System Libraries, or general-purpose tools or generally available free
   2.142 +programs which are used unmodified in performing those activities but
   2.143 +which are not part of the work.  For example, Corresponding Source
   2.144 +includes interface definition files associated with source files for
   2.145 +the work, and the source code for shared libraries and dynamically
   2.146 +linked subprograms that the work is specifically designed to require,
   2.147 +such as by intimate data communication or control flow between those
   2.148 +subprograms and other parts of the work.
   2.149 +
   2.150 +  The Corresponding Source need not include anything that users
   2.151 +can regenerate automatically from other parts of the Corresponding
   2.152 +Source.
   2.153 +
   2.154 +  The Corresponding Source for a work in source code form is that
   2.155 +same work.
   2.156 +
   2.157 +  2. Basic Permissions.
   2.158 +
   2.159 +  All rights granted under this License are granted for the term of
   2.160 +copyright on the Program, and are irrevocable provided the stated
   2.161 +conditions are met.  This License explicitly affirms your unlimited
   2.162 +permission to run the unmodified Program.  The output from running a
   2.163 +covered work is covered by this License only if the output, given its
   2.164 +content, constitutes a covered work.  This License acknowledges your
   2.165 +rights of fair use or other equivalent, as provided by copyright law.
   2.166 +
   2.167 +  You may make, run and propagate covered works that you do not
   2.168 +convey, without conditions so long as your license otherwise remains
   2.169 +in force.  You may convey covered works to others for the sole purpose
   2.170 +of having them make modifications exclusively for you, or provide you
   2.171 +with facilities for running those works, provided that you comply with
   2.172 +the terms of this License in conveying all material for which you do
   2.173 +not control copyright.  Those thus making or running the covered works
   2.174 +for you must do so exclusively on your behalf, under your direction
   2.175 +and control, on terms that prohibit them from making any copies of
   2.176 +your copyrighted material outside their relationship with you.
   2.177 +
   2.178 +  Conveying under any other circumstances is permitted solely under
   2.179 +the conditions stated below.  Sublicensing is not allowed; section 10
   2.180 +makes it unnecessary.
   2.181 +
   2.182 +  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
   2.183 +
   2.184 +  No covered work shall be deemed part of an effective technological
   2.185 +measure under any applicable law fulfilling obligations under article
   2.186 +11 of the WIPO copyright treaty adopted on 20 December 1996, or
   2.187 +similar laws prohibiting or restricting circumvention of such
   2.188 +measures.
   2.189 +
   2.190 +  When you convey a covered work, you waive any legal power to forbid
   2.191 +circumvention of technological measures to the extent such circumvention
   2.192 +is effected by exercising rights under this License with respect to
   2.193 +the covered work, and you disclaim any intention to limit operation or
   2.194 +modification of the work as a means of enforcing, against the work's
   2.195 +users, your or third parties' legal rights to forbid circumvention of
   2.196 +technological measures.
   2.197 +
   2.198 +  4. Conveying Verbatim Copies.
   2.199 +
   2.200 +  You may convey verbatim copies of the Program's source code as you
   2.201 +receive it, in any medium, provided that you conspicuously and
   2.202 +appropriately publish on each copy an appropriate copyright notice;
   2.203 +keep intact all notices stating that this License and any
   2.204 +non-permissive terms added in accord with section 7 apply to the code;
   2.205 +keep intact all notices of the absence of any warranty; and give all
   2.206 +recipients a copy of this License along with the Program.
   2.207 +
   2.208 +  You may charge any price or no price for each copy that you convey,
   2.209 +and you may offer support or warranty protection for a fee.
   2.210 +
   2.211 +  5. Conveying Modified Source Versions.
   2.212 +
   2.213 +  You may convey a work based on the Program, or the modifications to
   2.214 +produce it from the Program, in the form of source code under the
   2.215 +terms of section 4, provided that you also meet all of these conditions:
   2.216 +
   2.217 +    a) The work must carry prominent notices stating that you modified
   2.218 +    it, and giving a relevant date.
   2.219 +
   2.220 +    b) The work must carry prominent notices stating that it is
   2.221 +    released under this License and any conditions added under section
   2.222 +    7.  This requirement modifies the requirement in section 4 to
   2.223 +    "keep intact all notices".
   2.224 +
   2.225 +    c) You must license the entire work, as a whole, under this
   2.226 +    License to anyone who comes into possession of a copy.  This
   2.227 +    License will therefore apply, along with any applicable section 7
   2.228 +    additional terms, to the whole of the work, and all its parts,
   2.229 +    regardless of how they are packaged.  This License gives no
   2.230 +    permission to license the work in any other way, but it does not
   2.231 +    invalidate such permission if you have separately received it.
   2.232 +
   2.233 +    d) If the work has interactive user interfaces, each must display
   2.234 +    Appropriate Legal Notices; however, if the Program has interactive
   2.235 +    interfaces that do not display Appropriate Legal Notices, your
   2.236 +    work need not make them do so.
   2.237 +
   2.238 +  A compilation of a covered work with other separate and independent
   2.239 +works, which are not by their nature extensions of the covered work,
   2.240 +and which are not combined with it such as to form a larger program,
   2.241 +in or on a volume of a storage or distribution medium, is called an
   2.242 +"aggregate" if the compilation and its resulting copyright are not
   2.243 +used to limit the access or legal rights of the compilation's users
   2.244 +beyond what the individual works permit.  Inclusion of a covered work
   2.245 +in an aggregate does not cause this License to apply to the other
   2.246 +parts of the aggregate.
   2.247 +
   2.248 +  6. Conveying Non-Source Forms.
   2.249 +
   2.250 +  You may convey a covered work in object code form under the terms
   2.251 +of sections 4 and 5, provided that you also convey the
   2.252 +machine-readable Corresponding Source under the terms of this License,
   2.253 +in one of these ways:
   2.254 +
   2.255 +    a) Convey the object code in, or embodied in, a physical product
   2.256 +    (including a physical distribution medium), accompanied by the
   2.257 +    Corresponding Source fixed on a durable physical medium
   2.258 +    customarily used for software interchange.
   2.259 +
   2.260 +    b) Convey the object code in, or embodied in, a physical product
   2.261 +    (including a physical distribution medium), accompanied by a
   2.262 +    written offer, valid for at least three years and valid for as
   2.263 +    long as you offer spare parts or customer support for that product
   2.264 +    model, to give anyone who possesses the object code either (1) a
   2.265 +    copy of the Corresponding Source for all the software in the
   2.266 +    product that is covered by this License, on a durable physical
   2.267 +    medium customarily used for software interchange, for a price no
   2.268 +    more than your reasonable cost of physically performing this
   2.269 +    conveying of source, or (2) access to copy the
   2.270 +    Corresponding Source from a network server at no charge.
   2.271 +
   2.272 +    c) Convey individual copies of the object code with a copy of the
   2.273 +    written offer to provide the Corresponding Source.  This
   2.274 +    alternative is allowed only occasionally and noncommercially, and
   2.275 +    only if you received the object code with such an offer, in accord
   2.276 +    with subsection 6b.
   2.277 +
   2.278 +    d) Convey the object code by offering access from a designated
   2.279 +    place (gratis or for a charge), and offer equivalent access to the
   2.280 +    Corresponding Source in the same way through the same place at no
   2.281 +    further charge.  You need not require recipients to copy the
   2.282 +    Corresponding Source along with the object code.  If the place to
   2.283 +    copy the object code is a network server, the Corresponding Source
   2.284 +    may be on a different server (operated by you or a third party)
   2.285 +    that supports equivalent copying facilities, provided you maintain
   2.286 +    clear directions next to the object code saying where to find the
   2.287 +    Corresponding Source.  Regardless of what server hosts the
   2.288 +    Corresponding Source, you remain obligated to ensure that it is
   2.289 +    available for as long as needed to satisfy these requirements.
   2.290 +
   2.291 +    e) Convey the object code using peer-to-peer transmission, provided
   2.292 +    you inform other peers where the object code and Corresponding
   2.293 +    Source of the work are being offered to the general public at no
   2.294 +    charge under subsection 6d.
   2.295 +
   2.296 +  A separable portion of the object code, whose source code is excluded
   2.297 +from the Corresponding Source as a System Library, need not be
   2.298 +included in conveying the object code work.
   2.299 +
   2.300 +  A "User Product" is either (1) a "consumer product", which means any
   2.301 +tangible personal property which is normally used for personal, family,
   2.302 +or household purposes, or (2) anything designed or sold for incorporation
   2.303 +into a dwelling.  In determining whether a product is a consumer product,
   2.304 +doubtful cases shall be resolved in favor of coverage.  For a particular
   2.305 +product received by a particular user, "normally used" refers to a
   2.306 +typical or common use of that class of product, regardless of the status
   2.307 +of the particular user or of the way in which the particular user
   2.308 +actually uses, or expects or is expected to use, the product.  A product
   2.309 +is a consumer product regardless of whether the product has substantial
   2.310 +commercial, industrial or non-consumer uses, unless such uses represent
   2.311 +the only significant mode of use of the product.
   2.312 +
   2.313 +  "Installation Information" for a User Product means any methods,
   2.314 +procedures, authorization keys, or other information required to install
   2.315 +and execute modified versions of a covered work in that User Product from
   2.316 +a modified version of its Corresponding Source.  The information must
   2.317 +suffice to ensure that the continued functioning of the modified object
   2.318 +code is in no case prevented or interfered with solely because
   2.319 +modification has been made.
   2.320 +
   2.321 +  If you convey an object code work under this section in, or with, or
   2.322 +specifically for use in, a User Product, and the conveying occurs as
   2.323 +part of a transaction in which the right of possession and use of the
   2.324 +User Product is transferred to the recipient in perpetuity or for a
   2.325 +fixed term (regardless of how the transaction is characterized), the
   2.326 +Corresponding Source conveyed under this section must be accompanied
   2.327 +by the Installation Information.  But this requirement does not apply
   2.328 +if neither you nor any third party retains the ability to install
   2.329 +modified object code on the User Product (for example, the work has
   2.330 +been installed in ROM).
   2.331 +
   2.332 +  The requirement to provide Installation Information does not include a
   2.333 +requirement to continue to provide support service, warranty, or updates
   2.334 +for a work that has been modified or installed by the recipient, or for
   2.335 +the User Product in which it has been modified or installed.  Access to a
   2.336 +network may be denied when the modification itself materially and
   2.337 +adversely affects the operation of the network or violates the rules and
   2.338 +protocols for communication across the network.
   2.339 +
   2.340 +  Corresponding Source conveyed, and Installation Information provided,
   2.341 +in accord with this section must be in a format that is publicly
   2.342 +documented (and with an implementation available to the public in
   2.343 +source code form), and must require no special password or key for
   2.344 +unpacking, reading or copying.
   2.345 +
   2.346 +  7. Additional Terms.
   2.347 +
   2.348 +  "Additional permissions" are terms that supplement the terms of this
   2.349 +License by making exceptions from one or more of its conditions.
   2.350 +Additional permissions that are applicable to the entire Program shall
   2.351 +be treated as though they were included in this License, to the extent
   2.352 +that they are valid under applicable law.  If additional permissions
   2.353 +apply only to part of the Program, that part may be used separately
   2.354 +under those permissions, but the entire Program remains governed by
   2.355 +this License without regard to the additional permissions.
   2.356 +
   2.357 +  When you convey a copy of a covered work, you may at your option
   2.358 +remove any additional permissions from that copy, or from any part of
   2.359 +it.  (Additional permissions may be written to require their own
   2.360 +removal in certain cases when you modify the work.)  You may place
   2.361 +additional permissions on material, added by you to a covered work,
   2.362 +for which you have or can give appropriate copyright permission.
   2.363 +
   2.364 +  Notwithstanding any other provision of this License, for material you
   2.365 +add to a covered work, you may (if authorized by the copyright holders of
   2.366 +that material) supplement the terms of this License with terms:
   2.367 +
   2.368 +    a) Disclaiming warranty or limiting liability differently from the
   2.369 +    terms of sections 15 and 16 of this License; or
   2.370 +
   2.371 +    b) Requiring preservation of specified reasonable legal notices or
   2.372 +    author attributions in that material or in the Appropriate Legal
   2.373 +    Notices displayed by works containing it; or
   2.374 +
   2.375 +    c) Prohibiting misrepresentation of the origin of that material, or
   2.376 +    requiring that modified versions of such material be marked in
   2.377 +    reasonable ways as different from the original version; or
   2.378 +
   2.379 +    d) Limiting the use for publicity purposes of names of licensors or
   2.380 +    authors of the material; or
   2.381 +
   2.382 +    e) Declining to grant rights under trademark law for use of some
   2.383 +    trade names, trademarks, or service marks; or
   2.384 +
   2.385 +    f) Requiring indemnification of licensors and authors of that
   2.386 +    material by anyone who conveys the material (or modified versions of
   2.387 +    it) with contractual assumptions of liability to the recipient, for
   2.388 +    any liability that these contractual assumptions directly impose on
   2.389 +    those licensors and authors.
   2.390 +
   2.391 +  All other non-permissive additional terms are considered "further
   2.392 +restrictions" within the meaning of section 10.  If the Program as you
   2.393 +received it, or any part of it, contains a notice stating that it is
   2.394 +governed by this License along with a term that is a further
   2.395 +restriction, you may remove that term.  If a license document contains
   2.396 +a further restriction but permits relicensing or conveying under this
   2.397 +License, you may add to a covered work material governed by the terms
   2.398 +of that license document, provided that the further restriction does
   2.399 +not survive such relicensing or conveying.
   2.400 +
   2.401 +  If you add terms to a covered work in accord with this section, you
   2.402 +must place, in the relevant source files, a statement of the
   2.403 +additional terms that apply to those files, or a notice indicating
   2.404 +where to find the applicable terms.
   2.405 +
   2.406 +  Additional terms, permissive or non-permissive, may be stated in the
   2.407 +form of a separately written license, or stated as exceptions;
   2.408 +the above requirements apply either way.
   2.409 +
   2.410 +  8. Termination.
   2.411 +
   2.412 +  You may not propagate or modify a covered work except as expressly
   2.413 +provided under this License.  Any attempt otherwise to propagate or
   2.414 +modify it is void, and will automatically terminate your rights under
   2.415 +this License (including any patent licenses granted under the third
   2.416 +paragraph of section 11).
   2.417 +
   2.418 +  However, if you cease all violation of this License, then your
   2.419 +license from a particular copyright holder is reinstated (a)
   2.420 +provisionally, unless and until the copyright holder explicitly and
   2.421 +finally terminates your license, and (b) permanently, if the copyright
   2.422 +holder fails to notify you of the violation by some reasonable means
   2.423 +prior to 60 days after the cessation.
   2.424 +
   2.425 +  Moreover, your license from a particular copyright holder is
   2.426 +reinstated permanently if the copyright holder notifies you of the
   2.427 +violation by some reasonable means, this is the first time you have
   2.428 +received notice of violation of this License (for any work) from that
   2.429 +copyright holder, and you cure the violation prior to 30 days after
   2.430 +your receipt of the notice.
   2.431 +
   2.432 +  Termination of your rights under this section does not terminate the
   2.433 +licenses of parties who have received copies or rights from you under
   2.434 +this License.  If your rights have been terminated and not permanently
   2.435 +reinstated, you do not qualify to receive new licenses for the same
   2.436 +material under section 10.
   2.437 +
   2.438 +  9. Acceptance Not Required for Having Copies.
   2.439 +
   2.440 +  You are not required to accept this License in order to receive or
   2.441 +run a copy of the Program.  Ancillary propagation of a covered work
   2.442 +occurring solely as a consequence of using peer-to-peer transmission
   2.443 +to receive a copy likewise does not require acceptance.  However,
   2.444 +nothing other than this License grants you permission to propagate or
   2.445 +modify any covered work.  These actions infringe copyright if you do
   2.446 +not accept this License.  Therefore, by modifying or propagating a
   2.447 +covered work, you indicate your acceptance of this License to do so.
   2.448 +
   2.449 +  10. Automatic Licensing of Downstream Recipients.
   2.450 +
   2.451 +  Each time you convey a covered work, the recipient automatically
   2.452 +receives a license from the original licensors, to run, modify and
   2.453 +propagate that work, subject to this License.  You are not responsible
   2.454 +for enforcing compliance by third parties with this License.
   2.455 +
   2.456 +  An "entity transaction" is a transaction transferring control of an
   2.457 +organization, or substantially all assets of one, or subdividing an
   2.458 +organization, or merging organizations.  If propagation of a covered
   2.459 +work results from an entity transaction, each party to that
   2.460 +transaction who receives a copy of the work also receives whatever
   2.461 +licenses to the work the party's predecessor in interest had or could
   2.462 +give under the previous paragraph, plus a right to possession of the
   2.463 +Corresponding Source of the work from the predecessor in interest, if
   2.464 +the predecessor has it or can get it with reasonable efforts.
   2.465 +
   2.466 +  You may not impose any further restrictions on the exercise of the
   2.467 +rights granted or affirmed under this License.  For example, you may
   2.468 +not impose a license fee, royalty, or other charge for exercise of
   2.469 +rights granted under this License, and you may not initiate litigation
   2.470 +(including a cross-claim or counterclaim in a lawsuit) alleging that
   2.471 +any patent claim is infringed by making, using, selling, offering for
   2.472 +sale, or importing the Program or any portion of it.
   2.473 +
   2.474 +  11. Patents.
   2.475 +
   2.476 +  A "contributor" is a copyright holder who authorizes use under this
   2.477 +License of the Program or a work on which the Program is based.  The
   2.478 +work thus licensed is called the contributor's "contributor version".
   2.479 +
   2.480 +  A contributor's "essential patent claims" are all patent claims
   2.481 +owned or controlled by the contributor, whether already acquired or
   2.482 +hereafter acquired, that would be infringed by some manner, permitted
   2.483 +by this License, of making, using, or selling its contributor version,
   2.484 +but do not include claims that would be infringed only as a
   2.485 +consequence of further modification of the contributor version.  For
   2.486 +purposes of this definition, "control" includes the right to grant
   2.487 +patent sublicenses in a manner consistent with the requirements of
   2.488 +this License.
   2.489 +
   2.490 +  Each contributor grants you a non-exclusive, worldwide, royalty-free
   2.491 +patent license under the contributor's essential patent claims, to
   2.492 +make, use, sell, offer for sale, import and otherwise run, modify and
   2.493 +propagate the contents of its contributor version.
   2.494 +
   2.495 +  In the following three paragraphs, a "patent license" is any express
   2.496 +agreement or commitment, however denominated, not to enforce a patent
   2.497 +(such as an express permission to practice a patent or covenant not to
   2.498 +sue for patent infringement).  To "grant" such a patent license to a
   2.499 +party means to make such an agreement or commitment not to enforce a
   2.500 +patent against the party.
   2.501 +
   2.502 +  If you convey a covered work, knowingly relying on a patent license,
   2.503 +and the Corresponding Source of the work is not available for anyone
   2.504 +to copy, free of charge and under the terms of this License, through a
   2.505 +publicly available network server or other readily accessible means,
   2.506 +then you must either (1) cause the Corresponding Source to be so
   2.507 +available, or (2) arrange to deprive yourself of the benefit of the
   2.508 +patent license for this particular work, or (3) arrange, in a manner
   2.509 +consistent with the requirements of this License, to extend the patent
   2.510 +license to downstream recipients.  "Knowingly relying" means you have
   2.511 +actual knowledge that, but for the patent license, your conveying the
   2.512 +covered work in a country, or your recipient's use of the covered work
   2.513 +in a country, would infringe one or more identifiable patents in that
   2.514 +country that you have reason to believe are valid.
   2.515 +
   2.516 +  If, pursuant to or in connection with a single transaction or
   2.517 +arrangement, you convey, or propagate by procuring conveyance of, a
   2.518 +covered work, and grant a patent license to some of the parties
   2.519 +receiving the covered work authorizing them to use, propagate, modify
   2.520 +or convey a specific copy of the covered work, then the patent license
   2.521 +you grant is automatically extended to all recipients of the covered
   2.522 +work and works based on it.
   2.523 +
   2.524 +  A patent license is "discriminatory" if it does not include within
   2.525 +the scope of its coverage, prohibits the exercise of, or is
   2.526 +conditioned on the non-exercise of one or more of the rights that are
   2.527 +specifically granted under this License.  You may not convey a covered
   2.528 +work if you are a party to an arrangement with a third party that is
   2.529 +in the business of distributing software, under which you make payment
   2.530 +to the third party based on the extent of your activity of conveying
   2.531 +the work, and under which the third party grants, to any of the
   2.532 +parties who would receive the covered work from you, a discriminatory
   2.533 +patent license (a) in connection with copies of the covered work
   2.534 +conveyed by you (or copies made from those copies), or (b) primarily
   2.535 +for and in connection with specific products or compilations that
   2.536 +contain the covered work, unless you entered into that arrangement,
   2.537 +or that patent license was granted, prior to 28 March 2007.
   2.538 +
   2.539 +  Nothing in this License shall be construed as excluding or limiting
   2.540 +any implied license or other defenses to infringement that may
   2.541 +otherwise be available to you under applicable patent law.
   2.542 +
   2.543 +  12. No Surrender of Others' Freedom.
   2.544 +
   2.545 +  If conditions are imposed on you (whether by court order, agreement or
   2.546 +otherwise) that contradict the conditions of this License, they do not
   2.547 +excuse you from the conditions of this License.  If you cannot convey a
   2.548 +covered work so as to satisfy simultaneously your obligations under this
   2.549 +License and any other pertinent obligations, then as a consequence you may
   2.550 +not convey it at all.  For example, if you agree to terms that obligate you
   2.551 +to collect a royalty for further conveying from those to whom you convey
   2.552 +the Program, the only way you could satisfy both those terms and this
   2.553 +License would be to refrain entirely from conveying the Program.
   2.554 +
   2.555 +  13. Use with the GNU Affero General Public License.
   2.556 +
   2.557 +  Notwithstanding any other provision of this License, you have
   2.558 +permission to link or combine any covered work with a work licensed
   2.559 +under version 3 of the GNU Affero General Public License into a single
   2.560 +combined work, and to convey the resulting work.  The terms of this
   2.561 +License will continue to apply to the part which is the covered work,
   2.562 +but the special requirements of the GNU Affero General Public License,
   2.563 +section 13, concerning interaction through a network will apply to the
   2.564 +combination as such.
   2.565 +
   2.566 +  14. Revised Versions of this License.
   2.567 +
   2.568 +  The Free Software Foundation may publish revised and/or new versions of
   2.569 +the GNU General Public License from time to time.  Such new versions will
   2.570 +be similar in spirit to the present version, but may differ in detail to
   2.571 +address new problems or concerns.
   2.572 +
   2.573 +  Each version is given a distinguishing version number.  If the
   2.574 +Program specifies that a certain numbered version of the GNU General
   2.575 +Public License "or any later version" applies to it, you have the
   2.576 +option of following the terms and conditions either of that numbered
   2.577 +version or of any later version published by the Free Software
   2.578 +Foundation.  If the Program does not specify a version number of the
   2.579 +GNU General Public License, you may choose any version ever published
   2.580 +by the Free Software Foundation.
   2.581 +
   2.582 +  If the Program specifies that a proxy can decide which future
   2.583 +versions of the GNU General Public License can be used, that proxy's
   2.584 +public statement of acceptance of a version permanently authorizes you
   2.585 +to choose that version for the Program.
   2.586 +
   2.587 +  Later license versions may give you additional or different
   2.588 +permissions.  However, no additional obligations are imposed on any
   2.589 +author or copyright holder as a result of your choosing to follow a
   2.590 +later version.
   2.591 +
   2.592 +  15. Disclaimer of Warranty.
   2.593 +
   2.594 +  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
   2.595 +APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
   2.596 +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
   2.597 +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
   2.598 +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   2.599 +PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
   2.600 +IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
   2.601 +ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
   2.602 +
   2.603 +  16. Limitation of Liability.
   2.604 +
   2.605 +  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
   2.606 +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
   2.607 +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
   2.608 +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
   2.609 +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
   2.610 +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
   2.611 +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
   2.612 +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
   2.613 +SUCH DAMAGES.
   2.614 +
   2.615 +  17. Interpretation of Sections 15 and 16.
   2.616 +
   2.617 +  If the disclaimer of warranty and limitation of liability provided
   2.618 +above cannot be given local legal effect according to their terms,
   2.619 +reviewing courts shall apply local law that most closely approximates
   2.620 +an absolute waiver of all civil liability in connection with the
   2.621 +Program, unless a warranty or assumption of liability accompanies a
   2.622 +copy of the Program in return for a fee.
   2.623 +
   2.624 +                     END OF TERMS AND CONDITIONS
   2.625 +
   2.626 +            How to Apply These Terms to Your New Programs
   2.627 +
   2.628 +  If you develop a new program, and you want it to be of the greatest
   2.629 +possible use to the public, the best way to achieve this is to make it
   2.630 +free software which everyone can redistribute and change under these terms.
   2.631 +
   2.632 +  To do so, attach the following notices to the program.  It is safest
   2.633 +to attach them to the start of each source file to most effectively
   2.634 +state the exclusion of warranty; and each file should have at least
   2.635 +the "copyright" line and a pointer to where the full notice is found.
   2.636 +
   2.637 +    <one line to give the program's name and a brief idea of what it does.>
   2.638 +    Copyright (C) <year>  <name of author>
   2.639 +
   2.640 +    This program is free software: you can redistribute it and/or modify
   2.641 +    it under the terms of the GNU General Public License as published by
   2.642 +    the Free Software Foundation, either version 3 of the License, or
   2.643 +    (at your option) any later version.
   2.644 +
   2.645 +    This program is distributed in the hope that it will be useful,
   2.646 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
   2.647 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   2.648 +    GNU General Public License for more details.
   2.649 +
   2.650 +    You should have received a copy of the GNU General Public License
   2.651 +    along with this program.  If not, see <http://www.gnu.org/licenses/>.
   2.652 +
   2.653 +Also add information on how to contact you by electronic and paper mail.
   2.654 +
   2.655 +  If the program does terminal interaction, make it output a short
   2.656 +notice like this when it starts in an interactive mode:
   2.657 +
   2.658 +    <program>  Copyright (C) <year>  <name of author>
   2.659 +    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
   2.660 +    This is free software, and you are welcome to redistribute it
   2.661 +    under certain conditions; type `show c' for details.
   2.662 +
   2.663 +The hypothetical commands `show w' and `show c' should show the appropriate
   2.664 +parts of the General Public License.  Of course, your program's commands
   2.665 +might be different; for a GUI interface, you would use an "about box".
   2.666 +
   2.667 +  You should also get your employer (if you work as a programmer) or school,
   2.668 +if any, to sign a "copyright disclaimer" for the program, if necessary.
   2.669 +For more information on this, and how to apply and follow the GNU GPL, see
   2.670 +<http://www.gnu.org/licenses/>.
   2.671 +
   2.672 +  The GNU General Public License does not permit incorporating your program
   2.673 +into proprietary programs.  If your program is a subroutine library, you
   2.674 +may consider it more useful to permit linking proprietary applications with
   2.675 +the library.  If this is what you want to do, use the GNU Lesser General
   2.676 +Public License instead of this License.  But first, please read
   2.677 +<http://www.gnu.org/philosophy/why-not-lgpl.html>.

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/Makefile	Sun Nov 09 13:03:36 2014 +0200
     3.3 @@ -0,0 +1,50 @@
     3.4 +src = $(wildcard src/*.cc) $(wildcard vmath/*.cc)
     3.5 +csrc = $(wildcard src/*.c) $(wildcard vmath/*.c) $(wildcard anim/*.c)
     3.6 +obj = $(src:.cc=.o) $(csrc:.c=.o)
     3.7 +dep = $(obj:.o=.d)
     3.8 +bin = ray1
     3.9 +
    3.10 +opt = -O3 -march=native
    3.11 +dbg = -g
    3.12 +#prof = -pg
    3.13 +CFLAGS = -pedantic -Wall $(dbg) $(opt) $(prof) -I.
    3.14 +CXXFLAGS = -std=c++11 $(CFLAGS)
    3.15 +LDFLAGS = $(prof) $(libgl) -limago
    3.16 +
    3.17 +ifeq ($(shell uname -s), Darwin)
    3.18 +	# the gcc shipping with Darwin is ancient and doesn't support C++11
    3.19 +	# use clang instead.
    3.20 +	CXX = clang++
    3.21 +	CPP = clang -E
    3.22 +	CXXFLAGS += -stdlib=libc++
    3.23 +	LDFLAGS += -stdlib=libc++
    3.24 +
    3.25 +	libgl = -framework OpenGL -framework GLUT -lGLEW
    3.26 +else
    3.27 +	libgl = -lGL -lGLU -lglut -lGLEW
    3.28 +endif
    3.29 +
    3.30 +ifeq ($(CC), icc)
    3.31 +	libomp = -liomp5
    3.32 +else
    3.33 +	libomp = -lgomp
    3.34 +endif
    3.35 +
    3.36 +$(bin): $(obj)
    3.37 +	$(CXX) -o $@ $(obj) $(LDFLAGS)
    3.38 +
    3.39 +-include $(dep)
    3.40 +
    3.41 +%.d: %.c
    3.42 +	@$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@
    3.43 +
    3.44 +%.d: %.cc
    3.45 +	@$(CPP) $(CXXFLAGS) $< -MM -MT $(@:.d=.o) >$@
    3.46 +
    3.47 +.PHONY: clean
    3.48 +clean:
    3.49 +	rm -f $(obj) $(bin)
    3.50 +
    3.51 +.PHONY: cleandep
    3.52 +cleandep: clean
    3.53 +	rm -f $(dep)

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/README	Sun Nov 09 13:03:36 2014 +0200
     4.3 @@ -0,0 +1,11 @@
     4.4 +To compile just type make. Install a recent version of the g++ compiler,
     4.5 +preferable 4.7, as the code is written according to the recent C++11 standard.
     4.6 +
     4.7 +Copyright 2012 John Tsiombikas <nuclear@member.fsf.org>
     4.8 +You may use, modify, and distribute the program under the terms of the GNU
     4.9 +General Public License version 3, or at your option, any later version published
    4.10 +by the Free Software Foundation. See COPYING for details.
    4.11 +
    4.12 +Dependencies:
    4.13 + - GLUT: http://freeglut.sourceforge.net
    4.14 + - libimago: http://code.google.com/p/libimago

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/anim/anim.c	Sun Nov 09 13:03:36 2014 +0200
     5.3 @@ -0,0 +1,498 @@
     5.4 +#include <stdlib.h>
     5.5 +#include <limits.h>
     5.6 +#include <assert.h>
     5.7 +#include "anim.h"
     5.8 +#include "dynarr.h"
     5.9 +
    5.10 +#define ROT_USE_SLERP
    5.11 +
    5.12 +static void invalidate_cache(struct anm_node *node);
    5.13 +
    5.14 +int anm_init_node(struct anm_node *node)
    5.15 +{
    5.16 +	int i, j;
    5.17 +	static const float defaults[] = {
    5.18 +		0.0f, 0.0f, 0.0f,		/* default position */
    5.19 +		0.0f, 0.0f, 0.0f, 1.0f,	/* default rotation quat */
    5.20 +		1.0f, 1.0f, 1.0f		/* default scale factor */
    5.21 +	};
    5.22 +
    5.23 +	memset(node, 0, sizeof *node);
    5.24 +
    5.25 +	/* initialize thread-local matrix cache */
    5.26 +	pthread_key_create(&node->cache_key, 0);
    5.27 +	pthread_mutex_init(&node->cache_list_lock, 0);
    5.28 +
    5.29 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
    5.30 +		if(anm_init_track(node->tracks + i) == -1) {
    5.31 +			for(j=0; j<i; j++) {
    5.32 +				anm_destroy_track(node->tracks + i);
    5.33 +			}
    5.34 +		}
    5.35 +		anm_set_track_default(node->tracks + i, defaults[i]);
    5.36 +	}
    5.37 +	return 0;
    5.38 +}
    5.39 +
    5.40 +void anm_destroy_node(struct anm_node *node)
    5.41 +{
    5.42 +	int i;
    5.43 +	free(node->name);
    5.44 +
    5.45 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
    5.46 +		anm_destroy_track(node->tracks + i);
    5.47 +	}
    5.48 +
    5.49 +	/* destroy thread-specific cache */
    5.50 +	pthread_key_delete(node->cache_key);
    5.51 +
    5.52 +	while(node->cache_list) {
    5.53 +		struct mat_cache *tmp = node->cache_list;
    5.54 +		node->cache_list = tmp->next;
    5.55 +		free(tmp);
    5.56 +	}
    5.57 +}
    5.58 +
    5.59 +void anm_destroy_node_tree(struct anm_node *tree)
    5.60 +{
    5.61 +	struct anm_node *c, *tmp;
    5.62 +
    5.63 +	if(!tree) return;
    5.64 +
    5.65 +	c = tree->child;
    5.66 +	while(c) {
    5.67 +		tmp = c;
    5.68 +		c = c->next;
    5.69 +
    5.70 +		anm_destroy_node_tree(tmp);
    5.71 +	}
    5.72 +	anm_destroy_node(tree);
    5.73 +}
    5.74 +
    5.75 +struct anm_node *anm_create_node(void)
    5.76 +{
    5.77 +	struct anm_node *n;
    5.78 +
    5.79 +	if((n = malloc(sizeof *n))) {
    5.80 +		if(anm_init_node(n) == -1) {
    5.81 +			free(n);
    5.82 +			return 0;
    5.83 +		}
    5.84 +	}
    5.85 +	return n;
    5.86 +}
    5.87 +
    5.88 +void anm_free_node(struct anm_node *node)
    5.89 +{
    5.90 +	anm_destroy_node(node);
    5.91 +	free(node);
    5.92 +}
    5.93 +
    5.94 +void anm_free_node_tree(struct anm_node *tree)
    5.95 +{
    5.96 +	struct anm_node *c, *tmp;
    5.97 +
    5.98 +	if(!tree) return;
    5.99 +
   5.100 +	c = tree->child;
   5.101 +	while(c) {
   5.102 +		tmp = c;
   5.103 +		c = c->next;
   5.104 +
   5.105 +		anm_free_node_tree(tmp);
   5.106 +	}
   5.107 +
   5.108 +	anm_free_node(tree);
   5.109 +}
   5.110 +
   5.111 +int anm_set_node_name(struct anm_node *node, const char *name)
   5.112 +{
   5.113 +	char *str;
   5.114 +
   5.115 +	if(!(str = malloc(strlen(name) + 1))) {
   5.116 +		return -1;
   5.117 +	}
   5.118 +	strcpy(str, name);
   5.119 +	free(node->name);
   5.120 +	node->name = str;
   5.121 +	return 0;
   5.122 +}
   5.123 +
   5.124 +const char *anm_get_node_name(struct anm_node *node)
   5.125 +{
   5.126 +	return node->name ? node->name : "";
   5.127 +}
   5.128 +
   5.129 +void anm_set_interpolator(struct anm_node *node, enum anm_interpolator in)
   5.130 +{
   5.131 +	int i;
   5.132 +
   5.133 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   5.134 +		anm_set_track_interpolator(node->tracks + i, in);
   5.135 +	}
   5.136 +	invalidate_cache(node);
   5.137 +}
   5.138 +
   5.139 +void anm_set_extrapolator(struct anm_node *node, enum anm_extrapolator ex)
   5.140 +{
   5.141 +	int i;
   5.142 +
   5.143 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   5.144 +		anm_set_track_extrapolator(node->tracks + i, ex);
   5.145 +	}
   5.146 +	invalidate_cache(node);
   5.147 +}
   5.148 +
   5.149 +void anm_link_node(struct anm_node *p, struct anm_node *c)
   5.150 +{
   5.151 +	c->next = p->child;
   5.152 +	p->child = c;
   5.153 +
   5.154 +	c->parent = p;
   5.155 +	invalidate_cache(c);
   5.156 +}
   5.157 +
   5.158 +int anm_unlink_node(struct anm_node *p, struct anm_node *c)
   5.159 +{
   5.160 +	struct anm_node *iter;
   5.161 +
   5.162 +	if(p->child == c) {
   5.163 +		p->child = c->next;
   5.164 +		c->next = 0;
   5.165 +		invalidate_cache(c);
   5.166 +		return 0;
   5.167 +	}
   5.168 +
   5.169 +	iter = p->child;
   5.170 +	while(iter->next) {
   5.171 +		if(iter->next == c) {
   5.172 +			iter->next = c->next;
   5.173 +			c->next = 0;
   5.174 +			invalidate_cache(c);
   5.175 +			return 0;
   5.176 +		}
   5.177 +	}
   5.178 +	return -1;
   5.179 +}
   5.180 +
   5.181 +void anm_set_position(struct anm_node *node, vec3_t pos, anm_time_t tm)
   5.182 +{
   5.183 +	anm_set_value(node->tracks + ANM_TRACK_POS_X, tm, pos.x);
   5.184 +	anm_set_value(node->tracks + ANM_TRACK_POS_Y, tm, pos.y);
   5.185 +	anm_set_value(node->tracks + ANM_TRACK_POS_Z, tm, pos.z);
   5.186 +	invalidate_cache(node);
   5.187 +}
   5.188 +
   5.189 +vec3_t anm_get_node_position(struct anm_node *node, anm_time_t tm)
   5.190 +{
   5.191 +	vec3_t v;
   5.192 +	v.x = anm_get_value(node->tracks + ANM_TRACK_POS_X, tm);
   5.193 +	v.y = anm_get_value(node->tracks + ANM_TRACK_POS_Y, tm);
   5.194 +	v.z = anm_get_value(node->tracks + ANM_TRACK_POS_Z, tm);
   5.195 +	return v;
   5.196 +}
   5.197 +
   5.198 +void anm_set_rotation(struct anm_node *node, quat_t rot, anm_time_t tm)
   5.199 +{
   5.200 +	anm_set_value(node->tracks + ANM_TRACK_ROT_X, tm, rot.x);
   5.201 +	anm_set_value(node->tracks + ANM_TRACK_ROT_Y, tm, rot.y);
   5.202 +	anm_set_value(node->tracks + ANM_TRACK_ROT_Z, tm, rot.z);
   5.203 +	anm_set_value(node->tracks + ANM_TRACK_ROT_W, tm, rot.w);
   5.204 +	invalidate_cache(node);
   5.205 +}
   5.206 +
   5.207 +quat_t anm_get_node_rotation(struct anm_node *node, anm_time_t tm)
   5.208 +{
   5.209 +#ifndef ROT_USE_SLERP
   5.210 +	quat_t q;
   5.211 +	q.x = anm_get_value(node->tracks + ANM_TRACK_ROT_X, tm);
   5.212 +	q.y = anm_get_value(node->tracks + ANM_TRACK_ROT_Y, tm);
   5.213 +	q.z = anm_get_value(node->tracks + ANM_TRACK_ROT_Z, tm);
   5.214 +	q.w = anm_get_value(node->tracks + ANM_TRACK_ROT_W, tm);
   5.215 +	return q;
   5.216 +#else
   5.217 +	int idx0, idx1, last_idx;
   5.218 +	anm_time_t tstart, tend;
   5.219 +	float t, dt;
   5.220 +	struct anm_track *track_x, *track_y, *track_z, *track_w;
   5.221 +	quat_t q, q1, q2;
   5.222 +
   5.223 +	track_x = node->tracks + ANM_TRACK_ROT_X;
   5.224 +	track_y = node->tracks + ANM_TRACK_ROT_Y;
   5.225 +	track_z = node->tracks + ANM_TRACK_ROT_Z;
   5.226 +	track_w = node->tracks + ANM_TRACK_ROT_W;
   5.227 +
   5.228 +	if(!track_x->count) {
   5.229 +		q.x = track_x->def_val;
   5.230 +		q.y = track_y->def_val;
   5.231 +		q.z = track_z->def_val;
   5.232 +		q.w = track_w->def_val;
   5.233 +		return q;
   5.234 +	}
   5.235 +
   5.236 +	last_idx = track_x->count - 1;
   5.237 +
   5.238 +	tstart = track_x->keys[0].time;
   5.239 +	tend = track_x->keys[last_idx].time;
   5.240 +
   5.241 +	if(tstart == tend) {
   5.242 +		q.x = track_x->keys[0].val;
   5.243 +		q.y = track_y->keys[0].val;
   5.244 +		q.z = track_z->keys[0].val;
   5.245 +		q.w = track_w->keys[0].val;
   5.246 +		return q;
   5.247 +	}
   5.248 +
   5.249 +	tm = anm_remap_time(track_x, tm, tstart, tend);
   5.250 +
   5.251 +	idx0 = anm_get_key_interval(track_x, tm);
   5.252 +	assert(idx0 >= 0 && idx0 < track_x->count);
   5.253 +	idx1 = idx0 + 1;
   5.254 +
   5.255 +	if(idx0 == last_idx) {
   5.256 +		q.x = track_x->keys[idx0].val;
   5.257 +		q.y = track_y->keys[idx0].val;
   5.258 +		q.z = track_z->keys[idx0].val;
   5.259 +		q.w = track_w->keys[idx0].val;
   5.260 +		return q;
   5.261 +	}
   5.262 +
   5.263 +	dt = (float)(track_x->keys[idx1].time - track_x->keys[idx0].time);
   5.264 +	t = (float)(tm - track_x->keys[idx0].time) / dt;
   5.265 +
   5.266 +	q1.x = track_x->keys[idx0].val;
   5.267 +	q1.y = track_y->keys[idx0].val;
   5.268 +	q1.z = track_z->keys[idx0].val;
   5.269 +	q1.w = track_w->keys[idx0].val;
   5.270 +
   5.271 +	q2.x = track_x->keys[idx1].val;
   5.272 +	q2.y = track_y->keys[idx1].val;
   5.273 +	q2.z = track_z->keys[idx1].val;
   5.274 +	q2.w = track_w->keys[idx1].val;
   5.275 +
   5.276 +	/*q1 = quat_normalize(q1);
   5.277 +	q2 = quat_normalize(q2);*/
   5.278 +
   5.279 +	return quat_slerp(q1, q2, t);
   5.280 +#endif
   5.281 +}
   5.282 +
   5.283 +void anm_set_scaling(struct anm_node *node, vec3_t scl, anm_time_t tm)
   5.284 +{
   5.285 +	anm_set_value(node->tracks + ANM_TRACK_SCL_X, tm, scl.x);
   5.286 +	anm_set_value(node->tracks + ANM_TRACK_SCL_Y, tm, scl.y);
   5.287 +	anm_set_value(node->tracks + ANM_TRACK_SCL_Z, tm, scl.z);
   5.288 +	invalidate_cache(node);
   5.289 +}
   5.290 +
   5.291 +vec3_t anm_get_node_scaling(struct anm_node *node, anm_time_t tm)
   5.292 +{
   5.293 +	vec3_t v;
   5.294 +	v.x = anm_get_value(node->tracks + ANM_TRACK_SCL_X, tm);
   5.295 +	v.y = anm_get_value(node->tracks + ANM_TRACK_SCL_Y, tm);
   5.296 +	v.z = anm_get_value(node->tracks + ANM_TRACK_SCL_Z, tm);
   5.297 +	return v;
   5.298 +}
   5.299 +
   5.300 +
   5.301 +vec3_t anm_get_position(struct anm_node *node, anm_time_t tm)
   5.302 +{
   5.303 +	mat4_t xform;
   5.304 +	vec3_t pos = {0.0, 0.0, 0.0};
   5.305 +
   5.306 +	if(!node->parent) {
   5.307 +		return anm_get_node_position(node, tm);
   5.308 +	}
   5.309 +
   5.310 +	anm_get_matrix(node, xform, tm);
   5.311 +	return v3_transform(pos, xform);
   5.312 +}
   5.313 +
   5.314 +quat_t anm_get_rotation(struct anm_node *node, anm_time_t tm)
   5.315 +{
   5.316 +	quat_t rot, prot;
   5.317 +	rot = anm_get_node_rotation(node, tm);
   5.318 +
   5.319 +	if(!node->parent) {
   5.320 +		return rot;
   5.321 +	}
   5.322 +
   5.323 +	prot = anm_get_rotation(node->parent, tm);
   5.324 +	return quat_mul(prot, rot);
   5.325 +}
   5.326 +
   5.327 +vec3_t anm_get_scaling(struct anm_node *node, anm_time_t tm)
   5.328 +{
   5.329 +	vec3_t s, ps;
   5.330 +	s = anm_get_node_scaling(node, tm);
   5.331 +
   5.332 +	if(!node->parent) {
   5.333 +		return s;
   5.334 +	}
   5.335 +
   5.336 +	ps = anm_get_scaling(node->parent, tm);
   5.337 +	return v3_mul(s, ps);
   5.338 +}
   5.339 +
   5.340 +void anm_set_pivot(struct anm_node *node, vec3_t piv)
   5.341 +{
   5.342 +	node->pivot = piv;
   5.343 +}
   5.344 +
   5.345 +vec3_t anm_get_pivot(struct anm_node *node)
   5.346 +{
   5.347 +	return node->pivot;
   5.348 +}
   5.349 +
   5.350 +void anm_get_node_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   5.351 +{
   5.352 +	int i;
   5.353 +	mat4_t rmat;
   5.354 +	vec3_t pos, scale;
   5.355 +	quat_t rot;
   5.356 +
   5.357 +	pos = anm_get_node_position(node, tm);
   5.358 +	rot = anm_get_node_rotation(node, tm);
   5.359 +	scale = anm_get_node_scaling(node, tm);
   5.360 +
   5.361 +	m4_set_translation(mat, node->pivot.x, node->pivot.y, node->pivot.z);
   5.362 +
   5.363 +	quat_to_mat4(rmat, rot);
   5.364 +	for(i=0; i<3; i++) {
   5.365 +		mat[i][0] = rmat[i][0];
   5.366 +		mat[i][1] = rmat[i][1];
   5.367 +		mat[i][2] = rmat[i][2];
   5.368 +	}
   5.369 +	/* this loop is equivalent to: m4_mult(mat, mat, rmat); */
   5.370 +
   5.371 +	mat[0][0] *= scale.x; mat[0][1] *= scale.y; mat[0][2] *= scale.z; mat[0][3] += pos.x;
   5.372 +	mat[1][0] *= scale.x; mat[1][1] *= scale.y; mat[1][2] *= scale.z; mat[1][3] += pos.y;
   5.373 +	mat[2][0] *= scale.x; mat[2][1] *= scale.y; mat[2][2] *= scale.z; mat[2][3] += pos.z;
   5.374 +
   5.375 +	m4_translate(mat, -node->pivot.x, -node->pivot.y, -node->pivot.z);
   5.376 +
   5.377 +	/* that's basically: pivot * rotation * translation * scaling * -pivot */
   5.378 +}
   5.379 +
   5.380 +void anm_get_node_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   5.381 +{
   5.382 +	mat4_t tmp;
   5.383 +	anm_get_node_matrix(node, tmp, tm);
   5.384 +	m4_inverse(mat, tmp);
   5.385 +}
   5.386 +
   5.387 +void anm_get_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   5.388 +{
   5.389 +	struct mat_cache *cache = pthread_getspecific(node->cache_key);
   5.390 +	if(!cache) {
   5.391 +		cache = malloc(sizeof *cache);
   5.392 +		assert(cache);
   5.393 +
   5.394 +		pthread_mutex_lock(&node->cache_list_lock);
   5.395 +		cache->next = node->cache_list;
   5.396 +		node->cache_list = cache;
   5.397 +		pthread_mutex_unlock(&node->cache_list_lock);
   5.398 +
   5.399 +		cache->time = ANM_TIME_INVAL;
   5.400 +		cache->inv_time = ANM_TIME_INVAL;
   5.401 +		pthread_setspecific(node->cache_key, cache);
   5.402 +	}
   5.403 +
   5.404 +	if(cache->time != tm) {
   5.405 +		anm_get_node_matrix(node, cache->matrix, tm);
   5.406 +
   5.407 +		if(node->parent) {
   5.408 +			mat4_t parent_mat;
   5.409 +
   5.410 +			anm_get_matrix(node->parent, parent_mat, tm);
   5.411 +			m4_mult(cache->matrix, parent_mat, cache->matrix);
   5.412 +		}
   5.413 +		cache->time = tm;
   5.414 +	}
   5.415 +	m4_copy(mat, cache->matrix);
   5.416 +}
   5.417 +
   5.418 +void anm_get_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   5.419 +{
   5.420 +	struct mat_cache *cache = pthread_getspecific(node->cache_key);
   5.421 +	if(!cache) {
   5.422 +		cache = malloc(sizeof *cache);
   5.423 +		assert(cache);
   5.424 +
   5.425 +		pthread_mutex_lock(&node->cache_list_lock);
   5.426 +		cache->next = node->cache_list;
   5.427 +		node->cache_list = cache;
   5.428 +		pthread_mutex_unlock(&node->cache_list_lock);
   5.429 +
   5.430 +		cache->inv_time = ANM_TIME_INVAL;
   5.431 +		cache->inv_time = ANM_TIME_INVAL;
   5.432 +		pthread_setspecific(node->cache_key, cache);
   5.433 +	}
   5.434 +
   5.435 +	if(cache->inv_time != tm) {
   5.436 +		anm_get_matrix(node, mat, tm);
   5.437 +		m4_inverse(cache->inv_matrix, mat);
   5.438 +		cache->inv_time = tm;
   5.439 +	}
   5.440 +	m4_copy(mat, cache->inv_matrix);
   5.441 +}
   5.442 +
   5.443 +anm_time_t anm_get_start_time(struct anm_node *node)
   5.444 +{
   5.445 +	int i;
   5.446 +	struct anm_node *c;
   5.447 +	anm_time_t res = LONG_MAX;
   5.448 +
   5.449 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   5.450 +		if(node->tracks[i].count) {
   5.451 +			anm_time_t tm = node->tracks[i].keys[0].time;
   5.452 +			if(tm < res) {
   5.453 +				res = tm;
   5.454 +			}
   5.455 +		}
   5.456 +	}
   5.457 +
   5.458 +	c = node->child;
   5.459 +	while(c) {
   5.460 +		anm_time_t tm = anm_get_start_time(c);
   5.461 +		if(tm < res) {
   5.462 +			res = tm;
   5.463 +		}
   5.464 +		c = c->next;
   5.465 +	}
   5.466 +	return res;
   5.467 +}
   5.468 +
   5.469 +anm_time_t anm_get_end_time(struct anm_node *node)
   5.470 +{
   5.471 +	int i;
   5.472 +	struct anm_node *c;
   5.473 +	anm_time_t res = LONG_MIN;
   5.474 +
   5.475 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   5.476 +		if(node->tracks[i].count) {
   5.477 +			anm_time_t tm = node->tracks[i].keys[node->tracks[i].count - 1].time;
   5.478 +			if(tm > res) {
   5.479 +				res = tm;
   5.480 +			}
   5.481 +		}
   5.482 +	}
   5.483 +
   5.484 +	c = node->child;
   5.485 +	while(c) {
   5.486 +		anm_time_t tm = anm_get_end_time(c);
   5.487 +		if(tm > res) {
   5.488 +			res = tm;
   5.489 +		}
   5.490 +		c = c->next;
   5.491 +	}
   5.492 +	return res;
   5.493 +}
   5.494 +
   5.495 +static void invalidate_cache(struct anm_node *node)
   5.496 +{
   5.497 +	struct mat_cache *cache = pthread_getspecific(node->cache_key);
   5.498 +	if(cache) {
   5.499 +	   cache->time = cache->inv_time = ANM_TIME_INVAL;
   5.500 +	}
   5.501 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/anim/anim.h	Sun Nov 09 13:03:36 2014 +0200
     6.3 @@ -0,0 +1,117 @@
     6.4 +#ifndef LIBANIM_H_
     6.5 +#define LIBANIM_H_
     6.6 +
     6.7 +#include "config.h"
     6.8 +
     6.9 +#include <pthread.h>
    6.10 +
    6.11 +#include <vmath/vector.h>
    6.12 +#include <vmath/quat.h>
    6.13 +#include <vmath/matrix.h>
    6.14 +#include "track.h"
    6.15 +
    6.16 +enum {
    6.17 +	ANM_TRACK_POS_X,
    6.18 +	ANM_TRACK_POS_Y,
    6.19 +	ANM_TRACK_POS_Z,
    6.20 +
    6.21 +	ANM_TRACK_ROT_X,
    6.22 +	ANM_TRACK_ROT_Y,
    6.23 +	ANM_TRACK_ROT_Z,
    6.24 +	ANM_TRACK_ROT_W,
    6.25 +
    6.26 +	ANM_TRACK_SCL_X,
    6.27 +	ANM_TRACK_SCL_Y,
    6.28 +	ANM_TRACK_SCL_Z,
    6.29 +
    6.30 +	ANM_NUM_TRACKS
    6.31 +};
    6.32 +
    6.33 +struct anm_node {
    6.34 +	char *name;
    6.35 +
    6.36 +	struct anm_track tracks[ANM_NUM_TRACKS];
    6.37 +	vec3_t pivot;
    6.38 +
    6.39 +	/* matrix cache */
    6.40 +	struct mat_cache {
    6.41 +		mat4_t matrix, inv_matrix;
    6.42 +		anm_time_t time, inv_time;
    6.43 +		struct mat_cache *next;
    6.44 +	} *cache_list;
    6.45 +	pthread_key_t cache_key;
    6.46 +	pthread_mutex_t cache_list_lock;
    6.47 +
    6.48 +	struct anm_node *parent;
    6.49 +	struct anm_node *child;
    6.50 +	struct anm_node *next;
    6.51 +};
    6.52 +
    6.53 +#ifdef __cplusplus
    6.54 +extern "C" {
    6.55 +#endif
    6.56 +
    6.57 +/* node constructor and destructor */
    6.58 +int anm_init_node(struct anm_node *node);
    6.59 +void anm_destroy_node(struct anm_node *node);
    6.60 +
    6.61 +/* recursively destroy an animation node tree */
    6.62 +void anm_destroy_node_tree(struct anm_node *tree);
    6.63 +
    6.64 +/* helper functions to allocate/construct and destroy/free with
    6.65 + * a single call. They call anm_init_node and anm_destroy_node
    6.66 + * internally.
    6.67 + */
    6.68 +struct anm_node *anm_create_node(void);
    6.69 +void anm_free_node(struct anm_node *node);
    6.70 +
    6.71 +/* recursively destroy and free the nodes of a node tree */
    6.72 +void anm_free_node_tree(struct anm_node *tree);
    6.73 +
    6.74 +int anm_set_node_name(struct anm_node *node, const char *name);
    6.75 +const char *anm_get_node_name(struct anm_node *node);
    6.76 +
    6.77 +void anm_set_interpolator(struct anm_node *node, enum anm_interpolator in);
    6.78 +void anm_set_extrapolator(struct anm_node *node, enum anm_extrapolator ex);
    6.79 +
    6.80 +/* link and unlink nodes with parent/child relations */
    6.81 +void anm_link_node(struct anm_node *parent, struct anm_node *child);
    6.82 +int anm_unlink_node(struct anm_node *parent, struct anm_node *child);
    6.83 +
    6.84 +void anm_set_position(struct anm_node *node, vec3_t pos, anm_time_t tm);
    6.85 +vec3_t anm_get_node_position(struct anm_node *node, anm_time_t tm);
    6.86 +
    6.87 +void anm_set_rotation(struct anm_node *node, quat_t rot, anm_time_t tm);
    6.88 +quat_t anm_get_node_rotation(struct anm_node *node, anm_time_t tm);
    6.89 +
    6.90 +void anm_set_scaling(struct anm_node *node, vec3_t scl, anm_time_t tm);
    6.91 +vec3_t anm_get_node_scaling(struct anm_node *node, anm_time_t tm);
    6.92 +
    6.93 +/* these three return the full p/r/s taking hierarchy into account */
    6.94 +vec3_t anm_get_position(struct anm_node *node, anm_time_t tm);
    6.95 +quat_t anm_get_rotation(struct anm_node *node, anm_time_t tm);
    6.96 +vec3_t anm_get_scaling(struct anm_node *node, anm_time_t tm);
    6.97 +
    6.98 +void anm_set_pivot(struct anm_node *node, vec3_t pivot);
    6.99 +vec3_t anm_get_pivot(struct anm_node *node);
   6.100 +
   6.101 +/* these calculate the matrix and inverse matrix of this node alone */
   6.102 +void anm_get_node_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   6.103 +void anm_get_node_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   6.104 +
   6.105 +/* These calculate the matrix and inverse matrix of this node taking hierarchy
   6.106 + * into account. The results are cached in thread-specific storage and returned
   6.107 + * if there's no change in time or tracks from the last query...
   6.108 + */
   6.109 +void anm_get_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   6.110 +void anm_get_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   6.111 +
   6.112 +/* those return the start and end times of the whole tree */
   6.113 +anm_time_t anm_get_start_time(struct anm_node *node);
   6.114 +anm_time_t anm_get_end_time(struct anm_node *node);
   6.115 +
   6.116 +#ifdef __cplusplus
   6.117 +}
   6.118 +#endif
   6.119 +
   6.120 +#endif	/* LIBANIM_H_ */

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/anim/config.h	Sun Nov 09 13:03:36 2014 +0200
     7.3 @@ -0,0 +1,6 @@
     7.4 +#ifndef ANIM_CONFIG_H_
     7.5 +#define ANIM_CONFIG_H_
     7.6 +
     7.7 +#undef ANIM_THREAD_SAFE
     7.8 +
     7.9 +#endif	/* ANIM_CONFIG_H_ */

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/anim/dynarr.c	Sun Nov 09 13:03:36 2014 +0200
     8.3 @@ -0,0 +1,122 @@
     8.4 +#include <stdio.h>
     8.5 +#include <stdlib.h>
     8.6 +#include <string.h>
     8.7 +#include "dynarr.h"
     8.8 +
     8.9 +/* The array descriptor keeps auxilliary information needed to manipulate
    8.10 + * the dynamic array. It's allocated adjacent to the array buffer.
    8.11 + */
    8.12 +struct arrdesc {
    8.13 +	int nelem, szelem;
    8.14 +	int max_elem;
    8.15 +	int bufsz;	/* not including the descriptor */
    8.16 +};
    8.17 +
    8.18 +#define DESC(x)		((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc)))
    8.19 +
    8.20 +void *dynarr_alloc(int elem, int szelem)
    8.21 +{
    8.22 +	struct arrdesc *desc;
    8.23 +
    8.24 +	if(!(desc = malloc(elem * szelem + sizeof *desc))) {
    8.25 +		return 0;
    8.26 +	}
    8.27 +	desc->nelem = desc->max_elem = elem;
    8.28 +	desc->szelem = szelem;
    8.29 +	desc->bufsz = elem * szelem;
    8.30 +	return (char*)desc + sizeof *desc;
    8.31 +}
    8.32 +
    8.33 +void dynarr_free(void *da)
    8.34 +{
    8.35 +	if(da) {
    8.36 +		free(DESC(da));
    8.37 +	}
    8.38 +}
    8.39 +
    8.40 +void *dynarr_resize(void *da, int elem)
    8.41 +{
    8.42 +	int newsz;
    8.43 +	void *tmp;
    8.44 +	struct arrdesc *desc;
    8.45 +
    8.46 +	if(!da) return 0;
    8.47 +	desc = DESC(da);
    8.48 +
    8.49 +	newsz = desc->szelem * elem;
    8.50 +
    8.51 +	if(!(tmp = realloc(desc, newsz + sizeof *desc))) {
    8.52 +		return 0;
    8.53 +	}
    8.54 +	desc = tmp;
    8.55 +
    8.56 +	desc->nelem = desc->max_elem = elem;
    8.57 +	desc->bufsz = newsz;
    8.58 +	return (char*)desc + sizeof *desc;
    8.59 +}
    8.60 +
    8.61 +int dynarr_empty(void *da)
    8.62 +{
    8.63 +	return DESC(da)->nelem ? 0 : 1;
    8.64 +}
    8.65 +
    8.66 +int dynarr_size(void *da)
    8.67 +{
    8.68 +	return DESC(da)->nelem;
    8.69 +}
    8.70 +
    8.71 +
    8.72 +/* stack semantics */
    8.73 +void *dynarr_push(void *da, void *item)
    8.74 +{
    8.75 +	struct arrdesc *desc;
    8.76 +	int nelem;
    8.77 +
    8.78 +	desc = DESC(da);
    8.79 +	nelem = desc->nelem;
    8.80 +
    8.81 +	if(nelem >= desc->max_elem) {
    8.82 +		/* need to resize */
    8.83 +		struct arrdesc *tmp;
    8.84 +		int newsz = desc->max_elem ? desc->max_elem * 2 : 1;
    8.85 +
    8.86 +		if(!(tmp = dynarr_resize(da, newsz))) {
    8.87 +			fprintf(stderr, "failed to resize\n");
    8.88 +			return da;
    8.89 +		}
    8.90 +		da = tmp;
    8.91 +		desc = DESC(da);
    8.92 +		desc->nelem = nelem;
    8.93 +	}
    8.94 +
    8.95 +	memcpy((char*)da + desc->nelem++ * desc->szelem, item, desc->szelem);
    8.96 +	return da;
    8.97 +}
    8.98 +
    8.99 +void *dynarr_pop(void *da)
   8.100 +{
   8.101 +	struct arrdesc *desc;
   8.102 +	int nelem;
   8.103 +
   8.104 +	desc = DESC(da);
   8.105 +	nelem = desc->nelem;
   8.106 +
   8.107 +	if(!nelem) return da;
   8.108 +
   8.109 +	if(nelem <= desc->max_elem / 3) {
   8.110 +		/* reclaim space */
   8.111 +		struct arrdesc *tmp;
   8.112 +		int newsz = desc->max_elem / 2;
   8.113 +
   8.114 +		if(!(tmp = dynarr_resize(da, newsz))) {
   8.115 +			fprintf(stderr, "failed to resize\n");
   8.116 +			return da;
   8.117 +		}
   8.118 +		da = tmp;
   8.119 +		desc = DESC(da);
   8.120 +		desc->nelem = nelem;
   8.121 +	}
   8.122 +	desc->nelem--;
   8.123 +
   8.124 +	return da;
   8.125 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/anim/dynarr.h	Sun Nov 09 13:03:36 2014 +0200
     9.3 @@ -0,0 +1,16 @@
     9.4 +#ifndef DYNARR_H_
     9.5 +#define DYNARR_H_
     9.6 +
     9.7 +void *dynarr_alloc(int elem, int szelem);
     9.8 +void dynarr_free(void *da);
     9.9 +void *dynarr_resize(void *da, int elem);
    9.10 +
    9.11 +int dynarr_empty(void *da);
    9.12 +int dynarr_size(void *da);
    9.13 +
    9.14 +/* stack semantics */
    9.15 +void *dynarr_push(void *da, void *item);
    9.16 +void *dynarr_pop(void *da);
    9.17 +
    9.18 +
    9.19 +#endif	/* DYNARR_H_ */

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/anim/track.c	Sun Nov 09 13:03:36 2014 +0200
    10.3 @@ -0,0 +1,316 @@
    10.4 +#include <stdlib.h>
    10.5 +#include <string.h>
    10.6 +#include <assert.h>
    10.7 +#include "track.h"
    10.8 +#include "dynarr.h"
    10.9 +
   10.10 +static int keycmp(const void *a, const void *b);
   10.11 +static int find_prev_key(struct anm_keyframe *arr, int start, int end, anm_time_t tm);
   10.12 +
   10.13 +static float interp_step(float v0, float v1, float v2, float v3, float t);
   10.14 +static float interp_linear(float v0, float v1, float v2, float v3, float t);
   10.15 +static float interp_cubic(float v0, float v1, float v2, float v3, float t);
   10.16 +
   10.17 +static anm_time_t remap_extend(anm_time_t tm, anm_time_t start, anm_time_t end);
   10.18 +static anm_time_t remap_clamp(anm_time_t tm, anm_time_t start, anm_time_t end);
   10.19 +static anm_time_t remap_repeat(anm_time_t tm, anm_time_t start, anm_time_t end);
   10.20 +static anm_time_t remap_pingpong(anm_time_t tm, anm_time_t start, anm_time_t end);
   10.21 +
   10.22 +/* XXX keep this in sync with enum anm_interpolator at track.h */
   10.23 +static float (*interp[])(float, float, float, float, float) = {
   10.24 +	interp_step,
   10.25 +	interp_linear,
   10.26 +	interp_cubic,
   10.27 +	0
   10.28 +};
   10.29 +
   10.30 +/* XXX keep this in sync with enum anm_extrapolator at track.h */
   10.31 +static anm_time_t (*remap_time[])(anm_time_t, anm_time_t, anm_time_t) = {
   10.32 +	remap_extend,
   10.33 +	remap_clamp,
   10.34 +	remap_repeat,
   10.35 +	remap_pingpong,
   10.36 +	0
   10.37 +};
   10.38 +
   10.39 +int anm_init_track(struct anm_track *track)
   10.40 +{
   10.41 +	memset(track, 0, sizeof *track);
   10.42 +
   10.43 +	if(!(track->keys = dynarr_alloc(0, sizeof *track->keys))) {
   10.44 +		return -1;
   10.45 +	}
   10.46 +	track->interp = ANM_INTERP_LINEAR;
   10.47 +	track->extrap = ANM_EXTRAP_CLAMP;
   10.48 +	return 0;
   10.49 +}
   10.50 +
   10.51 +void anm_destroy_track(struct anm_track *track)
   10.52 +{
   10.53 +	dynarr_free(track->keys);
   10.54 +}
   10.55 +
   10.56 +struct anm_track *anm_create_track(void)
   10.57 +{
   10.58 +	struct anm_track *track;
   10.59 +
   10.60 +	if((track = malloc(sizeof *track))) {
   10.61 +		if(anm_init_track(track) == -1) {
   10.62 +			free(track);
   10.63 +			return 0;
   10.64 +		}
   10.65 +	}
   10.66 +	return track;
   10.67 +}
   10.68 +
   10.69 +void anm_free_track(struct anm_track *track)
   10.70 +{
   10.71 +	anm_destroy_track(track);
   10.72 +	free(track);
   10.73 +}
   10.74 +
   10.75 +void anm_copy_track(struct anm_track *dest, struct anm_track *src)
   10.76 +{
   10.77 +	free(dest->name);
   10.78 +	if(dest->keys) {
   10.79 +		dynarr_free(dest->keys);
   10.80 +	}
   10.81 +
   10.82 +	if(src->name) {
   10.83 +		dest->name = malloc(strlen(src->name) + 1);
   10.84 +		strcpy(dest->name, src->name);
   10.85 +	}
   10.86 +
   10.87 +	dest->count = src->count;
   10.88 +	dest->keys = dynarr_alloc(src->count, sizeof *dest->keys);
   10.89 +	memcpy(dest->keys, src->keys, src->count * sizeof *dest->keys);
   10.90 +
   10.91 +	dest->def_val = src->def_val;
   10.92 +	dest->interp = src->interp;
   10.93 +	dest->extrap = src->extrap;
   10.94 +}
   10.95 +
   10.96 +int anm_set_track_name(struct anm_track *track, const char *name)
   10.97 +{
   10.98 +	char *tmp;
   10.99 +
  10.100 +	if(!(tmp = malloc(strlen(name) + 1))) {
  10.101 +		return -1;
  10.102 +	}
  10.103 +	free(track->name);
  10.104 +	track->name = tmp;
  10.105 +	return 0;
  10.106 +}
  10.107 +
  10.108 +const char *anm_get_track_name(struct anm_track *track)
  10.109 +{
  10.110 +	return track->name;
  10.111 +}
  10.112 +
  10.113 +void anm_set_track_interpolator(struct anm_track *track, enum anm_interpolator in)
  10.114 +{
  10.115 +	track->interp = in;
  10.116 +}
  10.117 +
  10.118 +void anm_set_track_extrapolator(struct anm_track *track, enum anm_extrapolator ex)
  10.119 +{
  10.120 +	track->extrap = ex;
  10.121 +}
  10.122 +
  10.123 +anm_time_t anm_remap_time(struct anm_track *track, anm_time_t tm, anm_time_t start, anm_time_t end)
  10.124 +{
  10.125 +	return remap_time[track->extrap](tm, start, end);
  10.126 +}
  10.127 +
  10.128 +void anm_set_track_default(struct anm_track *track, float def)
  10.129 +{
  10.130 +	track->def_val = def;
  10.131 +}
  10.132 +
  10.133 +int anm_set_keyframe(struct anm_track *track, struct anm_keyframe *key)
  10.134 +{
  10.135 +	int idx = anm_get_key_interval(track, key->time);
  10.136 +
  10.137 +	/* if we got a valid keyframe index, compare them... */
  10.138 +	if(idx >= 0 && idx < track->count && keycmp(key, track->keys + idx) == 0) {
  10.139 +		/* ... it's the same key, just update the value */
  10.140 +		track->keys[idx].val = key->val;
  10.141 +	} else {
  10.142 +		/* ... it's a new key, add it and re-sort them */
  10.143 +		void *tmp;
  10.144 +		if(!(tmp = dynarr_push(track->keys, key))) {
  10.145 +			return -1;
  10.146 +		}
  10.147 +		track->keys = tmp;
  10.148 +		/* TODO lazy qsort */
  10.149 +		qsort(track->keys, ++track->count, sizeof *track->keys, keycmp);
  10.150 +	}
  10.151 +	return 0;
  10.152 +}
  10.153 +
  10.154 +static int keycmp(const void *a, const void *b)
  10.155 +{
  10.156 +	return ((struct anm_keyframe*)a)->time - ((struct anm_keyframe*)b)->time;
  10.157 +}
  10.158 +
  10.159 +struct anm_keyframe *anm_get_keyframe(struct anm_track *track, int idx)
  10.160 +{
  10.161 +	if(idx < 0 || idx >= track->count) {
  10.162 +		return 0;
  10.163 +	}
  10.164 +	return track->keys + idx;
  10.165 +}
  10.166 +
  10.167 +int anm_get_key_interval(struct anm_track *track, anm_time_t tm)
  10.168 +{
  10.169 +	int last;
  10.170 +
  10.171 +	if(!track->count || tm < track->keys[0].time) {
  10.172 +		return -1;
  10.173 +	}
  10.174 +
  10.175 +	last = track->count - 1;
  10.176 +	if(tm > track->keys[last].time) {
  10.177 +		return last;
  10.178 +	}
  10.179 +
  10.180 +	return find_prev_key(track->keys, 0, last, tm);
  10.181 +}
  10.182 +
  10.183 +static int find_prev_key(struct anm_keyframe *arr, int start, int end, anm_time_t tm)
  10.184 +{
  10.185 +	int mid;
  10.186 +
  10.187 +	if(end - start <= 1) {
  10.188 +		return start;
  10.189 +	}
  10.190 +
  10.191 +	mid = (start + end) / 2;
  10.192 +	if(tm < arr[mid].time) {
  10.193 +		return find_prev_key(arr, start, mid, tm);
  10.194 +	}
  10.195 +	if(tm > arr[mid].time) {
  10.196 +		return find_prev_key(arr, mid, end, tm);
  10.197 +	}
  10.198 +	return mid;
  10.199 +}
  10.200 +
  10.201 +int anm_set_value(struct anm_track *track, anm_time_t tm, float val)
  10.202 +{
  10.203 +	struct anm_keyframe key;
  10.204 +	key.time = tm;
  10.205 +	key.val = val;
  10.206 +
  10.207 +	return anm_set_keyframe(track, &key);
  10.208 +}
  10.209 +
  10.210 +float anm_get_value(struct anm_track *track, anm_time_t tm)
  10.211 +{
  10.212 +	int idx0, idx1, last_idx;
  10.213 +	anm_time_t tstart, tend;
  10.214 +	float t, dt;
  10.215 +	float v0, v1, v2, v3;
  10.216 +
  10.217 +	if(!track->count) {
  10.218 +		return track->def_val;
  10.219 +	}
  10.220 +
  10.221 +	last_idx = track->count - 1;
  10.222 +
  10.223 +	tstart = track->keys[0].time;
  10.224 +	tend = track->keys[last_idx].time;
  10.225 +
  10.226 +	if(tstart == tend) {
  10.227 +		return track->keys[0].val;
  10.228 +	}
  10.229 +
  10.230 +	tm = remap_time[track->extrap](tm, tstart, tend);
  10.231 +
  10.232 +	idx0 = anm_get_key_interval(track, tm);
  10.233 +	assert(idx0 >= 0 && idx0 < track->count);
  10.234 +	idx1 = idx0 + 1;
  10.235 +
  10.236 +	if(idx0 == last_idx) {
  10.237 +		return track->keys[idx0].val;
  10.238 +	}
  10.239 +
  10.240 +	dt = (float)(track->keys[idx1].time - track->keys[idx0].time);
  10.241 +	t = (float)(tm - track->keys[idx0].time) / dt;
  10.242 +
  10.243 +	v1 = track->keys[idx0].val;
  10.244 +	v2 = track->keys[idx1].val;
  10.245 +
  10.246 +	/* get the neigboring values to allow for cubic interpolation */
  10.247 +	v0 = idx0 > 0 ? track->keys[idx0 - 1].val : v1;
  10.248 +	v3 = idx1 < last_idx ? track->keys[idx1 + 1].val : v2;
  10.249 +
  10.250 +	return interp[track->interp](v0, v1, v2, v3, t);
  10.251 +}
  10.252 +
  10.253 +
  10.254 +static float interp_step(float v0, float v1, float v2, float v3, float t)
  10.255 +{
  10.256 +	return v1;
  10.257 +}
  10.258 +
  10.259 +static float interp_linear(float v0, float v1, float v2, float v3, float t)
  10.260 +{
  10.261 +	return v1 + (v2 - v1) * t;
  10.262 +}
  10.263 +
  10.264 +static float interp_cubic(float a, float b, float c, float d, float t)
  10.265 +{
  10.266 +	float x, y, z, w;
  10.267 +	float tsq = t * t;
  10.268 +
  10.269 +	x = -a + 3.0 * b - 3.0 * c + d;
  10.270 +	y = 2.0 * a - 5.0 * b + 4.0 * c - d;
  10.271 +	z = c - a;
  10.272 +	w = 2.0 * b;
  10.273 +
  10.274 +	return 0.5 * (x * tsq * t + y * tsq + z * t + w);
  10.275 +}
  10.276 +
  10.277 +static anm_time_t remap_extend(anm_time_t tm, anm_time_t start, anm_time_t end)
  10.278 +{
  10.279 +	return remap_repeat(tm, start, end);
  10.280 +}
  10.281 +
  10.282 +static anm_time_t remap_clamp(anm_time_t tm, anm_time_t start, anm_time_t end)
  10.283 +{
  10.284 +	if(start == end) {
  10.285 +		return start;
  10.286 +	}
  10.287 +	return tm < start ? start : (tm >= end ? end - 1 : tm);
  10.288 +}
  10.289 +
  10.290 +static anm_time_t remap_repeat(anm_time_t tm, anm_time_t start, anm_time_t end)
  10.291 +{
  10.292 +	anm_time_t x, interv = end - start;
  10.293 +
  10.294 +	if(interv == 0) {
  10.295 +		return start;
  10.296 +	}
  10.297 +
  10.298 +	x = (tm - start) % interv;
  10.299 +	if(x < 0) {
  10.300 +		x += interv;
  10.301 +	}
  10.302 +	return x + start;
  10.303 +
  10.304 +	/*if(tm < start) {
  10.305 +		while(tm < start) {
  10.306 +			tm += interv;
  10.307 +		}
  10.308 +		return tm;
  10.309 +	}
  10.310 +	return (tm - start) % interv + start;*/
  10.311 +}
  10.312 +
  10.313 +static anm_time_t remap_pingpong(anm_time_t tm, anm_time_t start, anm_time_t end)
  10.314 +{
  10.315 +	anm_time_t interv = end - start;
  10.316 +	anm_time_t x = remap_repeat(tm, start, end + interv);
  10.317 +
  10.318 +	return x > end ? end + interv - x : x;
  10.319 +}

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/anim/track.h	Sun Nov 09 13:03:36 2014 +0200
    11.3 @@ -0,0 +1,101 @@
    11.4 +/* An animation track defines the values of a single scalar over time
    11.5 + * and supports various interpolation and extrapolation modes.
    11.6 + */
    11.7 +#ifndef LIBANIM_TRACK_H_
    11.8 +#define LIBANIM_TRACK_H_
    11.9 +
   11.10 +#include <limits.h>
   11.11 +#include "config.h"
   11.12 +
   11.13 +enum anm_interpolator {
   11.14 +	ANM_INTERP_STEP,
   11.15 +	ANM_INTERP_LINEAR,
   11.16 +	ANM_INTERP_CUBIC
   11.17 +};
   11.18 +
   11.19 +enum anm_extrapolator {
   11.20 +	ANM_EXTRAP_EXTEND,	/* extend to infinity */
   11.21 +	ANM_EXTRAP_CLAMP,	/* clamp to last value */
   11.22 +	ANM_EXTRAP_REPEAT,	/* repeat motion */
   11.23 +	ANM_EXTRAP_PINGPONG	/* repeat with mirroring */
   11.24 +};
   11.25 +
   11.26 +typedef long anm_time_t;
   11.27 +#define ANM_TIME_INVAL	LONG_MIN
   11.28 +
   11.29 +#define ANM_SEC2TM(x)	((anm_time_t)((x) * 1000))
   11.30 +#define ANM_MSEC2TM(x)	((anm_time_t)(x))
   11.31 +#define ANM_TM2SEC(x)	((x) / 1000.0)
   11.32 +#define ANM_TM2MSEC(x)	(x)
   11.33 +
   11.34 +struct anm_keyframe {
   11.35 +	anm_time_t time;
   11.36 +	float val;
   11.37 +};
   11.38 +
   11.39 +struct anm_track {
   11.40 +	char *name;
   11.41 +	int count;
   11.42 +	struct anm_keyframe *keys;
   11.43 +
   11.44 +	float def_val;
   11.45 +
   11.46 +	enum anm_interpolator interp;
   11.47 +	enum anm_extrapolator extrap;
   11.48 +};
   11.49 +
   11.50 +#ifdef __cplusplus
   11.51 +extern "C" {
   11.52 +#endif
   11.53 +
   11.54 +/* track constructor and destructor */
   11.55 +int anm_init_track(struct anm_track *track);
   11.56 +void anm_destroy_track(struct anm_track *track);
   11.57 +
   11.58 +/* helper functions that use anm_init_track and anm_destroy_track internally */
   11.59 +struct anm_track *anm_create_track(void);
   11.60 +void anm_free_track(struct anm_track *track);
   11.61 +
   11.62 +/* copies track src to dest
   11.63 + * XXX: dest must have been initialized first
   11.64 + */
   11.65 +void anm_copy_track(struct anm_track *dest, struct anm_track *src);
   11.66 +
   11.67 +int anm_set_track_name(struct anm_track *track, const char *name);
   11.68 +const char *anm_get_track_name(struct anm_track *track);
   11.69 +
   11.70 +void anm_set_track_interpolator(struct anm_track *track, enum anm_interpolator in);
   11.71 +void anm_set_track_extrapolator(struct anm_track *track, enum anm_extrapolator ex);
   11.72 +
   11.73 +anm_time_t anm_remap_time(struct anm_track *track, anm_time_t tm, anm_time_t start, anm_time_t end);
   11.74 +
   11.75 +void anm_set_track_default(struct anm_track *track, float def);
   11.76 +
   11.77 +/* set or update a keyframe */
   11.78 +int anm_set_keyframe(struct anm_track *track, struct anm_keyframe *key);
   11.79 +
   11.80 +/* get the idx-th keyframe, returns null if it doesn't exist */
   11.81 +struct anm_keyframe *anm_get_keyframe(struct anm_track *track, int idx);
   11.82 +
   11.83 +/* Finds the 0-based index of the intra-keyframe interval which corresponds
   11.84 + * to the specified time. If the time falls exactly onto the N-th keyframe
   11.85 + * the function returns N.
   11.86 + *
   11.87 + * Special cases:
   11.88 + * - if the time is before the first keyframe -1 is returned.
   11.89 + * - if the time is after the last keyframe, the index of the last keyframe
   11.90 + *   is returned.
   11.91 + */
   11.92 +int anm_get_key_interval(struct anm_track *track, anm_time_t tm);
   11.93 +
   11.94 +int anm_set_value(struct anm_track *track, anm_time_t tm, float val);
   11.95 +
   11.96 +/* evaluates and returns the value of the track for a particular time */
   11.97 +float anm_get_value(struct anm_track *track, anm_time_t tm);
   11.98 +
   11.99 +#ifdef __cplusplus
  11.100 +}
  11.101 +#endif
  11.102 +
  11.103 +
  11.104 +#endif	/* LIBANIM_TRACK_H_ */

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/sdr/postsdr.glsl	Sun Nov 09 13:03:36 2014 +0200
    12.3 @@ -0,0 +1,9 @@
    12.4 +uniform sampler2D fb;
    12.5 +
    12.6 +void main()
    12.7 +{
    12.8 +	vec4 pixel = texture2D(fb, gl_TexCoord[0].st);
    12.9 +
   12.10 +	gl_FragColor.rgb = pow(pixel.rgb, vec3(1.0 / 2.2));
   12.11 +	gl_FragColor.a = pixel.a;
   12.12 +}

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/sdr/rt.glsl	Sun Nov 09 13:03:36 2014 +0200
    13.3 @@ -0,0 +1,523 @@
    13.4 +/* vi:set filetype=glsl ts=4 sw=4: */
    13.5 +#version 120
    13.6 +#extension GL_ARB_gpu_shader5 : enable
    13.7 +
    13.8 +#define M_PI	3.1415926
    13.9 +
   13.10 +#define INIT_EVERYTHING
   13.11 +#define USE_XFORM
   13.12 +#define OBJ_LINE_WIDTH	16.0
   13.13 +
   13.14 +struct Ray {
   13.15 +	vec3 origin, dir;
   13.16 +};
   13.17 +
   13.18 +struct Material {
   13.19 +	vec3 diffuse, specular;
   13.20 +	float shininess;
   13.21 +	vec4 megatex_rect;
   13.22 +	float reflectivity;
   13.23 +};
   13.24 +
   13.25 +struct HitPoint {
   13.26 +	float dist;
   13.27 +	vec3 pos, normal;
   13.28 +	vec2 texcoord;
   13.29 +	struct Material mat;
   13.30 +};
   13.31 +
   13.32 +struct Sphere {
   13.33 +	float index;
   13.34 +	vec3 pos;
   13.35 +	float radius;
   13.36 +	struct Material mat;
   13.37 +};
   13.38 +
   13.39 +struct Plane {
   13.40 +	float index;
   13.41 +	vec3 normal;
   13.42 +	float dist;
   13.43 +	struct Material mat;
   13.44 +};
   13.45 +
   13.46 +struct Box {
   13.47 +	float index;
   13.48 +	vec3 min, max;
   13.49 +	struct Material mat;
   13.50 +};
   13.51 +
   13.52 +struct Light {
   13.53 +	vec3 pos, color;
   13.54 +};
   13.55 +
   13.56 +vec3 shade(in Ray ray, in HitPoint hit);
   13.57 +bool find_intersection(in Ray ray, out HitPoint hit);
   13.58 +bool sphere_intersect(in Sphere sph, in Ray ray, out HitPoint pt);
   13.59 +bool plane_intersect(in Plane plane, in Ray ray, out HitPoint pt);
   13.60 +bool box_intersect(in Box box, in Ray ray, out HitPoint pt);
   13.61 +vec3 transform(in vec3 v, in mat4 inv_xform);
   13.62 +Ray transform(in Ray ray, in mat4 xform, in mat4 inv_xform);
   13.63 +Ray get_primary_ray();
   13.64 +
   13.65 +Sphere read_sphere(in float idx);
   13.66 +Plane read_plane(in float idx);
   13.67 +Box read_box(in float idx);
   13.68 +Material read_material(in sampler2D tex, in float ty);
   13.69 +void read_xform(in float idx, out mat4 xform, out mat4 inv_xform);
   13.70 +
   13.71 +uniform sampler2D tex_raydir;
   13.72 +uniform sampler2D tex_spheres, tex_planes, tex_boxes;
   13.73 +uniform sampler2D tex_megatex;
   13.74 +uniform sampler2D tex_xforms;
   13.75 +uniform samplerCube tex_env;
   13.76 +uniform vec2 fog;
   13.77 +
   13.78 +uniform Light lights[8];
   13.79 +uniform int num_lights;
   13.80 +
   13.81 +int num_spheres, num_planes, num_boxes;
   13.82 +float sph_tex_sz, plane_tex_sz, box_tex_sz, xform_tex_sz;
   13.83 +
   13.84 +#ifdef INIT_EVERYTHING
   13.85 +Material default_material;
   13.86 +#endif
   13.87 +
   13.88 +void main()
   13.89 +{
   13.90 +#ifdef INIT_EVERYTHING
   13.91 +	default_material.diffuse = default_material.specular = vec3(0.0, 0.0, 0.0);
   13.92 +	default_material.shininess = 1.0;
   13.93 +	default_material.reflectivity = 0.0;
   13.94 +	default_material.megatex_rect = vec4(0.0, 0.0, 0.0, 0.0);
   13.95 +#endif
   13.96 +
   13.97 +	Ray ray = get_primary_ray();
   13.98 +
   13.99 +	/* read the various descriptors specifying dimensions and counts for
  13.100 +	 * all the relevant data textures
  13.101 +	 */
  13.102 +	vec4 desc = texture2D(tex_spheres, vec2(0.0, 0.0));
  13.103 +	num_spheres = int(desc.x);
  13.104 +	sph_tex_sz = desc.y;
  13.105 +
  13.106 +	desc = texture2D(tex_planes, vec2(0.0, 0.0));
  13.107 +	num_planes = int(desc.x);
  13.108 +	plane_tex_sz = desc.y;
  13.109 +
  13.110 +	desc = texture2D(tex_boxes, vec2(0.0, 0.0));
  13.111 +	num_boxes = int(desc.x);
  13.112 +	box_tex_sz = desc.y;
  13.113 +
  13.114 +	xform_tex_sz = texture2D(tex_xforms, vec2(0.0, 0.0)).x;
  13.115 +
  13.116 +
  13.117 +	HitPoint hit;
  13.118 +#ifdef INIT_EVERYTHING
  13.119 +	hit.dist = 0.0;
  13.120 +	hit.pos = hit.normal = vec3(0.0, 0.0, 0.0);
  13.121 +#endif
  13.122 +
  13.123 +	vec3 color = vec3(0.0, 0.0, 0.0);
  13.124 +	float energy = 1.0;
  13.125 +
  13.126 +	int iter = 0;
  13.127 +	while(energy > 0.01 && iter++ < 4) {
  13.128 +		vec3 envcol = textureCube(tex_env, ray.dir).xyz;
  13.129 +
  13.130 +		if(find_intersection(ray, hit)) {
  13.131 +			float fog_t = clamp((hit.dist - fog.x) / (fog.y - fog.x), 0.0, 1.0);
  13.132 +			color += mix(shade(ray, hit), envcol, fog_t) * energy;
  13.133 +			energy *= hit.mat.reflectivity * (1.0 - fog_t);
  13.134 +			ray.origin = hit.pos;
  13.135 +			ray.dir = reflect(ray.dir, hit.normal);
  13.136 +		} else {
  13.137 +			color += envcol * energy;
  13.138 +			energy = 0.0;
  13.139 +			iter = 100;
  13.140 +		}
  13.141 +	}
  13.142 +
  13.143 +	gl_FragColor.xyz = color;
  13.144 +	gl_FragColor.w = 1.0;
  13.145 +}
  13.146 +
  13.147 +vec3 shade(in Ray ray, in HitPoint hit)
  13.148 +{
  13.149 +	vec3 normal = faceforward(hit.normal, ray.dir, hit.normal);
  13.150 +
  13.151 +	vec3 vdir = normalize(ray.dir);
  13.152 +	vec3 vref = reflect(vdir, normal);
  13.153 +
  13.154 +	/* if there's no texture rect.zw will be (0, 0, 0, 0) so this will map onto
  13.155 +	 * the top-left 1x1 null texture which is all white (having no effect)
  13.156 +	 */
  13.157 +	vec2 tc = mod(hit.texcoord, vec2(1.0, 1.0)) * hit.mat.megatex_rect.zw + hit.mat.megatex_rect.xy;
  13.158 +
  13.159 +	vec3 diffuse_color = hit.mat.diffuse * texture2D(tex_megatex, tc).xyz;
  13.160 +
  13.161 +	vec3 color = vec3(0.0, 0.0, 0.0);
  13.162 +	for(int i=0; i<num_lights; i++) {
  13.163 +		Ray shadow_ray;
  13.164 +		shadow_ray.origin = hit.pos;
  13.165 +		shadow_ray.dir = lights[i].pos - hit.pos;
  13.166 +
  13.167 +		HitPoint shadow_hit;
  13.168 +		if(!find_intersection(shadow_ray, shadow_hit) || shadow_hit.dist > 1.0) {
  13.169 +			vec3 ldir = normalize(shadow_ray.dir);
  13.170 +
  13.171 +			float diffuse = max(dot(ldir, normal), 0.0);
  13.172 +			float specular = pow(max(dot(ldir, vref), 0.0), hit.mat.shininess);
  13.173 +
  13.174 +			color += (diffuse_color * diffuse + hit.mat.specular * specular) * lights[i].color;
  13.175 +		}
  13.176 +	}
  13.177 +
  13.178 +	return color;
  13.179 +}
  13.180 +
  13.181 +bool find_intersection(in Ray ray, out HitPoint hit)
  13.182 +{
  13.183 +	hit.dist = 100000.0;
  13.184 +#ifdef INIT_EVERYTHING
  13.185 +	hit.pos = hit.normal = vec3(0.0, 0.0, 0.0);
  13.186 +	hit.mat = default_material;
  13.187 +	hit.texcoord = vec2(0.0, 0.0);
  13.188 +#endif
  13.189 +	bool found = false;
  13.190 +
  13.191 +	for(int i=0; i<num_spheres; i++) {
  13.192 +		Sphere sph = read_sphere(i);
  13.193 +
  13.194 +		HitPoint tmphit;
  13.195 +		if(sphere_intersect(sph, ray, tmphit) && tmphit.dist < hit.dist) {
  13.196 +			hit = tmphit;
  13.197 +			found = true;
  13.198 +		}
  13.199 +	}
  13.200 +
  13.201 +	for(int i=0; i<num_planes; i++) {
  13.202 +		Plane plane = read_plane(i);
  13.203 +
  13.204 +		HitPoint tmphit;
  13.205 +		if(plane_intersect(plane, ray, tmphit) && tmphit.dist < hit.dist) {
  13.206 +			hit = tmphit;
  13.207 +			found = true;
  13.208 +		}
  13.209 +	}
  13.210 +
  13.211 +	for(int i=0; i<num_boxes; i++) {
  13.212 +		Box box = read_box(i);
  13.213 +
  13.214 +		HitPoint tmphit;
  13.215 +		if(box_intersect(box, ray, tmphit) && tmphit.dist < hit.dist) {
  13.216 +			hit = tmphit;
  13.217 +			found = true;
  13.218 +		}
  13.219 +	}
  13.220 +
  13.221 +	return found;
  13.222 +}
  13.223 +
  13.224 +#define EPSILON	1e-4
  13.225 +#define SQ(x)	((x) * (x))
  13.226 +
  13.227 +bool sphere_intersect(in Sphere sph, in Ray inray, out HitPoint pt)
  13.228 +{
  13.229 +#ifdef USE_XFORM
  13.230 +	mat4 xform, inv_xform;
  13.231 +	read_xform(sph.index, xform, inv_xform);
  13.232 +
  13.233 +	Ray ray = transform(inray, inv_xform, xform);
  13.234 +#else
  13.235 +	Ray ray = inray;
  13.236 +#endif
  13.237 +
  13.238 +#ifdef INIT_EVERYTHING
  13.239 +	pt.dist = 0.0;
  13.240 +	pt.pos = pt.normal = vec3(0.0, 0.0, 0.0);
  13.241 +	pt.mat = default_material;
  13.242 +	pt.texcoord = vec2(0.0, 0.0);
  13.243 +#endif
  13.244 +
  13.245 +	float a = dot(ray.dir, ray.dir);
  13.246 +	float b = dot(ray.dir, ray.origin - sph.pos) * 2.0;
  13.247 +	float c = dot(ray.origin, ray.origin) + dot(sph.pos, sph.pos) -
  13.248 +		2.0 * dot(ray.origin, sph.pos) - sph.radius * sph.radius;
  13.249 +
  13.250 +	float discr = b * b - 4.0 * a * c;
  13.251 +	if(discr < EPSILON)
  13.252 +		return false;
  13.253 +
  13.254 +	float sqrt_discr = sqrt(discr);
  13.255 +	float t0 = (-b + sqrt_discr) / (2.0 * a);
  13.256 +	float t1 = (-b - sqrt_discr) / (2.0 * a);
  13.257 +
  13.258 +	if(t0 < EPSILON)
  13.259 +		t0 = t1;
  13.260 +	if(t1 < EPSILON)
  13.261 +		t1 = t0;
  13.262 +
  13.263 +	float t = min(t0, t1);
  13.264 +	if(t < EPSILON)
  13.265 +		return false;
  13.266 +
  13.267 +	// fill the HitPoint structure
  13.268 +	pt.dist = t;
  13.269 +	pt.pos = ray.origin + ray.dir * t;
  13.270 +	pt.normal = (pt.pos - sph.pos) / sph.radius;
  13.271 +	pt.mat = sph.mat;
  13.272 +
  13.273 +	pt.texcoord.x = 0.5 * atan(pt.normal.z, pt.normal.x) / M_PI + 0.5;
  13.274 +	pt.texcoord.y = acos(pt.normal.y) / M_PI;
  13.275 +
  13.276 +#ifdef USE_XFORM
  13.277 +	pt.pos = (xform * vec4(pt.pos, 1.0)).xyz;
  13.278 +	pt.normal = normalize(transform(pt.normal, xform));
  13.279 +#endif
  13.280 +	return true;
  13.281 +}
  13.282 +
  13.283 +bool plane_intersect(in Plane plane, in Ray inray, out HitPoint pt)
  13.284 +{
  13.285 +#ifdef USE_XFORM
  13.286 +	mat4 xform, inv_xform;
  13.287 +	read_xform(plane.index, xform, inv_xform);
  13.288 +
  13.289 +	Ray ray = transform(inray, inv_xform, xform);
  13.290 +#else
  13.291 +	Ray ray = inray;
  13.292 +#endif
  13.293 +
  13.294 +#ifdef INIT_EVERYTHING
  13.295 +	pt.dist = 0.0;
  13.296 +	pt.pos = pt.normal = vec3(0.0, 0.0, 0.0);
  13.297 +	pt.mat = default_material;
  13.298 +	pt.texcoord = vec2(0.0, 0.0);
  13.299 +#endif
  13.300 +
  13.301 +	float ndotdir = dot(plane.normal, ray.dir);
  13.302 +	if(abs(ndotdir) < EPSILON) {
  13.303 +		return false;
  13.304 +	}
  13.305 +
  13.306 +	vec3 planept = plane.normal * plane.dist;
  13.307 +	vec3 pptdir = planept - ray.origin;
  13.308 +
  13.309 +	float t = dot(plane.normal, pptdir) / ndotdir;
  13.310 +	if(t < EPSILON) {
  13.311 +		return false;
  13.312 +	}
  13.313 +
  13.314 +	pt.dist = t;
  13.315 +	pt.pos = ray.origin + ray.dir * t;
  13.316 +	pt.normal = plane.normal;
  13.317 +	pt.mat = plane.mat;
  13.318 +	pt.texcoord.x = pt.pos.x;
  13.319 +	pt.texcoord.y = pt.pos.z;
  13.320 +
  13.321 +#ifdef USE_XFORM
  13.322 +	pt.pos = (xform * vec4(pt.pos, 1.0)).xyz;
  13.323 +	pt.normal = normalize(transform(pt.normal, xform));
  13.324 +#endif
  13.325 +	return true;
  13.326 +}
  13.327 +
  13.328 +bool box_intersect(in Box box, in Ray inray, out HitPoint pt)
  13.329 +{
  13.330 +#ifdef USE_XFORM
  13.331 +	mat4 xform, inv_xform;
  13.332 +	read_xform(box.index, xform, inv_xform);
  13.333 +
  13.334 +	Ray ray = transform(inray, inv_xform, xform);
  13.335 +#else
  13.336 +	Ray ray = inray;
  13.337 +#endif
  13.338 +
  13.339 +#ifdef INIT_EVERYTHING
  13.340 +	pt.dist = 0.0;
  13.341 +	pt.pos = pt.normal = vec3(0.0, 0.0, 0.0);
  13.342 +	pt.mat = default_material;
  13.343 +	pt.texcoord = vec2(0.0, 0.0);
  13.344 +#endif
  13.345 +
  13.346 +	vec3 param[2];
  13.347 +	param[0] = box.min;
  13.348 +	param[1] = box.max;
  13.349 +
  13.350 +	vec3 inv_dir = 1.0 / ray.dir;
  13.351 +	int sgn[3];
  13.352 +	sgn[0] = inv_dir.x < 0.0 ? 1 : 0;
  13.353 +	sgn[1] = inv_dir.y < 0.0 ? 1 : 0;
  13.354 +	sgn[2] = inv_dir.z < 0.0 ? 1 : 0;
  13.355 +
  13.356 +	float tmin = (param[sgn[0]].x - ray.origin.x) * inv_dir.x;
  13.357 +	float tmax = (param[1 - sgn[0]].x - ray.origin.x) * inv_dir.x;
  13.358 +	float tymin = (param[sgn[1]].y - ray.origin.y) * inv_dir.y;
  13.359 +	float tymax = (param[1 - sgn[1]].y - ray.origin.y) * inv_dir.y;
  13.360 +
  13.361 +	pt.normal = vec3(ray.origin.x > 0.0 ? 1.0 : -1.0, 0.0, 0.0);
  13.362 +
  13.363 +	if(tmin > tymax || tymin > tmax) {
  13.364 +		return false;
  13.365 +	}
  13.366 +	if(tymin > tmin) {
  13.367 +		pt.normal = vec3(0.0, ray.origin.y > 0.0 ? 1.0 : -1.0, 0.0);
  13.368 +		tmin = tymin;
  13.369 +	}
  13.370 +	if(tymax < tmax) {
  13.371 +		tmax = tymax;
  13.372 +	}
  13.373 +
  13.374 +	float tzmin = (param[sgn[2]].z - ray.origin.z) * inv_dir.z;
  13.375 +	float tzmax = (param[1 - sgn[2]].z - ray.origin.z) * inv_dir.z;
  13.376 +
  13.377 +	if(tmin > tzmax || tzmin > tmax) {
  13.378 +		return false;
  13.379 +	}
  13.380 +	if(tzmin > tmin) {
  13.381 +		pt.normal = vec3(0.0, 0.0, ray.origin.z > 0.0 ? 1.0 : -1.0);
  13.382 +		tmin = tzmin;
  13.383 +	}
  13.384 +	if(tzmax < tmax) {
  13.385 +		tmax = tzmax;
  13.386 +	}
  13.387 +
  13.388 +	float t = tmin < EPSILON ? tmax : tmin;
  13.389 +	if(t >= 1e-4) {
  13.390 +		pt.dist = t;
  13.391 +		pt.pos = ray.origin + ray.dir * t;
  13.392 +		pt.mat = box.mat;
  13.393 +
  13.394 +		float min_dist = 10000.0;
  13.395 +
  13.396 +		vec3 offs = box.min + (box.max - box.min) / 2.0;
  13.397 +		vec3 local_pt = pt.pos - offs;
  13.398 +
  13.399 +		vec3 dist = abs((box.max - offs) - abs(local_pt));
  13.400 +		if(dist.x < min_dist) {
  13.401 +			min_dist = dist.x;
  13.402 +			pt.normal = sign(local_pt.x) * vec3(1.0, 0.0, 0.0);
  13.403 +			pt.texcoord = pt.pos.zy;
  13.404 +		}
  13.405 +		if(dist.y < min_dist) {
  13.406 +			min_dist = dist.y;
  13.407 +			pt.normal = sign(local_pt.y) * vec3(0.0, 1.0, 0.0);
  13.408 +			pt.texcoord = pt.pos.xz;
  13.409 +		}
  13.410 +		if(dist.z < min_dist) {
  13.411 +			pt.normal = sign(local_pt.y) * vec3(0.0, 0.0, 1.0);
  13.412 +			pt.texcoord = pt.pos.xy;
  13.413 +		}
  13.414 +
  13.415 +
  13.416 +#ifdef USE_XFORM
  13.417 +		pt.pos = (xform * vec4(pt.pos, 1.0)).xyz;
  13.418 +		pt.normal = normalize(transform(pt.normal, xform));
  13.419 +#endif
  13.420 +		return true;
  13.421 +	}
  13.422 +	return false;
  13.423 +}
  13.424 +
  13.425 +vec3 transform(in vec3 v, in mat4 xform)
  13.426 +{
  13.427 +	return mat3(xform) * v;
  13.428 +}
  13.429 +
  13.430 +Ray transform(in Ray ray, in mat4 xform, in mat4 inv_xform)
  13.431 +{
  13.432 +	Ray res;
  13.433 +	res.origin = (xform * vec4(ray.origin, 1.0)).xyz;
  13.434 +	res.dir = transform(ray.dir, xform);
  13.435 +	return res;
  13.436 +}
  13.437 +
  13.438 +Ray get_primary_ray()
  13.439 +{
  13.440 +	Ray ray;
  13.441 +	ray.origin = (gl_ModelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
  13.442 +	vec3 dir = texture2D(tex_raydir, gl_TexCoord[0].st).xyz;
  13.443 +	ray.dir = normalize(gl_NormalMatrix * dir);
  13.444 +	return ray;
  13.445 +}
  13.446 +
  13.447 +#define ITEM(x)	((float(x) + 0.5) / OBJ_LINE_WIDTH)
  13.448 +
  13.449 +Sphere read_sphere(in float idx)
  13.450 +{
  13.451 +	Sphere sph;
  13.452 +	// +1 because the first scanline is the descriptor
  13.453 +	float ty = (idx + 1.0) / sph_tex_sz;
  13.454 +
  13.455 +	sph.index = texture2D(tex_spheres, vec2(ITEM(0), ty)).x;
  13.456 +
  13.457 +	vec4 texel = texture2D(tex_spheres, vec2(ITEM(1), ty));
  13.458 +	sph.pos = texel.xyz;
  13.459 +	sph.radius = texel.w;
  13.460 +
  13.461 +	sph.mat = read_material(tex_spheres, ty);
  13.462 +	return sph;
  13.463 +}
  13.464 +
  13.465 +Plane read_plane(in float idx)
  13.466 +{
  13.467 +	Plane plane;
  13.468 +	// +1 (see above)
  13.469 +	float ty = (idx + 1.0) / plane_tex_sz;
  13.470 +
  13.471 +	plane.index = texture2D(tex_planes, vec2(ITEM(0), ty)).x;
  13.472 +
  13.473 +	vec4 texel = texture2D(tex_planes, vec2(ITEM(1), ty));
  13.474 +	plane.normal = texel.xyz;
  13.475 +	plane.dist = texel.w;
  13.476 +
  13.477 +	plane.mat = read_material(tex_planes, ty);
  13.478 +	return plane;
  13.479 +}
  13.480 +
  13.481 +Box read_box(in float idx)
  13.482 +{
  13.483 +	Box box;
  13.484 +	float ty = (idx + 1.0) / box_tex_sz;
  13.485 +
  13.486 +	box.index = texture2D(tex_boxes, vec2(ITEM(0), ty)).x;
  13.487 +
  13.488 +	box.min = texture2D(tex_boxes, vec2(ITEM(1), ty)).xyz;
  13.489 +	box.max = texture2D(tex_boxes, vec2(ITEM(2), ty)).xyz;
  13.490 +
  13.491 +	box.mat = read_material(tex_boxes, ty);
  13.492 +	return box;
  13.493 +}
  13.494 +
  13.495 +void read_xform(in float idx, out mat4 xform, out mat4 inv_xform)
  13.496 +{
  13.497 +	float ty = (idx + 1.0) / xform_tex_sz;
  13.498 +
  13.499 +	for(int i=0; i<4; i++) {
  13.500 +		xform[i] = texture2D(tex_xforms, vec2(ITEM(i), ty));
  13.501 +	}
  13.502 +	inv_xform = inverse(xform);
  13.503 +	/*for(int i=0; i<4; i++) {
  13.504 +		inv_xform[i] = texture2D(tex_xforms, vec2(ITEM(float(i) + 4.0), ty));
  13.505 +	}*/
  13.506 +}
  13.507 +
  13.508 +#define MAT_START	4
  13.509 +Material read_material(in sampler2D tex, in float ty)
  13.510 +{
  13.511 +	Material mat;
  13.512 +
  13.513 +	vec4 texel = texture2D(tex, vec2(ITEM(MAT_START), ty));
  13.514 +	mat.diffuse = texel.xyz;
  13.515 +
  13.516 +	texel = texture2D(tex, vec2(ITEM(MAT_START + 1), ty));
  13.517 +	mat.specular = texel.xyz;
  13.518 +	mat.shininess = texel.w;
  13.519 +
  13.520 +	texel = texture2D(tex, vec2(ITEM(MAT_START + 2), ty));
  13.521 +	mat.reflectivity = texel.x;
  13.522 +
  13.523 +	mat.megatex_rect = texture2D(tex, vec2(ITEM(MAT_START + 3), ty));
  13.524 +
  13.525 +	return mat;
  13.526 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/sdr/vertex.glsl	Sun Nov 09 13:03:36 2014 +0200
    14.3 @@ -0,0 +1,6 @@
    14.4 +void main()
    14.5 +{
    14.6 +	gl_Position = gl_Vertex;
    14.7 +	gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
    14.8 +	gl_TexCoord[1] = gl_MultiTexCoord0;
    14.9 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/src/box.cc	Sun Nov 09 13:03:36 2014 +0200
    15.3 @@ -0,0 +1,63 @@
    15.4 +#include "box.h"
    15.5 +
    15.6 +Box::Box()
    15.7 +	: min(-0.5, -0.5, -0.5), max(0.5, 0.5, 0.5)
    15.8 +{
    15.9 +}
   15.10 +
   15.11 +Box::Box(const Vector3 &min_arg, const Vector3 &max_arg)
   15.12 +	: min(min_arg), max(max_arg)
   15.13 +{
   15.14 +}
   15.15 +
   15.16 +bool Box::intersect(const Ray &inray, HitPoint *pt) const
   15.17 +{
   15.18 +	Ray ray = inray.transformed(inv_xform);
   15.19 +
   15.20 +	Vector3 param[2] = {min, max};
   15.21 +	Vector3 inv_dir(1.0 / ray.dir.x, 1.0 / ray.dir.y, 1.0 / ray.dir.z);
   15.22 +	int sign[3] = {inv_dir.x < 0, inv_dir.y < 0, inv_dir.z < 0};
   15.23 +
   15.24 +	float tmin = (param[sign[0]].x - ray.origin.x) * inv_dir.x;
   15.25 +	float tmax = (param[1 - sign[0]].x - ray.origin.x) * inv_dir.x;
   15.26 +	float tymin = (param[sign[1]].y - ray.origin.y) * inv_dir.y;
   15.27 +	float tymax = (param[1 - sign[1]].y - ray.origin.y) * inv_dir.y;
   15.28 +
   15.29 +	pt->normal = Vector3(ray.origin.x > 0.0 ? 1 : -1, 0, 0);
   15.30 +
   15.31 +	if(tmin > tymax || tymin > tmax) {
   15.32 +		return false;
   15.33 +	}
   15.34 +	if(tymin > tmin) {
   15.35 +		pt->normal = Vector3(0, ray.origin.y > 0.0 ? 1 : -1, 0);
   15.36 +		tmin = tymin;
   15.37 +	}
   15.38 +	if(tymax < tmax) {
   15.39 +		tmax = tymax;
   15.40 +	}
   15.41 +
   15.42 +	float tzmin = (param[sign[2]].z - ray.origin.z) * inv_dir.z;
   15.43 +	float tzmax = (param[1 - sign[2]].z - ray.origin.z) * inv_dir.z;
   15.44 +
   15.45 +	if(tmin > tzmax || tzmin > tmax) {
   15.46 +		return false;
   15.47 +	}
   15.48 +	if(tzmin > tmin) {
   15.49 +		pt->normal = Vector3(0, 0, ray.origin.z > 0.0 ? 1 : -1);
   15.50 +		tmin = tzmin;
   15.51 +	}
   15.52 +	if(tzmax < tmax) {
   15.53 +		tmax = tzmax;
   15.54 +	}
   15.55 +
   15.56 +	float t = tmin < 1e-4 ? tmax : tmin;
   15.57 +	if(t >= 1e-4) {
   15.58 +		pt->obj = this;
   15.59 +		pt->dist = t;
   15.60 +		pt->pos = ray.origin + ray.dir * t;
   15.61 +		pt->pos.transform(xform);
   15.62 +		pt->normal.transform(dir_xform);
   15.63 +		return true;
   15.64 +	}
   15.65 +	return false;
   15.66 +}

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/src/box.h	Sun Nov 09 13:03:36 2014 +0200
    16.3 @@ -0,0 +1,17 @@
    16.4 +#ifndef BOX_H_
    16.5 +#define BOX_H_
    16.6 +
    16.7 +#include "vmath/vmath.h"
    16.8 +#include "object.h"
    16.9 +
   16.10 +class Box : public Object {
   16.11 +public:
   16.12 +	Vector3 min, max;
   16.13 +
   16.14 +	Box();
   16.15 +	Box(const Vector3 &min, const Vector3 &max);
   16.16 +
   16.17 +	bool intersect(const Ray &ray, HitPoint *pt) const;
   16.18 +};
   16.19 +
   16.20 +#endif	// BOX_H_

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/src/camera.cc	Sun Nov 09 13:03:36 2014 +0200
    17.3 @@ -0,0 +1,199 @@
    17.4 +#include <stdio.h>
    17.5 +#include <math.h>
    17.6 +#include "camera.h"
    17.7 +
    17.8 +static void calc_sample_pos_rec(int sidx, float xsz, float ysz, float *pos);
    17.9 +
   17.10 +Camera::Camera()
   17.11 +{
   17.12 +	vfov = M_PI / 4.0;
   17.13 +	cached_matrix_valid = false;
   17.14 +
   17.15 +	rdir_cache_width = rdir_cache_height = 0;
   17.16 +	rdir_cache = 0;
   17.17 +}
   17.18 +
   17.19 +Camera::Camera(const Vector3 &p)
   17.20 +	: pos(p)
   17.21 +{
   17.22 +	vfov = M_PI / 4.0;
   17.23 +	cached_matrix_valid = false;
   17.24 +
   17.25 +	rdir_cache_width = rdir_cache_height = 0;
   17.26 +	rdir_cache = 0;
   17.27 +}
   17.28 +
   17.29 +Camera::~Camera()
   17.30 +{
   17.31 +	delete [] rdir_cache;
   17.32 +}
   17.33 +
   17.34 +void Camera::set_fov(float vfov)
   17.35 +{
   17.36 +	this->vfov = vfov;
   17.37 +
   17.38 +	// invalidate the dir cache
   17.39 +	delete [] rdir_cache;
   17.40 +}
   17.41 +
   17.42 +float Camera::get_fov() const
   17.43 +{
   17.44 +	return vfov;
   17.45 +}
   17.46 +
   17.47 +void Camera::set_position(const Vector3 &pos)
   17.48 +{
   17.49 +	this->pos = pos;
   17.50 +	cached_matrix_valid = false;	// invalidate the cached matrix
   17.51 +}
   17.52 +
   17.53 +const Vector3 &Camera::get_position() const
   17.54 +{
   17.55 +	return pos;
   17.56 +}
   17.57 +
   17.58 +const Matrix4x4 &Camera::get_matrix() const
   17.59 +{
   17.60 +	if(!cached_matrix_valid) {
   17.61 +		calc_matrix(&cached_matrix);
   17.62 +		cached_matrix_valid = true;
   17.63 +	}
   17.64 +	return cached_matrix;
   17.65 +}
   17.66 +
   17.67 +Vector2 Camera::calc_sample_pos(int x, int y, int xsz, int ysz, int sample) const
   17.68 +{
   17.69 +	float ppos[2];
   17.70 +	float aspect = (float)xsz / (float)ysz;
   17.71 +
   17.72 +	float pwidth = 2.0 * aspect / (float)xsz;
   17.73 +	float pheight = 2.0 / (float)ysz;
   17.74 +
   17.75 +	ppos[0] = (float)x * pwidth - aspect;
   17.76 +	ppos[1] = 1.0 - (float)y * pheight;
   17.77 +
   17.78 +	calc_sample_pos_rec(sample, pwidth, pheight, ppos);
   17.79 +	return Vector2(ppos[0], ppos[1]);
   17.80 +}
   17.81 +
   17.82 +Ray Camera::get_primary_ray(int x, int y, int xsz, int ysz, int sample) const
   17.83 +{
   17.84 +	if(!rdir_cache || rdir_cache_width != xsz || rdir_cache_height != ysz) {
   17.85 +		printf("calculating primary ray direction cache\n");
   17.86 +
   17.87 +		delete [] rdir_cache;
   17.88 +		rdir_cache = new Vector3[xsz * ysz];
   17.89 +
   17.90 +		for(int i=0; i<ysz; i++) {
   17.91 +			Vector3 *rdir = rdir_cache + i * xsz;
   17.92 +			for(int j=0; j<xsz; j++) {
   17.93 +				Vector2 ppos = calc_sample_pos(j, i, xsz, ysz, 0);
   17.94 +
   17.95 +				rdir->x = ppos.x;
   17.96 +				rdir->y = ppos.y;
   17.97 +				rdir->z = 1.0 / tan(vfov / 2.0);
   17.98 +				rdir->normalize();
   17.99 +
  17.100 +				rdir++;
  17.101 +			}
  17.102 +		}
  17.103 +		rdir_cache_width = xsz;
  17.104 +		rdir_cache_height = ysz;
  17.105 +	}
  17.106 +
  17.107 +	Ray ray;
  17.108 +	ray.origin = pos;
  17.109 +	ray.dir = rdir_cache[y * xsz + x];
  17.110 +
  17.111 +	// transform the ray direction with the camera matrix
  17.112 +	Matrix4x4 mat = get_matrix();
  17.113 +	mat.m[0][3] = mat.m[1][3] = mat.m[2][3] = mat.m[3][0] = mat.m[3][1] = mat.m[3][2] = 0.0;
  17.114 +	mat.m[3][3] = 1.0;
  17.115 +
  17.116 +	ray.dir = ray.dir.transformed(mat);
  17.117 +	return ray;
  17.118 +}
  17.119 +
  17.120 +TargetCamera::TargetCamera() {}
  17.121 +
  17.122 +TargetCamera::TargetCamera(const Vector3 &pos, const Vector3 &targ)
  17.123 +	: Camera(pos), target(targ)
  17.124 +{
  17.125 +}
  17.126 +
  17.127 +void TargetCamera::set_target(const Vector3 &targ)
  17.128 +{
  17.129 +	target = targ;
  17.130 +	cached_matrix_valid = false; // invalidate the cached matrix
  17.131 +}
  17.132 +
  17.133 +const Vector3 &TargetCamera::get_target() const
  17.134 +{
  17.135 +	return target;
  17.136 +}
  17.137 +
  17.138 +void TargetCamera::calc_matrix(Matrix4x4 *mat) const
  17.139 +{
  17.140 +	Vector3 up(0, 1, 0);
  17.141 +	Vector3 dir = (target - pos).normalized();
  17.142 +	Vector3 right = cross_product(up, dir);
  17.143 +	up = cross_product(dir, right);
  17.144 +
  17.145 +	*mat = Matrix4x4(
  17.146 +			right.x, up.x, dir.x, pos.x,
  17.147 +			right.y, up.y, dir.y, pos.y,
  17.148 +			right.z, up.z, dir.z, pos.z,
  17.149 +			0.0, 0.0, 0.0, 1.0);
  17.150 +}
  17.151 +
  17.152 +void FlyCamera::input_move(float x, float y, float z)
  17.153 +{
  17.154 +	static const Vector3 vfwd(0, 0, 1), vright(1, 0, 0);
  17.155 +
  17.156 +	Vector3 k = vfwd.transformed(rot);
  17.157 +	Vector3	i = vright.transformed(rot);
  17.158 +	Vector3 j = cross_product(k, i);
  17.159 +
  17.160 +	pos += i * x + j * y + k * z;
  17.161 +	cached_matrix_valid = false;
  17.162 +}
  17.163 +
  17.164 +void FlyCamera::input_rotate(float x, float y, float z)
  17.165 +{
  17.166 +	Vector3 axis(x, y, z);
  17.167 +	float axis_len = axis.length();
  17.168 +	if(fabs(axis_len) < 1e-5) {
  17.169 +		return;
  17.170 +	}
  17.171 +	rot.rotate(axis / axis_len, -axis_len);
  17.172 +	rot.normalize();
  17.173 +
  17.174 +	cached_matrix_valid = false;
  17.175 +}
  17.176 +
  17.177 +void FlyCamera::calc_matrix(Matrix4x4 *mat) const
  17.178 +{
  17.179 +	Matrix3x3 rmat = rot.get_rotation_matrix();
  17.180 +	*mat = rmat;
  17.181 +}
  17.182 +
  17.183 +/* generates a sample position for sample number sidx, in the unit square
  17.184 + * by recursive subdivision and jittering
  17.185 + */
  17.186 +static void calc_sample_pos_rec(int sidx, float xsz, float ysz, float *pos)
  17.187 +{
  17.188 +    static const float subpt[4][2] = {
  17.189 +        {-0.25, -0.25}, {0.25, -0.25}, {-0.25, 0.25}, {0.25, 0.25}
  17.190 +    };
  17.191 +
  17.192 +    if(!sidx) {
  17.193 +        return;
  17.194 +    }
  17.195 +
  17.196 +    /* determine which quadrant to recurse into */
  17.197 +    int quadrant = ((sidx - 1) % 4);
  17.198 +    pos[0] += subpt[quadrant][0] * xsz;
  17.199 +    pos[1] += subpt[quadrant][1] * ysz;
  17.200 +
  17.201 +    calc_sample_pos_rec((sidx - 1) / 4, xsz / 2, ysz / 2, pos);
  17.202 +}

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/src/camera.h	Sun Nov 09 13:03:36 2014 +0200
    18.3 @@ -0,0 +1,61 @@
    18.4 +#ifndef CAMERA_H_
    18.5 +#define CAMERA_H_
    18.6 +
    18.7 +#include "vmath/vmath.h"
    18.8 +
    18.9 +class Camera {
   18.10 +protected:
   18.11 +	Vector3 pos;
   18.12 +	float vfov;	// vertical field of view in radians
   18.13 +
   18.14 +	mutable Matrix4x4 cached_matrix;
   18.15 +	mutable bool cached_matrix_valid;
   18.16 +
   18.17 +	mutable Vector3 *rdir_cache;
   18.18 +	mutable int rdir_cache_width, rdir_cache_height;
   18.19 +
   18.20 +	virtual void calc_matrix(Matrix4x4 *mat) const = 0;
   18.21 +
   18.22 +	Vector2 calc_sample_pos(int x, int y, int xsz, int ysz, int sample) const;
   18.23 +
   18.24 +public:
   18.25 +	Camera();
   18.26 +	Camera(const Vector3 &pos);
   18.27 +	virtual ~Camera();
   18.28 +
   18.29 +	virtual void set_fov(float vfov);
   18.30 +	virtual float get_fov() const;
   18.31 +
   18.32 +	virtual void set_position(const Vector3 &pos);
   18.33 +	virtual const Vector3 &get_position() const;
   18.34 +	virtual const Matrix4x4 &get_matrix() const;
   18.35 +
   18.36 +	virtual Ray get_primary_ray(int x, int y, int xsz, int ysz, int sample = 0) const;
   18.37 +};
   18.38 +
   18.39 +class TargetCamera : public Camera {
   18.40 +protected:
   18.41 +	Vector3 target;
   18.42 +
   18.43 +	void calc_matrix(Matrix4x4 *mat) const;
   18.44 +
   18.45 +public:
   18.46 +	TargetCamera();
   18.47 +	TargetCamera(const Vector3 &pos, const Vector3 &targ);
   18.48 +
   18.49 +	virtual void set_target(const Vector3 &targ);
   18.50 +	virtual const Vector3 &get_target() const;
   18.51 +};
   18.52 +
   18.53 +class FlyCamera : public Camera {
   18.54 +protected:
   18.55 +	Quaternion rot;
   18.56 +
   18.57 +	void calc_matrix(Matrix4x4 *mat) const;
   18.58 +
   18.59 +public:
   18.60 +	void input_move(float x, float y, float z);
   18.61 +	void input_rotate(float x, float y, float z);
   18.62 +};
   18.63 +
   18.64 +#endif	// CAMERA_H_

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/src/glsdr.c	Sun Nov 09 13:03:36 2014 +0200
    19.3 @@ -0,0 +1,411 @@
    19.4 +#include <stdio.h>
    19.5 +#include <stdlib.h>
    19.6 +#include <string.h>
    19.7 +#include <errno.h>
    19.8 +#include <stdarg.h>
    19.9 +#include <assert.h>
   19.10 +#include <GL/glew.h>
   19.11 +
   19.12 +#if defined(unix) || defined(__unix__)
   19.13 +#include <unistd.h>
   19.14 +#include <sys/stat.h>
   19.15 +#endif	/* unix */
   19.16 +
   19.17 +#include "glsdr.h"
   19.18 +
   19.19 +static const char *sdrtypestr(unsigned int sdrtype);
   19.20 +
   19.21 +unsigned int create_vertex_shader(const char *src)
   19.22 +{
   19.23 +	return create_shader(src, GL_VERTEX_SHADER);
   19.24 +}
   19.25 +
   19.26 +unsigned int create_pixel_shader(const char *src)
   19.27 +{
   19.28 +	return create_shader(src, GL_FRAGMENT_SHADER);
   19.29 +}
   19.30 +
   19.31 +unsigned int create_tessctl_shader(const char *src)
   19.32 +{
   19.33 +	return create_shader(src, GL_TESS_CONTROL_SHADER);
   19.34 +}
   19.35 +
   19.36 +unsigned int create_tesseval_shader(const char *src)
   19.37 +{
   19.38 +	return create_shader(src, GL_TESS_EVALUATION_SHADER);
   19.39 +}
   19.40 +
   19.41 +unsigned int create_geometry_shader(const char *src)
   19.42 +{
   19.43 +	return create_shader(src, GL_GEOMETRY_SHADER);
   19.44 +}
   19.45 +
   19.46 +unsigned int create_shader(const char *src, unsigned int sdr_type)
   19.47 +{
   19.48 +	unsigned int sdr;
   19.49 +	int success, info_len;
   19.50 +	char *info_str = 0;
   19.51 +	GLenum err;
   19.52 +
   19.53 +	sdr = glCreateShader(sdr_type);
   19.54 +	assert(glGetError() == GL_NO_ERROR);
   19.55 +	glShaderSource(sdr, 1, &src, 0);
   19.56 +	err = glGetError();
   19.57 +	assert(err == GL_NO_ERROR);
   19.58 +	glCompileShader(sdr);
   19.59 +	assert(glGetError() == GL_NO_ERROR);
   19.60 +
   19.61 +	glGetShaderiv(sdr, GL_COMPILE_STATUS, &success);
   19.62 +	assert(glGetError() == GL_NO_ERROR);
   19.63 +	glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);
   19.64 +	assert(glGetError() == GL_NO_ERROR);
   19.65 +
   19.66 +	if(info_len) {
   19.67 +		if((info_str = malloc(info_len + 1))) {
   19.68 +			glGetShaderInfoLog(sdr, info_len, 0, info_str);
   19.69 +			assert(glGetError() == GL_NO_ERROR);
   19.70 +		}
   19.71 +	}
   19.72 +
   19.73 +	if(success) {
   19.74 +		fprintf(stderr, info_str ? "done: %s\n" : "done\n", info_str);
   19.75 +	} else {
   19.76 +		fprintf(stderr, info_str ? "failed: %s\n" : "failed\n", info_str);
   19.77 +		glDeleteShader(sdr);
   19.78 +		sdr = 0;
   19.79 +	}
   19.80 +
   19.81 +	free(info_str);
   19.82 +	return sdr;
   19.83 +}
   19.84 +
   19.85 +void free_shader(unsigned int sdr)
   19.86 +{
   19.87 +	glDeleteShader(sdr);
   19.88 +}
   19.89 +
   19.90 +unsigned int load_vertex_shader(const char *fname)
   19.91 +{
   19.92 +	return load_shader(fname, GL_VERTEX_SHADER);
   19.93 +}
   19.94 +
   19.95 +unsigned int load_pixel_shader(const char *fname)
   19.96 +{
   19.97 +	return load_shader(fname, GL_FRAGMENT_SHADER);
   19.98 +}
   19.99 +
  19.100 +unsigned int load_tessctl_shader(const char *fname)
  19.101 +{
  19.102 +	return load_shader(fname, GL_TESS_CONTROL_SHADER);
  19.103 +}
  19.104 +
  19.105 +unsigned int load_tesseval_shader(const char *fname)
  19.106 +{
  19.107 +	return load_shader(fname, GL_TESS_EVALUATION_SHADER);
  19.108 +}
  19.109 +
  19.110 +unsigned int load_geometry_shader(const char *fname)
  19.111 +{
  19.112 +	return load_shader(fname, GL_GEOMETRY_SHADER);
  19.113 +}
  19.114 +
  19.115 +unsigned int load_shader(const char *fname, unsigned int sdr_type)
  19.116 +{
  19.117 +#if defined(unix) || defined(__unix__)
  19.118 +	struct stat st;
  19.119 +#endif
  19.120 +	unsigned int sdr;
  19.121 +	size_t filesize;
  19.122 +	FILE *fp;
  19.123 +	char *src;
  19.124 +
  19.125 +	if(!(fp = fopen(fname, "r"))) {
  19.126 +		fprintf(stderr, "failed to open shader %s: %s\n", fname, strerror(errno));
  19.127 +		return 0;
  19.128 +	}
  19.129 +
  19.130 +#if defined(unix) || defined(__unix__)
  19.131 +	fstat(fileno(fp), &st);
  19.132 +	filesize = st.st_size;
  19.133 +#else
  19.134 +	fseek(fp, 0, SEEK_END);
  19.135 +	filesize = ftell(fp);
  19.136 +	fseek(fp, 0, SEEK_SET);
  19.137 +#endif	/* unix */
  19.138 +
  19.139 +	if(!(src = malloc(filesize + 1))) {
  19.140 +		fclose(fp);
  19.141 +		return 0;
  19.142 +	}
  19.143 +	fread(src, 1, filesize, fp);
  19.144 +	src[filesize] = 0;
  19.145 +	fclose(fp);
  19.146 +
  19.147 +	fprintf(stderr, "compiling %s shader: %s... ", sdrtypestr(sdr_type), fname);
  19.148 +	sdr = create_shader(src, sdr_type);
  19.149 +
  19.150 +	free(src);
  19.151 +	return sdr;
  19.152 +}
  19.153 +
  19.154 +
  19.155 +unsigned int get_vertex_shader(const char *fname)
  19.156 +{
  19.157 +	return get_shader(fname, GL_VERTEX_SHADER);
  19.158 +}
  19.159 +
  19.160 +unsigned int get_pixel_shader(const char *fname)
  19.161 +{
  19.162 +	return get_shader(fname, GL_FRAGMENT_SHADER);
  19.163 +}
  19.164 +
  19.165 +unsigned int get_tessctl_shader(const char *fname)
  19.166 +{
  19.167 +	return get_shader(fname, GL_TESS_CONTROL_SHADER);
  19.168 +}
  19.169 +
  19.170 +unsigned int get_tesseval_shader(const char *fname)
  19.171 +{
  19.172 +	return get_shader(fname, GL_TESS_EVALUATION_SHADER);
  19.173 +}
  19.174 +
  19.175 +unsigned int get_geometry_shader(const char *fname)
  19.176 +{
  19.177 +	return get_shader(fname, GL_GEOMETRY_SHADER);
  19.178 +}
  19.179 +
  19.180 +unsigned int get_shader(const char *fname, unsigned int sdr_type)
  19.181 +{
  19.182 +	unsigned int sdr;
  19.183 +	if(!(sdr = load_shader(fname, sdr_type))) {
  19.184 +		return 0;
  19.185 +	}
  19.186 +	return sdr;
  19.187 +}
  19.188 +
  19.189 +
  19.190 +/* ---- gpu programs ---- */
  19.191 +
  19.192 +unsigned int create_program(void)
  19.193 +{
  19.194 +	unsigned int prog = glCreateProgram();
  19.195 +	assert(glGetError() == GL_NO_ERROR);
  19.196 +	return prog;
  19.197 +}
  19.198 +
  19.199 +unsigned int create_program_link(unsigned int sdr0, ...)
  19.200 +{
  19.201 +	unsigned int prog, sdr;
  19.202 +	va_list ap;
  19.203 +
  19.204 +	if(!(prog = create_program())) {
  19.205 +		return 0;
  19.206 +	}
  19.207 +
  19.208 +	attach_shader(prog, sdr0);
  19.209 +	if(glGetError()) {
  19.210 +		return 0;
  19.211 +	}
  19.212 +
  19.213 +	va_start(ap, sdr0);
  19.214 +	while((sdr = va_arg(ap, unsigned int))) {
  19.215 +		attach_shader(prog, sdr);
  19.216 +		if(glGetError()) {
  19.217 +			return 0;
  19.218 +		}
  19.219 +	}
  19.220 +	va_end(ap);
  19.221 +
  19.222 +	if(link_program(prog) == -1) {
  19.223 +		free_program(prog);
  19.224 +		return 0;
  19.225 +	}
  19.226 +	return prog;
  19.227 +}
  19.228 +
  19.229 +unsigned int create_program_load(const char *vfile, const char *pfile)
  19.230 +{
  19.231 +	unsigned int sdr[2];
  19.232 +	int i = 0;
  19.233 +
  19.234 +	if(vfile && *vfile && !(sdr[i++] = get_vertex_shader(vfile))) {
  19.235 +		return 0;
  19.236 +	}
  19.237 +	if(pfile && *pfile && !(sdr[i++] = get_pixel_shader(pfile))) {
  19.238 +		return 0;
  19.239 +	}
  19.240 +	return create_program_link(sdr[0], sdr[1], 0);
  19.241 +}
  19.242 +
  19.243 +void free_program(unsigned int sdr)
  19.244 +{
  19.245 +	glDeleteProgram(sdr);
  19.246 +}
  19.247 +
  19.248 +void attach_shader(unsigned int prog, unsigned int sdr)
  19.249 +{
  19.250 +	glAttachShader(prog, sdr);
  19.251 +	assert(glGetError() == GL_NO_ERROR);
  19.252 +}
  19.253 +
  19.254 +int link_program(unsigned int prog)
  19.255 +{
  19.256 +	int linked, info_len, retval = 0;
  19.257 +	char *info_str = 0;
  19.258 +
  19.259 +	glLinkProgram(prog);
  19.260 +	assert(glGetError() == GL_NO_ERROR);
  19.261 +	glGetProgramiv(prog, GL_LINK_STATUS, &linked);
  19.262 +	assert(glGetError() == GL_NO_ERROR);
  19.263 +	glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);
  19.264 +	assert(glGetError() == GL_NO_ERROR);
  19.265 +
  19.266 +	if(info_len) {
  19.267 +		if((info_str = malloc(info_len + 1))) {
  19.268 +			glGetProgramInfoLog(prog, info_len, 0, info_str);
  19.269 +			assert(glGetError() == GL_NO_ERROR);
  19.270 +		}
  19.271 +	}
  19.272 +
  19.273 +	if(linked) {
  19.274 +		fprintf(stderr, info_str ? "linking done: %s\n" : "linking done\n", info_str);
  19.275 +	} else {
  19.276 +		fprintf(stderr, info_str ? "linking failed: %s\n" : "linking failed\n", info_str);
  19.277 +		retval = -1;
  19.278 +	}
  19.279 +
  19.280 +	free(info_str);
  19.281 +	return retval;
  19.282 +}
  19.283 +
  19.284 +int bind_program(unsigned int prog)
  19.285 +{
  19.286 +	GLenum err;
  19.287 +
  19.288 +	glUseProgram(prog);
  19.289 +	if(prog && (err = glGetError()) != GL_NO_ERROR) {
  19.290 +		/* maybe the program is not linked, try linking first */
  19.291 +		if(err == GL_INVALID_OPERATION) {
  19.292 +			if(link_program(prog) == -1) {
  19.293 +				return -1;
  19.294 +			}
  19.295 +			glUseProgram(prog);
  19.296 +			return glGetError() == GL_NO_ERROR ? 0 : -1;
  19.297 +		}
  19.298 +		return -1;
  19.299 +	}
  19.300 +	return 0;
  19.301 +}
  19.302 +
  19.303 +/* ugly but I'm not going to write the same bloody code over and over */
  19.304 +#define BEGIN_UNIFORM_CODE \
  19.305 +	int loc, curr_prog; \
  19.306 +	glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \
  19.307 +	if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { \
  19.308 +		return -1; \
  19.309 +	} \
  19.310 +	if((loc = glGetUniformLocation(prog, name)) != -1)
  19.311 +
  19.312 +#define END_UNIFORM_CODE \
  19.313 +	if((unsigned int)curr_prog != prog) { \
  19.314 +		bind_program(curr_prog); \
  19.315 +	} \
  19.316 +	return loc == -1 ? -1 : 0
  19.317 +
  19.318 +int set_uniform_int(unsigned int prog, const char *name, int val)
  19.319 +{
  19.320 +	BEGIN_UNIFORM_CODE {
  19.321 +		glUniform1i(loc, val);
  19.322 +	}
  19.323 +	END_UNIFORM_CODE;
  19.324 +}
  19.325 +
  19.326 +int set_uniform_float(unsigned int prog, const char *name, float val)
  19.327 +{
  19.328 +	BEGIN_UNIFORM_CODE {
  19.329 +		glUniform1f(loc, val);
  19.330 +	}
  19.331 +	END_UNIFORM_CODE;
  19.332 +}
  19.333 +
  19.334 +int set_uniform_float2(unsigned int prog, const char *name, float x, float y)
  19.335 +{
  19.336 +	BEGIN_UNIFORM_CODE {
  19.337 +		glUniform2f(loc, x, y);
  19.338 +	}
  19.339 +	END_UNIFORM_CODE;
  19.340 +}
  19.341 +
  19.342 +int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z)
  19.343 +{
  19.344 +	BEGIN_UNIFORM_CODE {
  19.345 +		glUniform3f(loc, x, y, z);
  19.346 +	}
  19.347 +	END_UNIFORM_CODE;
  19.348 +}
  19.349 +
  19.350 +int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w)
  19.351 +{
  19.352 +	BEGIN_UNIFORM_CODE {
  19.353 +		glUniform4f(loc, x, y, z, w);
  19.354 +	}
  19.355 +	END_UNIFORM_CODE;
  19.356 +}
  19.357 +
  19.358 +int set_uniform_matrix4(unsigned int prog, const char *name, float *mat)
  19.359 +{
  19.360 +	BEGIN_UNIFORM_CODE {
  19.361 +		glUniformMatrix4fv(loc, 1, GL_FALSE, mat);
  19.362 +	}
  19.363 +	END_UNIFORM_CODE;
  19.364 +}
  19.365 +
  19.366 +int set_uniform_matrix4_transposed(unsigned int prog, const char *name, float *mat)
  19.367 +{
  19.368 +	BEGIN_UNIFORM_CODE {
  19.369 +		glUniformMatrix4fv(loc, 1, GL_TRUE, mat);
  19.370 +	}
  19.371 +	END_UNIFORM_CODE;
  19.372 +}
  19.373 +
  19.374 +int get_attrib_loc(unsigned int prog, const char *name)
  19.375 +{
  19.376 +	int loc, curr_prog;
  19.377 +
  19.378 +	glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
  19.379 +	if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
  19.380 +		return -1;
  19.381 +	}
  19.382 +
  19.383 +	loc = glGetAttribLocation(prog, (char*)name);
  19.384 +
  19.385 +	if((unsigned int)curr_prog != prog) {
  19.386 +		bind_program(curr_prog);
  19.387 +	}
  19.388 +	return loc;
  19.389 +}
  19.390 +
  19.391 +void set_attrib_float3(int attr_loc, float x, float y, float z)
  19.392 +{
  19.393 +	glVertexAttrib3f(attr_loc, x, y, z);
  19.394 +}
  19.395 +
  19.396 +static const char *sdrtypestr(unsigned int sdrtype)
  19.397 +{
  19.398 +	switch(sdrtype) {
  19.399 +	case GL_VERTEX_SHADER:
  19.400 +		return "vertex";
  19.401 +	case GL_FRAGMENT_SHADER:
  19.402 +		return "pixel";
  19.403 +	case GL_TESS_CONTROL_SHADER:
  19.404 +		return "tessellation control";
  19.405 +	case GL_TESS_EVALUATION_SHADER:
  19.406 +		return "tessellation evaluation";
  19.407 +	case GL_GEOMETRY_SHADER:
  19.408 +		return "geometry";
  19.409 +
  19.410 +	default:
  19.411 +		break;
  19.412 +	}
  19.413 +	return "<unknown>";
  19.414 +}

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/src/glsdr.h	Sun Nov 09 13:03:36 2014 +0200
    20.3 @@ -0,0 +1,59 @@
    20.4 +#ifndef SDR_H_
    20.5 +#define SDR_H_
    20.6 +
    20.7 +#ifdef __cplusplus
    20.8 +extern "C" {
    20.9 +#endif	/* __cplusplus */
   20.10 +
   20.11 +/* ---- shaders ---- */
   20.12 +unsigned int create_vertex_shader(const char *src);
   20.13 +unsigned int create_pixel_shader(const char *src);
   20.14 +unsigned int create_tessctl_shader(const char *src);
   20.15 +unsigned int create_tesseval_shader(const char *src);
   20.16 +unsigned int create_geometry_shader(const char *src);
   20.17 +unsigned int create_shader(const char *src, unsigned int sdr_type);
   20.18 +void free_shader(unsigned int sdr);
   20.19 +
   20.20 +unsigned int load_vertex_shader(const char *fname);
   20.21 +unsigned int load_pixel_shader(const char *fname);
   20.22 +unsigned int load_tessctl_shader(const char *fname);
   20.23 +unsigned int load_tesseval_shader(const char *fname);
   20.24 +unsigned int load_geometry_shader(const char *fname);
   20.25 +unsigned int load_shader(const char *src, unsigned int sdr_type);
   20.26 +
   20.27 +unsigned int get_vertex_shader(const char *fname);
   20.28 +unsigned int get_pixel_shader(const char *fname);
   20.29 +unsigned int get_tessctl_shader(const char *fname);
   20.30 +unsigned int get_tesseval_shader(const char *fname);
   20.31 +unsigned int get_geometry_shader(const char *fname);
   20.32 +unsigned int get_shader(const char *fname, unsigned int sdr_type);
   20.33 +
   20.34 +int add_shader(const char *fname, unsigned int sdr);
   20.35 +int remove_shader(const char *fname);
   20.36 +
   20.37 +/* ---- gpu programs ---- */
   20.38 +unsigned int create_program(void);
   20.39 +unsigned int create_program_link(unsigned int sdr0, ...);
   20.40 +unsigned int create_program_load(const char *vfile, const char *pfile);
   20.41 +void free_program(unsigned int sdr);
   20.42 +
   20.43 +void attach_shader(unsigned int prog, unsigned int sdr);
   20.44 +int link_program(unsigned int prog);
   20.45 +int bind_program(unsigned int prog);
   20.46 +
   20.47 +int set_uniform_int(unsigned int prog, const char *name, int val);
   20.48 +int set_uniform_float(unsigned int prog, const char *name, float val);
   20.49 +int set_uniform_float2(unsigned int prog, const char *name, float x, float y);
   20.50 +int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z);
   20.51 +int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w);
   20.52 +int set_uniform_matrix4(unsigned int prog, const char *name, float *mat);
   20.53 +int set_uniform_matrix4_transposed(unsigned int prog, const char *name, float *mat);
   20.54 +
   20.55 +int get_attrib_loc(unsigned int prog, const char *name);
   20.56 +void set_attrib_float3(int attr_loc, float x, float y, float z);
   20.57 +
   20.58 +#ifdef __cplusplus
   20.59 +}
   20.60 +#endif	/* __cplusplus */
   20.61 +
   20.62 +#endif	/* SDR_H_ */

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/src/gpuscene.cc	Sun Nov 09 13:03:36 2014 +0200
    21.3 @@ -0,0 +1,317 @@
    21.4 +#include <algorithm>
    21.5 +#include <assert.h>
    21.6 +#include "gpuscene.h"
    21.7 +#include "sphere.h"
    21.8 +#include "plane.h"
    21.9 +#include "box.h"
   21.10 +#include "opengl.h"
   21.11 +
   21.12 +GPUScene::GPUScene()
   21.13 +{
   21.14 +	glGenTextures(NUM_TEXTURES, textures);
   21.15 +
   21.16 +	for(int i=0; i<NUM_TEXTURES; i++) {
   21.17 +		glBindTexture(GL_TEXTURE_2D, textures[i]);
   21.18 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   21.19 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   21.20 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   21.21 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   21.22 +	}
   21.23 +
   21.24 +	xform_buf = 0;
   21.25 +}
   21.26 +
   21.27 +GPUScene::~GPUScene()
   21.28 +{
   21.29 +	glDeleteTextures(NUM_TEXTURES, textures);
   21.30 +	delete [] xform_buf;
   21.31 +}
   21.32 +
   21.33 +bool GPUScene::create_textures()
   21.34 +{
   21.35 +	// must be first to generate the megatecture rectangles
   21.36 +	create_megatexture();
   21.37 +
   21.38 +	Sphere *sph;
   21.39 +	Plane *plane;
   21.40 +	Box *box;
   21.41 +
   21.42 +	std::vector<Sphere*> spheres;
   21.43 +	std::vector<Plane*> planes;
   21.44 +	std::vector<Box*> boxes;
   21.45 +
   21.46 +	// collect all objects into the different type-specific arrays
   21.47 +	for(auto obj : objects) {
   21.48 +		if((sph = dynamic_cast<Sphere*>(obj))) {
   21.49 +			spheres.push_back(sph);
   21.50 +
   21.51 +		} else if((plane = dynamic_cast<Plane*>(obj))) {
   21.52 +			planes.push_back(plane);
   21.53 +
   21.54 +		} else if((box = dynamic_cast<Box*>(obj))) {
   21.55 +			boxes.push_back(box);
   21.56 +
   21.57 +		} else {
   21.58 +			fprintf(stderr, "skipping object of unknown type: %s\n", obj->get_name());
   21.59 +		}
   21.60 +	}
   21.61 +
   21.62 +	create_sphere_texture(spheres);
   21.63 +	create_plane_texture(planes);
   21.64 +	create_box_texture(boxes);
   21.65 +
   21.66 +	create_env_texture();
   21.67 +	create_xform_texture();
   21.68 +
   21.69 +	return true;
   21.70 +}
   21.71 +
   21.72 +unsigned int GPUScene::get_texture(int which) const
   21.73 +{
   21.74 +	return textures[which];
   21.75 +}
   21.76 +
   21.77 +#define MAT_START	4
   21.78 +static void copy_material(Vector4 *ptr, const Material *mtl)
   21.79 +{
   21.80 +	ptr[MAT_START].x = mtl->diffuse.x;
   21.81 +	ptr[MAT_START].y = mtl->diffuse.y;
   21.82 +	ptr[MAT_START].z = mtl->diffuse.z;
   21.83 +	ptr[MAT_START].w = mtl->transparency;
   21.84 +
   21.85 +	ptr[MAT_START + 1].x = mtl->specular.x;
   21.86 +	ptr[MAT_START + 1].y = mtl->specular.y;
   21.87 +	ptr[MAT_START + 1].z = mtl->specular.z;
   21.88 +	ptr[MAT_START + 1].w = mtl->shininess;
   21.89 +
   21.90 +	ptr[MAT_START + 2].x = mtl->reflectivity;
   21.91 +	ptr[MAT_START + 2].y = mtl->ior;
   21.92 +
   21.93 +	ptr[MAT_START + 3] = mtl->mega_rect;
   21.94 +}
   21.95 +
   21.96 +int GPUScene::object_index(const Object *obj) const
   21.97 +{
   21.98 +	for(int i=0; i<(int)objects.size(); i++) {
   21.99 +		if(objects[i] == obj) {
  21.100 +			return i;
  21.101 +		}
  21.102 +	}
  21.103 +	abort();	// can't happen
  21.104 +	return -1;
  21.105 +}
  21.106 +
  21.107 +#define OBJ_LINE_WIDTH	16
  21.108 +void GPUScene::create_sphere_texture(const std::vector<Sphere*> &spheres)
  21.109 +{
  21.110 +	int xsz = OBJ_LINE_WIDTH;
  21.111 +	int ysz = (int)spheres.size() + 1;
  21.112 +	int tex_ysz = next_pow2(ysz);
  21.113 +
  21.114 +	Vector4 *pixels = new Vector4[xsz * tex_ysz];
  21.115 +
  21.116 +	pixels[0].x = (float)ysz;
  21.117 +	pixels[0].y = (float)tex_ysz;
  21.118 +	pixels[0].z = 0.5;
  21.119 +	pixels[0].w = 1.0;
  21.120 +
  21.121 +	Vector4 *pixptr = pixels + xsz;
  21.122 +
  21.123 +	for(size_t i=0; i<spheres.size(); i++) {
  21.124 +		pixptr[0].x = object_index(spheres[i]);
  21.125 +
  21.126 +		pixptr[1].x = spheres[i]->pos.x;
  21.127 +		pixptr[1].y = spheres[i]->pos.y;
  21.128 +		pixptr[1].z = spheres[i]->pos.z;
  21.129 +		pixptr[1].w = spheres[i]->radius;
  21.130 +
  21.131 +		copy_material(pixptr, &spheres[i]->material);
  21.132 +		pixptr += OBJ_LINE_WIDTH;
  21.133 +	}
  21.134 +
  21.135 +	glBindTexture(GL_TEXTURE_2D, textures[TEX_SPHERE]);
  21.136 +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, pixels);
  21.137 +
  21.138 +	delete [] pixels;
  21.139 +}
  21.140 +
  21.141 +void GPUScene::create_plane_texture(const std::vector<Plane*> &planes)
  21.142 +{
  21.143 +	int xsz = OBJ_LINE_WIDTH;
  21.144 +	int ysz = (int)planes.size() + 1;
  21.145 +	int tex_ysz = next_pow2(ysz);
  21.146 +
  21.147 +	Vector4 *pixels = new Vector4[xsz * tex_ysz];
  21.148 +
  21.149 +	pixels[0].x = (float)ysz;
  21.150 +	pixels[0].y = (float)tex_ysz;
  21.151 +
  21.152 +	Vector4 *pixptr = pixels + xsz;
  21.153 +
  21.154 +	for(size_t i=0; i<planes.size(); i++) {
  21.155 +		pixptr[0].x = object_index(planes[i]);
  21.156 +
  21.157 +		pixptr[1].x = planes[i]->normal.x;
  21.158 +		pixptr[1].y = planes[i]->normal.y;
  21.159 +		pixptr[1].z = planes[i]->normal.z;
  21.160 +		pixptr[1].w = planes[i]->dist;
  21.161 +
  21.162 +		copy_material(pixptr, &planes[i]->material);
  21.163 +		pixptr += OBJ_LINE_WIDTH;
  21.164 +	}
  21.165 +
  21.166 +	glBindTexture(GL_TEXTURE_2D, textures[TEX_PLANE]);
  21.167 +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, pixels);
  21.168 +
  21.169 +	delete [] pixels;
  21.170 +}
  21.171 +
  21.172 +void GPUScene::create_box_texture(const std::vector<Box*> &boxes)
  21.173 +{
  21.174 +	int xsz = OBJ_LINE_WIDTH;
  21.175 +	int ysz = (int)boxes.size() + 1;
  21.176 +	int tex_ysz = next_pow2(ysz);
  21.177 +
  21.178 +	Vector4 *pixels = new Vector4[xsz * tex_ysz];
  21.179 +
  21.180 +	pixels[0].x = (float)ysz;
  21.181 +	pixels[0].y = (float)tex_ysz;
  21.182 +
  21.183 +	Vector4 *pixptr = pixels + xsz;
  21.184 +
  21.185 +	for(size_t i=0; i<boxes.size(); i++) {
  21.186 +		pixptr[0].x = object_index(boxes[i]);
  21.187 +		pixptr[1] = boxes[i]->min;
  21.188 +		pixptr[2] = boxes[i]->max;
  21.189 +
  21.190 +		copy_material(pixptr, &boxes[i]->material);
  21.191 +		pixptr += OBJ_LINE_WIDTH;
  21.192 +	}
  21.193 +
  21.194 +	glBindTexture(GL_TEXTURE_2D, textures[TEX_BOX]);
  21.195 +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, pixels);
  21.196 +
  21.197 +	delete [] pixels;
  21.198 +}
  21.199 +
  21.200 +void GPUScene::create_megatexture()
  21.201 +{
  21.202 +	// at least a 1x1 dummy white texture
  21.203 +	int xsz = 1;
  21.204 +	int ysz = 1;
  21.205 +	int num_textures = 0;
  21.206 +
  21.207 +	for(auto obj : objects) {
  21.208 +		// only need 2D textures at this point
  21.209 +		Texture *tex = dynamic_cast<Texture2D*>(obj->material.tex);
  21.210 +		if(tex) {
  21.211 +			const Image *img = tex->get_image();
  21.212 +
  21.213 +			xsz = std::max(xsz, img->xsz);
  21.214 +			ysz += img->ysz;
  21.215 +			num_textures++;
  21.216 +		}
  21.217 +	}
  21.218 +
  21.219 +	int tex_xsz = next_pow2(xsz);
  21.220 +	int tex_ysz = next_pow2(ysz);
  21.221 +
  21.222 +	Color *pixels = new Color[tex_xsz * tex_ysz];
  21.223 +
  21.224 +	// null texture
  21.225 +	pixels[0] = Color(1, 1, 1);
  21.226 +
  21.227 +	Color *pixptr = pixels + tex_xsz;
  21.228 +
  21.229 +	float offs_y = 0.0;
  21.230 +	for(auto obj : objects) {
  21.231 +		Texture *tex = dynamic_cast<Texture2D*>(obj->material.tex);
  21.232 +		if(tex) {
  21.233 +			const Image *img = tex->get_image();
  21.234 +
  21.235 +			Vector4 rect{0.0, offs_y, (float)img->xsz / (float)tex_xsz,
  21.236 +				(float)img->ysz / (float)tex_ysz};
  21.237 +
  21.238 +			offs_y += rect.w;
  21.239 +
  21.240 +			obj->material.mega_rect = rect;
  21.241 +
  21.242 +			for(int i=0; i<img->ysz; i++) {
  21.243 +				memcpy(pixptr, img->pixels + i * img->xsz, img->xsz * sizeof *pixels);
  21.244 +				pixptr += tex_xsz;
  21.245 +			}
  21.246 +		} else {
  21.247 +			obj->material.mega_rect = Vector4(0, 0, 0, 0);
  21.248 +		}
  21.249 +	}
  21.250 +
  21.251 +	glBindTexture(GL_TEXTURE_2D, textures[TEX_TEXTURE]);
  21.252 +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F, tex_xsz, tex_ysz, 0, GL_RGB, GL_FLOAT, pixels);
  21.253 +
  21.254 +	delete [] pixels;
  21.255 +}
  21.256 +
  21.257 +void GPUScene::create_env_texture()
  21.258 +{
  21.259 +	// create the scene cubemap, or a null cubemap if we don't have one
  21.260 +	glDeleteTextures(1, textures + TEX_ENV);	// cause it's not a 2D texture :)
  21.261 +
  21.262 +	glGenTextures(1, textures + TEX_ENV);
  21.263 +	glBindTexture(GL_TEXTURE_CUBE_MAP, textures[TEX_ENV]);
  21.264 +	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  21.265 +	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  21.266 +	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  21.267 +	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  21.268 +	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
  21.269 +
  21.270 +	if(envmap) {
  21.271 +		// we have an environment cubemap, just pass the data to OpenGL
  21.272 +		for(int i=0; i<6; i++) {
  21.273 +			const Image *img = envmap->get_image(i);
  21.274 +
  21.275 +			int face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
  21.276 +			glTexImage2D(face, 0, GL_RGB16F, img->xsz, img->ysz, 0, GL_RGB, GL_FLOAT, img->pixels);
  21.277 +		}
  21.278 +	} else {
  21.279 +		// we don't have an env cubemap, make a dummy 1x1 cubemap with the background color
  21.280 +		for(int i=0; i<6; i++) {
  21.281 +			int face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
  21.282 +			glTexImage2D(face, 0, GL_RGB16F, 1, 1, 0, GL_RGB, GL_FLOAT, &bgcolor);
  21.283 +		}
  21.284 +	}
  21.285 +}
  21.286 +
  21.287 +#define XFORM_LINE_WIDTH	OBJ_LINE_WIDTH
  21.288 +void GPUScene::create_xform_texture()
  21.289 +{
  21.290 +	int tex_xsz = XFORM_LINE_WIDTH;
  21.291 +	int tex_ysz = next_pow2((int)objects.size() + 1);	// leave space for the descriptor
  21.292 +
  21.293 +	glBindTexture(GL_TEXTURE_2D, textures[TEX_XFORM]);
  21.294 +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);
  21.295 +
  21.296 +	update_xform_texture();
  21.297 +}
  21.298 +
  21.299 +void GPUScene::update_xform_texture()
  21.300 +{
  21.301 +	int tex_xsz = XFORM_LINE_WIDTH;
  21.302 +	int tex_ysz = next_pow2((int)objects.size() + 1);	// leave space for the descriptor
  21.303 +
  21.304 +	if(!xform_buf) {
  21.305 +		xform_buf = new Vector4[tex_xsz * tex_ysz];
  21.306 +		xform_buf[0].x = tex_ysz;	// descriptor
  21.307 +	}
  21.308 +
  21.309 +	Vector4 *pixptr = xform_buf + tex_xsz;
  21.310 +	for(auto obj : objects) {
  21.311 +		for(int i=0; i<4; i++) {
  21.312 +			pixptr[i] = obj->xform.get_column_vector(i);
  21.313 +			pixptr[i + 4] = obj->inv_xform.get_column_vector(i);
  21.314 +		}
  21.315 +		pixptr += tex_xsz;
  21.316 +	}
  21.317 +
  21.318 +	glBindTexture(GL_TEXTURE_2D, textures[TEX_XFORM]);
  21.319 +	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, tex_xsz, tex_ysz, GL_RGBA, GL_FLOAT, xform_buf);
  21.320 +}

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/src/gpuscene.h	Sun Nov 09 13:03:36 2014 +0200
    22.3 @@ -0,0 +1,38 @@
    22.4 +#ifndef GPUSCENE_H_
    22.5 +#define GPUSCENE_H_
    22.6 +
    22.7 +#include <vector>
    22.8 +#include "scene.h"
    22.9 +#include "sphere.h"
   22.10 +#include "plane.h"
   22.11 +#include "box.h"
   22.12 +
   22.13 +class GPUScene : public Scene {
   22.14 +public:
   22.15 +	enum { TEX_SPHERE, TEX_PLANE, TEX_BOX, TEX_TEXTURE, TEX_ENV, TEX_XFORM, NUM_TEXTURES };
   22.16 +
   22.17 +private:
   22.18 +	unsigned int textures[NUM_TEXTURES];
   22.19 +	Vector4 *xform_buf;
   22.20 +
   22.21 +	int object_index(const Object *obj) const;
   22.22 +
   22.23 +	void create_sphere_texture(const std::vector<Sphere*> &spheres);
   22.24 +	void create_plane_texture(const std::vector<Plane*> &planes);
   22.25 +	void create_box_texture(const std::vector<Box*> &box);
   22.26 +	void create_megatexture();
   22.27 +	void create_env_texture();
   22.28 +	void create_xform_texture();
   22.29 +
   22.30 +public:
   22.31 +	GPUScene();
   22.32 +	~GPUScene();
   22.33 +
   22.34 +	bool create_textures();
   22.35 +
   22.36 +	void update_xform_texture();
   22.37 +
   22.38 +	unsigned int get_texture(int which) const;
   22.39 +};
   22.40 +
   22.41 +#endif	// GPUSCENE_H_