pax_global_header 0000666 0000000 0000000 00000000064 13615262311 0014512 g ustar 00root root 0000000 0000000 52 comment=f90160de8c0cff3c627eaae2994f6cec142e6f7c
visualization.spectrum-3.0.3-Leia/ 0000775 0000000 0000000 00000000000 13615262311 0017127 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/.gitignore 0000664 0000000 0000000 00000001042 13615262311 0021114 0 ustar 00root root 0000000 0000000 # build artifacts
build/
visualization.*/addon.xml
# Debian build files
debian/changelog
debian/files
debian/*.log
debian/*.substvars
debian/.debhelper/
debian/tmp/
debian/kodi-visualization-*/
obj-x86_64-linux-gnu/
# commonly used editors
# vim
*.swp
# Eclipse
*.project
*.cproject
.classpath
*.sublime-*
.settings/
# KDevelop 4
*.kdev4
# gedit
*~
# CLion
/.idea
# clion
.idea/
# to prevent add after a "git format-patch VALUE" and "git add ." call
/*.patch
# to prevent add if project code opened by Visual Studio over CMake file
.vs/
visualization.spectrum-3.0.3-Leia/.travis.yml 0000664 0000000 0000000 00000002347 13615262311 0021246 0 ustar 00root root 0000000 0000000 language: cpp
#
# Define the build matrix
#
# Travis defaults to building on Ubuntu Precise when building on
# Linux. We need Trusty in order to get up to date versions of
# cmake and g++.
#
env:
global:
- app_id=visualization.spectrum
matrix:
include:
- os: linux
dist: xenial
sudo: required
compiler: gcc
- os: linux
dist: xenial
sudo: required
compiler: clang
- os: osx
osx_image: xcode9.3
before_install:
- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then sudo apt-get install -y libgl1-mesa-dev; fi
#
# The addon source is automatically checked out in $TRAVIS_BUILD_DIR,
# we'll put the Kodi source on the same level
#
before_script:
- cd $TRAVIS_BUILD_DIR/..
- git clone --branch Leia --depth=1 https://github.com/xbmc/xbmc.git
- cd ${app_id} && mkdir build && cd build
- mkdir -p definition/${app_id}
- echo ${app_id} $TRAVIS_BUILD_DIR $TRAVIS_COMMIT > definition/${app_id}/${app_id}.txt
- cmake -DADDONS_TO_BUILD=${app_id} -DADDON_SRC_PREFIX=$TRAVIS_BUILD_DIR/.. -DADDONS_DEFINITION_DIR=$TRAVIS_BUILD_DIR/build/definition -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=$TRAVIS_BUILD_DIR/../xbmc/addons -DPACKAGE_ZIP=1 $TRAVIS_BUILD_DIR/../xbmc/cmake/addons
script: make
visualization.spectrum-3.0.3-Leia/CMakeLists.txt 0000664 0000000 0000000 00000004170 13615262311 0021671 0 ustar 00root root 0000000 0000000 cmake_minimum_required(VERSION 3.5)
project(visualization.spectrum)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR})
find_package(Kodi REQUIRED)
if(WIN32)
set(APP_RENDER_SYSTEM dx11)
add_definitions(-DDIRECTX_SPEKTRUM_EXPORTS -D_WIN32PC -D_USRDLL)
set(SHADER_FILES src/DefaultVertexShader.hlsl
src/DefaultPixelShader.hlsl)
set(SHADER_INCLUDES)
foreach( SHADER_FILE ${SHADER_FILES} )
get_filename_component( FileName ${SHADER_FILE} NAME_WE )
if(${FileName} MATCHES "(.+Vertex.+)")
set(ShaderType vs)
elseif(${FileName} MATCHES "(.+Pixel.+)")
set(ShaderType ps)
else()
message(FATAL_ERROR ${SHADER_FILE}": Unknown shader type.")
endif()
set( IncFile src/${FileName}.inc )
list( APPEND SHADER_INCLUDES ${IncFile} )
add_custom_command(
OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${IncFile}
COMMAND fxc /nologo /T${ShaderType}_4_0_level_9_1 /Vn ${FileName}Code /Fh ${IncFile} ${SHADER_FILE}
MAIN_DEPENDENCY ${SHADER_FILE}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
VERBATIM)
endforeach(SHADER_FILE)
add_custom_target(generate ALL DEPENDS ${SHADER_INCLUDES})
set(SPECTRUM_SOURCES src/directx_spectrum.cpp)
else()
find_package(glm REQUIRED)
if(APP_RENDER_SYSTEM STREQUAL "gl" OR NOT APP_RENDER_SYSTEM)
find_package(OpenGl REQUIRED)
set(DEPLIBS ${OPENGL_LIBRARIES})
set(INCLUDES ${OPENGL_INCLUDE_DIR})
add_definitions(${OPENGL_DEFINITIONS})
elseif(APP_RENDER_SYSTEM STREQUAL "gles")
find_package(OpenGLES REQUIRED)
set(DEPLIBS ${OPENGLES_LIBRARIES})
set(INCLUDES ${OPENGLES_INCLUDE_DIR})
add_definitions(${OPENGLES_DEFINITIONS})
endif()
set(SPECTRUM_SOURCES src/opengl_spectrum.cpp)
include_directories(${GLM_INCLUDE_DIR}
${PROJECT_SOURCE_DIR}/lib)
endif()
message(STATUS "Configured render system: ${APP_RENDER_SYSTEM}")
include_directories(${INCLUDES}
${KODI_INCLUDE_DIR}/..) # Hack way with "/..", need bigger Kodi cmake rework to match right include ways (becomes done in future)
build_addon(visualization.spectrum SPECTRUM DEPLIBS)
include(CPack)
visualization.spectrum-3.0.3-Leia/COPYING 0000664 0000000 0000000 00000104513 13615262311 0020166 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, 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
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If 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 convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU 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
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
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 3 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, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
visualization.spectrum-3.0.3-Leia/FindOpenGLES.cmake 0000664 0000000 0000000 00000003636 13615262311 0022316 0 ustar 00root root 0000000 0000000 #.rst:
# FindOpenGLES
# ------------
# Finds the OpenGLES2 and OpenGLES3 library
#
# This will define the following variables:
#
# OPENGLES_FOUND - system has OpenGLES
# OPENGLES_INCLUDE_DIRS - the OpenGLES include directory
# OPENGLES_LIBRARIES - the OpenGLES libraries
# OPENGLES_DEFINITIONS - the OpenGLES definitions
#
if(CORE_PLATFORM_NAME_LC STREQUAL rbpi)
set(_brcmprefix brcm)
endif()
if(PKG_CONFIG_FOUND)
pkg_check_modules(PC_OPENGLES ${_brcmprefix}glesv2 QUIET)
endif()
if(NOT CORE_SYSTEM_NAME STREQUAL ios AND
NOT CORE_SYSTEM_NAME STREQUAL darwin_embedded)
find_path(OPENGLES_INCLUDE_DIR GLES2/gl2.h
PATHS ${PC_OPENGLES_INCLUDEDIR})
find_library(OPENGLES_gl_LIBRARY NAMES ${_brcmprefix}GLESv2
PATHS ${PC_OPENGLES_LIBDIR})
else()
find_library(OPENGLES_gl_LIBRARY NAMES OpenGLES
PATHS ${CMAKE_OSX_SYSROOT}/System/Library
PATH_SUFFIXES Frameworks
NO_DEFAULT_PATH)
set(OPENGLES_INCLUDE_DIR ${OPENGLES_gl_LIBRARY}/Headers)
endif()
find_path(OPENGLES3_INCLUDE_DIR GLES3/gl3.h)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(OpenGLES
REQUIRED_VARS OPENGLES_gl_LIBRARY OPENGLES_INCLUDE_DIR)
find_path(OPENGLES3_INCLUDE_DIR GLES3/gl3.h
PATHS ${PC_OPENGLES_INCLUDEDIR})
if(OPENGLES_FOUND)
set(OPENGLES_LIBRARIES ${OPENGLES_gl_LIBRARY})
if(OPENGLES3_INCLUDE_DIR)
set(OPENGLES_INCLUDE_DIRS ${OPENGLES_INCLUDE_DIR} ${OPENGLES3_INCLUDE_DIR})
set(OPENGLES_DEFINITIONS -DHAS_GLES=3)
mark_as_advanced(OPENGLES_INCLUDE_DIR OPENGLES3_INCLUDE_DIR OPENGLES_gl_LIBRARY)
else()
set(OPENGLES_INCLUDE_DIRS ${OPENGLES_INCLUDE_DIR})
set(OPENGLES_DEFINITIONS -DHAS_GLES=2)
mark_as_advanced(OPENGLES_INCLUDE_DIR OPENGLES_gl_LIBRARY)
endif()
endif()
visualization.spectrum-3.0.3-Leia/FindOpenGl.cmake 0000664 0000000 0000000 00000002407 13615262311 0022121 0 ustar 00root root 0000000 0000000 #.rst:
# FindOpenGl
# ----------
# Finds the FindOpenGl library
#
# This will define the following variables::
#
# OPENGL_FOUND - system has OpenGl
# OPENGL_INCLUDE_DIRS - the OpenGl include directory
# OPENGL_LIBRARIES - the OpenGl libraries
# OPENGL_DEFINITIONS - the OpenGl definitions
if(PKG_CONFIG_FOUND)
pkg_check_modules(PC_OPENGL gl QUIET)
endif()
if(NOT CORE_SYSTEM_NAME STREQUAL osx)
find_path(OPENGL_INCLUDE_DIR GL/gl.h
PATHS ${PC_OPENGL_gl_INCLUDEDIR})
find_library(OPENGL_gl_LIBRARY NAMES GL
PATHS ${PC_OPENGL_gl_LIBDIR})
else()
find_library(OPENGL_gl_LIBRARY NAMES OpenGL
PATHS ${CMAKE_OSX_SYSROOT}/System/Library
PATH_SUFFIXES Frameworks
NO_DEFAULT_PATH)
set(OPENGL_INCLUDE_DIR ${OPENGL_gl_LIBRARY}/Headers)
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(OpenGl
REQUIRED_VARS OPENGL_gl_LIBRARY OPENGL_INCLUDE_DIR)
if(OPENGL_FOUND)
set(OPENGL_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR})
set(OPENGL_LIBRARIES ${OPENGL_gl_LIBRARY})
set(OPENGL_DEFINITIONS -DHAS_GL=1)
endif()
mark_as_advanced(OPENGL_INCLUDE_DIR OPENGL_gl_LIBRARY)
visualization.spectrum-3.0.3-Leia/Jenkinsfile 0000664 0000000 0000000 00000000035 13615262311 0021311 0 ustar 00root root 0000000 0000000 buildPlugin(version: "Leia")
visualization.spectrum-3.0.3-Leia/README.md 0000664 0000000 0000000 00000003144 13615262311 0020410 0 ustar 00root root 0000000 0000000 # visualization.spectrum addon for Kodi
This is a [Kodi](https://kodi.tv) visualization addon.
[](https://travis-ci.org/xbmc/visualization.spectrum/branches)
[](https://ci.appveyor.com/project/xbmc/visualization-spectrum?branch=Leia)

## Build instructions
When building the addon you have to use the correct branch depending on which version of Kodi you're building against.
If you want to build the addon to be compatible with the latest kodi `master` commit, you need to checkout the branch with the current kodi codename.
Also make sure you follow this README from the branch in question.
### Linux
The following instructions assume you will have built Kodi already in the `kodi-build` directory
suggested by the README.
1. `git clone --branch Leia https://github.com/xbmc/xbmc.git`
2. `git clone --branch Leia https://github.com/xbmc/visualization.spectrum.git`
3. `cd visualization.spectrum && mkdir build && cd build`
4. `cmake -DADDONS_TO_BUILD=visualization.spectrum -DADDON_SRC_PREFIX=../.. -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=../../xbmc/kodi-build/addons -DPACKAGE_ZIP=1 ../../xbmc/cmake/addons`
5. `make`
The addon files will be placed in `../../xbmc/kodi-build/addons` so if you build Kodi from source and run it directly
the addon will be available as a system addon.
visualization.spectrum-3.0.3-Leia/appveyor.yml 0000664 0000000 0000000 00000002271 13615262311 0021521 0 ustar 00root root 0000000 0000000 version: BuildNr.{build}
image: Visual Studio 2017
shallow_clone: true
clone_folder: c:\projects\visualization.spectrum
environment:
app_id: visualization.spectrum
matrix:
- GENERATOR: "Visual Studio 15"
CONFIG: Release
- GENERATOR: "Visual Studio 15 Win64"
CONFIG: Release
- GENERATOR: "Visual Studio 15 Win64"
CONFIG: Release
WINSTORE: -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0.16299.0"
- GENERATOR: "Visual Studio 15 ARM"
CONFIG: Release
WINSTORE: -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0.16299.0"
build_script:
- cd ..
- git clone --branch Leia --depth=1 https://github.com/xbmc/xbmc.git
- cd %app_id%
- mkdir build
- cd build
- mkdir -p definition\%app_id%
- echo %app_id% %APPVEYOR_BUILD_FOLDER% %APPVEYOR_REPO_COMMIT% > definition\%app_id%\%app_id%.txt
- cmake -T host=x64 -G "%GENERATOR%" %WINSTORE% -DADDONS_TO_BUILD=%app_id% -DCMAKE_BUILD_TYPE=%CONFIG% -DADDONS_DEFINITION_DIR=%APPVEYOR_BUILD_FOLDER%/build/definition -DADDON_SRC_PREFIX=../.. -DCMAKE_INSTALL_PREFIX=../../xbmc/addons -DPACKAGE_ZIP=1 ../../xbmc/cmake/addons
- cmake --build . --config %CONFIG% --target %app_id%
visualization.spectrum-3.0.3-Leia/debian/ 0000775 0000000 0000000 00000000000 13615262311 0020351 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/debian/changelog.in 0000664 0000000 0000000 00000000300 13615262311 0022621 0 ustar 00root root 0000000 0000000 kodi-visualization-spectrum (#PACKAGEVERSION#-#TAGREV#~#DIST#) #DIST#; urgency=low
[ kodi ]
* autogenerated dummy changelog
-- Nobody Sat, 01 Jun 2013 00:59:22 +0200
visualization.spectrum-3.0.3-Leia/debian/compat 0000664 0000000 0000000 00000000002 13615262311 0021547 0 ustar 00root root 0000000 0000000 9
visualization.spectrum-3.0.3-Leia/debian/control 0000664 0000000 0000000 00000001332 13615262311 0021753 0 ustar 00root root 0000000 0000000 Source: kodi-visualization-spectrum
Priority: extra
Maintainer: Nobody
Build-Depends: debhelper (>= 9.0.0), cmake, kodi-addon-dev,
libgles2-mesa-dev [arm64 armhf], libgl1-mesa-dev [i386 amd64],
libglm-dev
Standards-Version: 4.1.2
Section: libs
Homepage: http://kodi.tv
Package: kodi-visualization-spectrum
Section: libs
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Spectrum visualizer for Kodi
Spectrum visualizer for Kodi
Package: kodi-visualization-spectrum-dbg
Section: debug
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: debug symbols for Spectrum visualizer for Kodi
debug symbols for Spectrum visualizer for Kodi
visualization.spectrum-3.0.3-Leia/debian/copyright 0000664 0000000 0000000 00000003617 13615262311 0022313 0 ustar 00root root 0000000 0000000 Format: http://dep.debian.net/deps/dep5
Upstream-Name: visualization.spectrum
Files: *
Copyright: 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies
2005-2020 Team Kodi
License: GPL-2+
This package 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 package 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, see
.
On Debian systems, the complete text of the GNU General
Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
Files: debian/*
Copyright: 2013 Arne Morten Kvarving
2013 wsnipex
2005-2020 Team Kodi
License: GPL-2+
This package 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 package 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, see
.
On Debian systems, the complete text of the GNU General
Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
visualization.spectrum-3.0.3-Leia/debian/kodi-visualization-spectrum.install 0000664 0000000 0000000 00000000026 13615262311 0027424 0 ustar 00root root 0000000 0000000 usr/lib/*
usr/share/*
visualization.spectrum-3.0.3-Leia/debian/rules 0000775 0000000 0000000 00000001310 13615262311 0021424 0 ustar 00root root 0000000 0000000 #!/usr/bin/make -f
# -*- makefile -*-
# Sample debian/rules that uses debhelper.
# This file was originally written by Joey Hess and Craig Small.
# As a special exception, when this file is copied by dh-make into a
# dh-make output file, you may use that output file without restriction.
# This special exception was added by Craig Small in version 0.37 of dh-make.
# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1
%:
dh $@
override_dh_auto_configure:
dh_auto_configure -- -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=1 -DUSE_LTO=1
override_dh_strip:
dh_strip --dbg-package=kodi-visualization-spectrum-dbg
override_dh_installdocs:
dh_installdocs --link-doc=kodi-visualization-spectrum
visualization.spectrum-3.0.3-Leia/debian/source/ 0000775 0000000 0000000 00000000000 13615262311 0021651 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/debian/source/format 0000664 0000000 0000000 00000000014 13615262311 0023057 0 ustar 00root root 0000000 0000000 3.0 (quilt)
visualization.spectrum-3.0.3-Leia/depends/ 0000775 0000000 0000000 00000000000 13615262311 0020551 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/depends/common/ 0000775 0000000 0000000 00000000000 13615262311 0022041 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/depends/common/glm/ 0000775 0000000 0000000 00000000000 13615262311 0022620 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/depends/common/glm/flags.txt 0000664 0000000 0000000 00000000150 13615262311 0024451 0 ustar 00root root 0000000 0000000 -DGLM_TEST_ENABLE_CXX_11=1 -DGLM_TEST_ENABLE=0 -DGLM_TEST_ENABLE_SIMD_SSE2=0 -DCMAKE_INSTALL_LIBDIR=lib
visualization.spectrum-3.0.3-Leia/depends/common/glm/glm.sha256 0000664 0000000 0000000 00000000101 13615262311 0024321 0 ustar 00root root 0000000 0000000 3a073eb8f3be07cee74481db0e1f78eda553b554941e405c863ab64de6a2e954
visualization.spectrum-3.0.3-Leia/depends/common/glm/glm.txt 0000664 0000000 0000000 00000000071 13615262311 0024136 0 ustar 00root root 0000000 0000000 glm https://github.com/g-truc/glm/archive/0.9.9.4.tar.gz
visualization.spectrum-3.0.3-Leia/depends/osx/ 0000775 0000000 0000000 00000000000 13615262311 0021362 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/depends/osx/glm/ 0000775 0000000 0000000 00000000000 13615262311 0022141 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/depends/osx/glm/flags.txt 0000664 0000000 0000000 00000000150 13615262311 0023772 0 ustar 00root root 0000000 0000000 -DGLM_TEST_ENABLE_CXX_11=1 -DGLM_TEST_ENABLE=0 -DGLM_TEST_ENABLE_SIMD_SSE2=1 -DCMAKE_INSTALL_LIBDIR=lib
visualization.spectrum-3.0.3-Leia/depends/osx/glm/glm.sha256 0000664 0000000 0000000 00000000101 13615262311 0023642 0 ustar 00root root 0000000 0000000 3a073eb8f3be07cee74481db0e1f78eda553b554941e405c863ab64de6a2e954
visualization.spectrum-3.0.3-Leia/depends/osx/glm/glm.txt 0000664 0000000 0000000 00000000071 13615262311 0023457 0 ustar 00root root 0000000 0000000 glm https://github.com/g-truc/glm/archive/0.9.9.4.tar.gz
visualization.spectrum-3.0.3-Leia/lib/ 0000775 0000000 0000000 00000000000 13615262311 0017675 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/lib/kodi/ 0000775 0000000 0000000 00000000000 13615262311 0020623 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/lib/kodi/gui/ 0000775 0000000 0000000 00000000000 13615262311 0021407 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/lib/kodi/gui/gl/ 0000775 0000000 0000000 00000000000 13615262311 0022011 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/lib/kodi/gui/gl/GL.h 0000664 0000000 0000000 00000006515 13615262311 0022473 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2005-2019 Team Kodi
* This file is part of Kodi - https://kodi.tv
*
* SPDX-License-Identifier: GPL-2.0-or-later
* See LICENSES/README.md for more information.
*/
#pragma once
//==============================================================================
///
/// \defgroup cpp_kodi_gui_gl Kodi OpenGL helpers
/// \ingroup cpp_kodi_gui
/// \brief Auxiliary functions for Open GL
///
/// This group includes help for definitions, functions, and classes for
/// OpenGL.
///
/// To use OpenGL for your system, add the \ref GL.h "#include ".
///
///
///-----------------------------------------------------------------------------
///
/// The \ref HAS_GL is declared if Open GL is required and \ref HAS_GLES if Open GL
/// Embedded Systems (ES) is required, with ES the version is additionally given
/// in the definition, this can be "2" or "3".
///
///
///-----------------------------------------------------------------------------
///
/// Following \ref GL_TYPE_STRING define can be used, for example, to manage
/// different folders for GL and GLES and make the selection easier.
/// This are on OpenGL **"`GL`"** and on Open GL|ES **"`GLES`"**.
/// **Example:**
/// ~~~~~~~~~~~~~~~~~{.cpp}
/// kodi::GetAddonPath("resources/shaders/" GL_TYPE_STRING "/frag.glsl");
/// ~~~~~~~~~~~~~~~~~
///
///
///----------------------------------------------------------------------------
///
/// In addition, \ref BUFFER_OFFSET is declared in it which can be used to give an
/// offset on the array to GL.
/// **Example:**
/// ~~~~~~~~~~~~~~~~~{.cpp}
/// const struct PackedVertex {
/// float position[3]; // Position x, y, z
/// float color[4]; // Color r, g, b, a
/// } vertices[3] = {
/// { { -0.5f, -0.5f, 0.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
/// { { 0.5f, -0.5f, 0.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
/// { { 0.0f, 0.5f, 0.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
/// };
///
/// glVertexAttribPointer(m_aPosition, 3, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, position)));
/// glEnableVertexAttribArray(m_aPosition);
///
/// glVertexAttribPointer(m_aColor, 4, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, color)));
/// glEnableVertexAttribArray(m_aColor);
/// ~~~~~~~~~~~~~~~~~
#if HAS_GL
#define GL_TYPE_STRING "GL"
// always define GL_GLEXT_PROTOTYPES before include gl headers
#if !defined(GL_GLEXT_PROTOTYPES)
#define GL_GLEXT_PROTOTYPES
#endif
#if defined(TARGET_LINUX)
#include
#include
#elif defined(TARGET_FREEBSD)
#include
#elif defined(TARGET_DARWIN)
#include
#include
#elif defined(WIN32)
#error Use of GL under Windows is not possible
#endif
#elif HAS_GLES >= 2
#define GL_TYPE_STRING "GLES"
#if defined(WIN32)
#error Use of GLES under Windows is not possible
#elif defined(TARGET_DARWIN)
#if HAS_GLES == 3
#include
#include
#else
#include
#include
#endif
#else
#if HAS_GLES == 3
#include
#include
#else
#include
#include
#endif
#endif
#endif
#ifndef BUFFER_OFFSET
#define BUFFER_OFFSET(i) ((char *)nullptr + (i))
#endif
visualization.spectrum-3.0.3-Leia/lib/kodi/gui/gl/Shader.h 0000664 0000000 0000000 00000024735 13615262311 0023403 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2005-2019 Team Kodi
* This file is part of Kodi - https://kodi.tv
*
* SPDX-License-Identifier: GPL-2.0-or-later
* See LICENSES/README.md for more information.
*/
#pragma once
#include "GL.h"
#include
#include
#include
#include
#include
#define LOG_SIZE 1024
#define GLchar char
namespace kodi
{
namespace gui
{
namespace gl
{
//========================================================================
/// CShader - base class
class ATTRIBUTE_HIDDEN CShader
{
public:
CShader() = default;
virtual ~CShader() = default;
virtual bool Compile(const std::string& extraBegin = "",
const std::string& extraEnd = "") = 0;
virtual void Free() = 0;
virtual GLuint Handle() = 0;
bool LoadSource(const std::string& file)
{
char buffer[16384];
kodi::vfs::CFile source;
if (!source.OpenFile(file))
{
kodi::Log(ADDON_LOG_ERROR, "CShader::%s: Failed to open file '%s'", __FUNCTION__, file.c_str());
return false;
}
size_t len = source.Read(buffer, sizeof(buffer));
m_source.assign(buffer);
m_source[len] = 0;
source.Close();
return true;
}
bool OK() { return m_compiled; }
protected:
std::string m_source;
std::string m_lastLog;
bool m_compiled = false;
};
//------------------------------------------------------------------------
//========================================================================
/// CVertexShader
class ATTRIBUTE_HIDDEN CVertexShader : public CShader
{
public:
CVertexShader() = default;
~CVertexShader() override { Free(); }
void Free() override
{
if (m_vertexShader)
glDeleteShader(m_vertexShader);
m_vertexShader = 0;
}
bool Compile(const std::string& extraBegin = "",
const std::string& extraEnd = "") override
{
GLint params[4];
Free();
m_vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLsizei count = 0;
const char *sources[3];
if (!extraBegin.empty())
sources[count++] = extraBegin.c_str();
if (!m_source.empty())
sources[count++] = m_source.c_str();
if (!extraEnd.empty())
sources[count++] = extraEnd.c_str();
glShaderSource(m_vertexShader, count, sources, nullptr);
glCompileShader(m_vertexShader);
glGetShaderiv(m_vertexShader, GL_COMPILE_STATUS, params);
if (params[0] != GL_TRUE)
{
GLchar log[LOG_SIZE];
glGetShaderInfoLog(m_vertexShader, LOG_SIZE, nullptr, log);
kodi::Log(ADDON_LOG_ERROR, "CVertexShader::%s: %s", __FUNCTION__, log);
fprintf(stderr, "CVertexShader::%s: %s\n", __FUNCTION__, log);
m_lastLog = log;
m_compiled = false;
}
else
{
GLchar log[LOG_SIZE];
glGetShaderInfoLog(m_vertexShader, LOG_SIZE, nullptr, log);
m_lastLog = log;
m_compiled = true;
}
return m_compiled;
}
GLuint Handle() override { return m_vertexShader; }
protected:
GLuint m_vertexShader = 0;
};
//------------------------------------------------------------------------
//========================================================================
/// CPixelShader
class ATTRIBUTE_HIDDEN CPixelShader : public CShader
{
public:
CPixelShader() = default;
~CPixelShader() { Free(); }
void Free() override
{
if (m_pixelShader)
glDeleteShader(m_pixelShader);
m_pixelShader = 0;
}
bool Compile(const std::string& extraBegin = "",
const std::string& extraEnd = "") override
{
GLint params[4];
Free();
if (m_source.length()==0)
return true;
m_pixelShader = glCreateShader(GL_FRAGMENT_SHADER);
GLsizei count = 0;
const char *sources[3];
if (!extraBegin.empty())
sources[count++] = extraBegin.c_str();
if (!m_source.empty())
sources[count++] = m_source.c_str();
if (!extraEnd.empty())
sources[count++] = extraEnd.c_str();
glShaderSource(m_pixelShader, count, sources, 0);
glCompileShader(m_pixelShader);
glGetShaderiv(m_pixelShader, GL_COMPILE_STATUS, params);
if (params[0] != GL_TRUE)
{
GLchar log[LOG_SIZE];
glGetShaderInfoLog(m_pixelShader, LOG_SIZE, nullptr, log);
kodi::Log(ADDON_LOG_ERROR, "CPixelShader::%s: %s", __FUNCTION__, log);
fprintf(stderr, "CPixelShader::%s: %s\n", __FUNCTION__, log);
m_lastLog = log;
m_compiled = false;
}
else
{
GLchar log[LOG_SIZE];
glGetShaderInfoLog(m_pixelShader, LOG_SIZE, nullptr, log);
m_lastLog = log;
m_compiled = true;
}
return m_compiled;
}
GLuint Handle() override { return m_pixelShader; }
protected:
GLuint m_pixelShader = 0;
};
//------------------------------------------------------------------------
//========================================================================
/// CShaderProgram
class ATTRIBUTE_HIDDEN CShaderProgram
{
public:
CShaderProgram() = default;
CShaderProgram(const std::string &vert, const std::string &frag)
{
LoadShaderFiles(vert, frag);
}
virtual ~CShaderProgram()
{
ShaderFree();
}
bool LoadShaderFiles(const std::string &vert, const std::string &frag)
{
if (!kodi::vfs::FileExists(vert) || !m_pVP.LoadSource(vert))
{
kodi::Log(ADDON_LOG_ERROR, "%s: Failed to load '%s'", __func__, vert.c_str());
return false;
}
if (!kodi::vfs::FileExists(frag) || !m_pFP.LoadSource(frag))
{
kodi::Log(ADDON_LOG_ERROR, "%s: Failed to load '%s'", __func__, frag.c_str());
return false;
}
return true;
}
bool CompileAndLink(const std::string& vertexExtraBegin = "",
const std::string& vertexExtraEnd = "",
const std::string& fragmentExtraBegin = "",
const std::string& fragmentExtraEnd = "")
{
GLint params[4];
// free resources
ShaderFree();
m_ok = false;
// compiled vertex shader
if (!m_pVP.Compile(vertexExtraBegin, vertexExtraEnd))
{
kodi::Log(ADDON_LOG_ERROR, "GL: Error compiling vertex shader");
return false;
}
// compile pixel shader
if (!m_pFP.Compile(fragmentExtraBegin, fragmentExtraEnd))
{
m_pVP.Free();
kodi::Log(ADDON_LOG_ERROR, "GL: Error compiling fragment shader");
return false;
}
// create program object
if (!(m_shaderProgram = glCreateProgram()))
{
kodi::Log(ADDON_LOG_ERROR, "CShaderProgram::%s: Failed to create GL program", __FUNCTION__);
ShaderFree();
return false;
}
// attach the vertex shader
glAttachShader(m_shaderProgram, m_pVP.Handle());
glAttachShader(m_shaderProgram, m_pFP.Handle());
// link the program
glLinkProgram(m_shaderProgram);
glGetProgramiv(m_shaderProgram, GL_LINK_STATUS, params);
if (params[0] != GL_TRUE)
{
GLchar log[LOG_SIZE];
glGetProgramInfoLog(m_shaderProgram, LOG_SIZE, nullptr, log);
kodi::Log(ADDON_LOG_ERROR, "CShaderProgram::%s: %s", __FUNCTION__, log);
fprintf(stderr, "CShaderProgram::%s: %s\n", __FUNCTION__, log);
ShaderFree();
return false;
}
m_validated = false;
m_ok = true;
OnCompiledAndLinked();
return true;
}
bool EnableShader()
{
if (ShaderOK())
{
glUseProgram(m_shaderProgram);
if (OnEnabled())
{
if (!m_validated)
{
// validate the program
GLint params[4];
glValidateProgram(m_shaderProgram);
glGetProgramiv(m_shaderProgram, GL_VALIDATE_STATUS, params);
if (params[0] != GL_TRUE)
{
GLchar log[LOG_SIZE];
glGetProgramInfoLog(m_shaderProgram, LOG_SIZE, nullptr, log);
kodi::Log(ADDON_LOG_ERROR, "CShaderProgram::%s: %s", __FUNCTION__, log);
fprintf(stderr, "CShaderProgram::%s: %s\n", __FUNCTION__, log);
}
m_validated = true;
}
return true;
}
else
{
glUseProgram(0);
return false;
}
return true;
}
return false;
}
void DisableShader()
{
if (ShaderOK())
{
glUseProgram(0);
OnDisabled();
}
}
ATTRIBUTE_FORCEINLINE bool ShaderOK() { return m_ok; }
ATTRIBUTE_FORCEINLINE CVertexShader& VertexShader() { return m_pVP; }
ATTRIBUTE_FORCEINLINE CPixelShader& PixelShader() { return m_pFP; }
ATTRIBUTE_FORCEINLINE GLuint ProgramHandle() { return m_shaderProgram; }
virtual void OnCompiledAndLinked() {};
virtual bool OnEnabled() { return false; };
virtual void OnDisabled() {};
private:
void ShaderFree()
{
if (m_shaderProgram)
glDeleteProgram(m_shaderProgram);
m_shaderProgram = 0;
m_ok = false;
}
CVertexShader m_pVP;
CPixelShader m_pFP;
GLuint m_shaderProgram = 0;
bool m_ok = false;
bool m_validated = false;
};
//------------------------------------------------------------------------
} /* namespace gl */
} /* namespace gui */
} /* namespace kodi */
visualization.spectrum-3.0.3-Leia/src/ 0000775 0000000 0000000 00000000000 13615262311 0017716 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/src/DefaultPixelShader.hlsl 0000664 0000000 0000000 00000001444 13615262311 0024322 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2005-2020 Team Kodi
* http://kodi.tv
*
* 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, 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 Kodi; see the file COPYING. If not, see
* .
*
*/
float4 main(float4 pos: SV_POSITION, float4 col : COLOR) : SV_TARGET
{
return col;
} visualization.spectrum-3.0.3-Leia/src/DefaultVertexShader.hlsl 0000664 0000000 0000000 00000002130 13615262311 0024507 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2005-2020 Team Kodi
* http://kodi.tv
*
* 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, 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 Kodi; see the file COPYING. If not, see
* .
*
*/
struct VS_OUT
{
float4 pos : SV_POSITION;
float4 col : COLOR;
};
cbuffer cbViewProj : register(b0)
{
float4x4 view;
float4x4 proj;
};
cbuffer cbWorld : register(b1)
{
float4x4 world;
};
VS_OUT main(float4 pos : POSITION, float4 col : COLOR)
{
VS_OUT r = (VS_OUT)0;
r.pos = mul( pos, world);
r.pos = mul(r.pos, view);
r.pos = mul(r.pos, proj);
r.col = col;
return r;
} visualization.spectrum-3.0.3-Leia/src/directx_spectrum.cpp 0000664 0000000 0000000 00000043655 13615262311 0024023 0 ustar 00root root 0000000 0000000 /*
* XMMS - Cross-platform multimedia player
* Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies
* Copyright (C) 2005-2020 Team Kodi
* http://kodi.tv
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* Wed May 24 10:49:37 CDT 2000
* Fixes to threading/context creation for the nVidia X4 drivers by
* Christian Zander
*/
/*
* Ported to XBMC by d4rk
* Also added 'm_hSpeed' to animate transition between bar heights
*/
#include
#include
#include
#include
#include
#include
#define NUM_BANDS 16
#define NUM_VERTICIES 36
using namespace DirectX;
using namespace DirectX::PackedVector;
// Include the precompiled shader code.
namespace
{
#include "DefaultPixelShader.inc"
#include "DefaultVertexShader.inc"
}
typedef struct
{
XMFLOAT3 pos;
XMFLOAT4 col;
} Vertex_t;
typedef struct
{
XMFLOAT4X4 view;
XMFLOAT4X4 proj;
} cbViewProj;
typedef struct
{
XMFLOAT4X4 world;
} cbWorld;
#define VERTEX_FORMAT (D3DFVF_XYZ | D3DFVF_DIFFUSE)
class CVisualizationSpectrum
: public kodi::addon::CAddonBase,
public kodi::addon::CInstanceVisualization
{
public:
CVisualizationSpectrum();
~CVisualizationSpectrum() override;
bool Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName) override;
void Render() override;
void AudioData(const float* audioData, int audioDataLength, float *freqData, int freqDataLength) override;
ADDON_STATUS SetSetting(const std::string& settingName, const kodi::CSettingValue& settingValue) override;
private:
void SetBarHeightSetting(int settingValue);
void SetSpeedSetting(int settingValue);
void SetModeSetting(int settingValue);
float heights[16][16], cHeights[16][16], m_scale;
DWORD m_mode; // D3DFILL_SOLID;
float m_y_angle, m_y_speed, m_y_fixedAngle;
float m_x_angle, m_x_speed;
float m_z_angle, m_z_speed;
float m_hSpeed;
void draw_vertex(Vertex_t * pVertex, float x, float y, float z, XMFLOAT4 color);
int draw_rectangle(Vertex_t * verts, float x1, float y1, float z1, float x2, float y2, float z2, XMFLOAT4 color);
void draw_bar(float x_offset, float z_offset, float height, float red, float green, float blue);
void draw_bars(void);
bool init_renderer_objs();
ID3D11Device* m_device = nullptr;
ID3D11DeviceContext* m_context = nullptr;
ID3D11VertexShader* m_vShader = nullptr;
ID3D11PixelShader* m_pShader = nullptr;
ID3D11InputLayout* m_inputLayout = nullptr;
ID3D11Buffer* m_vBuffer = nullptr;
ID3D11Buffer* m_cViewProj = nullptr;
ID3D11Buffer* m_cWorld = nullptr;
ID3D11RasterizerState* m_rsStateSolid = nullptr;
ID3D11RasterizerState* m_rsStateWire = nullptr;
ID3D11BlendState* m_omBlend = nullptr;
ID3D11DepthStencilState* m_omDepth = nullptr;
};
//-- Create -------------------------------------------------------------------
// Called on load. Addon should fully initalize or return error status
// !!! Add-on master function !!!
//-----------------------------------------------------------------------------
CVisualizationSpectrum::CVisualizationSpectrum()
: m_mode(3),
m_y_angle(45.0f),
m_y_speed(0.5f),
m_x_angle(20.0f),
m_x_speed(0.0f),
m_z_angle(0.0f),
m_z_speed(0.0f),
m_hSpeed(0.05f)
{
m_context = (ID3D11DeviceContext*)Device();
m_context->GetDevice(&m_device);
SetBarHeightSetting(kodi::GetSettingInt("bar_height"));
SetSpeedSetting(kodi::GetSettingInt("speed"));
SetModeSetting(kodi::GetSettingInt("mode"));
m_y_fixedAngle = kodi::GetSettingInt("rotation_angle");
if (!init_renderer_objs())
kodi::Log(ADDON_LOG_ERROR, "Failed to init DirectX");
}
//-- Destroy ------------------------------------------------------------------
// Do everything before unload of this add-on
// !!! Add-on master function !!!
//-----------------------------------------------------------------------------
CVisualizationSpectrum::~CVisualizationSpectrum()
{
if (m_cViewProj)
m_cViewProj->Release();
if (m_cWorld)
m_cWorld->Release();
if (m_rsStateSolid)
m_rsStateSolid->Release();
if (m_rsStateWire)
m_rsStateWire->Release();
if (m_omBlend)
m_omBlend->Release();
if (m_omDepth)
m_omDepth->Release();
if (m_vBuffer)
m_vBuffer->Release();
if (m_inputLayout)
m_inputLayout->Release();
if (m_vShader)
m_vShader->Release();
if (m_pShader)
m_pShader->Release();
if (m_device)
m_device->Release();
}
//-- Render -------------------------------------------------------------------
// Called once per frame. Do all rendering here.
//-----------------------------------------------------------------------------
void CVisualizationSpectrum::Render()
{
bool configured = true; //FALSE;
float factors[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
m_context->OMSetBlendState(m_omBlend, factors, 0xFFFFFFFF);
m_context->OMSetDepthStencilState(m_omDepth, 0);
switch (m_mode)
{
case 1: // D3DFILL_POINT:
case 2: // D3DFILL_WIREFRAME:
m_context->RSSetState(m_rsStateWire);
break;
case 3: // D3DFILL_SOLID:
m_context->RSSetState(m_rsStateSolid);
break;
}
unsigned stride = sizeof(Vertex_t), offset = 0;
m_context->IASetVertexBuffers(0, 1, &m_vBuffer, &stride, &offset);
m_context->IASetInputLayout(m_inputLayout);
m_context->VSSetShader(m_vShader, 0, 0);
m_context->VSSetConstantBuffers(0, 1, &m_cViewProj);
m_context->VSSetConstantBuffers(1, 1, &m_cWorld);
m_context->PSSetShader(m_pShader, 0, 0);
if(configured)
{
m_x_angle += m_x_speed;
if (m_x_angle >= 360.0f)
m_x_angle -= 360.0f;
if (m_y_fixedAngle < 0.0f)
{
m_y_angle += m_y_speed;
if(m_y_angle >= 360.0)
m_y_angle -= 360.0;
}
else
{
m_y_angle = m_y_fixedAngle;
}
m_z_angle += m_z_speed;
if (m_z_angle >= 360.0f)
m_z_angle -= 360.0f;
D3D11_MAPPED_SUBRESOURCE res;
if (S_OK == m_context->Map(m_cWorld, 0, D3D11_MAP_WRITE_DISCARD, 0, &res))
{
cbWorld *cWorld = (cbWorld*)res.pData;
XMMATRIX
matRotationX = XMMatrixRotationX(-XMConvertToRadians(m_x_angle)),
matRotationY = XMMatrixRotationY(-XMConvertToRadians(m_y_angle)),
matRotationZ = XMMatrixRotationZ(XMConvertToRadians(m_z_angle)),
matTranslation = XMMatrixTranslation(0.0f, -0.5f, 5.0f),
matWorld = matRotationZ * matRotationY * matRotationX * matTranslation;
XMStoreFloat4x4(&cWorld->world, XMMatrixTranspose(matWorld));
m_context->Unmap(m_cWorld, 0);
}
draw_bars();
}
}
bool CVisualizationSpectrum::Start(int iChannels, int iSamplesPerSec, int iBitsPerSample, std::string szSongName)
{
int x, y;
for(x = 0; x < 16; x++)
{
for(y = 0; y < 16; y++)
{
cHeights[y][x] = 0.0f;
}
}
m_scale = 1.0f / log(256.0f);
m_x_speed = 0.0f;
m_y_speed = 0.5f;
m_z_speed = 0.0f;
m_x_angle = 20.0f;
m_y_angle = 45.0f;
m_z_angle = 0.0f;
return true;
}
void CVisualizationSpectrum::AudioData(const float* pAudioData, int iAudioDataLength, float *pFreqData, int iFreqDataLength)
{
int i,c;
int y=0;
float val;
int xscale[] = {0, 1, 2, 3, 5, 7, 10, 14, 20, 28, 40, 54, 74, 101, 137, 187, 255};
for(y = 15; y > 0; y--)
{
for(i = 0; i < 16; i++)
{
heights[y][i] = heights[y - 1][i];
}
}
for(i = 0; i < NUM_BANDS; i++)
{
for(c = xscale[i], y = 0; c < xscale[i + 1]; c++)
{
if (c y))
y = (int)(pAudioData[c] * (0x07fff+.5f));
}
else
continue;
}
y >>= 7;
if(y > 0)
val = (logf((float)y) * m_scale);
else
val = 0;
heights[0][i] = val;
}
}
void CVisualizationSpectrum::SetBarHeightSetting(int settingValue)
{
switch (settingValue)
{
case 1://standard
m_scale = 1.f / log(256.f);
break;
case 2://big
m_scale = 2.f / log(256.f);
break;
case 3://real big
m_scale = 3.f / log(256.f);
break;
case 4://unused
m_scale = 0.33f / log(256.f);
break;
case 0://small
default:
m_scale = 0.5f / log(256.f);
break;
}
}
void CVisualizationSpectrum::SetSpeedSetting(int settingValue)
{
switch (settingValue)
{
case 1:
m_hSpeed = 0.025f;
break;
case 2:
m_hSpeed = 0.0125f;
break;
case 3:
m_hSpeed = 0.1f;
break;
case 4:
m_hSpeed = 0.2f;
break;
case 0:
default:
m_hSpeed = 0.05f;
break;
}
}
void CVisualizationSpectrum::SetModeSetting(int settingValue)
{
switch (settingValue)
{
case 1:
m_mode = 2; // D3DFILL_WIREFRAME;
break;
case 2:
m_mode = 1; // D3DFILL_POINT;
break;
case 0:
default:
m_mode = 3; // D3DFILL_SOLID;
break;
}
}
//-- SetSetting ---------------------------------------------------------------
// Set a specific Setting value (called from XBMC)
// !!! Add-on master function !!!
//-----------------------------------------------------------------------------
ADDON_STATUS CVisualizationSpectrum::SetSetting(const std::string& settingName, const kodi::CSettingValue& settingValue)
{
if (settingName.empty() || settingValue.empty())
return ADDON_STATUS_UNKNOWN;
if (settingName == "bar_height")
{
SetBarHeightSetting(settingValue.GetInt());
return ADDON_STATUS_OK;
}
else if (settingName == "speed")
{
SetSpeedSetting(settingValue.GetInt());
return ADDON_STATUS_OK;
}
else if (settingName == "mode")
{
SetModeSetting(settingValue.GetInt());
return ADDON_STATUS_OK;
}
else if (settingName == "rotation_angle")
{
m_y_fixedAngle = settingValue.GetInt();
return ADDON_STATUS_OK;
}
return ADDON_STATUS_UNKNOWN;
}
void CVisualizationSpectrum::draw_vertex(Vertex_t * pVertex, float x, float y, float z, XMFLOAT4 color)
{
pVertex->col = XMFLOAT4(color);
pVertex->pos = XMFLOAT3(x, y, z);
}
int CVisualizationSpectrum::draw_rectangle(Vertex_t * verts, float x1, float y1, float z1, float x2, float y2, float z2, XMFLOAT4 color)
{
if(y1 == y2)
{
draw_vertex(&verts[0], x1, y1, z1, color);
draw_vertex(&verts[1], x2, y1, z1, color);
draw_vertex(&verts[2], x2, y2, z2, color);
draw_vertex(&verts[3], x2, y2, z2, color);
draw_vertex(&verts[4], x1, y2, z2, color);
draw_vertex(&verts[5], x1, y1, z1, color);
}
else
{
draw_vertex(&verts[0], x1, y1, z1, color);
draw_vertex(&verts[1], x2, y1, z2, color);
draw_vertex(&verts[2], x2, y2, z2, color);
draw_vertex(&verts[3], x2, y2, z2, color);
draw_vertex(&verts[4], x1, y2, z1, color);
draw_vertex(&verts[5], x1, y1, z1, color);
}
return 6;
}
void CVisualizationSpectrum::draw_bar(float x_offset, float z_offset, float height, float red, float green, float blue)
{
Vertex_t verts[NUM_VERTICIES];
int verts_idx = 0;
float width = 0.1f;
XMFLOAT4 color;
if (1 == m_mode /*== D3DFILL_POINT*/)
color = XMFLOAT4(0.2f, 1.0f, 0.2f, 1.0f);
if (1 != m_mode /*!= D3DFILL_POINT*/)
{
color = XMFLOAT4(red, green, blue, 1.0f);
verts_idx += draw_rectangle(&verts[verts_idx], x_offset, height, z_offset, x_offset + width, height, z_offset + 0.1f, color);
}
verts_idx += draw_rectangle(&verts[verts_idx], x_offset, 0.0f, z_offset, x_offset + width, 0.0f, z_offset + 0.1f, color);
if (1 != m_mode /*!= D3DFILL_POINT*/)
{
color = XMFLOAT4(0.5f * red, 0.5f * green, 0.5f * blue, 1.0f);
verts_idx += draw_rectangle(&verts[verts_idx], x_offset, 0.0f, z_offset + 0.1f, x_offset + width, height, z_offset + 0.1f, color);
}
verts_idx += draw_rectangle(&verts[verts_idx], x_offset, 0.0f, z_offset, x_offset + width, height, z_offset, color);
if (1 != m_mode /*!= D3DFILL_POINT*/)
{
color = XMFLOAT4(0.25f * red, 0.25f * green, 0.25f * blue, 1.0f);
verts_idx += draw_rectangle(&verts[verts_idx], x_offset, 0.0f, z_offset , x_offset, height, z_offset + 0.1f, color);
}
verts_idx += draw_rectangle(&verts[verts_idx], x_offset + width, 0.0f, z_offset , x_offset + width, height, z_offset + 0.1f, color);
D3D11_MAPPED_SUBRESOURCE res;
if (S_OK == m_context->Map(m_vBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &res))
{
memcpy(res.pData, verts, sizeof(Vertex_t) * NUM_VERTICIES);
m_context->Unmap(m_vBuffer, 0);
}
m_context->IASetPrimitiveTopology(m_mode != 1 /*D3DFILL_POINT*/ ? D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST : D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
m_context->Draw(verts_idx, 0);
}
void CVisualizationSpectrum::draw_bars(void)
{
int x,y;
float x_offset, z_offset, r_base, b_base;
for(y = 0; y < 16; y++)
{
z_offset = -1.6f + ((15 - y) * 0.2f);
b_base = y * (1.0f / 15);
r_base = 1.0f - b_base;
for(x = 0; x < 16; x++)
{
x_offset = -1.6f + (x * 0.2f);
if (::fabs(cHeights[y][x]-heights[y][x])>m_hSpeed)
{
if (cHeights[y][x]CreateVertexShader(DefaultVertexShaderCode, sizeof(DefaultVertexShaderCode), nullptr, &m_vShader))
return false;
// Create input layout
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
if (S_OK != m_device->CreateInputLayout(layout, ARRAYSIZE(layout), DefaultVertexShaderCode, sizeof(DefaultVertexShaderCode), &m_inputLayout))
return false;
// Create pixel shader
if (S_OK != m_device->CreatePixelShader(DefaultPixelShaderCode, sizeof(DefaultPixelShaderCode), nullptr, &m_pShader))
return false;
// create buffers
CD3D11_BUFFER_DESC desc(sizeof(Vertex_t) * NUM_VERTICIES, D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
if (S_OK != m_device->CreateBuffer(&desc, NULL, &m_vBuffer))
return false;
desc.ByteWidth = sizeof(cbWorld);
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
if (S_OK != m_device->CreateBuffer(&desc, NULL, &m_cWorld))
return false;
cbViewProj cViewProj;
XMStoreFloat4x4(&cViewProj.view, XMMatrixTranspose(XMMatrixIdentity()));
XMStoreFloat4x4(&cViewProj.proj, XMMatrixTranspose(XMMatrixPerspectiveOffCenterLH(-1.0f, 1.0f, -1.0f, 1.0f, 1.5f, 10.0f)));
desc.ByteWidth = sizeof(cbViewProj);
desc.Usage = D3D11_USAGE_DEFAULT;
desc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA initData = { 0 };
initData.pSysMem = &cViewProj;
if (S_OK != m_device->CreateBuffer(&desc, &initData, &m_cViewProj))
return false;
// create blend state
D3D11_BLEND_DESC blendState = { 0 };
ZeroMemory(&blendState, sizeof(D3D11_BLEND_DESC));
blendState.RenderTarget[0].BlendEnable = true;
blendState.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendState.RenderTarget[0].DestBlend = D3D11_BLEND_ZERO;
blendState.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendState.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendState.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendState.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendState.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
if (S_OK != m_device->CreateBlendState(&blendState, &m_omBlend))
return false;
// create depth state
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
ZeroMemory(&depthStencilDesc, sizeof(D3D11_DEPTH_STENCIL_DESC));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
if (S_OK != m_device->CreateDepthStencilState(&depthStencilDesc, &m_omDepth))
return false;
// create raster states
D3D11_RASTERIZER_DESC rasterizerState;
rasterizerState.CullMode = D3D11_CULL_NONE;
rasterizerState.FillMode = D3D11_FILL_SOLID;
rasterizerState.FrontCounterClockwise = false;
rasterizerState.DepthBias = 0;
rasterizerState.DepthBiasClamp = 0.0f;
rasterizerState.DepthClipEnable = true;
rasterizerState.SlopeScaledDepthBias = 0.0f;
rasterizerState.ScissorEnable = false;
rasterizerState.MultisampleEnable = false;
rasterizerState.AntialiasedLineEnable = false;
if (S_OK != m_device->CreateRasterizerState(&rasterizerState, &m_rsStateSolid))
return false;
rasterizerState.FillMode = D3D11_FILL_WIREFRAME;
if (S_OK != m_device->CreateRasterizerState(&rasterizerState, &m_rsStateWire))
return false;
// we are ready
return true;
}
ADDONCREATOR(CVisualizationSpectrum)
visualization.spectrum-3.0.3-Leia/src/opengl_spectrum.cpp 0000664 0000000 0000000 00000040717 13615262311 0023641 0 ustar 00root root 0000000 0000000 /*
* XMMS - Cross-platform multimedia player
* Copyright (C) 1998-2000 Peter Alm, Mikael Alm, Olle Hallnas, Thomas Nilsson and 4Front Technologies
* Copyright (C) 2005-2020 Team Kodi
* http://kodi.tv
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* Wed May 24 10:49:37 CDT 2000
* Fixes to threading/context creation for the nVidia X4 drivers by
* Christian Zander
*/
/*
* Ported to XBMC by d4rk
* Also added 'm_hSpeed' to animate transition between bar heights
*
* Ported to GLES 2.0 by Gimli
*/
#define __STDC_LIMIT_MACROS
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef M_PI
#define M_PI 3.141592654f
#endif
#define NUM_BANDS 16
class ATTRIBUTE_HIDDEN CVisualizationSpectrum
: public kodi::addon::CAddonBase,
public kodi::addon::CInstanceVisualization,
public kodi::gui::gl::CShaderProgram
{
public:
CVisualizationSpectrum();
~CVisualizationSpectrum() override = default;
bool Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName) override;
void Stop() override;
void Render() override;
void AudioData(const float* audioData, int audioDataLength, float* freqData, int freqDataLength) override;
ADDON_STATUS SetSetting(const std::string& settingName, const kodi::CSettingValue& settingValue) override;
void OnCompiledAndLinked() override;
bool OnEnabled() override;
private:
void SetBarHeightSetting(int settingValue);
void SetSpeedSetting(int settingValue);
void SetModeSetting(int settingValue);
GLfloat m_heights[16][16];
GLfloat m_cHeights[16][16];
GLfloat m_scale;
GLenum m_mode;
float m_y_angle, m_y_speed, m_y_fixedAngle;
float m_x_angle, m_x_speed;
float m_z_angle, m_z_speed;
float m_hSpeed;
void draw_bar(GLfloat x_offset, GLfloat z_offset, GLfloat height, GLfloat red, GLfloat green, GLfloat blue);
void draw_bars(void);
// Shader related data
glm::mat4 m_projMat;
glm::mat4 m_modelMat;
GLfloat m_pointSize = 0.0f;
std::vector m_vertex_buffer_data;
std::vector m_color_buffer_data;
#ifdef HAS_GL
GLuint m_vertexVBO[2] = {0};
#endif
GLint m_uProjMatrix = -1;
GLint m_uModelMatrix = -1;
GLint m_uPointSize = -1;
GLint m_hPos = -1;
GLint m_hCol = -1;
bool m_startOK = false;
};
CVisualizationSpectrum::CVisualizationSpectrum()
: m_mode(GL_TRIANGLES),
m_y_angle(45.0f),
m_y_speed(0.5f),
m_x_angle(20.0f),
m_x_speed(0.0f),
m_z_angle(0.0f),
m_z_speed(0.0f),
m_hSpeed(0.05f)
{
m_scale = 1.0 / log(256.0);
SetBarHeightSetting(kodi::GetSettingInt("bar_height"));
SetSpeedSetting(kodi::GetSettingInt("speed"));
SetModeSetting(kodi::GetSettingInt("mode"));
m_y_fixedAngle = kodi::GetSettingInt("rotation_angle");
m_vertex_buffer_data.resize(48);
m_color_buffer_data.resize(48);
}
bool CVisualizationSpectrum::Start(int channels, int samplesPerSec, int bitsPerSample, std::string songName)
{
(void)channels;
(void)samplesPerSec;
(void)bitsPerSample;
(void)songName;
std::string fraqShader = kodi::GetAddonPath("resources/shaders/" GL_TYPE_STRING "/frag.glsl");
std::string vertShader = kodi::GetAddonPath("resources/shaders/" GL_TYPE_STRING "/vert.glsl");
if (!LoadShaderFiles(vertShader, fraqShader) || !CompileAndLink())
{
kodi::Log(ADDON_LOG_ERROR, "Failed to create or compile shader");
return false;
}
int x, y;
for(x = 0; x < 16; x++)
{
for(y = 0; y < 16; y++)
{
m_cHeights[y][x] = 0.0;
}
}
m_x_speed = 0.0;
m_y_speed = 0.5;
m_z_speed = 0.0;
m_x_angle = 20.0;
m_y_angle = 45.0;
m_z_angle = 0.0;
m_projMat = glm::frustum(-1.0f, 1.0f, -1.0f, 1.0f, 1.5f, 10.0f);
#ifdef HAS_GL
glGenBuffers(2, m_vertexVBO);
#endif
m_startOK = true;
return true;
}
void CVisualizationSpectrum::Stop()
{
if (!m_startOK)
return;
m_startOK = false;
#ifdef HAS_GL
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(2, m_vertexVBO);
m_vertexVBO[0] = 0;
m_vertexVBO[1] = 0;
#endif
}
//-- Render -------------------------------------------------------------------
// Called once per frame. Do all rendering here.
//-----------------------------------------------------------------------------
void CVisualizationSpectrum::Render()
{
if (!m_startOK)
return;
#ifdef HAS_GL
glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO[0]);
glVertexAttribPointer(m_hPos, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*3, nullptr);
glEnableVertexAttribArray(m_hPos);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO[1]);
glVertexAttribPointer(m_hCol, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*3, nullptr);
glEnableVertexAttribArray(m_hCol);
#else
// 1rst attribute buffer : vertices
glEnableVertexAttribArray(m_hPos);
glVertexAttribPointer(m_hPos, 3, GL_FLOAT, GL_FALSE, 0, &m_vertex_buffer_data[0]);
// 2nd attribute buffer : colors
glEnableVertexAttribArray(m_hCol);
glVertexAttribPointer(m_hCol, 3, GL_FLOAT, GL_FALSE, 0, &m_color_buffer_data[0]);
#endif
glDisable(GL_BLEND);
#ifdef HAS_GL
glEnable(GL_PROGRAM_POINT_SIZE);
#endif
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
// Clear the screen
glClear(GL_DEPTH_BUFFER_BIT);
m_x_angle += m_x_speed;
if(m_x_angle >= 360.0)
m_x_angle -= 360.0;
if (m_y_fixedAngle < 0.0f)
{
m_y_angle += m_y_speed;
if(m_y_angle >= 360.0)
m_y_angle -= 360.0;
}
else
{
m_y_angle = m_y_fixedAngle;
}
m_z_angle += m_z_speed;
if(m_z_angle >= 360.0)
m_z_angle -= 360.0;
m_modelMat = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, -0.5f, -5.0f));
m_modelMat = glm::rotate(m_modelMat, glm::radians(m_x_angle), glm::vec3(1.0f, 0.0f, 0.0f));
m_modelMat = glm::rotate(m_modelMat, glm::radians(m_y_angle), glm::vec3(0.0f, 1.0f, 0.0f));
m_modelMat = glm::rotate(m_modelMat, glm::radians(m_z_angle), glm::vec3(0.0f, 0.0f, 1.0f));
EnableShader();
draw_bars();
DisableShader();
glDisableVertexAttribArray(m_hPos);
glDisableVertexAttribArray(m_hCol);
glDisable(GL_DEPTH_TEST);
#ifdef HAS_GL
glDisable(GL_PROGRAM_POINT_SIZE);
#endif
glEnable(GL_BLEND);
}
void CVisualizationSpectrum::OnCompiledAndLinked()
{
// Variables passed directly to the Vertex shader
m_uProjMatrix = glGetUniformLocation(ProgramHandle(), "u_projectionMatrix");
m_uModelMatrix = glGetUniformLocation(ProgramHandle(), "u_modelViewMatrix");
m_uPointSize = glGetUniformLocation(ProgramHandle(), "u_pointSize");
m_hPos = glGetAttribLocation(ProgramHandle(), "a_position");
m_hCol = glGetAttribLocation(ProgramHandle(), "a_color");
}
bool CVisualizationSpectrum::OnEnabled()
{
// This is called after glUseProgram()
glUniformMatrix4fv(m_uProjMatrix, 1, GL_FALSE, glm::value_ptr(m_projMat));
glUniformMatrix4fv(m_uModelMatrix, 1, GL_FALSE, glm::value_ptr(m_modelMat));
glUniform1f(m_uPointSize, m_pointSize);
return true;
}
void CVisualizationSpectrum::draw_bar(GLfloat x_offset, GLfloat z_offset, GLfloat height, GLfloat red, GLfloat green, GLfloat blue )
{
GLfloat width = 0.1f;
m_vertex_buffer_data =
{
// Bottom
{ x_offset + width, 0.0f, z_offset + width },
{ x_offset, 0.0f, z_offset },
{ x_offset + width, 0.0f, z_offset },
{ x_offset + width, 0.0f, z_offset + width },
{ x_offset, 0.0f, z_offset + width },
{ x_offset, 0.0f, z_offset },
{ x_offset, 0.0f, z_offset + width },
{ x_offset + width, 0.0f, z_offset },
{ x_offset + width, 0.0f, z_offset + width },
{ x_offset, 0.0f, z_offset + width },
{ x_offset + width, 0.0f, z_offset },
{ x_offset, 0.0f, z_offset },
// Side
{ x_offset, 0.0f, z_offset },
{ x_offset, 0.0f, z_offset + width },
{ x_offset, height, z_offset + width },
{ x_offset, 0.0f, z_offset },
{ x_offset, height, z_offset + width },
{ x_offset, height, z_offset },
{ x_offset + width, height, z_offset },
{ x_offset, 0.0f, z_offset },
{ x_offset, height, z_offset },
{ x_offset + width, height, z_offset },
{ x_offset + width, 0.0f, z_offset },
{ x_offset, 0.0f, z_offset },
{ x_offset, height, z_offset + width },
{ x_offset, 0.0f, z_offset + width },
{ x_offset + width, 0.0f, z_offset + width },
{ x_offset + width, height, z_offset + width },
{ x_offset, height, z_offset + width },
{ x_offset + width, 0.0f, z_offset + width },
{ x_offset + width, height, z_offset + width },
{ x_offset + width, 0.0f, z_offset },
{ x_offset + width, height, z_offset },
{ x_offset + width, 0.0f, z_offset },
{ x_offset + width, height, z_offset + width },
{ x_offset + width, 0.0f, z_offset + width },
// Top
{ x_offset + width, height, z_offset + width },
{ x_offset + width, height, z_offset },
{ x_offset, height, z_offset },
{ x_offset + width, height, z_offset + width },
{ x_offset, height, z_offset },
{ x_offset, height, z_offset + width },
{ x_offset, height, z_offset + width },
{ x_offset + width, height, z_offset },
{ x_offset, height, z_offset },
{ x_offset + width, height, z_offset },
{ x_offset + width, height, z_offset + width },
{ x_offset, height, z_offset + width }
};
float sideMlpy1, sideMlpy2, sideMlpy3, sideMlpy4;
if (m_mode == GL_TRIANGLES)
{
sideMlpy1 = 0.5f;
sideMlpy2 = 0.25f;
sideMlpy3 = 0.75f;
sideMlpy4 = 0.5f;
}
else
{
sideMlpy1 = sideMlpy2 = sideMlpy3 = sideMlpy4 = 1.0f;
}
// One color for each vertex. They were generated randomly.
m_color_buffer_data =
{
// Bottom
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
// Side
{ red * sideMlpy1, green * sideMlpy1, blue * sideMlpy1 },
{ red * sideMlpy1, green * sideMlpy1, blue * sideMlpy1 },
{ red * sideMlpy1, green * sideMlpy1, blue * sideMlpy1 },
{ red * sideMlpy1, green * sideMlpy1, blue * sideMlpy1 },
{ red * sideMlpy1, green * sideMlpy1, blue * sideMlpy1 },
{ red * sideMlpy1, green * sideMlpy1, blue * sideMlpy1 },
{ red * sideMlpy2, green * sideMlpy2, blue * sideMlpy2 },
{ red * sideMlpy2, green * sideMlpy2, blue * sideMlpy2 },
{ red * sideMlpy2, green * sideMlpy2, blue * sideMlpy2 },
{ red * sideMlpy2, green * sideMlpy2, blue * sideMlpy2 },
{ red * sideMlpy2, green * sideMlpy2, blue * sideMlpy2 },
{ red * sideMlpy2, green * sideMlpy2, blue * sideMlpy2 },
{ red * sideMlpy3, green * sideMlpy3, blue * sideMlpy3 },
{ red * sideMlpy3, green * sideMlpy3, blue * sideMlpy3 },
{ red * sideMlpy3, green * sideMlpy3, blue * sideMlpy3 },
{ red * sideMlpy3, green * sideMlpy3, blue * sideMlpy3 },
{ red * sideMlpy3, green * sideMlpy3, blue * sideMlpy3 },
{ red * sideMlpy3, green * sideMlpy3, blue * sideMlpy3 },
{ red * sideMlpy4, green * sideMlpy4, blue * sideMlpy4 },
{ red * sideMlpy4, green * sideMlpy4, blue * sideMlpy4 },
{ red * sideMlpy4, green * sideMlpy4, blue * sideMlpy4 },
{ red * sideMlpy4, green * sideMlpy4, blue * sideMlpy4 },
{ red * sideMlpy4, green * sideMlpy4, blue * sideMlpy4 },
{ red * sideMlpy4, green * sideMlpy4, blue * sideMlpy4 },
// Top
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
{ red, green, blue },
};
#ifdef HAS_GL
glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO[0]);
glBufferData(GL_ARRAY_BUFFER, m_vertex_buffer_data.size()*sizeof(glm::vec3), &m_vertex_buffer_data[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO[1]);
glBufferData(GL_ARRAY_BUFFER, m_color_buffer_data.size()*sizeof(glm::vec3), &m_color_buffer_data[0], GL_STATIC_DRAW);
#endif
glDrawArrays(m_mode, 0, m_vertex_buffer_data.size()); /* 12*3 indices starting at 0 -> 12 triangles + 4*3 to have on lines show correct */
}
void CVisualizationSpectrum::draw_bars(void)
{
int x, y;
GLfloat x_offset, z_offset, r_base, b_base;
for(y = 0; y < 16; y++)
{
z_offset = -1.6 + ((15 - y) * 0.2);
b_base = y * (1.0 / 15);
r_base = 1.0 - b_base;
for(x = 0; x < 16; x++)
{
x_offset = -1.6 + ((float)x * 0.2);
if (::fabs(m_cHeights[y][x]-m_heights[y][x])>m_hSpeed)
{
if (m_cHeights[y][x] 0; y--)
{
for(i = 0; i < 16; i++)
{
m_heights[y][i] = m_heights[y - 1][i];
}
}
for(i = 0; i < NUM_BANDS; i++)
{
for(c = xscale[i], y = 0; c < xscale[i + 1]; c++)
{
if (c y)
y = (int)(pAudioData[c] * (INT16_MAX));
}
else
continue;
}
y >>= 7;
if(y > 0)
val = (logf(y) * m_scale);
else
val = 0;
m_heights[0][i] = val;
}
}
void CVisualizationSpectrum::SetBarHeightSetting(int settingValue)
{
switch (settingValue)
{
case 1://standard
m_scale = 1.f / log(256.f);
break;
case 2://big
m_scale = 2.f / log(256.f);
break;
case 3://real big
m_scale = 3.f / log(256.f);
break;
case 4://unused
m_scale = 0.33f / log(256.f);
break;
case 0://small
default:
m_scale = 0.5f / log(256.f);
break;
}
}
void CVisualizationSpectrum::SetSpeedSetting(int settingValue)
{
switch (settingValue)
{
case 1:
m_hSpeed = 0.025f;
break;
case 2:
m_hSpeed = 0.0125f;
break;
case 3:
m_hSpeed = 0.1f;
break;
case 4:
m_hSpeed = 0.2f;
break;
case 0:
default:
m_hSpeed = 0.05f;
break;
}
}
void CVisualizationSpectrum::SetModeSetting(int settingValue)
{
switch (settingValue)
{
case 1:
m_mode = GL_LINES;
m_pointSize = 0.0f;
break;
case 2:
m_mode = GL_POINTS;
m_pointSize = kodi::GetSettingInt("pointsize");
break;
case 0:
default:
m_mode = GL_TRIANGLES;
m_pointSize = 0.0f;
break;
}
}
//-- SetSetting ---------------------------------------------------------------
// Set a specific Setting value (called from Kodi)
// !!! Add-on master function !!!
//-----------------------------------------------------------------------------
ADDON_STATUS CVisualizationSpectrum::SetSetting(const std::string& settingName, const kodi::CSettingValue& settingValue)
{
if (settingName.empty() || settingValue.empty())
return ADDON_STATUS_UNKNOWN;
if (settingName == "bar_height")
{
SetBarHeightSetting(settingValue.GetInt());
return ADDON_STATUS_OK;
}
else if (settingName == "speed")
{
SetSpeedSetting(settingValue.GetInt());
return ADDON_STATUS_OK;
}
else if (settingName == "mode")
{
SetModeSetting(settingValue.GetInt());
return ADDON_STATUS_OK;
}
else if (settingName == "rotation_angle")
{
m_y_fixedAngle = settingValue.GetInt();
return ADDON_STATUS_OK;
}
return ADDON_STATUS_UNKNOWN;
}
ADDONCREATOR(CVisualizationSpectrum)
visualization.spectrum-3.0.3-Leia/visualization.spectrum/ 0000775 0000000 0000000 00000000000 13615262311 0023671 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/visualization.spectrum/addon.xml.in 0000664 0000000 0000000 00000057026 13615262311 0026117 0 ustar 00root root 0000000 0000000
@ADDON_DEPENDS@Visualisering wys a roterende 3D Spektrum Analiseerderعارض يظهر طيف محلل دوري ثلاثي الأبعادVisualisation showing a rotating 3D Spectrum AnalyzerВизуализация представяща ротиращ се 3D спектрален анализаторVisualització mostrant un analitzador d'espectre giratori 3DVizualizace zobrazující rotující 3D spektrální analyzátorVisualisering der viser en roterende 3D-spektrumanalyseDiese Visualisierung zeigt eine rotierende Spektrum Analyse in 3DΟπτικοποίηση που εμφανίζει έναν περιστρεφόμενο τρισδιάστατο Αναλυτή ΦάσματοςVisualisation showing a rotating 3D Spectrum AnalyzerVisualización que muestra un analizador de espectro en 3D girandoVisualización que muestra un analizador de espectro en 3D girandoVisualización que muestra un Analizador de Espectro giratorio 3DVisuaal, mis näitab pöörlevat 3D spektraalanalüüsiPyörivä 3D-spektrianalysaattoriVisualisation affichant un analyseur de spectre 3D en rotationVisualización que amosa un analizador de espectro virando en 3DDirectX Spectrum זהו חיזוי אשר מציג סיבובי 3D Spectrum AnalyzerVizualizacija koja prikazuje rotirajući 3D spektralni analizatorVizualizáció 3D spektrum analizátorralMyndskreyting sem sýnir þrívíddar rófgreiniLa visualizzazione mostra un analizzatore di spettro 3D rotante回転する 3D スペクトラムアナライザーを表示する ビジュアライザー회전하는 3D 스펙트럼 분석기를 보여지는 음악시각화Vizualizacija rodo rotacinis 3D spektro analizatoriųВизуализација која покажува ротирачки 3Д анализатор на спектарDirectX-visualisatie die een roterende 3D-spectrumanalyse weergeeftVisualisering som viser en roterende 3D Spectrum AnalyzerWizualizacja pokazująca obracający się analizator widma w 3DVisualização que mostra um analisador espectral rotativo em 3DVisualização que mostra um analisador espectral rotativo em 3DVizualizare cu afișarea unui analizor de spectru 3D rotativВизуализация, показывающая вращающийся трёхмерный анализатор спектраVizualizácia zobrazujúca rotujúci 3D spektrálny analyzátorVizualizacija, ki prikatuje vrtečo 3D spektralno analizoVisualisering som visar en roterande 3D-spektrumanalysatorการแสดงแสงสี ทำให้เห็นการหมุนแบบ 3 มิติ ของการวิเคราะห์คลื่นความถี่เสียงВізуалізація що показує обертаючийся 3D спектроаналізатор.显示旋转三维频谱分析图像的可视化效果顯示旋轉的3D頻譜分析視覺效果Spectrum is 'n Visualisering wat 'n roterende 3D Spektrum Analiseerder, verbeeld met , vertoon wat op die maat van die musiek beweeg en 'n golf effek oor die spektrum rooster skep.
Dit het ook verstellings vir die aanpas van spektrum staaf hoogte, sy spoed, en hoe die stawe verbeeld word (solied, punte, draad raamwerk) en is 'n lekker ligte, lae cpu verbruik visualisering wat fantasties lykطيف هو تحليل بصري متحرك ثلاثي الابعاد للموسيقى! يتحرك بواسطة يرنامج على وزن الموسيقى في شكل موجة.
توجد ايضا اعدادات لتعديل شبكة الطيف من حيث طول الاعمدة, سرعتها, وحتى شكلها (صلبة, نقاط, اسلاك) تعمل هذة بحمل خفيف, ومعالجة cpu ضئيلة لكنها تبدو رائعةSpectrum is a Visualisation showing a rotating 3D Spectrum Analyzer rendered in that moves to the beat of the music creating a wave effect across the spectrum grid.
It also has settings to adjust the spectrum bar height, Its speed, and how the bars are rendered (solid, points, wire frame) and is a nice light weight, low cpu useage visualisation that looks greatSpectrum е визуализация изобразяваща ротиращ се 3D спектрален анализатор (рендването се извършва с ). Ротацията е според ритъма на музиката и предизвиква вълнови ефект по спектрална решетка.
Можете да настройвате височината на спектралните стълбове, скоростта и рендването - solid, points, wire frame. Характеризира се с отличен вид, като същевременно почти не натоварва процесора.Spectrum és una visualització que mostra un analitzador d'espectre giratori en 3D renderitzat amb que es mou al ritme de la música creant un efecte d'ona al llarg de la graella de l'espectre.⏎ També té opcions per ajustar l'alçada de la barra de l'espectre, la seva velocitat, i com es renderitzen les barres (sòlid, punts, malla de filferro). Una visualització que utilitza poca CPU i que és veu molt bé. Spectrum je vizualizace zobrazující rotující 3D spektrální analyzátor rendrovaný v , který se pohybuje v rytmu hudby a vytváří vlnový efekt napříč spektrální mřížkou.
Obsahuje také nastavení pro přizpůsobení výšky sloupců spektra, rychlosti a způsobu vykreslení (vyplněný, body, drátový model). Je to velmi lehká vizualizace s nízkou zatíží CPU, která vypadá skvěle.-spektrum er en visualisering, der viser en roterende 3D-spektrumanalysator renderet i DirectX, som bevæger sig i takt til musikken og skaber en bølgeeffekt på tværs af spektrumfeltet.
Den har også indstillinger til at justere spektrumliniens højde, fart og hvordan den bliver renderet (fast, punkter, trådramme). Det er en letvægtsvisualisering med lavt CPU-forbrug, som ser godt ud.Spectrum ist eine Visualisierung, die eine rotierende Spektrum Analyse in 3D zeigt. Die Visualisierung wird so gerendert, dass sie sich zum Takt der Musik bewegt und eine Welle über das Spektrum Grid legt.
Es lässt sich neben der Höhe, die Geschwindigkeit als auch die Art der Balken (durchgehend, Punkte, Drahtgeflecht) einstellen. Eine schöne Visualisierung, die nur eine geringe CPU-Last erzeugtΤο Spectrum είναι μία Οπτικοποίηση που εμφανίζει έναν περιστρεφόμενο τρισδιάστατο Αναλυτή Φάσματος που αποδίδεται μέσω και κινείται στο ρυθμό της μουσικής δημιουργώντας ένα κυματικό εφέ κατά μήκος του φασματικού πλέγματος.
Διαθέτει ρυθμίσεις για τον ορισμό του ύψους των στηλών του φάσματος, του τρόπου απόδοσης των στηλών (συμπαγείς, σημειακές, συρματόπλεγμα), και είναι μία ελαφριά, εμφανίσιμη και χαμηλής υπολογιστικής ισχύος οπτικοποίησηSpectrum is a Visualisation showing a rotating 3D Spectrum Analyzer rendered in that moves to the beat of the music creating a wave effect across the spectrum grid.
It also has settings to adjust the spectrum bar height, Its speed, and how the bars are rendered (solid, points, wire frame) and is a nice light weight, low cpu useage visualisation that looks greatSpectrum es una visualización que muestra un analizador de espectro en 3D girando renderizado con que se mueve al ritmo de la música creando un efecto de onda en la rejilla del espectro.
Se puede ajustar la altura de las barras, su velocidad, y como son renderizadas (sólido, puntos, malla). Es una visualización que utiliza poca CPU y muy agradable.Spectrum es una visualización que muestra un analizador de espectro en 3D girando, renderizado con , que se mueve al ritmo de la música creando un efecto de onda en la rejilla del espectro.
Se puede ajustar la altura de las barras, su velocidad, y como son renderizadas (sólido, puntos, malla). Es una visualización que utiliza poca CPU y muy agradable.Espectro es una Visualización que muestra un Analizador de Especto en 3D rotando renderizado en que se mueve al ritmo de la música creando un efecto de onda a través del espectro de la red.
También tiene configuraciones para ajustar la altura de la barra de espectro, su velocidad, y cómo las barras son renderizadas (sólidas, puntos, malla de alambre) y es una buena visualización liviana, de poco uso de cpu que se ve genial.Spectrum on visuaal, mis näitab 3D spektraalanalüüsi renderdatud 'is, mis liigub liigub muusika rütmis luues laineefekti üle spektraalvõrgustiku.
Lisaks on olemas ka võimalus seadistada spektri kõrgust, selle kiirust ja kuidas ribasid renderdatakse (tahkis, punktid, sõrestik). Spectrum on hea väljanägemisega kerge ja vähese protsessorikasutusega visuaal.Näyttää pyörivän 3D-spektrianalysaattorin, joka liikkuu musiikin tahdissa tuottaen aaltotehosteen spektrikuvaajaan.
Spektripalkin korkeuden, nopeuden, ja piirtotavan (täytetyt, pisteet, ääriviivat) voi asettaa asetuksista. Spectrum on kevyt visualisointi joka näyttää hyvältä.Spectrum est une visualisation affichant un analyseur de spectre 3D en rotation, sous . Il réagit au rythme de la musique, créant un effet d'onde sur la grille du spectre.
Il propose divers paramètres pour ajuster la hauteur, la vitesse, et le rendu des barres du spectre (plein, points, fil de fer). Une visualisation légère, peu gourmande en CPU et agréable à regarder.Spectrum é unha Visualización que amosa un analizador de espectro virando en 3D renderizado con que se move ó ritmo da música creando un efecto de onde ó longo da grella do espectro.
Tamén ten opcións para axustar a altura da barra, a velocidade e como se renderizan as barras (sólidas, puntos, malla) do espectro. É bonito, lixeiro, de baixo custo en CPU.Spectrum זהו חיזוי אשר מציג סיבובי 3D Spectrum Analyzer אשר זז לצלילי המוזיקה שיוצר אפקט גלים לרוחב רשת הספקטרום.
יש אפשרות גם להגדיר את גובה פס הספקטרום, את המהירות, ואת התנהגות הפסים (filled, points, wire frame) וזהו חיזוי נחמד קל משקל לא מעמיס על המעבד ונראה נהדר.Spectrum je vizualizacija koja prikazuje rotirajući 3D spektralni analizator renderiran u -u koji se pokreće u ritmu muzike stvarajući efekt valova u spektralnoj mreži.
Također sadrži i postavke za namještanje visine sprektralnih traka, njihove brzine, i načina na koji su prikazane (popunjeno, točke, žičani okvir). Vizualizacija izgleda sjajno te je malih memorijskih i CPU zahtjeva.Az Spectrum egy olyan vizualizáció ami egy 3D hang spektrum analizátort mutat segítségével megjelenítve, ami a zene ritmusára mozog egy hullám-effektust képezve a teljes spektrumhálón.
Beállítható a spektrum oszlopok magassága, mozgási sebessége és hogy az oszlopok hogyan jelenjenek meg (teli, pontok, drótváz). Ez egy kis erőforrásigényű vizualizáció ami nagyon jól mutat.Spectrum er myndskreyting sem sýnir þrívíddar rófgreini sem snýst sem er teiknaður í og hreyfist í takt við tónlistina sem myndar bylgjuhreyfingu yfir rófið.
Það er líka hægt að stilla hæð mælingana, hraða og hvernig þær eru teiknaðar (fyllt, punktar, útlínur) myndskrytingin setur lítið álag á örgjörva og lítur vel útSpectrum è una visualizzazione che mostra un analizzatore di spettro renderizzato in che si muove a tempo di musica creando un effetto onda attraverso la griglia.
E' possibile regolare varie impostazioni: l'altezza delle barre, la velocità di risposta e come le barre sono renderizzate (piene, con punti o con righe). E' una visualizzazione rilassante e con basso uso del processore.Spectrum is a Visualisation showing a rotating 3D Spectrum Analyzer rendered in that moves to the beat of the music creating a wave effect across the spectrum grid.
It also has settings to adjust the spectrum bar height, Its speed, and how the bars are rendered (solid, points, wire frame) and is a nice light weight, low cpu useage visualisation that looks great스펙트럼은 회전하는 3D 스펙트럼 분석기를 통해 음악시각화를 보여주며 음악의 비트가 만들어내는 웨이브 효과를 스펙트럼 그리드에 보여줍니다. 설정에서 스펙트럼 바의 높이, 속도, 바의 갯수 (채워짐, 점, 와이어 프레임)를 지정할수 있습니다. 가볍고 CPU를 많이 사용하지 않습니다.Spektro vizualizacija, kurioje besisukantį 3D spektro analizatorių, priimtą , katras juda į muzikos ritmą, įsteigiantis bangų poveikį visame spektro tinklelyje.
Taip pat turi nustatymus nureguliuoti spektro juostos aukštį, jos greitį, ir teikiamas kraštines (kieta, taškai, tinklelio rėmas) ir yra gražus bei lengvas, mažai naudoja CPU vizualizacijai, ir atrodo puikiaiSpectrum is a Visualisation showing a rotating 3D Spectrum Analyzer rendered in that moves to the beat of the music creating a wave effect across the spectrum grid.⏎ It also has settings to adjust the spectrum bar height, Its speed, and how the bars are rendered (solid, points, wire frame) and is a nice light weight, low cpu useage visualisation that looks greatSpectrum is een visualisatie met een draaiende 3D Spectrum Analyzer gerenderd in . Deze visualisatie beweegt op het ritme van de muziek en creëert een golf effect over het hele spectrum. ⏎
Het heeft instellingen om de barhoogte en de snelheid aan te passen, en hoe de staven worden weergegeven (vast, punten, draad frame) en is een mooie lichtgewicht visualisatie die weinig van de cpu vraagt en er geweldig uit ziet.Spectrum er en visualisering som viser et roterende 3D Spectrum Analyzer gjengitt i som flytter til rytmen i musikken skaper en bølge effekt over hele spekteret rutenettet.⏎
Det har også innstillinger for å justere spekterets bar høyde, hastighet, og hvordan barene gjengis (solid, punkt, wireframe) og er en fin lett vekt, lav cpu brukende visualisering som ser flott utWizualizacja pokazuje obracający się, trójwymiarowy analizator widma, renderowany przy użyciu . Możesz ustawić wysokość słupków, ich prędkość i wygląd.Spectrum é uma visualização que mostra um analisador espectral 3D rotativo, renderizado em , que se sincroniza com o ritmo da música, criando assim um efeito de ondas na grelha espectral.
Pode-se definir a altura das barras, a sua velocidade e como são renderizadas (sólido, pontos ou contorno). É uma visualização que não utiliza muito CPU e tem um aspecto fantástico.O Spectrum é uma visualização que mostra um analisador espectral rotativo 3D, renderizado em , que se sincroniza com a batida, criando assim um efeito de ondas na grelha espectral.
Pode-se definir a altura das barras, a sua velocidade e como são renderizadas (sólido, pontos ou contorno). É uma visualização que utiliza pouco o CPU e com um visual fantástico.Spectrul este o vizualizare care afișează un analizor de spectre 3D rotativ randat în care se mișcă după bătăile muzicii creând un val dea-lungul grilei spectrale.
De asemenea, are setări pentru ajustarea înălțimii bărilor spectrale, a vitezei, și a modului în care bările sunt randate (umplere, puncte, contur). Este o vizualizare cu consum redus al procesorului care arată fantastic de bine.Эта визуализация на основе показывает вращающийся трёхмерный анализатор спектра, который движется в такт музыке, создавая эффект волны по всему спектру сетки.⏎
Визуализация имеет настройки для регулировки высоты полос спектра, скорости движения и способа отображения полос (сплошной, точки, каркас), а также обладает небольшим размером и малой нагрузкой на процессор.Spectrum je vizualizácia zobrazujúca rotujúci 3D spektrálny analyzátor vykresľovaný pomocou , ktorý sa hýbe v rytme hudby a tak vytvára vlny naprieč mriežkou spektra.[CR]
Zároveň má nastavenia upravujúce výšku stĺpcov spektra, ich rýchlosť a ako sú vykresľované (vyplnené, body, drôtový model). Je to jednoduchá vizualizácia s nízkou záťažou CPU, ktorá výborne vyzerá.Spectrum je vizualizacija, ki prikazuje vrtečo 3D spektralno analizato, generirano v , ki se premika v ritmu glasbe in ustvarja učinek valovanja v celotnem spektru. Vsebuje tudi nastavitve za prilagoditev višine spektra, hitrosti in oblike (polno, točke, okvir) ter je varčna vizualizacija z nizka porabo CPU-ja, ki izgleda super.Spektrum är en visualisering som visar en roterande 3D-spektrumanalysator renderad i . Den rör sig till musikens takt och skapar en vågeffekt över spektrat.
-spektrum har inställningar för att justera staplarnas höjd, deras hastighet, hur de ska visas (solida, punkter, ramverk) och är en visualisering med låg cpu-användning samtidigt som den ser bra utSpectrum เป็น การแสดงแสงสี ทำให้เห็นการหมุนกราฟวิเคราะห์คลื่นความถี่เสียง แบบ 3 มิติ ที่สร้างขึ้นโดย ที่ขยับไปตามจังหวะของเพลงที่สร้างผลกระทบเป็นคลื่นไปทั่วตารางความถี่.
นอกจากนี้ยังมีการตั้งค่าเพื่อปรับความสูงของแท่งคลื่นความถี่,ความเร็วและกระบวนการที่แท่งแสดงผล (ของแข็ง, จุด, โครงลวด) ทั้งยังใช้ทรัพยากรน้อยได้ดี, การแสดงแสงสี ที่ใช้ซีพียูต่ำนั่นก็ดูยอดเยี่ยมทีเดียวSpectrum є візалізаціє що показує обертаючийся 3D спектроаналізатор що промальовується з використанням технології . Спектроаналізатор показує стовпчики змінної висоти що рухаються в такт з музикою і створюють ефект подібний до хвилі.
Ви маєте можливість налаштувати висоту стовпчиків, їх швидкість і те як вони намальовані (Заповнені, контури, крапки). Це досить проста, і невимоглива до процесора візуалізація, але яка має чудовий вигляд.Spectrum可视化效果是渲染的一个旋转的三维频谱分析图像,频谱矩阵随着音乐节拍而象波浪起伏。
你还可以设置频谱棒的高度、变换速度、以及呈现效果(固体、点、框架)。这是一个不错的轻量级,低CPU使用率的可视化效果。 Spectrum 是使用 描繪顯示旋轉的3D頻譜分析視覺效果,頻譜格線隨著音樂節拍而像波浪起伏。
它還可以調整頻譜長條的高度、速度以及呈現效果(實心、點狀、線框)。它是個很好的輕量級、低 CPU 使用率的視覺化效果。@PLATFORM@GPL-2.0https://github.com/xbmc/visualization.spectrumresources/icon.pngresources/fanart.jpgresources/screenshot-01.jpgresources/screenshot-02.jpgresources/screenshot-03.jpg
visualization.spectrum-3.0.3-Leia/visualization.spectrum/resources/ 0000775 0000000 0000000 00000000000 13615262311 0025703 5 ustar 00root root 0000000 0000000 visualization.spectrum-3.0.3-Leia/visualization.spectrum/resources/fanart.jpg 0000664 0000000 0000000 00000372347 13615262311 0027700 0 ustar 00root root 0000000 0000000 JFIF % %