Update for new simgear Canvas system.
A refactored version of the Canvas system can now be found in SimGear.
This commit is contained in:
Thomas Geymayer
parent
4a535f67c0
commit
28779e7a51
70 changed files with 215 additions and 14720 deletions
|
|
@ -148,6 +148,7 @@ else(SIMGEAR_SHARED)
|
|||
|
||||
find_sg_library(SimGearCore SIMGEAR_CORE SIMGEAR_CORE_LIBRARIES)
|
||||
find_sg_library(SimGearScene SIMGEAR_SCENE SIMGEAR_LIBRARIES)
|
||||
find_sg_library(ShivaVG SIMGEAR_SCENE SIMGEAR_LIBRARIES)
|
||||
|
||||
# again link order matters - scene libraries depend on core ones
|
||||
list(APPEND SIMGEAR_LIBRARIES ${SIMGEAR_CORE_LIBRARIES})
|
||||
|
|
|
|||
|
|
@ -1,35 +1,17 @@
|
|||
include(FlightGearComponent)
|
||||
|
||||
set(SOURCES
|
||||
canvas.cxx
|
||||
canvas_mgr.cxx
|
||||
elements/element.cxx
|
||||
elements/group.cxx
|
||||
elements/map.cxx
|
||||
elements/path.cxx
|
||||
elements/text.cxx
|
||||
elements/CanvasImage.cxx
|
||||
FGCanvasSystemAdapter.cxx
|
||||
gui_mgr.cxx
|
||||
placement.cxx
|
||||
property_helper.cxx
|
||||
window.cxx
|
||||
)
|
||||
|
||||
set(HEADERS
|
||||
canvas.hxx
|
||||
canvas_mgr.hxx
|
||||
elements/element.hxx
|
||||
elements/group.hxx
|
||||
elements/map.hxx
|
||||
elements/path.hxx
|
||||
elements/text.hxx
|
||||
elements/CanvasImage.hxx
|
||||
FGCanvasSystemAdapter.hxx
|
||||
gui_mgr.hxx
|
||||
placement.hxx
|
||||
property_helper.hxx
|
||||
window.hxx
|
||||
)
|
||||
|
||||
flightgear_component(Canvas "${SOURCES}" "${HEADERS}")
|
||||
|
||||
add_subdirectory(ShivaVG/src)
|
||||
flightgear_component(Canvas "${SOURCES}" "${HEADERS}")
|
||||
70
src/Canvas/FGCanvasSystemAdapter.cxx
Normal file
70
src/Canvas/FGCanvasSystemAdapter.cxx
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
#include "FGCanvasSystemAdapter.hxx"
|
||||
|
||||
#include <Main/globals.hxx>
|
||||
#include <Viewer/renderer.hxx>
|
||||
|
||||
#include <osgDB/ReadFile>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
//----------------------------------------------------------------------------
|
||||
simgear::canvas::FontPtr
|
||||
FGCanvasSystemAdapter::getFont(const std::string& name) const
|
||||
{
|
||||
SGPath path = globals->resolve_resource_path("Fonts/" + name);
|
||||
if( path.isNull() )
|
||||
{
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_ALERT,
|
||||
"canvas::Text: No such font: " << name
|
||||
);
|
||||
return simgear::canvas::FontPtr();
|
||||
}
|
||||
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_INFO,
|
||||
"canvas::Text: using font file " << path.str()
|
||||
);
|
||||
|
||||
simgear::canvas::FontPtr font = osgText::readFontFile(path.c_str());
|
||||
if( !font )
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_ALERT,
|
||||
"canvas::Text: Failed to open font file " << path.c_str()
|
||||
);
|
||||
|
||||
return font;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void FGCanvasSystemAdapter::addCamera(osg::Camera* camera) const
|
||||
{
|
||||
globals->get_renderer()->addCamera(camera, false);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void FGCanvasSystemAdapter::removeCamera(osg::Camera* camera) const
|
||||
{
|
||||
globals->get_renderer()->removeCamera(camera);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
osg::Image* FGCanvasSystemAdapter::getImage(const std::string& path) const
|
||||
{
|
||||
SGPath tpath = globals->resolve_resource_path(path);
|
||||
if( tpath.isNull() || !tpath.exists() )
|
||||
{
|
||||
SG_LOG(SG_GL, SG_ALERT, "canvas::Image: No such image: " << path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return osgDB::readImageFile(tpath.c_str());
|
||||
}
|
||||
|
||||
}
|
||||
26
src/Canvas/FGCanvasSystemAdapter.hxx
Normal file
26
src/Canvas/FGCanvasSystemAdapter.hxx
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
/*
|
||||
* FGCanvasSystemAdapter.hxx
|
||||
*
|
||||
* Created on: 02.11.2012
|
||||
* Author: tom
|
||||
*/
|
||||
|
||||
#ifndef FG_CANVASSYSTEMADAPTER_HXX_
|
||||
#define FG_CANVASSYSTEMADAPTER_HXX_
|
||||
|
||||
#include <simgear/canvas/CanvasSystemAdapter.hxx>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
class FGCanvasSystemAdapter:
|
||||
public simgear::canvas::SystemAdapter
|
||||
{
|
||||
public:
|
||||
virtual simgear::canvas::FontPtr getFont(const std::string& name) const;
|
||||
virtual void addCamera(osg::Camera* camera) const;
|
||||
virtual void removeCamera(osg::Camera* camera) const;
|
||||
virtual osg::Image* getImage(const std::string& path) const;
|
||||
};
|
||||
}
|
||||
|
||||
#endif /* FG_CANVASSYSTEMADAPTER_HXX_ */
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
// Mouse event
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_MOUSE_EVENT_HXX_
|
||||
#define CANVAS_MOUSE_EVENT_HXX_
|
||||
|
||||
#include <osgGA/GUIEventAdapter>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
class MouseEvent
|
||||
{
|
||||
public:
|
||||
typedef osgGA::GUIEventAdapter::EventType EventType;
|
||||
typedef osgGA::GUIEventAdapter::ScrollingMotion Scroll;
|
||||
|
||||
MouseEvent(EventType type):
|
||||
type(type),
|
||||
x(-1), y(-1),
|
||||
dx(0), dy(0),
|
||||
button(-1),
|
||||
state(-1),
|
||||
mod(-1),
|
||||
scroll(osgGA::GUIEventAdapter::SCROLL_NONE)
|
||||
{}
|
||||
|
||||
osg::Vec2f getPos() const { return osg::Vec2f(x, y); }
|
||||
osg::Vec3f getPos3() const { return osg::Vec3f(x, y, 0); }
|
||||
|
||||
EventType type;
|
||||
float x, y,
|
||||
dx, dy;
|
||||
int button, //<! Button for this event
|
||||
state, //<! Current button state
|
||||
mod; //<! Keyboard modifier state
|
||||
Scroll scroll;
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_MOUSE_EVENT_HXX_ */
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
===============================================================================
|
||||
ShivaVG - an open-source LGPL ANSI C implementation of the OpenVG specification
|
||||
===============================================================================
|
||||
|
||||
Lead developer:
|
||||
|
||||
Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
Occasional patches:
|
||||
|
||||
Daniel Turing
|
||||
Vincenzo Pupillo
|
||||
|
|
@ -1,504 +0,0 @@
|
|||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the Lesser GPL. It also counts
|
||||
as the successor of the GNU Library Public License, version 2, hence
|
||||
the version number 2.1.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Lesser General Public License, applies to some
|
||||
specially designated software packages--typically libraries--of the
|
||||
Free Software Foundation and other authors who decide to use it. You
|
||||
can use it too, but we suggest you first think carefully about whether
|
||||
this license or the ordinary General Public License is the better
|
||||
strategy to use in any particular case, based on the explanations below.
|
||||
|
||||
When we speak of free software, we are referring to freedom of use,
|
||||
not price. Our General Public Licenses are designed to make sure that
|
||||
you have the freedom to distribute copies of free software (and charge
|
||||
for this service if you wish); that you receive source code or can get
|
||||
it if you want it; that you can change the software and use pieces of
|
||||
it in new free programs; and that you are informed that you can do
|
||||
these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
distributors to deny you these rights or to ask you to surrender these
|
||||
rights. These restrictions translate to certain responsibilities for
|
||||
you if you distribute copies of the library or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link other code with the library, you must provide
|
||||
complete object files to the recipients, so that they can relink them
|
||||
with the library after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
We protect your rights with a two-step method: (1) we copyright the
|
||||
library, and (2) we offer you this license, which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
To protect each distributor, we want to make it very clear that
|
||||
there is no warranty for the free library. Also, if the library is
|
||||
modified by someone else and passed on, the recipients should know
|
||||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
restrictive license from a patent holder. Therefore, we insist that
|
||||
any patent license obtained for a version of the library must be
|
||||
consistent with the full freedom of use specified in this license.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the
|
||||
ordinary GNU General Public License. This license, the GNU Lesser
|
||||
General Public License, applies to certain designated libraries, and
|
||||
is quite different from the ordinary General Public License. We use
|
||||
this license for certain libraries in order to permit linking those
|
||||
libraries into non-free programs.
|
||||
|
||||
When a program is linked with a library, whether statically or using
|
||||
a shared library, the combination of the two is legally speaking a
|
||||
combined work, a derivative of the original library. The ordinary
|
||||
General Public License therefore permits such linking only if the
|
||||
entire combination fits its criteria of freedom. The Lesser General
|
||||
Public License permits more lax criteria for linking other code with
|
||||
the library.
|
||||
|
||||
We call this license the "Lesser" General Public License because it
|
||||
does Less to protect the user's freedom than the ordinary General
|
||||
Public License. It also provides other free software developers Less
|
||||
of an advantage over competing non-free programs. These disadvantages
|
||||
are the reason we use the ordinary General Public License for many
|
||||
libraries. However, the Lesser license provides advantages in certain
|
||||
special circumstances.
|
||||
|
||||
For example, on rare occasions, there may be a special need to
|
||||
encourage the widest possible use of a certain library, so that it becomes
|
||||
a de-facto standard. To achieve this, non-free programs must be
|
||||
allowed to use the library. A more frequent case is that a free
|
||||
library does the same job as widely used non-free libraries. In this
|
||||
case, there is little to gain by limiting the free library to free
|
||||
software only, so we use the Lesser General Public License.
|
||||
|
||||
In other cases, permission to use a particular library in non-free
|
||||
programs enables a greater number of people to use a large body of
|
||||
free software. For example, permission to use the GNU C Library in
|
||||
non-free programs enables many more people to use the whole GNU
|
||||
operating system, as well as its variant, the GNU/Linux operating
|
||||
system.
|
||||
|
||||
Although the Lesser General Public License is Less protective of the
|
||||
users' freedom, it does ensure that the user of a program that is
|
||||
linked with the Library has the freedom and the wherewithal to run
|
||||
that program using a modified version of the Library.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library or other
|
||||
program which contains a notice placed by the copyright holder or
|
||||
other authorized party saying it may be distributed under the terms of
|
||||
this Lesser General Public License (also called "this License").
|
||||
Each licensee is addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (1) uses at run time a
|
||||
copy of the library already present on the user's computer system,
|
||||
rather than copying library functions into the executable, and (2)
|
||||
will operate properly with a modified version of the library, if
|
||||
the user installs one, as long as the modified version is
|
||||
interface-compatible with the version that the work was made with.
|
||||
|
||||
c) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
d) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
e) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the materials to be distributed need not include anything that is
|
||||
normally distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Lesser General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
possible use to the public, we recommend making it free software that
|
||||
everyone can redistribute and change. You can do so by permitting
|
||||
redistribution under these terms (or, alternatively, under the terms of the
|
||||
ordinary General Public License).
|
||||
|
||||
To apply these terms, attach the following notices to the library. It is
|
||||
safest to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least the
|
||||
"copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the library, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
||||
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
|
||||
|
||||
|
|
@ -1,67 +0,0 @@
|
|||
04 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* shImage.c: shCopyPixels uses memcpy when formats are
|
||||
equal.
|
||||
|
||||
04 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* openvg.h: changed typedef of VGHandle to void*. Code
|
||||
compiles with no warnings on 64-bit systems now and
|
||||
it's much safer anyway.
|
||||
|
||||
03 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* shContest.c: fixed a bug in SHContext destructor where
|
||||
resource deletion loop was iterating image array while
|
||||
freeing paint objects
|
||||
|
||||
03 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* a patch by Vincenzo Pupillo fixes array constructor behavior
|
||||
when it runs out of memory plus makes its destructor a bit
|
||||
more robust
|
||||
|
||||
03 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* autogen.sh: added --force to autoreconf call
|
||||
|
||||
03 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* Removed automake/autoconf generated files. Added autogen.sh
|
||||
to generate them.
|
||||
|
||||
03 Feb 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* configure.in: changed order of checks for glut library and
|
||||
glXGetProcAddress in -lGL so that latter doesn't fail when
|
||||
glut is not installed.
|
||||
|
||||
30 Jan 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* shGeometry.c: shStrokePath() fixed to handle zero-length line
|
||||
segments gracefully
|
||||
|
||||
* fixed the image color component ordering to be valid against the
|
||||
spec
|
||||
|
||||
* shImage.c, shImage.h: completely overhauled to support multiple
|
||||
image formats. Everything but _PRE and _BW_1 now supported.
|
||||
|
||||
24 Jan 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* Moved release-related info from ChangeLog to NEWS. ChangeLog will
|
||||
now include info regarding each commit to repository
|
||||
|
||||
* Rearranged the path tesselletaion and user-to-surface transformation
|
||||
steps in the pipeline to produce higher curve resolution when path is
|
||||
scaled up
|
||||
|
||||
* Using new pipeline design, transformed bound-box query can now return
|
||||
really tight bounds
|
||||
|
||||
* Inserted empty/nop definitions for all non-implemented function so
|
||||
that linking against the library doesn't fail.
|
||||
|
||||
22 Jan 2008 Ivan Leben <ivan.leben@gmail.com>
|
||||
|
||||
* Fixed a bug where vgGetError would always return VG_NO_ERROR
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
shIsValid* functions do a search through array!!!
|
||||
That is required because user handles are actually pointers and need to be found in the valid path array. Solution would be to use indices into an array of pointers for internal handle-to-pointer conversion. When a path is deleted, an empty space would be left in the array and used when the next path is created.
|
||||
|
||||
How to speed up image upload / manipulation
|
||||
=============================================
|
||||
|
||||
1) shCopyPixels uses memcpy
|
||||
|
||||
First, manipulation can be speeded up by modifying shCopyPixels
|
||||
to copy lines using memcpy directly when source and target
|
||||
formats are equal. If stride is same too, than we can memcpy
|
||||
the whole block of memory.
|
||||
|
||||
2) What about mapping image manipulation directly to OpenGL
|
||||
texture manipulation calls? Which formats could support this?
|
||||
|
||||
PROBLEM: if NOPS textures are not supported, then writing
|
||||
and reading the image data back results in a precision loss!
|
||||
Even if PBO available we'd need to gluScaleImage into it.
|
||||
|
||||
--> means: no NOPS, need intermediate buffer anyway
|
||||
|
||||
=== Solution1: PBO are available ====
|
||||
|
||||
Extension required: EXT_pixel_buffer_object (ARB_pixel_buffer_object ?)
|
||||
|
||||
Complexity of implementation: really easy - PBO simply
|
||||
replaces the buffer that would be used if NOPS were not there
|
||||
|
||||
Cannot just glBindBuffer(GL_PIXEL_UNPACK_BUFFER) and then
|
||||
glReadPixels into client memory, because glPixelStore
|
||||
doesn't allow for random row byte size ("stride" must be
|
||||
a multiple of pixel byte size).
|
||||
|
||||
We can safely glMapBuffer and copy from it whatever we want
|
||||
however we want, and do any kind of conversion inbetween.
|
||||
Is glMapBuffer + memcpy into user memory faster than just
|
||||
glGetTexImage? Probably yes, since glGetTexImage probably
|
||||
first downloads the data from GPU anyway.
|
||||
|
||||
glMapBuffer better anyway, because we can directly do the format
|
||||
conversions unsupported by OpenGL (premultiplied to unpremultiplied,
|
||||
grayscale conversion with different per component coefficients
|
||||
instead of simple averaging etc.). We use all the exact same code
|
||||
as when NOPS not supported.
|
||||
|
||||
|
||||
=== Solution2: no PBOs ===
|
||||
|
||||
- vgImageSubData => glTexSubImage2D
|
||||
- vgGetImageSubData => glGetTexImage
|
||||
- vgCopyImage => glGetTexImage, glTexSubImage2D
|
||||
- vgSetPixels => glGetTexImage, glDrawPixels
|
||||
|
||||
(PROBLEM: for glGetTexImage, row length in glPixelStore must
|
||||
be a multiple of pixel byte size!)
|
||||
|
||||
- when copying pixels to/from the texture, we still need to
|
||||
manually clip the working pixel region to the intersection
|
||||
of the source and destination rectangles, since opengl spec
|
||||
says INVALID_VALUE error is generated for invalid regions
|
||||
(e.g. dstX + copyW > dstW)
|
||||
|
||||
|
||||
How to solve great slow-down when scaled up?
|
||||
=============================================
|
||||
|
||||
Reasons:
|
||||
- cpu is subdividing a loooong path
|
||||
- fill-rate is a bad thing
|
||||
|
||||
1. By writing gradient shaders, there would be no need to
|
||||
draw into stencil first and then fill the whole area where stencil
|
||||
odd - at least not when drawing stroke (optimizes half of the pipeline)
|
||||
|
||||
2. Real tesselation would reduce fill rate for filled paths, but does
|
||||
the CPU bottleneck outweight the gain?
|
||||
|
||||
3. Early path discarding (transformed bounds outside surface? maybe
|
||||
early convex-hull rule removal?)
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
version 0.2.0 to 0.2.1 (20 Mar 2009):
|
||||
* Implemented scissoring for 1 scissor rectangle
|
||||
|
||||
version 0.2.0 (20 Jan 2008):
|
||||
* Fixed a bug where rotation in the paint-to-user matrix broke radial
|
||||
gradient fill.
|
||||
|
||||
* vgCreateContextSH interface changed to allow for specification of
|
||||
surface width and height
|
||||
|
||||
* new extension: vgResizeSurfaceSH to be called whenever the surface
|
||||
needs to be resized to match the new window size
|
||||
|
||||
* #define GL_GLEXT_LEGACY in shExtensions.h prior to including gl.h
|
||||
so it doesn't include glext.h automatically, which enables us to
|
||||
check for OpenGL version and define OpenGL extension functions
|
||||
manually.
|
||||
|
||||
* Optimized image uploading by replacing the call to gluBuild2DMipmaps
|
||||
with glTexImage2D and changing the filter used to GL_LINEAR
|
||||
|
||||
* Added detection of ARB_texture_non_power_of_two extension to upload
|
||||
rectangular images directly instead of scaling them and loosing
|
||||
precision
|
||||
|
||||
* Pattern paint implemented
|
||||
|
||||
* Include folder changed to "vg" (lowercase)
|
||||
|
||||
* Added a message to test_blend program to notify the user that it
|
||||
has not been implemented yet (black screen is therefore fine)
|
||||
|
||||
* All the calls to glLoadMatrix replaced with glPushMatrix,
|
||||
glMultMatrix, glPopMatrix.
|
||||
|
||||
* Replaced images used in example programs for royalty-free
|
||||
|
||||
* README file written
|
||||
|
|
@ -1,252 +0,0 @@
|
|||
ShivaVG
|
||||
=============================
|
||||
|
||||
See AUTHORS for the list of contributors
|
||||
|
||||
ShivaVG is an open-source LGPL ANSI C implementation of the Khronos
|
||||
Group OpenVG specification.
|
||||
|
||||
I. BUILD
|
||||
II. TESTING
|
||||
III. IMPLEMENTATION STATUS
|
||||
IV. EXTENSIONS
|
||||
|
||||
|
||||
I. BUILD
|
||||
=============================
|
||||
|
||||
* Prerequisites:
|
||||
|
||||
OpenGL development libraries and headers should be installed.
|
||||
Othe than that, since it's ANSI C should compile with any modern
|
||||
C compiler. jpeglib needs to be installed for example programs
|
||||
that use images.
|
||||
|
||||
* Compiling under UNIX systems:
|
||||
|
||||
Read the INSTALL file for more detailed (though generic) directions.
|
||||
This library uses the standard ./configure ; make. The example
|
||||
programs are automatically compiled. However, compilation of each
|
||||
example program can be toggled by ./configure --with-example-xxx
|
||||
command where xxx denotes the name of the example. Run ./configure
|
||||
--help for a list of such options.
|
||||
|
||||
* Compiling on Mac:
|
||||
|
||||
No XCode project files provided yet. The easiest way is by just
|
||||
using gcc, in which case look under UNIX compiling section.
|
||||
|
||||
* Compiling natively on Windows platform:
|
||||
|
||||
Solution files are provided for Visual C++ version 7 and 8. For
|
||||
the example programs using images to compile, you will need the
|
||||
appropriate build of jpeglib to match your Visual C++ version.
|
||||
|
||||
* Compiling in mingw / cygwin environment:
|
||||
|
||||
Might work just as fine as any UNIX-flavored system, but hasn't
|
||||
been tested yet.
|
||||
|
||||
|
||||
II. TESTING
|
||||
=============================
|
||||
|
||||
There is no real testing suite yet. The example programs are there
|
||||
just to play with what the implementation can currently do, but
|
||||
can hardly provide any proper validation, since no reference images
|
||||
are provided. Here is a description of each example program and
|
||||
what features it highlights:
|
||||
|
||||
* test_vgu
|
||||
|
||||
Constructs some path primitives using the VGU API.
|
||||
|
||||
* test_tiger
|
||||
|
||||
The most simple performance test. It draws the well known svg
|
||||
tiger using just simple stroke and fill of solid colors. It
|
||||
consists of 240 paths.
|
||||
|
||||
* test_dash
|
||||
|
||||
Shows different stroke dashing modes.
|
||||
|
||||
* test_linear
|
||||
|
||||
A rectangle drawn using 3-color linear gradient fill paint
|
||||
|
||||
* test_radial
|
||||
|
||||
A rectangle drawn using 3-color radial gradient fill paint
|
||||
|
||||
* test_interpolate
|
||||
|
||||
Interpolates between two paths - an apple and a pear.
|
||||
|
||||
* test_image
|
||||
|
||||
Images are drawn using VG_DRAW_IMAGE_MULTIPLY image mode to be
|
||||
multiplied with radial gradient fill paint.
|
||||
|
||||
* test_pattern
|
||||
|
||||
An image is drawn in multiply mode with an image pattern fill
|
||||
paint.
|
||||
|
||||
|
||||
III. IMPLEMENTATION STATUS
|
||||
=============================
|
||||
|
||||
Khronos states in the OpenVG specification, that the contexts for all
|
||||
their client APIs are expected to be created via the EGL API. Since
|
||||
EGL to use with ShivaVG has not been implemented yet, there is a set
|
||||
of extension functions provided for the task of creating, maintaining
|
||||
and destroying the OpenVG context. (See next section EXTENSIONS for
|
||||
details.)
|
||||
|
||||
What follows is a description of which functions or to what extent
|
||||
a certain function has been implemented. When a function is marked
|
||||
as PARTIALLY implemented, the TODO file or the comments in the code
|
||||
itself would provide further clues.
|
||||
|
||||
|
||||
* General:
|
||||
|
||||
vgGetError ............................ FULLY implemented
|
||||
vgFlush ............................... FULLY implemented
|
||||
vgFinish .............................. FULLY implemented
|
||||
|
||||
* Getters and setters:
|
||||
|
||||
vgSet ................................. FULLY implemented
|
||||
vgSeti ................................ FULLY implemented
|
||||
vgSetfv ............................... FULLY implemented
|
||||
vgSetiv ............................... FULLY implemented
|
||||
vgGetf ................................ FULLY implemented
|
||||
vgGeti ................................ FULLY implemented
|
||||
vgGetVectorSize ....................... FULLY implemented
|
||||
vgGetfv ............................... FULLY implemented
|
||||
vgGetiv ............................... FULLY implemented
|
||||
vgSetParameterf ....................... FULLY implemented
|
||||
vgSetParameteri ....................... FULLY implemented
|
||||
vgSetParameterfv ...................... FULLY implemented
|
||||
vgSetParameteriv ...................... FULLY implemented
|
||||
vgGetParameterf ....................... FULLY implemented
|
||||
vgGetParameteri ....................... FULLY implemented
|
||||
vgGetParameterVectorSize............... FULLY implemented
|
||||
vgGetParameterfv ...................... FULLY implemented
|
||||
vgGetParameteriv ...................... FULLY implemented
|
||||
|
||||
* Matrix Manipulation:
|
||||
|
||||
vgLoadIdentity ........................ FULLY implemented
|
||||
vgLoadMatrix .......................... FULLY implemented
|
||||
vgGetMatrix ........................... FULLY implemented
|
||||
vgMultMatrix .......................... FULLY implemented
|
||||
vgTranslate ........................... FULLY implemented
|
||||
vgScale ............................... FULLY implemented
|
||||
vgShear ............................... FULLY implemented
|
||||
vgRotate .............................. FULLY implemented
|
||||
|
||||
* Masking and Clearing:
|
||||
|
||||
vgMask ................................ NOT implemented
|
||||
vgClear ............................... FULLY implemented
|
||||
|
||||
* Paths:
|
||||
|
||||
vgCreatePath .......................... FULLY implemented
|
||||
vgClearPath ........................... FULLY implemented
|
||||
vgDestroyPath ......................... FULLY implemented
|
||||
vgRemovePathCapabilities .............. FULLY implemented
|
||||
vgGetPathCapabilities ................. FULLY implemented
|
||||
vgAppendPath .......................... FULLY implemented
|
||||
vgAppendPathData ...................... FULLY implemented
|
||||
vgModifyPathCoords .................... FULLY implemented
|
||||
vgTransformPath ....................... FULLY implemented
|
||||
vgInterpolatePath ..................... FULLY implemented
|
||||
vgPathLength .......................... NOT implemented
|
||||
vgPointAlongPath ...................... NOT implemented
|
||||
vgPathBounds .......................... FULLY implemented
|
||||
vgPathTransformedBounds ............... FULLY implemented
|
||||
vgDrawPath ............................ PARTIALLY implemented
|
||||
|
||||
* Paint:
|
||||
|
||||
vgCreatePaint ......................... FULLY implemented
|
||||
vgDestroyPaint ........................ FULLY implemented
|
||||
vgSetPaint ............................ FULLY implemented
|
||||
vgGetPaint ............................ FULLY implemented
|
||||
vgSetColor ............................ FULLY implemented
|
||||
vgGetColor ............................ FULLY implemented
|
||||
vgPaintPattern ........................ FULLY implemented
|
||||
|
||||
* Images:
|
||||
|
||||
vgCreateImage ......................... PARTIALLY implemented
|
||||
vgDestroyImage ........................ FULLY implemented
|
||||
vgClearImage .......................... FULLY implemented
|
||||
vgImageSubData ........................ PARTIALLY implemented
|
||||
vgGetImageSubData ..................... PARTIALLY implemented
|
||||
vgChildImage .......................... NOT implemented
|
||||
vgGetParent ........................... NOT implemented
|
||||
vgCopyImage ........................... FULLY implemented
|
||||
vgDrawImage ........................... PARTIALLY implemented
|
||||
vgSetPixels ........................... FULLY implemented
|
||||
vgWritePixels ......................... FULLY implemented
|
||||
vgGetPixels ........................... FULLY implemented
|
||||
vgReadPixels .......................... FULLY implemented
|
||||
vgCopyPixels .......................... FULLY implemented
|
||||
|
||||
* Image Filters:
|
||||
|
||||
vgColorMatrix ......................... NOT implemented
|
||||
vgConvolve ............................ NOT implemented
|
||||
vgSeparableConvolve ................... NOT implemented
|
||||
vgGaussianBlur ........................ NOT implemented
|
||||
vgLookup .............................. NOT implemented
|
||||
vgLookupSingle ........................ NOT implemented
|
||||
|
||||
* Hardware Queries:
|
||||
|
||||
vgHardwareQuery ....................... NOT implemented
|
||||
|
||||
* Renderer and Extension Information:
|
||||
|
||||
vgGetString ........................... FULLY implemented
|
||||
|
||||
* VGU
|
||||
|
||||
vguLine ............................... FULLY implemented
|
||||
vguPolygon ............................ FULLY implemented
|
||||
vguRect ............................... FULLY implemented
|
||||
vguRoundRect .......................... FULLY implemented
|
||||
vguEllipse ............................ FULLY implemented
|
||||
vguArc ................................ FULLY implemented
|
||||
vguComputeWarpQuadToSquare ............ NOT implemented
|
||||
vguComputeWarpSquareToQuad ............ NOT implemented
|
||||
vguComputeWarpQuadToQuad .............. NOT implemented
|
||||
|
||||
|
||||
IV. EXTENSIONS
|
||||
=============================
|
||||
|
||||
There are three extensions to the API that manipulate the OpenVG
|
||||
context as a temporary replacement for EGL:
|
||||
|
||||
VGboolean vgCreateContextSH(VGint width, VGint height)
|
||||
|
||||
Creates an OpenVG context on top of an existing OpenGL context
|
||||
that should have been manually initialized by the user of the
|
||||
library. Width and height specify the size of the rendering
|
||||
surface. No multi-threading support has been implemented yet.
|
||||
The context is created once per process.
|
||||
|
||||
void vgResizeSurfaceSH(VGint width, VGint height)
|
||||
|
||||
Should be called whenever the size of the surface changes (e.g.
|
||||
the owner window of the OpenGL context is resized).
|
||||
|
||||
void vgDestroyContextSH()
|
||||
|
||||
Destroys the OpenVG context associated with the calling process.
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
----------
|
||||
Known bugs
|
||||
----------
|
||||
|
||||
- outofmemory in arrays silently ignored
|
||||
- blending doesn't use premultiplied colors (not porter-duff model)
|
||||
- gradient color ramp is not interpolated in linear space
|
||||
- linear and non-linear image formats behave both linearly
|
||||
- radial gradient circle has got a fixed step instead of
|
||||
proportional to its radius
|
||||
|
||||
-------------------------
|
||||
Incomplete functionality:
|
||||
-------------------------
|
||||
|
||||
- non-zero fill mode
|
||||
- proper porter-duff blending
|
||||
- masking
|
||||
- scissoring
|
||||
- child images
|
||||
- VG_DRAW_IMAGE_STENCIL
|
||||
- _PRE and BW_1 image formats
|
||||
- VGU warp matrices
|
||||
- EGL (image drawing targets)
|
||||
- boundbox / point-on-path / tangent-on-path queries
|
||||
- RENDERING_QUALITY_FASTER == RENDERING_QUALITY_BETTER
|
||||
|
||||
---------------------------
|
||||
Possible portability issues
|
||||
---------------------------
|
||||
|
||||
- GL_UNSIGNED_INT_8_8_8_8 and other for images
|
||||
- GL_MIRRORED_REPEAT for gradients
|
||||
- GL_CLAMP_TO_EDGE for gradients and pattern paints
|
||||
- GL_CLAMP_TO_BORDER for pattern paints
|
||||
- multitexturing for VG_DRAW_IMAGE_MULTIPLY, VG_DRAW_IMAGE_STENCIL
|
||||
|
||||
------
|
||||
Bonus:
|
||||
------
|
||||
|
||||
- gradient shaders? antialiasing shader?
|
||||
|
|
@ -1,632 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _OPENVG_H
|
||||
#define _OPENVG_H
|
||||
|
||||
#define OPENVG_VERSION_1_0_1 1
|
||||
|
||||
/* Type definitions */
|
||||
/* TODO: we can't use config.h in this header so there
|
||||
must be some other technique to assert the proper
|
||||
size of the basic types */
|
||||
|
||||
typedef float VGfloat;
|
||||
typedef char VGbyte;
|
||||
typedef unsigned char VGubyte;
|
||||
typedef short VGshort;
|
||||
typedef int VGint;
|
||||
typedef unsigned int VGuint;
|
||||
typedef unsigned int VGbitfield;
|
||||
|
||||
typedef enum {
|
||||
VG_FALSE = 0,
|
||||
VG_TRUE = 1
|
||||
} VGboolean;
|
||||
|
||||
#define VG_MAXSHORT ((VGshort)((~((unsigned)0)) >> 1))
|
||||
#define VG_MAXINT ((VGint)((~((unsigned)0)) >> 1))
|
||||
|
||||
/* Define handle to be of same length as any pointer */
|
||||
|
||||
typedef void * VGHandle;
|
||||
#define VG_INVALID_HANDLE ((VGHandle)NULL)
|
||||
|
||||
/* Enumerations */
|
||||
|
||||
typedef enum {
|
||||
VG_NO_ERROR = 0,
|
||||
VG_BAD_HANDLE_ERROR = 0x1000,
|
||||
VG_ILLEGAL_ARGUMENT_ERROR = 0x1001,
|
||||
VG_OUT_OF_MEMORY_ERROR = 0x1002,
|
||||
VG_PATH_CAPABILITY_ERROR = 0x1003,
|
||||
VG_UNSUPPORTED_IMAGE_FORMAT_ERROR = 0x1004,
|
||||
VG_UNSUPPORTED_PATH_FORMAT_ERROR = 0x1005,
|
||||
VG_IMAGE_IN_USE_ERROR = 0x1006,
|
||||
VG_NO_CONTEXT_ERROR = 0x1007
|
||||
} VGErrorCode;
|
||||
|
||||
typedef enum {
|
||||
/* Mode settings */
|
||||
VG_MATRIX_MODE = 0x1100,
|
||||
VG_FILL_RULE = 0x1101,
|
||||
VG_IMAGE_QUALITY = 0x1102,
|
||||
VG_RENDERING_QUALITY = 0x1103,
|
||||
VG_BLEND_MODE = 0x1104,
|
||||
VG_IMAGE_MODE = 0x1105,
|
||||
|
||||
/* Scissoring rectangles */
|
||||
VG_SCISSOR_RECTS = 0x1106,
|
||||
|
||||
/* Stroke parameters */
|
||||
VG_STROKE_LINE_WIDTH = 0x1110,
|
||||
VG_STROKE_CAP_STYLE = 0x1111,
|
||||
VG_STROKE_JOIN_STYLE = 0x1112,
|
||||
VG_STROKE_MITER_LIMIT = 0x1113,
|
||||
VG_STROKE_DASH_PATTERN = 0x1114,
|
||||
VG_STROKE_DASH_PHASE = 0x1115,
|
||||
VG_STROKE_DASH_PHASE_RESET = 0x1116,
|
||||
|
||||
/* Edge fill color for VG_TILE_FILL tiling mode */
|
||||
VG_TILE_FILL_COLOR = 0x1120,
|
||||
|
||||
/* Color for vgClear */
|
||||
VG_CLEAR_COLOR = 0x1121,
|
||||
|
||||
/* Enable/disable alpha masking and scissoring */
|
||||
VG_MASKING = 0x1130,
|
||||
VG_SCISSORING = 0x1131,
|
||||
|
||||
/* Pixel layout information */
|
||||
VG_PIXEL_LAYOUT = 0x1140,
|
||||
VG_SCREEN_LAYOUT = 0x1141,
|
||||
|
||||
/* Source format selection for image filters */
|
||||
VG_FILTER_FORMAT_LINEAR = 0x1150,
|
||||
VG_FILTER_FORMAT_PREMULTIPLIED = 0x1151,
|
||||
|
||||
/* Destination write enable mask for image filters */
|
||||
VG_FILTER_CHANNEL_MASK = 0x1152,
|
||||
|
||||
/* Implementation limits (read-only) */
|
||||
VG_MAX_SCISSOR_RECTS = 0x1160,
|
||||
VG_MAX_DASH_COUNT = 0x1161,
|
||||
VG_MAX_KERNEL_SIZE = 0x1162,
|
||||
VG_MAX_SEPARABLE_KERNEL_SIZE = 0x1163,
|
||||
VG_MAX_COLOR_RAMP_STOPS = 0x1164,
|
||||
VG_MAX_IMAGE_WIDTH = 0x1165,
|
||||
VG_MAX_IMAGE_HEIGHT = 0x1166,
|
||||
VG_MAX_IMAGE_PIXELS = 0x1167,
|
||||
VG_MAX_IMAGE_BYTES = 0x1168,
|
||||
VG_MAX_FLOAT = 0x1169,
|
||||
VG_MAX_GAUSSIAN_STD_DEVIATION = 0x116A
|
||||
} VGParamType;
|
||||
|
||||
typedef enum {
|
||||
VG_RENDERING_QUALITY_NONANTIALIASED = 0x1200,
|
||||
VG_RENDERING_QUALITY_FASTER = 0x1201,
|
||||
VG_RENDERING_QUALITY_BETTER = 0x1202 /* Default */
|
||||
} VGRenderingQuality;
|
||||
|
||||
typedef enum {
|
||||
VG_PIXEL_LAYOUT_UNKNOWN = 0x1300,
|
||||
VG_PIXEL_LAYOUT_RGB_VERTICAL = 0x1301,
|
||||
VG_PIXEL_LAYOUT_BGR_VERTICAL = 0x1302,
|
||||
VG_PIXEL_LAYOUT_RGB_HORIZONTAL = 0x1303,
|
||||
VG_PIXEL_LAYOUT_BGR_HORIZONTAL = 0x1304
|
||||
} VGPixelLayout;
|
||||
|
||||
typedef enum {
|
||||
VG_MATRIX_PATH_USER_TO_SURFACE = 0x1400,
|
||||
VG_MATRIX_IMAGE_USER_TO_SURFACE = 0x1401,
|
||||
VG_MATRIX_FILL_PAINT_TO_USER = 0x1402,
|
||||
VG_MATRIX_STROKE_PAINT_TO_USER = 0x1403
|
||||
} VGMatrixMode;
|
||||
|
||||
typedef enum {
|
||||
VG_CLEAR_MASK = 0x1500,
|
||||
VG_FILL_MASK = 0x1501,
|
||||
VG_SET_MASK = 0x1502,
|
||||
VG_UNION_MASK = 0x1503,
|
||||
VG_INTERSECT_MASK = 0x1504,
|
||||
VG_SUBTRACT_MASK = 0x1505
|
||||
} VGMaskOperation;
|
||||
|
||||
#define VG_PATH_FORMAT_STANDARD 0
|
||||
|
||||
typedef enum {
|
||||
VG_PATH_DATATYPE_S_8 = 0,
|
||||
VG_PATH_DATATYPE_S_16 = 1,
|
||||
VG_PATH_DATATYPE_S_32 = 2,
|
||||
VG_PATH_DATATYPE_F = 3
|
||||
} VGPathDatatype;
|
||||
|
||||
typedef enum {
|
||||
VG_ABSOLUTE = 0,
|
||||
VG_RELATIVE = 1
|
||||
} VGPathAbsRel;
|
||||
|
||||
typedef enum {
|
||||
VG_CLOSE_PATH = ( 0 << 1),
|
||||
VG_MOVE_TO = ( 1 << 1),
|
||||
VG_LINE_TO = ( 2 << 1),
|
||||
VG_HLINE_TO = ( 3 << 1),
|
||||
VG_VLINE_TO = ( 4 << 1),
|
||||
VG_QUAD_TO = ( 5 << 1),
|
||||
VG_CUBIC_TO = ( 6 << 1),
|
||||
VG_SQUAD_TO = ( 7 << 1),
|
||||
VG_SCUBIC_TO = ( 8 << 1),
|
||||
VG_SCCWARC_TO = ( 9 << 1),
|
||||
VG_SCWARC_TO = (10 << 1),
|
||||
VG_LCCWARC_TO = (11 << 1),
|
||||
VG_LCWARC_TO = (12 << 1)
|
||||
} VGPathSegment;
|
||||
|
||||
typedef enum {
|
||||
VG_MOVE_TO_ABS = VG_MOVE_TO | VG_ABSOLUTE,
|
||||
VG_MOVE_TO_REL = VG_MOVE_TO | VG_RELATIVE,
|
||||
VG_LINE_TO_ABS = VG_LINE_TO | VG_ABSOLUTE,
|
||||
VG_LINE_TO_REL = VG_LINE_TO | VG_RELATIVE,
|
||||
VG_HLINE_TO_ABS = VG_HLINE_TO | VG_ABSOLUTE,
|
||||
VG_HLINE_TO_REL = VG_HLINE_TO | VG_RELATIVE,
|
||||
VG_VLINE_TO_ABS = VG_VLINE_TO | VG_ABSOLUTE,
|
||||
VG_VLINE_TO_REL = VG_VLINE_TO | VG_RELATIVE,
|
||||
VG_QUAD_TO_ABS = VG_QUAD_TO | VG_ABSOLUTE,
|
||||
VG_QUAD_TO_REL = VG_QUAD_TO | VG_RELATIVE,
|
||||
VG_CUBIC_TO_ABS = VG_CUBIC_TO | VG_ABSOLUTE,
|
||||
VG_CUBIC_TO_REL = VG_CUBIC_TO | VG_RELATIVE,
|
||||
VG_SQUAD_TO_ABS = VG_SQUAD_TO | VG_ABSOLUTE,
|
||||
VG_SQUAD_TO_REL = VG_SQUAD_TO | VG_RELATIVE,
|
||||
VG_SCUBIC_TO_ABS = VG_SCUBIC_TO | VG_ABSOLUTE,
|
||||
VG_SCUBIC_TO_REL = VG_SCUBIC_TO | VG_RELATIVE,
|
||||
VG_SCCWARC_TO_ABS = VG_SCCWARC_TO | VG_ABSOLUTE,
|
||||
VG_SCCWARC_TO_REL = VG_SCCWARC_TO | VG_RELATIVE,
|
||||
VG_SCWARC_TO_ABS = VG_SCWARC_TO | VG_ABSOLUTE,
|
||||
VG_SCWARC_TO_REL = VG_SCWARC_TO | VG_RELATIVE,
|
||||
VG_LCCWARC_TO_ABS = VG_LCCWARC_TO | VG_ABSOLUTE,
|
||||
VG_LCCWARC_TO_REL = VG_LCCWARC_TO | VG_RELATIVE,
|
||||
VG_LCWARC_TO_ABS = VG_LCWARC_TO | VG_ABSOLUTE,
|
||||
VG_LCWARC_TO_REL = VG_LCWARC_TO | VG_RELATIVE
|
||||
} VGPathCommand;
|
||||
|
||||
typedef VGHandle VGPath;
|
||||
|
||||
typedef enum {
|
||||
VG_PATH_CAPABILITY_APPEND_FROM = (1 << 0),
|
||||
VG_PATH_CAPABILITY_APPEND_TO = (1 << 1),
|
||||
VG_PATH_CAPABILITY_MODIFY = (1 << 2),
|
||||
VG_PATH_CAPABILITY_TRANSFORM_FROM = (1 << 3),
|
||||
VG_PATH_CAPABILITY_TRANSFORM_TO = (1 << 4),
|
||||
VG_PATH_CAPABILITY_INTERPOLATE_FROM = (1 << 5),
|
||||
VG_PATH_CAPABILITY_INTERPOLATE_TO = (1 << 6),
|
||||
VG_PATH_CAPABILITY_PATH_LENGTH = (1 << 7),
|
||||
VG_PATH_CAPABILITY_POINT_ALONG_PATH = (1 << 8),
|
||||
VG_PATH_CAPABILITY_TANGENT_ALONG_PATH = (1 << 9),
|
||||
VG_PATH_CAPABILITY_PATH_BOUNDS = (1 << 10),
|
||||
VG_PATH_CAPABILITY_PATH_TRANSFORMED_BOUNDS = (1 << 11),
|
||||
VG_PATH_CAPABILITY_ALL = (1 << 12) - 1
|
||||
} VGPathCapabilities;
|
||||
|
||||
typedef enum {
|
||||
VG_PATH_FORMAT = 0x1600,
|
||||
VG_PATH_DATATYPE = 0x1601,
|
||||
VG_PATH_SCALE = 0x1602,
|
||||
VG_PATH_BIAS = 0x1603,
|
||||
VG_PATH_NUM_SEGMENTS = 0x1604,
|
||||
VG_PATH_NUM_COORDS = 0x1605
|
||||
} VGPathParamType;
|
||||
|
||||
typedef enum {
|
||||
VG_CAP_BUTT = 0x1700,
|
||||
VG_CAP_ROUND = 0x1701,
|
||||
VG_CAP_SQUARE = 0x1702
|
||||
} VGCapStyle;
|
||||
|
||||
typedef enum {
|
||||
VG_JOIN_MITER = 0x1800,
|
||||
VG_JOIN_ROUND = 0x1801,
|
||||
VG_JOIN_BEVEL = 0x1802
|
||||
} VGJoinStyle;
|
||||
|
||||
typedef enum {
|
||||
VG_EVEN_ODD = 0x1900,
|
||||
VG_NON_ZERO = 0x1901
|
||||
} VGFillRule;
|
||||
|
||||
typedef enum {
|
||||
VG_STROKE_PATH = (1 << 0),
|
||||
VG_FILL_PATH = (1 << 1)
|
||||
} VGPaintMode;
|
||||
|
||||
typedef VGHandle VGPaint;
|
||||
|
||||
typedef enum {
|
||||
/* Color paint parameters */
|
||||
VG_PAINT_TYPE = 0x1A00,
|
||||
VG_PAINT_COLOR = 0x1A01,
|
||||
VG_PAINT_COLOR_RAMP_SPREAD_MODE = 0x1A02,
|
||||
VG_PAINT_COLOR_RAMP_PREMULTIPLIED = 0x1A07,
|
||||
VG_PAINT_COLOR_RAMP_STOPS = 0x1A03,
|
||||
|
||||
/* Linear gradient paint parameters */
|
||||
VG_PAINT_LINEAR_GRADIENT = 0x1A04,
|
||||
|
||||
/* Radial gradient paint parameters */
|
||||
VG_PAINT_RADIAL_GRADIENT = 0x1A05,
|
||||
|
||||
/* Pattern paint parameters */
|
||||
VG_PAINT_PATTERN_TILING_MODE = 0x1A06
|
||||
} VGPaintParamType;
|
||||
|
||||
typedef enum {
|
||||
VG_PAINT_TYPE_COLOR = 0x1B00,
|
||||
VG_PAINT_TYPE_LINEAR_GRADIENT = 0x1B01,
|
||||
VG_PAINT_TYPE_RADIAL_GRADIENT = 0x1B02,
|
||||
VG_PAINT_TYPE_PATTERN = 0x1B03
|
||||
} VGPaintType;
|
||||
|
||||
typedef enum {
|
||||
VG_COLOR_RAMP_SPREAD_PAD = 0x1C00,
|
||||
VG_COLOR_RAMP_SPREAD_REPEAT = 0x1C01,
|
||||
VG_COLOR_RAMP_SPREAD_REFLECT = 0x1C02
|
||||
} VGColorRampSpreadMode;
|
||||
|
||||
typedef enum {
|
||||
VG_TILE_FILL = 0x1D00,
|
||||
VG_TILE_PAD = 0x1D01,
|
||||
VG_TILE_REPEAT = 0x1D02,
|
||||
VG_TILE_REFLECT = 0x1D03
|
||||
} VGTilingMode;
|
||||
|
||||
typedef enum {
|
||||
/* RGB{A,X} channel ordering */
|
||||
VG_sRGBX_8888 = 0,
|
||||
VG_sRGBA_8888 = 1,
|
||||
VG_sRGBA_8888_PRE = 2,
|
||||
VG_sRGB_565 = 3,
|
||||
VG_sRGBA_5551 = 4,
|
||||
VG_sRGBA_4444 = 5,
|
||||
VG_sL_8 = 6,
|
||||
VG_lRGBX_8888 = 7,
|
||||
VG_lRGBA_8888 = 8,
|
||||
VG_lRGBA_8888_PRE = 9,
|
||||
VG_lL_8 = 10,
|
||||
VG_A_8 = 11,
|
||||
VG_BW_1 = 12,
|
||||
|
||||
/* {A,X}RGB channel ordering */
|
||||
VG_sXRGB_8888 = 0 | (1 << 6),
|
||||
VG_sARGB_8888 = 1 | (1 << 6),
|
||||
VG_sARGB_8888_PRE = 2 | (1 << 6),
|
||||
VG_sARGB_1555 = 4 | (1 << 6),
|
||||
VG_sARGB_4444 = 5 | (1 << 6),
|
||||
VG_lXRGB_8888 = 7 | (1 << 6),
|
||||
VG_lARGB_8888 = 8 | (1 << 6),
|
||||
VG_lARGB_8888_PRE = 9 | (1 << 6),
|
||||
|
||||
/* BGR{A,X} channel ordering */
|
||||
VG_sBGRX_8888 = 0 | (1 << 7),
|
||||
VG_sBGRA_8888 = 1 | (1 << 7),
|
||||
VG_sBGRA_8888_PRE = 2 | (1 << 7),
|
||||
VG_sBGR_565 = 3 | (1 << 7),
|
||||
VG_sBGRA_5551 = 4 | (1 << 7),
|
||||
VG_sBGRA_4444 = 5 | (1 << 7),
|
||||
VG_lBGRX_8888 = 7 | (1 << 7),
|
||||
VG_lBGRA_8888 = 8 | (1 << 7),
|
||||
VG_lBGRA_8888_PRE = 9 | (1 << 7),
|
||||
|
||||
/* {A,X}BGR channel ordering */
|
||||
VG_sXBGR_8888 = 0 | (1 << 6) | (1 << 7),
|
||||
VG_sABGR_8888 = 1 | (1 << 6) | (1 << 7),
|
||||
VG_sABGR_8888_PRE = 2 | (1 << 6) | (1 << 7),
|
||||
VG_sABGR_1555 = 4 | (1 << 6) | (1 << 7),
|
||||
VG_sABGR_4444 = 5 | (1 << 6) | (1 << 7),
|
||||
VG_lXBGR_8888 = 7 | (1 << 6) | (1 << 7),
|
||||
VG_lABGR_8888 = 8 | (1 << 6) | (1 << 7),
|
||||
VG_lABGR_8888_PRE = 9 | (1 << 6) | (1 << 7)
|
||||
} VGImageFormat;
|
||||
|
||||
typedef VGHandle VGImage;
|
||||
|
||||
typedef enum {
|
||||
VG_IMAGE_QUALITY_NONANTIALIASED = (1 << 0),
|
||||
VG_IMAGE_QUALITY_FASTER = (1 << 1),
|
||||
VG_IMAGE_QUALITY_BETTER = (1 << 2)
|
||||
} VGImageQuality;
|
||||
|
||||
typedef enum {
|
||||
VG_IMAGE_FORMAT = 0x1E00,
|
||||
VG_IMAGE_WIDTH = 0x1E01,
|
||||
VG_IMAGE_HEIGHT = 0x1E02
|
||||
} VGImageParamType;
|
||||
|
||||
typedef enum {
|
||||
VG_DRAW_IMAGE_NORMAL = 0x1F00,
|
||||
VG_DRAW_IMAGE_MULTIPLY = 0x1F01,
|
||||
VG_DRAW_IMAGE_STENCIL = 0x1F02
|
||||
} VGImageMode;
|
||||
|
||||
typedef enum {
|
||||
VG_RED = (1 << 3),
|
||||
VG_GREEN = (1 << 2),
|
||||
VG_BLUE = (1 << 1),
|
||||
VG_ALPHA = (1 << 0)
|
||||
} VGImageChannel;
|
||||
|
||||
typedef enum {
|
||||
VG_BLEND_SRC = 0x2000,
|
||||
VG_BLEND_SRC_OVER = 0x2001,
|
||||
VG_BLEND_DST_OVER = 0x2002,
|
||||
VG_BLEND_SRC_IN = 0x2003,
|
||||
VG_BLEND_DST_IN = 0x2004,
|
||||
VG_BLEND_MULTIPLY = 0x2005,
|
||||
VG_BLEND_SCREEN = 0x2006,
|
||||
VG_BLEND_DARKEN = 0x2007,
|
||||
VG_BLEND_LIGHTEN = 0x2008,
|
||||
VG_BLEND_ADDITIVE = 0x2009,
|
||||
VG_BLEND_SRC_OUT_SH = 0x200A,
|
||||
VG_BLEND_DST_OUT_SH = 0x200B,
|
||||
VG_BLEND_SRC_ATOP_SH = 0x200C,
|
||||
VG_BLEND_DST_ATOP_SH = 0x200D
|
||||
} VGBlendMode;
|
||||
|
||||
typedef enum {
|
||||
VG_IMAGE_FORMAT_QUERY = 0x2100,
|
||||
VG_PATH_DATATYPE_QUERY = 0x2101
|
||||
} VGHardwareQueryType;
|
||||
|
||||
typedef enum {
|
||||
VG_HARDWARE_ACCELERATED = 0x2200,
|
||||
VG_HARDWARE_UNACCELERATED = 0x2201
|
||||
} VGHardwareQueryResult;
|
||||
|
||||
typedef enum {
|
||||
VG_VENDOR = 0x2300,
|
||||
VG_RENDERER = 0x2301,
|
||||
VG_VERSION = 0x2302,
|
||||
VG_EXTENSIONS = 0x2303
|
||||
} VGStringID;
|
||||
|
||||
/* Function Prototypes */
|
||||
|
||||
#if defined(_WIN32) || defined(__VC32__)
|
||||
# if defined(VG_API_EXPORT)
|
||||
# define VG_API_CALL __declspec(dllexport)
|
||||
# else
|
||||
# define VG_API_CALL __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define VG_API_CALL extern
|
||||
#endif
|
||||
|
||||
#if defined (__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
VG_API_CALL VGErrorCode vgGetError(void);
|
||||
|
||||
VG_API_CALL void vgFlush(void);
|
||||
VG_API_CALL void vgFinish(void);
|
||||
|
||||
/* Getters and Setters */
|
||||
VG_API_CALL void vgSetf (VGParamType type, VGfloat value);
|
||||
VG_API_CALL void vgSeti (VGParamType type, VGint value);
|
||||
VG_API_CALL void vgSetfv(VGParamType type, VGint count,
|
||||
const VGfloat * values);
|
||||
VG_API_CALL void vgSetiv(VGParamType type, VGint count,
|
||||
const VGint * values);
|
||||
|
||||
VG_API_CALL VGfloat vgGetf(VGParamType type);
|
||||
VG_API_CALL VGint vgGeti(VGParamType type);
|
||||
VG_API_CALL VGint vgGetVectorSize(VGParamType type);
|
||||
VG_API_CALL void vgGetfv(VGParamType type, VGint count, VGfloat * values);
|
||||
VG_API_CALL void vgGetiv(VGParamType type, VGint count, VGint * values);
|
||||
|
||||
VG_API_CALL void vgSetParameterf(VGHandle object,
|
||||
VGint paramType,
|
||||
VGfloat value);
|
||||
VG_API_CALL void vgSetParameteri(VGHandle object,
|
||||
VGint paramType,
|
||||
VGint value);
|
||||
VG_API_CALL void vgSetParameterfv(VGHandle object,
|
||||
VGint paramType,
|
||||
VGint count, const VGfloat * values);
|
||||
VG_API_CALL void vgSetParameteriv(VGHandle object,
|
||||
VGint paramType,
|
||||
VGint count, const VGint * values);
|
||||
|
||||
VG_API_CALL VGfloat vgGetParameterf(VGHandle object,
|
||||
VGint paramType);
|
||||
VG_API_CALL VGint vgGetParameteri(VGHandle object,
|
||||
VGint paramType);
|
||||
VG_API_CALL VGint vgGetParameterVectorSize(VGHandle object,
|
||||
VGint paramType);
|
||||
VG_API_CALL void vgGetParameterfv(VGHandle object,
|
||||
VGint paramType,
|
||||
VGint count, VGfloat * values);
|
||||
VG_API_CALL void vgGetParameteriv(VGHandle object,
|
||||
VGint paramType,
|
||||
VGint count, VGint * values);
|
||||
|
||||
/* Matrix Manipulation */
|
||||
VG_API_CALL void vgLoadIdentity(void);
|
||||
VG_API_CALL void vgLoadMatrix(const VGfloat * m);
|
||||
VG_API_CALL void vgGetMatrix(VGfloat * m);
|
||||
VG_API_CALL void vgMultMatrix(const VGfloat * m);
|
||||
VG_API_CALL void vgTranslate(VGfloat tx, VGfloat ty);
|
||||
VG_API_CALL void vgScale(VGfloat sx, VGfloat sy);
|
||||
VG_API_CALL void vgShear(VGfloat shx, VGfloat shy);
|
||||
VG_API_CALL void vgRotate(VGfloat angle);
|
||||
|
||||
/* Masking and Clearing */
|
||||
VG_API_CALL void vgMask(VGImage mask, VGMaskOperation operation,
|
||||
VGint x, VGint y, VGint width, VGint height);
|
||||
VG_API_CALL void vgClear(VGint x, VGint y, VGint width, VGint height);
|
||||
|
||||
/* Paths */
|
||||
VG_API_CALL VGPath vgCreatePath(VGint pathFormat,
|
||||
VGPathDatatype datatype,
|
||||
VGfloat scale, VGfloat bias,
|
||||
VGint segmentCapacityHint,
|
||||
VGint coordCapacityHint,
|
||||
VGbitfield capabilities);
|
||||
VG_API_CALL void vgClearPath(VGPath path, VGbitfield capabilities);
|
||||
VG_API_CALL void vgDestroyPath(VGPath path);
|
||||
VG_API_CALL void vgRemovePathCapabilities(VGPath path,
|
||||
VGbitfield capabilities);
|
||||
VG_API_CALL VGbitfield vgGetPathCapabilities(VGPath path);
|
||||
VG_API_CALL void vgAppendPath(VGPath dstPath, VGPath srcPath);
|
||||
VG_API_CALL void vgAppendPathData(VGPath dstPath,
|
||||
VGint numSegments,
|
||||
const VGubyte * pathSegments,
|
||||
const void * pathData);
|
||||
VG_API_CALL void vgModifyPathCoords(VGPath dstPath, VGint startIndex,
|
||||
VGint numSegments,
|
||||
const void * pathData);
|
||||
VG_API_CALL void vgTransformPath(VGPath dstPath, VGPath srcPath);
|
||||
VG_API_CALL VGboolean vgInterpolatePath(VGPath dstPath,
|
||||
VGPath startPath,
|
||||
VGPath endPath,
|
||||
VGfloat amount);
|
||||
VG_API_CALL VGfloat vgPathLength(VGPath path,
|
||||
VGint startSegment, VGint numSegments);
|
||||
VG_API_CALL void vgPointAlongPath(VGPath path,
|
||||
VGint startSegment, VGint numSegments,
|
||||
VGfloat distance,
|
||||
VGfloat * x, VGfloat * y,
|
||||
VGfloat * tangentX, VGfloat * tangentY);
|
||||
VG_API_CALL void vgPathBounds(VGPath path,
|
||||
VGfloat * minX, VGfloat * minY,
|
||||
VGfloat * width, VGfloat * height);
|
||||
VG_API_CALL void vgPathTransformedBounds(VGPath path,
|
||||
VGfloat * minX, VGfloat * minY,
|
||||
VGfloat * width, VGfloat * height);
|
||||
VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes);
|
||||
|
||||
/* Paint */
|
||||
VG_API_CALL VGPaint vgCreatePaint(void);
|
||||
VG_API_CALL void vgDestroyPaint(VGPaint paint);
|
||||
VG_API_CALL void vgSetPaint(VGPaint paint, VGbitfield paintModes);
|
||||
VG_API_CALL VGPaint vgGetPaint(VGPaintMode paintMode);
|
||||
VG_API_CALL void vgSetColor(VGPaint paint, VGuint rgba);
|
||||
VG_API_CALL VGuint vgGetColor(VGPaint paint);
|
||||
VG_API_CALL void vgPaintPattern(VGPaint paint, VGImage pattern);
|
||||
|
||||
/* Images */
|
||||
VG_API_CALL VGImage vgCreateImage(VGImageFormat format,
|
||||
VGint width, VGint height,
|
||||
VGbitfield allowedQuality);
|
||||
VG_API_CALL void vgDestroyImage(VGImage image);
|
||||
VG_API_CALL void vgClearImage(VGImage image,
|
||||
VGint x, VGint y, VGint width, VGint height);
|
||||
VG_API_CALL void vgImageSubData(VGImage image,
|
||||
const void * data, VGint dataStride,
|
||||
VGImageFormat dataFormat,
|
||||
VGint x, VGint y, VGint width, VGint height);
|
||||
VG_API_CALL void vgGetImageSubData(VGImage image,
|
||||
void * data, VGint dataStride,
|
||||
VGImageFormat dataFormat,
|
||||
VGint x, VGint y,
|
||||
VGint width, VGint height);
|
||||
VG_API_CALL VGImage vgChildImage(VGImage parent,
|
||||
VGint x, VGint y, VGint width, VGint height);
|
||||
VG_API_CALL VGImage vgGetParent(VGImage image);
|
||||
VG_API_CALL void vgCopyImage(VGImage dst, VGint dx, VGint dy,
|
||||
VGImage src, VGint sx, VGint sy,
|
||||
VGint width, VGint height,
|
||||
VGboolean dither);
|
||||
VG_API_CALL void vgDrawImage(VGImage image);
|
||||
VG_API_CALL void vgSetPixels(VGint dx, VGint dy,
|
||||
VGImage src, VGint sx, VGint sy,
|
||||
VGint width, VGint height);
|
||||
VG_API_CALL void vgWritePixels(const void * data, VGint dataStride,
|
||||
VGImageFormat dataFormat,
|
||||
VGint dx, VGint dy,
|
||||
VGint width, VGint height);
|
||||
VG_API_CALL void vgGetPixels(VGImage dst, VGint dx, VGint dy,
|
||||
VGint sx, VGint sy,
|
||||
VGint width, VGint height);
|
||||
VG_API_CALL void vgReadPixels(void * data, VGint dataStride,
|
||||
VGImageFormat dataFormat,
|
||||
VGint sx, VGint sy,
|
||||
VGint width, VGint height);
|
||||
VG_API_CALL void vgCopyPixels(VGint dx, VGint dy,
|
||||
VGint sx, VGint sy,
|
||||
VGint width, VGint height);
|
||||
|
||||
/* Image Filters */
|
||||
VG_API_CALL void vgColorMatrix(VGImage dst, VGImage src,
|
||||
const VGfloat * matrix);
|
||||
VG_API_CALL void vgConvolve(VGImage dst, VGImage src,
|
||||
VGint kernelWidth, VGint kernelHeight,
|
||||
VGint shiftX, VGint shiftY,
|
||||
const VGshort * kernel,
|
||||
VGfloat scale,
|
||||
VGfloat bias,
|
||||
VGTilingMode tilingMode);
|
||||
VG_API_CALL void vgSeparableConvolve(VGImage dst, VGImage src,
|
||||
VGint kernelWidth,
|
||||
VGint kernelHeight,
|
||||
VGint shiftX, VGint shiftY,
|
||||
const VGshort * kernelX,
|
||||
const VGshort * kernelY,
|
||||
VGfloat scale,
|
||||
VGfloat bias,
|
||||
VGTilingMode tilingMode);
|
||||
VG_API_CALL void vgGaussianBlur(VGImage dst, VGImage src,
|
||||
VGfloat stdDeviationX,
|
||||
VGfloat stdDeviationY,
|
||||
VGTilingMode tilingMode);
|
||||
VG_API_CALL void vgLookup(VGImage dst, VGImage src,
|
||||
const VGubyte * redLUT,
|
||||
const VGubyte * greenLUT,
|
||||
const VGubyte * blueLUT,
|
||||
const VGubyte * alphaLUT,
|
||||
VGboolean outputLinear,
|
||||
VGboolean outputPremultiplied);
|
||||
VG_API_CALL void vgLookupSingle(VGImage dst, VGImage src,
|
||||
const VGuint * lookupTable,
|
||||
VGImageChannel sourceChannel,
|
||||
VGboolean outputLinear,
|
||||
VGboolean outputPremultiplied);
|
||||
|
||||
/* Hardware Queries */
|
||||
VG_API_CALL VGHardwareQueryResult vgHardwareQuery(VGHardwareQueryType key,
|
||||
VGint setting);
|
||||
|
||||
/* Renderer and Extension Information */
|
||||
VG_API_CALL const VGubyte * vgGetString(VGStringID name);
|
||||
|
||||
/* Extensions */
|
||||
|
||||
#define OVG_SH_blend_src_out 1
|
||||
#define OVG_SH_blend_dst_out 1
|
||||
#define OVG_SH_blend_src_atop 1
|
||||
#define OVG_SH_blend_dst_atop 1
|
||||
|
||||
VG_API_CALL VGboolean vgCreateContextSH(VGint width, VGint height);
|
||||
VG_API_CALL void vgResizeSurfaceSH(VGint width, VGint height);
|
||||
VG_API_CALL void vgDestroyContextSH(void);
|
||||
|
||||
|
||||
#if defined (__cplusplus)
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
#endif /* _OPENVG_H */
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef _VGU_H
|
||||
#define _VGU_H
|
||||
|
||||
#include "openvg.h"
|
||||
|
||||
#define VGU_VERSION_1_0 1
|
||||
#define VGU_VERSION_1_0_1 1
|
||||
|
||||
#ifndef VGU_API_CALL
|
||||
#define VGU_API_CALL VG_API_CALL
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
VGU_NO_ERROR = 0,
|
||||
VGU_BAD_HANDLE_ERROR = 0xF000,
|
||||
VGU_ILLEGAL_ARGUMENT_ERROR = 0xF001,
|
||||
VGU_OUT_OF_MEMORY_ERROR = 0xF002,
|
||||
VGU_PATH_CAPABILITY_ERROR = 0xF003,
|
||||
VGU_BAD_WARP_ERROR = 0xF004
|
||||
} VGUErrorCode;
|
||||
|
||||
typedef enum {
|
||||
VGU_ARC_OPEN = 0xF100,
|
||||
VGU_ARC_CHORD = 0xF101,
|
||||
VGU_ARC_PIE = 0xF102
|
||||
} VGUArcType;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguLine(VGPath path,
|
||||
VGfloat x0, VGfloat y0,
|
||||
VGfloat x1, VGfloat y1);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguPolygon(VGPath path,
|
||||
const VGfloat * points, VGint count,
|
||||
VGboolean closed);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguRect(VGPath path,
|
||||
VGfloat x, VGfloat y,
|
||||
VGfloat width, VGfloat height);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguRoundRect(VGPath path,
|
||||
VGfloat x, VGfloat y,
|
||||
VGfloat width, VGfloat height,
|
||||
VGfloat arcWidth, VGfloat arcHeight);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguEllipse(VGPath path,
|
||||
VGfloat cx, VGfloat cy,
|
||||
VGfloat width, VGfloat height);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguArc(VGPath path,
|
||||
VGfloat x, VGfloat y,
|
||||
VGfloat width, VGfloat height,
|
||||
VGfloat startAngle, VGfloat angleExtent,
|
||||
VGUArcType arcType);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
|
||||
VGfloat sx1, VGfloat sy1,
|
||||
VGfloat sx2, VGfloat sy2,
|
||||
VGfloat sx3, VGfloat sy3,
|
||||
VGfloat * matrix);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
|
||||
VGfloat dx1, VGfloat dy1,
|
||||
VGfloat dx2, VGfloat dy2,
|
||||
VGfloat dx3, VGfloat dy3,
|
||||
VGfloat * matrix);
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
|
||||
VGfloat dx1, VGfloat dy1,
|
||||
VGfloat dx2, VGfloat dy2,
|
||||
VGfloat dx3, VGfloat dy3,
|
||||
VGfloat sx0, VGfloat sy0,
|
||||
VGfloat sx1, VGfloat sy1,
|
||||
VGfloat sx2, VGfloat sy2,
|
||||
VGfloat sx3, VGfloat sy3,
|
||||
VGfloat * matrix);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* #ifndef _VGU_H */
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
include(CheckIncludeFile)
|
||||
check_include_file("inttypes.h" HAVE_INTTYPES_H)
|
||||
|
||||
if(HAVE_INTTYPES_H)
|
||||
add_definitions(-DHAVE_INTTYPES_H)
|
||||
endif()
|
||||
add_definitions(-DVG_API_EXPORT)
|
||||
|
||||
INCLUDE_DIRECTORIES(
|
||||
${OPENGL_INCLUDE_DIR}
|
||||
../include
|
||||
)
|
||||
|
||||
SET(INCROOT ../include/VG)
|
||||
SET(SRCROOT .)
|
||||
|
||||
SET(ShivaVG_Src
|
||||
${SRCROOT}/shArrays.c
|
||||
${SRCROOT}/shArrays.h
|
||||
${SRCROOT}/shContext.c
|
||||
${SRCROOT}/shContext.h
|
||||
${SRCROOT}/shExtensions.c
|
||||
${SRCROOT}/shExtensions.h
|
||||
${SRCROOT}/shGeometry.c
|
||||
${SRCROOT}/shGeometry.h
|
||||
${SRCROOT}/shImage.c
|
||||
${SRCROOT}/shImage.h
|
||||
${SRCROOT}/shPaint.c
|
||||
${SRCROOT}/shPaint.h
|
||||
${SRCROOT}/shParams.c
|
||||
${SRCROOT}/shPath.c
|
||||
${SRCROOT}/shPath.h
|
||||
${SRCROOT}/shPipeline.c
|
||||
${SRCROOT}/shVectors.c
|
||||
${SRCROOT}/shVectors.h
|
||||
${SRCROOT}/shVgu.c
|
||||
)
|
||||
|
||||
ADD_LIBRARY(
|
||||
ShivaVG
|
||||
${ShivaVG_Src}
|
||||
)
|
||||
|
||||
TARGET_LINK_LIBRARIES(
|
||||
ShivaVG
|
||||
${OPENGL_gl_LIBRARY}
|
||||
${OPENGL_glu_LIBRARY}
|
||||
)
|
||||
|
|
@ -1,370 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
/*------------------------------------------------------------
|
||||
* The base for any type of array. According to appropriate
|
||||
* macro definitions, specific array types will be generated
|
||||
* and their manipulation functions respectively.
|
||||
*
|
||||
* This code assumes the following are defined:
|
||||
* _ITEM_T: the type of the items in the array
|
||||
* _ARRAY_T: the name of the structure
|
||||
* _FUNC_T: the prefix to prepend to each function
|
||||
*
|
||||
* And at least one of these:
|
||||
* _ARRAY_DECLARE: generate structure declaration
|
||||
* _ARRAY_DEFINE: generate function definitions
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
#ifndef __SHARRAYBASE_H
|
||||
#define __SHARRAYBASE_H
|
||||
|
||||
#include "shDefs.h"
|
||||
|
||||
#define VAL(x,y) x ## y
|
||||
#define JN(x,y) VAL(x,y)
|
||||
|
||||
#endif
|
||||
|
||||
/*--------------------------------------------
|
||||
* The rest is not #ifndef protected to allow
|
||||
* for various array type definitions.
|
||||
*--------------------------------------------*/
|
||||
|
||||
|
||||
#ifdef _ARRAY_DECLARE
|
||||
typedef struct
|
||||
{
|
||||
_ITEM_T *items;
|
||||
SHint32 capacity;
|
||||
SHint32 size;
|
||||
SHint outofmemory;
|
||||
|
||||
} _ARRAY_T;
|
||||
#endif
|
||||
|
||||
|
||||
void JN(_ARRAY_T,_ctor) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
a->items = (_ITEM_T*)malloc(sizeof(_ITEM_T));
|
||||
|
||||
if (!a->items) {
|
||||
a->outofmemory = 1;
|
||||
a->capacity = 0;
|
||||
a->size = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
a->outofmemory = 0;
|
||||
a->capacity = 1;
|
||||
a->size = 0;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
void JN(_ARRAY_T,_dtor) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
if (a->items) {
|
||||
free(a->items);
|
||||
a->items = NULL;
|
||||
}
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
void JN(_FUNC_T,Clear) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
a->size = 0;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
/*--------------------------------------------------------
|
||||
* Set the capacity of the array. In case of reallocation
|
||||
* the items are not preserved.
|
||||
*--------------------------------------------------------*/
|
||||
|
||||
int JN(_FUNC_T,Realloc) (_ARRAY_T *a, SHint newsize)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
_ITEM_T *newitems = 0;
|
||||
|
||||
SH_ASSERT(newsize > 0);
|
||||
if (newsize == a->capacity)
|
||||
return 1;
|
||||
|
||||
newitems = (_ITEM_T*)malloc(newsize * sizeof(_ITEM_T));
|
||||
|
||||
if (!newitems) {
|
||||
a->outofmemory = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (a->items)
|
||||
free(a->items);
|
||||
|
||||
a->outofmemory = 0;
|
||||
a->items = newitems;
|
||||
a->capacity = newsize;
|
||||
a->size = 0;
|
||||
return 1;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
/*------------------------------------------------------
|
||||
* Asserts the capacity is at least [newsize]. In case
|
||||
* of reallocation items are not preserved.
|
||||
*------------------------------------------------------*/
|
||||
|
||||
int JN(_FUNC_T,Reserve) (_ARRAY_T *a, SHint newsize)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
_ITEM_T *newitems = 0;
|
||||
|
||||
SH_ASSERT(newsize >= 0);
|
||||
if (newsize <= a->capacity)
|
||||
return 1;
|
||||
|
||||
newitems = (_ITEM_T*)malloc(newsize * sizeof(_ITEM_T));
|
||||
|
||||
if (!newitems) {
|
||||
a->outofmemory = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (a->items)
|
||||
free(a->items);
|
||||
|
||||
a->outofmemory = 0;
|
||||
a->items = newitems;
|
||||
a->capacity = newsize;
|
||||
a->size = 0;
|
||||
return 1;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
/*------------------------------------------------------
|
||||
* Asserts the capacity is at least [newsize]. In case
|
||||
* of reallocation items are copied.
|
||||
*------------------------------------------------------*/
|
||||
|
||||
int JN(_FUNC_T,ReserveAndCopy) (_ARRAY_T *a, SHint newsize)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
_ITEM_T *newitems = 0;
|
||||
|
||||
SH_ASSERT(newsize >= 0);
|
||||
if (newsize <= a->capacity)
|
||||
return 1;
|
||||
|
||||
newitems = (_ITEM_T*)realloc(a->items, newsize * sizeof(_ITEM_T));
|
||||
|
||||
if (!newitems) {
|
||||
a->outofmemory = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
a->outofmemory = 0;
|
||||
a->items = newitems;
|
||||
a->capacity = newsize;
|
||||
return 1;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
int JN(_FUNC_T,PushBack) (_ARRAY_T *a, _ITEM_T item)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
if (a->capacity == 0) {
|
||||
JN(_FUNC_T,Realloc)(a, 1);
|
||||
if (a->outofmemory)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (a->size + 1 > a->capacity)
|
||||
JN(_FUNC_T,ReserveAndCopy)(a, a->capacity*2);
|
||||
|
||||
if (a->outofmemory)
|
||||
return 0;
|
||||
|
||||
a->items[a->size++] = item;
|
||||
return 1;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
int JN(_FUNC_T,PushBackP) (_ARRAY_T *a, _ITEM_T *item)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
if (a->capacity == 0) {
|
||||
JN(_FUNC_T,Realloc)(a, 1);
|
||||
if (a->outofmemory)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (a->size + 1 > a->capacity)
|
||||
JN(_FUNC_T,ReserveAndCopy)(a, a->capacity*2);
|
||||
|
||||
if (a->outofmemory)
|
||||
return 0;
|
||||
|
||||
a->items[a->size++] = *item;
|
||||
return 1;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
void JN(_FUNC_T,PopBack) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(a->size);
|
||||
--a->size;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
_ITEM_T JN(_FUNC_T,Front) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(a->size);
|
||||
return a->items[0];
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
_ITEM_T* JN(_FUNC_T,FrontP) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(a->size);
|
||||
return &a->items[0];
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
_ITEM_T JN(_FUNC_T,Back) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(a->size);
|
||||
return a->items[a->size - 1];
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
_ITEM_T* JN(_FUNC_T,BackP) (_ARRAY_T *a)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(a->size);
|
||||
return &a->items[a->size - 1];
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
_ITEM_T JN(_FUNC_T,At) (_ARRAY_T *a, SHint index)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(index >= 0);
|
||||
SH_ASSERT(index < a->size);
|
||||
return a->items[index];
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
|
||||
_ITEM_T* JN(_FUNC_T,AtP) (_ARRAY_T *a, SHint index)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
SH_ASSERT(index >= 0);
|
||||
SH_ASSERT(index < a->size);
|
||||
return &a->items[index];
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
SHint JN(_FUNC_T,Find) (_ARRAY_T *a, _ITEM_T item)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<a->size; ++i) {
|
||||
#ifdef _COMPARE_T
|
||||
if (_COMPARE_T(a->items[i], item))
|
||||
return i;
|
||||
#else
|
||||
if (a->items[i] == item)
|
||||
return i;
|
||||
#endif
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
void JN(_FUNC_T,RemoveAt) (_ARRAY_T *a, SHint index)
|
||||
#ifdef _ARRAY_DEFINE
|
||||
{
|
||||
int i;
|
||||
SH_ASSERT(index >= 0);
|
||||
SH_ASSERT(index < a->size);
|
||||
for (i=index; i<a->size-1; ++i)
|
||||
a->items[i] = a->items[i+1];
|
||||
a->size--;
|
||||
}
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
|
||||
#undef _ITEM_T
|
||||
#undef _ARRAY_T
|
||||
#undef _FUNC_T
|
||||
#undef _COMPARE_T
|
||||
#undef _ARRAY_DEFINE
|
||||
#undef _ARRAY_DECLARE
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
/*--------------------------------------------
|
||||
* Definitions of all the arrays used
|
||||
*--------------------------------------------*/
|
||||
|
||||
#include "shArrays.h"
|
||||
|
||||
#define _ITEM_T SHint
|
||||
#define _ARRAY_T SHIntArray
|
||||
#define _FUNC_T shIntArray
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHuint8
|
||||
#define _ARRAY_T SHUint8Array
|
||||
#define _FUNC_T shUint8Array
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHfloat
|
||||
#define _ARRAY_T SHFloatArray
|
||||
#define _FUNC_T shFloatArray
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHRectangle
|
||||
#define _ARRAY_T SHRectArray
|
||||
#define _FUNC_T shRectArray
|
||||
#define _COMPARE_T(x,y) 1
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
/*--------------------------------------------
|
||||
* Declarations of all the arrays used
|
||||
*--------------------------------------------*/
|
||||
|
||||
#ifndef __SHARRAYS_H
|
||||
#define __SHARRAYS_H
|
||||
|
||||
#include "shVectors.h"
|
||||
|
||||
|
||||
#define _ITEM_T SHint
|
||||
#define _ARRAY_T SHIntArray
|
||||
#define _FUNC_T shIntArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHuint8
|
||||
#define _ARRAY_T SHUint8Array
|
||||
#define _FUNC_T shUint8Array
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHfloat
|
||||
#define _ARRAY_T SHFloatArray
|
||||
#define _FUNC_T shFloatArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHRectangle
|
||||
#define _ARRAY_T SHRectArray
|
||||
#define _FUNC_T shRectArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#endif
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
|
||||
#ifndef __SHCONFIG_H
|
||||
#define __SHCONFIG_H
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
// Identify the operating system
|
||||
////////////////////////////////////////////////////////////
|
||||
#if defined(_WIN32) || defined(__WIN32__)
|
||||
|
||||
// Windows
|
||||
#define VG_API_WINDOWS
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
|
||||
#elif defined(linux) || defined(__linux)
|
||||
|
||||
// Linux
|
||||
#define VG_API_LINUX
|
||||
|
||||
#elif defined(__APPLE__) || defined(MACOSX) || defined(macintosh) || defined(Macintosh)
|
||||
|
||||
// MacOS
|
||||
#define VG_API_MACOSX
|
||||
|
||||
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
|
||||
|
||||
// FreeBSD
|
||||
#define VG_API_FREEBSD
|
||||
|
||||
#else
|
||||
|
||||
// Unsupported system
|
||||
#error This operating system is not supported by SFML library
|
||||
|
||||
#endif
|
||||
|
||||
#endif // __SHCONFIG_H
|
||||
|
|
@ -1,493 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <vg/openvg.h>
|
||||
#include "shContext.h"
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*-----------------------------------------------------
|
||||
* Simple functions to create a VG context instance
|
||||
* on top of an existing OpenGL context.
|
||||
* TODO: There is no mechanics yet to asure the OpenGL
|
||||
* context exists and to choose which context / window
|
||||
* to bind to.
|
||||
*-----------------------------------------------------*/
|
||||
|
||||
static VGContext *g_context = NULL;
|
||||
|
||||
VG_API_CALL VGboolean vgCreateContextSH(VGint width, VGint height)
|
||||
{
|
||||
/* return if already created */
|
||||
if (g_context) return VG_TRUE;
|
||||
|
||||
/* create new context */
|
||||
SH_NEWOBJ(VGContext, g_context);
|
||||
if (!g_context) return VG_FALSE;
|
||||
|
||||
/* init surface info */
|
||||
g_context->surfaceWidth = width;
|
||||
g_context->surfaceHeight = height;
|
||||
|
||||
/* setup GL projection */
|
||||
glViewport(0,0,width,height);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
gluOrtho2D(0,width,0,height);
|
||||
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
|
||||
return VG_TRUE;
|
||||
}
|
||||
|
||||
VG_API_CALL void vgResizeSurfaceSH(VGint width, VGint height)
|
||||
{
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
/* update surface info */
|
||||
context->surfaceWidth = width;
|
||||
context->surfaceHeight = height;
|
||||
|
||||
/* setup GL projection */
|
||||
glViewport(0,0,width,height);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
gluOrtho2D(0,width,0,height);
|
||||
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgDestroyContextSH()
|
||||
{
|
||||
/* return if already released */
|
||||
if (!g_context) return;
|
||||
|
||||
/* delete context object */
|
||||
SH_DELETEOBJ(VGContext, g_context);
|
||||
g_context = NULL;
|
||||
}
|
||||
|
||||
VGContext* shGetContext()
|
||||
{
|
||||
SH_ASSERT(g_context);
|
||||
return g_context;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------
|
||||
* VGContext constructor
|
||||
*-----------------------------------------------------*/
|
||||
|
||||
void shLoadExtensions(VGContext *c);
|
||||
|
||||
void VGContext_ctor(VGContext *c)
|
||||
{
|
||||
/* Surface info */
|
||||
c->surfaceWidth = 0;
|
||||
c->surfaceHeight = 0;
|
||||
|
||||
/* GetString info */
|
||||
strncpy(c->vendor, "Ivan Leben", sizeof(c->vendor));
|
||||
strncpy(c->renderer, "ShivaVG 0.1.0", sizeof(c->renderer));
|
||||
strncpy(c->version, "1.0", sizeof(c->version));
|
||||
strncpy(c->extensions, "", sizeof(c->extensions));
|
||||
|
||||
/* Mode settings */
|
||||
c->matrixMode = VG_MATRIX_PATH_USER_TO_SURFACE;
|
||||
c->fillRule = VG_EVEN_ODD;
|
||||
c->imageQuality = VG_IMAGE_QUALITY_FASTER;
|
||||
c->renderingQuality = VG_RENDERING_QUALITY_BETTER;
|
||||
c->blendMode = VG_BLEND_SRC_OVER;
|
||||
c->imageMode = VG_DRAW_IMAGE_NORMAL;
|
||||
|
||||
/* Scissor rectangles */
|
||||
SH_INITOBJ(SHRectArray, c->scissor);
|
||||
c->scissoring = VG_FALSE;
|
||||
c->masking = VG_FALSE;
|
||||
|
||||
/* Stroke parameters */
|
||||
c->strokeLineWidth = 1.0f;
|
||||
c->strokeCapStyle = VG_CAP_BUTT;
|
||||
c->strokeJoinStyle = VG_JOIN_MITER;
|
||||
c->strokeMiterLimit = 4.0f;
|
||||
c->strokeDashPhase = 0.0f;
|
||||
c->strokeDashPhaseReset = VG_FALSE;
|
||||
SH_INITOBJ(SHFloatArray, c->strokeDashPattern);
|
||||
|
||||
/* Edge fill color for vgConvolve and pattern paint */
|
||||
CSET(c->tileFillColor, 0,0,0,0);
|
||||
|
||||
/* Color for vgClear */
|
||||
CSET(c->clearColor, 0,0,0,0);
|
||||
|
||||
/* Color components layout inside pixel */
|
||||
c->pixelLayout = VG_PIXEL_LAYOUT_UNKNOWN;
|
||||
|
||||
/* Source format for image filters */
|
||||
c->filterFormatLinear = VG_FALSE;
|
||||
c->filterFormatPremultiplied = VG_FALSE;
|
||||
c->filterChannelMask = VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA;
|
||||
|
||||
/* Matrices */
|
||||
SH_INITOBJ(SHMatrix3x3, c->pathTransform);
|
||||
SH_INITOBJ(SHMatrix3x3, c->imageTransform);
|
||||
SH_INITOBJ(SHMatrix3x3, c->fillTransform);
|
||||
SH_INITOBJ(SHMatrix3x3, c->strokeTransform);
|
||||
|
||||
/* Paints */
|
||||
c->fillPaint = NULL;
|
||||
c->strokePaint = NULL;
|
||||
SH_INITOBJ(SHPaint, c->defaultPaint);
|
||||
|
||||
/* Error */
|
||||
c->error = VG_NO_ERROR;
|
||||
|
||||
/* Resources */
|
||||
SH_INITOBJ(SHPathArray, c->paths);
|
||||
SH_INITOBJ(SHPaintArray, c->paints);
|
||||
SH_INITOBJ(SHImageArray, c->images);
|
||||
|
||||
shLoadExtensions(c);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------
|
||||
* VGContext constructor
|
||||
*-----------------------------------------------------*/
|
||||
|
||||
void VGContext_dtor(VGContext *c)
|
||||
{
|
||||
int i;
|
||||
|
||||
SH_DEINITOBJ(SHRectArray, c->scissor);
|
||||
SH_DEINITOBJ(SHFloatArray, c->strokeDashPattern);
|
||||
|
||||
/* Destroy resources */
|
||||
for (i=0; i<c->paths.size; ++i)
|
||||
SH_DELETEOBJ(SHPath, c->paths.items[i]);
|
||||
|
||||
for (i=0; i<c->paints.size; ++i)
|
||||
SH_DELETEOBJ(SHPaint, c->paints.items[i]);
|
||||
|
||||
for (i=0; i<c->images.size; ++i)
|
||||
SH_DELETEOBJ(SHImage, c->images.items[i]);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------
|
||||
* Tries to find resources in this context
|
||||
*--------------------------------------------------*/
|
||||
|
||||
SHint shIsValidPath(VGContext *c, VGHandle h)
|
||||
{
|
||||
int index = shPathArrayFind(&c->paths, (SHPath*)h);
|
||||
return (index == -1) ? 0 : 1;
|
||||
}
|
||||
|
||||
SHint shIsValidPaint(VGContext *c, VGHandle h)
|
||||
{
|
||||
int index = shPaintArrayFind(&c->paints, (SHPaint*)h);
|
||||
return (index == -1) ? 0 : 1;
|
||||
}
|
||||
|
||||
SHint shIsValidImage(VGContext *c, VGHandle h)
|
||||
{
|
||||
int index = shImageArrayFind(&c->images, (SHImage*)h);
|
||||
return (index == -1) ? 0 : 1;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------
|
||||
* Tries to find a resources in this context and
|
||||
* return its type or invalid flag.
|
||||
*--------------------------------------------------*/
|
||||
|
||||
SHResourceType shGetResourceType(VGContext *c, VGHandle h)
|
||||
{
|
||||
if (shIsValidPath(c, h))
|
||||
return SH_RESOURCE_PATH;
|
||||
|
||||
else if (shIsValidPaint(c, h))
|
||||
return SH_RESOURCE_PAINT;
|
||||
|
||||
else if (shIsValidImage(c, h))
|
||||
return SH_RESOURCE_IMAGE;
|
||||
|
||||
else
|
||||
return SH_RESOURCE_INVALID;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------
|
||||
* Sets the specified error on the given context if
|
||||
* there is no pending error yet
|
||||
*-----------------------------------------------------*/
|
||||
|
||||
void shSetError(VGContext *c, VGErrorCode e)
|
||||
{
|
||||
if (c->error == VG_NO_ERROR)
|
||||
c->error = e;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------
|
||||
* Returns the oldest error pending on the current
|
||||
* context and clears its error code
|
||||
*--------------------------------------------------*/
|
||||
|
||||
VG_API_CALL VGErrorCode vgGetError(void)
|
||||
{
|
||||
VGErrorCode error;
|
||||
VG_GETCONTEXT(VG_NO_CONTEXT_ERROR);
|
||||
error = context->error;
|
||||
context->error = VG_NO_ERROR;
|
||||
VG_RETURN(error);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgFlush(void)
|
||||
{
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
glFlush();
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgFinish(void)
|
||||
{
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
glFinish();
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgMask(VGImage mask, VGMaskOperation operation,
|
||||
VGint x, VGint y, VGint width, VGint height)
|
||||
{
|
||||
}
|
||||
|
||||
VG_API_CALL void vgClear(VGint x, VGint y, VGint width, VGint height)
|
||||
{
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
/* Clip to window */
|
||||
if (x < 0) x = 0;
|
||||
if (y < 0) y = 0;
|
||||
if (width > context->surfaceWidth) width = context->surfaceWidth;
|
||||
if (height > context->surfaceHeight) height = context->surfaceHeight;
|
||||
|
||||
/* Check if scissoring needed */
|
||||
if (x > 0 || y > 0 ||
|
||||
width < context->surfaceWidth ||
|
||||
height < context->surfaceHeight) {
|
||||
|
||||
glScissor(x, y, width, height);
|
||||
glEnable(GL_SCISSOR_TEST);
|
||||
}
|
||||
|
||||
/* Clear GL color buffer */
|
||||
/* TODO: what about stencil and depth? when do we clear that?
|
||||
we would need some kind of special "begin" function at
|
||||
beginning of each drawing or clear the planes prior to each
|
||||
drawing where it takes places */
|
||||
glClearColor(context->clearColor.r,
|
||||
context->clearColor.g,
|
||||
context->clearColor.b,
|
||||
context->clearColor.a);
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT |
|
||||
GL_STENCIL_BUFFER_BIT |
|
||||
GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
glDisable(GL_SCISSOR_TEST);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Returns the matrix currently selected via VG_MATRIX_MODE
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
SHMatrix3x3* shCurrentMatrix(VGContext *c)
|
||||
{
|
||||
switch(c->matrixMode) {
|
||||
case VG_MATRIX_PATH_USER_TO_SURFACE:
|
||||
return &c->pathTransform;
|
||||
case VG_MATRIX_IMAGE_USER_TO_SURFACE:
|
||||
return &c->imageTransform;
|
||||
case VG_MATRIX_FILL_PAINT_TO_USER:
|
||||
return &c->fillTransform;
|
||||
default:
|
||||
return &c->strokeTransform;
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------
|
||||
* Sets the current matrix to identity
|
||||
*--------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgLoadIdentity(void)
|
||||
{
|
||||
SHMatrix3x3 *m;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
IDMAT((*m));
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------
|
||||
* Loads values into the current matrix from the given array.
|
||||
* Matrix affinity is preserved if an affine matrix is loaded.
|
||||
*-------------------------------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgLoadMatrix(const VGfloat * mm)
|
||||
{
|
||||
SHMatrix3x3 *m;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!mm, VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
/* TODO: check matrix array alignment */
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
|
||||
if (context->matrixMode == VG_MATRIX_IMAGE_USER_TO_SURFACE) {
|
||||
|
||||
SETMAT((*m),
|
||||
mm[0], mm[3], mm[6],
|
||||
mm[1], mm[4], mm[7],
|
||||
mm[2], mm[5], mm[8]);
|
||||
}else{
|
||||
|
||||
SETMAT((*m),
|
||||
mm[0], mm[3], mm[6],
|
||||
mm[1], mm[4], mm[7],
|
||||
0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------
|
||||
* Outputs the values of the current matrix into the given array
|
||||
*---------------------------------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgGetMatrix(VGfloat * mm)
|
||||
{
|
||||
SHMatrix3x3 *m; int i,j,k=0;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!mm, VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
/* TODO: check matrix array alignment */
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
|
||||
for (i=0; i<3; ++i)
|
||||
for (j=0; j<3; ++j)
|
||||
mm[k++] = m->m[j][i];
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------
|
||||
* Right-multiplies the current matrix with the one specified
|
||||
* in the given array. Matrix affinity is preserved if an
|
||||
* affine matrix is begin multiplied.
|
||||
*-------------------------------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgMultMatrix(const VGfloat * mm)
|
||||
{
|
||||
SHMatrix3x3 *m, mul, temp;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!mm, VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
/* TODO: check matrix array alignment */
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
|
||||
if (context->matrixMode == VG_MATRIX_IMAGE_USER_TO_SURFACE) {
|
||||
|
||||
SETMAT(mul,
|
||||
mm[0], mm[3], mm[6],
|
||||
mm[1], mm[4], mm[7],
|
||||
mm[2], mm[5], mm[8]);
|
||||
}else{
|
||||
|
||||
SETMAT(mul,
|
||||
mm[0], mm[3], mm[6],
|
||||
mm[1], mm[4], mm[7],
|
||||
0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
|
||||
MULMATMAT((*m), mul, temp);
|
||||
SETMATMAT((*m), temp);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgTranslate(VGfloat tx, VGfloat ty)
|
||||
{
|
||||
SHMatrix3x3 *m;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
TRANSLATEMATR((*m), tx, ty);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgScale(VGfloat sx, VGfloat sy)
|
||||
{
|
||||
SHMatrix3x3 *m;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
SCALEMATR((*m), sx, sy);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgShear(VGfloat shx, VGfloat shy)
|
||||
{
|
||||
SHMatrix3x3 *m;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
m = shCurrentMatrix(context);
|
||||
SHEARMATR((*m), shx, shy);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgRotate(VGfloat angle)
|
||||
{
|
||||
SHfloat a;
|
||||
SHMatrix3x3 *m;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
a = SH_DEG2RAD(angle);
|
||||
m = shCurrentMatrix(context);
|
||||
ROTATEMATR((*m), a);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL VGHardwareQueryResult vgHardwareQuery(VGHardwareQueryType key,
|
||||
VGint setting)
|
||||
{
|
||||
return VG_HARDWARE_UNACCELERATED;
|
||||
}
|
||||
|
|
@ -1,169 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHCONTEXT_H
|
||||
#define __SHCONTEXT_H
|
||||
|
||||
#include "shDefs.h"
|
||||
#include "shVectors.h"
|
||||
#include "shArrays.h"
|
||||
#include "shPath.h"
|
||||
#include "shPaint.h"
|
||||
#include "shImage.h"
|
||||
|
||||
/*------------------------------------------------
|
||||
* VGContext object
|
||||
*------------------------------------------------*/
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SH_RESOURCE_INVALID = 0,
|
||||
SH_RESOURCE_PATH = 1,
|
||||
SH_RESOURCE_PAINT = 2,
|
||||
SH_RESOURCE_IMAGE = 3
|
||||
} SHResourceType;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
/* Surface info (since no EGL yet) */
|
||||
SHint surfaceWidth;
|
||||
SHint surfaceHeight;
|
||||
|
||||
/* GetString info */
|
||||
char vendor[256];
|
||||
char renderer[256];
|
||||
char version[256];
|
||||
char extensions[256];
|
||||
|
||||
/* Mode settings */
|
||||
VGMatrixMode matrixMode;
|
||||
VGFillRule fillRule;
|
||||
VGImageQuality imageQuality;
|
||||
VGRenderingQuality renderingQuality;
|
||||
VGBlendMode blendMode;
|
||||
VGImageMode imageMode;
|
||||
|
||||
/* Scissor rectangles */
|
||||
SHRectArray scissor;
|
||||
VGboolean scissoring;
|
||||
VGboolean masking;
|
||||
|
||||
/* Stroke parameters */
|
||||
SHfloat strokeLineWidth;
|
||||
VGCapStyle strokeCapStyle;
|
||||
VGJoinStyle strokeJoinStyle;
|
||||
SHfloat strokeMiterLimit;
|
||||
SHFloatArray strokeDashPattern;
|
||||
SHfloat strokeDashPhase;
|
||||
VGboolean strokeDashPhaseReset;
|
||||
|
||||
/* Edge fill color for vgConvolve and pattern paint */
|
||||
SHColor tileFillColor;
|
||||
|
||||
/* Color for vgClear */
|
||||
SHColor clearColor;
|
||||
|
||||
/* Color components layout inside pixel */
|
||||
VGPixelLayout pixelLayout;
|
||||
|
||||
/* Source format for image filters */
|
||||
VGboolean filterFormatLinear;
|
||||
VGboolean filterFormatPremultiplied;
|
||||
VGbitfield filterChannelMask;
|
||||
|
||||
/* Matrices */
|
||||
SHMatrix3x3 pathTransform;
|
||||
SHMatrix3x3 imageTransform;
|
||||
SHMatrix3x3 fillTransform;
|
||||
SHMatrix3x3 strokeTransform;
|
||||
|
||||
/* Paints */
|
||||
SHPaint* fillPaint;
|
||||
SHPaint* strokePaint;
|
||||
SHPaint defaultPaint;
|
||||
|
||||
VGErrorCode error;
|
||||
|
||||
/* Resources */
|
||||
SHPathArray paths;
|
||||
SHPaintArray paints;
|
||||
SHImageArray images;
|
||||
|
||||
/* Pointers to extensions */
|
||||
SHint isGLAvailable_ClampToEdge;
|
||||
SHint isGLAvailable_MirroredRepeat;
|
||||
SHint isGLAvailable_Multitexture;
|
||||
SHint isGLAvailable_TextureNonPowerOfTwo;
|
||||
SH_PGLACTIVETEXTURE pglActiveTexture;
|
||||
SH_PGLMULTITEXCOORD1F pglMultiTexCoord1f;
|
||||
SH_PGLMULTITEXCOORD2F pglMultiTexCoord2f;
|
||||
|
||||
} VGContext;
|
||||
|
||||
void VGContext_ctor(VGContext *c);
|
||||
void VGContext_dtor(VGContext *c);
|
||||
void shSetError(VGContext *c, VGErrorCode e);
|
||||
SHint shIsValidPath(VGContext *c, VGHandle h);
|
||||
SHint shIsValidPaint(VGContext *c, VGHandle h);
|
||||
SHint shIsValidImage(VGContext *c, VGHandle h);
|
||||
SHResourceType shGetResourceType(VGContext *c, VGHandle h);
|
||||
VGContext* shGetContext();
|
||||
|
||||
/*----------------------------------------------------
|
||||
* TODO: Add mutex locking/unlocking to these macros
|
||||
* to assure sequentiallity in multithreading.
|
||||
*----------------------------------------------------*/
|
||||
|
||||
#define VG_NO_RETVAL
|
||||
|
||||
#define VG_GETCONTEXT(RETVAL) \
|
||||
VGContext *context = shGetContext(); \
|
||||
if (!context) return RETVAL;
|
||||
|
||||
#define VG_RETURN(RETVAL) \
|
||||
{ return RETVAL; }
|
||||
|
||||
#define VG_RETURN_ERR(ERRORCODE, RETVAL) \
|
||||
{ shSetError(context,ERRORCODE); return RETVAL; }
|
||||
|
||||
#define VG_RETURN_ERR_IF(COND, ERRORCODE, RETVAL) \
|
||||
{ if (COND) {shSetError(context,ERRORCODE); return RETVAL;} }
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Same macros but no mutex handling - used by sub-functions
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
#define SH_NO_RETVAL
|
||||
|
||||
#define SH_GETCONTEXT(RETVAL) \
|
||||
VGContext *context = shGetContext(); \
|
||||
if (!context) return RETVAL;
|
||||
|
||||
#define SH_RETURN(RETVAL) \
|
||||
{ return RETVAL; }
|
||||
|
||||
#define SH_RETURN_ERR(ERRORCODE, RETVAL) \
|
||||
{ shSetError(context,ERRORCODE); return RETVAL; }
|
||||
|
||||
#define SH_RETURN_ERR_IF(COND, ERRORCODE, RETVAL) \
|
||||
{ if (COND) {shSetError(context,ERRORCODE); return RETVAL;} }
|
||||
|
||||
|
||||
#endif /* __SHCONTEXT_H */
|
||||
|
|
@ -1,179 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHDEFS_H
|
||||
#define __SHDEFS_H
|
||||
|
||||
/* Standard headers */
|
||||
|
||||
#include "shConfig.h"
|
||||
|
||||
#ifdef VG_API_WINDOWS
|
||||
# include <windows.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
|
||||
#ifndef VG_API_MACOSX
|
||||
# include <malloc.h>
|
||||
#endif
|
||||
|
||||
/* Disable VGHandle-pointer conversion warnings since we
|
||||
do deal with it by defining VGHandle properly */
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma warning(disable:4311)
|
||||
# pragma warning(disable:4312)
|
||||
#endif
|
||||
|
||||
/* Type definitions */
|
||||
|
||||
#if HAVE_INTTYPES_H
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#else
|
||||
|
||||
#define int8_t char
|
||||
#define uint8_t unsigned char
|
||||
#define int16_t short
|
||||
#define uint16_t unsigned short
|
||||
#define int32_t int
|
||||
#define uint32_t unsigned int
|
||||
#define int64_t long long
|
||||
#define uint64_t unsigned long long
|
||||
|
||||
#endif
|
||||
|
||||
typedef int8_t SHint8;
|
||||
typedef uint8_t SHuint8;
|
||||
typedef int16_t SHint16;
|
||||
typedef uint16_t SHuint16;
|
||||
typedef int32_t SHint32;
|
||||
typedef uint32_t SHuint32;
|
||||
typedef float SHfloat32;
|
||||
|
||||
#define SHint SHint32
|
||||
#define SHuint SHuint32
|
||||
#define SHfloat SHfloat32
|
||||
|
||||
/* Maximum / minimum values */
|
||||
|
||||
#define SH_MAX_INT (0x7fffffff)
|
||||
#define SH_MIN_INT (-0x7fffffff-1)
|
||||
|
||||
#define SH_MANTISSA_BITS 23
|
||||
#define SH_EXPONENT_BITS 8
|
||||
|
||||
/* all 1s in exponent yields NaN in IEEE 754 so we take
|
||||
1 less then maximum representable with exponent bits */
|
||||
#define SH_MAX_EXPONENT ((1 << SH_EXPONENT_BITS) - 2)
|
||||
/* maximum representable with mantissa bits */
|
||||
#define SH_MAX_MANTISSA ((1 << SH_MANTISSA_BITS) - 1)
|
||||
/* compose into IEEE754 floating point bit value */
|
||||
#define SH_MAX_FLOAT_BITS (SH_MAX_EXPONENT << SH_MANTISSA_BITS) | SH_MAX_MANTISSA
|
||||
|
||||
typedef union {
|
||||
float f;
|
||||
unsigned int i;
|
||||
} SHfloatint;
|
||||
|
||||
SHfloat getMaxFloat();
|
||||
|
||||
/* Portable function definitions */
|
||||
|
||||
#define SH_SQRT (float)sqrt
|
||||
#define SH_COS (float)cos
|
||||
#define SH_SIN (float)sin
|
||||
#define SH_ACOS (float)acos
|
||||
#define SH_ASIN (float)asin
|
||||
#define SH_ATAN (float)atan
|
||||
#define SH_FLOOR (float)floor
|
||||
#define SH_CEIL (float)ceil
|
||||
#define SH_ASSERT assert
|
||||
|
||||
#if defined(__isnan) || (defined(__APPLE__) && (__GNUC__ == 3))
|
||||
# define SH_ISNAN __isnan
|
||||
#elif defined(_isnan) || defined(WIN32)
|
||||
# define SH_ISNAN _isnan
|
||||
#else
|
||||
# define SH_ISNAN isnan
|
||||
#endif
|
||||
|
||||
|
||||
/* Helper macros */
|
||||
|
||||
#define PI 3.141592654f
|
||||
#define SH_DEG2RAD(a) (a * PI / 180.0f)
|
||||
#define SH_RAD2DEG(a) (a * 180.0f / PI)
|
||||
#define SH_ABS(a) ((a < 0.0f) ? -a : a)
|
||||
#define SH_MAX(a,b) ((a > b) ? a : b)
|
||||
#define SH_MIN(a,b) ((a < b) ? a : b)
|
||||
#define SH_NEARZERO(a) (a >= -0.0001 && a < 0.0001)
|
||||
#define SH_SWAP(a,b) {SHfloat t=a; a=b; b=t;}
|
||||
#define SH_CLAMP(a,min,max) {if (a<min) a=min; if (a>max) a=max; }
|
||||
|
||||
#define SH_NEWOBJ(type,obj) { obj = (type*)malloc(sizeof(type)); if(obj) type ## _ctor(obj); }
|
||||
#define SH_INITOBJ(type,obj){ type ## _ctor(&obj); }
|
||||
#define SH_DEINITOBJ(type,obj) { type ## _dtor(&obj); }
|
||||
#define SH_DELETEOBJ(type,obj) { if(obj) type ## _dtor(obj); free(obj); }
|
||||
|
||||
/* Implementation limits */
|
||||
|
||||
#define SH_MAX_SCISSOR_RECTS 1
|
||||
#define SH_MAX_DASH_COUNT VG_MAXINT
|
||||
#define SH_MAX_IMAGE_WIDTH VG_MAXINT
|
||||
#define SH_MAX_IMAGE_HEIGHT VG_MAXINT
|
||||
#define SH_MAX_IMAGE_PIXELS VG_MAXINT
|
||||
#define SH_MAX_IMAGE_BYTES VG_MAXINT
|
||||
#define SH_MAX_COLOR_RAMP_STOPS 256
|
||||
|
||||
#define SH_MAX_VERTICES 999999999
|
||||
#define SH_MAX_RECURSE_DEPTH 16
|
||||
|
||||
#define SH_GRADIENT_TEX_SIZE 1024
|
||||
#define SH_GRADIENT_TEX_COORDSIZE 4096 /* 1024 * RGBA */
|
||||
|
||||
/* OpenGL headers */
|
||||
|
||||
#if defined(VG_API_LINUX)
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glu.h>
|
||||
#include <GL/glx.h>
|
||||
#elif defined(VG_API_MACOSX)
|
||||
#include <OpenGL/gl.h>
|
||||
#include <OpenGL/glu.h>
|
||||
#elif defined(VG_API_WINDOWS)
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glu.h>
|
||||
#else
|
||||
#define GL_GLEXT_LEGACY /* don't include glext.h */
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glu.h>
|
||||
#include <GL/glx.h>
|
||||
#endif
|
||||
|
||||
#include "shExtensions.h"
|
||||
|
||||
|
||||
#endif /* __SHDEFS_H */
|
||||
|
|
@ -1,131 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <vg/openvg.h>
|
||||
#include "shDefs.h"
|
||||
#include "shExtensions.h"
|
||||
#include "shContext.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
/*-----------------------------------------------------
|
||||
* Extensions check
|
||||
*-----------------------------------------------------*/
|
||||
|
||||
void fallbackActiveTexture(GLenum texture) {
|
||||
}
|
||||
|
||||
void fallbackMultiTexCoord1f(GLenum target, GLfloat x) {
|
||||
glTexCoord1f(x);
|
||||
}
|
||||
|
||||
void fallbackMultiTexCoord2f(GLenum target, GLfloat x, GLfloat y) {
|
||||
glTexCoord2f(x, y);
|
||||
}
|
||||
|
||||
static int checkExtension(const char *extensions, const char *name)
|
||||
{
|
||||
int nlen = (int)strlen(name);
|
||||
int elen = (int)strlen(extensions);
|
||||
const char *e = extensions;
|
||||
SH_ASSERT(nlen > 0);
|
||||
|
||||
while (1) {
|
||||
|
||||
/* Try to find sub-string */
|
||||
e = strstr(e, name);
|
||||
if (e == NULL) return 0;
|
||||
/* Check if last */
|
||||
if (e == extensions + elen - nlen)
|
||||
return 1;
|
||||
/* Check if space follows (avoid same names with a suffix) */
|
||||
if (*(e + nlen) == ' ')
|
||||
return 1;
|
||||
|
||||
e += nlen;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
typedef void (*PFVOID)();
|
||||
|
||||
PFVOID shGetProcAddress(const char *name)
|
||||
{
|
||||
#if defined(_WIN32)
|
||||
return (PFVOID)wglGetProcAddress(name);
|
||||
#elif defined(__APPLE__)
|
||||
/* TODO: Mac OS glGetProcAddress implementation */
|
||||
return (PFVOID)NULL;
|
||||
#else
|
||||
return (PFVOID)glXGetProcAddress((const unsigned char *)name);
|
||||
#endif
|
||||
}
|
||||
|
||||
void shLoadExtensions(VGContext *c)
|
||||
{
|
||||
const char *ext = (const char*)glGetString(GL_EXTENSIONS);
|
||||
|
||||
/* GL_TEXTURE_CLAMP_TO_EDGE */
|
||||
if (checkExtension(ext, "GL_EXT_texture_edge_clamp"))
|
||||
c->isGLAvailable_ClampToEdge = 1;
|
||||
else if (checkExtension(ext, "GL_SGIS_texture_edge_clamp"))
|
||||
c->isGLAvailable_ClampToEdge = 1;
|
||||
else /* Unavailable */
|
||||
c->isGLAvailable_ClampToEdge = 0;
|
||||
|
||||
|
||||
/* GL_TEXTURE_MIRRORED_REPEAT */
|
||||
if (checkExtension(ext, "GL_ARB_texture_mirrored_repeat"))
|
||||
c->isGLAvailable_MirroredRepeat = 1;
|
||||
else if(checkExtension(ext, "GL_IBM_texture_mirrored_repeat"))
|
||||
c->isGLAvailable_MirroredRepeat = 1;
|
||||
else /* Unavailable */
|
||||
c->isGLAvailable_MirroredRepeat = 0;
|
||||
|
||||
|
||||
/* glActiveTexture, glMultiTexCoord1f */
|
||||
if (checkExtension(ext, "GL_ARB_multitexture")) {
|
||||
c->isGLAvailable_Multitexture = 1;
|
||||
|
||||
c->pglActiveTexture = (SH_PGLACTIVETEXTURE)
|
||||
shGetProcAddress("glActiveTextureARB");
|
||||
c->pglMultiTexCoord1f = (SH_PGLMULTITEXCOORD1F)
|
||||
shGetProcAddress("glMultiTexCoord1fARB");
|
||||
c->pglMultiTexCoord2f = (SH_PGLMULTITEXCOORD2F)
|
||||
shGetProcAddress("glMultiTexCoord2fARB");
|
||||
|
||||
if (c->pglActiveTexture == NULL || c->pglMultiTexCoord1f == NULL ||
|
||||
c->pglMultiTexCoord2f == NULL)
|
||||
c->isGLAvailable_Multitexture = 0;
|
||||
|
||||
}else{ /* Unavailable */
|
||||
c->isGLAvailable_Multitexture = 0;
|
||||
c->pglActiveTexture = (SH_PGLACTIVETEXTURE)fallbackActiveTexture;
|
||||
c->pglMultiTexCoord1f = (SH_PGLMULTITEXCOORD1F)fallbackMultiTexCoord1f;
|
||||
c->pglMultiTexCoord2f = (SH_PGLMULTITEXCOORD2F)fallbackMultiTexCoord2f;
|
||||
}
|
||||
|
||||
/* Non-power-of-two textures */
|
||||
if (checkExtension(ext, "GL_ARB_texture_non_power_of_two"))
|
||||
c->isGLAvailable_TextureNonPowerOfTwo = 1;
|
||||
else /* Unavailable */
|
||||
c->isGLAvailable_TextureNonPowerOfTwo = 0;
|
||||
}
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHEXTENSIONS_H
|
||||
#define __SHEXTENSIONS_H
|
||||
|
||||
/* Define missing constants and route missing
|
||||
functions to extension pointers */
|
||||
|
||||
#ifndef APIENTRY
|
||||
#define APIENTRY
|
||||
#endif
|
||||
#ifndef APIENTRYP
|
||||
#define APIENTRYP APIENTRY *
|
||||
#endif
|
||||
|
||||
#ifndef GL_VERSION_1_2
|
||||
# define GL_BGRA 0x80E1
|
||||
# define GL_UNSIGNED_SHORT_5_6_5 0x8363
|
||||
# define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
|
||||
# define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
|
||||
# define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
|
||||
# define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
|
||||
# define GL_UNSIGNED_INT_8_8_8_8 0x8035
|
||||
# define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
|
||||
# define GL_CLAMP_TO_EDGE 0x812F
|
||||
#endif
|
||||
|
||||
#ifndef GL_VERSION_1_3
|
||||
# define GL_MULTISAMPLE 0x809D
|
||||
# define GL_TEXTURE0 0x84C0
|
||||
# define GL_TEXTURE1 0x84C1
|
||||
# define GL_CLAMP_TO_BORDER 0x812D
|
||||
# define glActiveTexture context->pglActiveTexture
|
||||
# define glMultiTexCoord1f context->pglMultiTexCoord1f
|
||||
# define glMultiTexCoord2f context->pglMultiTexCoord2f
|
||||
#endif
|
||||
|
||||
#ifndef GL_VERSION_1_4
|
||||
# define GL_MIRRORED_REPEAT 0x8370
|
||||
#endif
|
||||
|
||||
typedef void (APIENTRYP SH_PGLACTIVETEXTURE) (GLenum);
|
||||
typedef void (APIENTRYP SH_PGLMULTITEXCOORD1F) (GLenum, GLfloat);
|
||||
typedef void (APIENTRYP SH_PGLMULTITEXCOORD2F) (GLenum, GLfloat, GLfloat);
|
||||
|
||||
#endif
|
||||
|
|
@ -1,936 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <vg/openvg.h>
|
||||
#include "shContext.h"
|
||||
#include "shGeometry.h"
|
||||
|
||||
|
||||
static int shAddVertex(SHPath *p, SHVertex *v, SHint *contourStart)
|
||||
{
|
||||
/* Assert contour was open */
|
||||
SH_ASSERT((*contourStart) >= 0);
|
||||
|
||||
/* Check vertex limit */
|
||||
if (p->vertices.size >= SH_MAX_VERTICES) return 0;
|
||||
|
||||
/* Add vertex to subdivision */
|
||||
shVertexArrayPushBackP(&p->vertices, v);
|
||||
|
||||
/* Increment contour size. Its stored in
|
||||
the flags of first contour vertex */
|
||||
p->vertices.items[*contourStart].flags++;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void shSubrecurseQuad(SHPath *p, SHQuad *quad, SHint *contourStart)
|
||||
{
|
||||
SHVertex v;
|
||||
SHVector2 mid, dif, c1, c2, c3;
|
||||
SHQuad quads[SH_MAX_RECURSE_DEPTH];
|
||||
SHQuad *q, *qleft, *qright;
|
||||
SHint qindex=0;
|
||||
quads[0] = *quad;
|
||||
|
||||
while (qindex >= 0) {
|
||||
|
||||
q = &quads[qindex];
|
||||
|
||||
/* Calculate distance of control point from its
|
||||
counterpart on the line between end points */
|
||||
SET2V(mid, q->p1); ADD2V(mid, q->p3); DIV2(mid, 2);
|
||||
SET2V(dif, q->p2); SUB2V(dif, mid); ABS2(dif);
|
||||
|
||||
/* Cancel if the curve is flat enough */
|
||||
if (dif.x + dif.y <= 1.0f || qindex == SH_MAX_RECURSE_DEPTH-1) {
|
||||
|
||||
/* Add subdivision point */
|
||||
v.point = q->p3; v.flags = 0;
|
||||
if (qindex == 0) return; /* Skip last point */
|
||||
if (!shAddVertex(p, &v, contourStart)) return;
|
||||
--qindex;
|
||||
|
||||
}else{
|
||||
|
||||
/* Left recursion goes on top of stack! */
|
||||
qright = q; qleft = &quads[++qindex];
|
||||
|
||||
/* Subdivide into 2 sub-curves */
|
||||
SET2V(c1, q->p1); ADD2V(c1, q->p2); DIV2(c1, 2);
|
||||
SET2V(c3, q->p2); ADD2V(c3, q->p3); DIV2(c3, 2);
|
||||
SET2V(c2, c1); ADD2V(c2, c3); DIV2(c2, 2);
|
||||
|
||||
/* Add left recursion onto stack */
|
||||
qleft->p1 = q->p1;
|
||||
qleft->p2 = c1;
|
||||
qleft->p3 = c2;
|
||||
|
||||
/* Add right recursion onto stack */
|
||||
qright->p1 = c2;
|
||||
qright->p2 = c3;
|
||||
qright->p3 = q->p3;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void shSubrecurseCubic(SHPath *p, SHCubic *cubic, SHint *contourStart)
|
||||
{
|
||||
SHVertex v;
|
||||
SHfloat dx1, dy1, dx2, dy2;
|
||||
SHVector2 mm, c1, c2, c3, c4, c5;
|
||||
SHCubic cubics[SH_MAX_RECURSE_DEPTH];
|
||||
SHCubic *c, *cleft, *cright;
|
||||
SHint cindex = 0;
|
||||
cubics[0] = *cubic;
|
||||
|
||||
while (cindex >= 0) {
|
||||
|
||||
c = &cubics[cindex];
|
||||
|
||||
/* Calculate distance of control points from their
|
||||
counterparts on the line between end points */
|
||||
dx1 = 3.0f*c->p2.x - 2.0f*c->p1.x - c->p4.x; dx1 *= dx1;
|
||||
dy1 = 3.0f*c->p2.y - 2.0f*c->p1.y - c->p4.y; dy1 *= dy1;
|
||||
dx2 = 3.0f*c->p3.x - 2.0f*c->p4.x - c->p1.x; dx2 *= dx2;
|
||||
dy2 = 3.0f*c->p3.y - 2.0f*c->p4.y - c->p1.y; dy2 *= dy2;
|
||||
if (dx1 < dx2) dx1 = dx2;
|
||||
if (dy1 < dy2) dy1 = dy2;
|
||||
|
||||
/* Cancel if the curve is flat enough */
|
||||
if (dx1+dy1 <= 1.0 || cindex == SH_MAX_RECURSE_DEPTH-1) {
|
||||
|
||||
/* Add subdivision point */
|
||||
v.point = c->p4; v.flags = 0;
|
||||
if (cindex == 0) return; /* Skip last point */
|
||||
if (!shAddVertex(p, &v, contourStart)) return;
|
||||
--cindex;
|
||||
|
||||
}else{
|
||||
|
||||
/* Left recursion goes on top of stack! */
|
||||
cright = c; cleft = &cubics[++cindex];
|
||||
|
||||
/* Subdivide into 2 sub-curves */
|
||||
SET2V(c1, c->p1); ADD2V(c1, c->p2); DIV2(c1, 2);
|
||||
SET2V(mm, c->p2); ADD2V(mm, c->p3); DIV2(mm, 2);
|
||||
SET2V(c5, c->p3); ADD2V(c5, c->p4); DIV2(c5, 2);
|
||||
|
||||
SET2V(c2, c1); ADD2V(c2, mm); DIV2(c2, 2);
|
||||
SET2V(c4, mm); ADD2V(c4, c5); DIV2(c4, 2);
|
||||
|
||||
SET2V(c3, c2); ADD2V(c3, c4); DIV2(c3, 2);
|
||||
|
||||
/* Add left recursion to stack */
|
||||
cleft->p1 = c->p1;
|
||||
cleft->p2 = c1;
|
||||
cleft->p3 = c2;
|
||||
cleft->p4 = c3;
|
||||
|
||||
/* Add right recursion to stack */
|
||||
cright->p1 = c3;
|
||||
cright->p2 = c4;
|
||||
cright->p3 = c5;
|
||||
cright->p4 = c->p4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void shSubrecurseArc(SHPath *p, SHArc *arc,
|
||||
SHVector2 *c,SHVector2 *ux, SHVector2 *uy,
|
||||
SHint *contourStart)
|
||||
{
|
||||
SHVertex v;
|
||||
SHfloat am, cosa, sina, dx, dy;
|
||||
SHVector2 uux, uuy, c1, m;
|
||||
SHArc arcs[SH_MAX_RECURSE_DEPTH];
|
||||
SHArc *a, *aleft, *aright;
|
||||
SHint aindex=0;
|
||||
arcs[0] = *arc;
|
||||
|
||||
while (aindex >= 0) {
|
||||
|
||||
a = &arcs[aindex];
|
||||
|
||||
/* Middle angle and its cos/sin */
|
||||
am = (a->a1 + a->a2)/2;
|
||||
cosa = SH_COS(am);
|
||||
sina = SH_SIN(am);
|
||||
|
||||
/* New point */
|
||||
SET2V(uux, (*ux)); MUL2(uux, cosa);
|
||||
SET2V(uuy, (*uy)); MUL2(uuy, sina);
|
||||
SET2V(c1, (*c)); ADD2V(c1, uux); ADD2V(c1, uuy);
|
||||
|
||||
/* Check distance from linear midpoint */
|
||||
SET2V(m, a->p1); ADD2V(m, a->p2); DIV2(m, 2);
|
||||
dx = c1.x - m.x; dy = c1.y - m.y;
|
||||
if (dx < 0.0f) dx = -dx;
|
||||
if (dy < 0.0f) dy = -dy;
|
||||
|
||||
/* Stop if flat enough */
|
||||
if (dx+dy <= 1.0f || aindex == SH_MAX_RECURSE_DEPTH-1) {
|
||||
|
||||
/* Add middle subdivision point */
|
||||
v.point = c1; v.flags = 0;
|
||||
if (!shAddVertex(p, &v, contourStart)) return;
|
||||
if (aindex == 0) return; /* Skip very last point */
|
||||
|
||||
/* Add end subdivision point */
|
||||
v.point = a->p2; v.flags = 0;
|
||||
if (!shAddVertex(p, &v, contourStart)) return;
|
||||
--aindex;
|
||||
|
||||
}else{
|
||||
|
||||
/* Left subdivision goes on top of stack! */
|
||||
aright = a; aleft = &arcs[++aindex];
|
||||
|
||||
/* Add left recursion to stack */
|
||||
aleft->p1 = a->p1;
|
||||
aleft->a1 = a->a1;
|
||||
aleft->p2 = c1;
|
||||
aleft->a2 = am;
|
||||
|
||||
/* Add right recursion to stack */
|
||||
aright->p1 = c1;
|
||||
aright->a1 = am;
|
||||
aright->p2 = a->p2;
|
||||
aright->a2 = a->a2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void shSubdivideSegment(SHPath *p, VGPathSegment segment,
|
||||
VGPathCommand originalCommand,
|
||||
SHfloat *data, void *userData)
|
||||
{
|
||||
SHVertex v;
|
||||
SHint *contourStart = ((SHint**)userData)[0];
|
||||
SHint *surfaceSpace = ((SHint**)userData)[1];
|
||||
SHQuad quad; SHCubic cubic; SHArc arc;
|
||||
SHVector2 c, ux, uy;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
switch (segment)
|
||||
{
|
||||
case VG_MOVE_TO:
|
||||
|
||||
/* Set contour start here */
|
||||
(*contourStart) = p->vertices.size;
|
||||
|
||||
/* First contour vertex */
|
||||
v.point.x = data[2];
|
||||
v.point.y = data[3];
|
||||
v.flags = 0;
|
||||
if (*surfaceSpace)
|
||||
TRANSFORM2(v.point, context->pathTransform);
|
||||
break;
|
||||
|
||||
case VG_CLOSE_PATH:
|
||||
|
||||
/* Last contour vertex */
|
||||
v.point.x = data[2];
|
||||
v.point.y = data[3];
|
||||
v.flags = SH_VERTEX_FLAG_SEGEND | SH_VERTEX_FLAG_CLOSE;
|
||||
if (*surfaceSpace)
|
||||
TRANSFORM2(v.point, context->pathTransform);
|
||||
break;
|
||||
|
||||
case VG_LINE_TO:
|
||||
|
||||
/* Last segment vertex */
|
||||
v.point.x = data[2];
|
||||
v.point.y = data[3];
|
||||
v.flags = SH_VERTEX_FLAG_SEGEND;
|
||||
if (*surfaceSpace)
|
||||
TRANSFORM2(v.point, context->pathTransform);
|
||||
break;
|
||||
|
||||
case VG_QUAD_TO:
|
||||
|
||||
/* Recurse subdivision */
|
||||
SET2(quad.p1, data[0], data[1]);
|
||||
SET2(quad.p2, data[2], data[3]);
|
||||
SET2(quad.p3, data[4], data[5]);
|
||||
if (*surfaceSpace) {
|
||||
TRANSFORM2(quad.p1, context->pathTransform);
|
||||
TRANSFORM2(quad.p2, context->pathTransform);
|
||||
TRANSFORM2(quad.p3, context->pathTransform); }
|
||||
shSubrecurseQuad(p, &quad, contourStart);
|
||||
|
||||
/* Last segment vertex */
|
||||
v.point.x = data[4];
|
||||
v.point.y = data[5];
|
||||
v.flags = SH_VERTEX_FLAG_SEGEND;
|
||||
if (*surfaceSpace)
|
||||
TRANSFORM2(v.point, context->pathTransform);
|
||||
break;
|
||||
|
||||
case VG_CUBIC_TO:
|
||||
|
||||
/* Recurse subdivision */
|
||||
SET2(cubic.p1, data[0], data[1]);
|
||||
SET2(cubic.p2, data[2], data[3]);
|
||||
SET2(cubic.p3, data[4], data[5]);
|
||||
SET2(cubic.p4, data[6], data[7]);
|
||||
if (*surfaceSpace) {
|
||||
TRANSFORM2(cubic.p1, context->pathTransform);
|
||||
TRANSFORM2(cubic.p2, context->pathTransform);
|
||||
TRANSFORM2(cubic.p3, context->pathTransform);
|
||||
TRANSFORM2(cubic.p4, context->pathTransform); }
|
||||
shSubrecurseCubic(p, &cubic, contourStart);
|
||||
|
||||
/* Last segment vertex */
|
||||
v.point.x = data[6];
|
||||
v.point.y = data[7];
|
||||
v.flags = SH_VERTEX_FLAG_SEGEND;
|
||||
if (*surfaceSpace)
|
||||
TRANSFORM2(v.point, context->pathTransform);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
SH_ASSERT(segment==VG_SCWARC_TO || segment==VG_SCCWARC_TO ||
|
||||
segment==VG_LCWARC_TO || segment==VG_LCCWARC_TO);
|
||||
|
||||
/* Recurse subdivision */
|
||||
SET2(arc.p1, data[0], data[1]);
|
||||
SET2(arc.p2, data[10], data[11]);
|
||||
arc.a1 = data[8]; arc.a2 = data[9];
|
||||
SET2(c, data[2], data[3]);
|
||||
SET2(ux, data[4], data[5]);
|
||||
SET2(uy, data[6], data[7]);
|
||||
if (*surfaceSpace) {
|
||||
TRANSFORM2(arc.p1, context->pathTransform);
|
||||
TRANSFORM2(arc.p2, context->pathTransform);
|
||||
TRANSFORM2(c, context->pathTransform);
|
||||
TRANSFORM2DIR(ux, context->pathTransform);
|
||||
TRANSFORM2DIR(uy, context->pathTransform); }
|
||||
shSubrecurseArc(p, &arc, &c, &ux, &uy, contourStart);
|
||||
|
||||
/* Last segment vertex */
|
||||
v.point.x = data[10];
|
||||
v.point.y = data[11];
|
||||
v.flags = SH_VERTEX_FLAG_SEGEND;
|
||||
if (*surfaceSpace) {
|
||||
TRANSFORM2(v.point, context->pathTransform); }
|
||||
break;
|
||||
}
|
||||
|
||||
/* Add subdivision vertex */
|
||||
shAddVertex(p, &v, contourStart);
|
||||
}
|
||||
|
||||
/*--------------------------------------------------
|
||||
* Processes path data by simplfying it and sending
|
||||
* each segment to subdivision callback function
|
||||
*--------------------------------------------------*/
|
||||
|
||||
void shFlattenPath(SHPath *p, SHint surfaceSpace)
|
||||
{
|
||||
SHint contourStart = -1;
|
||||
// SHint surfSpace = surfaceSpace;
|
||||
SHint *userData[2];
|
||||
SHint processFlags =
|
||||
SH_PROCESS_SIMPLIFY_LINES |
|
||||
SH_PROCESS_SIMPLIFY_CURVES |
|
||||
SH_PROCESS_CENTRALIZE_ARCS |
|
||||
SH_PROCESS_REPAIR_ENDS;
|
||||
|
||||
userData[0] = &contourStart;
|
||||
userData[1] = &surfaceSpace;
|
||||
|
||||
shVertexArrayClear(&p->vertices);
|
||||
shProcessPathData(p, processFlags, shSubdivideSegment, userData);
|
||||
}
|
||||
|
||||
/*-------------------------------------------
|
||||
* Adds a rectangle to the path's stroke.
|
||||
*-------------------------------------------*/
|
||||
|
||||
static void shPushStrokeQuad(SHPath *p, SHVector2 *p1, SHVector2 *p2,
|
||||
SHVector2 *p3, SHVector2 *p4)
|
||||
{
|
||||
shVector2ArrayPushBackP(&p->stroke, p1);
|
||||
shVector2ArrayPushBackP(&p->stroke, p2);
|
||||
shVector2ArrayPushBackP(&p->stroke, p3);
|
||||
shVector2ArrayPushBackP(&p->stroke, p3);
|
||||
shVector2ArrayPushBackP(&p->stroke, p4);
|
||||
shVector2ArrayPushBackP(&p->stroke, p1);
|
||||
}
|
||||
|
||||
/*-------------------------------------------
|
||||
* Adds a triangle to the path's stroke.
|
||||
*-------------------------------------------*/
|
||||
|
||||
static void shPushStrokeTri(SHPath *p, SHVector2 *p1,
|
||||
SHVector2 *p2, SHVector2 *p3)
|
||||
{
|
||||
shVector2ArrayPushBackP(&p->stroke, p1);
|
||||
shVector2ArrayPushBackP(&p->stroke, p2);
|
||||
shVector2ArrayPushBackP(&p->stroke, p3);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Adds a miter join to the path's stroke at the given
|
||||
* turn point [c], with the end of the previous segment
|
||||
* outset [o1] and the beginning of the next segment
|
||||
* outset [o2], transiting from tangent [d1] to [d2].
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
static void shStrokeJoinMiter(SHPath *p, SHVector2 *c,
|
||||
SHVector2 *o1, SHVector2 *d1,
|
||||
SHVector2 *o2, SHVector2 *d2)
|
||||
{
|
||||
/* Init miter top to first point in case lines are colinear */
|
||||
SHVector2 x; SET2V(x,(*o1));
|
||||
|
||||
/* Find intersection of two outer turn edges
|
||||
(lines defined by origin and direction) */
|
||||
shLineLineXsection(o1, d1, o2, d2, &x);
|
||||
|
||||
/* Add a "diamond" quad with top on intersected point
|
||||
and bottom on center of turn (on the line) */
|
||||
shPushStrokeQuad(p, &x, o1, c, o2);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Adds a round join to the path's stroke at the given
|
||||
* turn point [c], with the end of the previous segment
|
||||
* outset [pstart] and the beginning of the next segment
|
||||
* outset [pend], transiting from perpendicular vector
|
||||
* [tstart] to [tend].
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
static void shStrokeJoinRound(SHPath *p, SHVector2 *c,
|
||||
SHVector2 *pstart, SHVector2 *tstart,
|
||||
SHVector2 *pend, SHVector2 *tend)
|
||||
{
|
||||
SHVector2 p1, p2;
|
||||
SHfloat a, ang, cosa, sina;
|
||||
|
||||
/* Find angle between lines */
|
||||
ang = ANGLE2((*tstart),(*tend));
|
||||
|
||||
/* Begin with start point */
|
||||
SET2V(p1,(*pstart));
|
||||
for (a=0.0f; a<ang; a+=PI/12) {
|
||||
|
||||
/* Rotate perpendicular vector around and
|
||||
find next offset point from center */
|
||||
cosa = SH_COS(-a);
|
||||
sina = SH_SIN(-a);
|
||||
SET2(p2, tstart->x*cosa - tstart->y*sina,
|
||||
tstart->x*sina + tstart->y*cosa);
|
||||
ADD2V(p2, (*c));
|
||||
|
||||
/* Add triangle, save previous */
|
||||
shPushStrokeTri(p, &p1, &p2, c);
|
||||
SET2V(p1, p2);
|
||||
}
|
||||
|
||||
/* Add last triangle */
|
||||
shPushStrokeTri(p, &p1, pend, c);
|
||||
}
|
||||
|
||||
static void shStrokeCapRound(SHPath *p, SHVector2 *c, SHVector2 *t, SHint start)
|
||||
{
|
||||
SHint a;
|
||||
SHfloat ang, cosa, sina;
|
||||
SHVector2 p1, p2;
|
||||
SHint steps = 12;
|
||||
SHVector2 tt;
|
||||
|
||||
/* Revert perpendicular vector if start cap */
|
||||
SET2V(tt, (*t));
|
||||
if (start) MUL2(tt, -1);
|
||||
|
||||
/* Find start point */
|
||||
SET2V(p1, (*c));
|
||||
ADD2V(p1, tt);
|
||||
|
||||
for (a = 1; a<=steps; ++a) {
|
||||
|
||||
/* Rotate perpendicular vector around and
|
||||
find next offset point from center */
|
||||
ang = (SHfloat)a * PI / steps;
|
||||
cosa = SH_COS(-ang);
|
||||
sina = SH_SIN(-ang);
|
||||
SET2(p2, tt.x*cosa - tt.y*sina,
|
||||
tt.x*sina + tt.y*cosa);
|
||||
ADD2V(p2, (*c));
|
||||
|
||||
/* Add triangle, save previous */
|
||||
shPushStrokeTri(p, &p1, &p2, c);
|
||||
SET2V(p1, p2);
|
||||
}
|
||||
}
|
||||
|
||||
static void shStrokeCapSquare(SHPath *p, SHVector2 *c, SHVector2 *t, SHint start)
|
||||
{
|
||||
SHVector2 tt, p1, p2, p3, p4;
|
||||
|
||||
/* Revert perpendicular vector if start cap */
|
||||
SET2V(tt, (*t));
|
||||
if (start) MUL2(tt, -1);
|
||||
|
||||
/* Find four corners of the quad */
|
||||
SET2V(p1, (*c));
|
||||
ADD2V(p1, tt);
|
||||
|
||||
SET2V(p2, p1);
|
||||
ADD2(p2, tt.y, -tt.x);
|
||||
|
||||
SET2V(p3, p2);
|
||||
ADD2(p3, -2*tt.x, -2*tt.y);
|
||||
|
||||
SET2V(p4, p3);
|
||||
ADD2(p4, -tt.y, tt.x);
|
||||
|
||||
shPushStrokeQuad(p, &p1, &p2, &p3, &p4);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Generates stroke of a path according to VGContext state.
|
||||
* Produces quads for every linear subdivision segment or
|
||||
* dash "on" segment, handles line caps and joins.
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
void shStrokePath(VGContext* c, SHPath *p)
|
||||
{
|
||||
/* Line width and vertex count */
|
||||
SHfloat w = c->strokeLineWidth / 2;
|
||||
SHfloat mlimit = c->strokeMiterLimit;
|
||||
SHint vertsize = p->vertices.size;
|
||||
|
||||
/* Contour state */
|
||||
SHint contourStart = 0;
|
||||
SHint contourLength = 0;
|
||||
SHint start = 0;
|
||||
SHint end = 0;
|
||||
SHint loop = 0;
|
||||
SHint close = 0;
|
||||
SHint segend = 0;
|
||||
|
||||
/* Current vertices */
|
||||
SHint i1=0, i2=0;
|
||||
SHVertex *v1, *v2;
|
||||
SHVector2 *p1, *p2;
|
||||
SHVector2 d, t, dprev, tprev;
|
||||
SHfloat norm, cross, mlength;
|
||||
|
||||
/* Stroke edge points */
|
||||
SHVector2 l1, r1, l2, r2, lprev, rprev;
|
||||
|
||||
/* Dash state */
|
||||
SHint dashIndex = 0;
|
||||
SHfloat dashLength = 0.0f, strokeLength = 0.0f;
|
||||
SHint dashSize = c->strokeDashPattern.size;
|
||||
SHfloat *dashPattern = c->strokeDashPattern.items;
|
||||
SHint dashOn = 1;
|
||||
|
||||
/* Dash edge points */
|
||||
SHVector2 dash1, dash2;
|
||||
SHVector2 dashL1, dashR1;
|
||||
SHVector2 dashL2, dashR2;
|
||||
SHfloat nextDashLength, dashOffset;
|
||||
|
||||
/* Discard odd dash segment */
|
||||
dashSize -= dashSize % 2;
|
||||
|
||||
/* Init previous so compiler doesn't warn
|
||||
for uninitialized usage */
|
||||
SET2(tprev, 0,0); SET2(dprev, 0,0);
|
||||
SET2(lprev, 0,0); SET2(rprev, 0,0);
|
||||
|
||||
|
||||
/* Walk over subdivision vertices */
|
||||
for (i1=0; i1<vertsize; ++i1) {
|
||||
|
||||
if (loop) {
|
||||
/* Start new contour if exists */
|
||||
if (contourStart < vertsize)
|
||||
i1 = contourStart;
|
||||
else break;
|
||||
}
|
||||
|
||||
start = end = loop = close = segend = 0;
|
||||
i2 = i1 + 1;
|
||||
|
||||
if (i1 == contourStart) {
|
||||
/* Contour has started. Get length */
|
||||
contourLength = p->vertices.items[i1].flags;
|
||||
start = 1;
|
||||
}
|
||||
|
||||
if (contourLength <= 1) {
|
||||
/* Discard empty contours. */
|
||||
contourStart = i1 + 1;
|
||||
loop = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
v1 = &p->vertices.items[i1];
|
||||
v2 = &p->vertices.items[i2];
|
||||
|
||||
if (i2 == contourStart + contourLength-1) {
|
||||
/* Contour has ended. Check close */
|
||||
close = v2->flags & SH_VERTEX_FLAG_CLOSE;
|
||||
end = 1;
|
||||
}
|
||||
|
||||
if (i1 == contourStart + contourLength-1) {
|
||||
/* Loop back to first edge. Check close */
|
||||
close = v1->flags & SH_VERTEX_FLAG_CLOSE;
|
||||
i2 = contourStart+1;
|
||||
contourStart = i1 + 1;
|
||||
i1 = i2 - 1;
|
||||
loop = 1;
|
||||
}
|
||||
|
||||
if (!start && !loop) {
|
||||
/* We are inside a contour. Check segment end. */
|
||||
segend = (v1->flags & SH_VERTEX_FLAG_SEGEND);
|
||||
}
|
||||
|
||||
if (dashSize > 0 && start &&
|
||||
(contourStart == 0 || c->strokeDashPhaseReset)) {
|
||||
|
||||
/* Reset pattern phase at contour start */
|
||||
dashLength = -c->strokeDashPhase;
|
||||
strokeLength = 0.0f;
|
||||
dashIndex = 0;
|
||||
dashOn = 1;
|
||||
|
||||
if (dashLength < 0.0f) {
|
||||
/* Consume dash segments forward to reach stroke start */
|
||||
while (dashLength + dashPattern[dashIndex] <= 0.0f) {
|
||||
dashLength += dashPattern[dashIndex];
|
||||
dashIndex = (dashIndex + 1) % dashSize;
|
||||
dashOn = !dashOn; }
|
||||
|
||||
}else if (dashLength > 0.0f) {
|
||||
/* Consume dash segments backward to return to stroke start */
|
||||
dashIndex = dashSize;
|
||||
while (dashLength > 0.0f) {
|
||||
dashIndex = dashIndex ? (dashIndex-1) : (dashSize-1);
|
||||
dashLength -= dashPattern[dashIndex];
|
||||
dashOn = !dashOn; }
|
||||
}
|
||||
}
|
||||
|
||||
/* Subdiv segment vertices and points */
|
||||
v1 = &p->vertices.items[i1];
|
||||
v2 = &p->vertices.items[i2];
|
||||
p1 = &v1->point;
|
||||
p2 = &v2->point;
|
||||
|
||||
/* Direction vector */
|
||||
SET2(d, p2->x-p1->x, p2->y-p1->y);
|
||||
norm = NORM2(d);
|
||||
if (norm == 0.0f) d = dprev;
|
||||
else DIV2(d, norm);
|
||||
|
||||
/* Perpendicular vector */
|
||||
SET2(t, -d.y, d.x);
|
||||
MUL2(t, w);
|
||||
cross = CROSS2(t,tprev);
|
||||
|
||||
/* Left and right edge points */
|
||||
SET2V(l1, (*p1)); ADD2V(l1, t);
|
||||
SET2V(r1, (*p1)); SUB2V(r1, t);
|
||||
SET2V(l2, (*p2)); ADD2V(l2, t);
|
||||
SET2V(r2, (*p2)); SUB2V(r2, t);
|
||||
|
||||
/* Check if join needed */
|
||||
if ((segend || (loop && close)) && dashOn) {
|
||||
|
||||
switch (c->strokeJoinStyle) {
|
||||
case VG_JOIN_ROUND:
|
||||
|
||||
/* Add a round join to stroke */
|
||||
if (cross >= 0.0f)
|
||||
shStrokeJoinRound(p, p1, &lprev, &tprev, &l1, &t);
|
||||
else{
|
||||
SHVector2 _t, _tprev;
|
||||
SET2(_t, -t.x, -t.y);
|
||||
SET2(_tprev, -tprev.x, -tprev.y);
|
||||
shStrokeJoinRound(p, p1, &r1, &_t, &rprev, &_tprev);
|
||||
}
|
||||
|
||||
break;
|
||||
case VG_JOIN_MITER:
|
||||
|
||||
/* Add a miter join to stroke */
|
||||
mlength = 1/SH_COS((ANGLE2(t, tprev))/2);
|
||||
if (mlength <= mlimit) {
|
||||
if (cross > 0.0f)
|
||||
shStrokeJoinMiter(p, p1, &lprev, &dprev, &l1, &d);
|
||||
else if (cross < 0.0f)
|
||||
shStrokeJoinMiter(p, p1, &rprev, &dprev, &r1, &d);
|
||||
break;
|
||||
}/* Else fall down to bevel */
|
||||
|
||||
case VG_JOIN_BEVEL:
|
||||
|
||||
/* Add a bevel join to stroke */
|
||||
if (cross > 0.0f)
|
||||
shPushStrokeTri(p, &l1, &lprev, p1);
|
||||
else if (cross < 0.0f)
|
||||
shPushStrokeTri(p, &r1, &rprev, p1);
|
||||
|
||||
break;
|
||||
}
|
||||
}else if (!start && !loop && dashOn) {
|
||||
|
||||
/* Fill gap with previous (= bevel join) */
|
||||
if (cross > 0.0f)
|
||||
shPushStrokeTri(p, &l1, &lprev, p1);
|
||||
else if (cross < 0.0f)
|
||||
shPushStrokeTri(p, &r1, &rprev, p1);
|
||||
}
|
||||
|
||||
|
||||
/* Apply cap to start of a non-closed contour or
|
||||
if we are dashing and dash segment is on */
|
||||
if ((dashSize == 0 && loop && !close) ||
|
||||
(dashSize > 0 && start && dashOn)) {
|
||||
switch (c->strokeCapStyle) {
|
||||
case VG_CAP_ROUND:
|
||||
shStrokeCapRound(p, p1, &t, 1); break;
|
||||
case VG_CAP_SQUARE:
|
||||
shStrokeCapSquare(p, p1, &t, 1); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
if (loop)
|
||||
continue;
|
||||
|
||||
/* Handle dashing */
|
||||
if (dashSize > 0) {
|
||||
|
||||
/* Start with beginning of subdiv segment */
|
||||
SET2V(dash1, (*p1)); SET2V(dashL1, l1); SET2V(dashR1, r1);
|
||||
|
||||
do {
|
||||
/* Interpolate point on the current subdiv segment */
|
||||
nextDashLength = dashLength + dashPattern[dashIndex];
|
||||
dashOffset = (nextDashLength - strokeLength) / norm;
|
||||
if (dashOffset > 1.0f) dashOffset = 1;
|
||||
SET2V(dash2, (*p2)); SUB2V(dash2, (*p1));
|
||||
MUL2(dash2, dashOffset); ADD2V(dash2, (*p1));
|
||||
|
||||
/* Left and right edge points */
|
||||
SET2V(dashL2, dash2); ADD2V(dashL2, t);
|
||||
SET2V(dashR2, dash2); SUB2V(dashR2, t);
|
||||
|
||||
/* Add quad for this dash segment */
|
||||
if (dashOn) shPushStrokeQuad(p, &dashL2, &dashL1, &dashR1, &dashR2);
|
||||
|
||||
/* Move to next dash segment if inside this subdiv segment */
|
||||
if (nextDashLength <= strokeLength + norm) {
|
||||
dashIndex = (dashIndex + 1) % dashSize;
|
||||
dashLength = nextDashLength;
|
||||
dashOn = !dashOn;
|
||||
SET2V(dash1, dash2);
|
||||
SET2V(dashL1, dashL2);
|
||||
SET2V(dashR1, dashR2);
|
||||
|
||||
/* Apply cap to dash segment */
|
||||
switch (c->strokeCapStyle) {
|
||||
case VG_CAP_ROUND:
|
||||
shStrokeCapRound(p, &dash1, &t, dashOn); break;
|
||||
case VG_CAP_SQUARE:
|
||||
shStrokeCapSquare(p, &dash1, &t, dashOn); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Consume dash segments until subdiv end met */
|
||||
} while (nextDashLength < strokeLength + norm);
|
||||
|
||||
}else{
|
||||
|
||||
/* Add quad for this line segment */
|
||||
shPushStrokeQuad(p, &l2, &l1, &r1, &r2);
|
||||
}
|
||||
|
||||
|
||||
/* Apply cap to end of a non-closed contour or
|
||||
if we are dashing and dash segment is on */
|
||||
if ((dashSize == 0 && end && !close) ||
|
||||
(dashSize > 0 && end && dashOn)) {
|
||||
switch (c->strokeCapStyle) {
|
||||
case VG_CAP_ROUND:
|
||||
shStrokeCapRound(p, p2, &t, 0); break;
|
||||
case VG_CAP_SQUARE:
|
||||
shStrokeCapSquare(p, p2, &t, 0); break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Save previous edge */
|
||||
strokeLength += norm;
|
||||
SET2V(lprev, l2);
|
||||
SET2V(rprev, r2);
|
||||
dprev = d;
|
||||
tprev = t;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------
|
||||
* Transforms the tessellation vertices using the given matrix
|
||||
*-------------------------------------------------------------*/
|
||||
|
||||
void shTransformVertices(SHMatrix3x3 *m, SHPath *p)
|
||||
{
|
||||
SHVector2 *v;
|
||||
int i = 0;
|
||||
|
||||
for (i = p->vertices.size-1; i>=0; --i) {
|
||||
v = (&p->vertices.items[i].point);
|
||||
TRANSFORM2((*v), (*m)); }
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------
|
||||
* Finds the tight bounding box of path's tesselation
|
||||
* vertices. Depends on whether the path had been
|
||||
* tesselated in user or surface space.
|
||||
*--------------------------------------------------------*/
|
||||
|
||||
void shFindBoundbox(SHPath *p)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (p->vertices.size == 0) {
|
||||
SET2(p->min, 0,0);
|
||||
SET2(p->max, 0,0);
|
||||
return;
|
||||
}
|
||||
|
||||
p->min.x = p->max.x = p->vertices.items[0].point.x;
|
||||
p->min.y = p->max.y = p->vertices.items[0].point.y;
|
||||
|
||||
for (i=0; i<p->vertices.size; ++i) {
|
||||
|
||||
SHVector2 *v = &p->vertices.items[i].point;
|
||||
if (v->x < p->min.x) p->min.x = v->x;
|
||||
if (v->x > p->max.x) p->max.x = v->x;
|
||||
if (v->y < p->min.y) p->min.y = v->y;
|
||||
if (v->y > p->max.y) p->max.y = v->y;
|
||||
}
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------
|
||||
* Outputs a tight bounding box of a path in path's own
|
||||
* coordinate system.
|
||||
*--------------------------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgPathBounds(VGPath path,
|
||||
VGfloat * minX, VGfloat * minY,
|
||||
VGfloat * width, VGfloat * height)
|
||||
{
|
||||
SHPath *p = NULL;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!shIsValidPath(context, path),
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(minX == NULL || minY == NULL ||
|
||||
width == NULL || height == NULL,
|
||||
VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* TODO: check output pointer alignment */
|
||||
|
||||
p = (SHPath*)path;
|
||||
VG_RETURN_ERR_IF(!(p->caps & VG_PATH_CAPABILITY_PATH_BOUNDS),
|
||||
VG_PATH_CAPABILITY_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Update path geometry */
|
||||
shFlattenPath(p, 0);
|
||||
shFindBoundbox(p);
|
||||
|
||||
/* Output bounds */
|
||||
*minX = p->min.x;
|
||||
*minY = p->min.y;
|
||||
*width = p->max.x - p->min.x;
|
||||
*height = p->max.y - p->min.y;
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------
|
||||
* Outputs a bounding box of a path defined by its control
|
||||
* points that is guaranteed to enclose the path geometry
|
||||
* after applying the current path-user-to-surface transform
|
||||
*------------------------------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgPathTransformedBounds(VGPath path,
|
||||
VGfloat * minX, VGfloat * minY,
|
||||
VGfloat * width, VGfloat * height)
|
||||
{
|
||||
SHPath *p = NULL;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!shIsValidPath(context, path),
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(minX == NULL || minY == NULL ||
|
||||
width == NULL || height == NULL,
|
||||
VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* TODO: check output pointer alignment */
|
||||
|
||||
p = (SHPath*)path;
|
||||
VG_RETURN_ERR_IF(!(p->caps & VG_PATH_CAPABILITY_PATH_BOUNDS),
|
||||
VG_PATH_CAPABILITY_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Update path geometry */
|
||||
shFlattenPath(p, 1);
|
||||
shFindBoundbox(p);
|
||||
|
||||
/* Output bounds */
|
||||
*minX = p->min.x;
|
||||
*minY = p->min.y;
|
||||
*width = p->max.x - p->min.x;
|
||||
*height = p->max.y - p->min.y;
|
||||
|
||||
/* Invalidate subdivision for rendering */
|
||||
p->cacheDataValid = VG_FALSE;
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL VGfloat vgPathLength(VGPath path,
|
||||
VGint startSegment, VGint numSegments)
|
||||
{
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
VG_API_CALL void vgPointAlongPath(VGPath path,
|
||||
VGint startSegment, VGint numSegments,
|
||||
VGfloat distance,
|
||||
VGfloat * x, VGfloat * y,
|
||||
VGfloat * tangentX, VGfloat * tangentY)
|
||||
{
|
||||
}
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SH_GEOMETRY_H
|
||||
|
||||
#include "shDefs.h"
|
||||
#include "shContext.h"
|
||||
#include "shVectors.h"
|
||||
#include "shPath.h"
|
||||
|
||||
void shFlattenPath(SHPath *p, SHint surfaceSpace);
|
||||
void shStrokePath(VGContext* c, SHPath *p);
|
||||
void shTransformVertices(SHMatrix3x3 *m, SHPath *p);
|
||||
void shFindBoundbox(SHPath *p);
|
||||
|
||||
#endif /* __SH_GEOMETRY_H */
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,154 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHIMAGE_H
|
||||
#define __SHIMAGE_H
|
||||
|
||||
#include "shDefs.h"
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* ColorFormat holds the data necessary to pack/unpack color
|
||||
* components from a pixel of each supported image format
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
VGImageFormat vgformat;
|
||||
SHuint8 bytes;
|
||||
|
||||
SHuint32 rmask;
|
||||
SHuint8 rshift;
|
||||
SHuint8 rmax;
|
||||
|
||||
SHuint32 gmask;
|
||||
SHuint8 gshift;
|
||||
SHuint8 gmax;
|
||||
|
||||
SHuint32 bmask;
|
||||
SHuint8 bshift;
|
||||
SHuint8 bmax;
|
||||
|
||||
SHuint32 amask;
|
||||
SHuint8 ashift;
|
||||
SHuint8 amax;
|
||||
|
||||
GLenum glintformat;
|
||||
GLenum glformat;
|
||||
GLenum gltype;
|
||||
|
||||
} SHImageFormatDesc;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SHfloat r,g,b,a;
|
||||
|
||||
} SHColor;
|
||||
|
||||
void SHColor_ctor(SHColor *c);
|
||||
void SHColor_dtor(SHColor *c);
|
||||
|
||||
#define _ITEM_T SHColor
|
||||
#define _ARRAY_T SHColorArray
|
||||
#define _FUNC_T shColorArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SHuint8 *data;
|
||||
SHint width;
|
||||
SHint height;
|
||||
SHImageFormatDesc fd;
|
||||
|
||||
SHint texwidth;
|
||||
SHint texheight;
|
||||
SHfloat texwidthK;
|
||||
SHfloat texheightK;
|
||||
GLuint texture;
|
||||
|
||||
} SHImage;
|
||||
|
||||
void SHImage_ctor(SHImage *i);
|
||||
void SHImage_dtor(SHImage *i);
|
||||
|
||||
#define _ITEM_T SHImage*
|
||||
#define _ARRAY_T SHImageArray
|
||||
#define _FUNC_T shImageArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
/*-------------------------------------------------------
|
||||
* Color operators
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#define CSET(c, rr,gg,bb,aa) { c.r=rr; c.g=gg; c.b=bb; c.a=aa; }
|
||||
#define CSETC(c1, c2) { c1.r=c2.r; c1.g=c2.g; c1.b=c2.b; c1.a=c2.a; }
|
||||
|
||||
#define CSUB(c1, rr,gg,bb,aa) { c.r-=rr; c.g-=gg; c.b-=bb; c.a-=aa; }
|
||||
#define CSUBC(c1, c2) { c1.r-=c2.r; c1.g-=c2.g; c1.b-=c2.b; c1.a-=c2.a; }
|
||||
#define CSUBCTO(c1, c2, c3) { c3.r=c1.r-c2.r; c3.g=c1.g-c2.g; c3.b=c1.b-c2.b; c3.a=c1.a-c2.a; }
|
||||
|
||||
#define CADD(c1, rr,gg,bb,aa) { c.r+=rr; c.g+=gg; c.b+=bb; c.a+=aa; }
|
||||
#define CADDC(c1, c2) { c1.r+=c2.r; c1.g+=c2.g; c1.b+=c2.b; c1.a+=c2.a; }
|
||||
#define CADDTO(c1, c2, c3) { c3.r=c1.r+c2.r; c3.g=c1.g+c2.g; c3.b=c1.b+c2.b; c3.a=c1.a+c2.a; }
|
||||
#define CADDCK(c1, c2, k) { c1.r+=k*c2.r; c1.g+=k*c2.g; c1.b+=k*c2.b; c1.a+=k*c2.a; }
|
||||
|
||||
#define CMUL(c, s) { c.r*=s; c.g*=s; c.b*=s; c.a*=s; }
|
||||
#define CDIV(c, s) { c.r/=s; c.g/=s; c.b/=s; c.a/=s; }
|
||||
|
||||
#define CPREMUL(c) { c.r*=c.a; c.g*=c.a; c.b*=c.a; }
|
||||
#define CUNPREMUL(c) { c.r/=c.a; c.g/=c.a; c.b/=c.a; }
|
||||
|
||||
/*-------------------------------------------------------
|
||||
* Color-to-memory functions
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#define CSTORE_RGBA1D_8(c, rgba, x) { \
|
||||
rgba[x*4+0] = (SHuint8)SH_FLOOR(c.r * 255); \
|
||||
rgba[x*4+1] = (SHuint8)SH_FLOOR(c.g * 255); \
|
||||
rgba[x*4+2] = (SHuint8)SH_FLOOR(c.b * 255); \
|
||||
rgba[x*4+3] = (SHuint8)SH_FLOOR(c.a * 255); }
|
||||
|
||||
#define CSTORE_RGBA1D_F(c, rgba, x) { \
|
||||
rgba[x*4+0] = c.r; \
|
||||
rgba[x*4+1] = c.g; \
|
||||
rgba[x*4+2] = c.b; \
|
||||
rgba[x*4+3] = c.a; }
|
||||
|
||||
#define CSTORE_RGBA2D_8(c, rgba, x, y, width) { \
|
||||
rgba[y*width*4+x*4+0] = (SHuint8)SH_FLOOR(c.r * 255); \
|
||||
rgba[y*width*4+x*4+1] = (SHuint8)SH_FLOOR(c.g * 255); \
|
||||
rgba[y*width*4+x*4+2] = (SHuint8)SH_FLOOR(c.b * 255); \
|
||||
rgba[y*width*4+x*4+3] = (SHuint8)SH_FLOOR(c.a * 255); }
|
||||
|
||||
#define CSTORE_RGBA2D_F(c, rgba, x, y, width) { \
|
||||
rgba[y*width*4+x*4+0] = c.r; \
|
||||
rgba[y*width*4+x*4+1] = c.g; \
|
||||
rgba[y*width*4+x*4+2] = c.b; \
|
||||
rgba[y*width*4+x*4+3] = c.a; }
|
||||
|
||||
#define INT2COLCOORD(i, max) ( (SHfloat)i / (SHfloat)max )
|
||||
#define COL2INTCOORD(c, max) ( (SHuint)SH_FLOOR(c * (SHfloat)max + 0.5f) )
|
||||
|
||||
void shStoreColor(SHColor *c, void *data, SHImageFormatDesc *f);
|
||||
void shLoadColor(SHColor *c, const void *data, SHImageFormatDesc *f);
|
||||
|
||||
|
||||
#endif /* __SHIMAGE_H */
|
||||
|
|
@ -1,789 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <vg/openvg.h>
|
||||
#include "shContext.h"
|
||||
#include "shPaint.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#define _ITEM_T SHStop
|
||||
#define _ARRAY_T SHStopArray
|
||||
#define _FUNC_T shStopArray
|
||||
#define _COMPARE_T(s1,s2) 0
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#define _ITEM_T SHPaint*
|
||||
#define _ARRAY_T SHPaintArray
|
||||
#define _FUNC_T shPaintArray
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
|
||||
void SHPaint_ctor(SHPaint *p)
|
||||
{
|
||||
int i;
|
||||
|
||||
p->type = VG_PAINT_TYPE_COLOR;
|
||||
CSET(p->color, 0,0,0,1);
|
||||
SH_INITOBJ(SHStopArray, p->instops);
|
||||
SH_INITOBJ(SHStopArray, p->stops);
|
||||
p->premultiplied = VG_FALSE;
|
||||
p->spreadMode = VG_COLOR_RAMP_SPREAD_PAD;
|
||||
p->tilingMode = VG_TILE_FILL;
|
||||
for (i=0; i<4; ++i) p->linearGradient[i] = 0.0f;
|
||||
for (i=0; i<5; ++i) p->radialGradient[i] = 0.0f;
|
||||
p->pattern = VG_INVALID_HANDLE;
|
||||
|
||||
glGenTextures(1, &p->texture);
|
||||
glBindTexture(GL_TEXTURE_1D, p->texture);
|
||||
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, SH_GRADIENT_TEX_SIZE, 0,
|
||||
GL_RGBA, GL_FLOAT, NULL);
|
||||
}
|
||||
|
||||
void SHPaint_dtor(SHPaint *p)
|
||||
{
|
||||
SH_DEINITOBJ(SHStopArray, p->instops);
|
||||
SH_DEINITOBJ(SHStopArray, p->stops);
|
||||
|
||||
if (glIsTexture(p->texture))
|
||||
glDeleteTextures(1, &p->texture);
|
||||
}
|
||||
|
||||
VG_API_CALL VGPaint vgCreatePaint(void)
|
||||
{
|
||||
SHPaint *p = NULL;
|
||||
VG_GETCONTEXT(VG_INVALID_HANDLE);
|
||||
|
||||
/* Create new paint object */
|
||||
SH_NEWOBJ(SHPaint, p);
|
||||
VG_RETURN_ERR_IF(!p, VG_OUT_OF_MEMORY_ERROR,
|
||||
VG_INVALID_HANDLE);
|
||||
|
||||
/* Add to resource list */
|
||||
shPaintArrayPushBack(&context->paints, p);
|
||||
|
||||
VG_RETURN((VGPaint)p);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgDestroyPaint(VGPaint paint)
|
||||
{
|
||||
SHint index;
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
/* Check if handle valid */
|
||||
index = shPaintArrayFind(&context->paints, (SHPaint*)paint);
|
||||
VG_RETURN_ERR_IF(index == -1, VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Delete object and remove resource */
|
||||
SH_DELETEOBJ(SHPaint, (SHPaint*)paint);
|
||||
shPaintArrayRemoveAt(&context->paints, index);
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgSetPaint(VGPaint paint, VGbitfield paintModes)
|
||||
{
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
/* Check if handle valid */
|
||||
VG_RETURN_ERR_IF(!shIsValidPaint(context, paint) &&
|
||||
paint != VG_INVALID_HANDLE,
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Check for invalid mode */
|
||||
VG_RETURN_ERR_IF(paintModes & ~(VG_STROKE_PATH | VG_FILL_PATH),
|
||||
VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Set stroke / fill */
|
||||
if (paintModes & VG_STROKE_PATH)
|
||||
context->strokePaint = (SHPaint*)paint;
|
||||
if (paintModes & VG_FILL_PATH)
|
||||
context->fillPaint = (SHPaint*)paint;
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgPaintPattern(VGPaint paint, VGImage pattern)
|
||||
{
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
/* Check if handle valid */
|
||||
VG_RETURN_ERR_IF(!shIsValidPaint(context, paint),
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Check if pattern image valid */
|
||||
VG_RETURN_ERR_IF(!shIsValidImage(context, pattern),
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* TODO: Check if pattern image is current rendering target */
|
||||
|
||||
/* Set pattern image */
|
||||
((SHPaint*)paint)->pattern = pattern;
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
void shUpdateColorRampTexture(SHPaint *p)
|
||||
{
|
||||
SHint s=0;
|
||||
SHStop *stop1, *stop2;
|
||||
SHfloat rgba[SH_GRADIENT_TEX_COORDSIZE];
|
||||
SHint x1=0, x2=0, dx, x;
|
||||
SHColor dc, c;
|
||||
SHfloat k;
|
||||
|
||||
/* Write first pixel color */
|
||||
stop1 = &p->stops.items[0];
|
||||
CSTORE_RGBA1D_F(stop1->color, rgba, x1);
|
||||
|
||||
/* Walk stops */
|
||||
for (s=1; s<p->stops.size; ++s, x1=x2, stop1=stop2) {
|
||||
|
||||
/* Pick next stop */
|
||||
stop2 = &p->stops.items[s];
|
||||
x2 = (SHint)(stop2->offset * (SH_GRADIENT_TEX_SIZE-1));
|
||||
|
||||
SH_ASSERT(x1 >= 0 && x1 < SH_GRADIENT_TEX_SIZE &&
|
||||
x2 >= 0 && x2 < SH_GRADIENT_TEX_SIZE &&
|
||||
x1 <= x2);
|
||||
|
||||
dx = x2 - x1;
|
||||
CSUBCTO(stop2->color, stop1->color, dc);
|
||||
|
||||
/* Interpolate inbetween */
|
||||
for (x=x1+1; x<=x2; ++x) {
|
||||
|
||||
k = (SHfloat)(x-x1)/dx;
|
||||
CSETC(c, stop1->color);
|
||||
CADDCK(c, dc, k);
|
||||
CSTORE_RGBA1D_F(c, rgba, x);
|
||||
}
|
||||
}
|
||||
|
||||
/* Update texture image */
|
||||
glBindTexture(GL_TEXTURE_1D, p->texture);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexSubImage1D(GL_TEXTURE_1D, 0, 0, SH_GRADIENT_TEX_SIZE,
|
||||
GL_RGBA, GL_FLOAT, rgba);
|
||||
}
|
||||
|
||||
void shValidateInputStops(SHPaint *p)
|
||||
{
|
||||
SHStop *instop, stop;
|
||||
SHfloat lastOffset=0.0f;
|
||||
int i;
|
||||
|
||||
shStopArrayClear(&p->stops);
|
||||
shStopArrayReserve(&p->stops, p->instops.size);
|
||||
|
||||
/* Assure input stops are properly defined */
|
||||
for (i=0; i<p->instops.size; ++i) {
|
||||
|
||||
/* Copy stop color */
|
||||
instop = &p->instops.items[i];
|
||||
stop.color = instop->color;
|
||||
|
||||
/* Offset must be in [0,1] */
|
||||
if (instop->offset < 0.0f || instop->offset > 1.0f)
|
||||
continue;
|
||||
|
||||
/* Discard whole sequence if not in ascending order */
|
||||
if (instop->offset < lastOffset)
|
||||
{shStopArrayClear(&p->stops); break;}
|
||||
|
||||
/* Add stop at offset 0 with same color if first not at 0 */
|
||||
if (p->stops.size == 0 && instop->offset != 0.0f) {
|
||||
stop.offset = 0.0f;
|
||||
shStopArrayPushBackP(&p->stops, &stop);}
|
||||
|
||||
/* Add current stop to array */
|
||||
stop.offset = instop->offset;
|
||||
shStopArrayPushBackP(&p->stops, &stop);
|
||||
|
||||
/* Save last offset */
|
||||
lastOffset = instop->offset;
|
||||
}
|
||||
|
||||
/* Add stop at offset 1 with same color if last not at 1 */
|
||||
if (p->stops.size > 0 && lastOffset != 1.0f) {
|
||||
stop.offset = 1.0f;
|
||||
shStopArrayPushBackP(&p->stops, &stop);
|
||||
}
|
||||
|
||||
/* Add 2 default stops if no valid found */
|
||||
if (p->stops.size == 0) {
|
||||
/* First opaque black */
|
||||
stop.offset = 0.0f;
|
||||
CSET(stop.color, 0,0,0,1);
|
||||
shStopArrayPushBackP(&p->stops, &stop);
|
||||
/* Last opaque white */
|
||||
stop.offset = 1.0f;
|
||||
CSET(stop.color, 1,1,1,1);
|
||||
shStopArrayPushBackP(&p->stops, &stop);
|
||||
}
|
||||
|
||||
/* Update texture */
|
||||
shUpdateColorRampTexture(p);
|
||||
}
|
||||
|
||||
void shGenerateStops(SHPaint *p, SHfloat minOffset, SHfloat maxOffset,
|
||||
SHStopArray *outStops)
|
||||
{
|
||||
SHStop *s1,*s2;
|
||||
SHint i1,i2;
|
||||
SHfloat o=0.0f;
|
||||
SHfloat ostep=0.0f;
|
||||
SHint istep=1;
|
||||
SHint istart=0;
|
||||
SHint iend=p->stops.size-1;
|
||||
SHint minDone=0;
|
||||
SHint maxDone=0;
|
||||
SHStop outStop;
|
||||
|
||||
/* Start below zero? */
|
||||
if (minOffset < 0.0f) {
|
||||
if (p->spreadMode == VG_COLOR_RAMP_SPREAD_PAD) {
|
||||
/* Add min offset stop */
|
||||
outStop = p->stops.items[0];
|
||||
outStop.offset = minOffset;
|
||||
shStopArrayPushBackP(outStops, &outStop);
|
||||
/* Add max offset stop and exit */
|
||||
if (maxOffset < 0.0f) {
|
||||
outStop.offset = maxOffset;
|
||||
shStopArrayPushBackP(outStops, &outStop);
|
||||
return; }
|
||||
}else{
|
||||
/* Pad starting offset to nearest factor of 2 */
|
||||
SHint ioff = (SHint)SH_FLOOR(minOffset);
|
||||
o = (SHfloat)(ioff - (ioff & 1));
|
||||
}
|
||||
}
|
||||
|
||||
/* Construct stops until max offset reached */
|
||||
for (i1=istart, i2=istart+istep; maxDone!=1;
|
||||
i1+=istep, i2+=istep, o+=ostep) {
|
||||
|
||||
/* All stops consumed? */
|
||||
if (i1==iend) { switch(p->spreadMode) {
|
||||
|
||||
case VG_COLOR_RAMP_SPREAD_PAD:
|
||||
/* Pick last stop */
|
||||
outStop = p->stops.items[i1];
|
||||
if (!minDone) {
|
||||
/* Add min offset stop with last color */
|
||||
outStop.offset = minOffset;
|
||||
shStopArrayPushBackP(outStops, &outStop); }
|
||||
/* Add max offset stop with last color */
|
||||
outStop.offset = maxOffset;
|
||||
shStopArrayPushBackP(outStops, &outStop);
|
||||
return;
|
||||
|
||||
case VG_COLOR_RAMP_SPREAD_REPEAT:
|
||||
/* Reset iteration */
|
||||
i1=istart; i2=istart+istep;
|
||||
/* Add stop1 if past min offset */
|
||||
if (minDone) {
|
||||
outStop = p->stops.items[0];
|
||||
outStop.offset = o;
|
||||
shStopArrayPushBackP(outStops, &outStop); }
|
||||
break;
|
||||
|
||||
case VG_COLOR_RAMP_SPREAD_REFLECT:
|
||||
/* Reflect iteration direction */
|
||||
istep = -istep;
|
||||
i2 = i1 + istep;
|
||||
iend = (istep==1) ? p->stops.size-1 : 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* 2 stops and their offset distance */
|
||||
s1 = &p->stops.items[i1];
|
||||
s2 = &p->stops.items[i2];
|
||||
ostep = s2->offset - s1->offset;
|
||||
ostep = SH_ABS(ostep);
|
||||
|
||||
/* Add stop1 if reached min offset */
|
||||
if (!minDone && o+ostep > minOffset) {
|
||||
minDone = 1;
|
||||
outStop = *s1;
|
||||
outStop.offset = o;
|
||||
shStopArrayPushBackP(outStops, &outStop);
|
||||
}
|
||||
|
||||
/* Mark done if reached max offset */
|
||||
if (o+ostep > maxOffset)
|
||||
maxDone = 1;
|
||||
|
||||
/* Add stop2 if past min offset */
|
||||
if (minDone) {
|
||||
outStop = *s2;
|
||||
outStop.offset = o+ostep;
|
||||
shStopArrayPushBackP(outStops, &outStop);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void shSetGradientTexGLState(SHPaint *p)
|
||||
{
|
||||
glBindTexture(GL_TEXTURE_1D, p->texture);
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
|
||||
switch (p->spreadMode) {
|
||||
case VG_COLOR_RAMP_SPREAD_PAD:
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); break;
|
||||
case VG_COLOR_RAMP_SPREAD_REPEAT:
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT); break;
|
||||
case VG_COLOR_RAMP_SPREAD_REFLECT:
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); break;
|
||||
}
|
||||
|
||||
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
glColor4f(1,1,1,1);
|
||||
}
|
||||
|
||||
void shSetPatternTexGLState(SHPaint *p, VGContext *c)
|
||||
{
|
||||
glBindTexture(GL_TEXTURE_2D, ((SHImage*)p->pattern)->texture);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
|
||||
switch(p->tilingMode) {
|
||||
case VG_TILE_FILL:
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
|
||||
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR,
|
||||
(GLfloat*)&c->tileFillColor);
|
||||
break;
|
||||
case VG_TILE_PAD:
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
break;
|
||||
case VG_TILE_REPEAT:
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
break;
|
||||
case VG_TILE_REFLECT:
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
|
||||
break;
|
||||
}
|
||||
|
||||
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
glColor4f(1,1,1,1);
|
||||
}
|
||||
|
||||
int shDrawLinearGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit)
|
||||
{
|
||||
SHint i;
|
||||
SHfloat n;
|
||||
|
||||
SHfloat x1 = p->linearGradient[0];
|
||||
SHfloat y1 = p->linearGradient[1];
|
||||
SHfloat x2 = p->linearGradient[2];
|
||||
SHfloat y2 = p->linearGradient[3];
|
||||
SHVector2 c, ux, uy;
|
||||
SHVector2 cc, uux, uuy;
|
||||
|
||||
SHMatrix3x3 *m = 0;
|
||||
SHMatrix3x3 mi;
|
||||
SHint invertible;
|
||||
SHVector2 corners[4];
|
||||
SHfloat minOffset = 0.0f;
|
||||
SHfloat maxOffset = 0.0f;
|
||||
SHfloat left = 0.0f;
|
||||
SHfloat right = 0.0f;
|
||||
SHVector2 l1,r1,l2,r2;
|
||||
|
||||
/* Pick paint transform matrix */
|
||||
SH_GETCONTEXT(0);
|
||||
if (mode == VG_FILL_PATH)
|
||||
m = &context->fillTransform;
|
||||
else if (mode == VG_STROKE_PATH)
|
||||
m = &context->strokeTransform;
|
||||
|
||||
/* Gradient center and unit vectors */
|
||||
SET2(c, x1, y1);
|
||||
SET2(ux, x2-x1, y2-y1);
|
||||
SET2(uy, -ux.y, ux.x);
|
||||
n = NORM2(ux);
|
||||
DIV2(ux, n);
|
||||
NORMALIZE2(uy);
|
||||
|
||||
/* Apply paint-to-user transformation */
|
||||
ADD2V(ux, c); ADD2V(uy, c);
|
||||
TRANSFORM2TO(c, (*m), cc);
|
||||
TRANSFORM2TO(ux, (*m), uux);
|
||||
TRANSFORM2TO(uy, (*m), uuy);
|
||||
SUB2V(ux,c); SUB2V(uy,c);
|
||||
SUB2V(uux,cc); SUB2V(uuy,cc);
|
||||
|
||||
/* Boundbox corners */
|
||||
SET2(corners[0], min->x, min->y);
|
||||
SET2(corners[1], max->x, min->y);
|
||||
SET2(corners[2], max->x, max->y);
|
||||
SET2(corners[3], min->x, max->y);
|
||||
|
||||
/* Find inverse transformation (back to paint space) */
|
||||
invertible = shInvertMatrix(m, &mi);
|
||||
if (!invertible || n==0.0f) {
|
||||
|
||||
/* Fill boundbox with color at offset 1 */
|
||||
SHColor *c = &p->stops.items[p->stops.size-1].color;
|
||||
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
|
||||
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
|
||||
glEnd();
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------*/
|
||||
|
||||
for (i=0; i<4; ++i) {
|
||||
|
||||
/* Find min/max offset and perpendicular span */
|
||||
SHfloat o, s;
|
||||
TRANSFORM2(corners[i], mi);
|
||||
SUB2V(corners[i], c);
|
||||
o = DOT2(corners[i], ux) / n;
|
||||
s = DOT2(corners[i], uy);
|
||||
if (o < minOffset || i==0) minOffset = o;
|
||||
if (o > maxOffset || i==0) maxOffset = o;
|
||||
if (s < left || i==0) left = s;
|
||||
if (s > right || i==0) right = s;
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*/
|
||||
|
||||
/* Corners of boundbox in gradient system */
|
||||
SET2V(l1, cc); SET2V(r1, cc);
|
||||
SET2V(l2, cc); SET2V(r2, cc);
|
||||
OFFSET2V(l1, uuy, left); OFFSET2V(l1, uux, minOffset * n);
|
||||
OFFSET2V(r1, uuy, right); OFFSET2V(r1, uux, minOffset * n);
|
||||
OFFSET2V(l2, uuy, left); OFFSET2V(l2, uux, maxOffset * n);
|
||||
OFFSET2V(r2, uuy, right); OFFSET2V(r2, uux, maxOffset * n);
|
||||
|
||||
/* Draw quad using color-ramp texture */
|
||||
glActiveTexture(texUnit);
|
||||
shSetGradientTexGLState(p);
|
||||
|
||||
glEnable(GL_TEXTURE_1D);
|
||||
glBegin(GL_QUAD_STRIP);
|
||||
|
||||
glMultiTexCoord1f(texUnit, minOffset);
|
||||
glVertex2fv((GLfloat*)&r1);
|
||||
glVertex2fv((GLfloat*)&l1);
|
||||
|
||||
glMultiTexCoord1f(texUnit, maxOffset);
|
||||
glVertex2fv((GLfloat*)&r2);
|
||||
glVertex2fv((GLfloat*)&l2);
|
||||
|
||||
glEnd();
|
||||
glDisable(GL_TEXTURE_1D);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int shDrawRadialGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit)
|
||||
{
|
||||
SHint i, j;
|
||||
float a, n;
|
||||
|
||||
SHfloat cx = p->radialGradient[0];
|
||||
SHfloat cy = p->radialGradient[1];
|
||||
SHfloat fx = p->radialGradient[2];
|
||||
SHfloat fy = p->radialGradient[3];
|
||||
float r = p->radialGradient[4];
|
||||
float fcx, fcy, rr, C;
|
||||
|
||||
SHVector2 ux;
|
||||
SHVector2 uy;
|
||||
SHVector2 c, f;
|
||||
SHVector2 cf;
|
||||
|
||||
SHMatrix3x3 *m = 0;
|
||||
SHMatrix3x3 mi;
|
||||
SHint invertible;
|
||||
SHVector2 corners[4];
|
||||
SHVector2 fcorners[4];
|
||||
SHfloat minOffset=0.0f;
|
||||
SHfloat maxOffset=0.0f;
|
||||
|
||||
SHint maxI=0, maxJ=0;
|
||||
SHfloat maxA=0.0f;
|
||||
SHfloat startA=0.0f;
|
||||
|
||||
int numsteps = 100;
|
||||
float step = 2*PI/numsteps;
|
||||
SHVector2 tmin, tmax;
|
||||
SHVector2 min1, max1, min2, max2;
|
||||
|
||||
/* Pick paint transform matrix */
|
||||
SH_GETCONTEXT(0);
|
||||
if (mode == VG_FILL_PATH)
|
||||
m = &context->fillTransform;
|
||||
else if (mode == VG_STROKE_PATH)
|
||||
m = &context->strokeTransform;
|
||||
|
||||
/* Move focus into circle if outside */
|
||||
SET2(cf, fx,fy);
|
||||
SUB2(cf, cx,cy);
|
||||
n = NORM2(cf);
|
||||
if (n > r) {
|
||||
DIV2(cf, n);
|
||||
fx = cx + 0.995f * r * cf.x;
|
||||
fy = cy + 0.995f * r * cf.y;
|
||||
}
|
||||
|
||||
/* Precalculations */
|
||||
rr = r*r;
|
||||
fcx = fx - cx;
|
||||
fcy = fy - cy;
|
||||
C = fcx*fcx + fcy*fcy - rr;
|
||||
|
||||
/* Apply paint-to-user transformation
|
||||
to focus and unit vectors */
|
||||
SET2(f, fx, fy);
|
||||
SET2(c, cx, cy);
|
||||
SET2(ux, 1, 0);
|
||||
SET2(uy, 0, 1);
|
||||
ADD2(ux, cx, cy);
|
||||
ADD2(uy, cx, cy);
|
||||
TRANSFORM2(f, (*m));
|
||||
TRANSFORM2(c, (*m));
|
||||
TRANSFORM2(ux, (*m));
|
||||
TRANSFORM2(uy, (*m));
|
||||
SUB2V(ux, c); SUB2V(uy, c);
|
||||
|
||||
/* Boundbox corners */
|
||||
SET2(corners[0], min->x, min->y);
|
||||
SET2(corners[1], max->x, min->y);
|
||||
SET2(corners[2], max->x, max->y);
|
||||
SET2(corners[3], min->x, max->y);
|
||||
|
||||
/* Find inverse transformation (back to paint space) */
|
||||
invertible = shInvertMatrix(m, &mi);
|
||||
if (!invertible || r <= 0.0f) {
|
||||
|
||||
/* Fill boundbox with color at offset 1 */
|
||||
SHColor *c = &p->stops.items[p->stops.size-1].color;
|
||||
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
|
||||
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
|
||||
glEnd();
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------*/
|
||||
|
||||
/* Find min/max offset */
|
||||
for (i=0; i<4; ++i) {
|
||||
|
||||
/* Transform to paint space */
|
||||
SHfloat ax,ay, A,B,D,t, off;
|
||||
TRANSFORM2TO(corners[i], mi, fcorners[i]);
|
||||
SUB2(fcorners[i], fx, fy);
|
||||
n = NORM2(fcorners[i]);
|
||||
if (n == 0.0f) {
|
||||
|
||||
/* Avoid zero-length vectors */
|
||||
off = 0.0f;
|
||||
|
||||
}else{
|
||||
|
||||
/* Distance from focus to circle at corner angle */
|
||||
DIV2(fcorners[i], n);
|
||||
ax = fcorners[i].x;
|
||||
ay = fcorners[i].y;
|
||||
A = ax*ax + ay*ay;
|
||||
B = 2 * (fcx*ax + fcy*ay);
|
||||
D = B*B - 4*A*C;
|
||||
t = (-B + SH_SQRT(D)) / (2*A);
|
||||
|
||||
/* Relative offset of boundbox corner */
|
||||
if (D <= 0.0f) off = 1.0f;
|
||||
else off = n / t;
|
||||
}
|
||||
|
||||
/* Find smallest and largest offset */
|
||||
if (off < minOffset || i==0) minOffset = off;
|
||||
if (off > maxOffset || i==0) maxOffset = off;
|
||||
}
|
||||
|
||||
/* Is transformed focus inside original boundbox? */
|
||||
if (f.x >= min->x && f.x <= max->x &&
|
||||
f.y >= min->y && f.y <= max->y) {
|
||||
|
||||
/* Draw whole circle */
|
||||
minOffset = 0.0f;
|
||||
startA = 0.0f;
|
||||
maxA = 2*PI;
|
||||
|
||||
}else{
|
||||
|
||||
/* Find most distant corner pair */
|
||||
for (i=0; i<3; ++i) {
|
||||
if (ISZERO2(fcorners[i])) continue;
|
||||
for (j=i+1; j<4; ++j) {
|
||||
if (ISZERO2(fcorners[j])) continue;
|
||||
a = ANGLE2N(fcorners[i], fcorners[j]);
|
||||
if (a > maxA || maxA == 0.0f)
|
||||
{maxA=a; maxI=i; maxJ=j;}
|
||||
}}
|
||||
|
||||
/* Pick starting angle */
|
||||
if (CROSS2(fcorners[maxI],fcorners[maxJ]) > 0.0f)
|
||||
startA = shVectorOrientation(&fcorners[maxI]);
|
||||
else startA = shVectorOrientation(&fcorners[maxJ]);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------*/
|
||||
|
||||
/* TODO: for minOffset we'd actually need to find minimum
|
||||
of the gradient function when X and Y are substitued
|
||||
with a line equation for each bound-box edge. As a
|
||||
workaround we use 0.0f for now. */
|
||||
minOffset = 0.0f;
|
||||
step = PI/50;
|
||||
numsteps = (SHint)SH_CEIL(maxA / step) + 1;
|
||||
|
||||
glActiveTexture(texUnit);
|
||||
shSetGradientTexGLState(p);
|
||||
|
||||
glEnable(GL_TEXTURE_1D);
|
||||
glBegin(GL_QUADS);
|
||||
|
||||
/* Walk the steps and draw gradient mesh */
|
||||
for (i=0, a=startA; i<numsteps; ++i, a+=step) {
|
||||
|
||||
/* Distance from focus to circle border
|
||||
at current angle (gradient space) */
|
||||
float ax = SH_COS(a);
|
||||
float ay = SH_SIN(a);
|
||||
float A = ax*ax + ay*ay;
|
||||
float B = 2 * (fcx*ax + fcy*ay);
|
||||
float D = B*B - 4*A*C;
|
||||
float t = (-B + SH_SQRT(D)) / (2*A);
|
||||
if (D <= 0.0f) t = 0.0f;
|
||||
|
||||
/* Vectors pointing towards minimum and maximum
|
||||
offset at current angle (gradient space) */
|
||||
tmin.x = ax * t * minOffset;
|
||||
tmin.y = ay * t * minOffset;
|
||||
tmax.x = ax * t * maxOffset;
|
||||
tmax.y = ay * t * maxOffset;
|
||||
|
||||
/* Transform back to user space */
|
||||
min2.x = f.x + tmin.x * ux.x + tmin.y * uy.x;
|
||||
min2.y = f.y + tmin.x * ux.y + tmin.y * uy.y;
|
||||
max2.x = f.x + tmax.x * ux.x + tmax.y * uy.x;
|
||||
max2.y = f.y + tmax.x * ux.y + tmax.y * uy.y;
|
||||
|
||||
/* Draw quad */
|
||||
if (i!=0) {
|
||||
glMultiTexCoord1f(texUnit, minOffset);
|
||||
glVertex2fv((GLfloat*)&min1);
|
||||
glVertex2fv((GLfloat*)&min2);
|
||||
glMultiTexCoord1f(texUnit, maxOffset);
|
||||
glVertex2fv((GLfloat*)&max2);
|
||||
glVertex2fv((GLfloat*)&max1);
|
||||
}
|
||||
|
||||
/* Save prev points */
|
||||
min1 = min2;
|
||||
max1 = max2;
|
||||
}
|
||||
|
||||
glEnd();
|
||||
glDisable(GL_TEXTURE_1D);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int shDrawPatternMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit)
|
||||
{
|
||||
SHMatrix3x3 *m = 0;
|
||||
SHMatrix3x3 mi;
|
||||
SHfloat migl[16];
|
||||
SHint invertible;
|
||||
SHVector2 corners[4];
|
||||
VGfloat sx, sy;
|
||||
SHImage *img;
|
||||
int i;
|
||||
|
||||
/* Pick paint transform matrix */
|
||||
SH_GETCONTEXT(0);
|
||||
if (mode == VG_FILL_PATH)
|
||||
m = &context->fillTransform;
|
||||
else if (mode == VG_STROKE_PATH)
|
||||
m = &context->strokeTransform;
|
||||
|
||||
/* Boundbox corners */
|
||||
SET2(corners[0], min->x, min->y);
|
||||
SET2(corners[1], max->x, min->y);
|
||||
SET2(corners[2], max->x, max->y);
|
||||
SET2(corners[3], min->x, max->y);
|
||||
|
||||
/* Find inverse transformation (back to paint space) */
|
||||
invertible = shInvertMatrix(m, &mi);
|
||||
if (!invertible) {
|
||||
|
||||
/* Fill boundbox with tile fill color */
|
||||
SHColor *c = &context->tileFillColor;
|
||||
glColor4fv((GLfloat*)c); glBegin(GL_QUADS);
|
||||
for (i=0; i<4; ++i) glVertex2fv((GLfloat*)&corners[i]);
|
||||
glEnd();
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/* Setup texture coordinate transform */
|
||||
img = (SHImage*)p->pattern;
|
||||
sx = 1.0f/(VGfloat)img->texwidth;
|
||||
sy = 1.0f/(VGfloat)img->texheight;
|
||||
|
||||
glActiveTexture(texUnit);
|
||||
shMatrixToGL(&mi, migl);
|
||||
glMatrixMode(GL_TEXTURE);
|
||||
glPushMatrix();
|
||||
glScalef(sx, sy, 1.0f);
|
||||
glMultMatrixf(migl);
|
||||
|
||||
|
||||
/* Draw boundbox with same texture coordinates
|
||||
that will get transformed back to paint space */
|
||||
shSetPatternTexGLState(p, context);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glBegin(GL_QUADS);
|
||||
|
||||
for (i=0; i<4; ++i) {
|
||||
glMultiTexCoord2f(texUnit, corners[i].x, corners[i].y);
|
||||
glVertex2fv((GLfloat*)&corners[i]);
|
||||
}
|
||||
|
||||
glEnd();
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glPopMatrix();
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,82 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHPAINT_H
|
||||
#define __SHPAINT_H
|
||||
|
||||
#include "shDefs.h"
|
||||
#include "shArrays.h"
|
||||
#include "shImage.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
float offset;
|
||||
SHColor color;
|
||||
|
||||
} SHStop;
|
||||
|
||||
#define _ITEM_T SHStop
|
||||
#define _ARRAY_T SHStopArray
|
||||
#define _FUNC_T shStopArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
VGPaintType type;
|
||||
SHColor color;
|
||||
SHColorArray colors;
|
||||
SHStopArray instops;
|
||||
SHStopArray stops;
|
||||
VGboolean premultiplied;
|
||||
VGColorRampSpreadMode spreadMode;
|
||||
VGTilingMode tilingMode;
|
||||
SHfloat linearGradient[4];
|
||||
SHfloat radialGradient[5];
|
||||
GLuint texture;
|
||||
VGImage pattern;
|
||||
|
||||
} SHPaint;
|
||||
|
||||
#define SH_GRADIENT_TEX_SIZE 1024
|
||||
|
||||
void SHPaint_ctor(SHPaint *p);
|
||||
void SHPaint_dtor(SHPaint *p);
|
||||
|
||||
#define _ITEM_T SHPaint*
|
||||
#define _ARRAY_T SHPaintArray
|
||||
#define _FUNC_T shPaintArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
void shValidateInputStops(SHPaint *p);
|
||||
void shSetGradientTexGLState(SHPaint *p);
|
||||
|
||||
int shDrawLinearGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit);
|
||||
|
||||
int shDrawRadialGradientMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit);
|
||||
|
||||
int shDrawPatternMesh(SHPaint *p, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit);
|
||||
|
||||
|
||||
#endif /* __SHPAINT_H */
|
||||
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
|
@ -1,142 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHPATH_H
|
||||
#define __SHPATH_H
|
||||
|
||||
#include "shVectors.h"
|
||||
#include "shArrays.h"
|
||||
|
||||
/* Helper structures for subdivision */
|
||||
typedef struct {
|
||||
SHVector2 p1;
|
||||
SHVector2 p2;
|
||||
SHVector2 p3;
|
||||
} SHQuad;
|
||||
|
||||
typedef struct {
|
||||
SHVector2 p1;
|
||||
SHVector2 p2;
|
||||
SHVector2 p3;
|
||||
SHVector2 p4;
|
||||
} SHCubic;
|
||||
|
||||
typedef struct {
|
||||
SHVector2 p1;
|
||||
SHVector2 p2;
|
||||
SHfloat a1;
|
||||
SHfloat a2;
|
||||
} SHArc;
|
||||
|
||||
/* SHVertex */
|
||||
typedef struct
|
||||
{
|
||||
SHVector2 point;
|
||||
SHVector2 tangent;
|
||||
SHfloat length;
|
||||
SHuint flags;
|
||||
|
||||
} SHVertex;
|
||||
|
||||
/* Vertex flags for contour definition */
|
||||
#define SH_VERTEX_FLAG_CLOSE (1 << 0)
|
||||
#define SH_VERTEX_FLAG_SEGEND (1 << 1)
|
||||
#define SH_SEGMENT_TYPE_COUNT 13
|
||||
|
||||
/* Vertex array */
|
||||
#define _ITEM_T SHVertex
|
||||
#define _ARRAY_T SHVertexArray
|
||||
#define _FUNC_T shVertexArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
|
||||
/* SHPath */
|
||||
typedef struct SHPath
|
||||
{
|
||||
/* Properties */
|
||||
VGint format;
|
||||
SHfloat scale;
|
||||
SHfloat bias;
|
||||
SHint segHint;
|
||||
SHint dataHint;
|
||||
VGbitfield caps;
|
||||
VGPathDatatype datatype;
|
||||
|
||||
/* Raw data */
|
||||
SHuint8 *segs;
|
||||
void *data;
|
||||
SHint segCount;
|
||||
SHint dataCount;
|
||||
|
||||
/* Subdivision */
|
||||
SHVertexArray vertices;
|
||||
SHVector2 min, max;
|
||||
|
||||
/* Additional stroke geometry (dash vertices if
|
||||
path dashed or triangle vertices if width > 1 */
|
||||
SHVector2Array stroke;
|
||||
|
||||
/* Cache */
|
||||
VGboolean cacheDataValid;
|
||||
|
||||
VGboolean cacheTransformInit;
|
||||
SHMatrix3x3 cacheTransform;
|
||||
|
||||
VGboolean cacheStrokeInit;
|
||||
VGboolean cacheStrokeTessValid;
|
||||
SHfloat cacheStrokeLineWidth;
|
||||
VGCapStyle cacheStrokeCapStyle;
|
||||
VGJoinStyle cacheStrokeJoinStyle;
|
||||
SHfloat cacheStrokeMiterLimit;
|
||||
SHfloat cacheStrokeDashPhase;
|
||||
VGboolean cacheStrokeDashPhaseReset;
|
||||
|
||||
} SHPath;
|
||||
|
||||
void SHPath_ctor(SHPath *p);
|
||||
void SHPath_dtor(SHPath *p);
|
||||
|
||||
|
||||
/* Processing normalization flags */
|
||||
#define SH_PROCESS_SIMPLIFY_LINES (1 << 0)
|
||||
#define SH_PROCESS_SIMPLIFY_CURVES (1 << 1)
|
||||
#define SH_PROCESS_CENTRALIZE_ARCS (1 << 2)
|
||||
#define SH_PROCESS_REPAIR_ENDS (1 << 3)
|
||||
|
||||
/* Segment callback function type */
|
||||
typedef void (*SegmentFunc) (SHPath *p, VGPathSegment segment,
|
||||
VGPathCommand originalCommand,
|
||||
SHfloat *data, void *userData);
|
||||
|
||||
/* Processes raw path data into normalized segments */
|
||||
void shProcessPathData(SHPath *p, int flags,
|
||||
SegmentFunc callback,
|
||||
void *userData);
|
||||
|
||||
|
||||
/* Pointer-to-path array */
|
||||
#define _ITEM_T SHPath*
|
||||
#define _ARRAY_T SHPathArray
|
||||
#define _FUNC_T shPathArray
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
#endif /* __SHPATH_H */
|
||||
|
|
@ -1,595 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <vg/openvg.h>
|
||||
#include "shDefs.h"
|
||||
#include "shExtensions.h"
|
||||
#include "shContext.h"
|
||||
#include "shPath.h"
|
||||
#include "shImage.h"
|
||||
#include "shGeometry.h"
|
||||
#include "shPaint.h"
|
||||
|
||||
void shPremultiplyFramebuffer()
|
||||
{
|
||||
/* Multiply target color with its own alpha */
|
||||
glBlendFunc(GL_ZERO, GL_DST_ALPHA);
|
||||
}
|
||||
|
||||
void shUnpremultiplyFramebuffer()
|
||||
{
|
||||
/* TODO: hmmmm..... any idea? */
|
||||
}
|
||||
|
||||
void updateBlendingStateGL(VGContext *c, int alphaIsOne)
|
||||
{
|
||||
/* Most common drawing mode (SRC_OVER with alpha=1)
|
||||
as well as SRC is optimized by turning OpenGL
|
||||
blending off. In other cases its turned on. */
|
||||
|
||||
switch (c->blendMode)
|
||||
{
|
||||
case VG_BLEND_SRC:
|
||||
glBlendFunc(GL_ONE, GL_ZERO);
|
||||
glDisable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_SRC_IN:
|
||||
glBlendFunc(GL_DST_ALPHA, GL_ZERO);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_DST_IN:
|
||||
glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_SRC_OUT_SH:
|
||||
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_DST_OUT_SH:
|
||||
glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_SRC_ATOP_SH:
|
||||
glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_DST_ATOP_SH:
|
||||
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_DST_OVER:
|
||||
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
|
||||
glEnable(GL_BLEND); break;
|
||||
|
||||
case VG_BLEND_SRC_OVER: default:
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
if (alphaIsOne) glDisable(GL_BLEND);
|
||||
else glEnable(GL_BLEND); break;
|
||||
};
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Draws the triangles representing the stroke of a path.
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
static void shDrawStroke(SHPath *p)
|
||||
{
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glVertexPointer(2, GL_FLOAT, 0, p->stroke.items);
|
||||
glDrawArrays(GL_TRIANGLES, 0, p->stroke.size);
|
||||
glDisableClientState(GL_VERTEX_ARRAY);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Draws the subdivided vertices in the OpenGL mode given
|
||||
* (this could be VG_TRIANGLE_FAN or VG_LINE_STRIP).
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
static void shDrawVertices(SHPath *p, GLenum mode)
|
||||
{
|
||||
int start = 0;
|
||||
int size = 0;
|
||||
|
||||
/* We separate vertex arrays by contours to properly
|
||||
handle the fill modes */
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glVertexPointer(2, GL_FLOAT, sizeof(SHVertex), p->vertices.items);
|
||||
|
||||
while (start < p->vertices.size) {
|
||||
size = p->vertices.items[start].flags;
|
||||
glDrawArrays(mode, start, size);
|
||||
start += size;
|
||||
}
|
||||
|
||||
glDisableClientState(GL_VERTEX_ARRAY);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------
|
||||
* Draw a single quad that covers the bounding box of a path
|
||||
*-------------------------------------------------------------*/
|
||||
|
||||
static void shDrawBoundBox(VGContext *c, SHPath *p, VGPaintMode mode)
|
||||
{
|
||||
SHfloat K = 1.0f;
|
||||
if (mode == VG_STROKE_PATH)
|
||||
K = SH_CEIL(c->strokeMiterLimit * c->strokeLineWidth) + 1.0f;
|
||||
|
||||
glBegin(GL_QUADS);
|
||||
glVertex2f(p->min.x-K, p->min.y-K);
|
||||
glVertex2f(p->max.x+K, p->min.y-K);
|
||||
glVertex2f(p->max.x+K, p->max.y+K);
|
||||
glVertex2f(p->min.x-K, p->max.y+K);
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/*--------------------------------------------------------------
|
||||
* Constructs & draws colored OpenGL primitives that cover the
|
||||
* given bounding box to represent the currently selected
|
||||
* stroke or fill paint
|
||||
*--------------------------------------------------------------*/
|
||||
|
||||
static void shDrawPaintMesh(VGContext *c, SHVector2 *min, SHVector2 *max,
|
||||
VGPaintMode mode, GLenum texUnit)
|
||||
{
|
||||
SHPaint *p = 0;
|
||||
SHVector2 pmin, pmax;
|
||||
SHfloat K = 1.0f;
|
||||
|
||||
/* Pick the right paint */
|
||||
if (mode == VG_FILL_PATH) {
|
||||
p = (c->fillPaint ? c->fillPaint : &c->defaultPaint);
|
||||
}else if (mode == VG_STROKE_PATH) {
|
||||
p = (c->strokePaint ? c->strokePaint : &c->defaultPaint);
|
||||
K = SH_CEIL(c->strokeMiterLimit * c->strokeLineWidth) + 1.0f;
|
||||
}
|
||||
|
||||
/* We want to be sure to cover every pixel of this path so better
|
||||
take a pixel more than leave some out (multisampling is tricky). */
|
||||
SET2V(pmin, (*min)); SUB2(pmin, K,K);
|
||||
SET2V(pmax, (*max)); ADD2(pmax, K,K);
|
||||
|
||||
/* Construct appropriate OpenGL primitives so as
|
||||
to fill the stencil mask with select paint */
|
||||
|
||||
switch (p->type) {
|
||||
case VG_PAINT_TYPE_LINEAR_GRADIENT:
|
||||
shDrawLinearGradientMesh(p, min, max, mode, texUnit);
|
||||
break;
|
||||
|
||||
case VG_PAINT_TYPE_RADIAL_GRADIENT:
|
||||
shDrawRadialGradientMesh(p, min, max, mode, texUnit);
|
||||
break;
|
||||
|
||||
case VG_PAINT_TYPE_PATTERN:
|
||||
if (p->pattern != VG_INVALID_HANDLE) {
|
||||
shDrawPatternMesh(p, min, max, mode, texUnit);
|
||||
break;
|
||||
}/* else behave as a color paint */
|
||||
|
||||
case VG_PAINT_TYPE_COLOR:
|
||||
glColor4fv((GLfloat*)&p->color);
|
||||
glBegin(GL_QUADS);
|
||||
glVertex2f(pmin.x, pmin.y);
|
||||
glVertex2f(pmax.x, pmin.y);
|
||||
glVertex2f(pmax.x, pmax.y);
|
||||
glVertex2f(pmin.x, pmax.y);
|
||||
glEnd();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
VGboolean shIsTessCacheValid (VGContext *c, SHPath *p)
|
||||
{
|
||||
SHfloat nX, nY;
|
||||
SHVector2 X, Y;
|
||||
SHMatrix3x3 mi;//, mchange;
|
||||
VGboolean valid = VG_TRUE;
|
||||
|
||||
if (p->cacheDataValid == VG_FALSE) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
else if (p->cacheTransformInit == VG_FALSE) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
else if (shInvertMatrix( &p->cacheTransform, &mi ) == VG_FALSE) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* TODO: Compare change matrix for any scale or shear */
|
||||
// MULMATMAT( c->pathTransform, mi, mchange );
|
||||
SET2( X, mi.m[0][0], mi.m[1][0] );
|
||||
SET2( Y, mi.m[0][1], mi.m[1][1] );
|
||||
nX = NORM2( X ); nY = NORM2( Y );
|
||||
if (nX > 1.01f || nX < 0.99 ||
|
||||
nY > 1.01f || nY < 0.99)
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
|
||||
if (valid == VG_FALSE)
|
||||
{
|
||||
/* Update cache */
|
||||
p->cacheDataValid = VG_TRUE;
|
||||
p->cacheTransformInit = VG_TRUE;
|
||||
p->cacheTransform = c->pathTransform;
|
||||
p->cacheStrokeTessValid = VG_FALSE;
|
||||
}
|
||||
|
||||
return valid;
|
||||
}
|
||||
|
||||
VGboolean shIsStrokeCacheValid (VGContext *c, SHPath *p)
|
||||
{
|
||||
VGboolean valid = VG_TRUE;
|
||||
|
||||
if (p->cacheStrokeInit == VG_FALSE) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
else if (p->cacheStrokeTessValid == VG_FALSE) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
else if (c->strokeDashPattern.size > 0) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
else if (p->cacheStrokeLineWidth != c->strokeLineWidth ||
|
||||
p->cacheStrokeCapStyle != c->strokeCapStyle ||
|
||||
p->cacheStrokeJoinStyle != c->strokeJoinStyle ||
|
||||
p->cacheStrokeMiterLimit != c->strokeMiterLimit) {
|
||||
valid = VG_FALSE;
|
||||
}
|
||||
|
||||
if (valid == VG_FALSE)
|
||||
{
|
||||
/* Update cache */
|
||||
p->cacheStrokeInit = VG_TRUE;
|
||||
p->cacheStrokeTessValid = VG_TRUE;
|
||||
p->cacheStrokeLineWidth = c->strokeLineWidth;
|
||||
p->cacheStrokeCapStyle = c->strokeCapStyle;
|
||||
p->cacheStrokeJoinStyle = c->strokeJoinStyle;
|
||||
p->cacheStrokeMiterLimit = c->strokeMiterLimit;
|
||||
}
|
||||
|
||||
return valid;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Tessellates / strokes the path and draws it according to
|
||||
* VGContext state.
|
||||
*-----------------------------------------------------------*/
|
||||
|
||||
VG_API_CALL void vgDrawPath(VGPath path, VGbitfield paintModes)
|
||||
{
|
||||
SHPath *p;
|
||||
SHMatrix3x3 mi;
|
||||
SHfloat mgl[16];
|
||||
SHPaint *fill, *stroke;
|
||||
SHRectangle *rect;
|
||||
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!shIsValidPath(context, path),
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(paintModes & (~(VG_STROKE_PATH | VG_FILL_PATH)),
|
||||
VG_ILLEGAL_ARGUMENT_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* Check whether scissoring is enabled and scissor
|
||||
rectangle is valid */
|
||||
if (context->scissoring == VG_TRUE) {
|
||||
rect = &context->scissor.items[0];
|
||||
if (context->scissor.size == 0) VG_RETURN( VG_NO_RETVAL );
|
||||
if (rect->w <= 0.0f || rect->h <= 0.0f) VG_RETURN( VG_NO_RETVAL );
|
||||
glScissor( (GLint)rect->x, (GLint)rect->y, (GLint)rect->w, (GLint)rect->h );
|
||||
glEnable( GL_SCISSOR_TEST );
|
||||
}
|
||||
|
||||
p = (SHPath*)path;
|
||||
|
||||
/* If user-to-surface matrix invertible tessellate in
|
||||
surface space for better path resolution */
|
||||
if (shIsTessCacheValid( context, p ) == VG_FALSE)
|
||||
{
|
||||
if (shInvertMatrix(&context->pathTransform, &mi)) {
|
||||
shFlattenPath(p, 1);
|
||||
shTransformVertices(&mi, p);
|
||||
}else shFlattenPath(p, 0);
|
||||
shFindBoundbox(p);
|
||||
}
|
||||
|
||||
/* TODO: Turn antialiasing on/off */
|
||||
glDisable(GL_LINE_SMOOTH);
|
||||
glDisable(GL_POLYGON_SMOOTH);
|
||||
glEnable(GL_MULTISAMPLE);
|
||||
|
||||
/* Pick paint if available or default*/
|
||||
fill = (context->fillPaint ? context->fillPaint : &context->defaultPaint);
|
||||
stroke = (context->strokePaint ? context->strokePaint : &context->defaultPaint);
|
||||
|
||||
/* Apply transformation */
|
||||
shMatrixToGL(&context->pathTransform, mgl);
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glPushMatrix();
|
||||
glMultMatrixf(mgl);
|
||||
|
||||
if (paintModes & VG_FILL_PATH) {
|
||||
|
||||
/* Tesselate into stencil */
|
||||
glEnable(GL_STENCIL_TEST);
|
||||
|
||||
if( context->fillRule == VG_EVEN_ODD )
|
||||
{
|
||||
glStencilFunc(GL_ALWAYS, 0, 0);
|
||||
glStencilOp(GL_INVERT, GL_INVERT, GL_INVERT);
|
||||
}
|
||||
else
|
||||
{
|
||||
// pseudo non-zero fill rule. Fill everything at least covered once, don't
|
||||
// care for possible decrements.
|
||||
// TODO implement real non-zero fill-rule
|
||||
glStencilFunc(GL_ALWAYS, 1, 1);
|
||||
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
|
||||
}
|
||||
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
|
||||
shDrawVertices(p, GL_TRIANGLE_FAN);
|
||||
|
||||
/* Setup blending */
|
||||
updateBlendingStateGL(context,
|
||||
fill->type == VG_PAINT_TYPE_COLOR &&
|
||||
fill->color.a == 1.0f);
|
||||
|
||||
/* Draw paint where stencil odd */
|
||||
glStencilFunc(GL_EQUAL, 1, 1);
|
||||
glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
|
||||
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
||||
shDrawPaintMesh(context, &p->min, &p->max, VG_FILL_PATH, GL_TEXTURE0);
|
||||
|
||||
/* Clear stencil for sure */
|
||||
/* TODO: Is there any way to do this safely along
|
||||
with the paint generation pass?? */
|
||||
glDisable(GL_BLEND);
|
||||
glDisable(GL_MULTISAMPLE);
|
||||
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
|
||||
shDrawBoundBox(context, p, VG_FILL_PATH);
|
||||
|
||||
/* Reset state */
|
||||
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
||||
glDisable(GL_STENCIL_TEST);
|
||||
glDisable(GL_BLEND);
|
||||
}
|
||||
|
||||
/* TODO: Turn antialiasing on/off */
|
||||
glDisable(GL_LINE_SMOOTH);
|
||||
glDisable(GL_POLYGON_SMOOTH);
|
||||
glEnable(GL_MULTISAMPLE);
|
||||
|
||||
if ((paintModes & VG_STROKE_PATH) &&
|
||||
context->strokeLineWidth > 0.0f) {
|
||||
|
||||
if (1) {/*context->strokeLineWidth > 1.0f) {*/
|
||||
|
||||
if (shIsStrokeCacheValid( context, p ) == VG_FALSE)
|
||||
{
|
||||
/* Generate stroke triangles in user space */
|
||||
shVector2ArrayClear(&p->stroke);
|
||||
shStrokePath(context, p);
|
||||
}
|
||||
|
||||
/* Stroke into stencil */
|
||||
glEnable(GL_STENCIL_TEST);
|
||||
glStencilFunc(GL_NOTEQUAL, 1, 1);
|
||||
glStencilOp(GL_KEEP, GL_INCR, GL_INCR);
|
||||
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
|
||||
shDrawStroke(p);
|
||||
|
||||
/* Setup blending */
|
||||
updateBlendingStateGL(context,
|
||||
stroke->type == VG_PAINT_TYPE_COLOR &&
|
||||
stroke->color.a == 1.0f);
|
||||
|
||||
/* Draw paint where stencil odd */
|
||||
glStencilFunc(GL_EQUAL, 1, 1);
|
||||
glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
|
||||
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
||||
shDrawPaintMesh(context, &p->min, &p->max, VG_STROKE_PATH, GL_TEXTURE0);
|
||||
|
||||
/* Clear stencil for sure */
|
||||
glDisable(GL_BLEND);
|
||||
glDisable(GL_MULTISAMPLE);
|
||||
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
|
||||
shDrawBoundBox(context, p, VG_STROKE_PATH);
|
||||
|
||||
/* Reset state */
|
||||
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
||||
glDisable(GL_STENCIL_TEST);
|
||||
glDisable(GL_BLEND);
|
||||
|
||||
}else{
|
||||
|
||||
/* Simulate thin stroke by alpha */
|
||||
SHColor c = stroke->color;
|
||||
if (context->strokeLineWidth < 1.0f)
|
||||
c.a *= context->strokeLineWidth;
|
||||
|
||||
/* Draw contour as a line */
|
||||
glDisable(GL_MULTISAMPLE);
|
||||
glEnable(GL_BLEND);
|
||||
glEnable(GL_LINE_SMOOTH);
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
glColor4fv((GLfloat*)&c);
|
||||
shDrawVertices(p, GL_LINE_STRIP);
|
||||
|
||||
glDisable(GL_BLEND);
|
||||
glDisable(GL_LINE_SMOOTH);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
glPopMatrix();
|
||||
|
||||
if (context->scissoring == VG_TRUE)
|
||||
glDisable( GL_SCISSOR_TEST );
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
||||
VG_API_CALL void vgDrawImage(VGImage image)
|
||||
{
|
||||
SHImage *i;
|
||||
SHfloat mgl[16];
|
||||
SHfloat texGenS[4] = {0,0,0,0};
|
||||
SHfloat texGenT[4] = {0,0,0,0};
|
||||
SHPaint *fill;
|
||||
SHVector2 min, max;
|
||||
SHRectangle *rect;
|
||||
|
||||
VG_GETCONTEXT(VG_NO_RETVAL);
|
||||
|
||||
VG_RETURN_ERR_IF(!shIsValidImage(context, image),
|
||||
VG_BAD_HANDLE_ERROR, VG_NO_RETVAL);
|
||||
|
||||
/* TODO: check if image is current render target */
|
||||
|
||||
/* Check whether scissoring is enabled and scissor
|
||||
rectangle is valid */
|
||||
if (context->scissoring == VG_TRUE) {
|
||||
rect = &context->scissor.items[0];
|
||||
if (context->scissor.size == 0) VG_RETURN( VG_NO_RETVAL );
|
||||
if (rect->w <= 0.0f || rect->h <= 0.0f) VG_RETURN( VG_NO_RETVAL );
|
||||
glScissor( (GLint)rect->x, (GLint)rect->y, (GLint)rect->w, (GLint)rect->h );
|
||||
glEnable( GL_SCISSOR_TEST );
|
||||
}
|
||||
|
||||
/* Apply image-user-to-surface transformation */
|
||||
i = (SHImage*)image;
|
||||
shMatrixToGL(&context->imageTransform, mgl);
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glPushMatrix();
|
||||
glMultMatrixf(mgl);
|
||||
|
||||
/* Clamp to edge for proper filtering, modulate for multiply mode */
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glBindTexture(GL_TEXTURE_2D, i->texture);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
|
||||
/* Adjust antialiasing to settings */
|
||||
if (context->imageQuality == VG_IMAGE_QUALITY_NONANTIALIASED) {
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glDisable(GL_MULTISAMPLE);
|
||||
}else{
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glEnable(GL_MULTISAMPLE);
|
||||
}
|
||||
|
||||
/* Generate image texture coords automatically */
|
||||
texGenS[0] = 1.0f / i->texwidth;
|
||||
texGenT[1] = 1.0f / i->texheight;
|
||||
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
|
||||
glTexGenfv(GL_S, GL_OBJECT_PLANE, texGenS);
|
||||
glTexGenfv(GL_T, GL_OBJECT_PLANE, texGenT);
|
||||
glEnable(GL_TEXTURE_GEN_S);
|
||||
glEnable(GL_TEXTURE_GEN_T);
|
||||
|
||||
/* Pick fill paint */
|
||||
fill = (context->fillPaint ? context->fillPaint : &context->defaultPaint);
|
||||
|
||||
/* Use paint color when multiplying with a color-paint */
|
||||
if (context->imageMode == VG_DRAW_IMAGE_MULTIPLY &&
|
||||
fill->type == VG_PAINT_TYPE_COLOR)
|
||||
glColor4fv((GLfloat*)&fill->color);
|
||||
else glColor4f(1,1,1,1);
|
||||
|
||||
|
||||
/* Check image drawing mode */
|
||||
if (context->imageMode == VG_DRAW_IMAGE_MULTIPLY &&
|
||||
fill->type != VG_PAINT_TYPE_COLOR) {
|
||||
|
||||
/* Draw image quad into stencil */
|
||||
glDisable(GL_BLEND);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glEnable(GL_STENCIL_TEST);
|
||||
glStencilFunc(GL_ALWAYS, 1, 1);
|
||||
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
|
||||
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
|
||||
|
||||
glBegin(GL_QUADS);
|
||||
glVertex2i(0, 0);
|
||||
glVertex2i(i->width, 0);
|
||||
glVertex2i(i->width, i->height);
|
||||
glVertex2i(0, i->height);
|
||||
glEnd();
|
||||
|
||||
/* Setup blending */
|
||||
updateBlendingStateGL(context, 0);
|
||||
|
||||
/* Draw gradient mesh where stencil 1*/
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glStencilFunc(GL_EQUAL, 1, 1);
|
||||
glStencilOp(GL_ZERO,GL_ZERO,GL_ZERO);
|
||||
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
|
||||
|
||||
SET2(min,0,0);
|
||||
SET2(max, (SHfloat)i->width, (SHfloat)i->height);
|
||||
if (fill->type == VG_PAINT_TYPE_RADIAL_GRADIENT) {
|
||||
shDrawRadialGradientMesh(fill, &min, &max, VG_FILL_PATH, GL_TEXTURE1);
|
||||
}else if (fill->type == VG_PAINT_TYPE_LINEAR_GRADIENT) {
|
||||
shDrawLinearGradientMesh(fill, &min, &max, VG_FILL_PATH, GL_TEXTURE1);
|
||||
}else if (fill->type == VG_PAINT_TYPE_PATTERN) {
|
||||
shDrawPatternMesh(fill, &min, &max, VG_FILL_PATH, GL_TEXTURE1); }
|
||||
|
||||
glActiveTexture(GL_TEXTURE0);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
glDisable(GL_STENCIL_TEST);
|
||||
|
||||
}else if (context->imageMode == VG_DRAW_IMAGE_STENCIL) {
|
||||
|
||||
|
||||
}else{/* Either normal mode or multiplying with a color-paint */
|
||||
|
||||
/* Setup blending */
|
||||
updateBlendingStateGL(context, 0);
|
||||
|
||||
/* Draw textured quad */
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
|
||||
glBegin(GL_QUADS);
|
||||
glVertex2i(0, 0);
|
||||
glVertex2i(i->width, 0);
|
||||
glVertex2i(i->width, i->height);
|
||||
glVertex2i(0, i->height);
|
||||
glEnd();
|
||||
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
}
|
||||
|
||||
|
||||
glDisable(GL_TEXTURE_GEN_S);
|
||||
glDisable(GL_TEXTURE_GEN_T);
|
||||
glPopMatrix();
|
||||
|
||||
if (context->scissoring == VG_TRUE)
|
||||
glDisable( GL_SCISSOR_TEST );
|
||||
|
||||
VG_RETURN(VG_NO_RETVAL);
|
||||
}
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shVectors.h"
|
||||
|
||||
#define _ITEM_T SHVector2
|
||||
#define _ARRAY_T SHVector2Array
|
||||
#define _FUNC_T shVector2Array
|
||||
#define _COMPARE_T(v1,v2) EQ2V(v1,v2)
|
||||
#define _ARRAY_DEFINE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
void SHVector2_ctor(SHVector2 *v) {
|
||||
v->x=0.0f; v->y=0.0f;
|
||||
}
|
||||
|
||||
void SHVector2_dtor(SHVector2 *v) {
|
||||
}
|
||||
|
||||
void SHVector3_ctor(SHVector3 *v) {
|
||||
v->x=0.0f; v->y=0.0f; v->z=0.0f;
|
||||
}
|
||||
|
||||
void SHVector3_dtor(SHVector3 *v) {
|
||||
}
|
||||
|
||||
void SHVector4_ctor(SHVector4 *v) {
|
||||
v->x=0.0f; v->y=0.0f; v->z=0.0f; v->w=0.0f;
|
||||
}
|
||||
|
||||
void SHVector4_dtor(SHVector4 *v) {
|
||||
}
|
||||
|
||||
void SHRectangle_ctor(SHRectangle *r) {
|
||||
r->x=0.0f; r->y=0.0f; r->w=0.0f; r->h=0.0f;
|
||||
}
|
||||
|
||||
void SHRectangle_dtor(SHRectangle *r) {
|
||||
}
|
||||
|
||||
void shRectangleSet(SHRectangle *r, SHfloat x,
|
||||
SHfloat y, SHfloat w, SHfloat h)
|
||||
{
|
||||
r->x=x; r->y=y; r->w=w; r->h=h;
|
||||
}
|
||||
|
||||
void SHMatrix3x3_ctor(SHMatrix3x3 *mt)
|
||||
{
|
||||
IDMAT((*mt));
|
||||
}
|
||||
|
||||
void SHMatrix3x3_dtor(SHMatrix3x3 *mt)
|
||||
{
|
||||
}
|
||||
|
||||
void shMatrixToGL(SHMatrix3x3 *m, SHfloat mgl[16])
|
||||
{
|
||||
/* When 2D vectors are specified OpenGL defaults Z to 0.0f so we
|
||||
have to shift the third column of our 3x3 matrix to right */
|
||||
mgl[0] = m->m[0][0]; mgl[4] = m->m[0][1]; mgl[8] = 0.0f; mgl[12] = m->m[0][2];
|
||||
mgl[1] = m->m[1][0]; mgl[5] = m->m[1][1]; mgl[9] = 0.0f; mgl[13] = m->m[1][2];
|
||||
mgl[2] = m->m[2][0]; mgl[6] = m->m[2][1]; mgl[10] = 1.0f; mgl[14] = m->m[2][1];
|
||||
mgl[3] = 0.0f; mgl[7] = 0.0f; mgl[11] = 0.0f; mgl[15] = 1.0f;
|
||||
}
|
||||
|
||||
int shInvertMatrix(SHMatrix3x3 *m, SHMatrix3x3 *mout)
|
||||
{
|
||||
/* Calculate determinant */
|
||||
SHfloat D0 = m->m[1][1]*m->m[2][2] - m->m[2][1]*m->m[1][2];
|
||||
SHfloat D1 = m->m[2][0]*m->m[1][2] - m->m[1][0]*m->m[2][2];
|
||||
SHfloat D2 = m->m[1][0]*m->m[2][1] - m->m[2][0]*m->m[1][1];
|
||||
SHfloat D = m->m[0][0]*D0 + m->m[0][1]*D1 + m->m[0][2]*D2;
|
||||
|
||||
/* Check if singular */
|
||||
if( D == 0.0f ) return 0;
|
||||
D = 1.0f / D;
|
||||
|
||||
/* Calculate inverse */
|
||||
mout->m[0][0] = D * D0;
|
||||
mout->m[1][0] = D * D1;
|
||||
mout->m[2][0] = D * D2;
|
||||
mout->m[0][1] = D * (m->m[2][1]*m->m[0][2] - m->m[0][1]*m->m[2][2]);
|
||||
mout->m[1][1] = D * (m->m[0][0]*m->m[2][2] - m->m[2][0]*m->m[0][2]);
|
||||
mout->m[2][1] = D * (m->m[2][0]*m->m[0][1] - m->m[0][0]*m->m[2][1]);
|
||||
mout->m[0][2] = D * (m->m[0][1]*m->m[1][2] - m->m[1][1]*m->m[0][2]);
|
||||
mout->m[1][2] = D * (m->m[1][0]*m->m[0][2] - m->m[0][0]*m->m[1][2]);
|
||||
mout->m[2][2] = D * (m->m[0][0]*m->m[1][1] - m->m[1][0]*m->m[0][1]);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
SHfloat shVectorOrientation(SHVector2 *v) {
|
||||
SHfloat norm = (SHfloat)NORM2((*v));
|
||||
SHfloat cosa = v->x/norm;
|
||||
SHfloat sina = v->y/norm;
|
||||
return (SHfloat)(sina>=0 ? SH_ACOS(cosa) : 2*PI-SH_ACOS(cosa));
|
||||
}
|
||||
|
||||
int shLineLineXsection(SHVector2 *o1, SHVector2 *v1,
|
||||
SHVector2 *o2, SHVector2 *v2,
|
||||
SHVector2 *xsection)
|
||||
{
|
||||
SHfloat rightU = o2->x - o1->x;
|
||||
SHfloat rightD = o2->y - o1->y;
|
||||
|
||||
SHfloat D = v1->x * (-v2->y) - v1->y * (-v2->x);
|
||||
SHfloat DX = rightU * (-v2->y) - rightD * (-v2->x);
|
||||
/*SHfloat DY = v1.x * rightD - v1.y * rightU;*/
|
||||
|
||||
SHfloat t1 = DX / D;
|
||||
|
||||
if (D == 0.0f)
|
||||
return 0;
|
||||
|
||||
xsection->x = o1->x + t1*v1->x;
|
||||
xsection->y = o1->y + t1*v1->y;
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1,275 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __SHVECTORS_H
|
||||
#define __SHVECTORS_H
|
||||
|
||||
#include "shDefs.h"
|
||||
|
||||
/* Vector structures
|
||||
*--------------------------------------------------------------*/
|
||||
typedef struct
|
||||
{
|
||||
SHfloat x,y;
|
||||
} SHVector2;
|
||||
|
||||
void SHVector2_ctor(SHVector2 *v);
|
||||
void SHVector2_dtor(SHVector2 *v);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SHfloat x,y,z;
|
||||
} SHVector3;
|
||||
|
||||
void SHVector3_ctor(SHVector3 *v);
|
||||
void SHVector3_dtor(SHVector3 *v);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SHfloat x,y,z,w;
|
||||
} SHVector4;
|
||||
|
||||
void SHVector4_ctor(SHVector4 *v);
|
||||
void SHVector4_dtor(SHVector4 *v);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SHfloat x,y,w,h;
|
||||
} SHRectangle;
|
||||
|
||||
void SHRectangle_ctor(SHRectangle *r);
|
||||
void SHRectangle_dtor(SHRectangle *r);
|
||||
void shRectangleSet(SHRectangle *r, SHfloat x,
|
||||
SHfloat y, SHfloat w, SHfloat h);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SHfloat m[3][3];
|
||||
} SHMatrix3x3;
|
||||
|
||||
void SHMatrix3x3_ctor(SHMatrix3x3 *m);
|
||||
void SHMatrix3x3_dtor(SHMatrix3x3 *m);
|
||||
|
||||
/*------------------------------------------------------------
|
||||
* Vector Arrays
|
||||
*------------------------------------------------------------*/
|
||||
|
||||
#define _ITEM_T SHVector2
|
||||
#define _ARRAY_T SHVector2Array
|
||||
#define _FUNC_T shVector2Array
|
||||
#define _ARRAY_DECLARE
|
||||
#include "shArrayBase.h"
|
||||
|
||||
/*--------------------------------------------------------
|
||||
* Macros for typical vector operations. The only way to
|
||||
* inline in C is to actually write a macro
|
||||
*--------------------------------------------------------- */
|
||||
|
||||
#define SET2(v,xs,ys) { v.x=xs; v.y=ys; }
|
||||
#define SET3(v,xs,ys,zs) { v.x=xs; v.y=ys; v.z=zs; }
|
||||
#define SET4(v,xs,ys,zs,ws) { v.x=xs; v.y=ys; v.z=zs; v.w=ws; }
|
||||
|
||||
#define SET2V(v1,v2) { v1.x=v2.x; v1.y=v2.y; }
|
||||
#define SET3V(v1,v2) { v1.x=v2.x; v1.y=v2.y; v1.z=v2.z; }
|
||||
#define SET4V(v1,v2) { v1.x=v2.x; v1.y=v2.y; v1.z=v2.z; v1.w=v2.w; }
|
||||
|
||||
#define EQ2(v,xx,yy) ( v.x==xx && v.y==yy )
|
||||
#define EQ3(v,xx,yy,zz) ( v.x==xx && v.y==yy && v.z==zz )
|
||||
#define EQ4(v,xx,yy,zz,ww) ( v.x==xx && v.y==yy && v.z==zz && v.w==ww )
|
||||
|
||||
#define ISZERO2(v) ( v.x==0.0f && v.y==0.0f )
|
||||
#define ISZERO3(v) ( v.x==0.0f && v.y==0.0f && v.z==0.0f)
|
||||
#define ISZERO4(v) ( v.x==0.0f && v.y==0.0f && v.z==0.0f && v.w==0.0f )
|
||||
|
||||
#define EQ2V(v1,v2) ( v1.x==v2.x && v1.y==v2.y )
|
||||
#define EQ3V(v1,v2) ( v1.x==v2.x && v1.y==v2.y && v1.z==v2.z )
|
||||
#define EQ4V(v1,v2) ( v1.x==v2.x && v1.y==v2.y && v1.z==v2.z && v1.w==v2.w )
|
||||
|
||||
#define ADD2(v,xx,yy) { v.x+=xx; v.y+=yy; }
|
||||
#define ADD3(v,xx,yy,zz) { v.x+=xx; v.y+=yy; v.z+=zz; }
|
||||
#define ADD4(v,xx,yy,zz,ww) { v.x+=xx; v.y+=yy; v.z+=zz; v.w+=ww; }
|
||||
|
||||
#define ADD2V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; }
|
||||
#define ADD3V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; }
|
||||
#define ADD4V(v1,v2) { v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; v1.w+=v2.w; }
|
||||
|
||||
#define SUB2(v,xx,yy) { v.x-=xx; v.y-=yy; }
|
||||
#define SUB3(v,xx,yy,zz) { v.x-=xx; v.y-=yy; v.z-=zz; }
|
||||
#define SUB4(v,xx,yy,zz,ww) { v.x-=xx; v.y-=yy; v.z-=zz; v.w-=v2.w; }
|
||||
|
||||
#define SUB2V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; }
|
||||
#define SUB3V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; v1.z-=v2.z; }
|
||||
#define SUB4V(v1,v2) { v1.x-=v2.x; v1.y-=v2.y; v1.z-=v2.z; v1.w-=v2.w; }
|
||||
|
||||
#define MUL2(v,f) { v.x*=f; v.y*=f; }
|
||||
#define MUL3(v,f) { v.x*=f; v.y*=f; v.z*=z; }
|
||||
#define MUL4(v,f) { v.x*=f; v.y*=f; v.z*=z; v.w*=w; }
|
||||
|
||||
#define DIV2(v,f) { v.x/=f; v.y/=f; }
|
||||
#define DIV3(v,f) { v.x/=f; v.y/=f; v.z/=z; }
|
||||
#define DIV4(v,f) { v.x/=f; v.y/=f; v.z/=z; v.w/=w; }
|
||||
|
||||
#define ABS2(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); }
|
||||
#define ABS3(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); v.z=SH_ABS(v.z); }
|
||||
#define ABS4(v) { v.x=SH_ABS(v.x); v.y=SH_ABS(v.y); v.z=SH_ABS(v.z); v.w=SH_ABS(v.w); }
|
||||
|
||||
#define NORMSQ2(v) (v.x*v.x + v.y*v.y)
|
||||
#define NORMSQ3(v) (v.x*v.x + v.y*v.y + v.z*v.z)
|
||||
#define NORMSQ4(v) (v.x*v.x + v.y*v.y + v.z*v.z + v.w*v.w)
|
||||
|
||||
#define NORM2(v) SH_SQRT(NORMSQ2(v))
|
||||
#define NORM3(v) SH_SQRT(NORMSQ3(v))
|
||||
#define NORM4(v) SH_SQRT(NORMSQ4(v))
|
||||
|
||||
#define NORMALIZE2(v) { SHfloat n=NORM2(v); v.x/=n; v.y/=n; }
|
||||
#define NORMALIZE3(v) { SHfloat n=NORM3(v); v.x/=n; v.y/=n; v.z/=n; }
|
||||
#define NORMALIZE4(v) { SHfloat n=NORM4(v); v.x/=n; v.y/=n; v.z/=n; v.w/=w; }
|
||||
|
||||
#define DOT2(v1,v2) (v1.x*v2.x + v1.y*v2.y)
|
||||
#define DOT3(v1,v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z)
|
||||
#define DOT4(v1,v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z + v1.w*v2.w)
|
||||
|
||||
#define CROSS2(v1,v2) (v1.x*v2.y - v2.x*v1.y)
|
||||
|
||||
#define ANGLE2(v1,v2) (SH_ACOS( DOT2(v1,v2) / (NORM2(v1)*NORM2(v2)) ))
|
||||
#define ANGLE2N(v1,v2) (SH_ACOS( DOT2(v1,v2) ))
|
||||
|
||||
#define OFFSET2V(v, o, s) { v.x += o.x*s; v.y += o.y*s; }
|
||||
#define OFFSET3V(v, o, s) { v.x += o.x*s; v.y += o.y*s; v.z += o.z*s; }
|
||||
#define OFFSET4V(v, o, s) { v.x += o.x*s; v.y += o.y*s; v.z += o.z*s; v.w += o.w*s; }
|
||||
|
||||
/*-----------------------------------------------------
|
||||
* Macros for matrix operations
|
||||
*-----------------------------------------------------*/
|
||||
|
||||
#define SETMAT(mat, m00, m01, m02, m10, m11, m12, m20, m21, m22) { \
|
||||
mat.m[0][0] = m00; mat.m[0][1] = m01; mat.m[0][2] = m02; \
|
||||
mat.m[1][0] = m10; mat.m[1][1] = m11; mat.m[1][2] = m12; \
|
||||
mat.m[2][0] = m20; mat.m[2][1] = m21; mat.m[2][2] = m22; }
|
||||
|
||||
#define SETMATMAT(m1, m2) { \
|
||||
int i,j; \
|
||||
for(i=0;i<3;i++) \
|
||||
for(j=0;j<3;j++) \
|
||||
m1.m[i][j] = m2.m[i][j]; }
|
||||
|
||||
#define MULMATS(mat, s) { \
|
||||
int i,j; \
|
||||
for(i=0;i<3;i++) \
|
||||
for(j=0;j<3;j++) \
|
||||
mat.m[i][j] *= s; }
|
||||
|
||||
#define DIVMATS(mat, s) { \
|
||||
int i,j; \
|
||||
for(i=0;i<3;i++) \
|
||||
for(j=0;j<3;j++) \
|
||||
mat.m[i][j] /= s; }
|
||||
|
||||
#define MULMATMAT(m1, m2, mout) { \
|
||||
int i,j; \
|
||||
for(i=0;i<3;i++) \
|
||||
for(j=0;j<3;j++) \
|
||||
mout.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]; }
|
||||
|
||||
#define IDMAT(mat) SETMAT(mat, 1,0,0, 0,1,0, 0,0,1)
|
||||
|
||||
#define TRANSLATEMATL(mat, tx, ty) { \
|
||||
SHMatrix3x3 trans,temp; \
|
||||
SETMAT(trans, 1,0,tx, 0,1,ty, 0,0,1); \
|
||||
MULMATMAT(trans, mat, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define TRANSLATEMATR(mat, tx, ty) { \
|
||||
SHMatrix3x3 trans,temp; \
|
||||
SETMAT(trans, 1,0,tx, 0,1,ty, 0,0,1); \
|
||||
MULMATMAT(mat, trans, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define SCALEMATL(mat, sx, sy) { \
|
||||
SHMatrix3x3 scale, temp; \
|
||||
SETMAT(scale, sx,0,0, 0,sy,0, 0,0,1); \
|
||||
MULMATMAT(scale, mat, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define SCALEMATR(mat, sx, sy) { \
|
||||
SHMatrix3x3 scale, temp; \
|
||||
SETMAT(scale, sx,0,0, 0,sy,0, 0,0,1); \
|
||||
MULMATMAT(mat, scale, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define SHEARMATL(mat, shx, shy) {\
|
||||
SHMatrix3x3 shear, temp;\
|
||||
SETMAT(shear, 1,shx,0, shy,1,0, 0,0,1); \
|
||||
MULMATMAT(shear, mat, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define SHEARMATR(mat, shx, shy) {\
|
||||
SHMatrix3x3 shear, temp;\
|
||||
SETMAT(shear, 1,shx,0, shy,1,0, 0,0,1); \
|
||||
MULMATMAT(mat, shear, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define ROTATEMATL(mat, a) { \
|
||||
SHfloat cosa=SH_COS(a), sina=SH_SIN(a); \
|
||||
SHMatrix3x3 rot, temp; \
|
||||
SETMAT(rot, cosa,-sina,0, sina,cosa,0, 0,0,1); \
|
||||
MULMATMAT(rot, mat, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define ROTATEMATR(mat, a) { \
|
||||
SHfloat cosa=SH_COS(a), sina=SH_SIN(a); \
|
||||
SHMatrix3x3 rot, temp; \
|
||||
SETMAT(rot, cosa,-sina,0, sina,cosa,0, 0,0,1); \
|
||||
MULMATMAT(mat, rot, temp); \
|
||||
SETMATMAT(mat, temp); }
|
||||
|
||||
#define TRANSFORM2TO(v, mat, vout) { \
|
||||
vout.x = v.x*mat.m[0][0] + v.y*mat.m[0][1] + 1*mat.m[0][2]; \
|
||||
vout.y = v.x*mat.m[1][0] + v.y*mat.m[1][1] + 1*mat.m[1][2]; }
|
||||
|
||||
#define TRANSFORM2(v, mat) { \
|
||||
SHVector2 temp; TRANSFORM2TO(v, mat, temp); v = temp; }
|
||||
|
||||
#define TRANSFORM2DIRTO(v, mat, vout) { \
|
||||
vout.x = v.x*mat.m[0][0] + v.y*mat.m[0][1]; \
|
||||
vout.y = v.x*mat.m[1][0] + v.y*mat.m[1][1]; }
|
||||
|
||||
#define TRANSFORM2DIR(v, mat) { \
|
||||
SHVector2 temp; TRANSFORM2DIRTO(v, mat, temp); v = temp; }
|
||||
|
||||
|
||||
/*--------------------------------------------------------
|
||||
* Additional functions
|
||||
*--------------------------------------------------------- */
|
||||
|
||||
void shMatrixToGL(SHMatrix3x3 *m, SHfloat mgl[16]);
|
||||
|
||||
SHint shInvertMatrix(SHMatrix3x3 *m, SHMatrix3x3 *mout);
|
||||
|
||||
SHfloat shVectorOrientation(SHVector2 *v);
|
||||
|
||||
int shLineLineXsection(SHVector2 *o1, SHVector2 *v1,
|
||||
SHVector2 *o2, SHVector2 *v2,
|
||||
SHVector2 *xsection);
|
||||
|
||||
#endif/* __SHVECTORS_H */
|
||||
|
|
@ -1,425 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Ivan Leben
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library in the file COPYING;
|
||||
* if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <vg/openvg.h>
|
||||
#include <vg/vgu.h>
|
||||
#include "shDefs.h"
|
||||
#include "shContext.h"
|
||||
#include <math.h>
|
||||
|
||||
static VGUErrorCode shAppend(VGPath path, SHint commSize, const VGubyte *comm,
|
||||
SHint dataSize, const VGfloat *data)
|
||||
{
|
||||
VGErrorCode err = VG_NO_ERROR;
|
||||
VGPathDatatype type = vgGetParameterf(path, VG_PATH_DATATYPE);
|
||||
VGfloat scale = vgGetParameterf(path, VG_PATH_SCALE);
|
||||
VGfloat bias = vgGetParameterf(path, VG_PATH_BIAS);
|
||||
SH_ASSERT(dataSize <= 26);
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case VG_PATH_DATATYPE_S_8: {
|
||||
|
||||
SHint8 data8[26]; int i;
|
||||
for (i=0; i<dataSize; ++i)
|
||||
data8[i] = (SHint8)SH_FLOOR((data[i] - bias) / scale + 0.5f);
|
||||
vgAppendPathData(path, commSize, comm, data8);
|
||||
|
||||
break;}
|
||||
case VG_PATH_DATATYPE_S_16: {
|
||||
|
||||
SHint16 data16[26]; int i;
|
||||
for (i=0; i<dataSize; ++i)
|
||||
data16[i] = (SHint16)SH_FLOOR((data[i] - bias) / scale + 0.5f);
|
||||
vgAppendPathData(path, commSize, comm, data16);
|
||||
|
||||
break;}
|
||||
case VG_PATH_DATATYPE_S_32: {
|
||||
|
||||
SHint32 data32[26]; int i;
|
||||
for (i=0; i<dataSize; ++i)
|
||||
data32[i] = (SHint32)SH_FLOOR((data[i] - bias) / scale + 0.5f);
|
||||
vgAppendPathData(path, commSize, comm, data32);
|
||||
|
||||
break;}
|
||||
default: {
|
||||
|
||||
VGfloat dataF[26]; int i;
|
||||
for (i=0; i<dataSize; ++i)
|
||||
dataF[i] = (data[i] - bias) / scale;
|
||||
vgAppendPathData(path, commSize, comm, dataF);
|
||||
|
||||
break;}
|
||||
}
|
||||
|
||||
err = vgGetError();
|
||||
if (err == VG_PATH_CAPABILITY_ERROR)
|
||||
return VGU_PATH_CAPABILITY_ERROR;
|
||||
else if (err == VG_BAD_HANDLE_ERROR)
|
||||
return VGU_BAD_HANDLE_ERROR;
|
||||
else if (err == VG_OUT_OF_MEMORY_ERROR)
|
||||
return VGU_OUT_OF_MEMORY_ERROR;
|
||||
|
||||
return VGU_NO_ERROR;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguLine(VGPath path,
|
||||
VGfloat x0, VGfloat y0,
|
||||
VGfloat x1, VGfloat y1)
|
||||
{
|
||||
VGUErrorCode err = VGU_NO_ERROR;
|
||||
const VGubyte comm[] = {VG_MOVE_TO_ABS, VG_LINE_TO_ABS};
|
||||
|
||||
VGfloat data[4];
|
||||
data[0] = x0; data[1] = y0;
|
||||
data[2] = x1; data[3] = y1;
|
||||
|
||||
err = shAppend(path, 2, comm, 4, data);
|
||||
return err;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguPolygon(VGPath path,
|
||||
const VGfloat * points, VGint count,
|
||||
VGboolean closed)
|
||||
{
|
||||
VGint i;
|
||||
VGubyte *comm = NULL;
|
||||
VGUErrorCode err = VGU_NO_ERROR;
|
||||
|
||||
if (points == NULL || count <= 0)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
/* TODO: check points array alignment */
|
||||
|
||||
comm = (VGubyte*)malloc( (count+1) * sizeof(VGubyte) );
|
||||
if (comm == NULL) return VGU_OUT_OF_MEMORY_ERROR;
|
||||
|
||||
comm[0] = VG_MOVE_TO_ABS;
|
||||
for (i=1; i<count; ++i)
|
||||
comm[i] = VG_LINE_TO_ABS;
|
||||
comm[count] = VG_CLOSE_PATH;
|
||||
|
||||
if (closed) err = shAppend(path, count+1, comm, count*2, points);
|
||||
else err = shAppend(path, count, comm, count*2, points);
|
||||
|
||||
free(comm);
|
||||
return err;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguRect(VGPath path,
|
||||
VGfloat x, VGfloat y,
|
||||
VGfloat width, VGfloat height)
|
||||
{
|
||||
VGUErrorCode err = VGU_NO_ERROR;
|
||||
|
||||
VGubyte comm[5] = {
|
||||
VG_MOVE_TO_ABS, VG_HLINE_TO_REL,
|
||||
VG_VLINE_TO_REL, VG_HLINE_TO_REL,
|
||||
VG_CLOSE_PATH };
|
||||
|
||||
VGfloat data[5];
|
||||
|
||||
if (width <= 0 || height <= 0)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
data[0] = x; data[1] = y;
|
||||
data[2] = width; data[3] = height;
|
||||
data[4] = -width;
|
||||
|
||||
err = shAppend(path, 5, comm, 5, data);
|
||||
return err;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguRoundRect(VGPath path,
|
||||
VGfloat x, VGfloat y,
|
||||
VGfloat width, VGfloat height,
|
||||
VGfloat arcWidth, VGfloat arcHeight)
|
||||
{
|
||||
VGUErrorCode err = VGU_NO_ERROR;
|
||||
|
||||
VGubyte comm[10] = {
|
||||
VG_MOVE_TO_ABS,
|
||||
VG_HLINE_TO_REL, VG_SCCWARC_TO_REL,
|
||||
VG_VLINE_TO_REL, VG_SCCWARC_TO_REL,
|
||||
VG_HLINE_TO_REL, VG_SCCWARC_TO_REL,
|
||||
VG_VLINE_TO_REL, VG_SCCWARC_TO_REL,
|
||||
VG_CLOSE_PATH };
|
||||
|
||||
VGfloat data[26];
|
||||
VGfloat rx, ry;
|
||||
|
||||
if (width <= 0 || height <= 0)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
SH_CLAMP(arcWidth, 0.0f, width);
|
||||
SH_CLAMP(arcHeight, 0.0f, height);
|
||||
rx = arcWidth/2;
|
||||
ry = arcHeight/2;
|
||||
|
||||
data[0] = x + rx; data[1] = y;
|
||||
|
||||
data[2] = width - arcWidth;
|
||||
data[3] = rx; data[4] = ry; data[5] = 0;
|
||||
data[6] = rx; data[7] = ry;
|
||||
|
||||
data[8] = height - arcHeight;
|
||||
data[9] = rx; data[10] = ry; data[11] = 0;
|
||||
data[12] = -rx; data[13] = ry;
|
||||
|
||||
data[14] = -(width - arcWidth);
|
||||
data[15] = rx; data[16] = ry; data[17] = 0;
|
||||
data[18] = -rx; data[19] = -ry;
|
||||
|
||||
data[20] = -(height - arcHeight);
|
||||
data[21] = rx; data[22] = ry; data[23] = 0;
|
||||
data[24] = rx; data[25] = -ry;
|
||||
|
||||
err = shAppend(path, 10, comm, 26, data);
|
||||
return err;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguEllipse(VGPath path,
|
||||
VGfloat cx, VGfloat cy,
|
||||
VGfloat width, VGfloat height)
|
||||
{
|
||||
VGUErrorCode err = VGU_NO_ERROR;
|
||||
|
||||
const VGubyte comm[] = {
|
||||
VG_MOVE_TO_ABS, VG_SCCWARC_TO_REL,
|
||||
VG_SCCWARC_TO_REL, VG_CLOSE_PATH};
|
||||
|
||||
VGfloat data[12];
|
||||
|
||||
if (width <= 0 || height <= 0)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
data[0] = cx + width/2; data[1] = cy;
|
||||
|
||||
data[2] = width/2; data[3] = height/2; data[4] = 0;
|
||||
data[5] = -width; data[6] = 0;
|
||||
|
||||
data[7] = width/2; data[8] = height/2; data[9] = 0;
|
||||
data[10] = width; data[11] = 0;
|
||||
|
||||
err = shAppend(path, 4, comm, 12, data);
|
||||
return err;
|
||||
}
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguArc(VGPath path,
|
||||
VGfloat x, VGfloat y,
|
||||
VGfloat width, VGfloat height,
|
||||
VGfloat startAngle, VGfloat angleExtent,
|
||||
VGUArcType arcType)
|
||||
{
|
||||
VGUErrorCode err = VGU_NO_ERROR;
|
||||
|
||||
VGubyte commStart[1] = {VG_MOVE_TO_ABS};
|
||||
VGfloat dataStart[2];
|
||||
|
||||
VGubyte commArcCCW[1] = {VG_SCCWARC_TO_ABS};
|
||||
VGubyte commArcCW[1] = {VG_SCWARC_TO_ABS};
|
||||
VGfloat dataArc[5];
|
||||
|
||||
VGubyte commEndPie[2] = {VG_LINE_TO_ABS, VG_CLOSE_PATH};
|
||||
VGfloat dataEndPie[2];
|
||||
|
||||
VGubyte commEndChord[1] = {VG_CLOSE_PATH};
|
||||
VGfloat dataEndChord[1] = {0.0f};
|
||||
|
||||
VGfloat alast, a = 0.0f;
|
||||
VGfloat rx = width/2, ry = height/2;
|
||||
|
||||
if (width <= 0 || height <= 0)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
if (arcType != VGU_ARC_OPEN &&
|
||||
arcType != VGU_ARC_CHORD &&
|
||||
arcType != VGU_ARC_PIE)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
startAngle = SH_DEG2RAD(startAngle);
|
||||
angleExtent = SH_DEG2RAD(angleExtent);
|
||||
alast = startAngle + angleExtent;
|
||||
|
||||
dataStart[0] = x + SH_COS(startAngle) * rx;
|
||||
dataStart[1] = y + SH_SIN(startAngle) * ry;
|
||||
err = shAppend(path, 1, commStart, 2, dataStart);
|
||||
if (err != VGU_NO_ERROR) return err;
|
||||
|
||||
dataArc[0] = rx;
|
||||
dataArc[1] = ry;
|
||||
dataArc[2] = 0.0f;
|
||||
|
||||
if (angleExtent > 0) {
|
||||
|
||||
a = startAngle + PI;
|
||||
while (a < alast) {
|
||||
dataArc[3] = x + SH_COS(a) * rx;
|
||||
dataArc[4] = y + SH_SIN(a) * ry;
|
||||
err = shAppend(path, 1, commArcCCW, 5, dataArc);
|
||||
if (err != VGU_NO_ERROR) return err;
|
||||
a += PI; }
|
||||
|
||||
dataArc[3] = x + SH_COS(alast) * rx;
|
||||
dataArc[4] = y + SH_SIN(alast) * ry;
|
||||
err = shAppend(path, 1, commArcCCW, 5, dataArc);
|
||||
if (err != VGU_NO_ERROR) return err;
|
||||
|
||||
}else{
|
||||
|
||||
a = startAngle - PI;
|
||||
while (a > alast) {
|
||||
dataArc[3] = x + SH_COS(a) * rx;
|
||||
dataArc[4] = y + SH_SIN(a) * ry;
|
||||
err = shAppend(path, 1, commArcCW, 5, dataArc);
|
||||
if (err != VGU_NO_ERROR) return err;
|
||||
a -= PI; }
|
||||
|
||||
dataArc[3] = x + SH_COS(alast) * rx;
|
||||
dataArc[4] = y + SH_SIN(alast) * ry;
|
||||
err = shAppend(path, 1, commArcCW, 5, dataArc);
|
||||
if (err != VGU_NO_ERROR) return err;
|
||||
}
|
||||
|
||||
|
||||
if (arcType == VGU_ARC_PIE) {
|
||||
dataEndPie[0] = x; dataEndPie[1] = y;
|
||||
err = shAppend(path, 2, commEndPie, 2, dataEndPie);
|
||||
}else if (arcType == VGU_ARC_CHORD) {
|
||||
err = shAppend(path, 1, commEndChord, 0, dataEndChord);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguComputeWarpQuadToSquare(VGfloat sx0, VGfloat sy0,
|
||||
VGfloat sx1, VGfloat sy1,
|
||||
VGfloat sx2, VGfloat sy2,
|
||||
VGfloat sx3, VGfloat sy3,
|
||||
VGfloat *matrix)
|
||||
{
|
||||
/* Basic idea taken from the reference implementation */
|
||||
VGfloat mat[3][3];
|
||||
VGfloat det, det00, det01, det02;
|
||||
|
||||
if( !matrix )
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
if( vguComputeWarpSquareToQuad( sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3,
|
||||
(VGfloat*)mat )
|
||||
== VGU_BAD_WARP_ERROR )
|
||||
return VGU_BAD_WARP_ERROR;
|
||||
|
||||
// Invert the matrix...
|
||||
det00 = mat[1][1]*mat[2][2] - mat[2][1]*mat[1][2];
|
||||
det01 = mat[2][0]*mat[1][2] - mat[1][0]*mat[2][2];
|
||||
det02 = mat[1][0]*mat[2][1] - mat[2][0]*mat[1][1];
|
||||
|
||||
det = mat[0][0]*det00 + mat[0][1]*det01 + mat[0][2]*det02;
|
||||
if( det == 0.0f )
|
||||
return VGU_BAD_WARP_ERROR;
|
||||
|
||||
det = 1 / det;
|
||||
|
||||
matrix[0] = det * det00;
|
||||
matrix[3] = det * det01;
|
||||
matrix[6] = det * det02;
|
||||
matrix[1] = det * (mat[2][1]*mat[0][2] - mat[0][1]*mat[2][2]);
|
||||
matrix[4] = det * (mat[0][0]*mat[2][2] - mat[2][0]*mat[0][2]);
|
||||
matrix[7] = det * (mat[2][0]*mat[0][1] - mat[0][0]*mat[2][1]);
|
||||
matrix[2] = det * (mat[0][1]*mat[1][2] - mat[1][1]*mat[0][2]);
|
||||
matrix[5] = det * (mat[1][0]*mat[0][2] - mat[0][0]*mat[1][2]);
|
||||
matrix[8] = det * (mat[0][0]*mat[1][1] - mat[1][0]*mat[0][1]);
|
||||
|
||||
return VGU_NO_ERROR;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguComputeWarpSquareToQuad(VGfloat dx0, VGfloat dy0,
|
||||
VGfloat dx1, VGfloat dy1,
|
||||
VGfloat dx2, VGfloat dy2,
|
||||
VGfloat dx3, VGfloat dy3,
|
||||
VGfloat * matrix)
|
||||
{
|
||||
/* Taken from https://github.com/mvr/shivavg (who has taken it from the
|
||||
reference implementation) */
|
||||
|
||||
VGfloat diffx1 = dx1 - dx3;
|
||||
VGfloat diffy1 = dy1 - dy3;
|
||||
VGfloat diffx2 = dx2 - dx3;
|
||||
VGfloat diffy2 = dy2 - dy3;
|
||||
|
||||
VGfloat det = diffx1*diffy2 - diffx2*diffy1;
|
||||
|
||||
VGfloat sumx = dx0 - dx1 + dx3 - dx2;
|
||||
VGfloat sumy = dy0 - dy1 + dy3 - dy2;
|
||||
|
||||
VGfloat g, h, oodet;
|
||||
|
||||
if(!matrix)
|
||||
return VGU_ILLEGAL_ARGUMENT_ERROR;
|
||||
|
||||
if(det == 0.0f)
|
||||
return VGU_BAD_WARP_ERROR;
|
||||
|
||||
if(sumx == 0.0f && sumy == 0.0f)
|
||||
{
|
||||
/* Affine mapping */
|
||||
matrix[0] = dx1 - dx0;
|
||||
matrix[1] = dy1 - dy0;
|
||||
matrix[2] = 0.0f;
|
||||
matrix[3] = dx3 - dx1;
|
||||
matrix[4] = dy3 - dy1;
|
||||
matrix[5] = 0.0f;
|
||||
matrix[6] = dx0;
|
||||
matrix[7] = dy0;
|
||||
matrix[8] = 1.0f;
|
||||
return VGU_NO_ERROR;
|
||||
}
|
||||
|
||||
oodet = 1.0f / det;
|
||||
g = (sumx*diffy2 - diffx2*sumy) * oodet;
|
||||
h = (diffx1*sumy - sumx*diffy1) * oodet;
|
||||
|
||||
matrix[0] = dx1-dx0+g*dx1;
|
||||
matrix[1] = dy1-dy0+g*dy1;
|
||||
matrix[2] = g;
|
||||
matrix[3] = dx2-dx0+h*dx2;
|
||||
matrix[4] = dy2-dy0+h*dy2;
|
||||
matrix[5] = h;
|
||||
matrix[6] = dx0;
|
||||
matrix[7] = dy0;
|
||||
matrix[8] = 1.0f;
|
||||
|
||||
return VGU_NO_ERROR;
|
||||
}
|
||||
|
||||
VGU_API_CALL VGUErrorCode vguComputeWarpQuadToQuad(VGfloat dx0, VGfloat dy0,
|
||||
VGfloat dx1, VGfloat dy1,
|
||||
VGfloat dx2, VGfloat dy2,
|
||||
VGfloat dx3, VGfloat dy3,
|
||||
VGfloat sx0, VGfloat sy0,
|
||||
VGfloat sx1, VGfloat sy1,
|
||||
VGfloat sx2, VGfloat sy2,
|
||||
VGfloat sx3, VGfloat sy3,
|
||||
VGfloat * matrix)
|
||||
{
|
||||
return VGU_NO_ERROR;
|
||||
}
|
||||
|
|
@ -1,499 +0,0 @@
|
|||
// The canvas for rendering with the 2d api
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "canvas.hxx"
|
||||
#include "elements/group.hxx"
|
||||
|
||||
#include <Canvas/MouseEvent.hxx>
|
||||
#include <Canvas/property_helper.hxx>
|
||||
#include <Main/fg_props.hxx>
|
||||
#include <Viewer/CameraGroup.hxx>
|
||||
#include <Viewer/renderer.hxx>
|
||||
|
||||
#include <simgear/scene/util/RenderConstants.hxx>
|
||||
|
||||
#include <osg/Camera>
|
||||
#include <osg/Geode>
|
||||
#include <osgText/Text>
|
||||
#include <osgViewer/Viewer>
|
||||
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
#include <iostream>
|
||||
|
||||
/**
|
||||
* Callback for resetting the render_dirty flag after rendering a frame.
|
||||
*/
|
||||
class Canvas::DrawCallback:
|
||||
public osg::Camera::DrawCallback
|
||||
{
|
||||
public:
|
||||
DrawCallback(Canvas* canvas):
|
||||
_canvas(canvas)
|
||||
{}
|
||||
|
||||
virtual void operator()(osg::RenderInfo& renderInfo) const
|
||||
{
|
||||
_canvas->_render_dirty = false;
|
||||
}
|
||||
|
||||
protected:
|
||||
Canvas *_canvas;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Canvas::CameraCullCallback::CameraCullCallback():
|
||||
_render( true ),
|
||||
_render_frame( 0 )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Canvas::CameraCullCallback::enableRendering()
|
||||
{
|
||||
_render = true;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Canvas::CameraCullCallback::operator()( osg::Node* node,
|
||||
osg::NodeVisitor* nv )
|
||||
{
|
||||
if( !_render && nv->getTraversalNumber() != _render_frame )
|
||||
return;
|
||||
|
||||
traverse(node, nv);
|
||||
|
||||
_render = false;
|
||||
_render_frame = nv->getTraversalNumber();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Canvas::CullCallback::CullCallback(CameraCullCallback* camera_cull):
|
||||
_camera_cull( camera_cull )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Canvas::CullCallback::operator()( osg::Node* node,
|
||||
osg::NodeVisitor* nv )
|
||||
{
|
||||
if( (nv->getTraversalMask() & simgear::MODEL_BIT) && _camera_cull.valid() )
|
||||
_camera_cull->enableRendering();
|
||||
|
||||
traverse(node, nv);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Canvas::Canvas(SGPropertyNode* node):
|
||||
PropertyBasedElement(node),
|
||||
_size_x(-1),
|
||||
_size_y(-1),
|
||||
_view_width(-1),
|
||||
_view_height(-1),
|
||||
_status(node, "status"),
|
||||
_status_msg(node, "status-msg"),
|
||||
_mouse_x(node, "mouse/x"),
|
||||
_mouse_y(node, "mouse/y"),
|
||||
_mouse_dx(node, "mouse/dx"),
|
||||
_mouse_dy(node, "mouse/dy"),
|
||||
_mouse_button(node, "mouse/button"),
|
||||
_mouse_state(node, "mouse/state"),
|
||||
_mouse_mod(node, "mouse/mod"),
|
||||
_mouse_scroll(node, "mouse/scroll"),
|
||||
_mouse_event(node, "mouse/event"),
|
||||
_sampling_dirty(false),
|
||||
_color_dirty(true),
|
||||
_render_dirty(true),
|
||||
_root_group( new canvas::Group(node) ),
|
||||
_render_always(false)
|
||||
{
|
||||
// Remove automatically created property listener as we forward them on our
|
||||
// own
|
||||
_root_group->removeListener();
|
||||
|
||||
_status = 0;
|
||||
setStatusFlags(MISSING_SIZE_X | MISSING_SIZE_Y);
|
||||
|
||||
_camera_callback = new CameraCullCallback;
|
||||
_cull_callback = new CullCallback(_camera_callback);
|
||||
|
||||
canvas::linkColorNodes
|
||||
(
|
||||
"color-background",
|
||||
_node,
|
||||
_color_background,
|
||||
osg::Vec4f(0,0,0,1)
|
||||
);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Canvas::~Canvas()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::update(double delta_time_sec)
|
||||
{
|
||||
if( !_texture.serviceable() )
|
||||
{
|
||||
if( _status != STATUS_OK )
|
||||
return;
|
||||
|
||||
_texture.setSize(_size_x, _size_y);
|
||||
_texture.useImageCoords(true);
|
||||
_texture.useStencil(true);
|
||||
_texture.allocRT(_camera_callback);
|
||||
|
||||
osg::Camera* camera = _texture.getCamera();
|
||||
camera->setClearColor(osg::Vec4(0.0f, 0.0f, 0.0f , 1.0f));
|
||||
camera->addChild(_root_group->getMatrixTransform());
|
||||
camera->setFinalDrawCallback(new DrawCallback(this));
|
||||
|
||||
// Ensure objects are drawn in order of traversal
|
||||
camera->getOrCreateStateSet()->setBinName("TraversalOrderBin");
|
||||
|
||||
if( _texture.serviceable() )
|
||||
{
|
||||
setStatusFlags(STATUS_OK);
|
||||
}
|
||||
else
|
||||
{
|
||||
setStatusFlags(CREATE_FAILED);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
_texture.setRender(_render_dirty);
|
||||
_root_group->update(delta_time_sec);
|
||||
|
||||
if( _sampling_dirty )
|
||||
{
|
||||
_texture.setSampling(
|
||||
_node->getBoolValue("mipmapping"),
|
||||
_node->getIntValue("coverage-samples"),
|
||||
_node->getIntValue("color-samples")
|
||||
);
|
||||
_sampling_dirty = false;
|
||||
_render_dirty = true;
|
||||
}
|
||||
if( _color_dirty )
|
||||
{
|
||||
_texture.getCamera()->setClearColor
|
||||
(
|
||||
osg::Vec4( _color_background[0]->getFloatValue(),
|
||||
_color_background[1]->getFloatValue(),
|
||||
_color_background[2]->getFloatValue(),
|
||||
_color_background[3]->getFloatValue() )
|
||||
);
|
||||
_color_dirty = false;
|
||||
_render_dirty = true;
|
||||
}
|
||||
|
||||
while( !_dirty_placements.empty() )
|
||||
{
|
||||
SGPropertyNode *node = _dirty_placements.back();
|
||||
_dirty_placements.pop_back();
|
||||
|
||||
if( node->getIndex() >= static_cast<int>(_placements.size()) )
|
||||
// New placement
|
||||
_placements.resize(node->getIndex() + 1);
|
||||
else
|
||||
// Remove possibly existing placements
|
||||
_placements[ node->getIndex() ].clear();
|
||||
|
||||
// Get new placements
|
||||
PlacementFactoryMap::const_iterator placement_factory =
|
||||
_placement_factories.find( node->getStringValue("type", "object") );
|
||||
if( placement_factory != _placement_factories.end() )
|
||||
{
|
||||
canvas::Placements& placements =
|
||||
_placements[ node->getIndex() ] =
|
||||
placement_factory->second
|
||||
(
|
||||
node,
|
||||
boost::static_pointer_cast<Canvas>(_self.lock())
|
||||
);
|
||||
node->setStringValue
|
||||
(
|
||||
"status-msg",
|
||||
placements.empty() ? "No match" : "Ok"
|
||||
);
|
||||
}
|
||||
else
|
||||
node->setStringValue("status-msg", "Unknown placement type");
|
||||
}
|
||||
|
||||
if( _render_always )
|
||||
_camera_callback->enableRendering();
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::setSizeX(int sx)
|
||||
{
|
||||
if( _size_x == sx )
|
||||
return;
|
||||
_size_x = sx;
|
||||
|
||||
// TODO resize if texture already allocated
|
||||
|
||||
if( _size_x <= 0 )
|
||||
setStatusFlags(MISSING_SIZE_X);
|
||||
else
|
||||
setStatusFlags(MISSING_SIZE_X, false);
|
||||
|
||||
// reset flag to allow creation with new size
|
||||
setStatusFlags(CREATE_FAILED, false);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::setSizeY(int sy)
|
||||
{
|
||||
if( _size_y == sy )
|
||||
return;
|
||||
_size_y = sy;
|
||||
|
||||
// TODO resize if texture already allocated
|
||||
|
||||
if( _size_y <= 0 )
|
||||
setStatusFlags(MISSING_SIZE_Y);
|
||||
else
|
||||
setStatusFlags(MISSING_SIZE_Y, false);
|
||||
|
||||
// reset flag to allow creation with new size
|
||||
setStatusFlags(CREATE_FAILED, false);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::setViewWidth(int w)
|
||||
{
|
||||
if( _view_width == w )
|
||||
return;
|
||||
_view_width = w;
|
||||
|
||||
_texture.setViewSize(_view_width, _view_height);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::setViewHeight(int h)
|
||||
{
|
||||
if( _view_height == h )
|
||||
return;
|
||||
_view_height = h;
|
||||
|
||||
_texture.setViewSize(_view_width, _view_height);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
bool Canvas::handleMouseEvent(const canvas::MouseEvent& event)
|
||||
{
|
||||
_mouse_x = event.x;
|
||||
_mouse_y = event.y;
|
||||
_mouse_dx = event.dx;
|
||||
_mouse_dy = event.dy;
|
||||
_mouse_button = event.button;
|
||||
_mouse_state = event.state;
|
||||
_mouse_mod = event.mod;
|
||||
_mouse_scroll = event.scroll;
|
||||
// Always set event type last because all listeners are attached to it
|
||||
_mouse_event = event.type;
|
||||
|
||||
return _root_group->handleMouseEvent(event);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::childAdded( SGPropertyNode * parent,
|
||||
SGPropertyNode * child )
|
||||
{
|
||||
if( parent != _node )
|
||||
return;
|
||||
|
||||
if( child->getNameString() == "placement" )
|
||||
_dirty_placements.push_back(child);
|
||||
else
|
||||
static_cast<canvas::Element*>(_root_group.get())
|
||||
->childAdded(parent, child);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::childRemoved( SGPropertyNode * parent,
|
||||
SGPropertyNode * child )
|
||||
{
|
||||
_render_dirty = true;
|
||||
|
||||
if( parent != _node )
|
||||
return;
|
||||
|
||||
if( child->getNameString() == "placement" )
|
||||
_placements[ child->getIndex() ].clear();
|
||||
else
|
||||
static_cast<canvas::Element*>(_root_group.get())
|
||||
->childRemoved(parent, child);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Canvas::valueChanged(SGPropertyNode* node)
|
||||
{
|
||||
if( boost::starts_with(node->getNameString(), "status")
|
||||
|| node->getParent()->getNameString() == "bounding-box" )
|
||||
return;
|
||||
_render_dirty = true;
|
||||
|
||||
bool handled = true;
|
||||
if( node->getParent()->getParent() == _node )
|
||||
{
|
||||
if( !_color_background.empty()
|
||||
&& _color_background[0]->getParent() == node->getParent() )
|
||||
{
|
||||
_color_dirty = true;
|
||||
}
|
||||
else if( node->getParent()->getNameString() == "placement" )
|
||||
{
|
||||
// prevent double updates...
|
||||
for( size_t i = 0; i < _dirty_placements.size(); ++i )
|
||||
{
|
||||
if( node->getParent() == _dirty_placements[i] )
|
||||
return;
|
||||
}
|
||||
|
||||
_dirty_placements.push_back(node->getParent());
|
||||
}
|
||||
else
|
||||
handled = false;
|
||||
}
|
||||
else if( node->getParent() == _node )
|
||||
{
|
||||
if( node->getNameString() == "mipmapping"
|
||||
|| node->getNameString() == "coverage-samples"
|
||||
|| node->getNameString() == "color-samples" )
|
||||
_sampling_dirty = true;
|
||||
else if( node->getNameString() == "render-always" )
|
||||
_render_always = node->getBoolValue();
|
||||
else if( node->getNameString() == "size" )
|
||||
{
|
||||
if( node->getIndex() == 0 )
|
||||
setSizeX( node->getIntValue() );
|
||||
else if( node->getIndex() == 1 )
|
||||
setSizeY( node->getIntValue() );
|
||||
}
|
||||
else if( node->getNameString() == "view" )
|
||||
{
|
||||
if( node->getIndex() == 0 )
|
||||
setViewWidth( node->getIntValue() );
|
||||
else if( node->getIndex() == 1 )
|
||||
setViewHeight( node->getIntValue() );
|
||||
}
|
||||
else if( node->getNameString() == "freeze" )
|
||||
_texture.setRender( node->getBoolValue() );
|
||||
else
|
||||
handled = false;
|
||||
}
|
||||
else
|
||||
handled = false;
|
||||
|
||||
if( !handled )
|
||||
_root_group->valueChanged(node);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
osg::Texture2D* Canvas::getTexture() const
|
||||
{
|
||||
return _texture.getTexture();
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
GLuint Canvas::getTexId() const
|
||||
{
|
||||
osg::Texture2D* tex = _texture.getTexture();
|
||||
if( !tex )
|
||||
return 0;
|
||||
|
||||
// osgViewer::Viewer::Contexts contexts;
|
||||
// globals->get_renderer()->getViewer()->getContexts(contexts);
|
||||
//
|
||||
// if( contexts.empty() )
|
||||
// return 0;
|
||||
|
||||
osg::Camera* guiCamera =
|
||||
flightgear::getGUICamera(flightgear::CameraGroup::getDefault());
|
||||
|
||||
osg::State* state = guiCamera->getGraphicsContext()->getState(); //contexts[0]->getState();
|
||||
if( !state )
|
||||
return 0;
|
||||
|
||||
osg::Texture::TextureObject* tobj =
|
||||
tex->getTextureObject( state->getContextID() );
|
||||
if( !tobj )
|
||||
return 0;
|
||||
|
||||
return tobj->_id;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Canvas::CameraCullCallbackPtr Canvas::getCameraCullCallback() const
|
||||
{
|
||||
return _camera_callback;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Canvas::CullCallbackPtr Canvas::getCullCallback() const
|
||||
{
|
||||
return _cull_callback;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::addPlacementFactory( const std::string& type,
|
||||
canvas::PlacementFactory factory )
|
||||
{
|
||||
if( _placement_factories.find(type) != _placement_factories.end() )
|
||||
SG_LOG
|
||||
(
|
||||
SG_GENERAL,
|
||||
SG_WARN,
|
||||
"Canvas::addPlacementFactory: replace existing factor for type " << type
|
||||
);
|
||||
|
||||
_placement_factories[type] = factory;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Canvas::setStatusFlags(unsigned int flags, bool set)
|
||||
{
|
||||
if( set )
|
||||
_status = _status | flags;
|
||||
else
|
||||
_status = _status & ~flags;
|
||||
// TODO maybe extend simgear::PropertyObject to allow |=, &= etc.
|
||||
|
||||
if( (_status & MISSING_SIZE_X) && (_status & MISSING_SIZE_Y) )
|
||||
_status_msg = "Missing size";
|
||||
else if( _status & MISSING_SIZE_X )
|
||||
_status_msg = "Missing size-x";
|
||||
else if( _status & MISSING_SIZE_Y )
|
||||
_status_msg = "Missing size-y";
|
||||
else if( _status & CREATE_FAILED )
|
||||
_status_msg = "Creating render target failed";
|
||||
else if( _status == STATUS_OK && !_texture.serviceable() )
|
||||
_status_msg = "Creation pending...";
|
||||
else
|
||||
_status_msg = "Ok";
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Canvas::PlacementFactoryMap Canvas::_placement_factories;
|
||||
|
|
@ -1,171 +0,0 @@
|
|||
// The canvas for rendering with the 2d api
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_HXX_
|
||||
#define CANVAS_HXX_
|
||||
|
||||
#include "placement.hxx"
|
||||
|
||||
#include <Canvas/canvas_fwd.hpp>
|
||||
#include <Cockpit/od_gauge.hxx>
|
||||
|
||||
#include <simgear/props/PropertyBasedElement.hxx>
|
||||
#include <simgear/props/propertyObject.hxx>
|
||||
#include <osg/NodeCallback>
|
||||
#include <osg/observer_ptr>
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
class Canvas:
|
||||
public simgear::PropertyBasedElement
|
||||
{
|
||||
public:
|
||||
|
||||
enum StatusFlags
|
||||
{
|
||||
STATUS_OK,
|
||||
MISSING_SIZE_X = 0x0001,
|
||||
MISSING_SIZE_Y = 0x0002,
|
||||
CREATE_FAILED = 0x0004
|
||||
};
|
||||
|
||||
/**
|
||||
* Callback used to disable/enable rendering to the texture if it is not
|
||||
* visible
|
||||
*/
|
||||
class CameraCullCallback:
|
||||
public osg::NodeCallback
|
||||
{
|
||||
public:
|
||||
CameraCullCallback();
|
||||
|
||||
/**
|
||||
* Enable rendering for the next frame
|
||||
*/
|
||||
void enableRendering();
|
||||
|
||||
private:
|
||||
bool _render;
|
||||
unsigned int _render_frame;
|
||||
|
||||
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
|
||||
};
|
||||
typedef osg::ref_ptr<CameraCullCallback> CameraCullCallbackPtr;
|
||||
typedef osg::observer_ptr<CameraCullCallback> CameraCullCallbackWeakPtr;
|
||||
|
||||
/**
|
||||
* This callback is installed on every placement of the canvas in the
|
||||
* scene to only render the canvas if at least one placement is visible
|
||||
*/
|
||||
class CullCallback:
|
||||
public osg::NodeCallback
|
||||
{
|
||||
public:
|
||||
CullCallback(CameraCullCallback* camera_cull);
|
||||
|
||||
private:
|
||||
CameraCullCallbackWeakPtr _camera_cull;
|
||||
|
||||
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
|
||||
};
|
||||
typedef osg::ref_ptr<CullCallback> CullCallbackPtr;
|
||||
|
||||
/**
|
||||
* Callback for resetting the render_dirty flag after rendering a frame.
|
||||
*/
|
||||
class DrawCallback;
|
||||
|
||||
Canvas(SGPropertyNode* node);
|
||||
virtual ~Canvas();
|
||||
|
||||
void update(double delta_time_sec);
|
||||
|
||||
int getSizeX() const
|
||||
{ return _size_x; }
|
||||
|
||||
int getSizeY() const
|
||||
{ return _size_y; }
|
||||
|
||||
void setSizeX(int sx);
|
||||
void setSizeY(int sy);
|
||||
|
||||
void setViewWidth(int w);
|
||||
void setViewHeight(int h);
|
||||
|
||||
bool handleMouseEvent(const canvas::MouseEvent& event);
|
||||
|
||||
virtual void childAdded( SGPropertyNode * parent,
|
||||
SGPropertyNode * child );
|
||||
virtual void childRemoved( SGPropertyNode * parent,
|
||||
SGPropertyNode * child );
|
||||
virtual void valueChanged (SGPropertyNode * node);
|
||||
|
||||
osg::Texture2D* getTexture() const;
|
||||
GLuint getTexId() const;
|
||||
|
||||
CameraCullCallbackPtr getCameraCullCallback() const;
|
||||
CullCallbackPtr getCullCallback() const;
|
||||
|
||||
static void addPlacementFactory( const std::string& type,
|
||||
canvas::PlacementFactory factory );
|
||||
|
||||
private:
|
||||
|
||||
Canvas(const Canvas&); // = delete;
|
||||
Canvas& operator=(const Canvas&); // = delete;
|
||||
|
||||
int _size_x,
|
||||
_size_y,
|
||||
_view_width,
|
||||
_view_height;
|
||||
|
||||
simgear::PropertyObject<int> _status;
|
||||
simgear::PropertyObject<std::string> _status_msg;
|
||||
|
||||
simgear::PropertyObject<int> _mouse_x, _mouse_y,
|
||||
_mouse_dx, _mouse_dy,
|
||||
_mouse_button,
|
||||
_mouse_state,
|
||||
_mouse_mod,
|
||||
_mouse_scroll,
|
||||
_mouse_event;
|
||||
|
||||
bool _sampling_dirty,
|
||||
_color_dirty,
|
||||
_render_dirty;
|
||||
|
||||
FGODGauge _texture;
|
||||
std::auto_ptr<canvas::Group> _root_group;
|
||||
|
||||
std::vector<SGPropertyNode_ptr> _color_background;
|
||||
|
||||
CameraCullCallbackPtr _camera_callback;
|
||||
CullCallbackPtr _cull_callback;
|
||||
bool _render_always; //<! Used to disable automatic lazy rendering (culling)
|
||||
|
||||
std::vector<SGPropertyNode*> _dirty_placements;
|
||||
std::vector<canvas::Placements> _placements;
|
||||
|
||||
typedef std::map<std::string, canvas::PlacementFactory> PlacementFactoryMap;
|
||||
static PlacementFactoryMap _placement_factories;
|
||||
|
||||
void setStatusFlags(unsigned int flags, bool set = true);
|
||||
};
|
||||
|
||||
#endif /* CANVAS_HXX_ */
|
||||
|
|
@ -19,29 +19,11 @@
|
|||
#ifndef CANVAS_FWD_HPP_
|
||||
#define CANVAS_FWD_HPP_
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/weak_ptr.hpp>
|
||||
#include <vector>
|
||||
|
||||
class SGPropertyNode;
|
||||
|
||||
class Canvas;
|
||||
typedef boost::shared_ptr<Canvas> CanvasPtr;
|
||||
typedef boost::weak_ptr<Canvas> CanvasWeakPtr;
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
class Group;
|
||||
class Image;
|
||||
class MouseEvent;
|
||||
|
||||
class Placement;
|
||||
typedef boost::shared_ptr<Placement> PlacementPtr;
|
||||
typedef std::vector<PlacementPtr> Placements;
|
||||
typedef boost::function<Placements( const SGPropertyNode*,
|
||||
CanvasPtr )> PlacementFactory;
|
||||
|
||||
class Window;
|
||||
typedef boost::shared_ptr<Window> WindowPtr;
|
||||
typedef boost::weak_ptr<Window> WindowWeakPtr;
|
||||
|
|
|
|||
|
|
@ -17,25 +17,23 @@
|
|||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "canvas_mgr.hxx"
|
||||
#include "canvas.hxx"
|
||||
|
||||
#include <Canvas/FGCanvasSystemAdapter.hxx>
|
||||
#include <Cockpit/od_gauge.hxx>
|
||||
#include <Main/fg_props.hxx>
|
||||
#include <Viewer/CameraGroup.hxx>
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
typedef boost::shared_ptr<Canvas> CanvasPtr;
|
||||
CanvasPtr canvasFactory(SGPropertyNode* node)
|
||||
{
|
||||
return CanvasPtr(new Canvas(node));
|
||||
}
|
||||
|
||||
#include <simgear/canvas/Canvas.hxx>
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
CanvasMgr::CanvasMgr():
|
||||
PropertyBasedMgr( fgGetNode("/canvas/by-index", true),
|
||||
"texture",
|
||||
&canvasFactory )
|
||||
simgear::canvas::CanvasMgr
|
||||
(
|
||||
fgGetNode("/canvas/by-index", true),
|
||||
simgear::canvas::SystemAdapterPtr( new canvas::FGCanvasSystemAdapter )
|
||||
)
|
||||
{
|
||||
using simgear::canvas::Canvas;
|
||||
Canvas::addPlacementFactory
|
||||
(
|
||||
"object",
|
||||
|
|
@ -49,22 +47,35 @@ CanvasMgr::CanvasMgr():
|
|||
);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
CanvasPtr CanvasMgr::getCanvas(size_t index) const
|
||||
{
|
||||
if( index >= _elements.size()
|
||||
|| !_elements[index] )
|
||||
return CanvasPtr();
|
||||
|
||||
return boost::static_pointer_cast<Canvas>(_elements[index]);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
unsigned int CanvasMgr::getCanvasTexId(size_t index) const
|
||||
{
|
||||
CanvasPtr canvas = getCanvas(index);
|
||||
if( canvas )
|
||||
return canvas->getTexId();
|
||||
else
|
||||
simgear::canvas::CanvasPtr canvas = getCanvas(index);
|
||||
|
||||
if( !canvas )
|
||||
return 0;
|
||||
|
||||
osg::Texture2D* tex = canvas->getTexture();
|
||||
if( !tex )
|
||||
return 0;
|
||||
|
||||
// osgViewer::Viewer::Contexts contexts;
|
||||
// globals->get_renderer()->getViewer()->getContexts(contexts);
|
||||
//
|
||||
// if( contexts.empty() )
|
||||
// return 0;
|
||||
|
||||
osg::Camera* guiCamera =
|
||||
flightgear::getGUICamera(flightgear::CameraGroup::getDefault());
|
||||
|
||||
osg::State* state = guiCamera->getGraphicsContext()->getState(); //contexts[0]->getState();
|
||||
if( !state )
|
||||
return 0;
|
||||
|
||||
osg::Texture::TextureObject* tobj =
|
||||
tex->getTextureObject( state->getContextID() );
|
||||
if( !tobj )
|
||||
return 0;
|
||||
|
||||
return tobj->_id;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,22 +19,15 @@
|
|||
#ifndef CANVAS_MGR_H_
|
||||
#define CANVAS_MGR_H_
|
||||
|
||||
#include "canvas_fwd.hpp"
|
||||
#include <simgear/canvas/CanvasMgr.hxx>
|
||||
#include <simgear/props/PropertyBasedMgr.hxx>
|
||||
|
||||
class CanvasMgr:
|
||||
public simgear::PropertyBasedMgr
|
||||
public simgear::canvas::CanvasMgr
|
||||
{
|
||||
public:
|
||||
CanvasMgr();
|
||||
|
||||
/**
|
||||
* Get ::Canvas by index
|
||||
*
|
||||
* @param index Index of texture node in /canvas/by-index/
|
||||
*/
|
||||
CanvasPtr getCanvas(size_t index) const;
|
||||
|
||||
/**
|
||||
* Get OpenGL texture name for given canvas
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,343 +0,0 @@
|
|||
// An image on the canvas
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "CanvasImage.hxx"
|
||||
|
||||
#include <osgDB/ReadFile>
|
||||
|
||||
#include <Canvas/canvas.hxx>
|
||||
#include <Canvas/canvas_mgr.hxx>
|
||||
#include <Canvas/property_helper.hxx>
|
||||
#include <osg/Array>
|
||||
#include <osg/Geometry>
|
||||
#include <osg/PrimitiveSet>
|
||||
|
||||
#include <Main/globals.hxx>
|
||||
#include <Main/fg_props.hxx>
|
||||
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
|
||||
/**
|
||||
* Callback to enable/disable rendering of canvas displayed inside windows or
|
||||
* other canvases.
|
||||
*/
|
||||
class CullCallback:
|
||||
public osg::Drawable::CullCallback
|
||||
{
|
||||
public:
|
||||
CullCallback(Canvas::CameraCullCallback* camera_cull);
|
||||
|
||||
private:
|
||||
Canvas::CameraCullCallbackWeakPtr _camera_cull;
|
||||
|
||||
virtual bool cull( osg::NodeVisitor* nv,
|
||||
osg::Drawable* drawable,
|
||||
osg::RenderInfo* renderInfo ) const;
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
CullCallback::CullCallback(Canvas::CameraCullCallback* camera_cull):
|
||||
_camera_cull( camera_cull )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
bool CullCallback::cull( osg::NodeVisitor* nv,
|
||||
osg::Drawable* drawable,
|
||||
osg::RenderInfo* renderInfo ) const
|
||||
{
|
||||
if( _camera_cull.valid() )
|
||||
_camera_cull->enableRendering();
|
||||
|
||||
// TODO check if window/image should be culled
|
||||
return false;
|
||||
}
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
//----------------------------------------------------------------------------
|
||||
Image::Image(SGPropertyNode_ptr node, const Style& parent_style):
|
||||
Element(node, parent_style),
|
||||
_texture(new osg::Texture2D),
|
||||
_node_src_rect( node->getNode("source", 0, true) )
|
||||
{
|
||||
_geom = new osg::Geometry;
|
||||
_geom->setUseDisplayList(false);
|
||||
|
||||
osg::StateSet *stateSet = _geom->getOrCreateStateSet();
|
||||
stateSet->setTextureAttributeAndModes(0, _texture.get());
|
||||
stateSet->setDataVariance(osg::Object::STATIC);
|
||||
|
||||
// allocate arrays for the image
|
||||
_vertices = new osg::Vec3Array(4);
|
||||
_vertices->setDataVariance(osg::Object::STATIC);
|
||||
_geom->setVertexArray(_vertices);
|
||||
|
||||
_texCoords = new osg::Vec2Array(4);
|
||||
_texCoords->setDataVariance(osg::Object::STATIC);
|
||||
_geom->setTexCoordArray(0, _texCoords);
|
||||
|
||||
_colors = new osg::Vec4Array(4);
|
||||
_colors->setDataVariance(osg::Object::STATIC);
|
||||
_geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
|
||||
_geom->setColorArray(_colors);
|
||||
|
||||
osg::DrawArrays* prim = new osg::DrawArrays(osg::PrimitiveSet::QUADS);
|
||||
prim->set(osg::PrimitiveSet::QUADS, 0, 4);
|
||||
prim->setDataVariance(osg::Object::STATIC);
|
||||
_geom->addPrimitiveSet(prim);
|
||||
|
||||
setDrawable(_geom);
|
||||
|
||||
addStyle("fill", &Image::setFill, this);
|
||||
setFill("#ffffff"); // TODO how should we handle default values?
|
||||
|
||||
setupStyle();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Image::~Image()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Image::update(double dt)
|
||||
{
|
||||
Element::update(dt);
|
||||
|
||||
if( _attributes_dirty & DEST_SIZE )
|
||||
{
|
||||
(*_vertices)[0].set(_region.l(), _region.t(), 0);
|
||||
(*_vertices)[1].set(_region.r(), _region.t(), 0);
|
||||
(*_vertices)[2].set(_region.r(), _region.b(), 0);
|
||||
(*_vertices)[3].set(_region.l(), _region.b(), 0);
|
||||
_vertices->dirty();
|
||||
|
||||
_attributes_dirty &= ~DEST_SIZE;
|
||||
_geom->dirtyBound();
|
||||
setBoundingBox(_geom->getBound());
|
||||
}
|
||||
|
||||
if( _attributes_dirty & SRC_RECT )
|
||||
{
|
||||
double u0 = _src_rect.l(),
|
||||
u1 = _src_rect.r(),
|
||||
v0 = _src_rect.b(),
|
||||
v1 = _src_rect.t();
|
||||
|
||||
if( !_node_src_rect->getBoolValue("normalized", true) )
|
||||
{
|
||||
const Rect<int>& tex_dim = getTextureDimensions();
|
||||
|
||||
u0 /= tex_dim.width();
|
||||
u1 /= tex_dim.width();
|
||||
v0 /= tex_dim.height();
|
||||
v1 /= tex_dim.height();
|
||||
}
|
||||
|
||||
(*_texCoords)[0].set(u0, v0);
|
||||
(*_texCoords)[1].set(u1, v0);
|
||||
(*_texCoords)[2].set(u1, v1);
|
||||
(*_texCoords)[3].set(u0, v1);
|
||||
_texCoords->dirty();
|
||||
|
||||
_attributes_dirty &= ~SRC_RECT;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Image::setCanvas(CanvasPtr canvas)
|
||||
{
|
||||
_canvas = canvas;
|
||||
_geom->getOrCreateStateSet()
|
||||
->setTextureAttribute(0, canvas ? canvas->getTexture() : 0);
|
||||
_geom->setCullCallback(
|
||||
canvas ? new CullCallback(canvas->getCameraCullCallback()) : 0
|
||||
);
|
||||
|
||||
if( !_canvas.expired() )
|
||||
setupDefaultDimensions();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
CanvasWeakPtr Image::getCanvas() const
|
||||
{
|
||||
return _canvas;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Image::setImage(osg::Image *img)
|
||||
{
|
||||
// remove canvas...
|
||||
setCanvas( CanvasPtr() );
|
||||
|
||||
_texture->setImage(img);
|
||||
_geom->getOrCreateStateSet()
|
||||
->setTextureAttributeAndModes(0, _texture);
|
||||
|
||||
if( img )
|
||||
setupDefaultDimensions();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Image::setFill(const std::string& fill)
|
||||
{
|
||||
osg::Vec4 color = parseColor(fill);
|
||||
for( int i = 0; i < 4; ++i )
|
||||
(*_colors)[i] = color;
|
||||
_colors->dirty();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
const Rect<float>& Image::getRegion() const
|
||||
{
|
||||
return _region;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Image::childChanged(SGPropertyNode* child)
|
||||
{
|
||||
const std::string& name = child->getNameString();
|
||||
|
||||
if( child->getParent() == _node_src_rect )
|
||||
{
|
||||
_attributes_dirty |= SRC_RECT;
|
||||
|
||||
if( name == "left" )
|
||||
_src_rect.setLeft( child->getFloatValue() );
|
||||
else if( name == "right" )
|
||||
_src_rect.setRight( child->getFloatValue() );
|
||||
else if( name == "top" )
|
||||
_src_rect.setTop( child->getFloatValue() );
|
||||
else if( name == "bottom" )
|
||||
_src_rect.setBottom( child->getFloatValue() );
|
||||
|
||||
return;
|
||||
}
|
||||
else if( child->getParent() != _node )
|
||||
return;
|
||||
|
||||
if( name == "x" )
|
||||
{
|
||||
_region.setX( child->getFloatValue() );
|
||||
_attributes_dirty |= DEST_SIZE;
|
||||
}
|
||||
else if( name == "y" )
|
||||
{
|
||||
_region.setY( child->getFloatValue() );
|
||||
_attributes_dirty |= DEST_SIZE;
|
||||
}
|
||||
else if( name == "size" )
|
||||
{
|
||||
if( child->getIndex() == 0 )
|
||||
_region.setWidth( child->getFloatValue() );
|
||||
else
|
||||
_region.setHeight( child->getFloatValue() );
|
||||
|
||||
_attributes_dirty |= DEST_SIZE;
|
||||
}
|
||||
else if( name == "file" )
|
||||
{
|
||||
static const std::string CANVAS_PROTOCOL = "canvas://";
|
||||
const std::string& path = child->getStringValue();
|
||||
|
||||
if( boost::starts_with(path, CANVAS_PROTOCOL) )
|
||||
{
|
||||
CanvasMgr* canvas_mgr =
|
||||
dynamic_cast<CanvasMgr*>(globals->get_subsystem("Canvas"));
|
||||
if( !canvas_mgr )
|
||||
{
|
||||
SG_LOG(SG_GL, SG_ALERT, "canvas::Image: Failed to get CanvasMgr");
|
||||
return;
|
||||
}
|
||||
|
||||
const SGPropertyNode* canvas_node =
|
||||
canvas_mgr->getPropertyRoot()
|
||||
->getParent()
|
||||
->getNode( path.substr(CANVAS_PROTOCOL.size()) );
|
||||
if( !canvas_node )
|
||||
{
|
||||
SG_LOG(SG_GL, SG_ALERT, "canvas::Image: No such canvas: " << path);
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO add support for other means of addressing canvases (eg. by
|
||||
// name)
|
||||
CanvasPtr canvas = canvas_mgr->getCanvas( canvas_node->getIndex() );
|
||||
if( !canvas )
|
||||
{
|
||||
SG_LOG(SG_GL, SG_ALERT, "canvas::Image: Invalid canvas: " << path);
|
||||
return;
|
||||
}
|
||||
|
||||
setCanvas(canvas);
|
||||
}
|
||||
else
|
||||
{
|
||||
SGPath tpath = globals->resolve_resource_path(path);
|
||||
if( tpath.isNull() || !tpath.exists() )
|
||||
{
|
||||
SG_LOG(SG_GL, SG_ALERT, "canvas::Image: No such image: " << path);
|
||||
return;
|
||||
}
|
||||
|
||||
setImage( osgDB::readImageFile(tpath.c_str()) );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Image::setupDefaultDimensions()
|
||||
{
|
||||
if( !_src_rect.width() || !_src_rect.height() )
|
||||
{
|
||||
const Rect<int>& tex_dim = getTextureDimensions();
|
||||
|
||||
_node_src_rect->setBoolValue("normalized", false);
|
||||
_node_src_rect->setFloatValue("right", tex_dim.width());
|
||||
_node_src_rect->setFloatValue("bottom", tex_dim.height());
|
||||
}
|
||||
|
||||
if( !_region.width() || !_region.height() )
|
||||
{
|
||||
_node->setFloatValue("size[0]", _src_rect.width());
|
||||
_node->setFloatValue("size[1]", _src_rect.height());
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Rect<int> Image::getTextureDimensions() const
|
||||
{
|
||||
osg::Texture2D *texture = !_canvas.expired()
|
||||
? _canvas.lock()->getTexture()
|
||||
: _texture.get();
|
||||
|
||||
if( !texture )
|
||||
return Rect<int>();
|
||||
|
||||
return Rect<int>
|
||||
(
|
||||
0,0,
|
||||
texture->getTextureWidth(),
|
||||
texture->getTextureHeight()
|
||||
);
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
// An image on the canvas
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_IMAGE_HXX_
|
||||
#define CANVAS_IMAGE_HXX_
|
||||
|
||||
#include "element.hxx"
|
||||
#include <Canvas/canvas_fwd.hpp>
|
||||
#include <Canvas/rect.hxx>
|
||||
|
||||
#include <osg/Texture2D>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
class Image:
|
||||
public Element
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* @param node Property node containing settings for this image:
|
||||
* rect/[left/right/top/bottom] Dimensions of source
|
||||
* rect
|
||||
* size[0-1] Dimensions of rectangle
|
||||
* [x,y] Position of rectangle
|
||||
*/
|
||||
Image(SGPropertyNode_ptr node, const Style& parent_style);
|
||||
virtual ~Image();
|
||||
|
||||
virtual void update(double dt);
|
||||
|
||||
void setCanvas(CanvasPtr canvas);
|
||||
CanvasWeakPtr getCanvas() const;
|
||||
|
||||
void setImage(osg::Image *img);
|
||||
void setFill(const std::string& fill);
|
||||
|
||||
const Rect<float>& getRegion() const;
|
||||
|
||||
protected:
|
||||
|
||||
enum ImageAttributes
|
||||
{
|
||||
SRC_RECT = LAST_ATTRIBUTE << 1, // Source image rectangle
|
||||
DEST_SIZE = SRC_RECT << 1 // Element size
|
||||
};
|
||||
|
||||
virtual void childChanged(SGPropertyNode * child);
|
||||
|
||||
void setupDefaultDimensions();
|
||||
Rect<int> getTextureDimensions() const;
|
||||
|
||||
osg::ref_ptr<osg::Texture2D> _texture;
|
||||
// TODO optionally forward events to canvas
|
||||
CanvasWeakPtr _canvas;
|
||||
|
||||
osg::ref_ptr<osg::Geometry> _geom;
|
||||
osg::ref_ptr<osg::Vec3Array> _vertices;
|
||||
osg::ref_ptr<osg::Vec2Array> _texCoords;
|
||||
osg::ref_ptr<osg::Vec4Array> _colors;
|
||||
|
||||
SGPropertyNode *_node_src_rect;
|
||||
Rect<float> _src_rect,
|
||||
_region;
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_IMAGE_HXX_ */
|
||||
|
|
@ -1,300 +0,0 @@
|
|||
// Interface for 2D canvas element
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "element.hxx"
|
||||
#include <Canvas/MouseEvent.hxx>
|
||||
#include <Canvas/property_helper.hxx>
|
||||
|
||||
#include <osg/Drawable>
|
||||
#include <osg/Geode>
|
||||
|
||||
#include <boost/foreach.hpp>
|
||||
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
const std::string NAME_TRANSFORM = "tf";
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::removeListener()
|
||||
{
|
||||
_node->removeChangeListener(this);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Element::~Element()
|
||||
{
|
||||
removeListener();
|
||||
|
||||
BOOST_FOREACH(osg::Group* parent, _transform->getParents())
|
||||
{
|
||||
parent->removeChild(_transform);
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::update(double dt)
|
||||
{
|
||||
if( !_transform->getNodeMask() )
|
||||
// Don't do anything if element is hidden
|
||||
return;
|
||||
|
||||
if( _transform_dirty )
|
||||
{
|
||||
osg::Matrix m;
|
||||
for( size_t i = 0; i < _transform_types.size(); ++i )
|
||||
{
|
||||
// Skip unused indizes...
|
||||
if( _transform_types[i] == TT_NONE )
|
||||
continue;
|
||||
|
||||
SGPropertyNode* tf_node = _node->getChild("tf", i, true);
|
||||
|
||||
// Build up the matrix representation of the current transform node
|
||||
osg::Matrix tf;
|
||||
switch( _transform_types[i] )
|
||||
{
|
||||
case TT_MATRIX:
|
||||
tf = osg::Matrix( tf_node->getDoubleValue("m[0]", 1),
|
||||
tf_node->getDoubleValue("m[1]", 0), 0, 0,
|
||||
|
||||
tf_node->getDoubleValue("m[2]", 0),
|
||||
tf_node->getDoubleValue("m[3]", 1), 0, 0,
|
||||
|
||||
0, 0, 1, 0,
|
||||
tf_node->getDoubleValue("m[4]", 0),
|
||||
tf_node->getDoubleValue("m[5]", 0), 0, 1 );
|
||||
break;
|
||||
case TT_TRANSLATE:
|
||||
tf.makeTranslate( osg::Vec3f( tf_node->getDoubleValue("t[0]", 0),
|
||||
tf_node->getDoubleValue("t[1]", 0),
|
||||
0 ) );
|
||||
break;
|
||||
case TT_ROTATE:
|
||||
tf.makeRotate( tf_node->getDoubleValue("rot", 0), 0, 0, 1 );
|
||||
break;
|
||||
case TT_SCALE:
|
||||
{
|
||||
float sx = tf_node->getDoubleValue("s[0]", 1);
|
||||
// sy defaults to sx...
|
||||
tf.makeScale( sx, tf_node->getDoubleValue("s[1]", sx), 1 );
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
m.postMult( tf );
|
||||
}
|
||||
_transform->setMatrix(m);
|
||||
_transform_dirty = false;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool Element::handleMouseEvent(const canvas::MouseEvent& event)
|
||||
{
|
||||
// Transform event to local coordinates
|
||||
const osg::Matrixd& m = _transform->getInverseMatrix();
|
||||
canvas::MouseEvent local_event = event;
|
||||
local_event.x = m(0, 0) * event.x + m(1, 0) * event.y + m(3, 0);
|
||||
local_event.y = m(0, 1) * event.x + m(1, 1) * event.y + m(3, 1);
|
||||
|
||||
// Drawables have a bounding box...
|
||||
if( _drawable )
|
||||
{
|
||||
if( !_drawable->getBound().contains(local_event.getPos3()) )
|
||||
return false;
|
||||
}
|
||||
// ... for other elements, i.e. groups only a bounding sphere is available
|
||||
else if( !_transform->getBound().contains(local_event.getPos3()) )
|
||||
return false;
|
||||
|
||||
local_event.dx = m(0, 0) * event.dx + m(1, 0) * event.dy;
|
||||
local_event.dy = m(0, 1) * event.dx + m(1, 1) * event.dy;
|
||||
|
||||
return handleLocalMouseEvent(local_event);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
osg::ref_ptr<osg::MatrixTransform> Element::getMatrixTransform()
|
||||
{
|
||||
return _transform;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::childAdded(SGPropertyNode* parent, SGPropertyNode* child)
|
||||
{
|
||||
if( parent == _node
|
||||
&& child->getNameString() == NAME_TRANSFORM )
|
||||
{
|
||||
if( child->getIndex() >= static_cast<int>(_transform_types.size()) )
|
||||
_transform_types.resize( child->getIndex() + 1 );
|
||||
|
||||
_transform_types[ child->getIndex() ] = TT_NONE;
|
||||
_transform_dirty = true;
|
||||
return;
|
||||
}
|
||||
else if( parent->getParent() == _node
|
||||
&& parent->getNameString() == NAME_TRANSFORM )
|
||||
{
|
||||
assert(parent->getIndex() < static_cast<int>(_transform_types.size()));
|
||||
|
||||
const std::string& name = child->getNameString();
|
||||
|
||||
TransformType& type = _transform_types[parent->getIndex()];
|
||||
|
||||
if( name == "m" )
|
||||
type = TT_MATRIX;
|
||||
else if( name == "t" )
|
||||
type = TT_TRANSLATE;
|
||||
else if( name == "rot" )
|
||||
type = TT_ROTATE;
|
||||
else if( name == "s" )
|
||||
type = TT_SCALE;
|
||||
|
||||
_transform_dirty = true;
|
||||
return;
|
||||
}
|
||||
|
||||
childAdded(child);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::childRemoved(SGPropertyNode* parent, SGPropertyNode* child)
|
||||
{
|
||||
if( parent == _node && child->getNameString() == NAME_TRANSFORM )
|
||||
{
|
||||
assert(child->getIndex() < static_cast<int>(_transform_types.size()));
|
||||
_transform_types[ child->getIndex() ] = TT_NONE;
|
||||
|
||||
while( !_transform_types.empty() && _transform_types.back() == TT_NONE )
|
||||
_transform_types.pop_back();
|
||||
|
||||
_transform_dirty = true;
|
||||
return;
|
||||
}
|
||||
|
||||
childRemoved(child);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::valueChanged(SGPropertyNode* child)
|
||||
{
|
||||
SGPropertyNode *parent = child->getParent();
|
||||
if( parent == _node )
|
||||
{
|
||||
if( setStyle(child) )
|
||||
return;
|
||||
else if( child->getNameString() == "update" )
|
||||
return update(0);
|
||||
else if( child->getNameString() == "visible" )
|
||||
// TODO check if we need another nodemask
|
||||
return _transform->setNodeMask( child->getBoolValue() ? 0xffffffff : 0 );
|
||||
}
|
||||
else if( parent->getParent() == _node
|
||||
&& parent->getNameString() == NAME_TRANSFORM )
|
||||
{
|
||||
_transform_dirty = true;
|
||||
return;
|
||||
}
|
||||
|
||||
childChanged(child);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::setBoundingBox(const osg::BoundingBox& bb)
|
||||
{
|
||||
if( _bounding_box.empty() )
|
||||
{
|
||||
SGPropertyNode* bb_node = _node->getChild("bounding-box", 0, true);
|
||||
_bounding_box.resize(4);
|
||||
_bounding_box[0] = bb_node->getChild("min-x", 0, true);
|
||||
_bounding_box[1] = bb_node->getChild("min-y", 0, true);
|
||||
_bounding_box[2] = bb_node->getChild("max-x", 0, true);
|
||||
_bounding_box[3] = bb_node->getChild("max-y", 0, true);
|
||||
}
|
||||
|
||||
_bounding_box[0]->setFloatValue(bb._min.x());
|
||||
_bounding_box[1]->setFloatValue(bb._min.y());
|
||||
_bounding_box[2]->setFloatValue(bb._max.x());
|
||||
_bounding_box[3]->setFloatValue(bb._max.y());
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Element::Element( SGPropertyNode_ptr node,
|
||||
const Style& parent_style ):
|
||||
_transform_dirty( false ),
|
||||
_transform( new osg::MatrixTransform ),
|
||||
_node( node ),
|
||||
_style( parent_style ),
|
||||
_drawable( 0 )
|
||||
{
|
||||
assert( _node );
|
||||
_node->addChangeListener(this);
|
||||
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_DEBUG,
|
||||
"New canvas element " << node->getPath()
|
||||
);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool Element::handleLocalMouseEvent(const canvas::MouseEvent& event)
|
||||
{
|
||||
std::cout << _node->getPath()
|
||||
<< " local: pos=(" << event.x << "|" << event.y << ") "
|
||||
<< "d=(" << event.dx << "|" << event.dx << ")"
|
||||
<< std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::setDrawable( osg::Drawable* drawable )
|
||||
{
|
||||
_drawable = drawable;
|
||||
assert( _drawable );
|
||||
|
||||
osg::ref_ptr<osg::Geode> geode = new osg::Geode;
|
||||
geode->addDrawable(_drawable);
|
||||
_transform->addChild(geode);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Element::setupStyle()
|
||||
{
|
||||
BOOST_FOREACH( Style::value_type style, _style )
|
||||
setStyle(style.second);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool Element::setStyle(const SGPropertyNode* child)
|
||||
{
|
||||
StyleSetters::const_iterator setter =
|
||||
_style_setters.find(child->getNameString());
|
||||
if( setter == _style_setters.end() )
|
||||
return false;
|
||||
|
||||
setter->second(child);
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,157 +0,0 @@
|
|||
// Interface for 2D canvas element
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_ELEMENT_HXX_
|
||||
#define CANVAS_ELEMENT_HXX_
|
||||
|
||||
#include <simgear/props/props.hxx>
|
||||
#include <simgear/misc/stdint.hxx> // for uint32_t
|
||||
#include <osg/BoundingBox>
|
||||
#include <osg/MatrixTransform>
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/function.hpp>
|
||||
|
||||
namespace osg
|
||||
{
|
||||
class Drawable;
|
||||
}
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
class MouseEvent;
|
||||
class Element:
|
||||
public SGPropertyChangeListener
|
||||
{
|
||||
public:
|
||||
typedef std::map<std::string, const SGPropertyNode*> Style;
|
||||
typedef boost::function<void(const SGPropertyNode*)> StyleSetter;
|
||||
typedef std::map<std::string, StyleSetter> StyleSetters;
|
||||
|
||||
void removeListener();
|
||||
virtual ~Element() = 0;
|
||||
|
||||
/**
|
||||
* Called every frame to update internal state
|
||||
*
|
||||
* @param dt Frame time in seconds
|
||||
*/
|
||||
virtual void update(double dt);
|
||||
|
||||
virtual bool handleMouseEvent(const canvas::MouseEvent& event);
|
||||
|
||||
osg::ref_ptr<osg::MatrixTransform> getMatrixTransform();
|
||||
|
||||
virtual void childAdded( SGPropertyNode * parent,
|
||||
SGPropertyNode * child );
|
||||
virtual void childRemoved( SGPropertyNode * parent,
|
||||
SGPropertyNode * child );
|
||||
virtual void valueChanged(SGPropertyNode * child);
|
||||
|
||||
/**
|
||||
* Write the given bounding box to the property tree
|
||||
*/
|
||||
void setBoundingBox(const osg::BoundingBox& bb);
|
||||
|
||||
protected:
|
||||
|
||||
enum Attributes
|
||||
{
|
||||
LAST_ATTRIBUTE = 0x0001
|
||||
};
|
||||
|
||||
enum TransformType
|
||||
{
|
||||
TT_NONE,
|
||||
TT_MATRIX,
|
||||
TT_TRANSLATE,
|
||||
TT_ROTATE,
|
||||
TT_SCALE
|
||||
};
|
||||
|
||||
uint32_t _attributes_dirty;
|
||||
|
||||
bool _transform_dirty;
|
||||
osg::ref_ptr<osg::MatrixTransform> _transform;
|
||||
std::vector<TransformType> _transform_types;
|
||||
|
||||
SGPropertyNode_ptr _node;
|
||||
Style _style;
|
||||
StyleSetters _style_setters;
|
||||
std::vector<SGPropertyNode_ptr> _bounding_box;
|
||||
|
||||
Element( SGPropertyNode_ptr node,
|
||||
const Style& parent_style );
|
||||
|
||||
template<typename T, class C1, class C2>
|
||||
Element::StyleSetter
|
||||
addStyle(const std::string& name, void (C1::*setter)(T), C2 instance)
|
||||
{
|
||||
return _style_setters[ name ] =
|
||||
bindStyleSetter<T>(name, setter, instance);
|
||||
}
|
||||
|
||||
template<typename T1, typename T2, class C1, class C2>
|
||||
Element::StyleSetter
|
||||
addStyle(const std::string& name, void (C1::*setter)(T2), C2 instance)
|
||||
{
|
||||
return _style_setters[ name ] =
|
||||
bindStyleSetter<T1>(name, setter, instance);
|
||||
}
|
||||
|
||||
template<class C1, class C2>
|
||||
Element::StyleSetter
|
||||
addStyle( const std::string& name,
|
||||
void (C1::*setter)(const std::string&),
|
||||
C2 instance )
|
||||
{
|
||||
return _style_setters[ name ] =
|
||||
bindStyleSetter<const char*>(name, setter, instance);
|
||||
}
|
||||
|
||||
template<typename T1, typename T2, class C1, class C2>
|
||||
Element::StyleSetter
|
||||
bindStyleSetter( const std::string& name,
|
||||
void (C1::*setter)(T2),
|
||||
C2 instance )
|
||||
{
|
||||
return boost::bind(setter, instance, boost::bind(&getValue<T1>, _1));
|
||||
}
|
||||
|
||||
virtual bool handleLocalMouseEvent(const canvas::MouseEvent& event);
|
||||
|
||||
virtual void childAdded(SGPropertyNode * child) {}
|
||||
virtual void childRemoved(SGPropertyNode * child){}
|
||||
virtual void childChanged(SGPropertyNode * child){}
|
||||
|
||||
void setDrawable(osg::Drawable* drawable);
|
||||
|
||||
void setupStyle();
|
||||
bool setStyle(const SGPropertyNode* child);
|
||||
|
||||
private:
|
||||
|
||||
osg::ref_ptr<osg::Drawable> _drawable;
|
||||
|
||||
Element(const Element&);// = delete
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_ELEMENT_HXX_ */
|
||||
|
|
@ -1,214 +0,0 @@
|
|||
// A group of 2D canvas elements
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "group.hxx"
|
||||
#include "map.hxx"
|
||||
#include "path.hxx"
|
||||
#include "text.hxx"
|
||||
#include "CanvasImage.hxx"
|
||||
|
||||
#include <boost/foreach.hpp>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Group::Group(SGPropertyNode_ptr node, const Style& parent_style):
|
||||
Element(node, parent_style)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Group::~Group()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Group::update(double dt)
|
||||
{
|
||||
BOOST_FOREACH( ChildList::value_type child, _children )
|
||||
child.second->update(dt);
|
||||
|
||||
Element::update(dt);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool Group::handleLocalMouseEvent(const canvas::MouseEvent& event)
|
||||
{
|
||||
// Iterate in reverse order as last child is displayed on top
|
||||
BOOST_REVERSE_FOREACH( ChildList::value_type child, _children )
|
||||
{
|
||||
if( child.second->handleMouseEvent(event) )
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Group::childAdded(SGPropertyNode* child)
|
||||
{
|
||||
if( child->getParent() != _node )
|
||||
return;
|
||||
|
||||
boost::shared_ptr<Element> element;
|
||||
|
||||
// TODO create map of child factories and use also to check for element
|
||||
// on deletion in ::childRemoved
|
||||
if( child->getNameString() == "text" )
|
||||
element.reset( new Text(child, _style) );
|
||||
else if( child->getNameString() == "group" )
|
||||
element.reset( new Group(child, _style) );
|
||||
else if( child->getNameString() == "map" )
|
||||
element.reset( new Map(child, _style) );
|
||||
else if( child->getNameString() == "path" )
|
||||
element.reset( new Path(child, _style) );
|
||||
else if( child->getNameString() == "image" )
|
||||
element.reset( new Image(child, _style) );
|
||||
|
||||
if( element )
|
||||
{
|
||||
// Add to osg scene graph...
|
||||
_transform->addChild( element->getMatrixTransform() );
|
||||
_children.push_back( ChildList::value_type(child, element) );
|
||||
return;
|
||||
}
|
||||
|
||||
_style[ child->getNameString() ] = child;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
struct ChildFinder
|
||||
{
|
||||
public:
|
||||
ChildFinder(SGPropertyNode *node):
|
||||
_node(node)
|
||||
{}
|
||||
|
||||
bool operator()(const Group::ChildList::value_type& el) const
|
||||
{
|
||||
return el.first == _node;
|
||||
}
|
||||
|
||||
private:
|
||||
SGPropertyNode *_node;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Group::childRemoved(SGPropertyNode* node)
|
||||
{
|
||||
if( node->getParent() != _node )
|
||||
return;
|
||||
|
||||
if( node->getNameString() == "text"
|
||||
|| node->getNameString() == "group"
|
||||
|| node->getNameString() == "map"
|
||||
|| node->getNameString() == "path"
|
||||
|| node->getNameString() == "image" )
|
||||
{
|
||||
ChildFinder pred(node);
|
||||
ChildList::iterator child =
|
||||
std::find_if(_children.begin(), _children.end(), pred);
|
||||
|
||||
if( child == _children.end() )
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_WARN,
|
||||
"can't removed unknown child " << node->getDisplayName()
|
||||
);
|
||||
else
|
||||
{
|
||||
_transform->removeChild( child->second->getMatrixTransform() );
|
||||
_children.erase(child);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Style::iterator style = _style.find(node->getNameString());
|
||||
if( style != _style.end() )
|
||||
_style.erase(style);
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Group::childChanged(SGPropertyNode* node)
|
||||
{
|
||||
if( node->getParent()->getParent() == _node
|
||||
&& node->getNameString() == "z-index" )
|
||||
return handleZIndexChanged(node->getParent(), node->getIntValue());
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Group::handleZIndexChanged(SGPropertyNode* node, int z_index)
|
||||
{
|
||||
ChildFinder pred(node);
|
||||
ChildList::iterator child =
|
||||
std::find_if(_children.begin(), _children.end(), pred);
|
||||
|
||||
if( child == _children.end() )
|
||||
return;
|
||||
|
||||
osg::Node* tf = child->second->getMatrixTransform();
|
||||
int index = _transform->getChildIndex(tf),
|
||||
index_new = index;
|
||||
|
||||
ChildList::iterator next = child;
|
||||
++next;
|
||||
|
||||
while( next != _children.end()
|
||||
&& next->first->getIntValue("z-index", 0) <= z_index )
|
||||
{
|
||||
++index_new;
|
||||
++next;
|
||||
}
|
||||
|
||||
if( index_new != index )
|
||||
{
|
||||
_children.insert(next, *child);
|
||||
}
|
||||
else
|
||||
{
|
||||
ChildList::iterator prev = child;
|
||||
while( prev != _children.begin()
|
||||
&& (--prev)->first->getIntValue("z-index", 0) > z_index)
|
||||
{
|
||||
--index_new;
|
||||
}
|
||||
|
||||
if( index == index_new )
|
||||
return;
|
||||
|
||||
_children.insert(prev, *child);
|
||||
}
|
||||
|
||||
_transform->removeChild(index);
|
||||
_transform->insertChild(index_new, tf);
|
||||
|
||||
_children.erase(child);
|
||||
|
||||
SG_LOG
|
||||
(
|
||||
SG_GENERAL,
|
||||
SG_INFO,
|
||||
"canvas::Group: Moved element " << index << " to position " << index_new
|
||||
);
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
// A group of 2D canvas elements
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_GROUP_HXX_
|
||||
#define CANVAS_GROUP_HXX_
|
||||
|
||||
#include "element.hxx"
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <list>
|
||||
#include <map>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
typedef boost::shared_ptr<Element> ElementPtr;
|
||||
|
||||
class Group:
|
||||
public Element
|
||||
{
|
||||
public:
|
||||
typedef std::list< std::pair< const SGPropertyNode*,
|
||||
ElementPtr
|
||||
>
|
||||
> ChildList;
|
||||
|
||||
Group(SGPropertyNode_ptr node, const Style& parent_style = Style());
|
||||
virtual ~Group();
|
||||
|
||||
virtual void update(double dt);
|
||||
|
||||
protected:
|
||||
|
||||
ChildList _children;
|
||||
|
||||
virtual bool handleLocalMouseEvent(const canvas::MouseEvent& event);
|
||||
|
||||
virtual void childAdded(SGPropertyNode * child);
|
||||
virtual void childRemoved(SGPropertyNode * child);
|
||||
virtual void childChanged(SGPropertyNode * child);
|
||||
|
||||
void handleZIndexChanged(SGPropertyNode* node, int z_index);
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_GROUP_HXX_ */
|
||||
|
|
@ -1,226 +0,0 @@
|
|||
// A group of 2D canvas elements which get automatically transformed according
|
||||
// to the map parameters.
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "map.hxx"
|
||||
#include "map/geo_node_pair.hxx"
|
||||
#include "map/projection.hxx"
|
||||
|
||||
#include <Main/fg_props.hxx>
|
||||
#include <cmath>
|
||||
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
|
||||
#define LOG_GEO_RET(msg) \
|
||||
{\
|
||||
SG_LOG\
|
||||
(\
|
||||
SG_GENERAL,\
|
||||
SG_WARN,\
|
||||
msg << " (" << child->getStringValue()\
|
||||
<< ", " << child->getPath() << ")"\
|
||||
);\
|
||||
return;\
|
||||
}
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
const std::string GEO = "-geo";
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Map::Map(SGPropertyNode_ptr node, const Style& parent_style):
|
||||
Group(node, parent_style),
|
||||
// TODO make projection configurable
|
||||
_projection(new SansonFlamsteedProjection),
|
||||
_projection_dirty(true)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Map::~Map()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Map::update(double dt)
|
||||
{
|
||||
for( GeoNodes::iterator it = _geo_nodes.begin();
|
||||
it != _geo_nodes.end();
|
||||
++it )
|
||||
{
|
||||
GeoNodePair* geo_node = it->second.get();
|
||||
if( !geo_node->isComplete()
|
||||
|| (!geo_node->isDirty() && !_projection_dirty) )
|
||||
continue;
|
||||
|
||||
GeoCoord lat = parseGeoCoord(geo_node->getLat());
|
||||
if( lat.type != GeoCoord::LATITUDE )
|
||||
continue;
|
||||
|
||||
GeoCoord lon = parseGeoCoord(geo_node->getLon());
|
||||
if( lon.type != GeoCoord::LONGITUDE )
|
||||
continue;
|
||||
|
||||
Projection::ScreenPosition pos =
|
||||
_projection->worldToScreen(lat.value, lon.value);
|
||||
|
||||
geo_node->setScreenPos(pos.x, pos.y);
|
||||
|
||||
// geo_node->print();
|
||||
geo_node->setDirty(false);
|
||||
}
|
||||
_projection_dirty = false;
|
||||
|
||||
Group::update(dt);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Map::childAdded(SGPropertyNode* parent, SGPropertyNode* child)
|
||||
{
|
||||
if( !boost::ends_with(child->getNameString(), GEO) )
|
||||
return Element::childAdded(parent, child);
|
||||
|
||||
_geo_nodes[child].reset(new GeoNodePair());
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Map::childRemoved(SGPropertyNode* parent, SGPropertyNode* child)
|
||||
{
|
||||
if( !boost::ends_with(child->getNameString(), GEO) )
|
||||
return Element::childRemoved(parent, child);
|
||||
|
||||
// TODO remove from other node
|
||||
_geo_nodes.erase(child);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Map::valueChanged(SGPropertyNode * child)
|
||||
{
|
||||
const std::string& name = child->getNameString();
|
||||
|
||||
if( !boost::ends_with(name, GEO) )
|
||||
return Group::valueChanged(child);
|
||||
|
||||
GeoNodes::iterator it_geo_node = _geo_nodes.find(child);
|
||||
if( it_geo_node == _geo_nodes.end() )
|
||||
LOG_GEO_RET("geo node not found!")
|
||||
GeoNodePair* geo_node = it_geo_node->second.get();
|
||||
|
||||
geo_node->setDirty();
|
||||
|
||||
if( geo_node->getStatus() & GeoNodePair::INCOMPLETE )
|
||||
{
|
||||
// Detect lat, lon tuples...
|
||||
GeoCoord coord = parseGeoCoord(child->getStringValue());
|
||||
int index_other = -1;
|
||||
|
||||
switch( coord.type )
|
||||
{
|
||||
case GeoCoord::LATITUDE:
|
||||
index_other = child->getIndex() + 1;
|
||||
geo_node->setNodeLat(child);
|
||||
break;
|
||||
case GeoCoord::LONGITUDE:
|
||||
index_other = child->getIndex() - 1;
|
||||
geo_node->setNodeLon(child);
|
||||
break;
|
||||
default:
|
||||
LOG_GEO_RET("Invalid geo coord")
|
||||
}
|
||||
|
||||
SGPropertyNode *other = child->getParent()->getChild(name, index_other);
|
||||
if( !other )
|
||||
return;
|
||||
|
||||
GeoCoord coord_other = parseGeoCoord(other->getStringValue());
|
||||
if( coord_other.type == GeoCoord::INVALID
|
||||
|| coord_other.type == coord.type )
|
||||
return;
|
||||
|
||||
GeoNodes::iterator it_geo_node_other = _geo_nodes.find(other);
|
||||
if( it_geo_node_other == _geo_nodes.end() )
|
||||
LOG_GEO_RET("other geo node not found!")
|
||||
GeoNodePair* geo_node_other = it_geo_node_other->second.get();
|
||||
|
||||
// Let use both nodes use the same GeoNodePair instance
|
||||
if( geo_node_other != geo_node )
|
||||
it_geo_node_other->second = it_geo_node->second;
|
||||
|
||||
if( coord_other.type == GeoCoord::LATITUDE )
|
||||
geo_node->setNodeLat(other);
|
||||
else
|
||||
geo_node->setNodeLon(other);
|
||||
|
||||
// Set name for resulting screen coordinate nodes
|
||||
geo_node->setTargetName( name.substr(0, name.length() - GEO.length()) );
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Map::childChanged(SGPropertyNode * child)
|
||||
{
|
||||
if( child->getParent() != _node )
|
||||
return Group::childChanged(child);
|
||||
|
||||
if( child->getNameString() == "ref-lat"
|
||||
|| child->getNameString() == "ref-lon" )
|
||||
_projection->setWorldPosition( _node->getDoubleValue("ref-lat"),
|
||||
_node->getDoubleValue("ref-lon") );
|
||||
else if( child->getNameString() == "hdg" )
|
||||
_projection->setOrientation(child->getFloatValue());
|
||||
else if( child->getNameString() == "range" )
|
||||
_projection->setRange(child->getDoubleValue());
|
||||
else
|
||||
return Group::childChanged(child);
|
||||
|
||||
_projection_dirty = true;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Map::GeoCoord Map::parseGeoCoord(const std::string& val) const
|
||||
{
|
||||
GeoCoord coord;
|
||||
if( val.length() < 2 )
|
||||
return coord;
|
||||
|
||||
if( val[0] == 'N' || val[0] == 'S' )
|
||||
coord.type = GeoCoord::LATITUDE;
|
||||
else if( val[0] == 'E' || val[0] == 'W' )
|
||||
coord.type = GeoCoord::LONGITUDE;
|
||||
else
|
||||
return coord;
|
||||
|
||||
char* end;
|
||||
coord.value = strtod(&val[1], &end);
|
||||
|
||||
if( end != &val[val.length()] )
|
||||
{
|
||||
coord.type = GeoCoord::INVALID;
|
||||
return coord;
|
||||
}
|
||||
|
||||
if( val[0] == 'S' || val[0] == 'W' )
|
||||
coord.value *= -1;
|
||||
|
||||
return coord;
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
// A group of 2D canvas elements which get automatically transformed according
|
||||
// to the map parameters.
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_MAP_HXX_
|
||||
#define CANVAS_MAP_HXX_
|
||||
|
||||
#include "group.hxx"
|
||||
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/unordered_map.hpp>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
class GeoNodePair;
|
||||
class HorizontalProjection;
|
||||
class Map:
|
||||
public Group
|
||||
{
|
||||
public:
|
||||
Map(SGPropertyNode_ptr node, const Style& parent_style);
|
||||
virtual ~Map();
|
||||
|
||||
virtual void update(double dt);
|
||||
|
||||
virtual void childAdded( SGPropertyNode * parent,
|
||||
SGPropertyNode * child );
|
||||
virtual void childRemoved( SGPropertyNode * parent,
|
||||
SGPropertyNode * child );
|
||||
virtual void valueChanged(SGPropertyNode * child);
|
||||
|
||||
protected:
|
||||
|
||||
virtual void childChanged(SGPropertyNode * child);
|
||||
|
||||
typedef boost::unordered_map< SGPropertyNode*,
|
||||
boost::shared_ptr<GeoNodePair>
|
||||
> GeoNodes;
|
||||
GeoNodes _geo_nodes;
|
||||
boost::shared_ptr<HorizontalProjection> _projection;
|
||||
bool _projection_dirty;
|
||||
|
||||
struct GeoCoord
|
||||
{
|
||||
GeoCoord():
|
||||
type(INVALID)
|
||||
{}
|
||||
enum
|
||||
{
|
||||
INVALID,
|
||||
LATITUDE,
|
||||
LONGITUDE
|
||||
} type;
|
||||
double value;
|
||||
};
|
||||
|
||||
GeoCoord parseGeoCoord(const std::string& val) const;
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_MAP_HXX_ */
|
||||
|
|
@ -1,120 +0,0 @@
|
|||
/*
|
||||
* geo_node_pair.hxx
|
||||
*
|
||||
* Created on: 11.07.2012
|
||||
* Author: tom
|
||||
*/
|
||||
|
||||
#ifndef CANVAS_GEO_NODE_PAIR_HXX_
|
||||
#define CANVAS_GEO_NODE_PAIR_HXX_
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
class GeoNodePair
|
||||
{
|
||||
public:
|
||||
enum StatusFlags
|
||||
{
|
||||
LAT_MISSING = 1,
|
||||
LON_MISSING = LAT_MISSING << 1,
|
||||
INCOMPLETE = LAT_MISSING | LON_MISSING,
|
||||
DIRTY = LON_MISSING << 1
|
||||
};
|
||||
|
||||
GeoNodePair():
|
||||
_status(INCOMPLETE),
|
||||
_node_lat(0),
|
||||
_node_lon(0)
|
||||
{}
|
||||
|
||||
uint8_t getStatus() const
|
||||
{
|
||||
return _status;
|
||||
}
|
||||
|
||||
void setDirty(bool flag = true)
|
||||
{
|
||||
if( flag )
|
||||
_status |= DIRTY;
|
||||
else
|
||||
_status &= ~DIRTY;
|
||||
}
|
||||
|
||||
bool isDirty() const
|
||||
{
|
||||
return (_status & DIRTY)!=0;
|
||||
}
|
||||
|
||||
bool isComplete() const
|
||||
{
|
||||
return !(_status & INCOMPLETE);
|
||||
}
|
||||
|
||||
void setNodeLat(SGPropertyNode* node)
|
||||
{
|
||||
_node_lat = node;
|
||||
_status &= ~LAT_MISSING;
|
||||
|
||||
if( node == _node_lon )
|
||||
{
|
||||
_node_lon = 0;
|
||||
_status |= LON_MISSING;
|
||||
}
|
||||
}
|
||||
|
||||
void setNodeLon(SGPropertyNode* node)
|
||||
{
|
||||
_node_lon = node;
|
||||
_status &= ~LON_MISSING;
|
||||
|
||||
if( node == _node_lat )
|
||||
{
|
||||
_node_lat = 0;
|
||||
_status |= LAT_MISSING;
|
||||
}
|
||||
}
|
||||
|
||||
const char* getLat() const
|
||||
{
|
||||
return _node_lat ? _node_lat->getStringValue() : "";
|
||||
}
|
||||
|
||||
const char* getLon() const
|
||||
{
|
||||
return _node_lon ? _node_lon->getStringValue() : "";
|
||||
}
|
||||
|
||||
void setTargetName(const std::string& name)
|
||||
{
|
||||
_target_name = name;
|
||||
}
|
||||
|
||||
void setScreenPos(float x, float y)
|
||||
{
|
||||
assert( isComplete() );
|
||||
SGPropertyNode *parent = _node_lat->getParent();
|
||||
parent->getChild(_target_name, _node_lat->getIndex(), true)
|
||||
->setDoubleValue(x);
|
||||
parent->getChild(_target_name, _node_lon->getIndex(), true)
|
||||
->setDoubleValue(y);
|
||||
}
|
||||
|
||||
void print()
|
||||
{
|
||||
std::cout << "lat=" << (_node_lat ? _node_lat->getPath() : "")
|
||||
<< ", lon=" << (_node_lon ? _node_lon->getPath() : "")
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
uint8_t _status;
|
||||
SGPropertyNode *_node_lat,
|
||||
*_node_lon;
|
||||
std::string _target_name;
|
||||
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_GEO_NODE_PAIR_HXX_ */
|
||||
|
|
@ -1,165 +0,0 @@
|
|||
/*
|
||||
* projection.hxx
|
||||
*
|
||||
* Created on: 12.07.2012
|
||||
* Author: tom
|
||||
*/
|
||||
|
||||
#ifndef CANVAS_MAP_PROJECTION_HXX_
|
||||
#define CANVAS_MAP_PROJECTION_HXX_
|
||||
|
||||
const double DEG2RAD = M_PI / 180.0;
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
/**
|
||||
* Base class for all projections
|
||||
*/
|
||||
class Projection
|
||||
{
|
||||
public:
|
||||
struct ScreenPosition
|
||||
{
|
||||
ScreenPosition() {}
|
||||
|
||||
ScreenPosition(double x, double y):
|
||||
x(x),
|
||||
y(y)
|
||||
{}
|
||||
|
||||
double x, y;
|
||||
};
|
||||
|
||||
virtual ~Projection() {}
|
||||
|
||||
void setScreenRange(double range)
|
||||
{
|
||||
_screen_range = range;
|
||||
}
|
||||
|
||||
virtual ScreenPosition worldToScreen(double x, double y) = 0;
|
||||
|
||||
protected:
|
||||
|
||||
double _screen_range;
|
||||
};
|
||||
|
||||
/**
|
||||
* Base class for horizontal projections
|
||||
*/
|
||||
class HorizontalProjection:
|
||||
public Projection
|
||||
{
|
||||
public:
|
||||
|
||||
HorizontalProjection():
|
||||
_cos_rot(1),
|
||||
_sin_rot(0),
|
||||
_range(5)
|
||||
{
|
||||
setScreenRange(200);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set world position of center point used for the projection
|
||||
*/
|
||||
void setWorldPosition(double lat, double lon)
|
||||
{
|
||||
_ref_lat = lat * DEG2RAD;
|
||||
_ref_lon = lon * DEG2RAD;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up heading
|
||||
*/
|
||||
void setOrientation(float hdg)
|
||||
{
|
||||
hdg *= DEG2RAD;
|
||||
_sin_rot = sin(hdg);
|
||||
_cos_rot = cos(hdg);
|
||||
}
|
||||
|
||||
void setRange(double range)
|
||||
{
|
||||
_range = range;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transform given world position to screen position
|
||||
*
|
||||
* @param lat Latitude in degrees
|
||||
* @param lon Longitude in degrees
|
||||
*/
|
||||
ScreenPosition worldToScreen(double lat, double lon)
|
||||
{
|
||||
lat *= DEG2RAD;
|
||||
lon *= DEG2RAD;
|
||||
ScreenPosition pos = project(lat, lon);
|
||||
double scale = _screen_range / _range;
|
||||
pos.x *= scale;
|
||||
pos.y *= scale;
|
||||
return ScreenPosition
|
||||
(
|
||||
_cos_rot * pos.x - _sin_rot * pos.y,
|
||||
-_sin_rot * pos.x - _cos_rot * pos.y
|
||||
);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
/**
|
||||
* Project given geographic world position to screen space
|
||||
*
|
||||
* @param lat Latitude in radians
|
||||
* @param lon Longitude in radians
|
||||
*/
|
||||
virtual ScreenPosition project(double lat, double lon) const = 0;
|
||||
|
||||
double _ref_lat,
|
||||
_ref_lon,
|
||||
_cos_rot,
|
||||
_sin_rot,
|
||||
_range;
|
||||
};
|
||||
|
||||
/**
|
||||
* Sanson-Flamsteed projection, relative to the projection center
|
||||
*/
|
||||
class SansonFlamsteedProjection:
|
||||
public HorizontalProjection
|
||||
{
|
||||
protected:
|
||||
|
||||
virtual ScreenPosition project(double lat, double lon) const
|
||||
{
|
||||
double d_lat = lat - _ref_lat,
|
||||
d_lon = lon - _ref_lon;
|
||||
double r = getEarthRadius(lat);
|
||||
|
||||
ScreenPosition pos;
|
||||
|
||||
pos.x = r * cos(lat) * d_lon;
|
||||
pos.y = r * d_lat;
|
||||
|
||||
return pos;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns Earth radius at a given latitude (Ellipsoide equation with two
|
||||
* equal axis)
|
||||
*/
|
||||
float getEarthRadius(float lat) const
|
||||
{
|
||||
const float rec = 6378137.f / 1852; // earth radius, equator (?)
|
||||
const float rpol = 6356752.314f / 1852; // earth radius, polar (?)
|
||||
|
||||
double a = cos(lat) / rec;
|
||||
double b = sin(lat) / rpol;
|
||||
return 1.0f / sqrt( a * a + b * b );
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_MAP_PROJECTION_HXX_ */
|
||||
|
|
@ -1,393 +0,0 @@
|
|||
// An OpenVG path on the canvas
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "path.hxx"
|
||||
#include <Canvas/canvas_fwd.hpp>
|
||||
#include <Canvas/property_helper.hxx>
|
||||
#include <Main/fg_props.hxx>
|
||||
|
||||
#include <vg/openvg.h>
|
||||
|
||||
#include <osg/Drawable>
|
||||
#include <osg/BlendFunc>
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
typedef std::vector<VGubyte> CmdList;
|
||||
typedef std::vector<VGfloat> CoordList;
|
||||
|
||||
class Path::PathDrawable:
|
||||
public osg::Drawable
|
||||
{
|
||||
public:
|
||||
PathDrawable(Path* path):
|
||||
_path_element(path),
|
||||
_path(VG_INVALID_HANDLE),
|
||||
_paint(VG_INVALID_HANDLE),
|
||||
_paint_fill(VG_INVALID_HANDLE),
|
||||
_attributes_dirty(~0),
|
||||
_mode(0),
|
||||
_fill_rule(VG_EVEN_ODD),
|
||||
_stroke_width(1),
|
||||
_stroke_linecap(VG_CAP_BUTT)
|
||||
{
|
||||
setSupportsDisplayList(false);
|
||||
setDataVariance(Object::DYNAMIC);
|
||||
|
||||
setUpdateCallback(new PathUpdateCallback());
|
||||
}
|
||||
|
||||
virtual ~PathDrawable()
|
||||
{
|
||||
if( _path != VG_INVALID_HANDLE )
|
||||
vgDestroyPath(_path);
|
||||
if( _paint != VG_INVALID_HANDLE )
|
||||
vgDestroyPaint(_paint);
|
||||
if( _paint_fill != VG_INVALID_HANDLE )
|
||||
vgDestroyPaint(_paint_fill);
|
||||
}
|
||||
|
||||
virtual const char* className() const { return "PathDrawable"; }
|
||||
virtual osg::Object* cloneType() const { return new PathDrawable(_path_element); }
|
||||
virtual osg::Object* clone(const osg::CopyOp&) const { return new PathDrawable(_path_element); }
|
||||
|
||||
/**
|
||||
* Replace the current path segments with the new ones
|
||||
*
|
||||
* @param cmds List of OpenVG path commands
|
||||
* @param coords List of coordinates/parameters used by #cmds
|
||||
*/
|
||||
void setSegments(const CmdList& cmds, const CoordList& coords)
|
||||
{
|
||||
_cmds = cmds;
|
||||
_coords = coords;
|
||||
|
||||
_attributes_dirty |= (PATH | BOUNDING_BOX);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set path fill paint ("none" if not filled)
|
||||
*/
|
||||
void setFill(const std::string& fill)
|
||||
{
|
||||
if( fill == "none" )
|
||||
{
|
||||
_mode &= ~VG_FILL_PATH;
|
||||
}
|
||||
else
|
||||
{
|
||||
_fill_color = parseColor(fill);
|
||||
_mode |= VG_FILL_PATH;
|
||||
_attributes_dirty |= FILL_COLOR;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set path fill rule ("pseudo-nonzero" or "evenodd")
|
||||
*
|
||||
* @warning As the current nonzero implementation causes sever artifacts
|
||||
* for every concave path we call it pseudo-nonzero, so that
|
||||
* everyone is warned that it won't work as expected :)
|
||||
*/
|
||||
void setFillRule(const std::string& fill_rule)
|
||||
{
|
||||
if( fill_rule == "pseudo-nonzero" )
|
||||
_fill_rule = VG_NON_ZERO;
|
||||
else // if( fill_rule == "evenodd" )
|
||||
_fill_rule = VG_EVEN_ODD;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set path stroke paint ("none" if no stroke)
|
||||
*/
|
||||
void setStroke(const std::string& stroke)
|
||||
{
|
||||
if( stroke == "none" )
|
||||
{
|
||||
_mode &= ~VG_STROKE_PATH;
|
||||
}
|
||||
else
|
||||
{
|
||||
_stroke_color = parseColor(stroke);
|
||||
_mode |= VG_STROKE_PATH;
|
||||
_attributes_dirty |= STROKE_COLOR;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set stroke width
|
||||
*/
|
||||
void setStrokeWidth(float width)
|
||||
{
|
||||
_stroke_width = width;
|
||||
_attributes_dirty |= BOUNDING_BOX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set stroke dash (line stipple)
|
||||
*/
|
||||
void setStrokeDashArray(const std::string& dash)
|
||||
{
|
||||
_stroke_dash = splitAndConvert(",\t\n ", dash);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set stroke-linecap
|
||||
*
|
||||
* @see http://www.w3.org/TR/SVG/painting.html#StrokeLinecapProperty
|
||||
*/
|
||||
void setStrokeLinecap(const std::string& linecap)
|
||||
{
|
||||
if( linecap == "round" )
|
||||
_stroke_linecap = VG_CAP_ROUND;
|
||||
else if( linecap == "square" )
|
||||
_stroke_linecap = VG_CAP_SQUARE;
|
||||
else
|
||||
_stroke_linecap = VG_CAP_BUTT;
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw callback
|
||||
*/
|
||||
virtual void drawImplementation(osg::RenderInfo& renderInfo) const
|
||||
{
|
||||
if( _attributes_dirty & PATH )
|
||||
return;
|
||||
|
||||
osg::State* state = renderInfo.getState();
|
||||
assert(state);
|
||||
|
||||
state->setActiveTextureUnit(0);
|
||||
state->setClientActiveTextureUnit(0);
|
||||
state->disableAllVertexArrays();
|
||||
|
||||
glPushAttrib(~0u); // Don't use GL_ALL_ATTRIB_BITS as on my machine it
|
||||
// eg. doesn't include GL_MULTISAMPLE_BIT
|
||||
glPushClientAttrib(~0u);
|
||||
|
||||
// Initialize/Update the paint
|
||||
if( _attributes_dirty & STROKE_COLOR )
|
||||
{
|
||||
if( _paint == VG_INVALID_HANDLE )
|
||||
_paint = vgCreatePaint();
|
||||
|
||||
vgSetParameterfv(_paint, VG_PAINT_COLOR, 4, _stroke_color._v);
|
||||
|
||||
_attributes_dirty &= ~STROKE_COLOR;
|
||||
}
|
||||
|
||||
// Initialize/update fill paint
|
||||
if( _attributes_dirty & FILL_COLOR )
|
||||
{
|
||||
if( _paint_fill == VG_INVALID_HANDLE )
|
||||
_paint_fill = vgCreatePaint();
|
||||
|
||||
vgSetParameterfv(_paint_fill, VG_PAINT_COLOR, 4, _fill_color._v);
|
||||
|
||||
_attributes_dirty &= ~FILL_COLOR;
|
||||
}
|
||||
|
||||
// Setup paint
|
||||
if( _mode & VG_STROKE_PATH )
|
||||
{
|
||||
vgSetPaint(_paint, VG_STROKE_PATH);
|
||||
|
||||
vgSetf(VG_STROKE_LINE_WIDTH, _stroke_width);
|
||||
vgSeti(VG_STROKE_CAP_STYLE, _stroke_linecap);
|
||||
vgSetfv( VG_STROKE_DASH_PATTERN,
|
||||
_stroke_dash.size(),
|
||||
_stroke_dash.empty() ? 0 : &_stroke_dash[0] );
|
||||
}
|
||||
if( _mode & VG_FILL_PATH )
|
||||
{
|
||||
vgSetPaint(_paint_fill, VG_FILL_PATH);
|
||||
|
||||
vgSeti(VG_FILL_RULE, _fill_rule);
|
||||
}
|
||||
|
||||
// And finally draw the path
|
||||
if( _mode )
|
||||
vgDrawPath(_path, _mode);
|
||||
|
||||
VGErrorCode err = vgGetError();
|
||||
if( err != VG_NO_ERROR )
|
||||
SG_LOG(SG_GL, SG_ALERT, "vgError: " << err);
|
||||
|
||||
glPopAttrib();
|
||||
glPopClientAttrib();
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute the bounding box
|
||||
*/
|
||||
virtual osg::BoundingBox computeBound() const
|
||||
{
|
||||
if( _path == VG_INVALID_HANDLE || (_attributes_dirty & PATH) )
|
||||
return osg::BoundingBox();
|
||||
|
||||
VGfloat min[2], size[2];
|
||||
vgPathBounds(_path, &min[0], &min[1], &size[0], &size[1]);
|
||||
|
||||
_attributes_dirty &= ~BOUNDING_BOX;
|
||||
|
||||
// vgPathBounds doesn't take stroke width into account
|
||||
float ext = 0.5 * _stroke_width;
|
||||
|
||||
osg::BoundingBox bb
|
||||
(
|
||||
min[0] - ext, min[1] - ext, -0.1,
|
||||
min[0] + size[0] + ext, min[1] + size[1] + ext, 0.1
|
||||
);
|
||||
_path_element->setBoundingBox(bb);
|
||||
|
||||
return bb;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
enum Attributes
|
||||
{
|
||||
PATH = 0x0001,
|
||||
STROKE_COLOR = PATH << 1,
|
||||
FILL_COLOR = STROKE_COLOR << 1,
|
||||
BOUNDING_BOX = FILL_COLOR << 1
|
||||
};
|
||||
|
||||
Path *_path_element;
|
||||
|
||||
mutable VGPath _path;
|
||||
mutable VGPaint _paint;
|
||||
mutable VGPaint _paint_fill;
|
||||
mutable uint32_t _attributes_dirty;
|
||||
|
||||
CmdList _cmds;
|
||||
CoordList _coords;
|
||||
|
||||
VGbitfield _mode;
|
||||
osg::Vec4f _fill_color;
|
||||
VGFillRule _fill_rule;
|
||||
osg::Vec4f _stroke_color;
|
||||
VGfloat _stroke_width;
|
||||
std::vector<VGfloat> _stroke_dash;
|
||||
VGCapStyle _stroke_linecap;
|
||||
|
||||
/**
|
||||
* Initialize/Update the OpenVG path
|
||||
*/
|
||||
void update()
|
||||
{
|
||||
if( _attributes_dirty & PATH )
|
||||
{
|
||||
const VGbitfield caps = VG_PATH_CAPABILITY_APPEND_TO
|
||||
| VG_PATH_CAPABILITY_MODIFY
|
||||
| VG_PATH_CAPABILITY_PATH_BOUNDS;
|
||||
|
||||
if( _path == VG_INVALID_HANDLE )
|
||||
_path = vgCreatePath(
|
||||
VG_PATH_FORMAT_STANDARD,
|
||||
VG_PATH_DATATYPE_F,
|
||||
1.f, 0.f, // scale,bias
|
||||
_cmds.size(), _coords.size(),
|
||||
caps
|
||||
);
|
||||
else
|
||||
vgClearPath(_path, caps);
|
||||
|
||||
if( !_cmds.empty() && !_coords.empty() )
|
||||
vgAppendPathData(_path, _cmds.size(), &_cmds[0], &_coords[0]);
|
||||
|
||||
_attributes_dirty &= ~PATH;
|
||||
_attributes_dirty |= BOUNDING_BOX;
|
||||
}
|
||||
|
||||
if( _attributes_dirty & BOUNDING_BOX )
|
||||
dirtyBound();
|
||||
}
|
||||
|
||||
struct PathUpdateCallback:
|
||||
public osg::Drawable::UpdateCallback
|
||||
{
|
||||
virtual void update(osg::NodeVisitor*, osg::Drawable* drawable)
|
||||
{
|
||||
static_cast<PathDrawable*>(drawable)->update();
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Path::Path(SGPropertyNode_ptr node, const Style& parent_style):
|
||||
Element(node, parent_style),
|
||||
_path( new PathDrawable(this) )
|
||||
{
|
||||
setDrawable(_path);
|
||||
PathDrawable *path = _path.get();
|
||||
|
||||
addStyle("fill", &PathDrawable::setFill, path);
|
||||
addStyle("fill-rule", &PathDrawable::setFillRule, path);
|
||||
addStyle("stroke", &PathDrawable::setStroke, path);
|
||||
addStyle("stroke-width", &PathDrawable::setStrokeWidth, path);
|
||||
addStyle("stroke-dasharray", &PathDrawable::setStrokeDashArray, path);
|
||||
addStyle("stroke-linecap", &PathDrawable::setStrokeLinecap, path);
|
||||
|
||||
setupStyle();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Path::~Path()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Path::update(double dt)
|
||||
{
|
||||
if( _attributes_dirty & (CMDS | COORDS) )
|
||||
{
|
||||
_path->setSegments
|
||||
(
|
||||
getVectorFromChildren<VGubyte, int>(_node, "cmd"),
|
||||
getVectorFromChildren<VGfloat, float>(_node, "coord")
|
||||
);
|
||||
|
||||
_attributes_dirty &= ~(CMDS | COORDS);
|
||||
}
|
||||
|
||||
Element::update(dt);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Path::childRemoved(SGPropertyNode* child)
|
||||
{
|
||||
childChanged(child);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Path::childChanged(SGPropertyNode* child)
|
||||
{
|
||||
if( child->getParent() != _node )
|
||||
return;
|
||||
|
||||
if( child->getNameString() == "cmd" )
|
||||
_attributes_dirty |= CMDS;
|
||||
else if( child->getNameString() == "coord" )
|
||||
_attributes_dirty |= COORDS;
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
// An OpenVG path on the canvas
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_PATH_HXX_
|
||||
#define CANVAS_PATH_HXX_
|
||||
|
||||
#include "element.hxx"
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
class Path:
|
||||
public Element
|
||||
{
|
||||
public:
|
||||
Path(SGPropertyNode_ptr node, const Style& parent_style);
|
||||
virtual ~Path();
|
||||
|
||||
virtual void update(double dt);
|
||||
|
||||
protected:
|
||||
|
||||
enum PathAttributes
|
||||
{
|
||||
CMDS = LAST_ATTRIBUTE << 1,
|
||||
COORDS = CMDS << 1
|
||||
};
|
||||
|
||||
class PathDrawable;
|
||||
osg::ref_ptr<PathDrawable> _path;
|
||||
|
||||
virtual void childRemoved(SGPropertyNode * child);
|
||||
virtual void childChanged(SGPropertyNode * child);
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_PATH_HXX_ */
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
// Mapping between strings and osg text alignment flags
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef ENUM_MAPPING
|
||||
# error "Only include with ENUM_MAPPING defined!"
|
||||
#endif
|
||||
|
||||
ENUM_MAPPING(LEFT_TOP, "left-top")
|
||||
ENUM_MAPPING(LEFT_CENTER, "left-center")
|
||||
ENUM_MAPPING(LEFT_BOTTOM, "left-bottom")
|
||||
|
||||
ENUM_MAPPING(CENTER_TOP, "center-top")
|
||||
ENUM_MAPPING(CENTER_CENTER, "center-center")
|
||||
ENUM_MAPPING(CENTER_BOTTOM, "center-bottom")
|
||||
|
||||
ENUM_MAPPING(RIGHT_TOP, "right-top")
|
||||
ENUM_MAPPING(RIGHT_CENTER, "right-center")
|
||||
ENUM_MAPPING(RIGHT_BOTTOM, "right-bottom")
|
||||
|
||||
ENUM_MAPPING(LEFT_BASE_LINE, "left-baseline")
|
||||
ENUM_MAPPING(CENTER_BASE_LINE, "center-baseline")
|
||||
ENUM_MAPPING(RIGHT_BASE_LINE, "right-baseline")
|
||||
|
||||
ENUM_MAPPING(LEFT_BOTTOM_BASE_LINE, "left-bottom-baseline")
|
||||
ENUM_MAPPING(CENTER_BOTTOM_BASE_LINE, "center-bottom-baseline")
|
||||
ENUM_MAPPING(RIGHT_BOTTOM_BASE_LINE, "right-bottom-baseline")
|
||||
|
|
@ -1,318 +0,0 @@
|
|||
// A text on the canvas
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "text.hxx"
|
||||
#include <Canvas/property_helper.hxx>
|
||||
|
||||
#include <Main/globals.hxx>
|
||||
#include <Main/fg_props.hxx>
|
||||
|
||||
#include <osgText/Text>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
class Text::TextOSG:
|
||||
public osgText::Text
|
||||
{
|
||||
public:
|
||||
|
||||
TextOSG(canvas::Text* text);
|
||||
|
||||
void setCharacterAspect(float aspect);
|
||||
void setFill(const std::string& fill);
|
||||
void setBackgroundColor(const std::string& fill);
|
||||
|
||||
osg::Vec2 handleHit(float x, float y);
|
||||
|
||||
virtual osg::BoundingBox computeBound() const;
|
||||
|
||||
protected:
|
||||
|
||||
canvas::Text *_text_element;
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Text::TextOSG::TextOSG(canvas::Text* text):
|
||||
_text_element(text)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::TextOSG::setCharacterAspect(float aspect)
|
||||
{
|
||||
setCharacterSize(getCharacterHeight(), aspect);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::TextOSG::setFill(const std::string& fill)
|
||||
{
|
||||
// if( fill == "none" )
|
||||
// TODO No text
|
||||
// else
|
||||
setColor( parseColor(fill) );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::TextOSG::setBackgroundColor(const std::string& fill)
|
||||
{
|
||||
setBoundingBoxColor( parseColor(fill) );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
osg::Vec2 Text::TextOSG::handleHit(float x, float y)
|
||||
{
|
||||
float line_height = _characterHeight + _lineSpacing;
|
||||
|
||||
// TODO check with align other than TOP
|
||||
float first_line_y = -0.5 * _lineSpacing;//_offset.y() - _characterHeight;
|
||||
size_t line = std::max<int>(0, (y - first_line_y) / line_height);
|
||||
|
||||
if( _textureGlyphQuadMap.empty() )
|
||||
return osg::Vec2(-1, -1);
|
||||
|
||||
// TODO check when it can be larger
|
||||
assert( _textureGlyphQuadMap.size() == 1 );
|
||||
|
||||
const GlyphQuads& glyphquad = _textureGlyphQuadMap.begin()->second;
|
||||
const GlyphQuads::Glyphs& glyphs = glyphquad._glyphs;
|
||||
const GlyphQuads::Coords2& coords = glyphquad._coords;
|
||||
const GlyphQuads::LineNumbers& line_numbers = glyphquad._lineNumbers;
|
||||
|
||||
const float HIT_FRACTION = 0.6;
|
||||
const float character_width = getCharacterHeight()
|
||||
* getCharacterAspectRatio();
|
||||
|
||||
y = (line + 0.5) * line_height;
|
||||
|
||||
bool line_found = false;
|
||||
for(size_t i = 0; i < line_numbers.size(); ++i)
|
||||
{
|
||||
if( line_numbers[i] != line )
|
||||
{
|
||||
if( !line_found )
|
||||
{
|
||||
if( line_numbers[i] < line )
|
||||
// Wait for the correct line...
|
||||
continue;
|
||||
|
||||
// We have already passed the correct line -> It's empty...
|
||||
return osg::Vec2(0, y);
|
||||
}
|
||||
|
||||
// Next line and not returned -> not before any character
|
||||
// -> return position after last character of line
|
||||
return osg::Vec2(coords[(i - 1) * 4 + 2].x(), y);
|
||||
}
|
||||
|
||||
line_found = true;
|
||||
|
||||
// Get threshold for mouse x position for setting cursor before or after
|
||||
// current character
|
||||
float threshold = coords[i * 4].x()
|
||||
+ HIT_FRACTION * glyphs[i]->getHorizontalAdvance()
|
||||
* character_width;
|
||||
|
||||
if( x <= threshold )
|
||||
{
|
||||
if( i == 0 || line_numbers[i - 1] != line )
|
||||
// first character of line
|
||||
x = coords[i * 4].x();
|
||||
else if( coords[(i - 1) * 4].x() == coords[(i - 1) * 4 + 2].x() )
|
||||
// If previous character width is zero set to begin of next character
|
||||
// (Happens eg. with spaces)
|
||||
x = coords[i * 4].x();
|
||||
else
|
||||
// position at center between characters
|
||||
x = 0.5 * (coords[(i - 1) * 4 + 2].x() + coords[i * 4].x());
|
||||
|
||||
return osg::Vec2(x, y);
|
||||
}
|
||||
}
|
||||
|
||||
// Nothing found -> return position after last character
|
||||
return osg::Vec2
|
||||
(
|
||||
coords.back().x(),
|
||||
(_lineCount - 0.5) * line_height
|
||||
);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
osg::BoundingBox Text::TextOSG::computeBound() const
|
||||
{
|
||||
osg::BoundingBox bb = osgText::Text::computeBound();
|
||||
if( !bb.valid() )
|
||||
return bb;
|
||||
|
||||
// TODO bounding box still doesn't seem always right (eg. with center
|
||||
// horizontal alignment not completely accurate)
|
||||
bb._min.y() += _offset.y();
|
||||
bb._max.y() += _offset.y();
|
||||
|
||||
_text_element->setBoundingBox(bb);
|
||||
|
||||
return bb;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Text::Text(SGPropertyNode_ptr node, const Style& parent_style):
|
||||
Element(node, parent_style),
|
||||
_text( new Text::TextOSG(this) )
|
||||
{
|
||||
setDrawable(_text);
|
||||
_text->setCharacterSizeMode(osgText::Text::OBJECT_COORDS);
|
||||
_text->setAxisAlignment(osgText::Text::USER_DEFINED_ROTATION);
|
||||
_text->setRotation(osg::Quat(osg::PI, osg::X_AXIS));
|
||||
|
||||
addStyle("fill", &TextOSG::setFill, _text);
|
||||
addStyle("background", &TextOSG::setBackgroundColor, _text);
|
||||
addStyle("character-size",
|
||||
static_cast<void (TextOSG::*)(float)>(&TextOSG::setCharacterSize),
|
||||
_text);
|
||||
addStyle("character-aspect-ratio", &TextOSG::setCharacterAspect, _text);
|
||||
addStyle("padding", &TextOSG::setBoundingBoxMargin, _text);
|
||||
// TEXT = 1 default
|
||||
// BOUNDINGBOX = 2
|
||||
// FILLEDBOUNDINGBOX = 4
|
||||
// ALIGNMENT = 8
|
||||
addStyle<int>("draw-mode", &TextOSG::setDrawMode, _text);
|
||||
addStyle("max-width", &TextOSG::setMaximumWidth, _text);
|
||||
addStyle("font", &Text::setFont, this);
|
||||
addStyle("alignment", &Text::setAlignment, this);
|
||||
addStyle("text", &Text::setText, this);
|
||||
|
||||
setupStyle();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Text::~Text()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::setText(const char* text)
|
||||
{
|
||||
_text->setText(text, osgText::String::ENCODING_UTF8);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::setFont(const char* name)
|
||||
{
|
||||
_text->setFont( getFont(name) );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::setAlignment(const char* align)
|
||||
{
|
||||
const std::string align_string(align);
|
||||
if( 0 ) return;
|
||||
#define ENUM_MAPPING(enum_val, string_val) \
|
||||
else if( align_string == string_val )\
|
||||
_text->setAlignment( osgText::Text::enum_val );
|
||||
#include "text-alignment.hxx"
|
||||
#undef ENUM_MAPPING
|
||||
else
|
||||
{
|
||||
if( !align_string.empty() )
|
||||
SG_LOG
|
||||
(
|
||||
SG_GENERAL,
|
||||
SG_WARN,
|
||||
"canvas::Text: unknown alignment '" << align_string << "'"
|
||||
);
|
||||
_text->setAlignment(osgText::Text::LEFT_BASE_LINE);
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
#if 0
|
||||
const char* Text::getAlignment() const
|
||||
{
|
||||
switch( _text->getAlignment() )
|
||||
{
|
||||
#define ENUM_MAPPING(enum_val, string_val) \
|
||||
case osgText::Text::enum_val:\
|
||||
return string_val;
|
||||
#include "text-alignment.hxx"
|
||||
#undef ENUM_MAPPING
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::childChanged(SGPropertyNode* child)
|
||||
{
|
||||
if( child->getParent() != _node )
|
||||
return;
|
||||
|
||||
const std::string& name = child->getNameString();
|
||||
if( name == "hit-y" )
|
||||
handleHit
|
||||
(
|
||||
_node->getFloatValue("hit-x"),
|
||||
_node->getFloatValue("hit-y")
|
||||
);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Text::handleHit(float x, float y)
|
||||
{
|
||||
const osg::Vec2& pos = _text->handleHit(x, y);
|
||||
_node->setFloatValue("cursor-x", pos.x());
|
||||
_node->setFloatValue("cursor-y", pos.y());
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Text::font_ptr Text::getFont(const std::string& name)
|
||||
{
|
||||
SGPath path = globals->resolve_resource_path("Fonts/" + name);
|
||||
if( path.isNull() )
|
||||
{
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_ALERT,
|
||||
"canvas::Text: No such font: " << name
|
||||
);
|
||||
return font_ptr();
|
||||
}
|
||||
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_INFO,
|
||||
"canvas::Text: using font file " << path.str()
|
||||
);
|
||||
|
||||
font_ptr font = osgText::readFontFile(path.c_str());
|
||||
if( !font )
|
||||
SG_LOG
|
||||
(
|
||||
SG_GL,
|
||||
SG_ALERT,
|
||||
"canvas::Text: Failed to open font file " << path.c_str()
|
||||
);
|
||||
|
||||
return font;
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
// A text on the canvas
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_TEXT_HXX_
|
||||
#define CANVAS_TEXT_HXX_
|
||||
|
||||
#include "element.hxx"
|
||||
#include <osgText/Text>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
class Text:
|
||||
public Element
|
||||
{
|
||||
public:
|
||||
Text(SGPropertyNode_ptr node, const Style& parent_style);
|
||||
~Text();
|
||||
|
||||
void setText(const char* text);
|
||||
void setFont(const char* name);
|
||||
void setAlignment(const char* align);
|
||||
|
||||
protected:
|
||||
|
||||
class TextOSG;
|
||||
osg::ref_ptr<TextOSG> _text;
|
||||
|
||||
virtual void childChanged(SGPropertyNode * child);
|
||||
|
||||
void handleHit(float x, float y);
|
||||
|
||||
typedef osg::ref_ptr<osgText::Font> font_ptr;
|
||||
static font_ptr getFont(const std::string& name);
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_TEXT_HXX_ */
|
||||
|
|
@ -18,13 +18,15 @@
|
|||
|
||||
#include "gui_mgr.hxx"
|
||||
#include <Canvas/window.hxx>
|
||||
#include <Canvas/canvas.hxx>
|
||||
|
||||
#include <Main/fg_props.hxx>
|
||||
#include <Main/globals.hxx>
|
||||
#include <Viewer/CameraGroup.hxx>
|
||||
#include <Viewer/renderer.hxx>
|
||||
|
||||
#include <simgear/canvas/Canvas.hxx>
|
||||
#include <simgear/canvas/CanvasPlacement.hxx>
|
||||
|
||||
#include <osg/BlendFunc>
|
||||
#include <osgViewer/Viewer>
|
||||
#include <osgGA/GUIEventHandler>
|
||||
|
|
@ -58,11 +60,11 @@ class GUIEventHandler:
|
|||
* Track a canvas placement on a window
|
||||
*/
|
||||
class WindowPlacement:
|
||||
public canvas::Placement
|
||||
public simgear::canvas::Placement
|
||||
{
|
||||
public:
|
||||
WindowPlacement( canvas::WindowPtr window,
|
||||
CanvasPtr canvas ):
|
||||
simgear::canvas::CanvasPtr canvas ):
|
||||
_window(window),
|
||||
_canvas(canvas)
|
||||
{}
|
||||
|
|
@ -73,15 +75,15 @@ class WindowPlacement:
|
|||
virtual ~WindowPlacement()
|
||||
{
|
||||
canvas::WindowPtr window = _window.lock();
|
||||
CanvasPtr canvas = _canvas.lock();
|
||||
simgear::canvas::CanvasPtr canvas = _canvas.lock();
|
||||
|
||||
if( window && canvas && canvas == window->getCanvas().lock() )
|
||||
window->setCanvas( CanvasPtr() );
|
||||
window->setCanvas( simgear::canvas::CanvasPtr() );
|
||||
}
|
||||
|
||||
private:
|
||||
canvas::WindowWeakPtr _window;
|
||||
CanvasWeakPtr _canvas;
|
||||
simgear::canvas::CanvasWeakPtr _canvas;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -124,7 +126,7 @@ GUIMgr::GUIMgr():
|
|||
osg::Viewport* vp = camera->getViewport();
|
||||
handleResize(vp->x(), vp->y(), vp->width(), vp->height());
|
||||
|
||||
Canvas::addPlacementFactory
|
||||
simgear::canvas::Canvas::addPlacementFactory
|
||||
(
|
||||
"window",
|
||||
boost::bind(&GUIMgr::addPlacement, this, _1, _2)
|
||||
|
|
@ -226,12 +228,13 @@ canvas::WindowPtr GUIMgr::getWindow(size_t i)
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
canvas::Placements GUIMgr::addPlacement( const SGPropertyNode* node,
|
||||
CanvasPtr canvas )
|
||||
simgear::canvas::Placements
|
||||
GUIMgr::addPlacement( const SGPropertyNode* node,
|
||||
simgear::canvas::CanvasPtr canvas )
|
||||
{
|
||||
int placement_index = node->getIntValue("index", -1);
|
||||
|
||||
canvas::Placements placements;
|
||||
simgear::canvas::Placements placements;
|
||||
for( size_t i = 0; i < _elements.size(); ++i )
|
||||
{
|
||||
if( placement_index >= 0 && static_cast<int>(i) != placement_index )
|
||||
|
|
@ -243,7 +246,7 @@ canvas::Placements GUIMgr::addPlacement( const SGPropertyNode* node,
|
|||
|
||||
window->setCanvas(canvas);
|
||||
placements.push_back(
|
||||
canvas::PlacementPtr(new WindowPlacement(window, canvas))
|
||||
simgear::canvas::PlacementPtr(new WindowPlacement(window, canvas))
|
||||
);
|
||||
}
|
||||
return placements;
|
||||
|
|
@ -255,7 +258,7 @@ bool GUIMgr::handleMouse(const osgGA::GUIEventAdapter& ea)
|
|||
if( !_transform->getNumChildren() )
|
||||
return false;
|
||||
|
||||
canvas::MouseEvent event( ea.getEventType() );
|
||||
simgear::canvas::MouseEvent event( ea.getEventType() );
|
||||
|
||||
event.x = 0.5 * (ea.getXnormalized() + 1) * _width + 0.5;
|
||||
event.y = 0.5 * (ea.getYnormalized() + 1) * _height + 0.5;
|
||||
|
|
|
|||
|
|
@ -19,9 +19,9 @@
|
|||
#ifndef CANVAS_GUI_MGR_HXX_
|
||||
#define CANVAS_GUI_MGR_HXX_
|
||||
|
||||
#include <Canvas/canvas_fwd.hpp>
|
||||
#include <Canvas/placement.hxx>
|
||||
#include "canvas_fwd.hpp"
|
||||
|
||||
#include <simgear/canvas/canvas_fwd.hxx>
|
||||
#include <simgear/props/PropertyBasedMgr.hxx>
|
||||
#include <simgear/props/propertyObject.hxx>
|
||||
|
||||
|
|
@ -60,8 +60,9 @@ class GUIMgr:
|
|||
_last_y;
|
||||
|
||||
canvas::WindowPtr getWindow(size_t i);
|
||||
canvas::Placements addPlacement( const SGPropertyNode*,
|
||||
CanvasPtr canvas );
|
||||
simgear::canvas::Placements
|
||||
addPlacement( const SGPropertyNode*,
|
||||
simgear::canvas::CanvasPtr canvas );
|
||||
|
||||
bool handleMouse(const osgGA::GUIEventAdapter& ea);
|
||||
void handleResize(int x, int y, int width, int height);
|
||||
|
|
|
|||
|
|
@ -1,36 +0,0 @@
|
|||
// Base class for canvas placements
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "placement.hxx"
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Placement::Placement()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
Placement::~Placement()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
} // namespace canvas
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
// Base class for canvas placements
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_PLACEMENT_HXX_
|
||||
#define CANVAS_PLACEMENT_HXX_
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
class Placement
|
||||
{
|
||||
public:
|
||||
Placement();
|
||||
virtual ~Placement() = 0;
|
||||
|
||||
private:
|
||||
Placement(const Placement&) /* = delete */;
|
||||
Placement& operator=(const Placement&) /* = delete */;
|
||||
};
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_PLACEMENT_HXX_ */
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
// Some helper functions for accessing the property tree
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "property_helper.hxx"
|
||||
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
#include <boost/algorithm/string/trim.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/tokenizer.hpp>
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
//----------------------------------------------------------------------------
|
||||
std::vector<float> splitAndConvert(const char del[], const std::string& str)
|
||||
{
|
||||
std::vector<float> values;
|
||||
size_t pos = 0;
|
||||
for(;;)
|
||||
{
|
||||
pos = str.find_first_not_of(del, pos);
|
||||
if( pos == std::string::npos )
|
||||
break;
|
||||
|
||||
char *end = 0;
|
||||
float val = strtod(&str[pos], &end);
|
||||
if( end == &str[pos] || !end )
|
||||
break;
|
||||
|
||||
values.push_back(val);
|
||||
pos = end - &str[0];
|
||||
}
|
||||
return values;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
osg::Vec4 parseColor(std::string str)
|
||||
{
|
||||
boost::trim(str);
|
||||
osg::Vec4 color(0,0,0,1);
|
||||
|
||||
if( str.empty() )
|
||||
return color;
|
||||
|
||||
// #rrggbb
|
||||
if( str[0] == '#' )
|
||||
{
|
||||
const int offsets[] = {2,2,2};
|
||||
const boost::offset_separator hex_separator( boost::begin(offsets),
|
||||
boost::end(offsets) );
|
||||
typedef boost::tokenizer<boost::offset_separator> offset_tokenizer;
|
||||
offset_tokenizer tokens(str.begin() + 1, str.end(), hex_separator);
|
||||
|
||||
int comp = 0;
|
||||
for( offset_tokenizer::const_iterator tok = tokens.begin();
|
||||
tok != tokens.end() && comp < 4;
|
||||
++tok, ++comp )
|
||||
{
|
||||
color._v[comp] = strtol(std::string(*tok).c_str(), 0, 16) / 255.f;
|
||||
}
|
||||
}
|
||||
// rgb(r,g,b)
|
||||
// rgba(r,g,b,a)
|
||||
else if( boost::ends_with(str, ")") )
|
||||
{
|
||||
const std::string RGB = "rgb(",
|
||||
RGBA = "rgba(";
|
||||
size_t pos;
|
||||
if( boost::starts_with(str, RGB) )
|
||||
pos = RGB.length();
|
||||
else if( boost::starts_with(str, RGBA) )
|
||||
pos = RGBA.length();
|
||||
else
|
||||
return color;
|
||||
|
||||
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
|
||||
const boost::char_separator<char> del(", \t\n");
|
||||
|
||||
tokenizer tokens(str.begin() + pos, str.end() - 1, del);
|
||||
int comp = 0;
|
||||
for( tokenizer::const_iterator tok = tokens.begin();
|
||||
tok != tokens.end() && comp < 4;
|
||||
++tok, ++comp )
|
||||
{
|
||||
color._v[comp] = boost::lexical_cast<float>(*tok)
|
||||
// rgb = [0,255], a = [0,1]
|
||||
/ (comp < 3 ? 255 : 1);
|
||||
}
|
||||
}
|
||||
else
|
||||
SG_LOG(SG_GENERAL, SG_WARN, "Unknown color: " << str);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void linkColorNodes( const char* name,
|
||||
SGPropertyNode* parent,
|
||||
std::vector<SGPropertyNode_ptr>& nodes,
|
||||
const osg::Vec4& def )
|
||||
{
|
||||
static const char* channels[] = {"red", "green", "blue", "alpha"};
|
||||
static const size_t num_channels = sizeof(channels)/sizeof(channels[0]);
|
||||
|
||||
assert(name);
|
||||
assert(parent);
|
||||
|
||||
// Don't tie to allow the usage of aliases
|
||||
SGPropertyNode_ptr color = parent->getChild(name, 0, true);
|
||||
|
||||
// We need to be carefull do not get any unitialized nodes or null pointers
|
||||
// because while creating the node a valueChanged event will be triggered.
|
||||
nodes.clear();
|
||||
nodes.reserve(num_channels);
|
||||
|
||||
for( size_t i = 0; i < num_channels; ++i )
|
||||
nodes.push_back( getChildDefault(color, channels[i], def[i]) );
|
||||
}
|
||||
}
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
// Some helper functions for accessing the property tree
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef PROPERTY_HELPER_HXX_
|
||||
#define PROPERTY_HELPER_HXX_
|
||||
|
||||
#include <simgear/props/props.hxx>
|
||||
#include <osg/Vec4>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
|
||||
/**
|
||||
* Get property node with default value
|
||||
*/
|
||||
template<typename T>
|
||||
SGPropertyNode* getChildDefault( SGPropertyNode* parent,
|
||||
const char* name,
|
||||
T def_val )
|
||||
{
|
||||
SGPropertyNode* node = parent->getNode(name);
|
||||
if( node )
|
||||
// also set value for existing nodes to enforce type...
|
||||
def_val = getValue<T>(node);
|
||||
else
|
||||
node = parent->getChild(name, 0, true);
|
||||
|
||||
setValue(node, def_val);
|
||||
return node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get vector of properties
|
||||
*/
|
||||
template<typename T, typename T_get /* = T */> // TODO use C++11 or traits
|
||||
std::vector<T> getVectorFromChildren( const SGPropertyNode* parent,
|
||||
const char* child_name )
|
||||
{
|
||||
const simgear::PropertyList& props = parent->getChildren(child_name);
|
||||
std::vector<T> values( props.size() );
|
||||
|
||||
for( size_t i = 0; i < props.size(); ++i )
|
||||
values[i] = getValue<T_get>(props[i]);
|
||||
|
||||
return values;
|
||||
}
|
||||
|
||||
/**
|
||||
* Split a string by a delimter and convert the values to float
|
||||
*
|
||||
* TODO do we need other types than float?
|
||||
*/
|
||||
std::vector<float> splitAndConvert(const char del[], const std::string& str);
|
||||
|
||||
/**
|
||||
* Parse a (CSS) color
|
||||
*/
|
||||
osg::Vec4 parseColor(std::string str);
|
||||
|
||||
/**
|
||||
* @param name Name of color node
|
||||
* @param parent Parent for color channel nodes
|
||||
* @param nodes Vector to push color nodes into
|
||||
* @param def Default color
|
||||
*
|
||||
* @deprecated Use only a single property instead and parse with #parseColor
|
||||
*
|
||||
* <name>
|
||||
* <red type="float">def[0] or existing value</red>
|
||||
* <green type="float">def[1] or existing value</green>
|
||||
* <blue type="float">def[2] or existing value</blue>
|
||||
* <alpha type="float">def[3] or existing value</alpha>
|
||||
* </name>
|
||||
*/
|
||||
void linkColorNodes( const char* name,
|
||||
SGPropertyNode* parent,
|
||||
std::vector<SGPropertyNode_ptr>& nodes,
|
||||
const osg::Vec4& def = osg::Vec4(0,0,0,1) );
|
||||
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* PROPERTY_HELPER_HXX_ */
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
// Class representing a rectangular region
|
||||
//
|
||||
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
|
||||
//
|
||||
// This program is free software; you can redistribute it and/or
|
||||
// modify it under the terms of the GNU General Public License as
|
||||
// published by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful, but
|
||||
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
// General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#ifndef CANVAS_RECT_HXX_
|
||||
#define CANVAS_RECT_HXX_
|
||||
|
||||
#include <osg/Vec2>
|
||||
|
||||
namespace canvas
|
||||
{
|
||||
template<typename T>
|
||||
class Rect
|
||||
{
|
||||
public:
|
||||
Rect():
|
||||
_x1(0),
|
||||
_x2(0),
|
||||
_y1(0),
|
||||
_y2(0)
|
||||
{}
|
||||
|
||||
Rect(T x, T y, T w, T h):
|
||||
_x1(x),
|
||||
_x2(x + w),
|
||||
_y1(y),
|
||||
_y2(y + h)
|
||||
{}
|
||||
|
||||
void set(T x, T y, T w, T h)
|
||||
{
|
||||
_x1 = x;
|
||||
_x2 = x + w;
|
||||
_y1 = y;
|
||||
_y2 = y + h;
|
||||
}
|
||||
|
||||
T x() const { return _x1; }
|
||||
T y() const { return _y1; }
|
||||
T width() const { return _x2 - _x1; }
|
||||
T height() const { return _y2 - _y1; }
|
||||
|
||||
void setX(T x) { T w = width(); _x1 = x; _x2 = x + w; }
|
||||
void setY(T y) { T h = height(); _y1 = y; _y2 = y + h; }
|
||||
void setWidth(T w) { _x2 = _x1 + w; }
|
||||
void setHeight(T h) { _y2 = _y1 + h; }
|
||||
|
||||
T l() const { return _x1; }
|
||||
T r() const { return _x2; }
|
||||
T t() const { return _y1; }
|
||||
T b() const { return _y2; }
|
||||
|
||||
void setLeft(T l) { _x1 = l; }
|
||||
void setRight(T r) { _x2 = r; }
|
||||
void setTop(T t) { _y1 = t; }
|
||||
void setBottom(T b) { _y2 = b; }
|
||||
|
||||
bool contains(T x, T y) const
|
||||
{
|
||||
return _x1 <= x && x <= _x2
|
||||
&& _y1 <= y && y <= _y2;
|
||||
}
|
||||
|
||||
private:
|
||||
T _x1, _x2, _y1, _y2;
|
||||
};
|
||||
} // namespace canvas
|
||||
|
||||
#endif /* CANVAS_RECT_HXX_ */
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
#include "window.hxx"
|
||||
#include <Canvas/canvas.hxx>
|
||||
#include <simgear/canvas/Canvas.hxx>
|
||||
|
||||
#include <osgGA/GUIEventHandler>
|
||||
|
||||
|
|
@ -28,7 +28,9 @@ namespace canvas
|
|||
//----------------------------------------------------------------------------
|
||||
Window::Window(SGPropertyNode* node):
|
||||
PropertyBasedElement(node),
|
||||
_image(node, Element::Style())
|
||||
_image( simgear::canvas::CanvasPtr(),
|
||||
node,
|
||||
simgear::canvas::Element::Style() )
|
||||
{
|
||||
_image.removeListener();
|
||||
|
||||
|
|
@ -71,25 +73,25 @@ namespace canvas
|
|||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
const Rect<float>& Window::getRegion() const
|
||||
const simgear::Rect<float>& Window::getRegion() const
|
||||
{
|
||||
return _image.getRegion();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
void Window::setCanvas(CanvasPtr canvas)
|
||||
void Window::setCanvas(simgear::canvas::CanvasPtr canvas)
|
||||
{
|
||||
_image.setCanvas(canvas);
|
||||
_image.setSrcCanvas(canvas);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
CanvasWeakPtr Window::getCanvas() const
|
||||
simgear::canvas::CanvasWeakPtr Window::getCanvas() const
|
||||
{
|
||||
return _image.getCanvas();
|
||||
return _image.getSrcCanvas();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool Window::handleMouseEvent(const MouseEvent& event)
|
||||
bool Window::handleMouseEvent(const simgear::canvas::MouseEvent& event)
|
||||
{
|
||||
if( !getCanvas().expired() )
|
||||
return getCanvas().lock()->handleMouseEvent(event);
|
||||
|
|
|
|||
|
|
@ -19,9 +19,8 @@
|
|||
#ifndef CANVAS_WINDOW_HXX_
|
||||
#define CANVAS_WINDOW_HXX_
|
||||
|
||||
#include <Canvas/elements/CanvasImage.hxx>
|
||||
#include <Canvas/MouseEvent.hxx>
|
||||
|
||||
#include <simgear/canvas/elements/CanvasImage.hxx>
|
||||
#include <simgear/canvas/MouseEvent.hxx>
|
||||
#include <simgear/props/PropertyBasedElement.hxx>
|
||||
#include <simgear/props/propertyObject.hxx>
|
||||
|
||||
|
|
@ -41,16 +40,16 @@ namespace canvas
|
|||
virtual void valueChanged (SGPropertyNode * node);
|
||||
|
||||
osg::Group* getGroup();
|
||||
const Rect<float>& getRegion() const;
|
||||
const simgear::Rect<float>& getRegion() const;
|
||||
|
||||
void setCanvas(CanvasPtr canvas);
|
||||
CanvasWeakPtr getCanvas() const;
|
||||
void setCanvas(simgear::canvas::CanvasPtr canvas);
|
||||
simgear::canvas::CanvasWeakPtr getCanvas() const;
|
||||
|
||||
bool handleMouseEvent(const MouseEvent& event);
|
||||
bool handleMouseEvent(const simgear::canvas::MouseEvent& event);
|
||||
|
||||
protected:
|
||||
|
||||
Image _image;
|
||||
simgear::canvas::Image _image;
|
||||
|
||||
void doRaise(SGPropertyNode* node_raise);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -47,30 +47,21 @@
|
|||
#include <simgear/scene/material/EffectGeode.hxx>
|
||||
#include <simgear/scene/util/RenderConstants.hxx>
|
||||
|
||||
#include <Canvas/FGCanvasSystemAdapter.hxx>
|
||||
#include <Main/globals.hxx>
|
||||
#include <Viewer/renderer.hxx>
|
||||
#include <Scenery/scenery.hxx>
|
||||
#include "od_gauge.hxx"
|
||||
|
||||
#include <cassert>
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
static void cbAddCamera(osg::Camera* cam)
|
||||
{
|
||||
globals->get_renderer()->addCamera(cam, false);
|
||||
}
|
||||
static simgear::canvas::SystemAdapterPtr system_adapter(
|
||||
new canvas::FGCanvasSystemAdapter
|
||||
);
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
static void cbRemoveCamera(osg::Camera* cam)
|
||||
FGODGauge::FGODGauge()
|
||||
{
|
||||
globals->get_renderer()->removeCamera(cam);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
FGODGauge::FGODGauge():
|
||||
simgear::ODGauge(cbAddCamera, cbRemoveCamera)
|
||||
{
|
||||
|
||||
setSystemAdapter(system_adapter);
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
|
@ -122,7 +113,7 @@ class ReplaceStaticTextureVisitor:
|
|||
* Get a list of groups which have been inserted into the scene graph to
|
||||
* replace the given texture
|
||||
*/
|
||||
canvas::Placements& getPlacements()
|
||||
simgear::canvas::Placements& getPlacements()
|
||||
{
|
||||
return _placements;
|
||||
}
|
||||
|
|
@ -198,7 +189,7 @@ class ReplaceStaticTextureVisitor:
|
|||
group->setCullCallback(_cull_callback);
|
||||
|
||||
_placements.push_back(
|
||||
canvas::PlacementPtr(new ObjectPlacement(group))
|
||||
simgear::canvas::PlacementPtr(new ObjectPlacement(group))
|
||||
);
|
||||
|
||||
osg::StateSet* stateSet = group->getOrCreateStateSet();
|
||||
|
|
@ -223,7 +214,7 @@ class ReplaceStaticTextureVisitor:
|
|||
protected:
|
||||
|
||||
class ObjectPlacement:
|
||||
public canvas::Placement
|
||||
public simgear::canvas::Placement
|
||||
{
|
||||
public:
|
||||
ObjectPlacement(osg::ref_ptr<osg::Group> group):
|
||||
|
|
@ -259,12 +250,13 @@ class ReplaceStaticTextureVisitor:
|
|||
osg::Texture2D *_new_texture;
|
||||
osg::NodeCallback *_cull_callback;
|
||||
|
||||
canvas::Placements _placements;
|
||||
simgear::canvas::Placements _placements;
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
canvas::Placements FGODGauge::set_texture( const char* name,
|
||||
osg::Texture2D* new_texture )
|
||||
simgear::canvas::Placements
|
||||
FGODGauge::set_texture( const char* name,
|
||||
osg::Texture2D* new_texture )
|
||||
{
|
||||
osg::Group* root = globals->get_scenery()->get_aircraft_branch();
|
||||
ReplaceStaticTextureVisitor visitor(name, new_texture);
|
||||
|
|
@ -273,9 +265,10 @@ canvas::Placements FGODGauge::set_texture( const char* name,
|
|||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
canvas::Placements FGODGauge::set_texture( const SGPropertyNode* placement,
|
||||
osg::Texture2D* new_texture,
|
||||
osg::NodeCallback* cull_callback )
|
||||
simgear::canvas::Placements
|
||||
FGODGauge::set_texture( const SGPropertyNode* placement,
|
||||
osg::Texture2D* new_texture,
|
||||
osg::NodeCallback* cull_callback )
|
||||
{
|
||||
osg::Group* root = globals->get_scenery()->get_aircraft_branch();
|
||||
ReplaceStaticTextureVisitor visitor(placement, new_texture, cull_callback);
|
||||
|
|
|
|||
|
|
@ -22,9 +22,9 @@
|
|||
#define _OD_GAUGE_HXX
|
||||
|
||||
#include <Canvas/canvas_fwd.hpp>
|
||||
#include <Canvas/placement.hxx>
|
||||
|
||||
#include <simgear/canvas/ODGauge.hxx>
|
||||
#include <simgear/canvas/CanvasPlacement.hxx>
|
||||
|
||||
class SGPropertyNode;
|
||||
|
||||
|
|
@ -32,7 +32,7 @@ class SGPropertyNode;
|
|||
* Owner Drawn Gauge helper class
|
||||
*/
|
||||
class FGODGauge:
|
||||
public simgear::ODGauge
|
||||
public simgear::canvas::ODGauge
|
||||
{
|
||||
public:
|
||||
FGODGauge();
|
||||
|
|
@ -46,8 +46,8 @@ class FGODGauge:
|
|||
* @return A list of groups which override the given texture
|
||||
*/
|
||||
static
|
||||
canvas::Placements set_texture( const char * name,
|
||||
osg::Texture2D* new_texture );
|
||||
simgear::canvas::Placements set_texture( const char * name,
|
||||
osg::Texture2D* new_texture );
|
||||
|
||||
/**
|
||||
* Replace an opengl texture name inside the aircraft scene graph.
|
||||
|
|
@ -64,9 +64,10 @@ class FGODGauge:
|
|||
* @return A list of groups which override the given texture
|
||||
*/
|
||||
static
|
||||
canvas::Placements set_texture( const SGPropertyNode* placement,
|
||||
osg::Texture2D* new_texture,
|
||||
osg::NodeCallback* cull_callback = 0 );
|
||||
simgear::canvas::Placements
|
||||
set_texture( const SGPropertyNode* placement,
|
||||
osg::Texture2D* new_texture,
|
||||
osg::NodeCallback* cull_callback = 0 );
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -90,9 +90,6 @@ if(ENABLE_JSBSIM)
|
|||
target_link_libraries(fgfs JSBSim)
|
||||
endif()
|
||||
|
||||
include_directories(${PROJECT_SOURCE_DIR}/src/Canvas/ShivaVG/include)
|
||||
add_definitions(-DVG_API_EXPORT)
|
||||
|
||||
target_link_libraries(fgfs
|
||||
${SQLITE3_LIBRARY}
|
||||
${SIMGEAR_LIBRARIES}
|
||||
|
|
@ -105,7 +102,6 @@ target_link_libraries(fgfs
|
|||
${SIMGEAR_CORE_LIBRARY_DEPENDENCIES}
|
||||
${SIMGEAR_SCENE_LIBRARY_DEPENDENCIES}
|
||||
${PLATFORM_LIBS}
|
||||
ShivaVG
|
||||
)
|
||||
|
||||
install(TARGETS fgfs RUNTIME DESTINATION bin)
|
||||
|
|
|
|||
|
|
@ -33,8 +33,8 @@
|
|||
|
||||
#include <simgear/sg_inlines.h>
|
||||
|
||||
#include <Canvas/canvas.hxx>
|
||||
#include <Canvas/elements/element.hxx>
|
||||
#include <simgear/canvas/Canvas.hxx>
|
||||
#include <simgear/canvas/elements/element.hxx>
|
||||
|
||||
static naRef canvasPrototype;
|
||||
static naRef elementPrototype;
|
||||
|
|
@ -88,17 +88,17 @@ static naRef eventTypeToNasal(naContext c, osgGA::GUIEventAdapter::EventType ty)
|
|||
return naNil();
|
||||
}
|
||||
|
||||
static canvas::Element* elementGhost(naRef r)
|
||||
static simgear::canvas::Element* elementGhost(naRef r)
|
||||
{
|
||||
if (naGhost_type(r) == &ElementGhostType)
|
||||
return (canvas::Element*) naGhost_ptr(r);
|
||||
return (simgear::canvas::Element*) naGhost_ptr(r);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static Canvas* canvasGhost(naRef r)
|
||||
static simgear::canvas::Canvas* canvasGhost(naRef r)
|
||||
{
|
||||
if (naGhost_type(r) == &CanvasGhostType)
|
||||
return (Canvas*) naGhost_ptr(r);
|
||||
return (simgear::canvas::Canvas*) naGhost_ptr(r);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -139,7 +139,7 @@ static const char* eventGhostGetMember(naContext c, void* g, naRef field, naRef*
|
|||
static const char* canvasGhostGetMember(naContext c, void* g, naRef field, naRef* out)
|
||||
{
|
||||
const char* fieldName = naStr_data(field);
|
||||
Canvas* cvs = (Canvas*) g;
|
||||
simgear::canvas::Canvas* cvs = (simgear::canvas::Canvas*) g;
|
||||
|
||||
if (!strcmp(fieldName, "parents")) {
|
||||
*out = naNewVector(c);
|
||||
|
|
@ -156,7 +156,7 @@ static const char* canvasGhostGetMember(naContext c, void* g, naRef field, naRef
|
|||
static const char* elementGhostGetMember(naContext c, void* g, naRef field, naRef* out)
|
||||
{
|
||||
const char* fieldName = naStr_data(field);
|
||||
canvas::Element* e = (canvas::Element*) g;
|
||||
simgear::canvas::Element* e = (simgear::canvas::Element*) g;
|
||||
SG_UNUSED(e);
|
||||
|
||||
if (!strcmp(fieldName, "parents")) {
|
||||
|
|
@ -172,7 +172,7 @@ static const char* elementGhostGetMember(naContext c, void* g, naRef field, naRe
|
|||
static void elementGhostSetMember(naContext c, void* g, naRef field, naRef value)
|
||||
{
|
||||
const char* fieldName = naStr_data(field);
|
||||
canvas::Element* e = (canvas::Element*) g;
|
||||
simgear::canvas::Element* e = (simgear::canvas::Element*) g;
|
||||
SG_UNUSED(fieldName);
|
||||
SG_UNUSED(e);
|
||||
}
|
||||
|
|
@ -180,7 +180,7 @@ static void elementGhostSetMember(naContext c, void* g, naRef field, naRef value
|
|||
|
||||
static naRef f_canvas_getElement(naContext c, naRef me, int argc, naRef* args)
|
||||
{
|
||||
Canvas* cvs = canvasGhost(me);
|
||||
simgear::canvas::Canvas* cvs = canvasGhost(me);
|
||||
if (!cvs) {
|
||||
naRuntimeError(c, "canvas.getElement called on non-canvas object");
|
||||
}
|
||||
|
|
@ -190,7 +190,7 @@ static naRef f_canvas_getElement(naContext c, naRef me, int argc, naRef* args)
|
|||
|
||||
static naRef f_element_addButtonCallback(naContext c, naRef me, int argc, naRef* args)
|
||||
{
|
||||
canvas::Element* e = elementGhost(me);
|
||||
simgear::canvas::Element* e = elementGhost(me);
|
||||
if (!e) {
|
||||
naRuntimeError(c, "element.addButtonCallback called on non-canvas-element object");
|
||||
}
|
||||
|
|
@ -200,7 +200,7 @@ static naRef f_element_addButtonCallback(naContext c, naRef me, int argc, naRef*
|
|||
|
||||
static naRef f_element_addDragCallback(naContext c, naRef me, int argc, naRef* args)
|
||||
{
|
||||
canvas::Element* e = elementGhost(me);
|
||||
simgear::canvas::Element* e = elementGhost(me);
|
||||
if (!e) {
|
||||
naRuntimeError(c, "element.addDragCallback called on non-canvas-element object");
|
||||
}
|
||||
|
|
@ -210,7 +210,7 @@ static naRef f_element_addDragCallback(naContext c, naRef me, int argc, naRef* a
|
|||
|
||||
static naRef f_element_addMoveCallback(naContext c, naRef me, int argc, naRef* args)
|
||||
{
|
||||
canvas::Element* e = elementGhost(me);
|
||||
simgear::canvas::Element* e = elementGhost(me);
|
||||
if (!e) {
|
||||
naRuntimeError(c, "element.addMoveCallback called on non-canvas-element object");
|
||||
}
|
||||
|
|
@ -220,7 +220,7 @@ static naRef f_element_addMoveCallback(naContext c, naRef me, int argc, naRef* a
|
|||
|
||||
static naRef f_element_addScrollCallback(naContext c, naRef me, int argc, naRef* args)
|
||||
{
|
||||
canvas::Element* e = elementGhost(me);
|
||||
simgear::canvas::Element* e = elementGhost(me);
|
||||
if (!e) {
|
||||
naRuntimeError(c, "element.addScrollCallback called on non-canvas-element object");
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue