1.1 --- a/android/Makefile	Mon May 25 05:27:26 2015 +0300
     1.2 +++ b/android/Makefile	Sun May 31 00:40:26 2015 +0300
     1.3 @@ -23,10 +23,12 @@
     1.4  
     1.5  android_usr = $(NDK)/platforms/$(android_platform)/arch-arm/usr
     1.6  android_inc = -I$(native_app_glue_dir)
     1.7 -android_libs = -llog -landroid -lEGL -lGLESv1_CM
     1.8 +android_libs = -lstdc++ -llog -landroid -lEGL -lGLESv2
     1.9  
    1.10 -CFLAGS = -std=c99 -Wall -g -DAPP_NAME=\"$(name)\" -march=armv7-a -mfloat-abi=softfp \
    1.11 +defs += -DANDROID -DAPP_NAME=\"$(name)\"
    1.12 +CXXFLAGS = -Wall -g $(defs) -march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16 \
    1.13  		 $(android_inc) -I$(root)/src/android -I$(root)/src/gles $(incpaths)
    1.14 +CFLAGS = -std=c99 $(CXXFLAGS)
    1.15  LDFLAGS = -Wl,--fix-cortex-a8 -Wl,-z,defs $(android_libs) $(libpaths) -lm
    1.16  
    1.17  .PHONY: debug
    1.18 @@ -46,7 +48,7 @@
    1.19  
    1.20  $(lib): $(obj)
    1.21  	@mkdir -p libs/armeabi
    1.22 -	$(CC) -o $@ -shared $(obj) $(LDFLAGS)
    1.23 +	$(CXX) -o $@ -shared $(obj) $(LDFLAGS)
    1.24  
    1.25  ant_files = *.xml *.properties proguard-project.txt
    1.26  ant_dirs = bin libs res obj src gen

     2.1 --- a/android/manifest.xml.in	Mon May 25 05:27:26 2015 +0300
     2.2 +++ b/android/manifest.xml.in	Sun May 31 00:40:26 2015 +0300
     2.3 @@ -8,6 +8,7 @@
     2.4  
     2.5  	<uses-permission android:name="android.permission.CAMERA" />
     2.6  	<uses-feature android:name="android.hardware.camera" />
     2.7 +	<uses-feature android:glEsVersion="0x00020000" android:required="true" />
     2.8  
     2.9  	<application android:label="$APPNAME" android:debuggable="true">
    2.10  		<!-- android:icon="@drawable/ic_launcher" -->

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/libs/drawtext/COPYING	Sun May 31 00:40:26 2015 +0300
     3.3 @@ -0,0 +1,674 @@
     3.4 +                    GNU GENERAL PUBLIC LICENSE
     3.5 +                       Version 3, 29 June 2007
     3.6 +
     3.7 + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
     3.8 + Everyone is permitted to copy and distribute verbatim copies
     3.9 + of this license document, but changing it is not allowed.
    3.10 +
    3.11 +                            Preamble
    3.12 +
    3.13 +  The GNU General Public License is a free, copyleft license for
    3.14 +software and other kinds of works.
    3.15 +
    3.16 +  The licenses for most software and other practical works are designed
    3.17 +to take away your freedom to share and change the works.  By contrast,
    3.18 +the GNU General Public License is intended to guarantee your freedom to
    3.19 +share and change all versions of a program--to make sure it remains free
    3.20 +software for all its users.  We, the Free Software Foundation, use the
    3.21 +GNU General Public License for most of our software; it applies also to
    3.22 +any other work released this way by its authors.  You can apply it to
    3.23 +your programs, too.
    3.24 +
    3.25 +  When we speak of free software, we are referring to freedom, not
    3.26 +price.  Our General Public Licenses are designed to make sure that you
    3.27 +have the freedom to distribute copies of free software (and charge for
    3.28 +them if you wish), that you receive source code or can get it if you
    3.29 +want it, that you can change the software or use pieces of it in new
    3.30 +free programs, and that you know you can do these things.
    3.31 +
    3.32 +  To protect your rights, we need to prevent others from denying you
    3.33 +these rights or asking you to surrender the rights.  Therefore, you have
    3.34 +certain responsibilities if you distribute copies of the software, or if
    3.35 +you modify it: responsibilities to respect the freedom of others.
    3.36 +
    3.37 +  For example, if you distribute copies of such a program, whether
    3.38 +gratis or for a fee, you must pass on to the recipients the same
    3.39 +freedoms that you received.  You must make sure that they, too, receive
    3.40 +or can get the source code.  And you must show them these terms so they
    3.41 +know their rights.
    3.42 +
    3.43 +  Developers that use the GNU GPL protect your rights with two steps:
    3.44 +(1) assert copyright on the software, and (2) offer you this License
    3.45 +giving you legal permission to copy, distribute and/or modify it.
    3.46 +
    3.47 +  For the developers' and authors' protection, the GPL clearly explains
    3.48 +that there is no warranty for this free software.  For both users' and
    3.49 +authors' sake, the GPL requires that modified versions be marked as
    3.50 +changed, so that their problems will not be attributed erroneously to
    3.51 +authors of previous versions.
    3.52 +
    3.53 +  Some devices are designed to deny users access to install or run
    3.54 +modified versions of the software inside them, although the manufacturer
    3.55 +can do so.  This is fundamentally incompatible with the aim of
    3.56 +protecting users' freedom to change the software.  The systematic
    3.57 +pattern of such abuse occurs in the area of products for individuals to
    3.58 +use, which is precisely where it is most unacceptable.  Therefore, we
    3.59 +have designed this version of the GPL to prohibit the practice for those
    3.60 +products.  If such problems arise substantially in other domains, we
    3.61 +stand ready to extend this provision to those domains in future versions
    3.62 +of the GPL, as needed to protect the freedom of users.
    3.63 +
    3.64 +  Finally, every program is threatened constantly by software patents.
    3.65 +States should not allow patents to restrict development and use of
    3.66 +software on general-purpose computers, but in those that do, we wish to
    3.67 +avoid the special danger that patents applied to a free program could
    3.68 +make it effectively proprietary.  To prevent this, the GPL assures that
    3.69 +patents cannot be used to render the program non-free.
    3.70 +
    3.71 +  The precise terms and conditions for copying, distribution and
    3.72 +modification follow.
    3.73 +
    3.74 +                       TERMS AND CONDITIONS
    3.75 +
    3.76 +  0. Definitions.
    3.77 +
    3.78 +  "This License" refers to version 3 of the GNU General Public License.
    3.79 +
    3.80 +  "Copyright" also means copyright-like laws that apply to other kinds of
    3.81 +works, such as semiconductor masks.
    3.82 +
    3.83 +  "The Program" refers to any copyrightable work licensed under this
    3.84 +License.  Each licensee is addressed as "you".  "Licensees" and
    3.85 +"recipients" may be individuals or organizations.
    3.86 +
    3.87 +  To "modify" a work means to copy from or adapt all or part of the work
    3.88 +in a fashion requiring copyright permission, other than the making of an
    3.89 +exact copy.  The resulting work is called a "modified version" of the
    3.90 +earlier work or a work "based on" the earlier work.
    3.91 +
    3.92 +  A "covered work" means either the unmodified Program or a work based
    3.93 +on the Program.
    3.94 +
    3.95 +  To "propagate" a work means to do anything with it that, without
    3.96 +permission, would make you directly or secondarily liable for
    3.97 +infringement under applicable copyright law, except executing it on a
    3.98 +computer or modifying a private copy.  Propagation includes copying,
    3.99 +distribution (with or without modification), making available to the
   3.100 +public, and in some countries other activities as well.
   3.101 +
   3.102 +  To "convey" a work means any kind of propagation that enables other
   3.103 +parties to make or receive copies.  Mere interaction with a user through
   3.104 +a computer network, with no transfer of a copy, is not conveying.
   3.105 +
   3.106 +  An interactive user interface displays "Appropriate Legal Notices"
   3.107 +to the extent that it includes a convenient and prominently visible
   3.108 +feature that (1) displays an appropriate copyright notice, and (2)
   3.109 +tells the user that there is no warranty for the work (except to the
   3.110 +extent that warranties are provided), that licensees may convey the
   3.111 +work under this License, and how to view a copy of this License.  If
   3.112 +the interface presents a list of user commands or options, such as a
   3.113 +menu, a prominent item in the list meets this criterion.
   3.114 +
   3.115 +  1. Source Code.
   3.116 +
   3.117 +  The "source code" for a work means the preferred form of the work
   3.118 +for making modifications to it.  "Object code" means any non-source
   3.119 +form of a work.
   3.120 +
   3.121 +  A "Standard Interface" means an interface that either is an official
   3.122 +standard defined by a recognized standards body, or, in the case of
   3.123 +interfaces specified for a particular programming language, one that
   3.124 +is widely used among developers working in that language.
   3.125 +
   3.126 +  The "System Libraries" of an executable work include anything, other
   3.127 +than the work as a whole, that (a) is included in the normal form of
   3.128 +packaging a Major Component, but which is not part of that Major
   3.129 +Component, and (b) serves only to enable use of the work with that
   3.130 +Major Component, or to implement a Standard Interface for which an
   3.131 +implementation is available to the public in source code form.  A
   3.132 +"Major Component", in this context, means a major essential component
   3.133 +(kernel, window system, and so on) of the specific operating system
   3.134 +(if any) on which the executable work runs, or a compiler used to
   3.135 +produce the work, or an object code interpreter used to run it.
   3.136 +
   3.137 +  The "Corresponding Source" for a work in object code form means all
   3.138 +the source code needed to generate, install, and (for an executable
   3.139 +work) run the object code and to modify the work, including scripts to
   3.140 +control those activities.  However, it does not include the work's
   3.141 +System Libraries, or general-purpose tools or generally available free
   3.142 +programs which are used unmodified in performing those activities but
   3.143 +which are not part of the work.  For example, Corresponding Source
   3.144 +includes interface definition files associated with source files for
   3.145 +the work, and the source code for shared libraries and dynamically
   3.146 +linked subprograms that the work is specifically designed to require,
   3.147 +such as by intimate data communication or control flow between those
   3.148 +subprograms and other parts of the work.
   3.149 +
   3.150 +  The Corresponding Source need not include anything that users
   3.151 +can regenerate automatically from other parts of the Corresponding
   3.152 +Source.
   3.153 +
   3.154 +  The Corresponding Source for a work in source code form is that
   3.155 +same work.
   3.156 +
   3.157 +  2. Basic Permissions.
   3.158 +
   3.159 +  All rights granted under this License are granted for the term of
   3.160 +copyright on the Program, and are irrevocable provided the stated
   3.161 +conditions are met.  This License explicitly affirms your unlimited
   3.162 +permission to run the unmodified Program.  The output from running a
   3.163 +covered work is covered by this License only if the output, given its
   3.164 +content, constitutes a covered work.  This License acknowledges your
   3.165 +rights of fair use or other equivalent, as provided by copyright law.
   3.166 +
   3.167 +  You may make, run and propagate covered works that you do not
   3.168 +convey, without conditions so long as your license otherwise remains
   3.169 +in force.  You may convey covered works to others for the sole purpose
   3.170 +of having them make modifications exclusively for you, or provide you
   3.171 +with facilities for running those works, provided that you comply with
   3.172 +the terms of this License in conveying all material for which you do
   3.173 +not control copyright.  Those thus making or running the covered works
   3.174 +for you must do so exclusively on your behalf, under your direction
   3.175 +and control, on terms that prohibit them from making any copies of
   3.176 +your copyrighted material outside their relationship with you.
   3.177 +
   3.178 +  Conveying under any other circumstances is permitted solely under
   3.179 +the conditions stated below.  Sublicensing is not allowed; section 10
   3.180 +makes it unnecessary.
   3.181 +
   3.182 +  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
   3.183 +
   3.184 +  No covered work shall be deemed part of an effective technological
   3.185 +measure under any applicable law fulfilling obligations under article
   3.186 +11 of the WIPO copyright treaty adopted on 20 December 1996, or
   3.187 +similar laws prohibiting or restricting circumvention of such
   3.188 +measures.
   3.189 +
   3.190 +  When you convey a covered work, you waive any legal power to forbid
   3.191 +circumvention of technological measures to the extent such circumvention
   3.192 +is effected by exercising rights under this License with respect to
   3.193 +the covered work, and you disclaim any intention to limit operation or
   3.194 +modification of the work as a means of enforcing, against the work's
   3.195 +users, your or third parties' legal rights to forbid circumvention of
   3.196 +technological measures.
   3.197 +
   3.198 +  4. Conveying Verbatim Copies.
   3.199 +
   3.200 +  You may convey verbatim copies of the Program's source code as you
   3.201 +receive it, in any medium, provided that you conspicuously and
   3.202 +appropriately publish on each copy an appropriate copyright notice;
   3.203 +keep intact all notices stating that this License and any
   3.204 +non-permissive terms added in accord with section 7 apply to the code;
   3.205 +keep intact all notices of the absence of any warranty; and give all
   3.206 +recipients a copy of this License along with the Program.
   3.207 +
   3.208 +  You may charge any price or no price for each copy that you convey,
   3.209 +and you may offer support or warranty protection for a fee.
   3.210 +
   3.211 +  5. Conveying Modified Source Versions.
   3.212 +
   3.213 +  You may convey a work based on the Program, or the modifications to
   3.214 +produce it from the Program, in the form of source code under the
   3.215 +terms of section 4, provided that you also meet all of these conditions:
   3.216 +
   3.217 +    a) The work must carry prominent notices stating that you modified
   3.218 +    it, and giving a relevant date.
   3.219 +
   3.220 +    b) The work must carry prominent notices stating that it is
   3.221 +    released under this License and any conditions added under section
   3.222 +    7.  This requirement modifies the requirement in section 4 to
   3.223 +    "keep intact all notices".
   3.224 +
   3.225 +    c) You must license the entire work, as a whole, under this
   3.226 +    License to anyone who comes into possession of a copy.  This
   3.227 +    License will therefore apply, along with any applicable section 7
   3.228 +    additional terms, to the whole of the work, and all its parts,
   3.229 +    regardless of how they are packaged.  This License gives no
   3.230 +    permission to license the work in any other way, but it does not
   3.231 +    invalidate such permission if you have separately received it.
   3.232 +
   3.233 +    d) If the work has interactive user interfaces, each must display
   3.234 +    Appropriate Legal Notices; however, if the Program has interactive
   3.235 +    interfaces that do not display Appropriate Legal Notices, your
   3.236 +    work need not make them do so.
   3.237 +
   3.238 +  A compilation of a covered work with other separate and independent
   3.239 +works, which are not by their nature extensions of the covered work,
   3.240 +and which are not combined with it such as to form a larger program,
   3.241 +in or on a volume of a storage or distribution medium, is called an
   3.242 +"aggregate" if the compilation and its resulting copyright are not
   3.243 +used to limit the access or legal rights of the compilation's users
   3.244 +beyond what the individual works permit.  Inclusion of a covered work
   3.245 +in an aggregate does not cause this License to apply to the other
   3.246 +parts of the aggregate.
   3.247 +
   3.248 +  6. Conveying Non-Source Forms.
   3.249 +
   3.250 +  You may convey a covered work in object code form under the terms
   3.251 +of sections 4 and 5, provided that you also convey the
   3.252 +machine-readable Corresponding Source under the terms of this License,
   3.253 +in one of these ways:
   3.254 +
   3.255 +    a) Convey the object code in, or embodied in, a physical product
   3.256 +    (including a physical distribution medium), accompanied by the
   3.257 +    Corresponding Source fixed on a durable physical medium
   3.258 +    customarily used for software interchange.
   3.259 +
   3.260 +    b) Convey the object code in, or embodied in, a physical product
   3.261 +    (including a physical distribution medium), accompanied by a
   3.262 +    written offer, valid for at least three years and valid for as
   3.263 +    long as you offer spare parts or customer support for that product
   3.264 +    model, to give anyone who possesses the object code either (1) a
   3.265 +    copy of the Corresponding Source for all the software in the
   3.266 +    product that is covered by this License, on a durable physical
   3.267 +    medium customarily used for software interchange, for a price no
   3.268 +    more than your reasonable cost of physically performing this
   3.269 +    conveying of source, or (2) access to copy the
   3.270 +    Corresponding Source from a network server at no charge.
   3.271 +
   3.272 +    c) Convey individual copies of the object code with a copy of the
   3.273 +    written offer to provide the Corresponding Source.  This
   3.274 +    alternative is allowed only occasionally and noncommercially, and
   3.275 +    only if you received the object code with such an offer, in accord
   3.276 +    with subsection 6b.
   3.277 +
   3.278 +    d) Convey the object code by offering access from a designated
   3.279 +    place (gratis or for a charge), and offer equivalent access to the
   3.280 +    Corresponding Source in the same way through the same place at no
   3.281 +    further charge.  You need not require recipients to copy the
   3.282 +    Corresponding Source along with the object code.  If the place to
   3.283 +    copy the object code is a network server, the Corresponding Source
   3.284 +    may be on a different server (operated by you or a third party)
   3.285 +    that supports equivalent copying facilities, provided you maintain
   3.286 +    clear directions next to the object code saying where to find the
   3.287 +    Corresponding Source.  Regardless of what server hosts the
   3.288 +    Corresponding Source, you remain obligated to ensure that it is
   3.289 +    available for as long as needed to satisfy these requirements.
   3.290 +
   3.291 +    e) Convey the object code using peer-to-peer transmission, provided
   3.292 +    you inform other peers where the object code and Corresponding
   3.293 +    Source of the work are being offered to the general public at no
   3.294 +    charge under subsection 6d.
   3.295 +
   3.296 +  A separable portion of the object code, whose source code is excluded
   3.297 +from the Corresponding Source as a System Library, need not be
   3.298 +included in conveying the object code work.
   3.299 +
   3.300 +  A "User Product" is either (1) a "consumer product", which means any
   3.301 +tangible personal property which is normally used for personal, family,
   3.302 +or household purposes, or (2) anything designed or sold for incorporation
   3.303 +into a dwelling.  In determining whether a product is a consumer product,
   3.304 +doubtful cases shall be resolved in favor of coverage.  For a particular
   3.305 +product received by a particular user, "normally used" refers to a
   3.306 +typical or common use of that class of product, regardless of the status
   3.307 +of the particular user or of the way in which the particular user
   3.308 +actually uses, or expects or is expected to use, the product.  A product
   3.309 +is a consumer product regardless of whether the product has substantial
   3.310 +commercial, industrial or non-consumer uses, unless such uses represent
   3.311 +the only significant mode of use of the product.
   3.312 +
   3.313 +  "Installation Information" for a User Product means any methods,
   3.314 +procedures, authorization keys, or other information required to install
   3.315 +and execute modified versions of a covered work in that User Product from
   3.316 +a modified version of its Corresponding Source.  The information must
   3.317 +suffice to ensure that the continued functioning of the modified object
   3.318 +code is in no case prevented or interfered with solely because
   3.319 +modification has been made.
   3.320 +
   3.321 +  If you convey an object code work under this section in, or with, or
   3.322 +specifically for use in, a User Product, and the conveying occurs as
   3.323 +part of a transaction in which the right of possession and use of the
   3.324 +User Product is transferred to the recipient in perpetuity or for a
   3.325 +fixed term (regardless of how the transaction is characterized), the
   3.326 +Corresponding Source conveyed under this section must be accompanied
   3.327 +by the Installation Information.  But this requirement does not apply
   3.328 +if neither you nor any third party retains the ability to install
   3.329 +modified object code on the User Product (for example, the work has
   3.330 +been installed in ROM).
   3.331 +
   3.332 +  The requirement to provide Installation Information does not include a
   3.333 +requirement to continue to provide support service, warranty, or updates
   3.334 +for a work that has been modified or installed by the recipient, or for
   3.335 +the User Product in which it has been modified or installed.  Access to a
   3.336 +network may be denied when the modification itself materially and
   3.337 +adversely affects the operation of the network or violates the rules and
   3.338 +protocols for communication across the network.
   3.339 +
   3.340 +  Corresponding Source conveyed, and Installation Information provided,
   3.341 +in accord with this section must be in a format that is publicly
   3.342 +documented (and with an implementation available to the public in
   3.343 +source code form), and must require no special password or key for
   3.344 +unpacking, reading or copying.
   3.345 +
   3.346 +  7. Additional Terms.
   3.347 +
   3.348 +  "Additional permissions" are terms that supplement the terms of this
   3.349 +License by making exceptions from one or more of its conditions.
   3.350 +Additional permissions that are applicable to the entire Program shall
   3.351 +be treated as though they were included in this License, to the extent
   3.352 +that they are valid under applicable law.  If additional permissions
   3.353 +apply only to part of the Program, that part may be used separately
   3.354 +under those permissions, but the entire Program remains governed by
   3.355 +this License without regard to the additional permissions.
   3.356 +
   3.357 +  When you convey a copy of a covered work, you may at your option
   3.358 +remove any additional permissions from that copy, or from any part of
   3.359 +it.  (Additional permissions may be written to require their own
   3.360 +removal in certain cases when you modify the work.)  You may place
   3.361 +additional permissions on material, added by you to a covered work,
   3.362 +for which you have or can give appropriate copyright permission.
   3.363 +
   3.364 +  Notwithstanding any other provision of this License, for material you
   3.365 +add to a covered work, you may (if authorized by the copyright holders of
   3.366 +that material) supplement the terms of this License with terms:
   3.367 +
   3.368 +    a) Disclaiming warranty or limiting liability differently from the
   3.369 +    terms of sections 15 and 16 of this License; or
   3.370 +
   3.371 +    b) Requiring preservation of specified reasonable legal notices or
   3.372 +    author attributions in that material or in the Appropriate Legal
   3.373 +    Notices displayed by works containing it; or
   3.374 +
   3.375 +    c) Prohibiting misrepresentation of the origin of that material, or
   3.376 +    requiring that modified versions of such material be marked in
   3.377 +    reasonable ways as different from the original version; or
   3.378 +
   3.379 +    d) Limiting the use for publicity purposes of names of licensors or
   3.380 +    authors of the material; or
   3.381 +
   3.382 +    e) Declining to grant rights under trademark law for use of some
   3.383 +    trade names, trademarks, or service marks; or
   3.384 +
   3.385 +    f) Requiring indemnification of licensors and authors of that
   3.386 +    material by anyone who conveys the material (or modified versions of
   3.387 +    it) with contractual assumptions of liability to the recipient, for
   3.388 +    any liability that these contractual assumptions directly impose on
   3.389 +    those licensors and authors.
   3.390 +
   3.391 +  All other non-permissive additional terms are considered "further
   3.392 +restrictions" within the meaning of section 10.  If the Program as you
   3.393 +received it, or any part of it, contains a notice stating that it is
   3.394 +governed by this License along with a term that is a further
   3.395 +restriction, you may remove that term.  If a license document contains
   3.396 +a further restriction but permits relicensing or conveying under this
   3.397 +License, you may add to a covered work material governed by the terms
   3.398 +of that license document, provided that the further restriction does
   3.399 +not survive such relicensing or conveying.
   3.400 +
   3.401 +  If you add terms to a covered work in accord with this section, you
   3.402 +must place, in the relevant source files, a statement of the
   3.403 +additional terms that apply to those files, or a notice indicating
   3.404 +where to find the applicable terms.
   3.405 +
   3.406 +  Additional terms, permissive or non-permissive, may be stated in the
   3.407 +form of a separately written license, or stated as exceptions;
   3.408 +the above requirements apply either way.
   3.409 +
   3.410 +  8. Termination.
   3.411 +
   3.412 +  You may not propagate or modify a covered work except as expressly
   3.413 +provided under this License.  Any attempt otherwise to propagate or
   3.414 +modify it is void, and will automatically terminate your rights under
   3.415 +this License (including any patent licenses granted under the third
   3.416 +paragraph of section 11).
   3.417 +
   3.418 +  However, if you cease all violation of this License, then your
   3.419 +license from a particular copyright holder is reinstated (a)
   3.420 +provisionally, unless and until the copyright holder explicitly and
   3.421 +finally terminates your license, and (b) permanently, if the copyright
   3.422 +holder fails to notify you of the violation by some reasonable means
   3.423 +prior to 60 days after the cessation.
   3.424 +
   3.425 +  Moreover, your license from a particular copyright holder is
   3.426 +reinstated permanently if the copyright holder notifies you of the
   3.427 +violation by some reasonable means, this is the first time you have
   3.428 +received notice of violation of this License (for any work) from that
   3.429 +copyright holder, and you cure the violation prior to 30 days after
   3.430 +your receipt of the notice.
   3.431 +
   3.432 +  Termination of your rights under this section does not terminate the
   3.433 +licenses of parties who have received copies or rights from you under
   3.434 +this License.  If your rights have been terminated and not permanently
   3.435 +reinstated, you do not qualify to receive new licenses for the same
   3.436 +material under section 10.
   3.437 +
   3.438 +  9. Acceptance Not Required for Having Copies.
   3.439 +
   3.440 +  You are not required to accept this License in order to receive or
   3.441 +run a copy of the Program.  Ancillary propagation of a covered work
   3.442 +occurring solely as a consequence of using peer-to-peer transmission
   3.443 +to receive a copy likewise does not require acceptance.  However,
   3.444 +nothing other than this License grants you permission to propagate or
   3.445 +modify any covered work.  These actions infringe copyright if you do
   3.446 +not accept this License.  Therefore, by modifying or propagating a
   3.447 +covered work, you indicate your acceptance of this License to do so.
   3.448 +
   3.449 +  10. Automatic Licensing of Downstream Recipients.
   3.450 +
   3.451 +  Each time you convey a covered work, the recipient automatically
   3.452 +receives a license from the original licensors, to run, modify and
   3.453 +propagate that work, subject to this License.  You are not responsible
   3.454 +for enforcing compliance by third parties with this License.
   3.455 +
   3.456 +  An "entity transaction" is a transaction transferring control of an
   3.457 +organization, or substantially all assets of one, or subdividing an
   3.458 +organization, or merging organizations.  If propagation of a covered
   3.459 +work results from an entity transaction, each party to that
   3.460 +transaction who receives a copy of the work also receives whatever
   3.461 +licenses to the work the party's predecessor in interest had or could
   3.462 +give under the previous paragraph, plus a right to possession of the
   3.463 +Corresponding Source of the work from the predecessor in interest, if
   3.464 +the predecessor has it or can get it with reasonable efforts.
   3.465 +
   3.466 +  You may not impose any further restrictions on the exercise of the
   3.467 +rights granted or affirmed under this License.  For example, you may
   3.468 +not impose a license fee, royalty, or other charge for exercise of
   3.469 +rights granted under this License, and you may not initiate litigation
   3.470 +(including a cross-claim or counterclaim in a lawsuit) alleging that
   3.471 +any patent claim is infringed by making, using, selling, offering for
   3.472 +sale, or importing the Program or any portion of it.
   3.473 +
   3.474 +  11. Patents.
   3.475 +
   3.476 +  A "contributor" is a copyright holder who authorizes use under this
   3.477 +License of the Program or a work on which the Program is based.  The
   3.478 +work thus licensed is called the contributor's "contributor version".
   3.479 +
   3.480 +  A contributor's "essential patent claims" are all patent claims
   3.481 +owned or controlled by the contributor, whether already acquired or
   3.482 +hereafter acquired, that would be infringed by some manner, permitted
   3.483 +by this License, of making, using, or selling its contributor version,
   3.484 +but do not include claims that would be infringed only as a
   3.485 +consequence of further modification of the contributor version.  For
   3.486 +purposes of this definition, "control" includes the right to grant
   3.487 +patent sublicenses in a manner consistent with the requirements of
   3.488 +this License.
   3.489 +
   3.490 +  Each contributor grants you a non-exclusive, worldwide, royalty-free
   3.491 +patent license under the contributor's essential patent claims, to
   3.492 +make, use, sell, offer for sale, import and otherwise run, modify and
   3.493 +propagate the contents of its contributor version.
   3.494 +
   3.495 +  In the following three paragraphs, a "patent license" is any express
   3.496 +agreement or commitment, however denominated, not to enforce a patent
   3.497 +(such as an express permission to practice a patent or covenant not to
   3.498 +sue for patent infringement).  To "grant" such a patent license to a
   3.499 +party means to make such an agreement or commitment not to enforce a
   3.500 +patent against the party.
   3.501 +
   3.502 +  If you convey a covered work, knowingly relying on a patent license,
   3.503 +and the Corresponding Source of the work is not available for anyone
   3.504 +to copy, free of charge and under the terms of this License, through a
   3.505 +publicly available network server or other readily accessible means,
   3.506 +then you must either (1) cause the Corresponding Source to be so
   3.507 +available, or (2) arrange to deprive yourself of the benefit of the
   3.508 +patent license for this particular work, or (3) arrange, in a manner
   3.509 +consistent with the requirements of this License, to extend the patent
   3.510 +license to downstream recipients.  "Knowingly relying" means you have
   3.511 +actual knowledge that, but for the patent license, your conveying the
   3.512 +covered work in a country, or your recipient's use of the covered work
   3.513 +in a country, would infringe one or more identifiable patents in that
   3.514 +country that you have reason to believe are valid.
   3.515 +
   3.516 +  If, pursuant to or in connection with a single transaction or
   3.517 +arrangement, you convey, or propagate by procuring conveyance of, a
   3.518 +covered work, and grant a patent license to some of the parties
   3.519 +receiving the covered work authorizing them to use, propagate, modify
   3.520 +or convey a specific copy of the covered work, then the patent license
   3.521 +you grant is automatically extended to all recipients of the covered
   3.522 +work and works based on it.
   3.523 +
   3.524 +  A patent license is "discriminatory" if it does not include within
   3.525 +the scope of its coverage, prohibits the exercise of, or is
   3.526 +conditioned on the non-exercise of one or more of the rights that are
   3.527 +specifically granted under this License.  You may not convey a covered
   3.528 +work if you are a party to an arrangement with a third party that is
   3.529 +in the business of distributing software, under which you make payment
   3.530 +to the third party based on the extent of your activity of conveying
   3.531 +the work, and under which the third party grants, to any of the
   3.532 +parties who would receive the covered work from you, a discriminatory
   3.533 +patent license (a) in connection with copies of the covered work
   3.534 +conveyed by you (or copies made from those copies), or (b) primarily
   3.535 +for and in connection with specific products or compilations that
   3.536 +contain the covered work, unless you entered into that arrangement,
   3.537 +or that patent license was granted, prior to 28 March 2007.
   3.538 +
   3.539 +  Nothing in this License shall be construed as excluding or limiting
   3.540 +any implied license or other defenses to infringement that may
   3.541 +otherwise be available to you under applicable patent law.
   3.542 +
   3.543 +  12. No Surrender of Others' Freedom.
   3.544 +
   3.545 +  If conditions are imposed on you (whether by court order, agreement or
   3.546 +otherwise) that contradict the conditions of this License, they do not
   3.547 +excuse you from the conditions of this License.  If you cannot convey a
   3.548 +covered work so as to satisfy simultaneously your obligations under this
   3.549 +License and any other pertinent obligations, then as a consequence you may
   3.550 +not convey it at all.  For example, if you agree to terms that obligate you
   3.551 +to collect a royalty for further conveying from those to whom you convey
   3.552 +the Program, the only way you could satisfy both those terms and this
   3.553 +License would be to refrain entirely from conveying the Program.
   3.554 +
   3.555 +  13. Use with the GNU Affero General Public License.
   3.556 +
   3.557 +  Notwithstanding any other provision of this License, you have
   3.558 +permission to link or combine any covered work with a work licensed
   3.559 +under version 3 of the GNU Affero General Public License into a single
   3.560 +combined work, and to convey the resulting work.  The terms of this
   3.561 +License will continue to apply to the part which is the covered work,
   3.562 +but the special requirements of the GNU Affero General Public License,
   3.563 +section 13, concerning interaction through a network will apply to the
   3.564 +combination as such.
   3.565 +
   3.566 +  14. Revised Versions of this License.
   3.567 +
   3.568 +  The Free Software Foundation may publish revised and/or new versions of
   3.569 +the GNU General Public License from time to time.  Such new versions will
   3.570 +be similar in spirit to the present version, but may differ in detail to
   3.571 +address new problems or concerns.
   3.572 +
   3.573 +  Each version is given a distinguishing version number.  If the
   3.574 +Program specifies that a certain numbered version of the GNU General
   3.575 +Public License "or any later version" applies to it, you have the
   3.576 +option of following the terms and conditions either of that numbered
   3.577 +version or of any later version published by the Free Software
   3.578 +Foundation.  If the Program does not specify a version number of the
   3.579 +GNU General Public License, you may choose any version ever published
   3.580 +by the Free Software Foundation.
   3.581 +
   3.582 +  If the Program specifies that a proxy can decide which future
   3.583 +versions of the GNU General Public License can be used, that proxy's
   3.584 +public statement of acceptance of a version permanently authorizes you
   3.585 +to choose that version for the Program.
   3.586 +
   3.587 +  Later license versions may give you additional or different
   3.588 +permissions.  However, no additional obligations are imposed on any
   3.589 +author or copyright holder as a result of your choosing to follow a
   3.590 +later version.
   3.591 +
   3.592 +  15. Disclaimer of Warranty.
   3.593 +
   3.594 +  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
   3.595 +APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
   3.596 +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
   3.597 +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
   3.598 +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   3.599 +PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
   3.600 +IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
   3.601 +ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
   3.602 +
   3.603 +  16. Limitation of Liability.
   3.604 +
   3.605 +  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
   3.606 +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
   3.607 +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
   3.608 +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
   3.609 +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
   3.610 +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
   3.611 +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
   3.612 +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
   3.613 +SUCH DAMAGES.
   3.614 +
   3.615 +  17. Interpretation of Sections 15 and 16.
   3.616 +
   3.617 +  If the disclaimer of warranty and limitation of liability provided
   3.618 +above cannot be given local legal effect according to their terms,
   3.619 +reviewing courts shall apply local law that most closely approximates
   3.620 +an absolute waiver of all civil liability in connection with the
   3.621 +Program, unless a warranty or assumption of liability accompanies a
   3.622 +copy of the Program in return for a fee.
   3.623 +
   3.624 +                     END OF TERMS AND CONDITIONS
   3.625 +
   3.626 +            How to Apply These Terms to Your New Programs
   3.627 +
   3.628 +  If you develop a new program, and you want it to be of the greatest
   3.629 +possible use to the public, the best way to achieve this is to make it
   3.630 +free software which everyone can redistribute and change under these terms.
   3.631 +
   3.632 +  To do so, attach the following notices to the program.  It is safest
   3.633 +to attach them to the start of each source file to most effectively
   3.634 +state the exclusion of warranty; and each file should have at least
   3.635 +the "copyright" line and a pointer to where the full notice is found.
   3.636 +
   3.637 +    <one line to give the program's name and a brief idea of what it does.>
   3.638 +    Copyright (C) <year>  <name of author>
   3.639 +
   3.640 +    This program is free software: you can redistribute it and/or modify
   3.641 +    it under the terms of the GNU General Public License as published by
   3.642 +    the Free Software Foundation, either version 3 of the License, or
   3.643 +    (at your option) any later version.
   3.644 +
   3.645 +    This program is distributed in the hope that it will be useful,
   3.646 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
   3.647 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   3.648 +    GNU General Public License for more details.
   3.649 +
   3.650 +    You should have received a copy of the GNU General Public License
   3.651 +    along with this program.  If not, see <http://www.gnu.org/licenses/>.
   3.652 +
   3.653 +Also add information on how to contact you by electronic and paper mail.
   3.654 +
   3.655 +  If the program does terminal interaction, make it output a short
   3.656 +notice like this when it starts in an interactive mode:
   3.657 +
   3.658 +    <program>  Copyright (C) <year>  <name of author>
   3.659 +    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
   3.660 +    This is free software, and you are welcome to redistribute it
   3.661 +    under certain conditions; type `show c' for details.
   3.662 +
   3.663 +The hypothetical commands `show w' and `show c' should show the appropriate
   3.664 +parts of the General Public License.  Of course, your program's commands
   3.665 +might be different; for a GUI interface, you would use an "about box".
   3.666 +
   3.667 +  You should also get your employer (if you work as a programmer) or school,
   3.668 +if any, to sign a "copyright disclaimer" for the program, if necessary.
   3.669 +For more information on this, and how to apply and follow the GNU GPL, see
   3.670 +<http://www.gnu.org/licenses/>.
   3.671 +
   3.672 +  The GNU General Public License does not permit incorporating your program
   3.673 +into proprietary programs.  If your program is a subroutine library, you
   3.674 +may consider it more useful to permit linking proprietary applications with
   3.675 +the library.  If this is what you want to do, use the GNU Lesser General
   3.676 +Public License instead of this License.  But first, please read
   3.677 +<http://www.gnu.org/philosophy/why-not-lgpl.html>.

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/libs/drawtext/COPYING.LESSER	Sun May 31 00:40:26 2015 +0300
     4.3 @@ -0,0 +1,165 @@
     4.4 +                   GNU LESSER GENERAL PUBLIC LICENSE
     4.5 +                       Version 3, 29 June 2007
     4.6 +
     4.7 + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
     4.8 + Everyone is permitted to copy and distribute verbatim copies
     4.9 + of this license document, but changing it is not allowed.
    4.10 +
    4.11 +
    4.12 +  This version of the GNU Lesser General Public License incorporates
    4.13 +the terms and conditions of version 3 of the GNU General Public
    4.14 +License, supplemented by the additional permissions listed below.
    4.15 +
    4.16 +  0. Additional Definitions.
    4.17 +
    4.18 +  As used herein, "this License" refers to version 3 of the GNU Lesser
    4.19 +General Public License, and the "GNU GPL" refers to version 3 of the GNU
    4.20 +General Public License.
    4.21 +
    4.22 +  "The Library" refers to a covered work governed by this License,
    4.23 +other than an Application or a Combined Work as defined below.
    4.24 +
    4.25 +  An "Application" is any work that makes use of an interface provided
    4.26 +by the Library, but which is not otherwise based on the Library.
    4.27 +Defining a subclass of a class defined by the Library is deemed a mode
    4.28 +of using an interface provided by the Library.
    4.29 +
    4.30 +  A "Combined Work" is a work produced by combining or linking an
    4.31 +Application with the Library.  The particular version of the Library
    4.32 +with which the Combined Work was made is also called the "Linked
    4.33 +Version".
    4.34 +
    4.35 +  The "Minimal Corresponding Source" for a Combined Work means the
    4.36 +Corresponding Source for the Combined Work, excluding any source code
    4.37 +for portions of the Combined Work that, considered in isolation, are
    4.38 +based on the Application, and not on the Linked Version.
    4.39 +
    4.40 +  The "Corresponding Application Code" for a Combined Work means the
    4.41 +object code and/or source code for the Application, including any data
    4.42 +and utility programs needed for reproducing the Combined Work from the
    4.43 +Application, but excluding the System Libraries of the Combined Work.
    4.44 +
    4.45 +  1. Exception to Section 3 of the GNU GPL.
    4.46 +
    4.47 +  You may convey a covered work under sections 3 and 4 of this License
    4.48 +without being bound by section 3 of the GNU GPL.
    4.49 +
    4.50 +  2. Conveying Modified Versions.
    4.51 +
    4.52 +  If you modify a copy of the Library, and, in your modifications, a
    4.53 +facility refers to a function or data to be supplied by an Application
    4.54 +that uses the facility (other than as an argument passed when the
    4.55 +facility is invoked), then you may convey a copy of the modified
    4.56 +version:
    4.57 +
    4.58 +   a) under this License, provided that you make a good faith effort to
    4.59 +   ensure that, in the event an Application does not supply the
    4.60 +   function or data, the facility still operates, and performs
    4.61 +   whatever part of its purpose remains meaningful, or
    4.62 +
    4.63 +   b) under the GNU GPL, with none of the additional permissions of
    4.64 +   this License applicable to that copy.
    4.65 +
    4.66 +  3. Object Code Incorporating Material from Library Header Files.
    4.67 +
    4.68 +  The object code form of an Application may incorporate material from
    4.69 +a header file that is part of the Library.  You may convey such object
    4.70 +code under terms of your choice, provided that, if the incorporated
    4.71 +material is not limited to numerical parameters, data structure
    4.72 +layouts and accessors, or small macros, inline functions and templates
    4.73 +(ten or fewer lines in length), you do both of the following:
    4.74 +
    4.75 +   a) Give prominent notice with each copy of the object code that the
    4.76 +   Library is used in it and that the Library and its use are
    4.77 +   covered by this License.
    4.78 +
    4.79 +   b) Accompany the object code with a copy of the GNU GPL and this license
    4.80 +   document.
    4.81 +
    4.82 +  4. Combined Works.
    4.83 +
    4.84 +  You may convey a Combined Work under terms of your choice that,
    4.85 +taken together, effectively do not restrict modification of the
    4.86 +portions of the Library contained in the Combined Work and reverse
    4.87 +engineering for debugging such modifications, if you also do each of
    4.88 +the following:
    4.89 +
    4.90 +   a) Give prominent notice with each copy of the Combined Work that
    4.91 +   the Library is used in it and that the Library and its use are
    4.92 +   covered by this License.
    4.93 +
    4.94 +   b) Accompany the Combined Work with a copy of the GNU GPL and this license
    4.95 +   document.
    4.96 +
    4.97 +   c) For a Combined Work that displays copyright notices during
    4.98 +   execution, include the copyright notice for the Library among
    4.99 +   these notices, as well as a reference directing the user to the
   4.100 +   copies of the GNU GPL and this license document.
   4.101 +
   4.102 +   d) Do one of the following:
   4.103 +
   4.104 +       0) Convey the Minimal Corresponding Source under the terms of this
   4.105 +       License, and the Corresponding Application Code in a form
   4.106 +       suitable for, and under terms that permit, the user to
   4.107 +       recombine or relink the Application with a modified version of
   4.108 +       the Linked Version to produce a modified Combined Work, in the
   4.109 +       manner specified by section 6 of the GNU GPL for conveying
   4.110 +       Corresponding Source.
   4.111 +
   4.112 +       1) Use a suitable shared library mechanism for linking with the
   4.113 +       Library.  A suitable mechanism is one that (a) uses at run time
   4.114 +       a copy of the Library already present on the user's computer
   4.115 +       system, and (b) will operate properly with a modified version
   4.116 +       of the Library that is interface-compatible with the Linked
   4.117 +       Version.
   4.118 +
   4.119 +   e) Provide Installation Information, but only if you would otherwise
   4.120 +   be required to provide such information under section 6 of the
   4.121 +   GNU GPL, and only to the extent that such information is
   4.122 +   necessary to install and execute a modified version of the
   4.123 +   Combined Work produced by recombining or relinking the
   4.124 +   Application with a modified version of the Linked Version. (If
   4.125 +   you use option 4d0, the Installation Information must accompany
   4.126 +   the Minimal Corresponding Source and Corresponding Application
   4.127 +   Code. If you use option 4d1, you must provide the Installation
   4.128 +   Information in the manner specified by section 6 of the GNU GPL
   4.129 +   for conveying Corresponding Source.)
   4.130 +
   4.131 +  5. Combined Libraries.
   4.132 +
   4.133 +  You may place library facilities that are a work based on the
   4.134 +Library side by side in a single library together with other library
   4.135 +facilities that are not Applications and are not covered by this
   4.136 +License, and convey such a combined library under terms of your
   4.137 +choice, if you do both of the following:
   4.138 +
   4.139 +   a) Accompany the combined library with a copy of the same work based
   4.140 +   on the Library, uncombined with any other library facilities,
   4.141 +   conveyed under the terms of this License.
   4.142 +
   4.143 +   b) Give prominent notice with the combined library that part of it
   4.144 +   is a work based on the Library, and explaining where to find the
   4.145 +   accompanying uncombined form of the same work.
   4.146 +
   4.147 +  6. Revised Versions of the GNU Lesser General Public License.
   4.148 +
   4.149 +  The Free Software Foundation may publish revised and/or new versions
   4.150 +of the GNU Lesser General Public License from time to time. Such new
   4.151 +versions will be similar in spirit to the present version, but may
   4.152 +differ in detail to address new problems or concerns.
   4.153 +
   4.154 +  Each version is given a distinguishing version number. If the
   4.155 +Library as you received it specifies that a certain numbered version
   4.156 +of the GNU Lesser General Public License "or any later version"
   4.157 +applies to it, you have the option of following the terms and
   4.158 +conditions either of that published version or of any later version
   4.159 +published by the Free Software Foundation. If the Library as you
   4.160 +received it does not specify a version number of the GNU Lesser
   4.161 +General Public License, you may choose any version of the GNU Lesser
   4.162 +General Public License ever published by the Free Software Foundation.
   4.163 +
   4.164 +  If the Library as you received it specifies that a proxy can decide
   4.165 +whether future versions of the GNU Lesser General Public License shall
   4.166 +apply, that proxy's public statement of acceptance of any version is
   4.167 +permanent authorization for you to choose that version for the
   4.168 +Library.

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/libs/drawtext/README	Sun May 31 00:40:26 2015 +0300
     5.3 @@ -0,0 +1,19 @@
     5.4 +libdrawtext - 0.2.1
     5.5 +-------------------
     5.6 +
     5.7 +Libdrawtext is a simple library for fast anti-aliased text rendering in OpenGL.
     5.8 +
     5.9 +Copyright (C) 2011-2014 John Tsiombikas <nuclear@member.fsf.org>
    5.10 +You may freely use, modify and/or redistribute libdrawtext, under the terms of
    5.11 +the GNU Lesser General Public License (LGPL) version 3 (or at your option, any
    5.12 +later version published by the Free Software Foundation). See COPYING, and
    5.13 +COPYING.LESSER for details.
    5.14 +
    5.15 +website: http://nuclear.mutantstargoat.com/sw/libdrawtext
    5.16 +
    5.17 +master repository (hg): http://nuclear.mutantstargoat.com/hg/libdrawtext
    5.18 +mirror repository (git): https://github.com/jtsiomb/libdrawtext.git
    5.19 +
    5.20 +Feel free to send in bug reports, patches, and other comments to
    5.21 +nuclear@member.fsf.org
    5.22 +Only plain text email messages, hard-wrapped at 72 columns will be accepted.

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/libs/drawtext/drawgl.c	Sun May 31 00:40:26 2015 +0300
     6.3 @@ -0,0 +1,302 @@
     6.4 +/*
     6.5 +libdrawtext - a simple library for fast text rendering in OpenGL
     6.6 +Copyright (C) 2011-2012  John Tsiombikas <nuclear@member.fsf.org>
     6.7 +
     6.8 +This program is free software: you can redistribute it and/or modify
     6.9 +it under the terms of the GNU Lesser General Public License as published by
    6.10 +the Free Software Foundation, either version 3 of the License, or
    6.11 +(at your option) any later version.
    6.12 +
    6.13 +This program is distributed in the hope that it will be useful,
    6.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    6.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    6.16 +GNU Lesser General Public License for more details.
    6.17 +
    6.18 +You should have received a copy of the GNU Lesser General Public License
    6.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    6.20 +*/
    6.21 +#ifndef NO_OPENGL
    6.22 +#include <stdarg.h>
    6.23 +#include <math.h>
    6.24 +#include <ctype.h>
    6.25 +
    6.26 +#include <stdlib.h>
    6.27 +
    6.28 +#ifndef _MSC_VER
    6.29 +#include <alloca.h>
    6.30 +#else
    6.31 +#include <malloc.h>
    6.32 +#endif
    6.33 +
    6.34 +#ifdef TARGET_IPHONE
    6.35 +#include <OpenGLES/ES2/gl.h>
    6.36 +#define GL_ES
    6.37 +#elif defined(ANDROID)
    6.38 +#include <GLES2/gl2.h>
    6.39 +#define GL_ES
    6.40 +#else
    6.41 +#include <GL/glew.h>
    6.42 +#endif
    6.43 +
    6.44 +#include "drawtext.h"
    6.45 +#include "drawtext_impl.h"
    6.46 +
    6.47 +struct vertex {
    6.48 +	float x, y;
    6.49 +	float s, t;
    6.50 +};
    6.51 +
    6.52 +struct quad {
    6.53 +	struct vertex v[6];
    6.54 +};
    6.55 +
    6.56 +static void cleanup(void);
    6.57 +static void add_glyph(struct glyph *g, float x, float y);
    6.58 +
    6.59 +#define QBUF_SZ		512
    6.60 +static struct quad *qbuf;
    6.61 +static int num_quads;
    6.62 +static int vattr = -1;
    6.63 +static int tattr = -1;
    6.64 +static unsigned int font_tex;
    6.65 +static int buf_mode = DTX_NBF;
    6.66 +
    6.67 +
    6.68 +int dtx_gl_init(void)
    6.69 +{
    6.70 +	if(qbuf) {
    6.71 +		return 0;	/* already initialized */
    6.72 +	}
    6.73 +
    6.74 +#ifdef __glew_h__
    6.75 +	glewInit();
    6.76 +#endif
    6.77 +
    6.78 +	if(!(qbuf = malloc(QBUF_SZ * sizeof *qbuf))) {
    6.79 +		return -1;
    6.80 +	}
    6.81 +	num_quads = 0;
    6.82 +
    6.83 +	atexit(cleanup);
    6.84 +	return 0;
    6.85 +}
    6.86 +
    6.87 +static void cleanup(void)
    6.88 +{
    6.89 +	free(qbuf);
    6.90 +}
    6.91 +
    6.92 +
    6.93 +void dtx_vertex_attribs(int vert_attr, int tex_attr)
    6.94 +{
    6.95 +	vattr = vert_attr;
    6.96 +	tattr = tex_attr;
    6.97 +}
    6.98 +
    6.99 +static void set_glyphmap_texture(struct dtx_glyphmap *gmap)
   6.100 +{
   6.101 +	if(!gmap->tex) {
   6.102 +		glGenTextures(1, &gmap->tex);
   6.103 +		glBindTexture(GL_TEXTURE_2D, gmap->tex);
   6.104 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
   6.105 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   6.106 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   6.107 +		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   6.108 +
   6.109 +#ifdef GL_ES
   6.110 +		glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, gmap->xsz, gmap->ysz, 0, GL_ALPHA, GL_UNSIGNED_BYTE, gmap->pixels);
   6.111 +		glGenerateMipmap(GL_TEXTURE_2D);
   6.112 +#else
   6.113 +		gluBuild2DMipmaps(GL_TEXTURE_2D, GL_ALPHA, gmap->xsz, gmap->ysz, GL_ALPHA, GL_UNSIGNED_BYTE, gmap->pixels);
   6.114 +#endif
   6.115 +	}
   6.116 +
   6.117 +	if(font_tex != gmap->tex) {
   6.118 +		dtx_flush();
   6.119 +	}
   6.120 +	font_tex = gmap->tex;
   6.121 +}
   6.122 +
   6.123 +void dtx_glyph(int code)
   6.124 +{
   6.125 +	struct dtx_glyphmap *gmap;
   6.126 +
   6.127 +	if(!dtx_font || !(gmap = dtx_get_font_glyphmap(dtx_font, dtx_font_sz, code))) {
   6.128 +		return;
   6.129 +	}
   6.130 +	set_glyphmap_texture(gmap);
   6.131 +
   6.132 +	add_glyph(gmap->glyphs + code - gmap->cstart, 0, 0);
   6.133 +	dtx_flush();
   6.134 +}
   6.135 +
   6.136 +static const char *put_char(const char *str, float *pos_x, float *pos_y, int *should_flush)
   6.137 +{
   6.138 +	struct dtx_glyphmap *gmap;
   6.139 +	float px, py;
   6.140 +	int code = dtx_utf8_char_code(str);
   6.141 +	str = dtx_utf8_next_char((char*)str);
   6.142 +
   6.143 +	if(buf_mode == DTX_LBF && code == '\n') {
   6.144 +		*should_flush = 1;
   6.145 +	}
   6.146 +
   6.147 +	px = *pos_x;
   6.148 +	py = *pos_y;
   6.149 +
   6.150 +	if((gmap = dtx_proc_char(code, pos_x, pos_y))) {
   6.151 +		int idx = code - gmap->cstart;
   6.152 +
   6.153 +		set_glyphmap_texture(gmap);
   6.154 +		add_glyph(gmap->glyphs + idx, px, py);
   6.155 +	}
   6.156 +	return str;
   6.157 +}
   6.158 +
   6.159 +void dtx_string(const char *str)
   6.160 +{
   6.161 +	int should_flush = buf_mode == DTX_NBF;
   6.162 +	float pos_x = 0.0f;
   6.163 +	float pos_y = 0.0f;
   6.164 +
   6.165 +	if(!dtx_font) {
   6.166 +		return;
   6.167 +	}
   6.168 +
   6.169 +	while(*str) {
   6.170 +		str = put_char(str, &pos_x, &pos_y, &should_flush);
   6.171 +	}
   6.172 +
   6.173 +	if(should_flush) {
   6.174 +		dtx_flush();
   6.175 +	}
   6.176 +}
   6.177 +
   6.178 +void dtx_printf(const char *fmt, ...)
   6.179 +{
   6.180 +	va_list ap;
   6.181 +	int buf_size;
   6.182 +	char *buf, tmp;
   6.183 +
   6.184 +	if(!dtx_font) {
   6.185 +		return;
   6.186 +	}
   6.187 +
   6.188 +	va_start(ap, fmt);
   6.189 +	buf_size = vsnprintf(&tmp, 0, fmt, ap);
   6.190 +	va_end(ap);
   6.191 +
   6.192 +	if(buf_size == -1) {
   6.193 +		buf_size = 512;
   6.194 +	}
   6.195 +
   6.196 +	buf = alloca(buf_size + 1);
   6.197 +	va_start(ap, fmt);
   6.198 +	vsnprintf(buf, buf_size + 1, fmt, ap);
   6.199 +	va_end(ap);
   6.200 +
   6.201 +	dtx_string(buf);
   6.202 +}
   6.203 +
   6.204 +static void qvertex(struct vertex *v, float x, float y, float s, float t)
   6.205 +{
   6.206 +	v->x = x;
   6.207 +	v->y = y;
   6.208 +	v->s = s;
   6.209 +	v->t = t;
   6.210 +}
   6.211 +
   6.212 +static void add_glyph(struct glyph *g, float x, float y)
   6.213 +{
   6.214 +	struct quad *qptr = qbuf + num_quads;
   6.215 +
   6.216 +	x -= g->orig_x;
   6.217 +	y -= g->orig_y;
   6.218 +
   6.219 +	qvertex(qptr->v + 0, x, y, g->nx, g->ny + g->nheight);
   6.220 +	qvertex(qptr->v + 1, x + g->width, y, g->nx + g->nwidth, g->ny + g->nheight);
   6.221 +	qvertex(qptr->v + 2, x + g->width, y + g->height, g->nx + g->nwidth, g->ny);
   6.222 +
   6.223 +	qvertex(qptr->v + 3, x, y, g->nx, g->ny + g->nheight);
   6.224 +	qvertex(qptr->v + 4, x + g->width, y + g->height, g->nx + g->nwidth, g->ny);
   6.225 +	qvertex(qptr->v + 5, x, y + g->height, g->nx, g->ny);
   6.226 +
   6.227 +	if(++num_quads >= QBUF_SZ) {
   6.228 +		dtx_flush();
   6.229 +	}
   6.230 +}
   6.231 +
   6.232 +void dtx_flush(void)
   6.233 +{
   6.234 +	int vbo;
   6.235 +
   6.236 +	if(!num_quads) {
   6.237 +		return;
   6.238 +	}
   6.239 +
   6.240 +	glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &vbo);
   6.241 +	glBindBuffer(GL_ARRAY_BUFFER, 0);
   6.242 +
   6.243 +#ifndef GL_ES
   6.244 +	glPushAttrib(GL_ENABLE_BIT);
   6.245 +	glEnable(GL_TEXTURE_2D);
   6.246 +#endif
   6.247 +	glBindTexture(GL_TEXTURE_2D, font_tex);
   6.248 +
   6.249 +	if(vattr != -1) {
   6.250 +		glEnableVertexAttribArray(vattr);
   6.251 +		glVertexAttribPointer(vattr, 2, GL_FLOAT, 0, sizeof(struct vertex), qbuf);
   6.252 +#ifndef GL_ES
   6.253 +	} else {
   6.254 +		glEnableClientState(GL_VERTEX_ARRAY);
   6.255 +		glVertexPointer(2, GL_FLOAT, sizeof(struct vertex), qbuf);
   6.256 +#endif
   6.257 +	}
   6.258 +	if(tattr != -1) {
   6.259 +		glEnableVertexAttribArray(tattr);
   6.260 +		glVertexAttribPointer(tattr, 2, GL_FLOAT, 0, sizeof(struct vertex), &qbuf->v[0].s);
   6.261 +#ifndef GL_ES
   6.262 +	} else {
   6.263 +		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
   6.264 +		glTexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), &qbuf->v[0].s);
   6.265 +#endif
   6.266 +	}
   6.267 +
   6.268 +	glEnable(GL_BLEND);
   6.269 +	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   6.270 +
   6.271 +	glDepthMask(0);
   6.272 +
   6.273 +	glDrawArrays(GL_TRIANGLES, 0, num_quads * 6);
   6.274 +
   6.275 +	glDepthMask(1);
   6.276 +
   6.277 +	if(vattr != -1) {
   6.278 +		glDisableVertexAttribArray(vattr);
   6.279 +#ifndef GL_ES
   6.280 +	} else {
   6.281 +		glDisableClientState(GL_VERTEX_ARRAY);
   6.282 +#endif
   6.283 +	}
   6.284 +	if(tattr != -1) {
   6.285 +		glDisableVertexAttribArray(tattr);
   6.286 +#ifndef GL_ES
   6.287 +	} else {
   6.288 +		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
   6.289 +#endif
   6.290 +	}
   6.291 +
   6.292 +#ifndef GL_ES
   6.293 +	glPopAttrib();
   6.294 +#else
   6.295 +	glDisable(GL_BLEND);
   6.296 +#endif
   6.297 +
   6.298 +	if(vbo) {
   6.299 +		glBindBuffer(GL_ARRAY_BUFFER, vbo);
   6.300 +	}
   6.301 +
   6.302 +	num_quads = 0;
   6.303 +}
   6.304 +
   6.305 +#endif	/* !def NO_OPENGL */

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/libs/drawtext/drawtext.h	Sun May 31 00:40:26 2015 +0300
     7.3 @@ -0,0 +1,188 @@
     7.4 +/*
     7.5 +libdrawtext - a simple library for fast text rendering in OpenGL
     7.6 +Copyright (C) 2011-2014  John Tsiombikas <nuclear@member.fsf.org>
     7.7 +
     7.8 +This program is free software: you can redistribute it and/or modify
     7.9 +it under the terms of the GNU Lesser General Public License as published by
    7.10 +the Free Software Foundation, either version 3 of the License, or
    7.11 +(at your option) any later version.
    7.12 +
    7.13 +This program is distributed in the hope that it will be useful,
    7.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    7.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    7.16 +GNU Lesser General Public License for more details.
    7.17 +
    7.18 +You should have received a copy of the GNU Lesser General Public License
    7.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    7.20 +*/
    7.21 +#ifndef LIBDRAWTEXT_H_
    7.22 +#define LIBDRAWTEXT_H_
    7.23 +
    7.24 +#include <stdio.h>
    7.25 +#include <stdlib.h>
    7.26 +
    7.27 +struct dtx_font;
    7.28 +struct dtx_glyphmap;
    7.29 +
    7.30 +/* draw buffering modes */
    7.31 +enum {
    7.32 +	DTX_NBF,	/* unbuffered */
    7.33 +	DTX_LBF,	/* line buffered */
    7.34 +	DTX_FBF		/* fully buffered */
    7.35 +};
    7.36 +
    7.37 +struct dtx_box {
    7.38 +	float x, y;
    7.39 +	float width, height;
    7.40 +};
    7.41 +
    7.42 +#ifdef __cplusplus
    7.43 +extern "C" {
    7.44 +#endif
    7.45 +
    7.46 +/* Open a truetype/opentype/whatever font.
    7.47 + *
    7.48 + * If sz is non-zero, the default ASCII glyphmap at the requested point size is
    7.49 + * automatically created as well, and ready to use.
    7.50 + *
    7.51 + * To use other unicode ranges and different font sizes you must first call
    7.52 + * dtx_prepare or dtx_prepare_range before issuing any drawing calls, otherwise
    7.53 + * nothing will be rendered.
    7.54 + */
    7.55 +struct dtx_font *dtx_open_font(const char *fname, int sz);
    7.56 +/* open a font by loading a precompiled glyphmap (see: dtx_save_glyphmap)
    7.57 + * this works even when compiled without freetype support
    7.58 + */
    7.59 +struct dtx_font *dtx_open_font_glyphmap(const char *fname);
    7.60 +/* close a font opened by either of the above */
    7.61 +void dtx_close_font(struct dtx_font *fnt);
    7.62 +
    7.63 +/* prepare an ASCII glyphmap for the specified font size */
    7.64 +void dtx_prepare(struct dtx_font *fnt, int sz);
    7.65 +/* prepare an arbitrary unicode range glyphmap for the specified font size */
    7.66 +void dtx_prepare_range(struct dtx_font *fnt, int sz, int cstart, int cend);
    7.67 +
    7.68 +/* Finds the glyphmap that contains the specified character code and matches the requested size
    7.69 + * Returns null if it hasn't been created (you should call dtx_prepare/dtx_prepare_range).
    7.70 + */
    7.71 +struct dtx_glyphmap *dtx_get_font_glyphmap(struct dtx_font *fnt, int sz, int code);
    7.72 +
    7.73 +/* Finds the glyphmap that contains the specified unicode range and matches the requested font size
    7.74 + * Will automatically generate one if it can't find it.
    7.75 + */
    7.76 +struct dtx_glyphmap *dtx_get_font_glyphmap_range(struct dtx_font *fnt, int sz, int cstart, int cend);
    7.77 +
    7.78 +/* Creates and returns a glyphmap for a particular unicode range and font size.
    7.79 + * The generated glyphmap is added to the font's list of glyphmaps.
    7.80 + */
    7.81 +struct dtx_glyphmap *dtx_create_glyphmap_range(struct dtx_font *fnt, int sz, int cstart, int cend);
    7.82 +/* free a glyphmap */
    7.83 +void dtx_free_glyphmap(struct dtx_glyphmap *gmap);
    7.84 +
    7.85 +/* returns a pointer to the raster image of a glyphmap (1 byte per pixel grayscale) */
    7.86 +unsigned char *dtx_get_glyphmap_image(struct dtx_glyphmap *gmap);
    7.87 +/* returns the width of the glyphmap image in pixels */
    7.88 +int dtx_get_glyphmap_width(struct dtx_glyphmap *gmap);
    7.89 +/* returns the height of the glyphmap image in pixels */
    7.90 +int dtx_get_glyphmap_height(struct dtx_glyphmap *gmap);
    7.91 +
    7.92 +/* The following functions can be used even when the library is compiled without
    7.93 + * freetype support.
    7.94 + */
    7.95 +struct dtx_glyphmap *dtx_load_glyphmap(const char *fname);
    7.96 +struct dtx_glyphmap *dtx_load_glyphmap_stream(FILE *fp);
    7.97 +int dtx_save_glyphmap(const char *fname, const struct dtx_glyphmap *gmap);
    7.98 +int dtx_save_glyphmap_stream(FILE *fp, const struct dtx_glyphmap *gmap);
    7.99 +
   7.100 +/* adds a glyphmap to a font */
   7.101 +void dtx_add_glyphmap(struct dtx_font *fnt, struct dtx_glyphmap *gmap);
   7.102 +
   7.103 +/* ---- rendering ---- */
   7.104 +
   7.105 +/* before drawing anything this function must set the font to use */
   7.106 +void dtx_use_font(struct dtx_font *fnt, int sz);
   7.107 +
   7.108 +/* sets the buffering mode
   7.109 + * - DTX_NBUF: every call to dtx_string gets rendered immediately.
   7.110 + * - DTX_LBUF: renders when the buffer is full or the string contains a newline.
   7.111 + * - DTX_FBUF: renders only when the buffer is full (you must call dtx_flush explicitly).
   7.112 + */
   7.113 +void dtx_draw_buffering(int mode);
   7.114 +
   7.115 +/* Sets the vertex attribute indices to use for passing vertex and texture coordinate
   7.116 + * data. By default both are -1 which means you don't have to use a shader, and if you
   7.117 + * do they are accessible through gl_Vertex and gl_MultiTexCoord0, as usual.
   7.118 + *
   7.119 + * NOTE: If you are using OpenGL ES 2.x or OpenGL >= 3.1 pure (non-compatibility) context
   7.120 + * you must specify valid attribute indices.
   7.121 + */
   7.122 +void dtx_vertex_attribs(int vert_attr, int tex_attr);
   7.123 +
   7.124 +/* draws a single glyph at the origin */
   7.125 +void dtx_glyph(int code);
   7.126 +/* draws a utf-8 string starting at the origin. \n \r and \t are handled appropriately. */
   7.127 +void dtx_string(const char *str);
   7.128 +
   7.129 +void dtx_printf(const char *fmt, ...);
   7.130 +
   7.131 +/* render any pending glyphs (see dtx_draw_buffering) */
   7.132 +void dtx_flush(void);
   7.133 +
   7.134 +
   7.135 +/* ---- encodings ---- */
   7.136 +
   7.137 +/* returns a pointer to the next character in a utf-8 stream */
   7.138 +char *dtx_utf8_next_char(char *str);
   7.139 +
   7.140 +/* returns the unicode character codepoint of the utf-8 character starting at str */
   7.141 +int dtx_utf8_char_code(const char *str);
   7.142 +
   7.143 +/* returns the number of bytes of the utf-8 character starting at str */
   7.144 +int dtx_utf8_nbytes(const char *str);
   7.145 +
   7.146 +/* returns the number of utf-8 character in a zero-terminated utf-8 string */
   7.147 +int dtx_utf8_char_count(const char *str);
   7.148 +
   7.149 +/* Converts a unicode code-point to a utf-8 character by filling in the buffer
   7.150 + * passed at the second argument, and returns the number of bytes taken by that
   7.151 + * utf-8 character.
   7.152 + * It's valid to pass a null buffer pointer, in which case only the byte count is
   7.153 + * returned (useful to figure out how much memory to allocate for a buffer).
   7.154 + */
   7.155 +size_t dtx_utf8_from_char_code(int code, char *buf);
   7.156 +
   7.157 +/* Converts a unicode utf-16 wchar_t string to utf-8, filling in the buffer passed
   7.158 + * at the second argument. Returns the size of the resulting string in bytes.
   7.159 + *
   7.160 + * It's valid to pass a null buffer pointer, in which case only the size gets
   7.161 + * calculated and returned, which is useful for figuring out how much memory to
   7.162 + * allocate for the utf-8 buffer.
   7.163 + */
   7.164 +size_t dtx_utf8_from_string(const wchar_t *str, char *buf);
   7.165 +
   7.166 +
   7.167 +/* ---- metrics ---- */
   7.168 +float dtx_line_height(void);
   7.169 +
   7.170 +/* rendered dimensions of a single glyph */
   7.171 +void dtx_glyph_box(int code, struct dtx_box *box);
   7.172 +float dtx_glyph_width(int code);
   7.173 +float dtx_glyph_height(int code);
   7.174 +
   7.175 +/* rendered dimensions of a string */
   7.176 +void dtx_string_box(const char *str, struct dtx_box *box);
   7.177 +float dtx_string_width(const char *str);
   7.178 +float dtx_string_height(const char *str);
   7.179 +
   7.180 +/* returns the horizontal position of the n-th character of the rendered string
   7.181 + * (useful for placing cursors)
   7.182 + */
   7.183 +float dtx_char_pos(const char *str, int n);
   7.184 +
   7.185 +int dtx_char_at_pt(const char *str, float pt);
   7.186 +
   7.187 +#ifdef __cplusplus
   7.188 +}
   7.189 +#endif
   7.190 +
   7.191 +#endif	/* LIBDRAWTEXT_H_ */

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/libs/drawtext/drawtext_impl.h	Sun May 31 00:40:26 2015 +0300
     8.3 @@ -0,0 +1,72 @@
     8.4 +/*
     8.5 +libdrawtext - a simple library for fast text rendering in OpenGL
     8.6 +Copyright (C) 2011-2012  John Tsiombikas <nuclear@member.fsf.org>
     8.7 +
     8.8 +This program is free software: you can redistribute it and/or modify
     8.9 +it under the terms of the GNU Lesser General Public License as published by
    8.10 +the Free Software Foundation, either version 3 of the License, or
    8.11 +(at your option) any later version.
    8.12 +
    8.13 +This program is distributed in the hope that it will be useful,
    8.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    8.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    8.16 +GNU Lesser General Public License for more details.
    8.17 +
    8.18 +You should have received a copy of the GNU Lesser General Public License
    8.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    8.20 +*/
    8.21 +#ifndef TEXT_IMPL_H_
    8.22 +#define TEXT_IMPL_H_
    8.23 +
    8.24 +struct glyph {
    8.25 +	int code;
    8.26 +	float x, y, width, height;
    8.27 +	/* normalized coords [0, 1] */
    8.28 +	float nx, ny, nwidth, nheight;
    8.29 +	float orig_x, orig_y;
    8.30 +	float advance;
    8.31 +	struct glyph *next;
    8.32 +};
    8.33 +
    8.34 +struct dtx_glyphmap {
    8.35 +	int ptsize;
    8.36 +
    8.37 +	int xsz, ysz;
    8.38 +	unsigned char *pixels;
    8.39 +	unsigned int tex;
    8.40 +
    8.41 +	int cstart, cend;	/* character range */
    8.42 +	int crange;
    8.43 +
    8.44 +	float line_advance;
    8.45 +
    8.46 +	struct glyph *glyphs;
    8.47 +	struct dtx_glyphmap *next;
    8.48 +};
    8.49 +
    8.50 +struct dtx_font {
    8.51 +	/* freetype FT_Face */
    8.52 +	void *face;
    8.53 +
    8.54 +	/* list of glyphmaps */
    8.55 +	struct dtx_glyphmap *gmaps;
    8.56 +
    8.57 +	/* last returned glyphmap (cache) */
    8.58 +	struct dtx_glyphmap *last_gmap;
    8.59 +};
    8.60 +
    8.61 +
    8.62 +struct dtx_font *dtx_font;
    8.63 +int dtx_font_sz;
    8.64 +
    8.65 +
    8.66 +#define fperror(str) \
    8.67 +	fprintf(stderr, "%s: %s: %s\n", __FUNCTION__, (str), strerror(errno))
    8.68 +
    8.69 +int dtx_gl_init(void);
    8.70 +
    8.71 +/* returns zero if it should NOT be printed and modifies xpos/ypos */
    8.72 +/* implemented in font.c */
    8.73 +struct dtx_glyphmap *dtx_proc_char(int code, float *xpos, float *ypos);
    8.74 +
    8.75 +#endif	/* TEXT_IMPL_H_ */

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/libs/drawtext/font.c	Sun May 31 00:40:26 2015 +0300
     9.3 @@ -0,0 +1,773 @@
     9.4 +/*
     9.5 +libdrawtext - a simple library for fast text rendering in OpenGL
     9.6 +Copyright (C) 2011-2014  John Tsiombikas <nuclear@member.fsf.org>
     9.7 +
     9.8 +This program is free software: you can redistribute it and/or modify
     9.9 +it under the terms of the GNU Lesser General Public License as published by
    9.10 +the Free Software Foundation, either version 3 of the License, or
    9.11 +(at your option) any later version.
    9.12 +
    9.13 +This program is distributed in the hope that it will be useful,
    9.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    9.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    9.16 +GNU Lesser General Public License for more details.
    9.17 +
    9.18 +You should have received a copy of the GNU Lesser General Public License
    9.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    9.20 +*/
    9.21 +#ifndef NO_FREETYPE
    9.22 +#define USE_FREETYPE
    9.23 +#endif
    9.24 +
    9.25 +#include <stdio.h>
    9.26 +#include <stdlib.h>
    9.27 +#include <string.h>
    9.28 +#include <math.h>
    9.29 +#include <limits.h>
    9.30 +#include <ctype.h>
    9.31 +#include <float.h>
    9.32 +#include <errno.h>
    9.33 +#ifdef USE_FREETYPE
    9.34 +#include <ft2build.h>
    9.35 +#include FT_FREETYPE_H
    9.36 +#endif
    9.37 +#include "drawtext.h"
    9.38 +#include "drawtext_impl.h"
    9.39 +
    9.40 +#define FTSZ_TO_PIXELS(x)	((x) / 64)
    9.41 +#define MAX_IMG_WIDTH		4096
    9.42 +
    9.43 +
    9.44 +#ifdef USE_FREETYPE
    9.45 +static int init_freetype(void);
    9.46 +static void cleanup(void);
    9.47 +
    9.48 +static void calc_best_size(int total_width, int max_gwidth, int max_gheight,
    9.49 +		int padding, int pow2, int *imgw, int *imgh);
    9.50 +static int next_pow2(int x);
    9.51 +
    9.52 +static FT_Library ft;
    9.53 +
    9.54 +
    9.55 +static int init_done;
    9.56 +
    9.57 +static int init_freetype(void)
    9.58 +{
    9.59 +	if(!init_done) {
    9.60 +		if(FT_Init_FreeType(&ft) != 0) {
    9.61 +			return -1;
    9.62 +		}
    9.63 +		atexit(cleanup);
    9.64 +		init_done = 1;
    9.65 +	}
    9.66 +	return 0;
    9.67 +}
    9.68 +
    9.69 +static void cleanup(void)
    9.70 +{
    9.71 +	if(init_done) {
    9.72 +		FT_Done_FreeType(ft);
    9.73 +	}
    9.74 +}
    9.75 +#endif	/* USE_FREETYPE */
    9.76 +
    9.77 +struct dtx_font *dtx_open_font(const char *fname, int sz)
    9.78 +{
    9.79 +	struct dtx_font *fnt = 0;
    9.80 +
    9.81 +#ifdef USE_FREETYPE
    9.82 +	init_freetype();
    9.83 +
    9.84 +	if(!(fnt = calloc(1, sizeof *fnt))) {
    9.85 +		fperror("failed to allocate font structure");
    9.86 +		return 0;
    9.87 +	}
    9.88 +
    9.89 +	if(FT_New_Face(ft, fname, 0, (FT_Face*)&fnt->face) != 0) {
    9.90 +		fprintf(stderr, "failed to open font file: %s\n", fname);
    9.91 +		return 0;
    9.92 +	}
    9.93 +
    9.94 +	/* pre-create the extended ASCII range glyphmap */
    9.95 +	if(sz) {
    9.96 +		dtx_prepare_range(fnt, sz, 0, 256);
    9.97 +
    9.98 +		if(!dtx_font) {
    9.99 +			dtx_use_font(fnt, sz);
   9.100 +		}
   9.101 +	}
   9.102 +#else
   9.103 +	fprintf(stderr, "ignoring call to dtx_open_font: not compiled with freetype support!\n");
   9.104 +#endif
   9.105 +
   9.106 +	return fnt;
   9.107 +}
   9.108 +
   9.109 +struct dtx_font *dtx_open_font_glyphmap(const char *fname)
   9.110 +{
   9.111 +	struct dtx_font *fnt;
   9.112 +	struct dtx_glyphmap *gmap;
   9.113 +
   9.114 +	if(!(fnt = calloc(1, sizeof *fnt))) {
   9.115 +		fperror("failed to allocate font structure");
   9.116 +		return 0;
   9.117 +	}
   9.118 +
   9.119 +	if(fname) {
   9.120 +		if(!(gmap = dtx_load_glyphmap(fname))) {
   9.121 +			free(fnt);
   9.122 +			return 0;
   9.123 +		}
   9.124 +
   9.125 +		dtx_add_glyphmap(fnt, gmap);
   9.126 +
   9.127 +		if(!dtx_font) {
   9.128 +			dtx_use_font(fnt, gmap->ptsize);
   9.129 +		}
   9.130 +	}
   9.131 +	return fnt;
   9.132 +}
   9.133 +
   9.134 +void dtx_close_font(struct dtx_font *fnt)
   9.135 +{
   9.136 +	if(!fnt) return;
   9.137 +
   9.138 +#ifdef USE_FREETYPE
   9.139 +	FT_Done_Face(fnt->face);
   9.140 +#endif
   9.141 +
   9.142 +	/* destroy the glyphmaps */
   9.143 +	while(fnt->gmaps) {
   9.144 +		void *tmp = fnt->gmaps;
   9.145 +		fnt->gmaps = fnt->gmaps->next;
   9.146 +		dtx_free_glyphmap(tmp);
   9.147 +	}
   9.148 +
   9.149 +	free(fnt);
   9.150 +}
   9.151 +
   9.152 +void dtx_prepare(struct dtx_font *fnt, int sz)
   9.153 +{
   9.154 +	if(!dtx_get_font_glyphmap_range(fnt, sz, 0, 256)) {
   9.155 +		fprintf(stderr, "%s: failed (sz: %d, range: 0-255 [ascii])\n", __FUNCTION__, sz);
   9.156 +	}
   9.157 +}
   9.158 +
   9.159 +void dtx_prepare_range(struct dtx_font *fnt, int sz, int cstart, int cend)
   9.160 +{
   9.161 +	if(!dtx_get_font_glyphmap_range(fnt, sz, cstart, cend)) {
   9.162 +		fprintf(stderr, "%s: failed (sz: %d, range: %d-%d)\n", __FUNCTION__, sz, cstart, cend);
   9.163 +	}
   9.164 +}
   9.165 +
   9.166 +struct dtx_glyphmap *dtx_get_font_glyphmap(struct dtx_font *fnt, int sz, int code)
   9.167 +{
   9.168 +	struct dtx_glyphmap *gm;
   9.169 +
   9.170 +	/* check to see if the last we've given out fits the bill */
   9.171 +	if(fnt->last_gmap && code >= fnt->last_gmap->cstart && code < fnt->last_gmap->cend && fnt->last_gmap->ptsize == sz) {
   9.172 +		return fnt->last_gmap;
   9.173 +	}
   9.174 +
   9.175 +	/* otherwise search for the appropriate glyphmap */
   9.176 +	gm = fnt->gmaps;
   9.177 +	while(gm) {
   9.178 +		if(code >= gm->cstart && code < gm->cend && sz == gm->ptsize) {
   9.179 +			fnt->last_gmap = gm;
   9.180 +			return gm;
   9.181 +		}
   9.182 +		gm = gm->next;
   9.183 +	}
   9.184 +	return 0;
   9.185 +}
   9.186 +
   9.187 +struct dtx_glyphmap *dtx_get_font_glyphmap_range(struct dtx_font *fnt, int sz, int cstart, int cend)
   9.188 +{
   9.189 +	struct dtx_glyphmap *gm;
   9.190 +
   9.191 +	/* search the available glyphmaps to see if we've got one that includes
   9.192 +	 * the requested range
   9.193 +	 */
   9.194 +	gm = fnt->gmaps;
   9.195 +	while(gm) {
   9.196 +		if(gm->cstart <= cstart && gm->cend >= cend && gm->ptsize == sz) {
   9.197 +			return gm;
   9.198 +		}
   9.199 +		gm = gm->next;
   9.200 +	}
   9.201 +
   9.202 +	/* not found, create one and add it to the list */
   9.203 +	if(!(gm = dtx_create_glyphmap_range(fnt, sz, cstart, cend))) {
   9.204 +		return 0;
   9.205 +	}
   9.206 +	return gm;
   9.207 +}
   9.208 +
   9.209 +struct dtx_glyphmap *dtx_create_glyphmap_range(struct dtx_font *fnt, int sz, int cstart, int cend)
   9.210 +{
   9.211 +	struct dtx_glyphmap *gmap = 0;
   9.212 +
   9.213 +#ifdef USE_FREETYPE
   9.214 +	FT_Face face = fnt->face;
   9.215 +	int i, j;
   9.216 +	int gx, gy;
   9.217 +	int padding = 4;
   9.218 +	int total_width, max_width, max_height;
   9.219 +
   9.220 +	FT_Set_Char_Size(fnt->face, 0, sz * 64, 72, 72);
   9.221 +
   9.222 +	if(!(gmap = calloc(1, sizeof *gmap))) {
   9.223 +		return 0;
   9.224 +	}
   9.225 +
   9.226 +	gmap->ptsize = sz;
   9.227 +	gmap->cstart = cstart;
   9.228 +	gmap->cend = cend;
   9.229 +	gmap->crange = cend - cstart;
   9.230 +	gmap->line_advance = FTSZ_TO_PIXELS((float)face->size->metrics.height);
   9.231 +
   9.232 +	if(!(gmap->glyphs = malloc(gmap->crange * sizeof *gmap->glyphs))) {
   9.233 +		free(gmap);
   9.234 +		return 0;
   9.235 +	}
   9.236 +
   9.237 +	total_width = padding;
   9.238 +	max_width = max_height = 0;
   9.239 +
   9.240 +	for(i=0; i<gmap->crange; i++) {
   9.241 +		int w, h;
   9.242 +
   9.243 +		FT_Load_Char(face, i + cstart, 0);
   9.244 +		w = FTSZ_TO_PIXELS(face->glyph->metrics.width);
   9.245 +		h = FTSZ_TO_PIXELS(face->glyph->metrics.height);
   9.246 +
   9.247 +		if(w > max_width) max_width = w;
   9.248 +		if(h > max_height) max_height = h;
   9.249 +
   9.250 +		total_width += w + padding;
   9.251 +	}
   9.252 +
   9.253 +	calc_best_size(total_width, max_width, max_height, padding, 1, &gmap->xsz, &gmap->ysz);
   9.254 +
   9.255 +	if(!(gmap->pixels = malloc(gmap->xsz * gmap->ysz))) {
   9.256 +		free(gmap->glyphs);
   9.257 +		free(gmap);
   9.258 +		return 0;
   9.259 +	}
   9.260 +	memset(gmap->pixels, 0, gmap->xsz * gmap->ysz);
   9.261 +
   9.262 +	gx = padding;
   9.263 +	gy = padding;
   9.264 +
   9.265 +	for(i=0; i<gmap->crange; i++) {
   9.266 +		float gwidth, gheight;
   9.267 +		unsigned char *src, *dst;
   9.268 +		FT_GlyphSlot glyph;
   9.269 +
   9.270 +		FT_Load_Char(face, i + cstart, FT_LOAD_RENDER);
   9.271 +		glyph = face->glyph;
   9.272 +		gwidth = FTSZ_TO_PIXELS((float)glyph->metrics.width);
   9.273 +		gheight = FTSZ_TO_PIXELS((float)glyph->metrics.height);
   9.274 +
   9.275 +		if(gx > gmap->xsz - gwidth - padding) {
   9.276 +			gx = padding;
   9.277 +			gy += max_height + padding;
   9.278 +		}
   9.279 +
   9.280 +		src = glyph->bitmap.buffer;
   9.281 +		dst = gmap->pixels + gy * gmap->xsz + gx;
   9.282 +
   9.283 +		for(j=0; j<glyph->bitmap.rows; j++) {
   9.284 +			memcpy(dst, src, glyph->bitmap.width);
   9.285 +			dst += gmap->xsz;
   9.286 +			src += glyph->bitmap.pitch;
   9.287 +		}
   9.288 +
   9.289 +		gmap->glyphs[i].code = i;
   9.290 +		gmap->glyphs[i].x = gx - 1;
   9.291 +		gmap->glyphs[i].y = gy - 1;
   9.292 +		gmap->glyphs[i].width = gwidth + 2;
   9.293 +		gmap->glyphs[i].height = gheight + 2;
   9.294 +		gmap->glyphs[i].orig_x = -FTSZ_TO_PIXELS((float)glyph->metrics.horiBearingX) + 1;
   9.295 +		gmap->glyphs[i].orig_y = FTSZ_TO_PIXELS((float)glyph->metrics.height - glyph->metrics.horiBearingY) + 1;
   9.296 +		gmap->glyphs[i].advance = FTSZ_TO_PIXELS((float)glyph->metrics.horiAdvance);
   9.297 +		/* also precalc normalized */
   9.298 +		gmap->glyphs[i].nx = (float)gmap->glyphs[i].x / (float)gmap->xsz;
   9.299 +		gmap->glyphs[i].ny = (float)gmap->glyphs[i].y / (float)gmap->ysz;
   9.300 +		gmap->glyphs[i].nwidth = (float)gmap->glyphs[i].width / (float)gmap->xsz;
   9.301 +		gmap->glyphs[i].nheight = (float)gmap->glyphs[i].height / (float)gmap->ysz;
   9.302 +
   9.303 +		gx += gwidth + padding;
   9.304 +	}
   9.305 +
   9.306 +	/* add it to the glyphmaps list of the font */
   9.307 +	dtx_add_glyphmap(fnt, gmap);
   9.308 +#endif	/* USE_FREETYPE */
   9.309 +
   9.310 +	return gmap;
   9.311 +}
   9.312 +
   9.313 +void dtx_free_glyphmap(struct dtx_glyphmap *gmap)
   9.314 +{
   9.315 +	if(gmap) {
   9.316 +		free(gmap->pixels);
   9.317 +		free(gmap->glyphs);
   9.318 +		free(gmap);
   9.319 +	}
   9.320 +}
   9.321 +
   9.322 +unsigned char *dtx_get_glyphmap_pixels(struct dtx_glyphmap *gmap)
   9.323 +{
   9.324 +	return gmap->pixels;
   9.325 +}
   9.326 +
   9.327 +int dtx_get_glyphmap_width(struct dtx_glyphmap *gmap)
   9.328 +{
   9.329 +	return gmap->xsz;
   9.330 +}
   9.331 +
   9.332 +int dtx_get_glyphmap_height(struct dtx_glyphmap *gmap)
   9.333 +{
   9.334 +	return gmap->ysz;
   9.335 +}
   9.336 +
   9.337 +struct dtx_glyphmap *dtx_load_glyphmap(const char *fname)
   9.338 +{
   9.339 +	FILE *fp;
   9.340 +	struct dtx_glyphmap *gmap;
   9.341 +
   9.342 +	if(!(fp = fopen(fname, "rb"))) {
   9.343 +		return 0;
   9.344 +	}
   9.345 +	gmap = dtx_load_glyphmap_stream(fp);
   9.346 +	fclose(fp);
   9.347 +	return gmap;
   9.348 +}
   9.349 +
   9.350 +struct dtx_glyphmap *dtx_load_glyphmap_stream(FILE *fp)
   9.351 +{
   9.352 +	char buf[512];
   9.353 +	int hdr_lines = 0;
   9.354 +	struct dtx_glyphmap *gmap;
   9.355 +	struct glyph *glyphs = 0;
   9.356 +	struct glyph *g;
   9.357 +	int min_code = INT_MAX;
   9.358 +	int max_code = INT_MIN;
   9.359 +	int i, max_pixval, num_pixels;
   9.360 +
   9.361 +	if(!(gmap = calloc(1, sizeof *gmap))) {
   9.362 +		fperror("failed to allocate glyphmap");
   9.363 +		return 0;
   9.364 +	}
   9.365 +	gmap->ptsize = -1;
   9.366 +	gmap->line_advance = FLT_MIN;
   9.367 +
   9.368 +	while(hdr_lines < 3) {
   9.369 +		char *line = buf;
   9.370 +		if(!fgets(buf, sizeof buf, fp)) {
   9.371 +			fperror("unexpected end of file");
   9.372 +			goto err;
   9.373 +		}
   9.374 +
   9.375 +		while(isspace(*line)) {
   9.376 +			line++;
   9.377 +		}
   9.378 +
   9.379 +		if(line[0] == '#') {
   9.380 +			int c, res;
   9.381 +			float x, y, xsz, ysz, orig_x, orig_y, adv, line_adv;
   9.382 +			int ptsize;
   9.383 +
   9.384 +			if((res = sscanf(line + 1, " size: %d\n", &ptsize)) == 1) {
   9.385 +				gmap->ptsize = ptsize;
   9.386 +
   9.387 +			} else if((res = sscanf(line + 1, " advance: %f\n", &line_adv)) == 1) {
   9.388 +				gmap->line_advance = line_adv;
   9.389 +
   9.390 +			} else if((res = sscanf(line + 1, " %d: %fx%f+%f+%f o:%f,%f adv:%f\n",
   9.391 +							&c, &xsz, &ysz, &x, &y, &orig_x, &orig_y, &adv)) == 8) {
   9.392 +				if(!(g = malloc(sizeof *g))) {
   9.393 +					fperror("failed to allocate glyph");
   9.394 +					goto err;
   9.395 +				}
   9.396 +				g->code = c;
   9.397 +				g->x = x;
   9.398 +				g->y = y;
   9.399 +				g->width = xsz;
   9.400 +				g->height = ysz;
   9.401 +				g->orig_x = orig_x;
   9.402 +				g->orig_y = orig_y;
   9.403 +				g->advance = adv;
   9.404 +				/* normalized coordinates will be precalculated after everything is loaded */
   9.405 +
   9.406 +				g->next = glyphs;
   9.407 +				glyphs = g;
   9.408 +
   9.409 +				if(c < min_code) {
   9.410 +					min_code = c;
   9.411 +				}
   9.412 +				if(c > max_code) {
   9.413 +					max_code = c;
   9.414 +				}
   9.415 +
   9.416 +			} else {
   9.417 +				fprintf(stderr, "%s: invalid glyph info line\n", __FUNCTION__);
   9.418 +				goto err;
   9.419 +			}
   9.420 +
   9.421 +		} else {
   9.422 +			switch(hdr_lines) {
   9.423 +			case 0:
   9.424 +				if(0[line] != 'P' || 1[line] != '6') {
   9.425 +					fprintf(stderr, "%s: invalid file format (magic)\n", __FUNCTION__);
   9.426 +					goto err;
   9.427 +				}
   9.428 +				break;
   9.429 +
   9.430 +			case 1:
   9.431 +				if(sscanf(line, "%d %d", &gmap->xsz, &gmap->ysz) != 2) {
   9.432 +					fprintf(stderr, "%s: invalid file format (dim)\n", __FUNCTION__);
   9.433 +					goto err;
   9.434 +				}
   9.435 +				break;
   9.436 +
   9.437 +			case 2:
   9.438 +				{
   9.439 +					char *endp;
   9.440 +					max_pixval = strtol(line, &endp, 10);
   9.441 +					if(endp == line) {
   9.442 +						fprintf(stderr, "%s: invalid file format (maxval)\n", __FUNCTION__);
   9.443 +						goto err;
   9.444 +					}
   9.445 +				}
   9.446 +				break;
   9.447 +
   9.448 +			default:
   9.449 +				break;	/* can't happen */
   9.450 +			}
   9.451 +			hdr_lines++;
   9.452 +		}
   9.453 +	}
   9.454 +
   9.455 +	if(gmap->ptsize == -1 || gmap->line_advance == FLT_MIN) {
   9.456 +		fprintf(stderr, "%s: invalid glyphmap, insufficient information in ppm comments\n", __FUNCTION__);
   9.457 +		goto err;
   9.458 +	}
   9.459 +
   9.460 +	/* precalculate normalized glyph coordinates */
   9.461 +	g = glyphs;
   9.462 +	while(g) {
   9.463 +		g->nx = g->x / gmap->xsz;
   9.464 +		g->ny = g->y / gmap->ysz;
   9.465 +		g->nwidth = g->width / gmap->xsz;
   9.466 +		g->nheight = g->height / gmap->ysz;
   9.467 +		g = g->next;
   9.468 +	}
   9.469 +
   9.470 +	num_pixels = gmap->xsz * gmap->ysz;
   9.471 +	if(!(gmap->pixels = malloc(num_pixels))) {
   9.472 +		fperror("failed to allocate pixels");
   9.473 +		goto err;
   9.474 +	}
   9.475 +
   9.476 +	for(i=0; i<num_pixels; i++) {
   9.477 +		long c = fgetc(fp);
   9.478 +		if(c == -1) {
   9.479 +			fprintf(stderr, "unexpected end of file while reading pixels\n");
   9.480 +			goto err;
   9.481 +		}
   9.482 +		gmap->pixels[i] = 255 * c / max_pixval;
   9.483 +		fseek(fp, 2, SEEK_CUR);
   9.484 +	}
   9.485 +
   9.486 +	gmap->cstart = min_code;
   9.487 +	gmap->cend = max_code + 1;
   9.488 +	gmap->crange = gmap->cend - gmap->cstart;
   9.489 +
   9.490 +	if(!(gmap->glyphs = calloc(gmap->crange, sizeof *gmap->glyphs))) {
   9.491 +		fperror("failed to allocate glyph info");
   9.492 +		goto err;
   9.493 +	}
   9.494 +
   9.495 +	while(glyphs) {
   9.496 +		struct glyph *g = glyphs;
   9.497 +		glyphs = glyphs->next;
   9.498 +
   9.499 +		gmap->glyphs[g->code - gmap->cstart] = *g;
   9.500 +		free(g);
   9.501 +	}
   9.502 +	return gmap;
   9.503 +
   9.504 +err:
   9.505 +	dtx_free_glyphmap(gmap);
   9.506 +	while(glyphs) {
   9.507 +		void *tmp = glyphs;
   9.508 +		glyphs = glyphs->next;
   9.509 +		free(tmp);
   9.510 +	}
   9.511 +	return 0;
   9.512 +}
   9.513 +
   9.514 +int dtx_save_glyphmap(const char *fname, const struct dtx_glyphmap *gmap)
   9.515 +{
   9.516 +	FILE *fp;
   9.517 +	int res;
   9.518 +
   9.519 +	if(!(fp = fopen(fname, "wb"))) {
   9.520 +		fprintf(stderr, "%s: failed to open file: %s: %s\n", __FUNCTION__, fname, strerror(errno));
   9.521 +		return -1;
   9.522 +	}
   9.523 +	res = dtx_save_glyphmap_stream(fp, gmap);
   9.524 +	fclose(fp);
   9.525 +	return res;
   9.526 +}
   9.527 +
   9.528 +int dtx_save_glyphmap_stream(FILE *fp, const struct dtx_glyphmap *gmap)
   9.529 +{
   9.530 +	int i, num_pixels;
   9.531 +	struct glyph *g = gmap->glyphs;
   9.532 +
   9.533 +	fprintf(fp, "P6\n%d %d\n", gmap->xsz, gmap->ysz);
   9.534 +	fprintf(fp, "# size: %d\n", gmap->ptsize);
   9.535 +	fprintf(fp, "# advance: %g\n", gmap->line_advance);
   9.536 +	for(i=0; i<gmap->crange; i++) {
   9.537 +		fprintf(fp, "# %d: %gx%g+%g+%g o:%g,%g adv:%g\n", g->code, g->width, g->height, g->x, g->y,
   9.538 +				g->orig_x, g->orig_y, g->advance);
   9.539 +		g++;
   9.540 +	}
   9.541 +	fprintf(fp, "255\n");
   9.542 +
   9.543 +	num_pixels = gmap->xsz * gmap->ysz;
   9.544 +	for(i=0; i<num_pixels; i++) {
   9.545 +		int c = gmap->pixels[i];
   9.546 +		fputc(c, fp);
   9.547 +		fputc(c, fp);
   9.548 +		fputc(c, fp);
   9.549 +	}
   9.550 +	return 0;
   9.551 +}
   9.552 +
   9.553 +void dtx_add_glyphmap(struct dtx_font *fnt, struct dtx_glyphmap *gmap)
   9.554 +{
   9.555 +	gmap->next = fnt->gmaps;
   9.556 +	fnt->gmaps = gmap;
   9.557 +}
   9.558 +
   9.559 +
   9.560 +void dtx_use_font(struct dtx_font *fnt, int sz)
   9.561 +{
   9.562 +	dtx_gl_init();
   9.563 +
   9.564 +	dtx_font = fnt;
   9.565 +	dtx_font_sz = sz;
   9.566 +}
   9.567 +
   9.568 +float dtx_line_height(void)
   9.569 +{
   9.570 +	struct dtx_glyphmap *gmap = dtx_get_font_glyphmap(dtx_font, dtx_font_sz, '\n');
   9.571 +
   9.572 +	return gmap->line_advance;
   9.573 +}
   9.574 +
   9.575 +void dtx_glyph_box(int code, struct dtx_box *box)
   9.576 +{
   9.577 +	int cidx;
   9.578 +	struct dtx_glyphmap *gmap;
   9.579 +	gmap = dtx_get_font_glyphmap(dtx_font, dtx_font_sz, code);
   9.580 +
   9.581 +	cidx = code - gmap->cstart;
   9.582 +
   9.583 +	box->x = gmap->glyphs[cidx].orig_x;
   9.584 +	box->y = gmap->glyphs[cidx].orig_y;
   9.585 +	box->width = gmap->glyphs[cidx].width;
   9.586 +	box->height = gmap->glyphs[cidx].height;
   9.587 +}
   9.588 +
   9.589 +float dtx_glyph_width(int code)
   9.590 +{
   9.591 +	struct dtx_box box;
   9.592 +	dtx_glyph_box(code, &box);
   9.593 +	return box.width;
   9.594 +}
   9.595 +
   9.596 +float dtx_glyph_height(int code)
   9.597 +{
   9.598 +	struct dtx_box box;
   9.599 +	dtx_glyph_box(code, &box);
   9.600 +	return box.height;
   9.601 +}
   9.602 +
   9.603 +void dtx_string_box(const char *str, struct dtx_box *box)
   9.604 +{
   9.605 +	int code;
   9.606 +	float pos_x = 0.0f, pos_y = 0.0f;
   9.607 +	struct glyph *g = 0;
   9.608 +	float x0, y0, x1, y1;
   9.609 +
   9.610 +	x0 = y0 = FLT_MAX;
   9.611 +	x1 = y1 = -FLT_MAX;
   9.612 +
   9.613 +	while(*str) {
   9.614 +		float px, py;
   9.615 +		struct dtx_glyphmap *gmap;
   9.616 +
   9.617 +		code = dtx_utf8_char_code(str);
   9.618 +		str = dtx_utf8_next_char((char*)str);
   9.619 +
   9.620 +		px = pos_x;
   9.621 +		py = pos_y;
   9.622 +
   9.623 +		if((gmap = dtx_proc_char(code, &pos_x, &pos_y))) {
   9.624 +			g = gmap->glyphs + code - gmap->cstart;
   9.625 +
   9.626 +			if(px + g->orig_x < x0) {
   9.627 +				x0 = px + g->orig_x;
   9.628 +			}
   9.629 +			if(py - g->orig_y < y0) {
   9.630 +				y0 = py - g->orig_y;
   9.631 +			}
   9.632 +			if(px + g->orig_x + g->width > x1) {
   9.633 +				x1 = px + g->orig_x + g->width;
   9.634 +			}
   9.635 +			if(py - g->orig_y + g->height > y1) {
   9.636 +				y1 = py - g->orig_y + g->height;
   9.637 +			}
   9.638 +		}
   9.639 +	}
   9.640 +
   9.641 +	box->x = x0;
   9.642 +	box->y = y0;
   9.643 +	box->width = x1 - x0;
   9.644 +	box->height = y1 - y0;
   9.645 +}
   9.646 +
   9.647 +float dtx_string_width(const char *str)
   9.648 +{
   9.649 +	struct dtx_box box;
   9.650 +
   9.651 +	dtx_string_box(str, &box);
   9.652 +	return box.width;
   9.653 +}
   9.654 +
   9.655 +float dtx_string_height(const char *str)
   9.656 +{
   9.657 +	struct dtx_box box;
   9.658 +
   9.659 +	dtx_string_box(str, &box);
   9.660 +	return box.height;
   9.661 +}
   9.662 +
   9.663 +float dtx_char_pos(const char *str, int n)
   9.664 +{
   9.665 +	int i;
   9.666 +	float pos = 0.0;
   9.667 +	struct dtx_glyphmap *gmap;
   9.668 +
   9.669 +	for(i=0; i<n; i++) {
   9.670 +		int code = dtx_utf8_char_code(str);
   9.671 +		str = dtx_utf8_next_char((char*)str);
   9.672 +
   9.673 +		gmap = dtx_get_font_glyphmap(dtx_font, dtx_font_sz, code);
   9.674 +		pos += gmap->glyphs[i].advance;
   9.675 +	}
   9.676 +	return pos;
   9.677 +}
   9.678 +
   9.679 +int dtx_char_at_pt(const char *str, float pt)
   9.680 +{
   9.681 +	int i;
   9.682 +	float prev_pos = 0.0f, pos = 0.0f;
   9.683 +	struct dtx_glyphmap *gmap;
   9.684 +
   9.685 +	for(i=0; *str; i++) {
   9.686 +		int code = dtx_utf8_char_code(str);
   9.687 +		str = dtx_utf8_next_char((char*)str);
   9.688 +
   9.689 +		gmap = dtx_get_font_glyphmap(dtx_font, dtx_font_sz, code);
   9.690 +		pos += gmap->glyphs[i].advance;
   9.691 +
   9.692 +		if(fabs(pt - prev_pos) < fabs(pt - pos)) {
   9.693 +			break;
   9.694 +		}
   9.695 +		prev_pos = pos;
   9.696 +	}
   9.697 +	return i;
   9.698 +}
   9.699 +
   9.700 +struct dtx_glyphmap *dtx_proc_char(int code, float *xpos, float *ypos)
   9.701 +{
   9.702 +	struct dtx_glyphmap *gmap;
   9.703 +	gmap = dtx_get_font_glyphmap(dtx_font, dtx_font_sz, code);
   9.704 +
   9.705 +	switch(code) {
   9.706 +	case '\n':
   9.707 +		*xpos = 0.0;
   9.708 +		if(gmap) {
   9.709 +			*ypos -= gmap->line_advance;
   9.710 +		}
   9.711 +		return 0;
   9.712 +
   9.713 +	case '\t':
   9.714 +		if(gmap) {
   9.715 +			*xpos = (fmod(*xpos, 4.0) + 4.0) * gmap->glyphs[0].advance;
   9.716 +		}
   9.717 +		return 0;
   9.718 +
   9.719 +	case '\r':
   9.720 +		*xpos = 0.0;
   9.721 +		return 0;
   9.722 +
   9.723 +	default:
   9.724 +		break;
   9.725 +	}
   9.726 +
   9.727 +	if(gmap) {
   9.728 +		*xpos += gmap->glyphs[code - gmap->cstart].advance;
   9.729 +	}
   9.730 +	return gmap;
   9.731 +}
   9.732 +
   9.733 +#ifdef USE_FREETYPE
   9.734 +static void calc_best_size(int total_width, int max_gwidth, int max_gheight, int padding, int pow2, int *imgw, int *imgh)
   9.735 +{
   9.736 +	int xsz, ysz, num_rows;
   9.737 +	float aspect;
   9.738 +
   9.739 +	for(xsz=2; xsz<=MAX_IMG_WIDTH; xsz *= 2) {
   9.740 +		num_rows = total_width / xsz + 1;
   9.741 +
   9.742 +		/* assume worst case, all last glyphs will float to the next line
   9.743 +		 * so let's add extra rows for that. */
   9.744 +		num_rows += (padding + (max_gwidth + padding) * num_rows + xsz - 1) / xsz;
   9.745 +
   9.746 +		ysz = num_rows * (max_gheight + padding) + padding;
   9.747 +		if(pow2) {
   9.748 +			ysz = next_pow2(ysz);
   9.749 +		}
   9.750 +		aspect = (float)xsz / (float)ysz;
   9.751 +
   9.752 +		if(aspect >= 1.0) {
   9.753 +			break;
   9.754 +		}
   9.755 +	}
   9.756 +
   9.757 +	if(xsz > MAX_IMG_WIDTH) {
   9.758 +		xsz = MAX_IMG_WIDTH;
   9.759 +	}
   9.760 +
   9.761 +	*imgw = xsz;
   9.762 +	*imgh = ysz;
   9.763 +}
   9.764 +
   9.765 +
   9.766 +static int next_pow2(int x)
   9.767 +{
   9.768 +	x--;
   9.769 +	x = (x >> 1) | x;
   9.770 +	x = (x >> 2) | x;
   9.771 +	x = (x >> 4) | x;
   9.772 +	x = (x >> 8) | x;
   9.773 +	x = (x >> 16) | x;
   9.774 +	return x + 1;
   9.775 +}
   9.776 +#endif

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/libs/drawtext/utf8.c	Sun May 31 00:40:26 2015 +0300
    10.3 @@ -0,0 +1,154 @@
    10.4 +/*
    10.5 +libdrawtext - a simple library for fast text rendering in OpenGL
    10.6 +Copyright (C) 2011  John Tsiombikas <nuclear@member.fsf.org>
    10.7 +
    10.8 +This program is free software: you can redistribute it and/or modify
    10.9 +it under the terms of the GNU Lesser General Public License as published by
   10.10 +the Free Software Foundation, either version 3 of the License, or
   10.11 +(at your option) any later version.
   10.12 +
   10.13 +This program is distributed in the hope that it will be useful,
   10.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.16 +GNU Lesser General Public License for more details.
   10.17 +
   10.18 +You should have received a copy of the GNU Lesser General Public License
   10.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   10.20 +*/
   10.21 +#include "drawtext.h"
   10.22 +
   10.23 +#define	U8_IS_FIRST(x)		(((((x) >> 7) & 1) == 0) || ((((x) >> 6) & 3) == 3))
   10.24 +
   10.25 +static const char first_mask[] = {
   10.26 +	0,
   10.27 +	0x7f,	/* single byte, 7 bits valid */
   10.28 +	0x1f,	/* two-bytes, 5 bits valid */
   10.29 +	0xf,	/* three-bytes, 4 bits valid */
   10.30 +	0x7		/* four-bytes, 3 bits valid */
   10.31 +};
   10.32 +static const char first_shift[] = { 0, 7, 5, 4, 3 };	/* see above */
   10.33 +
   10.34 +#define CONT_PREFIX	0x80
   10.35 +#define CONT_MASK	0x3f
   10.36 +#define CONT_SHIFT	6
   10.37 +
   10.38 +/* last charcodes for 1, 2, 3 or 4-byte utf8 chars */
   10.39 +static const int utf8_lastcode[] = { 0x7f, 0x7ff, 0xfff, 0x1fffff };
   10.40 +
   10.41 +#define prefix_mask(x)	(~first_mask[x])
   10.42 +#define prefix(x)		((prefix_mask(x) << 1) & 0xff)
   10.43 +
   10.44 +
   10.45 +char *dtx_utf8_next_char(char *str)
   10.46 +{
   10.47 +	return str + dtx_utf8_nbytes(str);
   10.48 +}
   10.49 +
   10.50 +int dtx_utf8_char_code(const char *str)
   10.51 +{
   10.52 +	int i, nbytes, shift, code = 0;
   10.53 +	int mask;
   10.54 +
   10.55 +	if(!U8_IS_FIRST(*str)) {
   10.56 +		return -1;
   10.57 +	}
   10.58 +
   10.59 +	nbytes = dtx_utf8_nbytes(str);
   10.60 +	mask = first_mask[nbytes];
   10.61 +	shift = 0;
   10.62 +
   10.63 +	for(i=0; i<nbytes; i++) {
   10.64 +		if(!*str) {
   10.65 +			break;
   10.66 +		}
   10.67 +
   10.68 +		code = (code << shift) | (*str++ & mask);
   10.69 +		mask = 0x3f;
   10.70 +		shift = 6;
   10.71 +	}
   10.72 +	return code;
   10.73 +}
   10.74 +
   10.75 +int dtx_utf8_nbytes(const char *str)
   10.76 +{
   10.77 +	int i, numset = 0;
   10.78 +	int c = *str;
   10.79 +
   10.80 +	if(!U8_IS_FIRST(c)) {
   10.81 +		for(i=0; !U8_IS_FIRST(str[i]); i++);
   10.82 +		return i;
   10.83 +	}
   10.84 +
   10.85 +	/* count the leading 1s */
   10.86 +	for(i=0; i<4; i++) {
   10.87 +		if(((c >> (7 - i)) & 1) == 0) {
   10.88 +			break;
   10.89 +		}
   10.90 +		numset++;
   10.91 +	}
   10.92 +
   10.93 +	if(!numset) {
   10.94 +		return 1;
   10.95 +	}
   10.96 +	return numset;
   10.97 +}
   10.98 +
   10.99 +int dtx_utf8_char_count(const char *str)
  10.100 +{
  10.101 +	int n = 0;
  10.102 +
  10.103 +	while(*str) {
  10.104 +		n++;
  10.105 +		str = dtx_utf8_next_char((char*)str);
  10.106 +	}
  10.107 +	return n;
  10.108 +}
  10.109 +
  10.110 +size_t dtx_utf8_from_char_code(int code, char *buf)
  10.111 +{
  10.112 +	size_t nbytes = 0;
  10.113 +	int i;
  10.114 +
  10.115 +	for(i=0; i<4; i++) {
  10.116 +		if(code <= utf8_lastcode[i]) {
  10.117 +			nbytes = i + 1;
  10.118 +			break;
  10.119 +		}
  10.120 +	}
  10.121 +
  10.122 +	if(!nbytes && buf) {
  10.123 +		for(i=0; i<(int)nbytes; i++) {
  10.124 +			int idx = nbytes - i - 1;
  10.125 +			int mask, shift, prefix;
  10.126 +
  10.127 +			if(idx > 0) {
  10.128 +				mask = CONT_MASK;
  10.129 +				shift = CONT_SHIFT;
  10.130 +				prefix = CONT_PREFIX;
  10.131 +			} else {
  10.132 +				mask = first_mask[nbytes];
  10.133 +				shift = first_shift[nbytes];
  10.134 +				prefix = prefix(nbytes);
  10.135 +			}
  10.136 +
  10.137 +			buf[idx] = (code & mask) | (prefix & ~mask);
  10.138 +			code >>= shift;
  10.139 +		}
  10.140 +	}
  10.141 +	return nbytes;
  10.142 +}
  10.143 +
  10.144 +size_t dtx_utf8_from_string(const wchar_t *str, char *buf)
  10.145 +{
  10.146 +	size_t nbytes = 0;
  10.147 +	char *ptr = buf;
  10.148 +
  10.149 +	while(*str) {
  10.150 +		int cbytes = dtx_utf8_from_char_code(*str++, ptr);
  10.151 +		if(ptr) {
  10.152 +			ptr += cbytes;
  10.153 +		}
  10.154 +		nbytes += cbytes;
  10.155 +	}
  10.156 +	return nbytes;
  10.157 +}

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/libs/vmath/basis.cc	Sun May 31 00:40:26 2015 +0300
    11.3 @@ -0,0 +1,80 @@
    11.4 +/*
    11.5 +libvmath - a vector math library
    11.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    11.7 +
    11.8 +This program is free software: you can redistribute it and/or modify
    11.9 +it under the terms of the GNU Lesser General Public License as published
   11.10 +by the Free Software Foundation, either version 3 of the License, or
   11.11 +(at your option) any later version.
   11.12 +
   11.13 +This program is distributed in the hope that it will be useful,
   11.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   11.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   11.16 +GNU Lesser General Public License for more details.
   11.17 +
   11.18 +You should have received a copy of the GNU Lesser General Public License
   11.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   11.20 +*/
   11.21 +#include "basis.h"
   11.22 +#include "vmath.h"
   11.23 +
   11.24 +Basis::Basis()
   11.25 +{
   11.26 +	i = Vector3(1, 0, 0);
   11.27 +	j = Vector3(0, 1, 0);
   11.28 +	k = Vector3(0, 0, 1);
   11.29 +}
   11.30 +
   11.31 +Basis::Basis(const Vector3 &i, const Vector3 &j, const Vector3 &k)
   11.32 +{
   11.33 +	this->i = i;
   11.34 +	this->j = j;
   11.35 +	this->k = k;
   11.36 +}
   11.37 +
   11.38 +Basis::Basis(const Vector3 &dir, bool left_handed)
   11.39 +{
   11.40 +	k = dir;
   11.41 +	j = Vector3(0, 1, 0);
   11.42 +	i = cross_product(j, k);
   11.43 +	j = cross_product(k, i);
   11.44 +}
   11.45 +
   11.46 +/** Rotate with euler angles */
   11.47 +void Basis::rotate(scalar_t x, scalar_t y, scalar_t z) {
   11.48 +	Matrix4x4 RotMat;
   11.49 +	RotMat.set_rotation(Vector3(x, y, z));
   11.50 +	i.transform(RotMat);
   11.51 +	j.transform(RotMat);
   11.52 +	k.transform(RotMat);
   11.53 +}
   11.54 +
   11.55 +/** Rotate by axis-angle specification */
   11.56 +void Basis::rotate(const Vector3 &axis, scalar_t angle) {
   11.57 +	Quaternion q;
   11.58 +	q.set_rotation(axis, angle);
   11.59 +	i.transform(q);
   11.60 +	j.transform(q);
   11.61 +	k.transform(q);
   11.62 +}
   11.63 +
   11.64 +/** Rotate with a 4x4 matrix */
   11.65 +void Basis::rotate(const Matrix4x4 &mat) {
   11.66 +	i.transform(mat);
   11.67 +	j.transform(mat);
   11.68 +	k.transform(mat);
   11.69 +}
   11.70 +
   11.71 +/** Rotate with a quaternion */
   11.72 +void Basis::rotate(const Quaternion &quat) {
   11.73 +	i.transform(quat);
   11.74 +	j.transform(quat);
   11.75 +	k.transform(quat);
   11.76 +}
   11.77 +
   11.78 +/** Extract a rotation matrix from the orthogonal basis */
   11.79 +Matrix3x3 Basis::create_rotation_matrix() const {
   11.80 +	return Matrix3x3(	i.x, j.x, k.x,
   11.81 +						i.y, j.y, k.y,
   11.82 +						i.z, j.z, k.z);
   11.83 +}

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/libs/vmath/basis.h	Sun May 31 00:40:26 2015 +0300
    12.3 @@ -0,0 +1,57 @@
    12.4 +/*
    12.5 +libvmath - a vector math library
    12.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    12.7 +
    12.8 +This program is free software: you can redistribute it and/or modify
    12.9 +it under the terms of the GNU Lesser General Public License as published
   12.10 +by the Free Software Foundation, either version 3 of the License, or
   12.11 +(at your option) any later version.
   12.12 +
   12.13 +This program is distributed in the hope that it will be useful,
   12.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   12.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12.16 +GNU Lesser General Public License for more details.
   12.17 +
   12.18 +You should have received a copy of the GNU Lesser General Public License
   12.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   12.20 +*/
   12.21 +
   12.22 +#ifndef VMATH_BASIS_H_
   12.23 +#define VMATH_BASIS_H_
   12.24 +
   12.25 +#include "vector.h"
   12.26 +#include "matrix.h"
   12.27 +
   12.28 +enum {
   12.29 +	LEFT_HANDED,
   12.30 +	RIGHT_HANDED
   12.31 +};
   12.32 +
   12.33 +#ifdef __cplusplus
   12.34 +extern "C" {
   12.35 +#endif	/* __cplusplus */
   12.36 +
   12.37 +void basis_matrix(mat4_t res, vec3_t i, vec3_t j, vec3_t k);
   12.38 +void basis_matrix_dir(mat4_t res, vec3_t dir);
   12.39 +
   12.40 +#ifdef __cplusplus
   12.41 +}	/* extern "C" */
   12.42 +
   12.43 +class Basis {
   12.44 +public:
   12.45 +	Vector3 i, j, k;
   12.46 +
   12.47 +	Basis();
   12.48 +	Basis(const Vector3 &i, const Vector3 &j, const Vector3 &k);
   12.49 +	Basis(const Vector3 &dir, bool left_handed = true);
   12.50 +
   12.51 +	void rotate(scalar_t x, scalar_t y, scalar_t z);
   12.52 +	void rotate(const Vector3 &axis, scalar_t angle);
   12.53 +	void rotate(const Matrix4x4 &mat);
   12.54 +	void rotate(const Quaternion &quat);
   12.55 +
   12.56 +	Matrix3x3 create_rotation_matrix() const;
   12.57 +};
   12.58 +#endif	/* __cplusplus */
   12.59 +
   12.60 +#endif	/* VMATH_BASIS_H_ */

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/libs/vmath/basis_c.c	Sun May 31 00:40:26 2015 +0300
    13.3 @@ -0,0 +1,37 @@
    13.4 +/*
    13.5 +libvmath - a vector math library
    13.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    13.7 +
    13.8 +This program is free software: you can redistribute it and/or modify
    13.9 +it under the terms of the GNU Lesser General Public License as published
   13.10 +by the Free Software Foundation, either version 3 of the License, or
   13.11 +(at your option) any later version.
   13.12 +
   13.13 +This program is distributed in the hope that it will be useful,
   13.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   13.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   13.16 +GNU Lesser General Public License for more details.
   13.17 +
   13.18 +You should have received a copy of the GNU Lesser General Public License
   13.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   13.20 +*/
   13.21 +
   13.22 +#include "basis.h"
   13.23 +#include "matrix.h"
   13.24 +
   13.25 +void basis_matrix(mat4_t res, vec3_t i, vec3_t j, vec3_t k)
   13.26 +{
   13.27 +	m4_identity(res);
   13.28 +	m4_set_column(res, v4_cons(i.x, i.y, i.z, 1.0), 0);
   13.29 +	m4_set_column(res, v4_cons(j.x, j.y, j.z, 1.0), 1);
   13.30 +	m4_set_column(res, v4_cons(k.x, k.y, k.z, 1.0), 2);
   13.31 +}
   13.32 +
   13.33 +void basis_matrix_dir(mat4_t res, vec3_t dir)
   13.34 +{
   13.35 +	vec3_t k = v3_normalize(dir);
   13.36 +	vec3_t j = {0, 1, 0};
   13.37 +	vec3_t i = v3_cross(j, k);
   13.38 +	j = v3_cross(k, i);
   13.39 +	basis_matrix(res, i, j, k);
   13.40 +}

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/libs/vmath/geom.c	Sun May 31 00:40:26 2015 +0300
    14.3 @@ -0,0 +1,150 @@
    14.4 +/*
    14.5 +libvmath - a vector math library
    14.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    14.7 +
    14.8 +This program is free software: you can redistribute it and/or modify
    14.9 +it under the terms of the GNU Lesser General Public License as published
   14.10 +by the Free Software Foundation, either version 3 of the License, or
   14.11 +(at your option) any later version.
   14.12 +
   14.13 +This program is distributed in the hope that it will be useful,
   14.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   14.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14.16 +GNU Lesser General Public License for more details.
   14.17 +
   14.18 +You should have received a copy of the GNU Lesser General Public License
   14.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   14.20 +*/
   14.21 +
   14.22 +
   14.23 +#include <math.h>
   14.24 +#include "geom.h"
   14.25 +#include "vector.h"
   14.26 +
   14.27 +plane_t plane_cons(scalar_t nx, scalar_t ny, scalar_t nz, scalar_t d)
   14.28 +{
   14.29 +	plane_t p;
   14.30 +	p.norm.x = nx;
   14.31 +	p.norm.y = ny;
   14.32 +	p.norm.z = nz;
   14.33 +	p.d = d;
   14.34 +	return p;
   14.35 +}
   14.36 +
   14.37 +plane_t plane_poly(vec3_t v0, vec3_t v1, vec3_t v2)
   14.38 +{
   14.39 +	vec3_t a, b, norm;
   14.40 +
   14.41 +	a = v3_sub(v1, v0);
   14.42 +	b = v3_sub(v2, v0);
   14.43 +	norm = v3_cross(a, b);
   14.44 +	norm = v3_normalize(norm);
   14.45 +
   14.46 +	return plane_ptnorm(v0, norm);
   14.47 +}
   14.48 +
   14.49 +plane_t plane_ptnorm(vec3_t pt, vec3_t normal)
   14.50 +{
   14.51 +	plane_t plane;
   14.52 +
   14.53 +	plane.norm = normal;
   14.54 +	plane.d = v3_dot(pt, normal);
   14.55 +
   14.56 +	return plane;
   14.57 +}
   14.58 +
   14.59 +plane_t plane_invert(plane_t p)
   14.60 +{
   14.61 +	p.norm = v3_neg(p.norm);
   14.62 +	p.d = -p.d;
   14.63 +	return p;
   14.64 +}
   14.65 +
   14.66 +scalar_t plane_signed_dist(plane_t plane, vec3_t pt)
   14.67 +{
   14.68 +	vec3_t pp = plane_point(plane);
   14.69 +	vec3_t pptopt = v3_sub(pt, pp);
   14.70 +	return v3_dot(pptopt, plane.norm);
   14.71 +}
   14.72 +
   14.73 +scalar_t plane_dist(plane_t plane, vec3_t pt)
   14.74 +{
   14.75 +	return fabs(plane_signed_dist(plane, pt));
   14.76 +}
   14.77 +
   14.78 +vec3_t plane_point(plane_t plane)
   14.79 +{
   14.80 +	return v3_scale(plane.norm, plane.d);
   14.81 +}
   14.82 +
   14.83 +int plane_ray_intersect(ray_t ray, plane_t plane, scalar_t *pos)
   14.84 +{
   14.85 +	vec3_t pt, orig_to_pt;
   14.86 +	scalar_t ndotdir;
   14.87 +
   14.88 +	pt = plane_point(plane);
   14.89 +	ndotdir = v3_dot(plane.norm, ray.dir);
   14.90 +
   14.91 +	if(fabs(ndotdir) < 1e-7) {
   14.92 +		return 0;
   14.93 +	}
   14.94 +
   14.95 +	if(pos) {
   14.96 +		orig_to_pt = v3_sub(pt, ray.origin);
   14.97 +		*pos = v3_dot(plane.norm, orig_to_pt) / ndotdir;
   14.98 +	}
   14.99 +	return 1;
  14.100 +}
  14.101 +
  14.102 +sphere_t sphere_cons(scalar_t x, scalar_t y, scalar_t z, scalar_t rad)
  14.103 +{
  14.104 +	sphere_t sph;
  14.105 +	sph.pos.x = x;
  14.106 +	sph.pos.y = y;
  14.107 +	sph.pos.z = z;
  14.108 +	sph.rad = rad;
  14.109 +	return sph;
  14.110 +}
  14.111 +
  14.112 +int sphere_ray_intersect(ray_t ray, sphere_t sph, scalar_t *pos)
  14.113 +{
  14.114 +	scalar_t a, b, c, d, sqrt_d, t1, t2, t;
  14.115 +
  14.116 +	a = v3_dot(ray.dir, ray.dir);
  14.117 +	b = 2.0 * ray.dir.x * (ray.origin.x - sph.pos.x) +
  14.118 +		2.0 * ray.dir.y * (ray.origin.y - sph.pos.y) +
  14.119 +		2.0 * ray.dir.z * (ray.origin.z - sph.pos.z);
  14.120 +	c = v3_dot(sph.pos, sph.pos) + v3_dot(ray.origin, ray.origin) +
  14.121 +		2.0 * v3_dot(v3_neg(sph.pos), ray.origin) - sph.rad * sph.rad;
  14.122 +
  14.123 +	d = b * b - 4.0 * a * c;
  14.124 +	if(d < 0.0) {
  14.125 +		return 0;
  14.126 +	}
  14.127 +
  14.128 +	sqrt_d = sqrt(d);
  14.129 +	t1 = (-b + sqrt_d) / (2.0 * a);
  14.130 +	t2 = (-b - sqrt_d) / (2.0 * a);
  14.131 +
  14.132 +	if(t1 < 1e-7 || t1 > 1.0) {
  14.133 +		t1 = t2;
  14.134 +	}
  14.135 +	if(t2 < 1e-7 || t2 > 1.0) {
  14.136 +		t2 = t1;
  14.137 +	}
  14.138 +	t = t1 < t2 ? t1 : t2;
  14.139 +
  14.140 +	if(t < 1e-7 || t > 1.0) {
  14.141 +		return 0;
  14.142 +	}
  14.143 +
  14.144 +	if(pos) {
  14.145 +		*pos = t;
  14.146 +	}
  14.147 +	return 1;
  14.148 +}
  14.149 +
  14.150 +int sphere_sphere_intersect(sphere_t sph1, sphere_t sph2, scalar_t *pos, scalar_t *rad)
  14.151 +{
  14.152 +	return -1;
  14.153 +}

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/libs/vmath/geom.h	Sun May 31 00:40:26 2015 +0300
    15.3 @@ -0,0 +1,72 @@
    15.4 +/*
    15.5 +libvmath - a vector math library
    15.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    15.7 +
    15.8 +This program is free software: you can redistribute it and/or modify
    15.9 +it under the terms of the GNU Lesser General Public License as published
   15.10 +by the Free Software Foundation, either version 3 of the License, or
   15.11 +(at your option) any later version.
   15.12 +
   15.13 +This program is distributed in the hope that it will be useful,
   15.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   15.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15.16 +GNU Lesser General Public License for more details.
   15.17 +
   15.18 +You should have received a copy of the GNU Lesser General Public License
   15.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   15.20 +*/
   15.21 +#ifndef LIBVMATH_GEOM_H_
   15.22 +#define LIBVMATH_GEOM_H_
   15.23 +
   15.24 +#include "vector.h"
   15.25 +#include "ray.h"
   15.26 +
   15.27 +typedef struct {
   15.28 +	vec3_t norm;
   15.29 +	scalar_t d;
   15.30 +} plane_t;
   15.31 +
   15.32 +typedef struct {
   15.33 +	vec3_t pos;
   15.34 +	scalar_t rad;
   15.35 +} sphere_t;
   15.36 +
   15.37 +typedef struct {
   15.38 +	vec3_t min, max;
   15.39 +} aabox_t;
   15.40 +
   15.41 +#ifdef __cplusplus
   15.42 +extern "C" {
   15.43 +#endif
   15.44 +
   15.45 +/* planes are good... you need planes, yes you do */
   15.46 +plane_t plane_cons(scalar_t nx, scalar_t ny, scalar_t nz, scalar_t d);
   15.47 +plane_t plane_poly(vec3_t v0, vec3_t v1, vec3_t v2);
   15.48 +plane_t plane_ptnorm(vec3_t pt, vec3_t normal);
   15.49 +
   15.50 +plane_t plane_invert(plane_t p);
   15.51 +
   15.52 +scalar_t plane_signed_dist(plane_t plane, vec3_t pt);
   15.53 +scalar_t plane_dist(plane_t plane, vec3_t pt);
   15.54 +vec3_t plane_point(plane_t plane);
   15.55 +
   15.56 +int plane_ray_intersect(ray_t ray, plane_t plane, scalar_t *pos);
   15.57 +
   15.58 +/* spheres always come in handy */
   15.59 +sphere_t sphere_cons(scalar_t x, scalar_t y, scalar_t z, scalar_t rad);
   15.60 +
   15.61 +int sphere_ray_intersect(ray_t ray, sphere_t sph, scalar_t *pos);
   15.62 +int sphere_sphere_intersect(sphere_t sph1, sphere_t sph2, scalar_t *pos, scalar_t *rad);
   15.63 +
   15.64 +#ifdef __cplusplus
   15.65 +}
   15.66 +
   15.67 +/* TODO
   15.68 +class Plane : public plane_t {
   15.69 +public:
   15.70 +};
   15.71 +*/
   15.72 +
   15.73 +#endif
   15.74 +
   15.75 +#endif	/* LIBVMATH_GEOM_H_ */

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/libs/vmath/matrix.cc	Sun May 31 00:40:26 2015 +0300
    16.3 @@ -0,0 +1,872 @@
    16.4 +/*
    16.5 +libvmath - a vector math library
    16.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    16.7 +
    16.8 +This program is free software: you can redistribute it and/or modify
    16.9 +it under the terms of the GNU Lesser General Public License as published
   16.10 +by the Free Software Foundation, either version 3 of the License, or
   16.11 +(at your option) any later version.
   16.12 +
   16.13 +This program is distributed in the hope that it will be useful,
   16.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   16.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   16.16 +GNU Lesser General Public License for more details.
   16.17 +
   16.18 +You should have received a copy of the GNU Lesser General Public License
   16.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   16.20 +*/
   16.21 +#include <cstdio>
   16.22 +#include <cmath>
   16.23 +#include "matrix.h"
   16.24 +#include "vector.h"
   16.25 +#include "quat.h"
   16.26 +
   16.27 +using namespace std;
   16.28 +
   16.29 +// ----------- Matrix3x3 --------------
   16.30 +
   16.31 +Matrix3x3 Matrix3x3::identity = Matrix3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);
   16.32 +
   16.33 +Matrix3x3::Matrix3x3()
   16.34 +{
   16.35 +	*this = Matrix3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);
   16.36 +}
   16.37 +
   16.38 +Matrix3x3::Matrix3x3(	scalar_t m11, scalar_t m12, scalar_t m13,
   16.39 +						scalar_t m21, scalar_t m22, scalar_t m23,
   16.40 +						scalar_t m31, scalar_t m32, scalar_t m33)
   16.41 +{
   16.42 +	m[0][0] = m11; m[0][1] = m12; m[0][2] = m13;
   16.43 +	m[1][0] = m21; m[1][1] = m22; m[1][2] = m23;
   16.44 +	m[2][0] = m31; m[2][1] = m32; m[2][2] = m33;
   16.45 +}
   16.46 +
   16.47 +Matrix3x3::Matrix3x3(const Vector3 &ivec, const Vector3 &jvec, const Vector3 &kvec)
   16.48 +{
   16.49 +	set_row_vector(ivec, 0);
   16.50 +	set_row_vector(jvec, 1);
   16.51 +	set_row_vector(kvec, 2);
   16.52 +}
   16.53 +
   16.54 +Matrix3x3::Matrix3x3(const mat3_t cmat)
   16.55 +{
   16.56 +	memcpy(m, cmat, sizeof(mat3_t));
   16.57 +}
   16.58 +
   16.59 +Matrix3x3::Matrix3x3(const Matrix4x4 &mat4x4)
   16.60 +{
   16.61 +	for(int i=0; i<3; i++) {
   16.62 +		for(int j=0; j<3; j++) {
   16.63 +			m[i][j] = mat4x4[i][j];
   16.64 +		}
   16.65 +	}
   16.66 +}
   16.67 +
   16.68 +Matrix3x3 operator +(const Matrix3x3 &m1, const Matrix3x3 &m2)
   16.69 +{
   16.70 +	Matrix3x3 res;
   16.71 +	const scalar_t *op1 = m1.m[0], *op2 = m2.m[0];
   16.72 +	scalar_t *dest = res.m[0];
   16.73 +
   16.74 +	for(int i=0; i<9; i++) {
   16.75 +		*dest++ = *op1++ + *op2++;
   16.76 +	}
   16.77 +	return res;
   16.78 +}
   16.79 +
   16.80 +Matrix3x3 operator -(const Matrix3x3 &m1, const Matrix3x3 &m2)
   16.81 +{
   16.82 +	Matrix3x3 res;
   16.83 +	const scalar_t *op1 = m1.m[0], *op2 = m2.m[0];
   16.84 +	scalar_t *dest = res.m[0];
   16.85 +
   16.86 +	for(int i=0; i<9; i++) {
   16.87 +		*dest++ = *op1++ - *op2++;
   16.88 +	}
   16.89 +	return res;
   16.90 +}
   16.91 +
   16.92 +Matrix3x3 operator *(const Matrix3x3 &m1, const Matrix3x3 &m2)
   16.93 +{
   16.94 +	Matrix3x3 res;
   16.95 +	for(int i=0; i<3; i++) {
   16.96 +		for(int j=0; j<3; j++) {
   16.97 +			res.m[i][j] = m1.m[i][0] * m2.m[0][j] + m1.m[i][1] * m2.m[1][j] + m1.m[i][2] * m2.m[2][j];
   16.98 +		}
   16.99 +	}
  16.100 +	return res;
  16.101 +}
  16.102 +
  16.103 +void operator +=(Matrix3x3 &m1, const Matrix3x3 &m2)
  16.104 +{
  16.105 +	scalar_t *op1 = m1.m[0];
  16.106 +	const scalar_t *op2 = m2.m[0];
  16.107 +
  16.108 +	for(int i=0; i<9; i++) {
  16.109 +		*op1++ += *op2++;
  16.110 +	}
  16.111 +}
  16.112 +
  16.113 +void operator -=(Matrix3x3 &m1, const Matrix3x3 &m2)
  16.114 +{
  16.115 +	scalar_t *op1 = m1.m[0];
  16.116 +	const scalar_t *op2 = m2.m[0];
  16.117 +
  16.118 +	for(int i=0; i<9; i++) {
  16.119 +		*op1++ -= *op2++;
  16.120 +	}
  16.121 +}
  16.122 +
  16.123 +void operator *=(Matrix3x3 &m1, const Matrix3x3 &m2)
  16.124 +{
  16.125 +	Matrix3x3 res;
  16.126 +	for(int i=0; i<3; i++) {
  16.127 +		for(int j=0; j<3; j++) {
  16.128 +			res.m[i][j] = m1.m[i][0] * m2.m[0][j] + m1.m[i][1] * m2.m[1][j] + m1.m[i][2] * m2.m[2][j];
  16.129 +		}
  16.130 +	}
  16.131 +	memcpy(m1.m, res.m, 9 * sizeof(scalar_t));
  16.132 +}
  16.133 +
  16.134 +Matrix3x3 operator *(const Matrix3x3 &mat, scalar_t scalar)
  16.135 +{
  16.136 +	Matrix3x3 res;
  16.137 +	const scalar_t *mptr = mat.m[0];
  16.138 +	scalar_t *dptr = res.m[0];
  16.139 +
  16.140 +	for(int i=0; i<9; i++) {
  16.141 +		*dptr++ = *mptr++ * scalar;
  16.142 +	}
  16.143 +	return res;
  16.144 +}
  16.145 +
  16.146 +Matrix3x3 operator *(scalar_t scalar, const Matrix3x3 &mat)
  16.147 +{
  16.148 +	Matrix3x3 res;
  16.149 +	const scalar_t *mptr = mat.m[0];
  16.150 +	scalar_t *dptr = res.m[0];
  16.151 +
  16.152 +	for(int i=0; i<9; i++) {
  16.153 +		*dptr++ = *mptr++ * scalar;
  16.154 +	}
  16.155 +	return res;
  16.156 +}
  16.157 +
  16.158 +void operator *=(Matrix3x3 &mat, scalar_t scalar)
  16.159 +{
  16.160 +	scalar_t *mptr = mat.m[0];
  16.161 +
  16.162 +	for(int i=0; i<9; i++) {
  16.163 +		*mptr++ *= scalar;
  16.164 +	}
  16.165 +}
  16.166 +
  16.167 +void Matrix3x3::translate(const Vector2 &trans)
  16.168 +{
  16.169 +	Matrix3x3 tmat(1, 0, trans.x, 0, 1, trans.y, 0, 0, 1);
  16.170 +	*this *= tmat;
  16.171 +}
  16.172 +
  16.173 +void Matrix3x3::set_translation(const Vector2 &trans)
  16.174 +{
  16.175 +	*this = Matrix3x3(1, 0, trans.x, 0, 1, trans.y, 0, 0, 1);
  16.176 +}
  16.177 +
  16.178 +void Matrix3x3::rotate(scalar_t angle)
  16.179 +{
  16.180 +	scalar_t cos_a = cos(angle);
  16.181 +	scalar_t sin_a = sin(angle);
  16.182 +	Matrix3x3 rmat(	cos_a,	-sin_a,		0,
  16.183 +					sin_a,	cos_a,		0,
  16.184 +					0,		0,			1);
  16.185 +	*this *= rmat;
  16.186 +}
  16.187 +
  16.188 +void Matrix3x3::set_rotation(scalar_t angle)
  16.189 +{
  16.190 +	scalar_t cos_a = cos(angle);
  16.191 +	scalar_t sin_a = sin(angle);
  16.192 +	*this = Matrix3x3(cos_a, -sin_a, 0, sin_a, cos_a, 0, 0, 0, 1);
  16.193 +}
  16.194 +
  16.195 +void Matrix3x3::rotate(const Vector3 &euler_angles)
  16.196 +{
  16.197 +	Matrix3x3 xrot, yrot, zrot;
  16.198 +
  16.199 +	xrot = Matrix3x3(	1,			0,					0,
  16.200 +						0,	cos(euler_angles.x),	-sin(euler_angles.x),
  16.201 +						0,	sin(euler_angles.x),	cos(euler_angles.x));
  16.202 +
  16.203 +	yrot = Matrix3x3(	cos(euler_angles.y),	0,	sin(euler_angles.y),
  16.204 +								0,				1,				0,
  16.205 +						-sin(euler_angles.y),	0,	cos(euler_angles.y));
  16.206 +
  16.207 +	zrot = Matrix3x3(	cos(euler_angles.z),	-sin(euler_angles.z),	0,
  16.208 +						sin(euler_angles.z),	cos(euler_angles.z),	0,
  16.209 +								0,						0,				1);
  16.210 +
  16.211 +	*this *= xrot * yrot * zrot;
  16.212 +}
  16.213 +
  16.214 +void Matrix3x3::set_rotation(const Vector3 &euler_angles)
  16.215 +{
  16.216 +	Matrix3x3 xrot, yrot, zrot;
  16.217 +
  16.218 +	xrot = Matrix3x3(	1,			0,					0,
  16.219 +						0,	cos(euler_angles.x),	-sin(euler_angles.x),
  16.220 +						0,	sin(euler_angles.x),	cos(euler_angles.x));
  16.221 +
  16.222 +	yrot = Matrix3x3(	cos(euler_angles.y),	0,	sin(euler_angles.y),
  16.223 +								0,				1,				0,
  16.224 +						-sin(euler_angles.y),	0,	cos(euler_angles.y));
  16.225 +
  16.226 +	zrot = Matrix3x3(	cos(euler_angles.z),	-sin(euler_angles.z),	0,
  16.227 +						sin(euler_angles.z),	cos(euler_angles.z),	0,
  16.228 +								0,						0,				1);
  16.229 +
  16.230 +	*this = xrot * yrot * zrot;
  16.231 +}
  16.232 +
  16.233 +void Matrix3x3::rotate(const Vector3 &axis, scalar_t angle)
  16.234 +{
  16.235 +	scalar_t sina = (scalar_t)sin(angle);
  16.236 +	scalar_t cosa = (scalar_t)cos(angle);
  16.237 +	scalar_t invcosa = 1-cosa;
  16.238 +	scalar_t nxsq = axis.x * axis.x;
  16.239 +	scalar_t nysq = axis.y * axis.y;
  16.240 +	scalar_t nzsq = axis.z * axis.z;
  16.241 +
  16.242 +	Matrix3x3 xform;
  16.243 +	xform.m[0][0] = nxsq + (1-nxsq) * cosa;
  16.244 +	xform.m[0][1] = axis.x * axis.y * invcosa - axis.z * sina;
  16.245 +	xform.m[0][2] = axis.x * axis.z * invcosa + axis.y * sina;
  16.246 +
  16.247 +	xform.m[1][0] = axis.x * axis.y * invcosa + axis.z * sina;
  16.248 +	xform.m[1][1] = nysq + (1-nysq) * cosa;
  16.249 +	xform.m[1][2] = axis.y * axis.z * invcosa - axis.x * sina;
  16.250 +
  16.251 +	xform.m[2][0] = axis.x * axis.z * invcosa - axis.y * sina;
  16.252 +	xform.m[2][1] = axis.y * axis.z * invcosa + axis.x * sina;
  16.253 +	xform.m[2][2] = nzsq + (1-nzsq) * cosa;
  16.254 +
  16.255 +	*this *= xform;
  16.256 +}
  16.257 +
  16.258 +void Matrix3x3::set_rotation(const Vector3 &axis, scalar_t angle)
  16.259 +{
  16.260 +	scalar_t sina = (scalar_t)sin(angle);
  16.261 +	scalar_t cosa = (scalar_t)cos(angle);
  16.262 +	scalar_t invcosa = 1-cosa;
  16.263 +	scalar_t nxsq = axis.x * axis.x;
  16.264 +	scalar_t nysq = axis.y * axis.y;
  16.265 +	scalar_t nzsq = axis.z * axis.z;
  16.266 +
  16.267 +	reset_identity();
  16.268 +	m[0][0] = nxsq + (1-nxsq) * cosa;
  16.269 +	m[0][1] = axis.x * axis.y * invcosa - axis.z * sina;
  16.270 +	m[0][2] = axis.x * axis.z * invcosa + axis.y * sina;
  16.271 +	m[1][0] = axis.x * axis.y * invcosa + axis.z * sina;
  16.272 +	m[1][1] = nysq + (1-nysq) * cosa;
  16.273 +	m[1][2] = axis.y * axis.z * invcosa - axis.x * sina;
  16.274 +	m[2][0] = axis.x * axis.z * invcosa - axis.y * sina;
  16.275 +	m[2][1] = axis.y * axis.z * invcosa + axis.x * sina;
  16.276 +	m[2][2] = nzsq + (1-nzsq) * cosa;
  16.277 +}
  16.278 +
  16.279 +// Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
  16.280 +// article "Quaternion Calculus and Fast Animation".
  16.281 +// adapted from: http://www.geometrictools.com/LibMathematics/Algebra/Wm5Quaternion.inl
  16.282 +Quaternion Matrix3x3::get_rotation_quat() const
  16.283 +{
  16.284 +	static const int next[3] = {1, 2, 0};
  16.285 +
  16.286 +	float quat[4];
  16.287 +
  16.288 +	scalar_t trace = m[0][0] + m[1][1] + m[2][2];
  16.289 +	scalar_t root;
  16.290 +
  16.291 +	if(trace > 0.0f) {
  16.292 +		// |w| > 1/2
  16.293 +		root = sqrt(trace + 1.0f);	// 2w
  16.294 +		quat[0] = 0.5f * root;
  16.295 +		root = 0.5f / root;	// 1 / 4w
  16.296 +		quat[1] = (m[2][1] - m[1][2]) * root;
  16.297 +		quat[2] = (m[0][2] - m[2][0]) * root;
  16.298 +		quat[3] = (m[1][0] - m[0][1]) * root;
  16.299 +	} else {
  16.300 +		// |w| <= 1/2
  16.301 +		int i = 0;
  16.302 +		if(m[1][1] > m[0][0]) {
  16.303 +			i = 1;
  16.304 +		}
  16.305 +		if(m[2][2] > m[i][i]) {
  16.306 +			i = 2;
  16.307 +		}
  16.308 +		int j = next[i];
  16.309 +		int k = next[j];
  16.310 +
  16.311 +		root = sqrt(m[i][i] - m[j][j] - m[k][k] + 1.0f);
  16.312 +		quat[i + 1] = 0.5f * root;
  16.313 +		root = 0.5f / root;
  16.314 +		quat[0] = (m[k][j] - m[j][k]) * root;
  16.315 +		quat[j + 1] = (m[j][i] - m[i][j]) * root;
  16.316 +		quat[k + 1] = (m[k][i] - m[i][k]) * root;
  16.317 +	}
  16.318 +	return Quaternion(quat[0], quat[1], quat[2], quat[3]);
  16.319 +}
  16.320 +
  16.321 +void Matrix3x3::scale(const Vector3 &scale_vec)
  16.322 +{
  16.323 +	Matrix3x3 smat(	scale_vec.x, 0, 0,
  16.324 +					0, scale_vec.y, 0,
  16.325 +					0, 0, scale_vec.z);
  16.326 +	*this *= smat;
  16.327 +}
  16.328 +
  16.329 +void Matrix3x3::set_scaling(const Vector3 &scale_vec)
  16.330 +{
  16.331 +	*this = Matrix3x3(	scale_vec.x, 0, 0,
  16.332 +						0, scale_vec.y, 0,
  16.333 +						0, 0, scale_vec.z);
  16.334 +}
  16.335 +
  16.336 +void Matrix3x3::set_column_vector(const Vector3 &vec, unsigned int col_index)
  16.337 +{
  16.338 +	m[0][col_index] = vec.x;
  16.339 +	m[1][col_index] = vec.y;
  16.340 +	m[2][col_index] = vec.z;
  16.341 +}
  16.342 +
  16.343 +void Matrix3x3::set_row_vector(const Vector3 &vec, unsigned int row_index)
  16.344 +{
  16.345 +	m[row_index][0] = vec.x;
  16.346 +	m[row_index][1] = vec.y;
  16.347 +	m[row_index][2] = vec.z;
  16.348 +}
  16.349 +
  16.350 +Vector3 Matrix3x3::get_column_vector(unsigned int col_index) const
  16.351 +{
  16.352 +	return Vector3(m[0][col_index], m[1][col_index], m[2][col_index]);
  16.353 +}
  16.354 +
  16.355 +Vector3 Matrix3x3::get_row_vector(unsigned int row_index) const
  16.356 +{
  16.357 +	return Vector3(m[row_index][0], m[row_index][1], m[row_index][2]);
  16.358 +}
  16.359 +
  16.360 +void Matrix3x3::transpose()
  16.361 +{
  16.362 +	Matrix3x3 tmp = *this;
  16.363 +	for(int i=0; i<3; i++) {
  16.364 +		for(int j=0; j<3; j++) {
  16.365 +			m[i][j] = tmp[j][i];
  16.366 +		}
  16.367 +	}
  16.368 +}
  16.369 +
  16.370 +Matrix3x3 Matrix3x3::transposed() const
  16.371 +{
  16.372 +	Matrix3x3 res;
  16.373 +	for(int i=0; i<3; i++) {
  16.374 +		for(int j=0; j<3; j++) {
  16.375 +			res[i][j] = m[j][i];
  16.376 +		}
  16.377 +	}
  16.378 +	return res;
  16.379 +}
  16.380 +
  16.381 +scalar_t Matrix3x3::determinant() const
  16.382 +{
  16.383 +	return	m[0][0] * (m[1][1]*m[2][2] - m[1][2]*m[2][1]) -
  16.384 +			m[0][1] * (m[1][0]*m[2][2] - m[1][2]*m[2][0]) +
  16.385 +			m[0][2] * (m[1][0]*m[2][1] - m[1][1]*m[2][0]);
  16.386 +}
  16.387 +
  16.388 +Matrix3x3 Matrix3x3::inverse() const
  16.389 +{
  16.390 +	// TODO: implement 3x3 inverse
  16.391 +	return *this;
  16.392 +}
  16.393 +
  16.394 +/*ostream &operator <<(ostream &out, const Matrix3x3 &mat)
  16.395 +{
  16.396 +	for(int i=0; i<3; i++) {
  16.397 +		char str[100];
  16.398 +		sprintf(str, "[ %12.5f %12.5f %12.5f ]\n", (float)mat.m[i][0], (float)mat.m[i][1], (float)mat.m[i][2]);
  16.399 +		out << str;
  16.400 +	}
  16.401 +	return out;
  16.402 +}*/
  16.403 +
  16.404 +
  16.405 +
  16.406 +/* ----------------- Matrix4x4 implementation --------------- */
  16.407 +
  16.408 +Matrix4x4 Matrix4x4::identity = Matrix4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
  16.409 +
  16.410 +Matrix4x4::Matrix4x4()
  16.411 +{
  16.412 +	*this = Matrix4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
  16.413 +}
  16.414 +
  16.415 +Matrix4x4::Matrix4x4(	scalar_t m11, scalar_t m12, scalar_t m13, scalar_t m14,
  16.416 +						scalar_t m21, scalar_t m22, scalar_t m23, scalar_t m24,
  16.417 +						scalar_t m31, scalar_t m32, scalar_t m33, scalar_t m34,
  16.418 +						scalar_t m41, scalar_t m42, scalar_t m43, scalar_t m44)
  16.419 +{
  16.420 +	m[0][0] = m11; m[0][1] = m12; m[0][2] = m13; m[0][3] = m14;
  16.421 +	m[1][0] = m21; m[1][1] = m22; m[1][2] = m23; m[1][3] = m24;
  16.422 +	m[2][0] = m31; m[2][1] = m32; m[2][2] = m33; m[2][3] = m34;
  16.423 +	m[3][0] = m41; m[3][1] = m42; m[3][2] = m43; m[3][3] = m44;
  16.424 +}
  16.425 +
  16.426 +Matrix4x4::Matrix4x4(const mat4_t cmat)
  16.427 +{
  16.428 +	memcpy(m, cmat, sizeof(mat4_t));
  16.429 +}
  16.430 +
  16.431 +Matrix4x4::Matrix4x4(const Matrix3x3 &mat3x3)
  16.432 +{
  16.433 +	reset_identity();
  16.434 +	for(int i=0; i<3; i++) {
  16.435 +		for(int j=0; j<3; j++) {
  16.436 +			m[i][j] = mat3x3[i][j];
  16.437 +		}
  16.438 +	}
  16.439 +}
  16.440 +
  16.441 +Matrix4x4 operator +(const Matrix4x4 &m1, const Matrix4x4 &m2)
  16.442 +{
  16.443 +	Matrix4x4 res;
  16.444 +	const scalar_t *op1 = m1.m[0], *op2 = m2.m[0];
  16.445 +	scalar_t *dest = res.m[0];
  16.446 +
  16.447 +	for(int i=0; i<16; i++) {
  16.448 +		*dest++ = *op1++ + *op2++;
  16.449 +	}
  16.450 +	return res;
  16.451 +}
  16.452 +
  16.453 +Matrix4x4 operator -(const Matrix4x4 &m1, const Matrix4x4 &m2)
  16.454 +{
  16.455 +	Matrix4x4 res;
  16.456 +	const scalar_t *op1 = m1.m[0], *op2 = m2.m[0];
  16.457 +	scalar_t *dest = res.m[0];
  16.458 +
  16.459 +	for(int i=0; i<16; i++) {
  16.460 +		*dest++ = *op1++ - *op2++;
  16.461 +	}
  16.462 +	return res;
  16.463 +}
  16.464 +
  16.465 +void operator +=(Matrix4x4 &m1, const Matrix4x4 &m2)
  16.466 +{
  16.467 +	scalar_t *op1 = m1.m[0];
  16.468 +	const scalar_t *op2 = m2.m[0];
  16.469 +
  16.470 +	for(int i=0; i<16; i++) {
  16.471 +		*op1++ += *op2++;
  16.472 +	}
  16.473 +}
  16.474 +
  16.475 +void operator -=(Matrix4x4 &m1, const Matrix4x4 &m2)
  16.476 +{
  16.477 +	scalar_t *op1 = m1.m[0];
  16.478 +	const scalar_t *op2 = m2.m[0];
  16.479 +
  16.480 +	for(int i=0; i<16; i++) {
  16.481 +		*op1++ -= *op2++;
  16.482 +	}
  16.483 +}
  16.484 +
  16.485 +Matrix4x4 operator *(const Matrix4x4 &mat, scalar_t scalar)
  16.486 +{
  16.487 +	Matrix4x4 res;
  16.488 +	const scalar_t *mptr = mat.m[0];
  16.489 +	scalar_t *dptr = res.m[0];
  16.490 +
  16.491 +	for(int i=0; i<16; i++) {
  16.492 +		*dptr++ = *mptr++ * scalar;
  16.493 +	}
  16.494 +	return res;
  16.495 +}
  16.496 +
  16.497 +Matrix4x4 operator *(scalar_t scalar, const Matrix4x4 &mat)
  16.498 +{
  16.499 +	Matrix4x4 res;
  16.500 +	const scalar_t *mptr = mat.m[0];
  16.501 +	scalar_t *dptr = res.m[0];
  16.502 +
  16.503 +	for(int i=0; i<16; i++) {
  16.504 +		*dptr++ = *mptr++ * scalar;
  16.505 +	}
  16.506 +	return res;
  16.507 +}
  16.508 +
  16.509 +void operator *=(Matrix4x4 &mat, scalar_t scalar)
  16.510 +{
  16.511 +	scalar_t *mptr = mat.m[0];
  16.512 +
  16.513 +	for(int i=0; i<16; i++) {
  16.514 +		*mptr++ *= scalar;
  16.515 +	}
  16.516 +}
  16.517 +
  16.518 +void Matrix4x4::translate(const Vector3 &trans)
  16.519 +{
  16.520 +	Matrix4x4 tmat(1, 0, 0, trans.x, 0, 1, 0, trans.y, 0, 0, 1, trans.z, 0, 0, 0, 1);
  16.521 +	*this *= tmat;
  16.522 +}
  16.523 +
  16.524 +void Matrix4x4::set_translation(const Vector3 &trans)
  16.525 +{
  16.526 +	*this = Matrix4x4(1, 0, 0, trans.x, 0, 1, 0, trans.y, 0, 0, 1, trans.z, 0, 0, 0, 1);
  16.527 +}
  16.528 +
  16.529 +Vector3 Matrix4x4::get_translation() const
  16.530 +{
  16.531 +	return Vector3(m[0][3], m[1][3], m[2][3]);
  16.532 +}
  16.533 +
  16.534 +void Matrix4x4::rotate(const Vector3 &euler_angles)
  16.535 +{
  16.536 +	Matrix3x3 xrot, yrot, zrot;
  16.537 +
  16.538 +	xrot = Matrix3x3(	1,			0,					0,
  16.539 +						0,	cos(euler_angles.x),	-sin(euler_angles.x),
  16.540 +						0,	sin(euler_angles.x),	cos(euler_angles.x));
  16.541 +
  16.542 +	yrot = Matrix3x3(	cos(euler_angles.y),	0,	sin(euler_angles.y),
  16.543 +								0,				1,				0,
  16.544 +						-sin(euler_angles.y),	0,	cos(euler_angles.y));
  16.545 +
  16.546 +	zrot = Matrix3x3(	cos(euler_angles.z),	-sin(euler_angles.z),	0,
  16.547 +						sin(euler_angles.z),	cos(euler_angles.z),	0,
  16.548 +								0,						0,				1);
  16.549 +
  16.550 +	*this *= Matrix4x4(xrot * yrot * zrot);
  16.551 +}
  16.552 +
  16.553 +void Matrix4x4::set_rotation(const Vector3 &euler_angles)
  16.554 +{
  16.555 +	Matrix3x3 xrot, yrot, zrot;
  16.556 +
  16.557 +	xrot = Matrix3x3(	1,			0,					0,
  16.558 +						0,	cos(euler_angles.x),	-sin(euler_angles.x),
  16.559 +						0,	sin(euler_angles.x),	cos(euler_angles.x));
  16.560 +
  16.561 +	yrot = Matrix3x3(	cos(euler_angles.y),	0,	sin(euler_angles.y),
  16.562 +								0,				1,				0,
  16.563 +						-sin(euler_angles.y),	0,	cos(euler_angles.y));
  16.564 +
  16.565 +	zrot = Matrix3x3(	cos(euler_angles.z),	-sin(euler_angles.z),	0,
  16.566 +						sin(euler_angles.z),	cos(euler_angles.z),	0,
  16.567 +								0,						0,				1);
  16.568 +
  16.569 +	*this = Matrix4x4(xrot * yrot * zrot);
  16.570 +}
  16.571 +
  16.572 +void Matrix4x4::rotate(const Vector3 &axis, scalar_t angle)
  16.573 +{
  16.574 +	scalar_t sina = (scalar_t)sin(angle);
  16.575 +	scalar_t cosa = (scalar_t)cos(angle);
  16.576 +	scalar_t invcosa = 1-cosa;
  16.577 +	scalar_t nxsq = axis.x * axis.x;
  16.578 +	scalar_t nysq = axis.y * axis.y;
  16.579 +	scalar_t nzsq = axis.z * axis.z;
  16.580 +
  16.581 +	Matrix4x4 xform;
  16.582 +	xform[0][0] = nxsq + (1-nxsq) * cosa;
  16.583 +	xform[0][1] = axis.x * axis.y * invcosa - axis.z * sina;
  16.584 +	xform[0][2] = axis.x * axis.z * invcosa + axis.y * sina;
  16.585 +	xform[1][0] = axis.x * axis.y * invcosa + axis.z * sina;
  16.586 +	xform[1][1] = nysq + (1-nysq) * cosa;
  16.587 +	xform[1][2] = axis.y * axis.z * invcosa - axis.x * sina;
  16.588 +	xform[2][0] = axis.x * axis.z * invcosa - axis.y * sina;
  16.589 +	xform[2][1] = axis.y * axis.z * invcosa + axis.x * sina;
  16.590 +	xform[2][2] = nzsq + (1-nzsq) * cosa;
  16.591 +
  16.592 +	*this *= xform;
  16.593 +}
  16.594 +
  16.595 +void Matrix4x4::set_rotation(const Vector3 &axis, scalar_t angle)
  16.596 +{
  16.597 +	scalar_t sina = (scalar_t)sin(angle);
  16.598 +	scalar_t cosa = (scalar_t)cos(angle);
  16.599 +	scalar_t invcosa = 1-cosa;
  16.600 +	scalar_t nxsq = axis.x * axis.x;
  16.601 +	scalar_t nysq = axis.y * axis.y;
  16.602 +	scalar_t nzsq = axis.z * axis.z;
  16.603 +
  16.604 +	reset_identity();
  16.605 +	m[0][0] = nxsq + (1-nxsq) * cosa;
  16.606 +	m[0][1] = axis.x * axis.y * invcosa - axis.z * sina;
  16.607 +	m[0][2] = axis.x * axis.z * invcosa + axis.y * sina;
  16.608 +	m[1][0] = axis.x * axis.y * invcosa + axis.z * sina;
  16.609 +	m[1][1] = nysq + (1-nysq) * cosa;
  16.610 +	m[1][2] = axis.y * axis.z * invcosa - axis.x * sina;
  16.611 +	m[2][0] = axis.x * axis.z * invcosa - axis.y * sina;
  16.612 +	m[2][1] = axis.y * axis.z * invcosa + axis.x * sina;
  16.613 +	m[2][2] = nzsq + (1-nzsq) * cosa;
  16.614 +}
  16.615 +
  16.616 +void Matrix4x4::rotate(const Quaternion &quat)
  16.617 +{
  16.618 +	*this *= quat.get_rotation_matrix();
  16.619 +}
  16.620 +
  16.621 +void Matrix4x4::set_rotation(const Quaternion &quat)
  16.622 +{
  16.623 +	*this = quat.get_rotation_matrix();
  16.624 +}
  16.625 +
  16.626 +Quaternion Matrix4x4::get_rotation_quat() const
  16.627 +{
  16.628 +	Matrix3x3 mat3 = *this;
  16.629 +	return mat3.get_rotation_quat();
  16.630 +}
  16.631 +
  16.632 +void Matrix4x4::scale(const Vector4 &scale_vec)
  16.633 +{
  16.634 +	Matrix4x4 smat(	scale_vec.x, 0, 0, 0,
  16.635 +					0, scale_vec.y, 0, 0,
  16.636 +					0, 0, scale_vec.z, 0,
  16.637 +					0, 0, 0, scale_vec.w);
  16.638 +	*this *= smat;
  16.639 +}
  16.640 +
  16.641 +void Matrix4x4::set_scaling(const Vector4 &scale_vec)
  16.642 +{
  16.643 +	*this = Matrix4x4(	scale_vec.x, 0, 0, 0,
  16.644 +						0, scale_vec.y, 0, 0,
  16.645 +						0, 0, scale_vec.z, 0,
  16.646 +						0, 0, 0, scale_vec.w);
  16.647 +}
  16.648 +
  16.649 +Vector3 Matrix4x4::get_scaling() const
  16.650 +{
  16.651 +	Vector3 vi = get_row_vector(0);
  16.652 +	Vector3 vj = get_row_vector(1);
  16.653 +	Vector3 vk = get_row_vector(2);
  16.654 +
  16.655 +	return Vector3(vi.length(), vj.length(), vk.length());
  16.656 +}
  16.657 +
  16.658 +void Matrix4x4::set_frustum(float left, float right, float bottom, float top, float znear, float zfar)
  16.659 +{
  16.660 +	float dx = right - left;
  16.661 +	float dy = top - bottom;
  16.662 +	float dz = zfar - znear;
  16.663 +
  16.664 +	float a = (right + left) / dx;
  16.665 +	float b = (top + bottom) / dy;
  16.666 +	float c = -(zfar + znear) / dz;
  16.667 +	float d = -2.0 * zfar * znear / dz;
  16.668 +
  16.669 +	*this = Matrix4x4(2.0 * znear / dx, 0, a, 0,
  16.670 +			0, 2.0 * znear / dy, b, 0,
  16.671 +			0, 0, c, d,
  16.672 +			0, 0, -1, 0);
  16.673 +}
  16.674 +
  16.675 +void Matrix4x4::set_perspective(float vfov, float aspect, float znear, float zfar)
  16.676 +{
  16.677 +	float f = 1.0f / tan(vfov * 0.5f);
  16.678 +    float dz = znear - zfar;
  16.679 +
  16.680 +	reset_identity();
  16.681 +
  16.682 +	m[0][0] = f / aspect;
  16.683 +    m[1][1] = f;
  16.684 +    m[2][2] = (zfar + znear) / dz;
  16.685 +    m[3][2] = -1.0f;
  16.686 +    m[2][3] = 2.0f * zfar * znear / dz;
  16.687 +    m[3][3] = 0.0f;
  16.688 +}
  16.689 +
  16.690 +void Matrix4x4::set_orthographic(float left, float right, float bottom, float top, float znear, float zfar)
  16.691 +{
  16.692 +	float dx = right - left;
  16.693 +	float dy = top - bottom;
  16.694 +	float dz = zfar - znear;
  16.695 +
  16.696 +	reset_identity();
  16.697 +
  16.698 +	m[0][0] = 2.0 / dx;
  16.699 +	m[1][1] = 2.0 / dy;
  16.700 +	m[2][2] = -2.0 / dz;
  16.701 +	m[0][3] = -(right + left) / dx;
  16.702 +	m[1][3] = -(top + bottom) / dy;
  16.703 +	m[2][3] = -(zfar + znear) / dz;
  16.704 +}
  16.705 +
  16.706 +void Matrix4x4::set_lookat(const Vector3 &pos, const Vector3 &targ, const Vector3 &up)
  16.707 +{
  16.708 +	Vector3 vk = (targ - pos).normalized();
  16.709 +	Vector3 vj = up.normalized();
  16.710 +	Vector3 vi = cross_product(vk, vj).normalized();
  16.711 +	vj = cross_product(vi, vk);
  16.712 +
  16.713 +	*this = Matrix4x4(
  16.714 +			vi.x, vi.y, vi.z, 0,
  16.715 +			vj.x, vj.y, vj.z, 0,
  16.716 +			-vk.x, -vk.y, -vk.z, 0,
  16.717 +			0, 0, 0, 1);
  16.718 +	translate(-pos);
  16.719 +}
  16.720 +
  16.721 +void Matrix4x4::set_column_vector(const Vector4 &vec, unsigned int col_index)
  16.722 +{
  16.723 +	m[0][col_index] = vec.x;
  16.724 +	m[1][col_index] = vec.y;
  16.725 +	m[2][col_index] = vec.z;
  16.726 +	m[3][col_index] = vec.w;
  16.727 +}
  16.728 +
  16.729 +void Matrix4x4::set_row_vector(const Vector4 &vec, unsigned int row_index)
  16.730 +{
  16.731 +	m[row_index][0] = vec.x;
  16.732 +	m[row_index][1] = vec.y;
  16.733 +	m[row_index][2] = vec.z;
  16.734 +	m[row_index][3] = vec.w;
  16.735 +}
  16.736 +
  16.737 +Vector4 Matrix4x4::get_column_vector(unsigned int col_index) const
  16.738 +{
  16.739 +	return Vector4(m[0][col_index], m[1][col_index], m[2][col_index], m[3][col_index]);
  16.740 +}
  16.741 +
  16.742 +Vector4 Matrix4x4::get_row_vector(unsigned int row_index) const
  16.743 +{
  16.744 +	return Vector4(m[row_index][0], m[row_index][1], m[row_index][2], m[row_index][3]);
  16.745 +}
  16.746 +
  16.747 +void Matrix4x4::transpose()
  16.748 +{
  16.749 +	Matrix4x4 tmp = *this;
  16.750 +	for(int i=0; i<4; i++) {
  16.751 +		for(int j=0; j<4; j++) {
  16.752 +			m[i][j] = tmp[j][i];
  16.753 +		}
  16.754 +	}
  16.755 +}
  16.756 +
  16.757 +Matrix4x4 Matrix4x4::transposed() const
  16.758 +{
  16.759 +	Matrix4x4 res;
  16.760 +	for(int i=0; i<4; i++) {
  16.761 +		for(int j=0; j<4; j++) {
  16.762 +			res[i][j] = m[j][i];
  16.763 +		}
  16.764 +	}
  16.765 +	return res;
  16.766 +}
  16.767 +
  16.768 +scalar_t Matrix4x4::determinant() const
  16.769 +{
  16.770 +	scalar_t det11 =	(m[1][1] * (m[2][2] * m[3][3] - m[3][2] * m[2][3])) -
  16.771 +						(m[1][2] * (m[2][1] * m[3][3] - m[3][1] * m[2][3])) +
  16.772 +						(m[1][3] * (m[2][1] * m[3][2] - m[3][1] * m[2][2]));
  16.773 +
  16.774 +	scalar_t det12 =	(m[1][0] * (m[2][2] * m[3][3] - m[3][2] * m[2][3])) -
  16.775 +						(m[1][2] * (m[2][0] * m[3][3] - m[3][0] * m[2][3])) +
  16.776 +						(m[1][3] * (m[2][0] * m[3][2] - m[3][0] * m[2][2]));
  16.777 +
  16.778 +	scalar_t det13 =	(m[1][0] * (m[2][1] * m[3][3] - m[3][1] * m[2][3])) -
  16.779 +						(m[1][1] * (m[2][0] * m[3][3] - m[3][0] * m[2][3])) +
  16.780 +						(m[1][3] * (m[2][0] * m[3][1] - m[3][0] * m[2][1]));
  16.781 +
  16.782 +	scalar_t det14 =	(m[1][0] * (m[2][1] * m[3][2] - m[3][1] * m[2][2])) -
  16.783 +						(m[1][1] * (m[2][0] * m[3][2] - m[3][0] * m[2][2])) +
  16.784 +						(m[1][2] * (m[2][0] * m[3][1] - m[3][0] * m[2][1]));
  16.785 +
  16.786 +	return m[0][0] * det11 - m[0][1] * det12 + m[0][2] * det13 - m[0][3] * det14;
  16.787 +}
  16.788 +
  16.789 +
  16.790 +Matrix4x4 Matrix4x4::adjoint() const
  16.791 +{
  16.792 +	Matrix4x4 coef;
  16.793 +
  16.794 +	coef.m[0][0] =	(m[1][1] * (m[2][2] * m[3][3] - m[3][2] * m[2][3])) -
  16.795 +					(m[1][2] * (m[2][1] * m[3][3] - m[3][1] * m[2][3])) +
  16.796 +					(m[1][3] * (m[2][1] * m[3][2] - m[3][1] * m[2][2]));
  16.797 +	coef.m[0][1] =	(m[1][0] * (m[2][2] * m[3][3] - m[3][2] * m[2][3])) -
  16.798 +					(m[1][2] * (m[2][0] * m[3][3] - m[3][0] * m[2][3])) +
  16.799 +					(m[1][3] * (m[2][0] * m[3][2] - m[3][0] * m[2][2]));
  16.800 +	coef.m[0][2] =	(m[1][0] * (m[2][1] * m[3][3] - m[3][1] * m[2][3])) -
  16.801 +					(m[1][1] * (m[2][0] * m[3][3] - m[3][0] * m[2][3])) +
  16.802 +					(m[1][3] * (m[2][0] * m[3][1] - m[3][0] * m[2][1]));
  16.803 +	coef.m[0][3] =	(m[1][0] * (m[2][1] * m[3][2] - m[3][1] * m[2][2])) -
  16.804 +					(m[1][1] * (m[2][0] * m[3][2] - m[3][0] * m[2][2])) +
  16.805 +					(m[1][2] * (m[2][0] * m[3][1] - m[3][0] * m[2][1]));
  16.806 +
  16.807 +	coef.m[1][0] =	(m[0][1] * (m[2][2] * m[3][3] - m[3][2] * m[2][3])) -
  16.808 +					(m[0][2] * (m[2][1] * m[3][3] - m[3][1] * m[2][3])) +
  16.809 +					(m[0][3] * (m[2][1] * m[3][2] - m[3][1] * m[2][2]));
  16.810 +	coef.m[1][1] =	(m[0][0] * (m[2][2] * m[3][3] - m[3][2] * m[2][3])) -
  16.811 +					(m[0][2] * (m[2][0] * m[3][3] - m[3][0] * m[2][3])) +
  16.812 +					(m[0][3] * (m[2][0] * m[3][2] - m[3][0] * m[2][2]));
  16.813 +	coef.m[1][2] =	(m[0][0] * (m[2][1] * m[3][3] - m[3][1] * m[2][3])) -
  16.814 +					(m[0][1] * (m[2][0] * m[3][3] - m[3][0] * m[2][3])) +
  16.815 +					(m[0][3] * (m[2][0] * m[3][1] - m[3][0] * m[2][1]));
  16.816 +	coef.m[1][3] =	(m[0][0] * (m[2][1] * m[3][2] - m[3][1] * m[2][2])) -
  16.817 +					(m[0][1] * (m[2][0] * m[3][2] - m[3][0] * m[2][2])) +
  16.818 +					(m[0][2] * (m[2][0] * m[3][1] - m[3][0] * m[2][1]));
  16.819 +
  16.820 +	coef.m[2][0] =	(m[0][1] * (m[1][2] * m[3][3] - m[3][2] * m[1][3])) -
  16.821 +					(m[0][2] * (m[1][1] * m[3][3] - m[3][1] * m[1][3])) +
  16.822 +					(m[0][3] * (m[1][1] * m[3][2] - m[3][1] * m[1][2]));
  16.823 +	coef.m[2][1] =	(m[0][0] * (m[1][2] * m[3][3] - m[3][2] * m[1][3])) -
  16.824 +					(m[0][2] * (m[1][0] * m[3][3] - m[3][0] * m[1][3])) +
  16.825 +					(m[0][3] * (m[1][0] * m[3][2] - m[3][0] * m[1][2]));
  16.826 +	coef.m[2][2] =	(m[0][0] * (m[1][1] * m[3][3] - m[3][1] * m[1][3])) -
  16.827 +					(m[0][1] * (m[1][0] * m[3][3] - m[3][0] * m[1][3])) +
  16.828 +					(m[0][3] * (m[1][0] * m[3][1] - m[3][0] * m[1][1]));
  16.829 +	coef.m[2][3] =	(m[0][0] * (m[1][1] * m[3][2] - m[3][1] * m[1][2])) -
  16.830 +					(m[0][1] * (m[1][0] * m[3][2] - m[3][0] * m[1][2])) +
  16.831 +					(m[0][2] * (m[1][0] * m[3][1] - m[3][0] * m[1][1]));
  16.832 +
  16.833 +	coef.m[3][0] =	(m[0][1] * (m[1][2] * m[2][3] - m[2][2] * m[1][3])) -
  16.834 +					(m[0][2] * (m[1][1] * m[2][3] - m[2][1] * m[1][3])) +
  16.835 +					(m[0][3] * (m[1][1] * m[2][2] - m[2][1] * m[1][2]));
  16.836 +	coef.m[3][1] =	(m[0][0] * (m[1][2] * m[2][3] - m[2][2] * m[1][3])) -
  16.837 +					(m[0][2] * (m[1][0] * m[2][3] - m[2][0] * m[1][3])) +
  16.838 +					(m[0][3] * (m[1][0] * m[2][2] - m[2][0] * m[1][2]));
  16.839 +	coef.m[3][2] =	(m[0][0] * (m[1][1] * m[2][3] - m[2][1] * m[1][3])) -
  16.840 +					(m[0][1] * (m[1][0] * m[2][3] - m[2][0] * m[1][3])) +
  16.841 +					(m[0][3] * (m[1][0] * m[2][1] - m[2][0] * m[1][1]));
  16.842 +	coef.m[3][3] =	(m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])) -
  16.843 +					(m[0][1] * (m[1][0] * m[2][2] - m[2][0] * m[1][2])) +
  16.844 +					(m[0][2] * (m[1][0] * m[2][1] - m[2][0] * m[1][1]));
  16.845 +
  16.846 +	coef.transpose();
  16.847 +
  16.848 +	for(int i=0; i<4; i++) {
  16.849 +		for(int j=0; j<4; j++) {
  16.850 +			coef.m[i][j] = j%2 ? -coef.m[i][j] : coef.m[i][j];
  16.851 +			if(i%2) coef.m[i][j] = -coef.m[i][j];
  16.852 +		}
  16.853 +	}
  16.854 +
  16.855 +	return coef;
  16.856 +}
  16.857 +
  16.858 +Matrix4x4 Matrix4x4::inverse() const
  16.859 +{
  16.860 +	Matrix4x4 adj = adjoint();
  16.861 +
  16.862 +	return adj * (1.0f / determinant());
  16.863 +}
  16.864 +
  16.865 +/*
  16.866 +ostream &operator <<(ostream &out, const Matrix4x4 &mat)
  16.867 +{
  16.868 +	for(int i=0; i<4; i++) {
  16.869 +		char str[100];
  16.870 +		sprintf(str, "[ %12.5f %12.5f %12.5f %12.5f ]\n", (float)mat.m[i][0], (float)mat.m[i][1], (float)mat.m[i][2], (float)mat.m[i][3]);
  16.871 +		out << str;
  16.872 +	}
  16.873 +	return out;
  16.874 +}
  16.875 +*/

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/libs/vmath/matrix.h	Sun May 31 00:40:26 2015 +0300
    17.3 @@ -0,0 +1,255 @@
    17.4 +/*
    17.5 +libvmath - a vector math library
    17.6 +Copyright (C) 2004-2015 John Tsiombikas <nuclear@member.fsf.org>
    17.7 +
    17.8 +This program is free software: you can redistribute it and/or modify
    17.9 +it under the terms of the GNU Lesser General Public License as published
   17.10 +by the Free Software Foundation, either version 3 of the License, or
   17.11 +(at your option) any later version.
   17.12 +
   17.13 +This program is distributed in the hope that it will be useful,
   17.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   17.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   17.16 +GNU Lesser General Public License for more details.
   17.17 +
   17.18 +You should have received a copy of the GNU Lesser General Public License
   17.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   17.20 +*/
   17.21 +
   17.22 +#ifndef VMATH_MATRIX_H_
   17.23 +#define VMATH_MATRIX_H_
   17.24 +
   17.25 +#include <stdio.h>
   17.26 +#include "vmath_types.h"
   17.27 +#include "vector.h"
   17.28 +
   17.29 +#ifdef __cplusplus
   17.30 +extern "C" {
   17.31 +#endif	/* __cplusplus */
   17.32 +
   17.33 +/* C matrix 3x3 functions */
   17.34 +static inline void m3_identity(mat3_t m);
   17.35 +static inline void m3_cons(mat3_t m,
   17.36 +		scalar_t m11, scalar_t m12, scalar_t m13,
   17.37 +		scalar_t m21, scalar_t m22, scalar_t m23,
   17.38 +		scalar_t m31, scalar_t m32, scalar_t m33);
   17.39 +static inline void m3_copy(mat3_t dest, mat3_t src);
   17.40 +void m3_to_m4(mat4_t dest, mat3_t src);
   17.41 +
   17.42 +void m3_print(FILE *fp, mat3_t m);
   17.43 +
   17.44 +/* C matrix 4x4 functions */
   17.45 +static inline void m4_identity(mat4_t m);
   17.46 +static inline void m4_cons(mat4_t m,
   17.47 +		scalar_t m11, scalar_t m12, scalar_t m13, scalar_t m14,
   17.48 +		scalar_t m21, scalar_t m22, scalar_t m23, scalar_t m24,
   17.49 +		scalar_t m31, scalar_t m32, scalar_t m33, scalar_t m34,
   17.50 +		scalar_t m41, scalar_t m42, scalar_t m43, scalar_t m44);
   17.51 +static inline void m4_copy(mat4_t dest, mat4_t src);
   17.52 +void m4_to_m3(mat3_t dest, mat4_t src);
   17.53 +
   17.54 +static inline void m4_mult(mat4_t res, mat4_t m1, mat4_t m2);
   17.55 +
   17.56 +void m4_set_translation(mat4_t m, scalar_t x, scalar_t y, scalar_t z);
   17.57 +void m4_translate(mat4_t m, scalar_t x, scalar_t y, scalar_t z);
   17.58 +
   17.59 +void m4_rotate(mat4_t m, scalar_t x, scalar_t y, scalar_t z);
   17.60 +
   17.61 +void m4_set_rotation_x(mat4_t m, scalar_t angle);
   17.62 +void m4_rotate_x(mat4_t m, scalar_t angle);
   17.63 +void m4_set_rotation_y(mat4_t m, scalar_t angle);
   17.64 +void m4_rotate_y(mat4_t m, scalar_t angle);
   17.65 +void m4_set_rotation_z(mat4_t m, scalar_t angle);
   17.66 +void m4_rotate_z(mat4_t m, scalar_t angle);
   17.67 +/* axis-angle rotation */
   17.68 +void m4_set_rotation_axis(mat4_t m, scalar_t angle, scalar_t x, scalar_t y, scalar_t z);
   17.69 +void m4_rotate_axis(mat4_t m, scalar_t angle, scalar_t x, scalar_t y, scalar_t z);
   17.70 +/* concatentate a rotation quaternion */
   17.71 +void m4_rotate_quat(mat4_t m, quat_t q);
   17.72 +
   17.73 +void m4_set_scaling(mat4_t m, scalar_t x, scalar_t y, scalar_t z);
   17.74 +void m4_scale(mat4_t m, scalar_t x, scalar_t y, scalar_t z);
   17.75 +
   17.76 +static inline void m4_set_column(mat4_t m, vec4_t v, int idx);
   17.77 +static inline void m4_set_row(mat4_t m, vec4_t v, int idx);
   17.78 +
   17.79 +void m4_transpose(mat4_t res, mat4_t m);
   17.80 +scalar_t m4_determinant(mat4_t m);
   17.81 +void m4_adjoint(mat4_t res, mat4_t m);
   17.82 +void m4_inverse(mat4_t res, mat4_t m);
   17.83 +
   17.84 +void m4_print(FILE *fp, mat4_t m);
   17.85 +
   17.86 +#ifdef __cplusplus
   17.87 +}
   17.88 +
   17.89 +/* when included from C++ source files, also define the matrix classes */
   17.90 +
   17.91 +/** 3x3 matrix */
   17.92 +class Matrix3x3 {
   17.93 +public:
   17.94 +	scalar_t m[3][3];
   17.95 +
   17.96 +	static Matrix3x3 identity;
   17.97 +
   17.98 +	Matrix3x3();
   17.99 +	Matrix3x3(	scalar_t m11, scalar_t m12, scalar_t m13,
  17.100 +				scalar_t m21, scalar_t m22, scalar_t m23,
  17.101 +				scalar_t m31, scalar_t m32, scalar_t m33);
  17.102 +	Matrix3x3(const Vector3 &ivec, const Vector3 &jvec, const Vector3 &kvec);
  17.103 +	Matrix3x3(const mat3_t cmat);
  17.104 +
  17.105 +	Matrix3x3(const Matrix4x4 &mat4x4);
  17.106 +
  17.107 +	/* binary operations matrix (op) matrix */
  17.108 +	friend Matrix3x3 operator +(const Matrix3x3 &m1, const Matrix3x3 &m2);
  17.109 +	friend Matrix3x3 operator -(const Matrix3x3 &m1, const Matrix3x3 &m2);
  17.110 +	friend Matrix3x3 operator *(const Matrix3x3 &m1, const Matrix3x3 &m2);
  17.111 +
  17.112 +	friend void operator +=(Matrix3x3 &m1, const Matrix3x3 &m2);
  17.113 +	friend void operator -=(Matrix3x3 &m1, const Matrix3x3 &m2);
  17.114 +	friend void operator *=(Matrix3x3 &m1, const Matrix3x3 &m2);
  17.115 +
  17.116 +	/* binary operations matrix (op) scalar and scalar (op) matrix */
  17.117 +	friend Matrix3x3 operator *(const Matrix3x3 &mat, scalar_t scalar);
  17.118 +	friend Matrix3x3 operator *(scalar_t scalar, const Matrix3x3 &mat);
  17.119 +
  17.120 +	friend void operator *=(Matrix3x3 &mat, scalar_t scalar);
  17.121 +
  17.122 +	inline scalar_t *operator [](int index);
  17.123 +	inline const scalar_t *operator [](int index) const;
  17.124 +
  17.125 +	inline void reset_identity();
  17.126 +
  17.127 +	void translate(const Vector2 &trans);
  17.128 +	void set_translation(const Vector2 &trans);
  17.129 +
  17.130 +	void rotate(scalar_t angle);						/* 2d rotation */
  17.131 +	void rotate(const Vector3 &euler_angles);			/* 3d rotation with euler angles */
  17.132 +	void rotate(const Vector3 &axis, scalar_t angle);	/* 3d axis/angle rotation */
  17.133 +	void set_rotation(scalar_t angle);
  17.134 +	void set_rotation(const Vector3 &euler_angles);
  17.135 +	void set_rotation(const Vector3 &axis, scalar_t angle);
  17.136 +	Quaternion get_rotation_quat() const;
  17.137 +
  17.138 +	void scale(const Vector3 &scale_vec);
  17.139 +	void set_scaling(const Vector3 &scale_vec);
  17.140 +
  17.141 +	void set_column_vector(const Vector3 &vec, unsigned int col_index);
  17.142 +	void set_row_vector(const Vector3 &vec, unsigned int row_index);
  17.143 +	Vector3 get_column_vector(unsigned int col_index) const;
  17.144 +	Vector3 get_row_vector(unsigned int row_index) const;
  17.145 +
  17.146 +	void transpose();
  17.147 +	Matrix3x3 transposed() const;
  17.148 +	scalar_t determinant() const;
  17.149 +	Matrix3x3 inverse() const;
  17.150 +};
  17.151 +
  17.152 +/* binary operations matrix (op) matrix */
  17.153 +Matrix3x3 operator +(const Matrix3x3 &m1, const Matrix3x3 &m2);
  17.154 +Matrix3x3 operator -(const Matrix3x3 &m1, const Matrix3x3 &m2);
  17.155 +Matrix3x3 operator *(const Matrix3x3 &m1, const Matrix3x3 &m2);
  17.156 +
  17.157 +void operator +=(Matrix3x3 &m1, const Matrix3x3 &m2);
  17.158 +void operator -=(Matrix3x3 &m1, const Matrix3x3 &m2);
  17.159 +void operator *=(Matrix3x3 &m1, const Matrix3x3 &m2);
  17.160 +
  17.161 +/* binary operations matrix (op) scalar and scalar (op) matrix */
  17.162 +Matrix3x3 operator *(const Matrix3x3 &mat, scalar_t scalar);
  17.163 +Matrix3x3 operator *(scalar_t scalar, const Matrix3x3 &mat);
  17.164 +
  17.165 +void operator *=(Matrix3x3 &mat, scalar_t scalar);
  17.166 +
  17.167 +
  17.168 +
  17.169 +/** 4x4 matrix */
  17.170 +class Matrix4x4 {
  17.171 +public:
  17.172 +	scalar_t m[4][4];
  17.173 +
  17.174 +	static Matrix4x4 identity;
  17.175 +
  17.176 +	Matrix4x4();
  17.177 +	Matrix4x4(	scalar_t m11, scalar_t m12, scalar_t m13, scalar_t m14,
  17.178 +				scalar_t m21, scalar_t m22, scalar_t m23, scalar_t m24,
  17.179 +				scalar_t m31, scalar_t m32, scalar_t m33, scalar_t m34,
  17.180 +				scalar_t m41, scalar_t m42, scalar_t m43, scalar_t m44);
  17.181 +	Matrix4x4(const mat4_t cmat);
  17.182 +
  17.183 +	Matrix4x4(const Matrix3x3 &mat3x3);
  17.184 +
  17.185 +	/* binary operations matrix (op) matrix */
  17.186 +	friend Matrix4x4 operator +(const Matrix4x4 &m1, const Matrix4x4 &m2);
  17.187 +	friend Matrix4x4 operator -(const Matrix4x4 &m1, const Matrix4x4 &m2);
  17.188 +	friend Matrix4x4 operator *(const Matrix4x4 &m1, const Matrix4x4 &m2);
  17.189 +
  17.190 +	friend void operator +=(Matrix4x4 &m1, const Matrix4x4 &m2);
  17.191 +	friend void operator -=(Matrix4x4 &m1, const Matrix4x4 &m2);
  17.192 +	friend inline void operator *=(Matrix4x4 &m1, const Matrix4x4 &m2);
  17.193 +
  17.194 +	/* binary operations matrix (op) scalar and scalar (op) matrix */
  17.195 +	friend Matrix4x4 operator *(const Matrix4x4 &mat, scalar_t scalar);
  17.196 +	friend Matrix4x4 operator *(scalar_t scalar, const Matrix4x4 &mat);
  17.197 +
  17.198 +	friend void operator *=(Matrix4x4 &mat, scalar_t scalar);
  17.199 +
  17.200 +	inline scalar_t *operator [](int index);
  17.201 +	inline const scalar_t *operator [](int index) const;
  17.202 +
  17.203 +	inline void reset_identity();
  17.204 +
  17.205 +	void translate(const Vector3 &trans);
  17.206 +	void set_translation(const Vector3 &trans);
  17.207 +	Vector3 get_translation() const;	/* extract translation */
  17.208 +
  17.209 +	void rotate(const Vector3 &euler_angles);			/* 3d rotation with euler angles */
  17.210 +	void rotate(const Vector3 &axis, scalar_t angle);	/* 3d axis/angle rotation */
  17.211 +	void rotate(const Quaternion &quat);
  17.212 +	void set_rotation(const Vector3 &euler_angles);
  17.213 +	void set_rotation(const Vector3 &axis, scalar_t angle);
  17.214 +	void set_rotation(const Quaternion &quat);
  17.215 +	Quaternion get_rotation_quat() const;		/* extract rotation */
  17.216 +
  17.217 +	void scale(const Vector4 &scale_vec);
  17.218 +	void set_scaling(const Vector4 &scale_vec);
  17.219 +	Vector3 get_scaling() const;		/* extract scaling */
  17.220 +
  17.221 +	void set_frustum(float left, float right, float top, float bottom, float znear, float zfar);
  17.222 +	void set_perspective(float vfov, float aspect, float znear, float zfar);
  17.223 +	void set_orthographic(float left, float right, float bottom, float top, float znear = -1.0, float zfar = 1.0);
  17.224 +
  17.225 +	void set_lookat(const Vector3 &pos, const Vector3 &targ = Vector3(0, 0, 0), const Vector3 &up = Vector3(0, 1, 0));
  17.226 +
  17.227 +	void set_column_vector(const Vector4 &vec, unsigned int col_index);
  17.228 +	void set_row_vector(const Vector4 &vec, unsigned int row_index);
  17.229 +	Vector4 get_column_vector(unsigned int col_index) const;
  17.230 +	Vector4 get_row_vector(unsigned int row_index) const;
  17.231 +
  17.232 +	void transpose();
  17.233 +	Matrix4x4 transposed() const;
  17.234 +	scalar_t determinant() const;
  17.235 +	Matrix4x4 adjoint() const;
  17.236 +	Matrix4x4 inverse() const;
  17.237 +};
  17.238 +
  17.239 +/* binary operations matrix (op) matrix */
  17.240 +Matrix4x4 operator +(const Matrix4x4 &m1, const Matrix4x4 &m2);
  17.241 +Matrix4x4 operator -(const Matrix4x4 &m1, const Matrix4x4 &m2);
  17.242 +inline Matrix4x4 operator *(const Matrix4x4 &m1, const Matrix4x4 &m2);
  17.243 +
  17.244 +void operator +=(Matrix4x4 &m1, const Matrix4x4 &m2);
  17.245 +void operator -=(Matrix4x4 &m1, const Matrix4x4 &m2);
  17.246 +inline void operator *=(Matrix4x4 &m1, const Matrix4x4 &m2);
  17.247 +
  17.248 +/* binary operations matrix (op) scalar and scalar (op) matrix */
  17.249 +Matrix4x4 operator *(const Matrix4x4 &mat, scalar_t scalar);
  17.250 +Matrix4x4 operator *(scalar_t scalar, const Matrix4x4 &mat);
  17.251 +
  17.252 +void operator *=(Matrix4x4 &mat, scalar_t scalar);
  17.253 +
  17.254 +#endif	/* __cplusplus */
  17.255 +
  17.256 +#include "matrix.inl"
  17.257 +
  17.258 +#endif	/* VMATH_MATRIX_H_ */