diff --git a/Makefile.common b/Makefile.common
index fe1b5eb13f..235ee2a893 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -1389,7 +1389,7 @@ ifeq ($(HAVE_PLAIN_DRM), 1)
endif
ifeq ($(HAVE_VITAGL), 1)
- DEFINES += -DHAVE_OPENGL1
+ DEFINES += -DHAVE_OPENGL1 -DHAVE_VITAGL
OBJ += gfx/drivers/gl1.o \
gfx/drivers_font/gl1_raster_font.o \
gfx/drivers_context/vita_ctx.o \
@@ -2320,19 +2320,6 @@ ifeq ($(HAVE_MATH_NEON), 1)
OBJ += $(patsubst %.c,%.o,$(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c)))
endif
-ifeq ($(HAVE_VITAGL), 1)
- INCLUDE_DIRS += -I$(DEPS_DIR)/vitaShaRK/source
- SOURCES := $(DEPS_DIR)/vitaShaRK/source
- OBJ += $(patsubst %.c,%.o,$(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c)))
-endif
-
-ifeq ($(HAVE_VITAGL), 1)
- DEFINES += -DHAVE_VITAGL -DSTB_DXT_IMPLEMENTATION -DSKIP_ERROR_HANDLING -DHAVE_SHARK
- INCLUDE_DIRS += -I$(DEPS_DIR)/vitaGL/source -I$(DEPS_DIR)/vitaShaRK/include
- SOURCES := $(DEPS_DIR)/vitaGL/source $(DEPS_DIR)/vitaGL/source/utils
- OBJ += $(patsubst %.c,%.o,$(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c)))
-endif
-
#####################################
### Android Play Feature Delivery ###
### (Play Store build core ###
diff --git a/Makefile.vita b/Makefile.vita
index d4aa224d52..dd94ba0282 100644
--- a/Makefile.vita
+++ b/Makefile.vita
@@ -132,7 +132,7 @@ CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions
VITA_LIBS := -lSceDisplay_stub -lSceGxm_stub -lSceNet_stub -lSceNetCtl_stub -lSceAppUtil_stub \
-lSceSysmodule_stub -lSceCtrl_stub -lSceHid_stub -lSceTouch_stub -lSceAudio_stub \
-lScePower_stub -lSceRtc_stub -lSceCommonDialog_stub -lScePgf_stub -lSceMotion_stub \
- -lSceFiber_stub -lSceMotion_stub -lSceAppMgr_stub -lstdc++ -lpthread -lpng -lz -lSceShaccCg_stub
+ -lSceFiber_stub -lSceMotion_stub -lSceAppMgr_stub -lstdc++ -lpthread -lpng -lz -lvitaGL -lvitashark -lSceShaccCg_stub
LIBS := $(WHOLE_START) -lretro_vita $(WHOLE_END) $(VITA_LIBS) -lm -lc
@@ -165,13 +165,7 @@ all: $(TARGETS)
%.depend: ;
-libSceShaccCg_stub.a:
- mkdir -p deps/vitaShaRK/SceShaccCg
- vita-libs-gen deps/vitaShaRK/SceShaccCg.yml deps/vitaShaRK/SceShaccCg
- make -C deps/vitaShaRK/SceShaccCg ARCH=arm-vita-eabi
- cp deps/vitaShaRK/SceShaccCg/libSceShaccCg_stub.a .
-
-$(TARGET).elf: $(OBJ) libretro_vita.a libSceShaccCg_stub.a
+$(TARGET).elf: $(OBJ) libretro_vita.a
$(LD) $(OBJ) $(LDFLAGS) $(LIBDIRS) $(LIBS) -o $@
%.velf: %.elf
@@ -187,8 +181,7 @@ $(TARGET).elf: $(OBJ) libretro_vita.a libSceShaccCg_stub.a
vita-pack-vpk -s param.sfo -b $< $@
clean:
- rm -f $(OBJ) $(TARGET).elf $(TARGET).elf.unstripped.elf $(TARGET).velf $(TARGET).self param.sfo $(TARGET).vpk libSceShaccCg_stub.a
- rm -rf deps/vitaShaRK/SceShaccCg
+ rm -f $(OBJ) $(TARGET).elf $(TARGET).elf.unstripped.elf $(TARGET).velf $(TARGET).self param.sfo $(TARGET).vpk
rm -f $(OBJ:.o=.depend)
# Useful for developers
diff --git a/deps/vitaGL/.clang-format b/deps/vitaGL/.clang-format
deleted file mode 100644
index 466a0cff41..0000000000
--- a/deps/vitaGL/.clang-format
+++ /dev/null
@@ -1,99 +0,0 @@
----
-Language: Cpp
-# BasedOnStyle: WebKit
-AccessModifierOffset: -4
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Right
-AlignOperands: false
-AlignTrailingComments: false
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
-BinPackArguments: true
-BinPackParameters: true
-BraceWrapping:
- AfterClass: false
- AfterControlStatement: false
- AfterEnum: false
- AfterFunction: true
- AfterNamespace: false
- AfterObjCDeclaration: false
- AfterStruct: false
- AfterUnion: false
- BeforeCatch: false
- BeforeElse: false
- IndentBraces: false
-BreakBeforeBinaryOperators: All
-BreakBeforeBraces: Attach
-BreakBeforeInheritanceComma: false
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakConstructorInitializers: BeforeComma
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit: 0
-CommentPragmas: '^ IWYU pragma:'
-CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: false
-DerivePointerAlignment: false
-DisableFormat: false
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: true
-ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
-IncludeCategories:
- - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
- Priority: 2
- - Regex: '^(<|"(gtest|isl|json)/)'
- Priority: 3
- - Regex: '.*'
- Priority: 1
-IncludeIsMainRegex: '$'
-IndentCaseLabels: false
-IndentWidth: 4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: false
-MacroBlockBegin: ''
-MacroBlockEnd: ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBlockIndentWidth: 4
-ObjCSpaceAfterProperty: true
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Right
-ReflowComments: true
-SortIncludes: true
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles: false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-TabWidth: 4
-UseTab: Always
-...
diff --git a/deps/vitaGL/.gitattributes b/deps/vitaGL/.gitattributes
deleted file mode 100644
index bdb0cabc87..0000000000
--- a/deps/vitaGL/.gitattributes
+++ /dev/null
@@ -1,17 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto
-
-# Custom for Visual Studio
-*.cs diff=csharp
-
-# Standard to msysgit
-*.doc diff=astextplain
-*.DOC diff=astextplain
-*.docx diff=astextplain
-*.DOCX diff=astextplain
-*.dot diff=astextplain
-*.DOT diff=astextplain
-*.pdf diff=astextplain
-*.PDF diff=astextplain
-*.rtf diff=astextplain
-*.RTF diff=astextplain
diff --git a/deps/vitaGL/.github/FUNDING.yml b/deps/vitaGL/.github/FUNDING.yml
deleted file mode 100644
index dbd470e946..0000000000
--- a/deps/vitaGL/.github/FUNDING.yml
+++ /dev/null
@@ -1 +0,0 @@
-patreon: Rinnegatamante
diff --git a/deps/vitaGL/.gitignore b/deps/vitaGL/.gitignore
deleted file mode 100644
index 23410e348b..0000000000
--- a/deps/vitaGL/.gitignore
+++ /dev/null
@@ -1,57 +0,0 @@
-*.vpk
-*.elf
-*.velf
-*.bin
-*.sfo
-
-# Windows image file caches
-Thumbs.db
-ehthumbs.db
-
-# Folder config file
-Desktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
-
-# =========================
-# Operating System Files
-# =========================
-
-# OSX
-# =========================
-
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-# Vita build stuffs
-*.a
-*.o
diff --git a/deps/vitaGL/COPYING b/deps/vitaGL/COPYING
deleted file mode 100644
index f288702d2f..0000000000
--- a/deps/vitaGL/COPYING
+++ /dev/null
@@ -1,674 +0,0 @@
- 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
-.
diff --git a/deps/vitaGL/COPYING.LESSER b/deps/vitaGL/COPYING.LESSER
deleted file mode 100644
index 0a041280bd..0000000000
--- a/deps/vitaGL/COPYING.LESSER
+++ /dev/null
@@ -1,165 +0,0 @@
- GNU LESSER 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.
-
-
- This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
- 0. Additional Definitions.
-
- As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
- "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
- An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
- A "Combined Work" is a work produced by combining or linking an
-Application with the Library. The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
- The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
- The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
- 1. Exception to Section 3 of the GNU GPL.
-
- You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
- 2. Conveying Modified Versions.
-
- If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
- a) under this License, provided that you make a good faith effort to
- ensure that, in the event an Application does not supply the
- function or data, the facility still operates, and performs
- whatever part of its purpose remains meaningful, or
-
- b) under the GNU GPL, with none of the additional permissions of
- this License applicable to that copy.
-
- 3. Object Code Incorporating Material from Library Header Files.
-
- The object code form of an Application may incorporate material from
-a header file that is part of the Library. You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
- a) Give prominent notice with each copy of the object code that the
- Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the object code with a copy of the GNU GPL and this license
- document.
-
- 4. Combined Works.
-
- You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
- a) Give prominent notice with each copy of the Combined Work that
- the Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the Combined Work with a copy of the GNU GPL and this license
- document.
-
- c) For a Combined Work that displays copyright notices during
- execution, include the copyright notice for the Library among
- these notices, as well as a reference directing the user to the
- copies of the GNU GPL and this license document.
-
- d) Do one of the following:
-
- 0) Convey the Minimal Corresponding Source under the terms of this
- License, and the Corresponding Application Code in a form
- suitable for, and under terms that permit, the user to
- recombine or relink the Application with a modified version of
- the Linked Version to produce a modified Combined Work, in the
- manner specified by section 6 of the GNU GPL for conveying
- Corresponding Source.
-
- 1) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (a) uses at run time
- a copy of the Library already present on the user's computer
- system, and (b) will operate properly with a modified version
- of the Library that is interface-compatible with the Linked
- Version.
-
- e) Provide Installation Information, but only if you would otherwise
- be required to provide such information under section 6 of the
- GNU GPL, and only to the extent that such information is
- necessary to install and execute a modified version of the
- Combined Work produced by recombining or relinking the
- Application with a modified version of the Linked Version. (If
- you use option 4d0, the Installation Information must accompany
- the Minimal Corresponding Source and Corresponding Application
- Code. If you use option 4d1, you must provide the Installation
- Information in the manner specified by section 6 of the GNU GPL
- for conveying Corresponding Source.)
-
- 5. Combined Libraries.
-
- You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
- a) Accompany the combined library with a copy of the same work based
- on the Library, uncombined with any other library facilities,
- conveyed under the terms of this License.
-
- b) Give prominent notice with the combined library that part of it
- is a work based on the Library, and explaining where to find the
- accompanying uncombined form of the same work.
-
- 6. Revised Versions of the GNU Lesser General Public License.
-
- The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
- If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
diff --git a/deps/vitaGL/Makefile b/deps/vitaGL/Makefile
deleted file mode 100644
index fc0f21bfca..0000000000
--- a/deps/vitaGL/Makefile
+++ /dev/null
@@ -1,83 +0,0 @@
-TARGET := libvitaGL
-SOURCES := source source/utils
-SHADERS := shaders
-
-ifeq ($(HAVE_SBRK),1)
-SOURCES += source/hacks
-endif
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-ASMFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.S))
-CGFILES := $(foreach dir,$(SHADERS), $(wildcard $(dir)/*.cg))
-HEADERS := $(CGFILES:.cg=.h)
-OBJS := $(CFILES:.c=.o) $(ASMFILES:.S=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-AR = $(PREFIX)-gcc-ar
-CFLAGS = -g -Wl,-q -O2 -ffast-math -mtune=cortex-a9 -mfpu=neon -ftree-vectorize -DSTB_DXT_IMPLEMENTATION
-ASFLAGS = $(CFLAGS)
-
-ifeq ($(NO_DEBUG),1)
-CFLAGS += -DSKIP_ERROR_HANDLING
-endif
-
-ifeq ($(HAVE_SHARK),1)
-CFLAGS += -DHAVE_SHARK
-endif
-
-ifeq ($(HAVE_SHARK),2)
-CFLAGS += -DHAVE_SHARK -DHAVE_SHARK_LOG
-endif
-
-all: $(TARGET).a
-
-$(TARGET).a: $(OBJS)
- $(AR) -rc $@ $^
-
-%_f.h:
- psp2cgc -profile sce_fp_psp2 $(@:_f.h=_f.cg) -Wperf -o $(@:_f.h=_f.gxp)
- bin2c $(@:_f.h=_f.gxp) source/shaders/$(notdir $(@)) $(notdir $(@:_f.h=_f))
- @rm -rf $(@:_f.h=_f.gxp)
-
-%_v.h:
- psp2cgc -profile sce_vp_psp2 $(@:_v.h=_v.cg) -Wperf -o $(@:_v.h=_v.gxp)
- bin2c $(@:_v.h=_v.gxp) source/shaders/$(notdir $(@:_v.h=_v.h)) $(notdir $(@:_v.h=_v))
- @rm -rf $(@:_v.h=_v.gxp)
-
-shaders: $(HEADERS)
-
-clean:
- @rm -rf $(TARGET).a $(TARGET).elf $(OBJS)
- @make -C samples/sample1 clean
- @make -C samples/sample2 clean
- @make -C samples/sample3 clean
- @make -C samples/sample4 clean
- @make -C samples/sample5 clean
- @make -C samples/sample6 clean
- @make -C samples/sample7 clean
- @make -C samples/sample8 clean
-
-install: $(TARGET).a
- @mkdir -p $(VITASDK)/$(PREFIX)/lib/
- cp $(TARGET).a $(VITASDK)/$(PREFIX)/lib/
- @mkdir -p $(VITASDK)/$(PREFIX)/include/
- cp source/vitaGL.h $(VITASDK)/$(PREFIX)/include/
-
-samples: $(TARGET).a
- @make -C samples/sample1
- cp "samples/sample1/vitaGL-Sample001.vpk" .
- @make -C samples/sample2
- cp "samples/sample2/vitaGL-Sample002.vpk" .
- @make -C samples/sample3
- cp "samples/sample3/vitaGL-Sample003.vpk" .
- @make -C samples/sample4
- cp "samples/sample4/vitaGL-Sample004.vpk" .
- @make -C samples/sample5
- cp "samples/sample5/vitaGL-Sample005.vpk" .
- @make -C samples/sample6
- cp "samples/sample6/vitaGL-Sample006.vpk" .
- @make -C samples/sample7
- cp "samples/sample7/vitaGL-Sample007.vpk" .
- @make -C samples/sample8
- cp "samples/sample8/vitaGL-Sample008.vpk" .
diff --git a/deps/vitaGL/README.md b/deps/vitaGL/README.md
deleted file mode 100644
index 98ab65c04a..0000000000
--- a/deps/vitaGL/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# vitaGL
-vitaGL is a wrapper between openGL and sceGxm. It allows to use a subset of openGL functions with fully hardware acceleration by translating the code to sceGxm equivalent.
-
-# Build Instructions
-In order to build vitaGL use the following command: `make HAVE_SBRK=1 install`.
-If you already have a newlib sbrk replacement in your app (eg. RetroArch), use instead this command: `make install`.
-
-# Samples
-
-You can find samples in the *samples* folder in this repository.
-
-# Help and Troubleshooting
-
-If you plan to use vitaGL for one of your projects, you can find an official channel to get help with it on Vita Nuova discord server: https://discord.gg/PyCaBx9
-
-# Projects actually using vitaGL
-
-Here you can find a list of projects using vitaGL:
-
-Direct OpenGL Usage:
-[vitaQuake](https://vitadb.rinnegatamante.it/#/info/10) - Port of Quake I and mission packs
-[vitaQuakeII](https://vitadb.rinnegatamante.it/#/info/278) -Port of Quake II and mission packs
-[vitaQuakeIII](https://vitadb.rinnegatamante.it/#/info/375) - Port of ioquake3 (Quake III: Arena, Quake III: Team Arena, OpenArena, Urban Terror)
-[vitaRTCW](https://vitadb.rinnegatamante.it/#/info/459) - Port of iortcw (Return to Castle Wolfenstein)
-[vitaHexenII](https://vitadb.rinnegatamante.it/#/info/196) - Port of Hexen II
-[vitaXash3D](https://vitadb.rinnegatamante.it/#/info/365) - Port of Xash3D (Half Life, Counter Strike 1.6)
-[Fade to Black](https://vitadb.rinnegatamante.it/#/info/367) - Port of Fade to Black
-[vitaVoyager](https://vitadb.rinnegatamante.it/#/info/367) - Port of lilium-voyager (Star Trek Voyager: Elite Force)
-[Daedalus X64](https://github.com/Rinnegatamante/daedalusx64-vitagl) - Port of Daedalus X64 (N64 Emulator)
-[RetroArch](https://github.com/libretro/RetroArch) - Vita's GL1 video driver of RetroArch
-[vitaET](https://github.com/Rinnegatamante/vitaET) - Port of ET: Legacy (Wolfenstein: Enemy Territory)
-[flycast](https://github.com/Rinnegatamante/flycast) - Port of flycast (Dreamcast Emulator)
-[AvP Gold](https://github.com/Rinnegatamante/AvP-Gold-Vita) - Port of Aliens versus Predator: Gold Edition
-[re3-vita](https://vitadb.rinnegatamante.it/#/info/589) - Port of Grand Theft Auto III
-[prboom-plus](https://vitadb.rinnegatamante.it/#/info/591) - Port of PrBoom Plus (Doom engine sourceport)
-[VITAlbum](https://vitadb.rinnegatamante.it/#/info/566) - Filebrowser and image viewer app
-[sm64-vita](https://github.com/bythos14/sm64-vita) - Port of Super Mario 64
-
-Libraries:
-[sdl12_gl](https://github.com/Rinnegatamante/SDL-Vita/tree/sdl12_gl/src) - SDL 1.2 Vita port adapted to work with vitaGL as renderer
-[imgui_vita](https://github.com/Rinnegatamante/imgui-vita) - Port of dear imGui
-
-sdl12_gl Apps:
-[SuperMarioWar](https://vitadb.rinnegatamante.it/#/info/422) - Port of Super Mario War
-[ZeldaOLB](https://vitadb.rinnegatamante.it/#/info/265) - Port of Zelda: Oni Link Begins
-[ZeldaROTH](https://vitadb.rinnegatamante.it/#/info/109) - Port of Zelda: Return of the Hylian
-[Zelda3T](https://vitadb.rinnegatamante.it/#/info/334) - Port of Zelda: Time to Triumph
-[ZeldaNSQ](https://vitadb.rinnegatamante.it/#/info/350) - Port of Zelda: Navi's Quest
-[vitaWolfen](https://vitadb.rinnegatamante.it/#/info/31) - Port of Wolf4SDL (Wolfenstein 3D)
-[meritous](https://vitadb.rinnegatamante.it/#/info/411) - Port of meritous
diff --git a/deps/vitaGL/format.bat b/deps/vitaGL/format.bat
deleted file mode 100644
index dab6c9f4a1..0000000000
--- a/deps/vitaGL/format.bat
+++ /dev/null
@@ -1,6 +0,0 @@
-@echo off
-cd source
-for /f %%f in ('dir *.c *.h /b/s') do (
- echo.%%f | findstr /C:"\\shaders\\">nul || (clang-format -i %%f)
-)
-cd ..
diff --git a/deps/vitaGL/samples/sample1/Makefile b/deps/vitaGL/samples/sample1/Makefile
deleted file mode 100644
index 006a1677b1..0000000000
--- a/deps/vitaGL/samples/sample1/Makefile
+++ /dev/null
@@ -1,40 +0,0 @@
-SAMPLE_NUM := 001
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lSceLibKernel_stub -lScePvf_stub -lmathneon \
- -lSceAppMgr_stub -lSceAppUtil_stub -lScePgf_stub \
- -ljpeg -lfreetype -lc -lSceCommonDialog_stub -lpng16 -lm -lz \
- -lSceGxm_stub -lSceDisplay_stub -lSceSysmodule_stub \
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin -a texture.bmp=texture.bmp $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample1/main.c b/deps/vitaGL/samples/sample1/main.c
deleted file mode 100644
index 45898dd51f..0000000000
--- a/deps/vitaGL/samples/sample1/main.c
+++ /dev/null
@@ -1,67 +0,0 @@
-// Drawing a fullscreen image on screen with glBegin/glEnd
-
-#include
-#include
-#include
-
-GLenum texture_format = GL_RGB;
-GLuint texture = 0;
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x800000);
-
- // Loading BMP image to use as texture
- SceUID fd = sceIoOpen("app0:texture.bmp", SCE_O_RDONLY, 0777);
- uint16_t w, h;
- sceIoLseek(fd, 0x12, SCE_SEEK_SET);
- sceIoRead(fd, &w, sizeof(uint16_t));
- sceIoLseek(fd, 0x16, SCE_SEEK_SET);
- sceIoRead(fd, &h, sizeof(uint16_t));
- sceIoLseek(fd, 0x26, SCE_SEEK_SET);
- uint8_t *buffer = (uint8_t*)malloc(w * h * 3);
- sceIoRead(fd, buffer, w * h * 3);
- sceIoClose(fd);
-
- glClearColor(0.50, 0, 0, 0);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, 960, 544, 0, -1, 1);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- // Initializing openGL texture
- glGenTextures(1, &texture);
- glBindTexture(GL_TEXTURE_2D, texture);
-
- glTexImage2D(GL_TEXTURE_2D, 0, texture_format, w, h, 0, texture_format, GL_UNSIGNED_BYTE, buffer);
-
- glEnable(GL_TEXTURE_2D);
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT);
- glBindTexture(GL_TEXTURE_2D, texture);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glBegin(GL_QUADS);
-
- // Note: BMP images are vertically flipped
- glTexCoord2i(0, 1);
- glVertex3f(0, 0, 0);
- glTexCoord2i(1, 1);
- glVertex3f(960, 0, 0);
- glTexCoord2i(1, 0);
- glVertex3f(960, 544, 0);
- glTexCoord2i(0, 0);
- glVertex3f(0, 544, 0);
-
- glEnd();
- vglStopRendering();
- glLoadIdentity();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/samples/sample1/texture.bmp b/deps/vitaGL/samples/sample1/texture.bmp
deleted file mode 100644
index cfcc30313b..0000000000
Binary files a/deps/vitaGL/samples/sample1/texture.bmp and /dev/null differ
diff --git a/deps/vitaGL/samples/sample2/Makefile b/deps/vitaGL/samples/sample2/Makefile
deleted file mode 100644
index 9a385a0fda..0000000000
--- a/deps/vitaGL/samples/sample2/Makefile
+++ /dev/null
@@ -1,42 +0,0 @@
-SAMPLE_NUM := 002
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_stub -lmathneon -lSceAppMgr_stub
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-debug: CFLAGS += -DDEBUG_BUILD
-debug: all
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- cp $< $<.unstripped.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
-
diff --git a/deps/vitaGL/samples/sample2/main.c b/deps/vitaGL/samples/sample2/main.c
deleted file mode 100644
index 79b2746f44..0000000000
--- a/deps/vitaGL/samples/sample2/main.c
+++ /dev/null
@@ -1,39 +0,0 @@
-// Drawing a triangle on screen with vertex array
-
-#include
-
-float colors[] = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0};
-float vertices[] = {100, 100, 0, 150, 100, 0, 100, 150, 0};
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x800000);
-
- glClearColor (0.50f, 0.0f, 0.0f, 1.0f);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, 960, 544, 0, -1, 1);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT);
-
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_COLOR_ARRAY);
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glColorPointer(3, GL_FLOAT, 0, colors);
- glDrawArrays(GL_TRIANGLES, 0, 3);
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_COLOR_ARRAY);
-
- vglStopRendering();
-
- glLoadIdentity();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/samples/sample3/Makefile b/deps/vitaGL/samples/sample3/Makefile
deleted file mode 100644
index 887e53b8b7..0000000000
--- a/deps/vitaGL/samples/sample3/Makefile
+++ /dev/null
@@ -1,38 +0,0 @@
-SAMPLE_NUM := 003
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lSceLibKernel_stub -lSceAppMgr_stub -lSceAppUtil_stub -lmathneon \
- -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_stub -lSceSysmodule_stub \
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample3/main.c b/deps/vitaGL/samples/sample3/main.c
deleted file mode 100644
index 97cb9f186e..0000000000
--- a/deps/vitaGL/samples/sample3/main.c
+++ /dev/null
@@ -1,36 +0,0 @@
-// Drawing a colored quad with glBegin/glEnd
-
-#include
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x800000);
-
- glClearColor(0.0, 0.0, 0.0, 0.0);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, 960, 544, 0, -1, 1);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT);
- glBegin(GL_QUADS);
- glColor3f(1.0, 0.0, 0.0);
- glVertex3f(400, 0, 0);
- glColor3f(1.0, 1.0, 0.0);
- glVertex3f(800, 0, 0);
- glColor3f(0.0, 1.0, 0.0);
- glVertex3f(800, 400, 0);
- glColor3f(1.0, 0.0, 1.0);
- glVertex3f(400, 400, 0);
- glEnd();
- vglStopRendering();
- glLoadIdentity();
- }
-
- vglEnd();
-
-}
diff --git a/deps/vitaGL/samples/sample4/Makefile b/deps/vitaGL/samples/sample4/Makefile
deleted file mode 100644
index 16fdc27ac7..0000000000
--- a/deps/vitaGL/samples/sample4/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-SAMPLE_NUM := 004
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_stub -lmathneon -lSceAppMgr_stub
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample4/main.c b/deps/vitaGL/samples/sample4/main.c
deleted file mode 100644
index c1ff0fda96..0000000000
--- a/deps/vitaGL/samples/sample4/main.c
+++ /dev/null
@@ -1,38 +0,0 @@
-// Drawing a quad on screen with glDrawElements
-
-#include
-
-float colors[] = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0};
-float vertices[] = {100, 100, 0, 150, 100, 0, 100, 150, 0, 150, 150, 0};
-uint16_t indices[] = {0, 1, 2, 1, 2, 3};
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x800000);
-
- glClearColor (0.50f, 0.0f, 0.0f, 1.0f);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, 960, 544, 0, -1, 1);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT);
-
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_COLOR_ARRAY);
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glColorPointer(3, GL_FLOAT, 0, colors);
- glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_COLOR_ARRAY);
- vglStopRendering();
- glLoadIdentity();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/samples/sample5/Makefile b/deps/vitaGL/samples/sample5/Makefile
deleted file mode 100644
index 964bd24cce..0000000000
--- a/deps/vitaGL/samples/sample5/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-SAMPLE_NUM := 005
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_stub -lSceAppMgr_stub -lmathneon
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample5/main.c b/deps/vitaGL/samples/sample5/main.c
deleted file mode 100644
index 6b4389c403..0000000000
--- a/deps/vitaGL/samples/sample5/main.c
+++ /dev/null
@@ -1,75 +0,0 @@
-// Drawing a rotating cube
-
-#include
-#include
-
-float colors[] = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0}; // Colors for a face
-
-float vertices_front[] = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f}; // Front Face
-float vertices_back[] = {-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Back Face
-float vertices_left[] = {-0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f}; // Left Face
-float vertices_right[] = {0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Right Face
-float vertices_top[] = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f}; // Top Face
-float vertices_bottom[] = {-0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Bottom Face
-
-uint16_t indices[] = {
- 0, 1, 2, 1, 2, 3, // Front
- 4, 5, 6, 5, 6, 7, // Back
- 8, 9,10, 9,10,11, // Left
- 12,13,14,13,14,15, // Right
- 16,17,18,17,18,19, // Top
- 20,21,22,21,22,23 // Bottom
-};
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x800000);
- vglWaitVblankStart(GL_TRUE);
-
- // Creating colors array
- float color_array[12*6];
- int i;
- for (i=0;i<12*6;i++){
- color_array[i] = colors[i % 12];
- }
-
- // Creating vertices array
- float vertex_array[12*6];
- memcpy(&vertex_array[12*0], &vertices_front[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*1], &vertices_back[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*2], &vertices_left[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*3], &vertices_right[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*4], &vertices_top[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*5], &vertices_bottom[0], sizeof(float) * 12);
-
- glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- gluPerspective(90.0f, 960.f/544.0f, 0.01f, 100.0f);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glTranslatef(0.0f, 0.0f, -3.0f); // Centering the cube
-
- glEnable(GL_DEPTH_TEST);
- glDepthFunc(GL_LESS);
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_COLOR_ARRAY);
- glVertexPointer(3, GL_FLOAT, 0, vertex_array);
- glColorPointer(3, GL_FLOAT, 0, color_array);
- glRotatef(1.0f, 0.0f, 0.0f, 1.0f);
- glRotatef(0.5f, 0.0f, 1.0f, 0.0f);
- glDrawElements(GL_TRIANGLES, 6*6, GL_UNSIGNED_SHORT, indices);
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_COLOR_ARRAY);
- vglStopRendering();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/samples/sample6/Makefile b/deps/vitaGL/samples/sample6/Makefile
deleted file mode 100644
index eaf8e9f488..0000000000
--- a/deps/vitaGL/samples/sample6/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-SAMPLE_NUM := 006
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_stub -lmathneon -lSceAppMgr_stub
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample6/main.c b/deps/vitaGL/samples/sample6/main.c
deleted file mode 100644
index 817eeecf05..0000000000
--- a/deps/vitaGL/samples/sample6/main.c
+++ /dev/null
@@ -1,89 +0,0 @@
-// Drawing a rotating cube with VBO
-
-#include
-#include
-
-#define BUF_OFFS(i) ((void*)(i))
-
-float colors[] = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0}; // Colors for a face
-
-float vertices_front[] = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f}; // Front Face
-float vertices_back[] = {-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Back Face
-float vertices_left[] = {-0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f}; // Left Face
-float vertices_right[] = {0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Right Face
-float vertices_top[] = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f}; // Top Face
-float vertices_bottom[] = {-0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Bottom Face
-
-GLuint buffers[2];
-
-uint16_t indices[] = {
- 0, 1, 2, 1, 2, 3, // Front
- 4, 5, 6, 5, 6, 7, // Back
- 8, 9,10, 9,10,11, // Left
- 12,13,14,13,14,15, // Right
- 16,17,18,17,18,19, // Top
- 20,21,22,21,22,23 // Bottom
-};
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x80000);
- vglWaitVblankStart(GL_TRUE);
-
- // Creating VBO data with vertices + colors
- float vbo[12*12];
- memcpy(&vbo[12*0], &vertices_front[0], sizeof(float) * 12);
- memcpy(&vbo[12*1], &vertices_back[0], sizeof(float) * 12);
- memcpy(&vbo[12*2], &vertices_left[0], sizeof(float) * 12);
- memcpy(&vbo[12*3], &vertices_right[0], sizeof(float) * 12);
- memcpy(&vbo[12*4], &vertices_top[0], sizeof(float) * 12);
- memcpy(&vbo[12*5], &vertices_bottom[0], sizeof(float) * 12);
- memcpy(&vbo[12*6], &colors[0], sizeof(float) * 12);
- memcpy(&vbo[12*7], &colors[0], sizeof(float) * 12);
- memcpy(&vbo[12*8], &colors[0], sizeof(float) * 12);
- memcpy(&vbo[12*9], &colors[0], sizeof(float) * 12);
- memcpy(&vbo[12*10], &colors[0], sizeof(float) * 12);
- memcpy(&vbo[12*11], &colors[0], sizeof(float) * 12);
-
- // Creating two buffers for colors, vertices and indices
- glGenBuffers(2, buffers);
-
- // Setting up VBO
- glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
- glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 12 * 12, vbo, GL_STATIC_DRAW);
-
- // Setting up indices array
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint16_t) * 6 * 6, indices, GL_STATIC_DRAW);
-
- glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- gluPerspective(90.0f, 960.f/544.0f, 0.01f, 100.0f);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glTranslatef(0.0f, 0.0f, -3.0f); // Centering the cube
-
- glEnable(GL_DEPTH_TEST);
- glDepthFunc(GL_LESS);
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_COLOR_ARRAY);
- glVertexPointer(3, GL_FLOAT, 0, BUF_OFFS(0));
- glColorPointer(3, GL_FLOAT, 0, BUF_OFFS(12*6*sizeof(float)));
- glRotatef(1.0f, 0.0f, 0.0f, 1.0f);
- glRotatef(0.5f, 1.0f, 0.0f, 0.0f);
- glDrawElements(GL_TRIANGLES, 6*6, GL_UNSIGNED_SHORT, BUF_OFFS(0));
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_COLOR_ARRAY);
- vglStopRendering();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/samples/sample7/Makefile b/deps/vitaGL/samples/sample7/Makefile
deleted file mode 100644
index 8b33dfa4f8..0000000000
--- a/deps/vitaGL/samples/sample7/Makefile
+++ /dev/null
@@ -1,40 +0,0 @@
-SAMPLE_NUM := 007
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lSceLibKernel_stub -lScePvf_stub \
- -lSceAppMgr_stub -lSceAppUtil_stub -lScePgf_stub \
- -ljpeg -lfreetype -lc -lSceCommonDialog_stub -lpng16 -lm -lz \
- -lSceGxm_stub -lSceDisplay_stub -lSceSysmodule_stub -lmathneon
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin -a texture.bmp=texture.bmp $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample7/main.c b/deps/vitaGL/samples/sample7/main.c
deleted file mode 100644
index 556bdad738..0000000000
--- a/deps/vitaGL/samples/sample7/main.c
+++ /dev/null
@@ -1,91 +0,0 @@
-// Drawing a fullscreen image on screen with glBegin/glEnd
-
-#include
-#include
-#include
-
-GLenum texture_format = GL_RGB;
-GLuint texture = 0;
-
-float colors[] = {0.4, 0.1, 0.3, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0};
-float vertices[] = {100, 100, 0, 150, 100, 0, 100, 150, 0};
-
-int main(){
-
- // Initializing graphics device
- vglInit(0x800000);
-
- // Loading BMP image to use as texture
- SceUID fd = sceIoOpen("app0:texture.bmp", SCE_O_RDONLY, 0777);
- uint16_t w, h;
- sceIoLseek(fd, 0x12, SCE_SEEK_SET);
- sceIoRead(fd, &w, sizeof(uint16_t));
- sceIoLseek(fd, 0x16, SCE_SEEK_SET);
- sceIoRead(fd, &h, sizeof(uint16_t));
- sceIoLseek(fd, 0x26, SCE_SEEK_SET);
- uint8_t *buffer = (uint8_t*)malloc(w * h * 3);
- sceIoRead(fd, buffer, w * h * 3);
- sceIoClose(fd);
-
- glClearColor(0.50, 0, 0, 0);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- glOrtho(0, 960, 544, 0, -1, 1);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
-
- // Initializing openGL texture
- glGenTextures(1, &texture);
- glBindTexture(GL_TEXTURE_2D, texture);
- glTexImage2D(GL_TEXTURE_2D, 0, texture_format, w, h, 0, texture_format, GL_UNSIGNED_BYTE, buffer);
- glEnable(GL_TEXTURE_2D);
-
- // Initializing framebuffer
- GLuint fb;
- glGenFramebuffers(1, &fb);
- glBindFramebuffer(GL_FRAMEBUFFER, fb);
-
- // Binding texture to framebuffer
- glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, 0);
-
- // Drawing on texture
- vglStartRendering();
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_COLOR_ARRAY);
- glVertexPointer(3, GL_FLOAT, 0, vertices);
- glColorPointer(3, GL_FLOAT, 0, colors);
- glDrawArrays(GL_TRIANGLES, 0, 3);
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_COLOR_ARRAY);
- vglStopRendering();
- glFinish();
- glLoadIdentity();
-
- glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT);
- glBindTexture(GL_TEXTURE_2D, texture);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
- glBegin(GL_QUADS);
-
- // Note: BMP images are vertically flipped
- glTexCoord2i(0, 1);
- glVertex3f(0, 0, 0);
- glTexCoord2i(1, 1);
- glVertex3f(960, 0, 0);
- glTexCoord2i(1, 0);
- glVertex3f(960, 544, 0);
- glTexCoord2i(0, 0);
- glVertex3f(0, 544, 0);
-
- glEnd();
- vglStopRendering();
- glLoadIdentity();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/samples/sample7/texture.bmp b/deps/vitaGL/samples/sample7/texture.bmp
deleted file mode 100644
index cfcc30313b..0000000000
Binary files a/deps/vitaGL/samples/sample7/texture.bmp and /dev/null differ
diff --git a/deps/vitaGL/samples/sample8/Makefile b/deps/vitaGL/samples/sample8/Makefile
deleted file mode 100644
index 68a1481bd6..0000000000
--- a/deps/vitaGL/samples/sample8/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-SAMPLE_NUM := 008
-TARGET := vitaGL-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_stub -lSceAppMgr_stub -lmathneon
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VITAGL$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -at 0x0E -m 0x10000 $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaGL/samples/sample8/main.c b/deps/vitaGL/samples/sample8/main.c
deleted file mode 100644
index 9a7feee685..0000000000
--- a/deps/vitaGL/samples/sample8/main.c
+++ /dev/null
@@ -1,76 +0,0 @@
-// Drawing a rotating cube
-
-#include
-#include
-
-float colors[] = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0}; // Colors for a face
-
-float vertices_front[] = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f}; // Front Face
-float vertices_back[] = {-0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Back Face
-float vertices_left[] = {-0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f}; // Left Face
-float vertices_right[] = {0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Right Face
-float vertices_top[] = {-0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f}; // Top Face
-float vertices_bottom[] = {-0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f}; // Bottom Face
-
-uint16_t indices[] = {
- 0, 1, 2, 1, 2, 3, // Front
- 4, 5, 6, 5, 6, 7, // Back
- 8, 9,10, 9,10,11, // Left
- 12,13,14,13,14,15, // Right
- 16,17,18,17,18,19, // Top
- 20,21,22,21,22,23 // Bottom
-};
-
-int main(){
-
- // Initializing graphics device
- vglSetParamBufferSize(2 * 1024 * 1024);
- vglInitWithCustomSizes(0x1000, 960, 544, 16 * 1024 * 1024, 0, 0, SCE_GXM_MULTISAMPLE_4X);
- vglWaitVblankStart(GL_TRUE);
-
- // Creating colors array
- float color_array[12*6];
- int i;
- for (i=0;i<12*6;i++){
- color_array[i] = colors[i % 12];
- }
-
- // Creating vertices array
- float vertex_array[12*6];
- memcpy(&vertex_array[12*0], &vertices_front[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*1], &vertices_back[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*2], &vertices_left[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*3], &vertices_right[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*4], &vertices_top[0], sizeof(float) * 12);
- memcpy(&vertex_array[12*5], &vertices_bottom[0], sizeof(float) * 12);
-
- glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
- glMatrixMode(GL_PROJECTION);
- glLoadIdentity();
- gluPerspective(90.0f, 960.f/544.0f, 0.01f, 100.0f);
- glMatrixMode(GL_MODELVIEW);
- glLoadIdentity();
- glTranslatef(0.0f, 0.0f, -3.0f); // Centering the cube
-
- glEnable(GL_DEPTH_TEST);
- glDepthFunc(GL_LESS);
-
- for (;;){
- vglStartRendering();
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
- glEnableClientState(GL_VERTEX_ARRAY);
- glEnableClientState(GL_COLOR_ARRAY);
- glVertexPointer(3, GL_FLOAT, 0, vertex_array);
- glColorPointer(3, GL_FLOAT, 0, color_array);
- glRotatef(1.0f, 0.0f, 0.0f, 1.0f);
- glRotatef(0.5f, 0.0f, 1.0f, 0.0f);
- glDrawElements(GL_TRIANGLES, 6*6, GL_UNSIGNED_SHORT, indices);
- glDisableClientState(GL_VERTEX_ARRAY);
- glDisableClientState(GL_COLOR_ARRAY);
- vglStopRendering();
- }
-
- vglEnd();
-
-}
\ No newline at end of file
diff --git a/deps/vitaGL/shaders/clear_f.cg b/deps/vitaGL/shaders/clear_f.cg
deleted file mode 100644
index aa28edf821..0000000000
--- a/deps/vitaGL/shaders/clear_f.cg
+++ /dev/null
@@ -1,4 +0,0 @@
-float4 main(uniform float4 u_clear_color) : COLOR
-{
- return u_clear_color;
-}
diff --git a/deps/vitaGL/shaders/clear_v.cg b/deps/vitaGL/shaders/clear_v.cg
deleted file mode 100644
index 95a138108a..0000000000
--- a/deps/vitaGL/shaders/clear_v.cg
+++ /dev/null
@@ -1,7 +0,0 @@
-float4 main(unsigned int idx : INDEX, uniform float4 position) : POSITION
-{
- float x = (idx == 1 || idx == 2) ? position[1] : position[0];
- float y = (idx == 2 || idx == 3) ? position[3] : position[2];
-
- return float4(x, y, 1.f, 1.f);
-}
diff --git a/deps/vitaGL/shaders/disable_color_buffer_f.cg b/deps/vitaGL/shaders/disable_color_buffer_f.cg
deleted file mode 100644
index 0202ff51c2..0000000000
--- a/deps/vitaGL/shaders/disable_color_buffer_f.cg
+++ /dev/null
@@ -1,5 +0,0 @@
-float main(
- uniform float depth_clear) : DEPTH
-{
- return depth_clear;
-}
diff --git a/deps/vitaGL/shaders/rgb_v.cg b/deps/vitaGL/shaders/rgb_v.cg
deleted file mode 100644
index e4f62b03e6..0000000000
--- a/deps/vitaGL/shaders/rgb_v.cg
+++ /dev/null
@@ -1,11 +0,0 @@
-void main(
- float3 aPosition,
- float3 aColor,
- column_major uniform float4x4 wvp,
- float4 out vPosition: POSITION,
- float4 out vColor: COLOR)
-{
- vPosition = mul(float4(aPosition, 1.f), wvp);
- vColor = float4(aColor, 1.f);
-}
-
diff --git a/deps/vitaGL/shaders/rgba_f.cg b/deps/vitaGL/shaders/rgba_f.cg
deleted file mode 100644
index 39ef1af00c..0000000000
--- a/deps/vitaGL/shaders/rgba_f.cg
+++ /dev/null
@@ -1,4 +0,0 @@
-float4 main(float4 vColor : COLOR) : COLOR
-{
- return vColor;
-}
diff --git a/deps/vitaGL/shaders/rgba_v.cg b/deps/vitaGL/shaders/rgba_v.cg
deleted file mode 100644
index 93786fd01e..0000000000
--- a/deps/vitaGL/shaders/rgba_v.cg
+++ /dev/null
@@ -1,11 +0,0 @@
-void main(
- float3 aPosition,
- float4 aColor,
- column_major uniform float4x4 wvp,
- float4 out vPosition: POSITION,
- float4 out vColor: COLOR)
-{
- vPosition = mul(float4(aPosition, 1.f), wvp);
- vColor = aColor;
-}
-
diff --git a/deps/vitaGL/shaders/texture2d_f.cg b/deps/vitaGL/shaders/texture2d_f.cg
deleted file mode 100644
index 2d202f7a9d..0000000000
--- a/deps/vitaGL/shaders/texture2d_f.cg
+++ /dev/null
@@ -1,83 +0,0 @@
-float4 main(
- float2 vTexcoord : TEXCOORD0,
- float4 coords: WPOS,
- uniform sampler2D tex,
- uniform float alphaCut,
- uniform int alphaOp,
- uniform float4 tintColor,
- uniform int texEnv,
- uniform int fog_mode,
- uniform float4 fogColor,
- uniform float4 texEnvColor,
- uniform float fog_near,
- uniform float fog_far,
- uniform float fog_density
- )
-{
- float4 texColor = tex2D(tex, vTexcoord);
-
- // Texture Environment
- if (texEnv < 4){
- if (texEnv == 0){ // GL_MODULATE
- texColor = texColor * tintColor;
- }else if (texEnv == 1){ // GL_DECAL
- texColor.rgb = lerp(tintColor.rgb, texColor.rgb, texColor.a);
- texColor.a = tintColor.a;
- }else if (texEnv == 2){ // GL_BLEND
- texColor.rgb = lerp(tintColor.rgb, texEnvColor.rgb, texColor.rgb);
- texColor.a = texColor.a * tintColor.a;
- }else{ // GL_ADD
- texColor.rgb = clamp(texColor.rgb + tintColor.rgb, 0.0, 1.0);
- texColor.a = texColor.a * tintColor.a;
- }
- }
-
- // Alpha Test
- if (alphaOp < 7){
- if (alphaOp == 0){
- if (texColor.a < alphaCut){
- discard;
- }
- }else if (alphaOp == 1){
- if (texColor.a <= alphaCut){
- discard;
- }
- }else if (alphaOp == 2){
- if (texColor.a == alphaCut){
- discard;
- }
- }else if (alphaOp == 3){
- if (texColor.a != alphaCut){
- discard;
- }
- }else if (alphaOp == 4){
- if (texColor.a > alphaCut){
- discard;
- }
- }else if (alphaOp == 5){
- if (texColor.a >= alphaCut){
- discard;
- }
- }else{
- discard;
- }
- }
-
- // Fogging
- if (fog_mode < 3){
- float vFog;
- if (fog_mode == 0){ // GL_LINEAR
- vFog = (fog_far - coords.z) / (fog_far - fog_near);
- }else if (fog_mode == 1){ // GL_EXP
- vFog = exp(-fog_density * coords.z);
- }else{ // GL_EXP2
- const float LOG2 = -1.442695;
- float d = fog_density * coords.z;
- vFog = exp(d * d * LOG2);
- }
- vFog = clamp(vFog, 0.0, 1.0);
- texColor.rgb = lerp(fogColor.rgb, texColor.rgb, vFog);
- }
-
- return texColor;
-}
diff --git a/deps/vitaGL/shaders/texture2d_rgba_f.cg b/deps/vitaGL/shaders/texture2d_rgba_f.cg
deleted file mode 100644
index f76328fdf9..0000000000
--- a/deps/vitaGL/shaders/texture2d_rgba_f.cg
+++ /dev/null
@@ -1,83 +0,0 @@
-float4 main(
- float2 vTexcoord : TEXCOORD0,
- float4 vColor : COLOR,
- float4 coords: WPOS,
- uniform sampler2D tex,
- uniform float alphaCut,
- uniform int alphaOp,
- uniform int texEnv,
- uniform int fog_mode,
- uniform float4 fogColor,
- uniform float4 texEnvColor,
- uniform float fog_near,
- uniform float fog_far,
- uniform float fog_density
- )
-{
- float4 texColor = tex2D(tex, vTexcoord);
-
- // Texture Environment
- if (texEnv < 4){
- if (texEnv == 0){ // GL_MODULATE
- texColor = texColor * vColor;
- }else if (texEnv == 1){ // GL_DECAL
- texColor.rgb = lerp(vColor.rgb, texColor.rgb, texColor.a);
- texColor.a = vColor.a;
- }else if (texEnv == 2){ // GL_BLEND
- texColor.rgb = lerp(vColor.rgb, texEnvColor.rgb, texColor.rgb);
- texColor.a = texColor.a * vColor.a;
- }else{ // GL_ADD
- texColor.rgb = clamp(texColor.rgb + vColor.rgb, 0.0, 1.0);
- texColor.a = texColor.a * vColor.a;
- }
- }
-
- // Alpha Test
- if (alphaOp < 7){
- if (alphaOp == 0){
- if (texColor.a < alphaCut){
- discard;
- }
- }else if (alphaOp == 1){
- if (texColor.a <= alphaCut){
- discard;
- }
- }else if (alphaOp == 2){
- if (texColor.a == alphaCut){
- discard;
- }
- }else if (alphaOp == 3){
- if (texColor.a != alphaCut){
- discard;
- }
- }else if (alphaOp == 4){
- if (texColor.a > alphaCut){
- discard;
- }
- }else if (alphaOp == 5){
- if (texColor.a >= alphaCut){
- discard;
- }
- }else{
- discard;
- }
- }
-
- // Fogging
- if (fog_mode < 3){
- float vFog;
- if (fog_mode == 0){ // GL_LINEAR
- vFog = (fog_far - coords.z) / (fog_far - fog_near);
- }else if (fog_mode == 1){ // GL_EXP
- vFog = exp(-fog_density * coords.z);
- }else{ // GL_EXP2
- const float LOG2 = -1.442695;
- float d = fog_density * coords.z;
- vFog = exp(d * d * LOG2);
- }
- vFog = clamp(vFog, 0.0, 1.0);
- texColor.rgb = lerp(fogColor.rgb, texColor.rgb, vFog);
- }
-
- return texColor;
-}
diff --git a/deps/vitaGL/shaders/texture2d_rgba_v.cg b/deps/vitaGL/shaders/texture2d_rgba_v.cg
deleted file mode 100644
index a1bf531855..0000000000
--- a/deps/vitaGL/shaders/texture2d_rgba_v.cg
+++ /dev/null
@@ -1,27 +0,0 @@
-void main(
- float3 position,
- float2 texcoord,
- float4 color,
- column_major uniform float4x4 wvp,
- uniform int clip_plane0, // In the future this can turn into an array to support other planes
- uniform float4 clip_plane0_eq, // In the future this can turn into an array to support other planes
- uniform float4x4 modelview,
- float4 out vPosition : POSITION,
- float2 out vTexcoord : TEXCOORD0,
- float4 out vColor : COLOR,
- float out vClip : CLP0)
-{
- float4 pos4 = float4(position, 1.f);
-
- // User clip planes
- if (clip_plane0 < 1) {
- vClip = 1.f;
- } else {
- float4 modelpos = mul(modelview, pos4);
- vClip = dot(modelpos, clip_plane0_eq);
- }
-
- vPosition = mul(pos4, wvp);
- vTexcoord = texcoord;
- vColor = color;
-}
diff --git a/deps/vitaGL/shaders/texture2d_v.cg b/deps/vitaGL/shaders/texture2d_v.cg
deleted file mode 100644
index 5111a38ab3..0000000000
--- a/deps/vitaGL/shaders/texture2d_v.cg
+++ /dev/null
@@ -1,24 +0,0 @@
-void main(
- float3 position,
- float2 texcoord,
- column_major uniform float4x4 wvp,
- uniform int clip_plane0, // In the future this can turn into an array to support other planes
- uniform float4 clip_plane0_eq, // In the future this can turn into an array to support other planes
- uniform float4x4 modelview,
- float4 out vPosition : POSITION,
- float2 out vTexcoord : TEXCOORD0,
- float out vClip : CLP0)
-{
- float4 pos4 = float4(position, 1.f);
-
- // User clip planes
- if (clip_plane0 < 1) {
- vClip = 1.f;
- } else {
- float4 modelpos = mul(modelview, pos4);
- vClip = dot(modelpos, clip_plane0_eq);
- }
-
- vPosition = mul(pos4, wvp);
- vTexcoord = texcoord;
-}
diff --git a/deps/vitaGL/source/custom_shaders.c b/deps/vitaGL/source/custom_shaders.c
deleted file mode 100644
index 398cb2a8c3..0000000000
--- a/deps/vitaGL/source/custom_shaders.c
+++ /dev/null
@@ -1,788 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * custom_shaders.c:
- * Implementation for custom shaders feature
- */
-
-#include "shared.h"
-
-#define MAX_CUSTOM_SHADERS 128 // Maximum number of linkable custom shaders
-#define MAX_SHADER_PARAMS 8 // Maximum number of parameters per custom shader
-
-// Internal stuffs
-void *frag_uniforms = NULL;
-void *vert_uniforms = NULL;
-uint8_t use_shark = 1; // Flag to check if vitaShaRK should be initialized at vitaGL boot
-uint8_t is_shark_online = 0; // Current vitaShaRK status
-
-#ifdef HAVE_SHARK
-// Internal runtime shader compiler settings
-static int32_t compiler_fastmath = 0;
-static int32_t compiler_fastprecision = 0;
-static int32_t compiler_fastint = 0;
-static shark_opt compiler_opts = SHARK_OPT_DEFAULT;
-#endif
-
-GLuint cur_program = 0; // Current in use custom program (0 = No custom program)
-
-// Uniform struct
-typedef struct uniform {
- GLboolean isVertex;
- const SceGxmProgramParameter *ptr;
- void *chain;
-} uniform;
-
-// Generic shader struct
-typedef struct shader {
- GLenum type;
- GLboolean valid;
- SceGxmShaderPatcherId id;
- const SceGxmProgram *prog;
- uint32_t size;
- char *log;
-} shader;
-
-// Program struct holding vertex/fragment shader info
-typedef struct program {
- shader *vshader;
- shader *fshader;
- GLboolean valid;
- SceGxmVertexAttribute attr[MAX_SHADER_PARAMS];
- SceGxmVertexStream stream[MAX_SHADER_PARAMS];
- SceGxmVertexProgram *vprog;
- SceGxmFragmentProgram *fprog;
- GLuint attr_num;
- GLuint stream_num;
- const SceGxmProgramParameter *wvp;
- uniform *uniforms;
- uniform *last_uniform;
-} program;
-
-// Internal shaders array
-static shader shaders[MAX_CUSTOM_SHADERS];
-
-// Internal programs array
-static program progs[MAX_CUSTOM_SHADERS / 2];
-
-void resetCustomShaders(void) {
- // Init custom shaders
- int i;
- for (i = 0; i < MAX_CUSTOM_SHADERS; i++) {
- shaders[i].valid = 0;
- shaders[i].log = NULL;
- progs[i >> 1].valid = 0;
- }
-}
-
-void changeCustomShadersBlend(SceGxmBlendInfo *blend_info) {
- int j;
- for (j = 0; j < MAX_CUSTOM_SHADERS / 2; j++) {
- program *p = &progs[j];
- if (p->valid) {
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- p->fshader->id,
- SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa_mode,
- blend_info,
- p->vshader->prog,
- &p->fprog);
- }
- }
-}
-
-void reloadCustomShader(void) {
- if (cur_program == 0)
- return;
- program *p = &progs[cur_program - 1];
- sceGxmSetVertexProgram(gxm_context, p->vprog);
- sceGxmSetFragmentProgram(gxm_context, p->fprog);
- vert_uniforms = NULL;
- frag_uniforms = NULL;
-}
-
-void _vglDrawObjects_CustomShadersIMPL(GLenum mode, GLsizei count, GLboolean implicit_wvp) {
- if (implicit_wvp) {
- program *p = &progs[cur_program - 1];
- if (mvp_modified) {
- matrix4x4_multiply(mvp_matrix, projection_matrix, modelview_matrix);
- mvp_modified = GL_FALSE;
- }
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- if (p->wvp == NULL)
- p->wvp = sceGxmProgramFindParameterByName(p->vshader->prog, "wvp");
- sceGxmSetUniformDataF(vert_uniforms, p->wvp, 0, 16, (const float *)mvp_matrix);
- }
-}
-
-#if defined(HAVE_SHARK) && defined(HAVE_SHARK_LOG)
-static char *shark_log = NULL;
-void shark_log_cb(const char *msg, shark_log_level msg_level, int line) {
- uint8_t append = shark_log != NULL;
- char newline[1024];
- switch (msg_level) {
- case SHARK_LOG_INFO:
- sprintf(newline, "%sI] %s on line %d", append ? "\n" : "", msg, line);
- break;
- case SHARK_LOG_WARNING:
- sprintf(newline, "%sW] %s on line %d", append ? "\n" : "", msg, line);
- break;
- case SHARK_LOG_ERROR:
- sprintf(newline, "%sE] %s on line %d", append ? "\n" : "", msg, line);
- break;
- }
- uint32_t size = (append ? strlen(shark_log) : 0) + strlen(newline);
- shark_log = realloc(shark_log, size + 1);
- if (append)
- sprintf(shark_log, "%s%s", shark_log, newline);
- else
- strcpy(shark_log, newline);
-}
-#endif
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-void vglSetupRuntimeShaderCompiler(shark_opt opt_level, int32_t use_fastmath, int32_t use_fastprecision, int32_t use_fastint) {
-#ifdef HAVE_SHARK
- compiler_opts = opt_level;
- compiler_fastmath = use_fastmath;
- compiler_fastprecision = use_fastprecision;
- compiler_fastint = use_fastint;
-#endif
-}
-
-void vglEnableRuntimeShaderCompiler(GLboolean usage) {
- use_shark = usage;
-}
-
-GLuint glCreateShader(GLenum shaderType) {
- // Looking for a free shader slot
- GLuint i, res = 0;
- for (i = 1; i < MAX_CUSTOM_SHADERS; i++) {
- if (!(shaders[i - 1].valid)) {
- res = i;
- break;
- }
- }
-
- // All shader slots are busy, exiting call
- if (res == 0)
- return res;
-
- // Reserving and initializing shader slot
- switch (shaderType) {
- case GL_FRAGMENT_SHADER:
- shaders[res - 1].type = GL_FRAGMENT_SHADER;
- break;
- case GL_VERTEX_SHADER:
- shaders[res - 1].type = GL_VERTEX_SHADER;
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- return 0;
- break;
- }
- shaders[res - 1].valid = GL_TRUE;
-
- return res;
-}
-
-void glGetShaderiv(GLuint handle, GLenum pname, GLint *params) {
- // Grabbing passed shader
- shader *s = &shaders[handle - 1];
-
- switch (pname) {
- case GL_SHADER_TYPE:
- *params = s->type;
- break;
- case GL_COMPILE_STATUS:
- *params = s->prog ? GL_TRUE : GL_FALSE;
- break;
- case GL_INFO_LOG_LENGTH:
- *params = s->log ? strlen(s->log) : 0;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glGetShaderInfoLog(GLuint handle, GLsizei maxLength, GLsizei *length, GLchar *infoLog) {
-#ifndef SKIP_ERROR_HANDLING
- if (maxLength < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Grabbing passed shader
- shader *s = &shaders[handle - 1];
-
- if (s->log) {
- *length = min(strlen(s->log), maxLength);
- memcpy_neon(infoLog, s->log, *length);
- }
-}
-
-void glShaderSource(GLuint handle, GLsizei count, const GLchar *const *string, const GLint *length) {
-#ifndef SKIP_ERROR_HANDLING
- if (count < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- if (!is_shark_online) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-
- // Grabbing passed shader
- shader *s = &shaders[handle - 1];
-
- // Temporarily setting prog to point to the shader source
- s->prog = (SceGxmProgram *)*string;
- s->size = length ? *length : strlen(*string);
-}
-
-void glShaderBinary(GLsizei count, const GLuint *handles, GLenum binaryFormat, const void *binary, GLsizei length) {
- // Grabbing passed shader
- shader *s = &shaders[handles[0] - 1];
-
- // Allocating compiled shader on RAM and registering it into sceGxmShaderPatcher
- s->prog = (SceGxmProgram *)malloc(length);
- memcpy_neon((void *)s->prog, binary, length);
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, s->prog, &s->id);
- s->prog = sceGxmShaderPatcherGetProgramFromId(s->id);
-}
-
-uint8_t shader_idxs = 0;
-void glCompileShader(GLuint handle) {
- // If vitaShaRK is not enabled, we just error out
- if (!is_shark_online) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#ifdef HAVE_SHARK
- // Grabbing passed shader
- shader *s = &shaders[handle - 1];
-
- // Compiling shader source
- s->prog = shark_compile_shader_extended((const char *)s->prog, &s->size, s->type == GL_FRAGMENT_SHADER ? SHARK_FRAGMENT_SHADER : SHARK_VERTEX_SHADER, compiler_opts, compiler_fastmath, compiler_fastprecision, compiler_fastint);
- if (s->prog) {
- SceGxmProgram *res = (SceGxmProgram *)malloc(s->size);
- memcpy_neon((void *)res, (void *)s->prog, s->size);
- s->prog = res;
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, s->prog, &s->id);
- s->prog = sceGxmShaderPatcherGetProgramFromId(s->id);
- }
-#ifdef HAVE_SHARK_LOG
- s->log = shark_log;
- shark_log = NULL;
-#endif
- shark_clear_output();
-#endif
-}
-
-void glDeleteShader(GLuint shad) {
- // Grabbing passed shader
- shader *s = &shaders[shad - 1];
-
- // Deallocating shader and unregistering it from sceGxmShaderPatcher
- if (s->valid) {
- sceGxmShaderPatcherForceUnregisterProgram(gxm_shader_patcher, s->id);
- free((void *)s->prog);
- if (s->log)
- free(s->log);
- }
- s->log = NULL;
- s->valid = GL_FALSE;
-}
-
-void glAttachShader(GLuint prog, GLuint shad) {
- // Grabbing passed shader and program
- shader *s = &shaders[shad - 1];
- program *p = &progs[prog - 1];
-
- // Attaching shader to desired program
- if (p->valid && s->valid) {
- switch (s->type) {
- case GL_VERTEX_SHADER:
- p->vshader = s;
- break;
- case GL_FRAGMENT_SHADER:
- p->fshader = s;
- break;
- default:
- break;
- }
- } else {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-}
-
-GLuint glCreateProgram(void) {
- // Looking for a free program slot
- GLuint i, res = 0;
- for (i = 1; i < (MAX_CUSTOM_SHADERS / 2); i++) {
- // Program slot found, reserving and initializing it
- if (!(progs[i - 1].valid)) {
- res = i;
- progs[i - 1].valid = GL_TRUE;
- progs[i - 1].attr_num = 0;
- progs[i - 1].wvp = NULL;
- progs[i - 1].uniforms = NULL;
- progs[i - 1].last_uniform = NULL;
- break;
- }
- }
- return res;
-}
-
-void glDeleteProgram(GLuint prog) {
- // Grabbing passed program
- program *p = &progs[prog - 1];
-
- // Releasing both vertex and fragment programs from sceGxmShaderPatcher
- if (p->valid) {
- unsigned int count, i;
- sceGxmShaderPatcherGetFragmentProgramRefCount(gxm_shader_patcher, p->fprog, &count);
- for (i = 0; i < count; i++) {
- sceGxmShaderPatcherReleaseFragmentProgram(gxm_shader_patcher, p->fprog);
- sceGxmShaderPatcherReleaseVertexProgram(gxm_shader_patcher, p->vprog);
- }
- while (p->uniforms != NULL) {
- uniform *old = p->uniforms;
- p->uniforms = (uniform *)p->uniforms->chain;
- free(old);
- }
- }
- p->valid = GL_FALSE;
-}
-
-void glLinkProgram(GLuint progr) {
- // Grabbing passed program
- program *p = &progs[progr - 1];
-
- // Creating fragment and vertex program via sceGxmShaderPatcher
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- p->vshader->id, p->attr, p->attr_num,
- p->stream, p->stream_num, &p->vprog);
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- p->fshader->id, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa_mode, NULL, p->vshader->prog,
- &p->fprog);
-}
-
-void glUseProgram(GLuint prog) {
- // Setting current custom program to passed program
- cur_program = prog;
-
- // Setting in-use vertex and fragment program in sceGxm
- reloadCustomShader();
-}
-
-GLint glGetUniformLocation(GLuint prog, const GLchar *name) {
- // Grabbing passed program
- program *p = &progs[prog - 1];
-
- uniform *res = (uniform *)malloc(sizeof(uniform));
- res->chain = NULL;
-
- // Checking if parameter is a vertex or fragment related one
- res->ptr = sceGxmProgramFindParameterByName(p->vshader->prog, name);
- res->isVertex = GL_TRUE;
- if (res->ptr == NULL) {
- res->ptr = sceGxmProgramFindParameterByName(p->fshader->prog, name);
- res->isVertex = GL_FALSE;
- }
-
- if (res->ptr == NULL) {
- free(res);
- return -1;
- }
-
- if (p->last_uniform != NULL)
- p->last_uniform->chain = (void *)res;
- p->last_uniform = res;
-
- return (GLint)res;
-}
-
-void glUniform1i(GLint location, GLint v0) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- float v0_f = (float)v0;
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 1, &v0_f);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- float v0_f = (float)v0;
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 1, &v0_f);
- }
-}
-
-void glUniform2i(GLint location, GLint v0, GLint v1) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- float v0_f[2];
- v0_f[0] = (float)v0;
- v0_f[1] = (float)v1;
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 2, v0_f);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- float v0_f[2];
- v0_f[0] = (float)v0;
- v0_f[1] = (float)v1;
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 2, v0_f);
- }
-}
-
-void glUniform1f(GLint location, GLfloat v0) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 1, &v0);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 1, &v0);
- }
-}
-
-void glUniform2f(GLint location, GLfloat v0, GLfloat v1) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- float v0_f[2];
- v0_f[0] = v0;
- v0_f[1] = v1;
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 2, v0_f);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- float v0_f[2];
- v0_f[0] = v0;
- v0_f[1] = v1;
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 2, v0_f);
- }
-}
-
-void glUniform2fv(GLint location, GLsizei count, const GLfloat *value) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 2 * count, value);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 2 * count, value);
- }
-}
-
-void glUniform3fv(GLint location, GLsizei count, const GLfloat *value) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 3 * count, value);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 3 * count, value);
- }
-}
-
-void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- float v[4] = { v0, v1, v2, v3 };
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 4, v);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 4, v);
- }
-}
-
-void glUniform4fv(GLint location, GLsizei count, const GLfloat *value) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 4 * count, value);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 4 * count, value);
- }
-}
-
-void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
- // Checking if the uniform does exist
- if (location == -1)
- return;
-
- // Grabbing passed uniform
- uniform *u = (uniform *)location;
- if (u->ptr == NULL)
- return;
-
- // Setting passed value to desired uniform
- if (u->isVertex) {
- if (vert_uniforms == NULL)
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vert_uniforms);
- sceGxmSetUniformDataF(vert_uniforms, u->ptr, 0, 16 * count, value);
- } else {
- if (frag_uniforms == NULL)
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &frag_uniforms);
- sceGxmSetUniformDataF(frag_uniforms, u->ptr, 0, 16 * count, value);
- }
-}
-
-/*
- * ------------------------------
- * - VGL_EXT_gxp_shaders -
- * ------------------------------
- */
-
-// Equivalent of glBindAttribLocation but for sceGxm architecture
-void vglBindAttribLocation(GLuint prog, GLuint index, const GLchar *name, const GLuint num, const GLenum type) {
- // Grabbing passed program
- program *p = &progs[prog - 1];
- SceGxmVertexAttribute *attributes = &p->attr[index];
- SceGxmVertexStream *streams = &p->stream[index];
-
- // Looking for desired parameter in requested program
- const SceGxmProgramParameter *param = sceGxmProgramFindParameterByName(p->vshader->prog, name);
- if (param == NULL)
- return;
-
- // Setting stream index and offset values
- attributes->streamIndex = index;
- attributes->offset = 0;
-
- // Detecting attribute format and size
- int bpe;
- switch (type) {
- case GL_FLOAT:
- attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- bpe = sizeof(float);
- break;
- case GL_SHORT:
- attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_S16N;
- bpe = sizeof(int16_t);
- break;
- case GL_UNSIGNED_BYTE:
- attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
- bpe = sizeof(uint8_t);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Setting various info about the stream
- attributes->componentCount = num;
- attributes->regIndex = sceGxmProgramParameterGetResourceIndex(param);
- streams->stride = bpe * num;
- streams->indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- if (index >= p->attr_num) {
- p->attr_num = index + 1;
- p->stream_num = index + 1;
- }
-}
-
-// Equivalent of glBindAttribLocation but for sceGxm architecture when packed attributes are used
-GLint vglBindPackedAttribLocation(GLuint prog, const GLchar *name, const GLuint num, const GLenum type, GLuint offset, GLint stride) {
- // Grabbing passed program
- program *p = &progs[prog - 1];
- SceGxmVertexAttribute *attributes = &p->attr[p->attr_num];
- SceGxmVertexStream *streams = &p->stream[0];
-
- // Looking for desired parameter in requested program
- const SceGxmProgramParameter *param = sceGxmProgramFindParameterByName(p->vshader->prog, name);
- if (param == NULL)
- return GL_FALSE;
-
- // Setting stream index and offset values
- attributes->streamIndex = 0;
- attributes->offset = offset;
-
- // Detecting attribute format and size
- int bpe;
- switch (type) {
- case GL_FLOAT:
- attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- bpe = sizeof(float);
- break;
- case GL_SHORT:
- attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_S16N;
- bpe = sizeof(int16_t);
- break;
- case GL_UNSIGNED_BYTE:
- attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
- bpe = sizeof(uint8_t);
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- return GL_FALSE;
- break;
- }
-
- // Setting various info about the stream
- attributes->componentCount = num;
- attributes->regIndex = sceGxmProgramParameterGetResourceIndex(param);
- streams->stride = stride ? stride : bpe * num;
- streams->indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- p->stream_num = 1;
- p->attr_num++;
-
- return GL_TRUE;
-}
-
-// Equivalent of glVertexAttribPointer but for sceGxm architecture
-void vglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint count, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (stride < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Detecting type size
- int bpe;
- switch (type) {
- case GL_FLOAT:
- bpe = sizeof(GLfloat);
- break;
- case GL_SHORT:
- bpe = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Allocating enough memory on vitaGL mempool
- void *ptr = gpu_pool_memalign(count * bpe * size, bpe * size);
-
- // Copying passed data to vitaGL mempool
- if (stride == 0)
- memcpy_neon(ptr, pointer, count * bpe * size); // Faster if stride == 0
- else {
- int i;
- uint8_t *dst = (uint8_t *)ptr;
- uint8_t *src = (uint8_t *)pointer;
- for (i = 0; i < count; i++) {
- memcpy_neon(dst, src, bpe * size);
- dst += (bpe * size);
- src += stride;
- }
- }
-
- // Setting vertex stream to passed index in sceGxm
- sceGxmSetVertexStream(gxm_context, index, ptr);
-}
-
-void vglVertexAttribPointerMapped(GLuint index, const GLvoid *pointer) {
- // Setting vertex stream to passed index in sceGxm
- sceGxmSetVertexStream(gxm_context, index, pointer);
-}
diff --git a/deps/vitaGL/source/framebuffers.c b/deps/vitaGL/source/framebuffers.c
deleted file mode 100644
index a93ad24148..0000000000
--- a/deps/vitaGL/source/framebuffers.c
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * framebuffers.c:
- * Implementation for framebuffers related functions
- */
-
-#include "shared.h"
-
-static framebuffer framebuffers[BUFFERS_NUM]; // Framebuffers array
-
-framebuffer *active_read_fb = NULL; // Current readback framebuffer in use
-framebuffer *active_write_fb = NULL; // Current write framebuffer in use
-
-uint32_t get_color_from_texture(uint32_t type) {
- uint32_t res = 0;
- switch (type) {
- case GL_RGB:
- res = SCE_GXM_COLOR_FORMAT_U8U8U8_BGR;
- break;
- case GL_RGBA:
- res = SCE_GXM_COLOR_FORMAT_U8U8U8U8_ABGR;
- break;
- case GL_LUMINANCE:
- res = SCE_GXM_COLOR_FORMAT_U8_R;
- break;
- case GL_LUMINANCE_ALPHA:
- res = SCE_GXM_COLOR_FORMAT_U8U8_GR;
- break;
- case GL_INTENSITY:
- res = SCE_GXM_COLOR_FORMAT_U8_R;
- break;
- case GL_ALPHA:
- res = SCE_GXM_COLOR_FORMAT_U8_A;
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- break;
- }
- return res;
-}
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void glGenFramebuffers(GLsizei n, GLuint *ids) {
- int i = 0, j = 0;
-#ifndef SKIP_ERROR_HANDLING
- if (n < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- for (i = 0; i < BUFFERS_NUM; i++) {
- if (!framebuffers[i].active) {
- ids[j++] = (GLuint)&framebuffers[i];
- framebuffers[i].active = 1;
- framebuffers[i].depth_buffer_addr = NULL;
- framebuffers[i].stencil_buffer_addr = NULL;
- }
- if (j >= n)
- break;
- }
-}
-
-void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers) {
-#ifndef SKIP_ERROR_HANDLING
- if (n < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- while (n > 0) {
- framebuffer *fb = (framebuffer *)framebuffers[n--];
- if (fb) {
- fb->active = 0;
- if (fb->target) {
- sceGxmDestroyRenderTarget(fb->target);
- fb->target = NULL;
- }
- if (fb->depth_buffer_addr) {
- vgl_mem_free(fb->depth_buffer_addr, fb->depth_buffer_mem_type);
- vgl_mem_free(fb->stencil_buffer_addr, fb->stencil_buffer_mem_type);
- fb->depth_buffer_addr = NULL;
- fb->stencil_buffer_addr = NULL;
- }
- }
- }
-}
-
-void glBindFramebuffer(GLenum target, GLuint fb) {
- switch (target) {
- case GL_DRAW_FRAMEBUFFER:
- active_write_fb = (framebuffer *)fb;
- break;
- case GL_READ_FRAMEBUFFER:
- active_read_fb = (framebuffer *)fb;
- break;
- case GL_FRAMEBUFFER:
- active_write_fb = active_read_fb = (framebuffer *)fb;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glFramebufferTexture(GLenum target, GLenum attachment, GLuint tex_id, GLint level) {
- // Detecting requested framebuffer
- framebuffer *fb = NULL;
- switch (target) {
- case GL_DRAW_FRAMEBUFFER:
- case GL_FRAMEBUFFER:
- fb = active_write_fb;
- break;
- case GL_READ_FRAMEBUFFER:
- fb = active_read_fb;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Aliasing to make code more readable
- texture *tex = &vgl_textures[tex_id];
-
- // Extracting texture sizes
- fb->width = sceGxmTextureGetWidth(&tex->gxm_tex);
- fb->height = sceGxmTextureGetHeight(&tex->gxm_tex);
-
- // Detecting requested attachment
- switch (attachment) {
- case GL_COLOR_ATTACHMENT0:
-
- // Allocating colorbuffer
- sceGxmColorSurfaceInit(
- &fb->colorbuffer,
- get_color_from_texture(tex->type),
- SCE_GXM_COLOR_SURFACE_LINEAR,
- msaa_mode == SCE_GXM_MULTISAMPLE_NONE ? SCE_GXM_COLOR_SURFACE_SCALE_NONE : SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE,
- SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
- fb->width,
- fb->height,
- fb->width,
- sceGxmTextureGetData(&tex->gxm_tex));
-
- // Allocating depth and stencil buffer (FIXME: This probably shouldn't be here)
- initDepthStencilBuffer(fb->width, fb->height, &fb->depthbuffer, &fb->depth_buffer_addr, &fb->stencil_buffer_addr, &fb->depth_buffer_mem_type, &fb->stencil_buffer_mem_type);
-
- // Creating rendertarget
- SceGxmRenderTargetParams renderTargetParams;
- memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
- renderTargetParams.flags = 0;
- renderTargetParams.width = sceGxmTextureGetWidth(&tex->gxm_tex);
- renderTargetParams.height = sceGxmTextureGetHeight(&tex->gxm_tex);
- renderTargetParams.scenesPerFrame = 1;
- renderTargetParams.multisampleMode = msaa_mode;
- renderTargetParams.multisampleLocations = 0;
- renderTargetParams.driverMemBlock = -1;
- sceGxmCreateRenderTarget(&renderTargetParams, &fb->target);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-/* vgl* */
-
-void vglTexImageDepthBuffer(GLenum target) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- switch (target) {
- case GL_TEXTURE_2D:
- {
- if (active_read_fb)
- sceGxmTextureInitLinear(&tex->gxm_tex, active_read_fb->depth_buffer_addr, SCE_GXM_TEXTURE_FORMAT_DF32M, active_read_fb->width, active_read_fb->height, 0);
- else
- sceGxmTextureInitLinear(&tex->gxm_tex, gxm_depth_surface_addr, SCE_GXM_TEXTURE_FORMAT_DF32M, DISPLAY_WIDTH, DISPLAY_HEIGHT, 0);
- tex->valid = 1;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
diff --git a/deps/vitaGL/source/get_info.c b/deps/vitaGL/source/get_info.c
deleted file mode 100644
index 1ad8a4a1ae..0000000000
--- a/deps/vitaGL/source/get_info.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * get_info.c:
- * Implementation for functions returning info to end user
- */
-
-#include "shared.h"
-
-// Constants returned by glGetString
-static const GLubyte *vendor = "Rinnegatamante";
-static const GLubyte *renderer = "SGX543MP4+";
-static const GLubyte *version = "VitaGL 1.0";
-static const GLubyte *extensions = "VGL_EXT_gpu_objects_array VGL_EXT_gxp_shaders";
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-const GLubyte *glGetString(GLenum name) {
- switch (name) {
- case GL_VENDOR: // Vendor
- return vendor;
- break;
- case GL_RENDERER: // Renderer
- return renderer;
- break;
- case GL_VERSION: // openGL Version
- return version;
- break;
- case GL_EXTENSIONS: // Supported extensions
- return extensions;
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- return NULL;
- break;
- }
-}
-
-void glGetBooleanv(GLenum pname, GLboolean *params) {
- switch (pname) {
- case GL_BLEND: // Blending feature state
- *params = blend_state;
- break;
- case GL_BLEND_DST_ALPHA: // Blend Alpha Factor for Destination
- *params = (blend_dfactor_a == SCE_GXM_BLEND_FACTOR_ZERO) ? GL_FALSE : GL_TRUE;
- break;
- case GL_BLEND_DST_RGB: // Blend RGB Factor for Destination
- *params = (blend_dfactor_rgb == SCE_GXM_BLEND_FACTOR_ZERO) ? GL_FALSE : GL_TRUE;
- break;
- case GL_BLEND_SRC_ALPHA: // Blend Alpha Factor for Source
- *params = (blend_sfactor_a == SCE_GXM_BLEND_FACTOR_ZERO) ? GL_FALSE : GL_TRUE;
- break;
- case GL_BLEND_SRC_RGB: // Blend RGB Factor for Source
- *params = (blend_sfactor_rgb == SCE_GXM_BLEND_FACTOR_ZERO) ? GL_FALSE : GL_TRUE;
- break;
- case GL_DEPTH_TEST: // Depth test state
- *params = depth_test_state;
- break;
- case GL_ACTIVE_TEXTURE: // Active texture
- *params = GL_FALSE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glGetFloatv(GLenum pname, GLfloat *data) {
- int i, j;
- switch (pname) {
- case GL_POLYGON_OFFSET_FACTOR: // Polygon offset factor
- *data = pol_factor;
- break;
- case GL_POLYGON_OFFSET_UNITS: // Polygon offset units
- *data = pol_units;
- break;
- case GL_MODELVIEW_MATRIX: // Modelview matrix
- // Since we use column-major matrices internally, wee need to transpose it before returning it to the application
- for (i = 0; i < 4; i++) {
- for (j = 0; j < 4; j++) {
- data[i * 4 + j] = modelview_matrix[j][i];
- }
- }
- break;
- case GL_PROJECTION_MATRIX: // Projection matrix
- // Since we use column-major matrices internally, wee need to transpose it before returning it to the application
- for (i = 0; i < 4; i++) {
- for (j = 0; j < 4; j++) {
- data[i * 4 + j] = projection_matrix[j][i];
- }
- }
- break;
- case GL_ACTIVE_TEXTURE: // Active texture
- *data = (1.0f * (server_texture_unit + GL_TEXTURE0));
- break;
- case GL_MAX_MODELVIEW_STACK_DEPTH: // Max modelview stack depth
- *data = MODELVIEW_STACK_DEPTH;
- break;
- case GL_MAX_PROJECTION_STACK_DEPTH: // Max projection stack depth
- *data = GENERIC_STACK_DEPTH;
- break;
- case GL_MAX_TEXTURE_STACK_DEPTH: // Max texture stack depth
- *data = GENERIC_STACK_DEPTH;
- break;
- case GL_DEPTH_BITS:
- *data = 32;
- break;
- case GL_STENCIL_BITS:
- *data = 8;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glGetIntegerv(GLenum pname, GLint *data) {
- // Aliasing to make code more readable
- texture_unit *server_tex_unit = &texture_units[server_texture_unit];
-
- switch (pname) {
- case GL_POLYGON_MODE:
- data[0] = gl_polygon_mode_front;
- data[1] = gl_polygon_mode_back;
- break;
- case GL_SCISSOR_BOX:
- data[0] = region.x;
- data[1] = region.y;
- data[2] = region.w;
- data[3] = region.h;
- break;
- case GL_TEXTURE_BINDING_2D:
- *data = server_tex_unit->tex_id;
- break;
- case GL_MAX_TEXTURE_SIZE:
- *data = 1024;
- break;
- case GL_VIEWPORT:
- data[0] = gl_viewport.x;
- data[1] = gl_viewport.y;
- data[2] = gl_viewport.w;
- data[3] = gl_viewport.h;
- break;
- case GL_DEPTH_BITS:
- data[0] = 32;
- break;
- case GL_STENCIL_BITS:
- data[0] = 8;
- break;
- case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
- *data = COMPRESSED_TEXTURE_FORMATS_NUM;
- break;
- case GL_COMPRESSED_TEXTURE_FORMATS:
- data[0] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
- data[1] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
- data[2] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
- data[3] = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
- data[4] = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
- data[5] = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
- data[6] = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
- data[7] = GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG;
- data[8] = GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-GLboolean glIsEnabled(GLenum cap) {
- GLboolean ret = GL_FALSE;
- switch (cap) {
- case GL_DEPTH_TEST:
- ret = depth_test_state;
- break;
- case GL_STENCIL_TEST:
- ret = stencil_test_state;
- break;
- case GL_BLEND:
- ret = blend_state;
- break;
- case GL_SCISSOR_TEST:
- ret = scissor_test_state;
- break;
- case GL_CULL_FACE:
- ret = cull_face_state;
- break;
- case GL_POLYGON_OFFSET_FILL:
- ret = pol_offset_fill;
- break;
- case GL_POLYGON_OFFSET_LINE:
- ret = pol_offset_line;
- break;
- case GL_POLYGON_OFFSET_POINT:
- ret = pol_offset_point;
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- break;
- }
- return ret;
-}
-
-GLenum glGetError(void) {
- GLenum ret = vgl_error;
- vgl_error = GL_NO_ERROR;
- return ret;
-}
diff --git a/deps/vitaGL/source/gxm.c b/deps/vitaGL/source/gxm.c
deleted file mode 100644
index 3851c9e27d..0000000000
--- a/deps/vitaGL/source/gxm.c
+++ /dev/null
@@ -1,477 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * gxm.c:
- * Implementation for setup and cleanup for sceGxm specific stuffs
- */
-
-#include "shared.h"
-
-static uint32_t gxm_param_buf_size = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE; // Param buffer size for sceGxm
-
-static void *vdm_ring_buffer_addr; // VDM ring buffer memblock starting address
-static void *vertex_ring_buffer_addr; // vertex ring buffer memblock starting address
-static void *fragment_ring_buffer_addr; // fragment ring buffer memblock starting address
-static void *fragment_usse_ring_buffer_addr; // fragment USSE ring buffer memblock starting address
-
-static SceGxmRenderTarget *gxm_render_target; // Display render target
-static SceGxmColorSurface gxm_color_surfaces[DISPLAY_BUFFER_COUNT]; // Display color surfaces
-void *gxm_color_surfaces_addr[DISPLAY_BUFFER_COUNT]; // Display color surfaces memblock starting addresses
-static SceGxmSyncObject *gxm_sync_objects[DISPLAY_BUFFER_COUNT]; // Display sync objects
-unsigned int gxm_front_buffer_index; // Display front buffer id
-unsigned int gxm_back_buffer_index; // Display back buffer id
-static unsigned int gxm_scene_flags = 0; // Current gxm scene flags
-
-static void *gxm_shader_patcher_buffer_addr; // Shader PAtcher buffer memblock starting address
-static void *gxm_shader_patcher_vertex_usse_addr; // Shader Patcher vertex USSE memblock starting address
-static void *gxm_shader_patcher_fragment_usse_addr; // Shader Patcher fragment USSE memblock starting address
-
-void *gxm_depth_surface_addr; // Depth surface memblock starting address
-static void *gxm_stencil_surface_addr; // Stencil surface memblock starting address
-static SceGxmDepthStencilSurface gxm_depth_stencil_surface; // Depth/Stencil surfaces setup for sceGxm
-
-static SceUID shared_fb; // In-use hared framebuffer identifier
-static SceSharedFbInfo shared_fb_info; // In-use shared framebuffer info struct
-
-SceGxmContext *gxm_context; // sceGxm context instance
-GLenum vgl_error = GL_NO_ERROR; // Error returned by glGetError
-SceGxmShaderPatcher *gxm_shader_patcher; // sceGxmShaderPatcher shader patcher instance
-
-matrix4x4 mvp_matrix; // ModelViewProjection Matrix
-matrix4x4 projection_matrix; // Projection Matrix
-matrix4x4 modelview_matrix; // ModelView Matrix
-
-int DISPLAY_WIDTH; // Display width in pixels
-int DISPLAY_HEIGHT; // Display height in pixels
-int DISPLAY_STRIDE; // Display stride in pixels
-float DISPLAY_WIDTH_FLOAT; // Display width in pixels (float)
-float DISPLAY_HEIGHT_FLOAT; // Display height in pixels (float)
-
-uint8_t system_app_mode = 0; // Flag for system app mode usage
-static uint8_t gxm_initialized = 0; // Current sceGxm state
-
-// sceDisplay callback data
-struct display_queue_callback_data {
- void *addr;
-};
-
-// sceGxmShaderPatcher custom allocator
-static void *shader_patcher_host_alloc_cb(void *user_data, unsigned int size) {
- return malloc(size);
-}
-
-// sceGxmShaderPatcher custom deallocator
-static void shader_patcher_host_free_cb(void *user_data, void *mem) {
- free(mem);
-}
-
-// sceDisplay callback
-static void display_queue_callback(const void *callbackData) {
- // Populating sceDisplay framebuffer parameters
- SceDisplayFrameBuf display_fb;
- const struct display_queue_callback_data *cb_data = callbackData;
- memset(&display_fb, 0, sizeof(SceDisplayFrameBuf));
- display_fb.size = sizeof(SceDisplayFrameBuf);
- display_fb.base = cb_data->addr;
- display_fb.pitch = DISPLAY_STRIDE;
- display_fb.pixelformat = SCE_DISPLAY_PIXELFORMAT_A8B8G8R8;
- display_fb.width = DISPLAY_WIDTH;
- display_fb.height = DISPLAY_HEIGHT;
-
- // Setting sceDisplay framebuffer
- sceDisplaySetFrameBuf(&display_fb, SCE_DISPLAY_SETBUF_NEXTFRAME);
-
- // Performing VSync if enabled
- if (vblank)
- sceDisplayWaitVblankStart();
-}
-
-void initGxm(void) {
- if (gxm_initialized)
- return;
-
- // Initializing runtime shader compiler
- if (use_shark) {
-#ifdef HAVE_SHARK
- if (shark_init(NULL) >= 0) {
- is_shark_online = 1;
-#ifdef HAVE_SHARK_LOG
- shark_install_log_cb(shark_log_cb);
- shark_set_warnings_level(SHARK_WARN_MAX);
-#endif
- } else
-#endif
- is_shark_online = 0;
- }
-
- // Checking if the running application is a system one
- SceAppMgrBudgetInfo info;
- info.size = sizeof(SceAppMgrBudgetInfo);
- if (!sceAppMgrGetBudgetInfo(&info))
- system_app_mode = 1;
-
- // Initializing sceGxm init parameters
- SceGxmInitializeParams gxm_init_params;
- memset(&gxm_init_params, 0, sizeof(SceGxmInitializeParams));
- gxm_init_params.flags = system_app_mode ? 0x0A : 0;
- gxm_init_params.displayQueueMaxPendingCount = DISPLAY_BUFFER_COUNT - 1;
- gxm_init_params.displayQueueCallback = display_queue_callback;
- gxm_init_params.displayQueueCallbackDataSize = sizeof(struct display_queue_callback_data);
- gxm_init_params.parameterBufferSize = gxm_param_buf_size;
-
- // Initializing sceGxm
- if (system_app_mode)
- sceGxmVshInitialize(&gxm_init_params);
- else
- sceGxmInitialize(&gxm_init_params);
- gxm_initialized = 1;
-}
-
-void initGxmContext(void) {
- vglMemType type = VGL_MEM_VRAM;
-
- // Allocating VDM ring buffer
- vdm_ring_buffer_addr = gpu_alloc_mapped(SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, &type);
-
- // Allocating vertex ring buffer
- vertex_ring_buffer_addr = gpu_alloc_mapped(SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, &type);
-
- // Allocating fragment ring buffer
- fragment_ring_buffer_addr = gpu_alloc_mapped(SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, &type);
-
- // Allocating fragment USSE ring buffer
- unsigned int fragment_usse_offset;
- fragment_usse_ring_buffer_addr = gpu_fragment_usse_alloc_mapped(
- SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE, &fragment_usse_offset);
-
- // Setting sceGxm context parameters
- SceGxmContextParams gxm_context_params;
- memset(&gxm_context_params, 0, sizeof(SceGxmContextParams));
- gxm_context_params.hostMem = malloc(SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE);
- gxm_context_params.hostMemSize = SCE_GXM_MINIMUM_CONTEXT_HOST_MEM_SIZE;
- gxm_context_params.vdmRingBufferMem = vdm_ring_buffer_addr;
- gxm_context_params.vdmRingBufferMemSize = SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE;
- gxm_context_params.vertexRingBufferMem = vertex_ring_buffer_addr;
- gxm_context_params.vertexRingBufferMemSize = SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE;
- gxm_context_params.fragmentRingBufferMem = fragment_ring_buffer_addr;
- gxm_context_params.fragmentRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE;
- gxm_context_params.fragmentUsseRingBufferMem = fragment_usse_ring_buffer_addr;
- gxm_context_params.fragmentUsseRingBufferMemSize = SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE;
- gxm_context_params.fragmentUsseRingBufferOffset = fragment_usse_offset;
-
- // Initializing sceGxm context
- sceGxmCreateContext(&gxm_context_params, &gxm_context);
-}
-
-void termGxmContext(void) {
- // Deallocating ring buffers
- vgl_mem_free(vdm_ring_buffer_addr, VGL_MEM_VRAM);
- vgl_mem_free(vertex_ring_buffer_addr, VGL_MEM_VRAM);
- vgl_mem_free(fragment_ring_buffer_addr, VGL_MEM_VRAM);
- gpu_fragment_usse_free_mapped(fragment_usse_ring_buffer_addr);
-
- // Destroying sceGxm context
- sceGxmDestroyContext(gxm_context);
-
- if (system_app_mode) {
- sceSharedFbBegin(shared_fb, &shared_fb_info);
- sceGxmUnmapMemory(shared_fb_info.fb_base);
- sceSharedFbEnd(shared_fb);
- sceSharedFbClose(shared_fb);
- }
-#ifdef HAVE_SHARK
- // Shutting down runtime shader compiler
- if (is_shark_online)
- shark_end();
-#endif
-}
-
-void createDisplayRenderTarget(void) {
- // Populating sceGxmRenderTarget parameters
- SceGxmRenderTargetParams render_target_params;
- memset(&render_target_params, 0, sizeof(SceGxmRenderTargetParams));
- render_target_params.flags = 0;
- render_target_params.width = DISPLAY_WIDTH;
- render_target_params.height = DISPLAY_HEIGHT;
- render_target_params.scenesPerFrame = 1;
- render_target_params.multisampleMode = msaa_mode;
- render_target_params.multisampleLocations = 0;
- render_target_params.driverMemBlock = -1;
-
- // Creating render target for the display
- sceGxmCreateRenderTarget(&render_target_params, &gxm_render_target);
-}
-
-void destroyDisplayRenderTarget(void) {
- // Destroying render target for the display
- sceGxmDestroyRenderTarget(gxm_render_target);
-}
-
-void initDisplayColorSurfaces(void) {
- // Getting access to the shared framebuffer on system app mode
- while (system_app_mode) {
- shared_fb = sceSharedFbOpen(1);
- memset(&shared_fb_info, 0, sizeof(SceSharedFbInfo));
- sceSharedFbGetInfo(shared_fb, &shared_fb_info);
- if (shared_fb_info.index == 1)
- sceSharedFbClose(shared_fb);
- else {
- sceGxmMapMemory(shared_fb_info.fb_base, shared_fb_info.fb_size, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE);
- gxm_color_surfaces_addr[0] = shared_fb_info.fb_base;
- gxm_color_surfaces_addr[1] = shared_fb_info.fb_base2;
- memset(&shared_fb_info, 0, sizeof(SceSharedFbInfo));
- break;
- }
- }
-
- vglMemType type = VGL_MEM_VRAM;
- int i;
- for (i = 0; i < DISPLAY_BUFFER_COUNT; i++) {
- // Allocating color surface memblock
- if (!system_app_mode) {
- gxm_color_surfaces_addr[i] = gpu_alloc_mapped(
- ALIGN(4 * DISPLAY_STRIDE * DISPLAY_HEIGHT, 1 * 1024 * 1024),
- &type);
- memset(gxm_color_surfaces_addr[i], 0, DISPLAY_STRIDE * DISPLAY_HEIGHT);
- }
-
- // Initializing allocated color surface
- sceGxmColorSurfaceInit(&gxm_color_surfaces[i],
- SCE_GXM_COLOR_FORMAT_A8B8G8R8,
- SCE_GXM_COLOR_SURFACE_LINEAR,
- msaa_mode == SCE_GXM_MULTISAMPLE_NONE ? SCE_GXM_COLOR_SURFACE_SCALE_NONE : SCE_GXM_COLOR_SURFACE_SCALE_MSAA_DOWNSCALE,
- SCE_GXM_OUTPUT_REGISTER_SIZE_32BIT,
- DISPLAY_WIDTH,
- DISPLAY_HEIGHT,
- DISPLAY_STRIDE,
- gxm_color_surfaces_addr[i]);
-
- // Creating a display sync object for the allocated color surface
- sceGxmSyncObjectCreate(&gxm_sync_objects[i]);
- }
-}
-
-void termDisplayColorSurfaces(void) {
- // Deallocating display's color surfaces and destroying sync objects
- int i;
- for (i = 0; i < DISPLAY_BUFFER_COUNT; i++) {
- if (!system_app_mode)
- vgl_mem_free(gxm_color_surfaces_addr[i], VGL_MEM_VRAM);
- sceGxmSyncObjectDestroy(gxm_sync_objects[i]);
- }
-}
-
-void initDepthStencilBuffer(uint32_t w, uint32_t h, SceGxmDepthStencilSurface *surface, void **depth_buffer, void **stencil_buffer, vglMemType *depth_type, vglMemType *stencil_type) {
- // Calculating sizes for depth and stencil surfaces
- unsigned int depth_stencil_width = ALIGN(w, SCE_GXM_TILE_SIZEX);
- unsigned int depth_stencil_height = ALIGN(h, SCE_GXM_TILE_SIZEY);
- unsigned int depth_stencil_samples = depth_stencil_width * depth_stencil_height;
- if (msaa_mode == SCE_GXM_MULTISAMPLE_2X)
- depth_stencil_samples = depth_stencil_samples * 2;
- else if (msaa_mode == SCE_GXM_MULTISAMPLE_4X)
- depth_stencil_samples = depth_stencil_samples * 4;
-
- // Allocating depth surface
- *depth_type = VGL_MEM_VRAM;
- *depth_buffer = gpu_alloc_mapped(4 * depth_stencil_samples, depth_type);
-
- // Allocating stencil surface
- *stencil_type = VGL_MEM_VRAM;
- *stencil_buffer = gpu_alloc_mapped(1 * depth_stencil_samples, stencil_type);
-
- // Initializing depth and stencil surfaces
- sceGxmDepthStencilSurfaceInit(surface,
- SCE_GXM_DEPTH_STENCIL_FORMAT_DF32M_S8,
- SCE_GXM_DEPTH_STENCIL_SURFACE_LINEAR,
- msaa_mode == SCE_GXM_MULTISAMPLE_4X ? depth_stencil_width * 2 : depth_stencil_width,
- *depth_buffer,
- *stencil_buffer);
-}
-
-void initDepthStencilSurfaces(void) {
- vglMemType t1, t2;
- initDepthStencilBuffer(DISPLAY_WIDTH, DISPLAY_HEIGHT, &gxm_depth_stencil_surface, &gxm_depth_surface_addr, &gxm_stencil_surface_addr, &t1, &t2);
-}
-
-void termDepthStencilSurfaces(void) {
- // Deallocating depth and stencil surfaces memblocks
- vgl_mem_free(gxm_depth_surface_addr, VGL_MEM_VRAM);
- vgl_mem_free(gxm_stencil_surface_addr, VGL_MEM_VRAM);
-}
-
-void startShaderPatcher(void) {
- // Constants for shader patcher buffers
- static const unsigned int shader_patcher_buffer_size = 1024 * 1024;
- static const unsigned int shader_patcher_vertex_usse_size = 1024 * 1024;
- static const unsigned int shader_patcher_fragment_usse_size = 1024 * 1024;
- vglMemType type = VGL_MEM_VRAM;
-
- // Allocating Shader Patcher buffer
- gxm_shader_patcher_buffer_addr = gpu_alloc_mapped(
- shader_patcher_buffer_size, &type);
-
- // Allocating Shader Patcher vertex USSE buffer
- unsigned int shader_patcher_vertex_usse_offset;
- gxm_shader_patcher_vertex_usse_addr = gpu_vertex_usse_alloc_mapped(
- shader_patcher_vertex_usse_size, &shader_patcher_vertex_usse_offset);
-
- // Allocating Shader Patcher fragment USSE buffer
- unsigned int shader_patcher_fragment_usse_offset;
- gxm_shader_patcher_fragment_usse_addr = gpu_fragment_usse_alloc_mapped(
- shader_patcher_fragment_usse_size, &shader_patcher_fragment_usse_offset);
-
- // Populating shader patcher parameters
- SceGxmShaderPatcherParams shader_patcher_params;
- memset(&shader_patcher_params, 0, sizeof(SceGxmShaderPatcherParams));
- shader_patcher_params.userData = NULL;
- shader_patcher_params.hostAllocCallback = shader_patcher_host_alloc_cb;
- shader_patcher_params.hostFreeCallback = shader_patcher_host_free_cb;
- shader_patcher_params.bufferAllocCallback = NULL;
- shader_patcher_params.bufferFreeCallback = NULL;
- shader_patcher_params.bufferMem = gxm_shader_patcher_buffer_addr;
- shader_patcher_params.bufferMemSize = shader_patcher_buffer_size;
- shader_patcher_params.vertexUsseAllocCallback = NULL;
- shader_patcher_params.vertexUsseFreeCallback = NULL;
- shader_patcher_params.vertexUsseMem = gxm_shader_patcher_vertex_usse_addr;
- shader_patcher_params.vertexUsseMemSize = shader_patcher_vertex_usse_size;
- shader_patcher_params.vertexUsseOffset = shader_patcher_vertex_usse_offset;
- shader_patcher_params.fragmentUsseAllocCallback = NULL;
- shader_patcher_params.fragmentUsseFreeCallback = NULL;
- shader_patcher_params.fragmentUsseMem = gxm_shader_patcher_fragment_usse_addr;
- shader_patcher_params.fragmentUsseMemSize = shader_patcher_fragment_usse_size;
- shader_patcher_params.fragmentUsseOffset = shader_patcher_fragment_usse_offset;
-
- // Creating shader patcher instance
- sceGxmShaderPatcherCreate(&shader_patcher_params, &gxm_shader_patcher);
-}
-
-void stopShaderPatcher(void) {
- // Destroying shader patcher instance
- sceGxmShaderPatcherDestroy(gxm_shader_patcher);
-
- // Freeing shader patcher buffers
- vgl_mem_free(gxm_shader_patcher_buffer_addr, VGL_MEM_VRAM);
- gpu_vertex_usse_free_mapped(gxm_shader_patcher_vertex_usse_addr);
- gpu_fragment_usse_free_mapped(gxm_shader_patcher_fragment_usse_addr);
-}
-
-void waitRenderingDone(void) {
- // Wait for rendering to be finished
- sceGxmDisplayQueueFinish();
- sceGxmFinish(gxm_context);
-}
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void vglSetParamBufferSize(uint32_t size) {
- gxm_param_buf_size = size;
-}
-
-void vglStartRendering(void) {
- // Starting drawing scene
- if (active_write_fb == NULL) { // Default framebuffer is used
- if (system_app_mode) {
- sceSharedFbBegin(shared_fb, &shared_fb_info);
- shared_fb_info.vsync = vblank;
- gxm_back_buffer_index = (shared_fb_info.index + 1) % 2;
- }
- sceGxmBeginScene(gxm_context, gxm_scene_flags, gxm_render_target,
- NULL, NULL,
- gxm_sync_objects[gxm_back_buffer_index],
- &gxm_color_surfaces[gxm_back_buffer_index],
- &gxm_depth_stencil_surface);
- gxm_scene_flags &= ~SCE_GXM_SCENE_VERTEX_WAIT_FOR_DEPENDENCY;
- } else {
- gxm_scene_flags |= SCE_GXM_SCENE_FRAGMENT_SET_DEPENDENCY;
- sceGxmBeginScene(gxm_context, gxm_scene_flags, active_write_fb->target,
- NULL, NULL, NULL,
- &active_write_fb->colorbuffer,
- &active_write_fb->depthbuffer);
- gxm_scene_flags |= SCE_GXM_SCENE_VERTEX_WAIT_FOR_DEPENDENCY;
- gxm_scene_flags &= ~SCE_GXM_SCENE_FRAGMENT_SET_DEPENDENCY;
- }
-
- // Setting back current viewport if enabled cause sceGxm will reset it at sceGxmEndScene call
- sceGxmSetViewport(gxm_context, x_port, x_scale, y_port, y_scale, z_port, z_scale);
-
- if (scissor_test_state)
- sceGxmSetRegionClip(gxm_context, SCE_GXM_REGION_CLIP_OUTSIDE, region.x, region.y, region.x + region.w - 1, region.y + region.h - 1);
- else
- sceGxmSetRegionClip(gxm_context, SCE_GXM_REGION_CLIP_OUTSIDE, 0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
-}
-
-void vglStopRenderingInit(void) {
- // Ending drawing scene
- sceGxmEndScene(gxm_context, NULL, NULL);
- if (system_app_mode && vblank)
- sceDisplayWaitVblankStart();
-}
-
-void vglStopRenderingTerm(void) {
- if (active_write_fb == NULL) { // Default framebuffer is used
- // Properly requesting a display update
- if (system_app_mode)
- sceSharedFbEnd(shared_fb);
- else {
- struct display_queue_callback_data queue_cb_data;
- queue_cb_data.addr = gxm_color_surfaces_addr[gxm_back_buffer_index];
- sceGxmDisplayQueueAddEntry(gxm_sync_objects[gxm_front_buffer_index],
- gxm_sync_objects[gxm_back_buffer_index], &queue_cb_data);
- gxm_front_buffer_index = gxm_back_buffer_index;
- gxm_back_buffer_index = (gxm_back_buffer_index + 1) % DISPLAY_BUFFER_COUNT;
- }
- }
-
- // Resetting vitaGL mempool
- gpu_pool_reset();
-}
-
-void vglStopRendering() {
- // Ending drawing scene
- vglStopRenderingInit();
-
- // Updating display and resetting vitaGL mempool
- vglStopRenderingTerm();
-}
-
-void vglUpdateCommonDialog() {
- // Populating SceCommonDialog parameters
- SceCommonDialogUpdateParam updateParam;
- memset(&updateParam, 0, sizeof(updateParam));
- updateParam.renderTarget.colorFormat = SCE_GXM_COLOR_FORMAT_A8B8G8R8;
- updateParam.renderTarget.surfaceType = SCE_GXM_COLOR_SURFACE_LINEAR;
- updateParam.renderTarget.width = DISPLAY_WIDTH;
- updateParam.renderTarget.height = DISPLAY_HEIGHT;
- updateParam.renderTarget.strideInPixels = DISPLAY_STRIDE;
- updateParam.renderTarget.colorSurfaceData = gxm_color_surfaces_addr[gxm_back_buffer_index];
- updateParam.renderTarget.depthSurfaceData = gxm_depth_surface_addr;
- updateParam.displaySyncObject = gxm_sync_objects[gxm_back_buffer_index];
-
- // Updating sceCommonDialog
- sceCommonDialogUpdate(&updateParam);
-}
-
-void glFinish(void) {
- // Waiting for GPU to finish drawing jobs
- sceGxmFinish(gxm_context);
-}
diff --git a/deps/vitaGL/source/hacks/memcpy_neon.S b/deps/vitaGL/source/hacks/memcpy_neon.S
deleted file mode 100644
index 2f1d33ebb7..0000000000
--- a/deps/vitaGL/source/hacks/memcpy_neon.S
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * NEON code contributed by Siarhei Siamashka .
- * Origin: http://sourceware.org/ml/libc-ports/2009-07/msg00003.html
- *
- * The GNU C Library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License.
- *
- * Tweaked for Android by Jim Huang
- */
-
-.arm
-.fpu neon
-
-@ void* memcpy_n(void *destination, const void *source, size_t num)
-.global memcpy_neon
-.type memcpy_neon, %function
-/*
- * ENABLE_UNALIGNED_MEM_ACCESSES macro can be defined to permit the use
- * of unaligned load/store memory accesses supported since ARMv6. This
- * will further improve performance, but can purely theoretically cause
- * problems if somebody decides to set SCTLR.A bit in the OS kernel
- * (to trap each unaligned memory access) or somehow mess with strongly
- * ordered/device memory.
- */
-#define ENABLE_UNALIGNED_MEM_ACCESSES 1
-
-#define NEON_MAX_PREFETCH_DISTANCE 320
-
-.align 4
-memcpy_neon:
- .fnstart
- mov ip, r0
- cmp r2, #16
- blt 4f @ Have less than 16 bytes to copy
-
- @ First ensure 16 byte alignment for the destination buffer
- tst r0, #0xF
- beq 2f
- tst r0, #1
- ldrneb r3, [r1], #1
- strneb r3, [ip], #1
- subne r2, r2, #1
- tst ip, #2
-#ifdef ENABLE_UNALIGNED_MEM_ACCESSES
- ldrneh r3, [r1], #2
- strneh r3, [ip], #2
-#else
- ldrneb r3, [r1], #1
- strneb r3, [ip], #1
- ldrneb r3, [r1], #1
- strneb r3, [ip], #1
-#endif
- subne r2, r2, #2
-
- tst ip, #4
- beq 1f
- vld4.8 {d0[0], d1[0], d2[0], d3[0]}, [r1]!
- vst4.8 {d0[0], d1[0], d2[0], d3[0]}, [ip, :32]!
- sub r2, r2, #4
-1:
- tst ip, #8
- beq 2f
- vld1.8 {d0}, [r1]!
- vst1.8 {d0}, [ip, :64]!
- sub r2, r2, #8
-2:
- subs r2, r2, #32
- blt 3f
- mov r3, #32
-
- @ Main copy loop, 32 bytes are processed per iteration.
- @ ARM instructions are used for doing fine-grained prefetch,
- @ increasing prefetch distance progressively up to
- @ NEON_MAX_PREFETCH_DISTANCE at runtime
-1:
- vld1.8 {d0-d3}, [r1]!
- cmp r3, #(NEON_MAX_PREFETCH_DISTANCE - 32)
- pld [r1, r3]
- addle r3, r3, #32
- vst1.8 {d0-d3}, [ip, :128]!
- sub r2, r2, #32
- cmp r2, r3
- bge 1b
- cmp r2, #0
- blt 3f
-1: @ Copy the remaining part of the buffer (already prefetched)
- vld1.8 {d0-d3}, [r1]!
- subs r2, r2, #32
- vst1.8 {d0-d3}, [ip, :128]!
- bge 1b
-3: @ Copy up to 31 remaining bytes
- tst r2, #16
- beq 4f
- vld1.8 {d0, d1}, [r1]!
- vst1.8 {d0, d1}, [ip, :128]!
-4:
- @ Use ARM instructions exclusively for the final trailing part
- @ not fully fitting into full 16 byte aligned block in order
- @ to avoid "ARM store after NEON store" hazard. Also NEON
- @ pipeline will be (mostly) flushed by the time when the
- @ control returns to the caller, making the use of NEON mostly
- @ transparent (and avoiding hazards in the caller code)
-
-#ifdef ENABLE_UNALIGNED_MEM_ACCESSES
- movs r3, r2, lsl #29
- ldrcs r3, [r1], #4
- strcs r3, [ip], #4
- ldrcs r3, [r1], #4
- strcs r3, [ip], #4
- ldrmi r3, [r1], #4
- strmi r3, [ip], #4
- movs r2, r2, lsl #31
- ldrcsh r3, [r1], #2
- strcsh r3, [ip], #2
- ldrmib r3, [r1], #1
- strmib r3, [ip], #1
-#else
- movs r3, r2, lsl #29
- bcc 1f
- .rept 8
- ldrcsb r3, [r1], #1
- strcsb r3, [ip], #1
- .endr
-1:
- bpl 1f
- .rept 4
- ldrmib r3, [r1], #1
- strmib r3, [ip], #1
- .endr
-1:
- movs r2, r2, lsl #31
- ldrcsb r3, [r1], #1
- strcsb r3, [ip], #1
- ldrcsb r3, [r1], #1
- strcsb r3, [ip], #1
- ldrmib r3, [r1], #1
- strmib r3, [ip], #1
-#endif
- bx lr
- .fnend
diff --git a/deps/vitaGL/source/hacks/sbrk.c b/deps/vitaGL/source/hacks/sbrk.c
deleted file mode 100644
index 828ce3ca39..0000000000
--- a/deps/vitaGL/source/hacks/sbrk.c
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * Copyright (c) 2016, 2017, 2018 vitasdk
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the copyright holder nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
- * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include
-#include
-#include
-
-extern unsigned int _newlib_heap_size_user __attribute__((weak));
-
-int _newlib_heap_memblock;
-unsigned _newlib_heap_size;
-static char *_newlib_heap_base, *_newlib_heap_end, *_newlib_heap_cur;
-static char _newlib_sbrk_mutex[32] __attribute__((aligned(8)));
-
-void *_sbrk_r(struct _reent *reent, ptrdiff_t incr) {
- if (sceKernelLockLwMutex((SceKernelLwMutexWork *)_newlib_sbrk_mutex, 1, 0) < 0)
- goto fail;
- if (!_newlib_heap_base || _newlib_heap_cur + incr >= _newlib_heap_end) {
- sceKernelUnlockLwMutex((SceKernelLwMutexWork *)_newlib_sbrk_mutex, 1);
- fail:
- reent->_errno = ENOMEM;
- return (void *)-1;
- }
-
- char *prev_heap_end = _newlib_heap_cur;
- _newlib_heap_cur += incr;
-
- sceKernelUnlockLwMutex((SceKernelLwMutexWork *)_newlib_sbrk_mutex, 1);
- return (void *)prev_heap_end;
-}
-
-void _init_vita_heap(void) {
- // Create a mutex to use inside _sbrk_r
- if (sceKernelCreateLwMutex((SceKernelLwMutexWork *)_newlib_sbrk_mutex, "sbrk mutex", 0, 0, 0) < 0) {
- goto failure;
- }
- if (&_newlib_heap_size_user != NULL) {
- _newlib_heap_size = _newlib_heap_size_user;
- } else {
- // Create a memblock for the heap memory, 32MB
- _newlib_heap_size = 32 * 1024 * 1024;
- }
- _newlib_heap_memblock = sceKernelAllocMemBlock("Newlib heap", 0x0c20d060, _newlib_heap_size, 0);
- if (_newlib_heap_memblock < 0) {
- goto failure;
- }
- if (sceKernelGetMemBlockBase(_newlib_heap_memblock, (void *)&_newlib_heap_base) < 0) {
- goto failure;
- }
- _newlib_heap_end = _newlib_heap_base + _newlib_heap_size;
- _newlib_heap_cur = _newlib_heap_base;
-
- return;
-failure:
- _newlib_heap_memblock = 0;
- _newlib_heap_base = 0;
- _newlib_heap_cur = 0;
-}
-
-void _free_vita_heap(void) {
- // Destroy the sbrk mutex
- sceKernelDeleteLwMutex((SceKernelLwMutexWork *)_newlib_sbrk_mutex);
-
- // Free the heap memblock to avoid memory leakage.
- sceKernelFreeMemBlock(_newlib_heap_memblock);
-
- _newlib_heap_memblock = 0;
- _newlib_heap_base = 0;
- _newlib_heap_cur = 0;
-}
diff --git a/deps/vitaGL/source/legacy.c b/deps/vitaGL/source/legacy.c
deleted file mode 100644
index 081cad03aa..0000000000
--- a/deps/vitaGL/source/legacy.c
+++ /dev/null
@@ -1,592 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * legacy.c:
- * Implementation for legacy openGL 1.0 rendering method
- */
-
-#include "shared.h"
-
-// Vertex list struct
-typedef struct vertexList {
- vector3f v;
- void *next;
-} vertexList;
-
-// Color vertex list struct
-typedef struct rgbaList {
- vector4f v;
- void *next;
-} rgbaList;
-
-// Texture coord list struct
-typedef struct uvList {
- vector2f v;
- void *next;
-} uvList;
-
-static vertexList *model_vertices = NULL; // Pointer to vertex list
-static vertexList *last_vert = NULL; // Pointer to last element in vertex list
-static rgbaList *model_color = NULL; // Pointer to color vertex list
-static rgbaList *last_clr = NULL; // Pointer to last element in color vertex list
-static uvList *model_uv = NULL; // Pointer to texcoord list
-static uvList *last_uv = NULL; // Pointer to last element in texcoord list
-static uint64_t vertex_count = 0; // Vertex counter for vertex list
-static SceGxmPrimitiveType prim; // Current in use primitive for rendering
-static SceGxmPrimitiveTypeExtra prim_extra = SCE_GXM_PRIMITIVE_NONE; // Current in use non native primitive for rendering
-static uint8_t np = 0xFF; // Number of expected vertices per element for current in use primitive
-
-vector4f current_color = { 1.0f, 1.0f, 1.0f, 1.0f }; // Current in use color
-
-static void purge_vertex_list() {
- vertexList *old;
- rgbaList *old2;
- uvList *old3;
-
- // Purging color and vertex lists
- while (model_vertices != NULL) {
- old = model_vertices;
- old2 = model_color;
- model_vertices = model_vertices->next;
- model_color = model_color->next;
- free(old);
- free(old2);
- }
-
- // Purging texcoord list
- while (model_uv != NULL) {
- old3 = model_uv;
- model_uv = model_uv->next;
- free(old3);
- }
-}
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase != MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Adding a new element to color and vertex lists
- if (model_vertices == NULL) {
- model_vertices = last_vert = (vertexList *)malloc(sizeof(vertexList));
- model_color = last_clr = (rgbaList *)malloc(sizeof(rgbaList));
- } else {
- last_vert->next = (vertexList *)malloc(sizeof(vertexList));
- last_clr->next = (rgbaList *)malloc(sizeof(rgbaList));
- last_vert = last_vert->next;
- last_clr = last_clr->next;
- }
-
- // Properly populating the new element
- last_vert->v.x = x;
- last_vert->v.y = y;
- last_vert->v.z = z;
- memcpy_neon(&last_clr->v, ¤t_color.r, sizeof(vector4f));
- last_clr->next = last_vert->next = NULL;
-
- // Increasing vertex counter
- vertex_count++;
-}
-
-void glVertex3fv(const GLfloat *v) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase != MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Adding a new element to color and vertex lists
- if (model_vertices == NULL) {
- model_vertices = last_vert = (vertexList *)malloc(sizeof(vertexList));
- model_color = last_clr = (rgbaList *)malloc(sizeof(rgbaList));
- } else {
- last_vert->next = (vertexList *)malloc(sizeof(vertexList));
- last_clr->next = (rgbaList *)malloc(sizeof(rgbaList));
- last_vert = last_vert->next;
- last_clr = last_clr->next;
- }
-
- // Properly populating the new element
- memcpy_neon(&last_vert->v, v, sizeof(vector3f));
- memcpy_neon(&last_clr->v, ¤t_color.r, sizeof(vector4f));
- last_clr->next = last_vert->next = NULL;
-
- // Increasing vertex counter
- vertex_count++;
-}
-
-void glVertex2f(GLfloat x, GLfloat y) {
- glVertex3f(x, y, 0.0f);
-}
-
-void glColor3f(GLfloat red, GLfloat green, GLfloat blue) {
- // Setting current color value
- current_color.r = red;
- current_color.g = green;
- current_color.b = blue;
- current_color.a = 1.0f;
-}
-
-void glColor3fv(const GLfloat *v) {
- // Setting current color value
- memcpy_neon(¤t_color.r, v, sizeof(vector3f));
- current_color.a = 1.0f;
-}
-
-void glColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
- // Setting current color value
- current_color.r = (1.0f * red) / 255.0f;
- current_color.g = (1.0f * green) / 255.0f;
- current_color.b = (1.0f * blue) / 255.0f;
- current_color.a = 1.0f;
-}
-
-void glColor3ubv(const GLubyte *c) {
- // Setting current color value
- current_color.r = (1.0f * c[0]) / 255.0f;
- current_color.g = (1.0f * c[1]) / 255.0f;
- current_color.b = (1.0f * c[2]) / 255.0f;
- current_color.a = 1.0f;
-}
-
-void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
- // Setting current color value
- current_color.r = red;
- current_color.g = green;
- current_color.b = blue;
- current_color.a = alpha;
-}
-
-void glColor4fv(const GLfloat *v) {
- // Setting current color value
- memcpy_neon(¤t_color.r, v, sizeof(vector4f));
-}
-
-void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
- current_color.r = (1.0f * red) / 255.0f;
- current_color.g = (1.0f * green) / 255.0f;
- current_color.b = (1.0f * blue) / 255.0f;
- current_color.a = (1.0f * alpha) / 255.0f;
-}
-
-void glColor4ubv(const GLubyte *c) {
- // Setting current color value
- current_color.r = (1.0f * c[0]) / 255.0f;
- current_color.g = (1.0f * c[1]) / 255.0f;
- current_color.b = (1.0f * c[2]) / 255.0f;
- current_color.a = (1.0f * c[3]) / 255.0f;
-}
-
-void glTexCoord2fv(GLfloat *f) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase != MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Adding a new element to texcoord list
- if (model_uv == NULL) {
- model_uv = last_uv = (uvList *)malloc(sizeof(uvList));
- } else {
- last_uv->next = (uvList *)malloc(sizeof(uvList));
- last_uv = last_uv->next;
- }
-
- // Properly populating the new element
- last_uv->v.x = f[0];
- last_uv->v.y = f[1];
- last_uv->next = NULL;
-}
-
-void glTexCoord2f(GLfloat s, GLfloat t) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase != MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Adding a new element to texcoord list
- if (model_uv == NULL) {
- model_uv = last_uv = (uvList *)malloc(sizeof(uvList));
- } else {
- last_uv->next = (uvList *)malloc(sizeof(uvList));
- last_uv = last_uv->next;
- }
-
- // Properly populating the new element
- last_uv->v.x = s;
- last_uv->v.y = t;
- last_uv->next = NULL;
-}
-
-void glTexCoord2i(GLint s, GLint t) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase != MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Adding a new element to texcoord list
- if (model_uv == NULL) {
- model_uv = last_uv = (uvList *)malloc(sizeof(uvList));
- } else {
- last_uv->next = (uvList *)malloc(sizeof(uvList));
- last_uv = last_uv->next;
- }
-
- // Properly populating the new element
- last_uv->v.x = s;
- last_uv->v.y = t;
- last_uv->next = NULL;
-}
-
-void glArrayElement(GLint i) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (i < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Aliasing client texture unit for better code readability
- texture_unit *tex_unit = &texture_units[client_texture_unit];
-
- // Checking if current texture unit has GL_VERTEX_ARRAY enabled
- if (tex_unit->vertex_array_state) {
- // Calculating offset of requested element
- uint8_t *ptr;
- if (tex_unit->vertex_array.stride == 0)
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (i * (tex_unit->vertex_array.num * tex_unit->vertex_array.size));
- else
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (i * tex_unit->vertex_array.stride);
-
- // Adding a new element to vertex and color lists
- if (model_vertices == NULL) {
- model_vertices = last_vert = (vertexList *)malloc(sizeof(vertexList));
- model_color = last_clr = (rgbaList *)malloc(sizeof(rgbaList));
- } else {
- last_vert->next = (vertexList *)malloc(sizeof(vertexList));
- last_clr->next = (rgbaList *)malloc(sizeof(rgbaList));
- last_vert = last_vert->next;
- last_clr = last_clr->next;
- }
- last_vert->next = NULL;
- last_clr->next = NULL;
-
- // Populating new vertex element
- memcpy_neon(&last_vert->v, ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
-
- // Checking if current texture unit has GL_COLOR_ARRAY enabled
- if (tex_unit->color_array_state) {
- // Calculating offset of requested element
- uint8_t *ptr_clr;
- if (tex_unit->color_array.stride == 0)
- ptr_clr = ((uint8_t *)tex_unit->color_array.pointer) + (i * (tex_unit->color_array.num * tex_unit->color_array.size));
- else
- ptr_clr = ((uint8_t *)tex_unit->color_array.pointer) + (i * tex_unit->color_array.stride);
-
- // Populating new color element
- last_clr->v.a = 1.0f;
- memcpy_neon(&last_clr->v, ptr_clr, tex_unit->color_array.size * tex_unit->color_array.num);
-
- } else {
- // Populating new color element with current color
- memcpy_neon(&last_clr->v, ¤t_color.r, sizeof(vector4f));
- }
-
- // Checking if current texture unit has GL_TEXTURE_COORD_ARRAY enabled
- if (tex_unit->texture_array_state) {
- // Calculating offset of requested element
- uint8_t *ptr_tex;
- if (tex_unit->texture_array.stride == 0)
- ptr_tex = ((uint8_t *)tex_unit->texture_array.pointer) + (i * (tex_unit->texture_array.num * tex_unit->texture_array.size));
- else
- ptr_tex = ((uint8_t *)tex_unit->texture_array.pointer) + (i * tex_unit->texture_array.stride);
-
- // Adding a new element to texcoord list
- if (model_uv == NULL) {
- model_uv = last_uv = (uvList *)malloc(sizeof(uvList));
- } else {
- last_uv->next = (uvList *)malloc(sizeof(uvList));
- last_uv = last_uv->next;
- }
-
- // Populating new texcoord element
- memcpy_neon(&last_uv->v, ptr_tex, tex_unit->vertex_array.size * 2);
- last_uv->next = NULL;
- }
- }
-}
-
-void glBegin(GLenum mode) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Changing current openGL machine state
- phase = MODEL_CREATION;
-
- // Translating primitive to sceGxm one
- prim_extra = SCE_GXM_PRIMITIVE_NONE;
- switch (mode) {
- case GL_POINTS:
- prim = SCE_GXM_PRIMITIVE_POINTS;
- np = 1;
- break;
- case GL_LINES:
- prim = SCE_GXM_PRIMITIVE_LINES;
- np = 2;
- break;
- case GL_TRIANGLES:
- prim = SCE_GXM_PRIMITIVE_TRIANGLES;
- np = 3;
- break;
- case GL_TRIANGLE_STRIP:
- prim = SCE_GXM_PRIMITIVE_TRIANGLE_STRIP;
- np = 1;
- break;
- case GL_TRIANGLE_FAN:
- prim = SCE_GXM_PRIMITIVE_TRIANGLE_FAN;
- np = 1;
- break;
- case GL_QUADS:
- prim = SCE_GXM_PRIMITIVE_TRIANGLES;
- prim_extra = SCE_GXM_PRIMITIVE_QUADS;
- np = 4;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Resetting vertex count
- vertex_count = 0;
-}
-
-void glEnd(void) {
-#ifndef SKIP_ERROR_HANDLING
- // Integrity checks
- if (vertex_count == 0 || ((vertex_count % np) != 0))
- return;
-
- // Error handling
- if (phase != MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- return;
- }
-#endif
-
- // Changing current openGL machine state
- phase = NONE;
-
- // Checking if we can totally skip drawing cause of culling mode
- if (no_polygons_mode && ((prim == SCE_GXM_PRIMITIVE_TRIANGLES) || (prim >= SCE_GXM_PRIMITIVE_TRIANGLE_STRIP))) {
- purge_vertex_list();
- vertex_count = 0;
- return;
- }
-
- // Aliasing server texture unit and texture id for better code readability
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
-
- // Calculating mvp matrix
- if (mvp_modified) {
- matrix4x4_multiply(mvp_matrix, projection_matrix, modelview_matrix);
- mvp_modified = GL_FALSE;
- }
-
- // Checking if we have to write a texture
- if ((server_texture_unit >= 0) && (tex_unit->enabled) && (model_uv != NULL) && (vgl_textures[texture2d_idx].valid)) {
- // Setting proper vertex and fragment programs
- sceGxmSetVertexProgram(gxm_context, texture2d_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_fragment_program_patched);
-
- // Setting fragment uniforms for alpha test and texture environment
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_op, 0, 1, &alpha_operation);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tint_color, 0, 4, ¤t_color.r);
- float tex_env = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env, 0, 1, &tex_env);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_density, 0, 1, (const float *)&fog_density);
-
- } else {
- // Setting proper vertex and fragment programs
- sceGxmSetVertexProgram(gxm_context, rgba_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- }
-
- // Reserving default uniform buffer for wvp
- int i, j;
- void *vertex_wvp_buffer;
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_wvp_buffer);
-
- // Checking if we have to write a texture
- if (model_uv != NULL) {
- // Setting wvp matrix
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_wvp, 0, 16, (const float *)mvp_matrix);
-
- // Setting fogging uniforms
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_mv, 0, 16, (const float *)modelview_matrix);
-
- // Setting in use texture
- sceGxmSetFragmentTexture(gxm_context, 0, &vgl_textures[texture2d_idx].gxm_tex);
-
- // Properly generating vertices, uv map and indices buffers
- vector3f *vertices;
- vector2f *uv_map;
- uint16_t *indices;
- int n = 0, quad_n = 0;
- vertexList *object = model_vertices;
- uvList *object_uv = model_uv;
- uint64_t idx_count = vertex_count;
- switch (prim_extra) {
- case SCE_GXM_PRIMITIVE_NONE:
- vertices = (vector3f *)gpu_pool_memalign(vertex_count * sizeof(vector3f), sizeof(vector3f));
- uv_map = (vector2f *)gpu_pool_memalign(vertex_count * sizeof(vector2f), sizeof(vector2f));
- memset(vertices, 0, (vertex_count * sizeof(vector3f)));
- indices = (uint16_t *)gpu_pool_memalign(idx_count * sizeof(uint16_t), sizeof(uint16_t));
- for (i = 0; i < vertex_count; i++) {
- memcpy_neon(&vertices[n], &object->v, sizeof(vector3f));
- memcpy_neon(&uv_map[n], &object_uv->v, sizeof(vector2f));
- indices[n] = n;
- object = object->next;
- object_uv = object_uv->next;
- n++;
- }
- break;
- case SCE_GXM_PRIMITIVE_QUADS:
- quad_n = vertex_count >> 2;
- idx_count = quad_n * 6;
- vertices = (vector3f *)gpu_pool_memalign(vertex_count * sizeof(vector3f), sizeof(vector3f));
- uv_map = (vector2f *)gpu_pool_memalign(vertex_count * sizeof(vector2f), sizeof(vector2f));
- memset(vertices, 0, (vertex_count * sizeof(vector3f)));
- indices = (uint16_t *)gpu_pool_memalign(idx_count * sizeof(uint16_t), sizeof(uint16_t));
- for (i = 0; i < quad_n; i++) {
- indices[i * 6] = i * 4;
- indices[i * 6 + 1] = i * 4 + 1;
- indices[i * 6 + 2] = i * 4 + 3;
- indices[i * 6 + 3] = i * 4 + 1;
- indices[i * 6 + 4] = i * 4 + 2;
- indices[i * 6 + 5] = i * 4 + 3;
- }
- for (j = 0; j < vertex_count; j++) {
- memcpy_neon(&vertices[j], &object->v, sizeof(vector3f));
- memcpy_neon(&uv_map[j], &object_uv->v, sizeof(vector2f));
- object = object->next;
- object_uv = object_uv->next;
- }
- break;
- }
-
- // Performing the requested draw call
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, uv_map);
- sceGxmDraw(gxm_context, prim, SCE_GXM_INDEX_FORMAT_U16, indices, idx_count);
-
- } else {
- // Setting wvp matrix
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
-
- // Properly generating vertices, colors and indices buffers
- vector3f *vertices;
- vector4f *colors;
- uint16_t *indices;
- int n = 0, quad_n = 0;
- vertexList *object = model_vertices;
- rgbaList *object_clr = model_color;
- uint64_t idx_count = vertex_count;
- switch (prim_extra) {
- case SCE_GXM_PRIMITIVE_NONE:
- vertices = (vector3f *)gpu_pool_memalign(vertex_count * sizeof(vector3f), sizeof(vector3f));
- colors = (vector4f *)gpu_pool_memalign(vertex_count * sizeof(vector4f), sizeof(vector4f));
- memset(vertices, 0, (vertex_count * sizeof(vector3f)));
- indices = (uint16_t *)gpu_pool_memalign(idx_count * sizeof(uint16_t), sizeof(uint16_t));
- for (i = 0; i < vertex_count; i++) {
- memcpy_neon(&vertices[n], &object->v, sizeof(vector3f));
- memcpy_neon(&colors[n], &object_clr->v, sizeof(vector4f));
- indices[n] = n;
- object = object->next;
- object_clr = object_clr->next;
- n++;
- }
- break;
- case SCE_GXM_PRIMITIVE_QUADS:
- quad_n = vertex_count >> 2;
- idx_count = quad_n * 6;
- vertices = (vector3f *)gpu_pool_memalign(vertex_count * sizeof(vector3f), sizeof(vector3f));
- colors = (vector4f *)gpu_pool_memalign(vertex_count * sizeof(vector4f), sizeof(vector4f));
- memset(vertices, 0, (vertex_count * sizeof(vector3f)));
- indices = (uint16_t *)gpu_pool_memalign(idx_count * sizeof(uint16_t), sizeof(uint16_t));
- int i, j;
- for (i = 0; i < quad_n; i++) {
- indices[i * 6] = i * 4;
- indices[i * 6 + 1] = i * 4 + 1;
- indices[i * 6 + 2] = i * 4 + 3;
- indices[i * 6 + 3] = i * 4 + 1;
- indices[i * 6 + 4] = i * 4 + 2;
- indices[i * 6 + 5] = i * 4 + 3;
- }
- for (j = 0; j < vertex_count; j++) {
- memcpy_neon(&vertices[j], &object->v, sizeof(vector3f));
- memcpy_neon(&colors[j], &object_clr->v, sizeof(vector4f));
- object = object->next;
- object_clr = object_clr->next;
- }
- break;
- }
-
- // Performing the requested draw call
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, colors);
- sceGxmDraw(gxm_context, prim, SCE_GXM_INDEX_FORMAT_U16, indices, idx_count);
- }
-
- // Purging vertex, colors and texcoord lists
- purge_vertex_list();
- vertex_count = 0;
-}
diff --git a/deps/vitaGL/source/matrices.c b/deps/vitaGL/source/matrices.c
deleted file mode 100644
index 50a65e536f..0000000000
--- a/deps/vitaGL/source/matrices.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * matrices.c:
- * Implementation for matrices related functions
- */
-
-#include "shared.h"
-
-matrix4x4 *matrix = NULL; // Current in-use matrix mode
-static matrix4x4 modelview_matrix_stack[MODELVIEW_STACK_DEPTH]; // Modelview matrices stack
-static uint8_t modelview_stack_counter = 0; // Modelview matrices stack counter
-static matrix4x4 projection_matrix_stack[GENERIC_STACK_DEPTH]; // Projection matrices stack
-static uint8_t projection_stack_counter = 0; // Projection matrices stack counter
-GLboolean mvp_modified = GL_TRUE; // Check if ModelViewProjection matrix needs to be recreated
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void glMatrixMode(GLenum mode) {
- // Changing current in use matrix
- switch (mode) {
- case GL_MODELVIEW: // Modelview matrix
- matrix = &modelview_matrix;
- break;
- case GL_PROJECTION: // Projection matrix
- matrix = &projection_matrix;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearVal, GLdouble farVal) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- } else if ((left == right) || (bottom == top) || (nearVal == farVal)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Initializing ortho matrix with requested parameters
- matrix4x4_init_orthographic(*matrix, left, right, bottom, top, nearVal, farVal);
- mvp_modified = GL_TRUE;
-}
-
-void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearVal, GLdouble farVal) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- } else if ((left == right) || (bottom == top) || (nearVal < 0) || (farVal < 0)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Initializing frustum matrix with requested parameters
- matrix4x4_init_frustum(*matrix, left, right, bottom, top, nearVal, farVal);
- mvp_modified = GL_TRUE;
-}
-
-void glLoadIdentity(void) {
- // Set current in use matrix to identity one
- matrix4x4_identity(*matrix);
- mvp_modified = GL_TRUE;
-}
-
-void glMultMatrixf(const GLfloat *m) {
- matrix4x4 res;
-
- // Properly ordering matrix to perform multiplication
- matrix4x4 tmp;
- int i, j;
- for (i = 0; i < 4; i++) {
- for (j = 0; j < 4; j++) {
- tmp[i][j] = m[j * 4 + i];
- }
- }
-
- // Multiplicating passed matrix with in use one
- matrix4x4_multiply(res, *matrix, tmp);
-
- // Copying result to in use matrix
- matrix4x4_copy(*matrix, res);
- mvp_modified = GL_TRUE;
-}
-
-void glLoadMatrixf(const GLfloat *m) {
- // Properly ordering matrix
- int i, j;
- for (i = 0; i < 4; i++) {
- for (j = 0; j < 4; j++) {
- (*matrix)[i][j] = m[j * 4 + i];
- }
- }
-
- mvp_modified = GL_TRUE;
-}
-
-void glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
- // Translating in use matrix
- matrix4x4_translate(*matrix, x, y, z);
- mvp_modified = GL_TRUE;
-}
-
-void glScalef(GLfloat x, GLfloat y, GLfloat z) {
- // Scaling in use matrix
- matrix4x4_scale(*matrix, x, y, z);
- mvp_modified = GL_TRUE;
-}
-
-void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Performing rotation on in use matrix depending on user call
- float rad = DEG_TO_RAD(angle);
- if (x == 1.0f) {
- matrix4x4_rotate_x(*matrix, rad);
- }
- if (y == 1.0f) {
- matrix4x4_rotate_y(*matrix, rad);
- }
- if (z == 1.0f) {
- matrix4x4_rotate_z(*matrix, rad);
- }
- mvp_modified = GL_TRUE;
-}
-
-void glPushMatrix(void) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- if (matrix == &modelview_matrix) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (modelview_stack_counter >= MODELVIEW_STACK_DEPTH) {
- SET_GL_ERROR(GL_STACK_OVERFLOW)
- } else
-#endif
- // Copying current matrix into the matrix stack and increasing stack counter
- matrix4x4_copy(modelview_matrix_stack[modelview_stack_counter++], *matrix);
-
- } else if (matrix == &projection_matrix) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (projection_stack_counter >= GENERIC_STACK_DEPTH) {
- SET_GL_ERROR(GL_STACK_OVERFLOW)
- } else
-#endif
- // Copying current matrix into the matrix stack and increasing stack counter
- matrix4x4_copy(projection_matrix_stack[projection_stack_counter++], *matrix);
- }
-}
-
-void glPopMatrix(void) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- if (matrix == &modelview_matrix) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (modelview_stack_counter == 0) {
- SET_GL_ERROR(GL_STACK_UNDERFLOW)
- } else
-#endif
- // Copying last matrix on stack into current matrix and decreasing stack counter
- matrix4x4_copy(*matrix, modelview_matrix_stack[--modelview_stack_counter]);
-
- } else if (matrix == &projection_matrix) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (projection_stack_counter == 0) {
- SET_GL_ERROR(GL_STACK_UNDERFLOW)
- } else
-#endif
- // Copying last matrix on stack into current matrix and decreasing stack counter
- matrix4x4_copy(*matrix, projection_matrix_stack[--projection_stack_counter]);
- }
- mvp_modified = GL_TRUE;
-}
-
-void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Initializing frustum matrix with requested parameters
- matrix4x4_init_perspective(*matrix, fovy, aspect, zNear, zFar);
- mvp_modified = GL_TRUE;
-}
diff --git a/deps/vitaGL/source/misc.c b/deps/vitaGL/source/misc.c
deleted file mode 100644
index 3c1d41d50b..0000000000
--- a/deps/vitaGL/source/misc.c
+++ /dev/null
@@ -1,568 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * misc.c:
- * Implementation for miscellaneous functions
- */
-
-#include "shared.h"
-GLboolean fast_texture_compression = GL_FALSE; // Hints for texture compression
-
-static void update_fogging_state() {
- if (fogging) {
- switch (fog_mode) {
- case GL_LINEAR:
- internal_fog_mode = LINEAR;
- break;
- case GL_EXP:
- internal_fog_mode = EXP;
- break;
- default:
- internal_fog_mode = EXP2;
- break;
- }
- } else
- internal_fog_mode = DISABLED;
-}
-
-static void update_polygon_offset() {
- switch (polygon_mode_front) {
- case SCE_GXM_POLYGON_MODE_TRIANGLE_LINE:
- if (pol_offset_line)
- sceGxmSetFrontDepthBias(gxm_context, (int)pol_factor, (int)pol_units);
- else
- sceGxmSetFrontDepthBias(gxm_context, 0, 0);
- break;
- case SCE_GXM_POLYGON_MODE_TRIANGLE_POINT:
- if (pol_offset_point)
- sceGxmSetFrontDepthBias(gxm_context, (int)pol_factor, (int)pol_units);
- else
- sceGxmSetFrontDepthBias(gxm_context, 0, 0);
- break;
- case SCE_GXM_POLYGON_MODE_TRIANGLE_FILL:
- if (pol_offset_fill)
- sceGxmSetFrontDepthBias(gxm_context, (int)pol_factor, (int)pol_units);
- else
- sceGxmSetFrontDepthBias(gxm_context, 0, 0);
- break;
- }
- switch (polygon_mode_back) {
- case SCE_GXM_POLYGON_MODE_TRIANGLE_LINE:
- if (pol_offset_line)
- sceGxmSetBackDepthBias(gxm_context, (int)pol_factor, (int)pol_units);
- else
- sceGxmSetBackDepthBias(gxm_context, 0, 0);
- break;
- case SCE_GXM_POLYGON_MODE_TRIANGLE_POINT:
- if (pol_offset_point)
- sceGxmSetBackDepthBias(gxm_context, (int)pol_factor, (int)pol_units);
- else
- sceGxmSetBackDepthBias(gxm_context, 0, 0);
- break;
- case SCE_GXM_POLYGON_MODE_TRIANGLE_FILL:
- if (pol_offset_fill)
- sceGxmSetBackDepthBias(gxm_context, (int)pol_factor, (int)pol_units);
- else
- sceGxmSetBackDepthBias(gxm_context, 0, 0);
- break;
- }
-}
-
-static void change_cull_mode() {
- // Setting proper cull mode in sceGxm depending to current openGL machine state
- if (cull_face_state) {
- if ((gl_front_face == GL_CW) && (gl_cull_mode == GL_BACK))
- sceGxmSetCullMode(gxm_context, SCE_GXM_CULL_CCW);
- else if ((gl_front_face == GL_CCW) && (gl_cull_mode == GL_BACK))
- sceGxmSetCullMode(gxm_context, SCE_GXM_CULL_CW);
- else if ((gl_front_face == GL_CCW) && (gl_cull_mode == GL_FRONT))
- sceGxmSetCullMode(gxm_context, SCE_GXM_CULL_CCW);
- else if ((gl_front_face == GL_CW) && (gl_cull_mode == GL_FRONT))
- sceGxmSetCullMode(gxm_context, SCE_GXM_CULL_CW);
- else if (gl_cull_mode == GL_FRONT_AND_BACK)
- no_polygons_mode = GL_TRUE;
- } else
- sceGxmSetCullMode(gxm_context, SCE_GXM_CULL_NONE);
-}
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void glPolygonMode(GLenum face, GLenum mode) {
- SceGxmPolygonMode new_mode;
- switch (mode) {
- case GL_POINT:
- new_mode = SCE_GXM_POLYGON_MODE_TRIANGLE_POINT;
- break;
- case GL_LINE:
- new_mode = SCE_GXM_POLYGON_MODE_TRIANGLE_LINE;
- break;
- case GL_FILL:
- new_mode = SCE_GXM_POLYGON_MODE_TRIANGLE_FILL;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- switch (face) {
- case GL_FRONT:
- polygon_mode_front = new_mode;
- gl_polygon_mode_front = mode;
- sceGxmSetFrontPolygonMode(gxm_context, new_mode);
- break;
- case GL_BACK:
- polygon_mode_back = new_mode;
- gl_polygon_mode_back = mode;
- sceGxmSetBackPolygonMode(gxm_context, new_mode);
- break;
- case GL_FRONT_AND_BACK:
- polygon_mode_front = polygon_mode_back = new_mode;
- gl_polygon_mode_front = gl_polygon_mode_back = mode;
- sceGxmSetFrontPolygonMode(gxm_context, new_mode);
- sceGxmSetBackPolygonMode(gxm_context, new_mode);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- return;
- }
- update_polygon_offset();
-}
-
-void glPolygonOffset(GLfloat factor, GLfloat units) {
- pol_factor = factor;
- pol_units = units;
- update_polygon_offset();
-}
-
-void glCullFace(GLenum mode) {
- gl_cull_mode = mode;
- if (cull_face_state)
- change_cull_mode();
-}
-
-void glFrontFace(GLenum mode) {
- gl_front_face = mode;
- if (cull_face_state)
- change_cull_mode();
-}
-
-void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
-#ifndef SKIP_ERROR_HANDLING
- if ((width < 0) || (height < 0)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- x_scale = width >> 1;
- x_port = x + x_scale;
- y_scale = -(height >> 1);
- y_port = DISPLAY_HEIGHT - y + y_scale;
- sceGxmSetViewport(gxm_context, x_port, x_scale, y_port, y_scale, z_port, z_scale);
- gl_viewport.x = x;
- gl_viewport.y = y;
- gl_viewport.w = width;
- gl_viewport.h = height;
-}
-
-void glDepthRange(GLdouble nearVal, GLdouble farVal) {
- z_port = (farVal + nearVal) / 2.0f;
- z_scale = (farVal - nearVal) / 2.0f;
- sceGxmSetViewport(gxm_context, x_port, x_scale, y_port, y_scale, z_port, z_scale);
-}
-
-void glDepthRangef(GLfloat nearVal, GLfloat farVal) {
- z_port = (farVal + nearVal) / 2.0f;
- z_scale = (farVal - nearVal) / 2.0f;
- sceGxmSetViewport(gxm_context, x_port, x_scale, y_port, y_scale, z_port, z_scale);
-}
-
-void glEnable(GLenum cap) {
-#ifndef SKIP_ERROR_HANDLING
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
- switch (cap) {
- case GL_DEPTH_TEST:
- depth_test_state = GL_TRUE;
- change_depth_func();
- break;
- case GL_STENCIL_TEST:
- stencil_test_state = GL_TRUE;
- change_stencil_settings();
- break;
- case GL_BLEND:
- if (!blend_state)
- change_blend_factor();
- blend_state = GL_TRUE;
- break;
- case GL_SCISSOR_TEST:
- scissor_test_state = GL_TRUE;
- update_scissor_test();
- break;
- case GL_CULL_FACE:
- cull_face_state = GL_TRUE;
- change_cull_mode();
- break;
- case GL_POLYGON_OFFSET_FILL:
- pol_offset_fill = GL_TRUE;
- update_polygon_offset();
- break;
- case GL_POLYGON_OFFSET_LINE:
- pol_offset_line = GL_TRUE;
- update_polygon_offset();
- break;
- case GL_POLYGON_OFFSET_POINT:
- pol_offset_point = GL_TRUE;
- update_polygon_offset();
- break;
- case GL_TEXTURE_2D:
- texture_units[server_texture_unit].enabled = GL_TRUE;
- break;
- case GL_ALPHA_TEST:
- alpha_test_state = GL_TRUE;
- update_alpha_test_settings();
- break;
- case GL_FOG:
- fogging = GL_TRUE;
- update_fogging_state();
- break;
- case GL_CLIP_PLANE0:
- clip_plane0 = GL_TRUE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glDisable(GLenum cap) {
-#ifndef SKIP_ERROR_HANDLING
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
- switch (cap) {
- case GL_DEPTH_TEST:
- depth_test_state = GL_FALSE;
- change_depth_func();
- break;
- case GL_STENCIL_TEST:
- stencil_test_state = GL_FALSE;
- change_stencil_settings();
- break;
- case GL_BLEND:
- if (blend_state)
- disable_blend();
- blend_state = GL_FALSE;
- break;
- case GL_SCISSOR_TEST:
- scissor_test_state = GL_FALSE;
- update_scissor_test();
- break;
- case GL_CULL_FACE:
- cull_face_state = GL_FALSE;
- change_cull_mode();
- break;
- case GL_POLYGON_OFFSET_FILL:
- pol_offset_fill = GL_FALSE;
- update_polygon_offset();
- break;
- case GL_POLYGON_OFFSET_LINE:
- pol_offset_line = GL_FALSE;
- update_polygon_offset();
- break;
- case GL_POLYGON_OFFSET_POINT:
- pol_offset_point = GL_FALSE;
- update_polygon_offset();
- break;
- case GL_TEXTURE_2D:
- texture_units[server_texture_unit].enabled = GL_FALSE;
- break;
- case GL_ALPHA_TEST:
- alpha_test_state = GL_FALSE;
- update_alpha_test_settings();
- break;
- case GL_FOG:
- fogging = GL_FALSE;
- update_fogging_state();
- break;
- case GL_CLIP_PLANE0:
- clip_plane0 = GL_FALSE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glClear(GLbitfield mask) {
- GLenum orig_depth_test = depth_test_state;
- if ((mask & GL_COLOR_BUFFER_BIT) == GL_COLOR_BUFFER_BIT) {
- invalidate_depth_test();
- change_depth_write(SCE_GXM_DEPTH_WRITE_DISABLED);
- sceGxmSetFrontPolygonMode(gxm_context, SCE_GXM_POLYGON_MODE_TRIANGLE_FILL);
- sceGxmSetBackPolygonMode(gxm_context, SCE_GXM_POLYGON_MODE_TRIANGLE_FILL);
- sceGxmSetVertexProgram(gxm_context, clear_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, clear_fragment_program_patched);
- void *color_buffer, *vertex_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &color_buffer);
- sceGxmSetUniformDataF(color_buffer, clear_color, 0, 4, &clear_rgba_val.r);
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_buffer);
- sceGxmSetUniformDataF(vertex_buffer, clear_position, 0, 4, &clear_vertices->x);
- sceGxmDraw(gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_FAN, SCE_GXM_INDEX_FORMAT_U16, depth_clear_indices, 4);
- validate_depth_test();
- change_depth_write(depth_mask_state ? SCE_GXM_DEPTH_WRITE_ENABLED : SCE_GXM_DEPTH_WRITE_DISABLED);
- sceGxmSetFrontPolygonMode(gxm_context, polygon_mode_front);
- sceGxmSetBackPolygonMode(gxm_context, polygon_mode_back);
- }
- if ((mask & GL_DEPTH_BUFFER_BIT) == GL_DEPTH_BUFFER_BIT) {
- invalidate_depth_test();
- change_depth_write(SCE_GXM_DEPTH_WRITE_ENABLED);
- sceGxmSetVertexProgram(gxm_context, clear_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, disable_color_buffer_fragment_program_patched);
- void *depth_buffer, *vertex_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &depth_buffer);
- float temp = depth_value;
- sceGxmSetUniformDataF(depth_buffer, clear_depth, 0, 1, &temp);
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_buffer);
- sceGxmSetUniformDataF(vertex_buffer, clear_position, 0, 4, &clear_vertices->x);
- sceGxmDraw(gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_FAN, SCE_GXM_INDEX_FORMAT_U16, depth_clear_indices, 4);
- validate_depth_test();
- change_depth_write(depth_mask_state ? SCE_GXM_DEPTH_WRITE_ENABLED : SCE_GXM_DEPTH_WRITE_DISABLED);
- }
- if ((mask & GL_STENCIL_BUFFER_BIT) == GL_STENCIL_BUFFER_BIT) {
- invalidate_depth_test();
- change_depth_write(SCE_GXM_DEPTH_WRITE_DISABLED);
- sceGxmSetVertexProgram(gxm_context, clear_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, disable_color_buffer_fragment_program_patched);
- sceGxmSetFrontStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_NEVER,
- SCE_GXM_STENCIL_OP_REPLACE,
- SCE_GXM_STENCIL_OP_REPLACE,
- SCE_GXM_STENCIL_OP_REPLACE,
- 0, stencil_value * 0xFF);
- sceGxmSetBackStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_NEVER,
- SCE_GXM_STENCIL_OP_REPLACE,
- SCE_GXM_STENCIL_OP_REPLACE,
- SCE_GXM_STENCIL_OP_REPLACE,
- 0, stencil_value * 0xFF);
- void *depth_buffer, *vertex_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &depth_buffer);
- float temp = 1.0f;
- sceGxmSetUniformDataF(depth_buffer, clear_depth, 0, 1, &temp);
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_buffer);
- sceGxmSetUniformDataF(vertex_buffer, clear_position, 0, 4, &clear_vertices->x);
- sceGxmDraw(gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_FAN, SCE_GXM_INDEX_FORMAT_U16, depth_clear_indices, 4);
- validate_depth_test();
- change_depth_write(depth_mask_state ? SCE_GXM_DEPTH_WRITE_ENABLED : SCE_GXM_DEPTH_WRITE_DISABLED);
- change_stencil_settings();
- }
-}
-
-void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
- clear_rgba_val.r = red;
- clear_rgba_val.g = green;
- clear_rgba_val.b = blue;
- clear_rgba_val.a = alpha;
-}
-
-void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *data) {
- SceDisplayFrameBuf pParam;
- pParam.size = sizeof(SceDisplayFrameBuf);
- sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME);
- y = DISPLAY_HEIGHT - (height + y);
- int i, j;
- uint8_t *out8 = (uint8_t *)data;
- uint8_t *in8 = (uint8_t *)pParam.base;
- uint32_t *out32 = (uint32_t *)data;
- uint32_t *in32 = (uint32_t *)pParam.base;
- switch (format) {
- case GL_RGBA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- in32 += (x + y * pParam.pitch);
- for (i = 0; i < height; i++) {
- for (j = 0; j < width; j++) {
- out32[(height - (i + 1)) * width + j] = in32[j];
- }
- in32 += pParam.pitch;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RGB:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- in8 += (x * 4 + y * pParam.pitch * 4);
- for (i = 0; i < height; i++) {
- for (j = 0; j < width; j++) {
- out8[((height - (i + 1)) * width + j) * 3] = in8[j * 4];
- out8[((height - (i + 1)) * width + j) * 3 + 1] = in8[j * 4 + 1];
- out8[((height - (i + 1)) * width + j) * 3 + 2] = in8[j * 4 + 2];
- }
- in8 += pParam.pitch * 4;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glLineWidth(GLfloat width) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (width <= 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Changing line and point width as requested
- sceGxmSetFrontPointLineWidth(gxm_context, width);
- sceGxmSetBackPointLineWidth(gxm_context, width);
-}
-
-void glPointSize(GLfloat size) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (size <= 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Changing line and point width as requested
- sceGxmSetFrontPointLineWidth(gxm_context, size);
- sceGxmSetBackPointLineWidth(gxm_context, size);
-}
-
-void glFogf(GLenum pname, GLfloat param) {
- switch (pname) {
- case GL_FOG_MODE:
- fog_mode = param;
- update_fogging_state();
- break;
- case GL_FOG_DENSITY:
- fog_density = param;
- break;
- case GL_FOG_START:
- fog_near = param;
- break;
- case GL_FOG_END:
- fog_far = param;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glFogfv(GLenum pname, const GLfloat *params) {
- switch (pname) {
- case GL_FOG_MODE:
- fog_mode = params[0];
- update_fogging_state();
- break;
- case GL_FOG_DENSITY:
- fog_density = params[0];
- break;
- case GL_FOG_START:
- fog_near = params[0];
- break;
- case GL_FOG_END:
- fog_far = params[0];
- break;
- case GL_FOG_COLOR:
- memcpy_neon(&fog_color.r, params, sizeof(vector4f));
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glFogi(GLenum pname, const GLint param) {
- switch (pname) {
- case GL_FOG_MODE:
- fog_mode = param;
- update_fogging_state();
- break;
- case GL_FOG_DENSITY:
- fog_density = param;
- break;
- case GL_FOG_START:
- fog_near = param;
- break;
- case GL_FOG_END:
- fog_far = param;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glClipPlane(GLenum plane, const GLdouble *equation) {
- switch (plane) {
- case GL_CLIP_PLANE0:
- clip_plane0_eq.x = equation[0];
- clip_plane0_eq.y = equation[1];
- clip_plane0_eq.z = equation[2];
- clip_plane0_eq.w = equation[3];
- matrix4x4 inverted, inverted_transposed;
- matrix4x4_invert(inverted, modelview_matrix);
- matrix4x4_transpose(inverted_transposed, inverted);
- vector4f temp;
- vector4f_matrix4x4_mult(&temp, inverted_transposed, &clip_plane0_eq);
- memcpy_neon(&clip_plane0_eq.x, &temp.x, sizeof(vector4f));
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glHint(GLenum target, GLenum mode) {
- switch (target) {
- case GL_TEXTURE_COMPRESSION_HINT:
- switch (mode) {
- case GL_FASTEST:
- fast_texture_compression = GL_TRUE;
- break;
- default:
- fast_texture_compression = GL_FALSE;
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
diff --git a/deps/vitaGL/source/shaders.h b/deps/vitaGL/source/shaders.h
deleted file mode 100644
index 705ec6f04d..0000000000
--- a/deps/vitaGL/source/shaders.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- *shaders.h:
- *Header file for default shaders related stuffs
- */
-
-#ifndef _SHADERS_H_
-#define _SHADERS_H_
-
-// Disable color buffer shader
-extern SceGxmShaderPatcherId disable_color_buffer_fragment_id;
-extern const SceGxmProgramParameter *disable_color_buffer_position;
-extern SceGxmFragmentProgram *disable_color_buffer_fragment_program_patched;
-extern const SceGxmProgramParameter *clear_depth;
-
-// Clear shader
-extern SceGxmShaderPatcherId clear_vertex_id;
-extern SceGxmShaderPatcherId clear_fragment_id;
-extern const SceGxmProgramParameter *clear_position;
-extern const SceGxmProgramParameter *clear_color;
-extern SceGxmVertexProgram *clear_vertex_program_patched;
-extern SceGxmFragmentProgram *clear_fragment_program_patched;
-
-// Color (RGBA/RGB) shader
-extern SceGxmShaderPatcherId rgba_vertex_id;
-extern SceGxmShaderPatcherId rgb_vertex_id;
-extern SceGxmShaderPatcherId rgba_fragment_id;
-extern const SceGxmProgramParameter *rgba_position;
-extern const SceGxmProgramParameter *rgba_color;
-extern const SceGxmProgramParameter *rgba_wvp;
-extern const SceGxmProgramParameter *rgb_position;
-extern const SceGxmProgramParameter *rgb_color;
-extern const SceGxmProgramParameter *rgb_wvp;
-extern SceGxmVertexProgram *rgba_vertex_program_patched;
-extern SceGxmVertexProgram *rgba_u8n_vertex_program_patched;
-extern SceGxmVertexProgram *rgb_vertex_program_patched;
-extern SceGxmVertexProgram *rgb_u8n_vertex_program_patched;
-extern SceGxmFragmentProgram *rgba_fragment_program_patched;
-extern const SceGxmProgram *rgba_fragment_program;
-
-// Texture2D shader
-extern SceGxmShaderPatcherId texture2d_vertex_id;
-extern SceGxmShaderPatcherId texture2d_fragment_id;
-extern const SceGxmProgramParameter *texture2d_position;
-extern const SceGxmProgramParameter *texture2d_texcoord;
-extern const SceGxmProgramParameter *texture2d_wvp;
-extern const SceGxmProgramParameter *texture2d_alpha_cut;
-extern const SceGxmProgramParameter *texture2d_alpha_op;
-extern const SceGxmProgramParameter *texture2d_tint_color;
-extern const SceGxmProgramParameter *texture2d_tex_env;
-extern const SceGxmProgramParameter *texture2d_clip_plane0;
-extern const SceGxmProgramParameter *texture2d_clip_plane0_eq;
-extern const SceGxmProgramParameter *texture2d_mv;
-extern const SceGxmProgramParameter *texture2d_fog_mode;
-extern const SceGxmProgramParameter *texture2d_fog_near;
-extern const SceGxmProgramParameter *texture2d_fog_far;
-extern const SceGxmProgramParameter *texture2d_fog_density;
-extern const SceGxmProgramParameter *texture2d_fog_color;
-extern const SceGxmProgramParameter *texture2d_tex_env_color;
-extern SceGxmVertexProgram *texture2d_vertex_program_patched;
-extern SceGxmFragmentProgram *texture2d_fragment_program_patched;
-extern const SceGxmProgram *texture2d_fragment_program;
-
-// Texture2D+RGBA shader
-extern SceGxmShaderPatcherId texture2d_rgba_vertex_id;
-extern SceGxmShaderPatcherId texture2d_rgba_fragment_id;
-extern const SceGxmProgramParameter *texture2d_rgba_position;
-extern const SceGxmProgramParameter *texture2d_rgba_texcoord;
-extern const SceGxmProgramParameter *texture2d_rgba_wvp;
-extern const SceGxmProgramParameter *texture2d_rgba_alpha_cut;
-extern const SceGxmProgramParameter *texture2d_rgba_alpha_op;
-extern const SceGxmProgramParameter *texture2d_rgba_color;
-extern const SceGxmProgramParameter *texture2d_rgba_tex_env;
-extern const SceGxmProgramParameter *texture2d_rgba_clip_plane0;
-extern const SceGxmProgramParameter *texture2d_rgba_clip_plane0_eq;
-extern const SceGxmProgramParameter *texture2d_rgba_mv;
-extern const SceGxmProgramParameter *texture2d_rgba_fog_mode;
-extern const SceGxmProgramParameter *texture2d_rgba_fog_near;
-extern const SceGxmProgramParameter *texture2d_rgba_fog_far;
-extern const SceGxmProgramParameter *texture2d_rgba_fog_density;
-extern const SceGxmProgramParameter *texture2d_rgba_fog_color;
-extern const SceGxmProgramParameter *texture2d_rgba_tex_env_color;
-extern SceGxmVertexProgram *texture2d_rgba_vertex_program_patched;
-extern SceGxmVertexProgram *texture2d_rgba_u8n_vertex_program_patched;
-extern SceGxmFragmentProgram *texture2d_rgba_fragment_program_patched;
-extern const SceGxmProgram *texture2d_rgba_fragment_program;
-
-#endif
diff --git a/deps/vitaGL/source/shaders/clear_f.h b/deps/vitaGL/source/shaders/clear_f.h
deleted file mode 100644
index 3efceae539..0000000000
--- a/deps/vitaGL/source/shaders/clear_f.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef __clear_f__
-#define __clear_f__
-
-static unsigned int size_clear_f = 236;
-static unsigned char clear_f[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0xea, 0x00, 0x00, 0x00, 0x31, 0xc7, 0xbe, 0x93,
- 0x4c, 0xc3, 0x26, 0xba, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00,
- 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x02, 0x80, 0x19, 0xf0,
- 0x7e, 0x0d, 0x80, 0x40, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00,
- 0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x5f, 0x63, 0x6c,
- 0x65, 0x61, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/clear_v.h b/deps/vitaGL/source/shaders/clear_v.h
deleted file mode 100644
index 1b55545922..0000000000
--- a/deps/vitaGL/source/shaders/clear_v.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef __clear_v__
-#define __clear_v__
-
-static unsigned int size_clear_v = 372;
-static unsigned char clear_v[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0x71, 0x01, 0x00, 0x00, 0xf3, 0x7d, 0x64, 0x50,
- 0xb9, 0x22, 0xc8, 0x0c, 0x04, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x01, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0d, 0x00, 0x00, 0x00,
- 0x88, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x03, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x10, 0x81,
- 0x0a, 0x05, 0x84, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa,
- 0x04, 0xc0, 0x07, 0xb0, 0x85, 0x01, 0x88, 0x48, 0x06, 0xc0, 0x07, 0xb0, 0x81, 0x01, 0x88, 0x48,
- 0x04, 0xc0, 0x07, 0xb0, 0x81, 0x01, 0x88, 0x4d, 0x00, 0x04, 0x40, 0xe0, 0x09, 0x00, 0x81, 0x50,
- 0x40, 0x00, 0x04, 0xc1, 0x01, 0x05, 0x80, 0x3d, 0x05, 0xc0, 0x07, 0xb0, 0x85, 0x01, 0x88, 0x4e,
- 0x00, 0x00, 0x00, 0xe0, 0x09, 0x00, 0x81, 0x50, 0x00, 0x00, 0x00, 0xc1, 0x09, 0x05, 0x80, 0x3a,
- 0x40, 0x00, 0x00, 0x42, 0x01, 0x05, 0x80, 0x38, 0x01, 0x00, 0x04, 0x50, 0x85, 0x11, 0xa5, 0x08,
- 0x01, 0x80, 0x56, 0x90, 0x81, 0x11, 0x83, 0x08, 0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb,
- 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
- 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
- 0x00, 0x00, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/disable_color_buffer_f.h b/deps/vitaGL/source/shaders/disable_color_buffer_f.h
deleted file mode 100644
index 397bdc35c9..0000000000
--- a/deps/vitaGL/source/shaders/disable_color_buffer_f.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef __disable_color_buffer_f__
-#define __disable_color_buffer_f__
-
-static unsigned int size_disable_color_buffer_f = 276;
-static unsigned char disable_color_buffer_f[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0x14, 0x01, 0x00, 0x00, 0x4d, 0x94, 0xc7, 0x39,
- 0x5b, 0xce, 0x5e, 0x9b, 0x15, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
- 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x44, 0xfa,
- 0x00, 0x00, 0x00, 0xe0, 0x08, 0x00, 0x81, 0x50, 0x02, 0x01, 0x00, 0xf0, 0x00, 0x00, 0x30, 0xfb,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
- 0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x70, 0x74, 0x68, 0x5f, 0x63, 0x6c,
- 0x65, 0x61, 0x72, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/rgb_v.h b/deps/vitaGL/source/shaders/rgb_v.h
deleted file mode 100644
index bc5caf32a9..0000000000
--- a/deps/vitaGL/source/shaders/rgb_v.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef __rgb_v__
-#define __rgb_v__
-
-static unsigned int size_rgb_v = 448;
-static unsigned char rgb_v[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0xbd, 0x01, 0x00, 0x00, 0xcf, 0x61, 0x92, 0x9a,
- 0x71, 0x82, 0x84, 0xfc, 0x04, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x50, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x08, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00,
- 0xe0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xec, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0, 0xa2,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x00, 0x2c, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x05, 0x00, 0xa3,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x01, 0x30, 0x82, 0x02, 0x05, 0x80, 0x38, 0x07, 0x01, 0x43, 0xa2,
- 0x8e, 0x0d, 0x80, 0x40, 0x0f, 0x05, 0x83, 0xa2, 0x8e, 0x0d, 0x80, 0x40, 0x05, 0x00, 0xc3, 0xa1,
- 0x8e, 0x0d, 0x80, 0x40, 0x0d, 0x04, 0x03, 0xa2, 0x8e, 0x0d, 0x80, 0x40, 0x00, 0x00, 0x40, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x00, 0x04, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x04, 0x00, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x01, 0x00, 0x82, 0x02, 0x05, 0x84, 0x38, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x81, 0x00, 0x84, 0x90, 0x85, 0x19, 0xa5, 0x08,
- 0x02, 0x80, 0x81, 0xaf, 0x9c, 0x0d, 0xc0, 0x40, 0x14, 0x89, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40,
- 0x0b, 0x11, 0x49, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 0x07, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18,
- 0x01, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 0x00, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18,
- 0xc1, 0x00, 0xd4, 0x90, 0x89, 0x11, 0xc1, 0x08, 0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb,
- 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
- 0x6e, 0x00, 0x61, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x77, 0x76, 0x70, 0x00, 0x00, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/rgba_f.h b/deps/vitaGL/source/shaders/rgba_f.h
deleted file mode 100644
index f89c9ae975..0000000000
--- a/deps/vitaGL/source/shaders/rgba_f.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef __rgba_f__
-#define __rgba_f__
-
-static unsigned int size_rgba_f = 212;
-static unsigned char rgba_f[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x9c, 0xd6, 0x9b, 0xf7,
- 0x94, 0x1a, 0xc4, 0x74, 0x01, 0x10, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00,
- 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x0f, 0xa0, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x02, 0x80, 0x19, 0xa0,
- 0x7e, 0x0d, 0x80, 0x40,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/rgba_v.h b/deps/vitaGL/source/shaders/rgba_v.h
deleted file mode 100644
index f72aaa45a4..0000000000
--- a/deps/vitaGL/source/shaders/rgba_v.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef __rgba_v__
-#define __rgba_v__
-
-static unsigned int size_rgba_v = 440;
-static unsigned char rgba_v[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0xb5, 0x01, 0x00, 0x00, 0x24, 0xdc, 0x9e, 0xbb,
- 0xe8, 0xbd, 0x34, 0xb5, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x08, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x09, 0x00, 0x00, 0x00,
- 0xe0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0xd4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x08,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0, 0xa2,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x00, 0x2c, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x05, 0x00, 0xa3,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x01, 0x30, 0x82, 0x02, 0x05, 0x80, 0x38, 0x07, 0x01, 0x43, 0xa2,
- 0x8e, 0x0d, 0x80, 0x40, 0x0f, 0x05, 0x83, 0xa2, 0x8e, 0x0d, 0x80, 0x40, 0x05, 0x00, 0xc3, 0xa1,
- 0x8e, 0x0d, 0x80, 0x40, 0x0d, 0x04, 0x03, 0xa2, 0x8e, 0x0d, 0x80, 0x40, 0x00, 0x00, 0x40, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x00, 0x04, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x04, 0x00, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x01, 0x00, 0x82, 0x02, 0x05, 0x84, 0x38, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x80, 0x00, 0x08, 0x83, 0x21, 0x1d, 0x80, 0x38,
- 0x02, 0x80, 0x81, 0xaf, 0x9c, 0x0d, 0xc0, 0x40, 0x14, 0x89, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40,
- 0x0b, 0x11, 0x49, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 0x07, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18,
- 0x01, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 0x00, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18,
- 0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
- 0x30, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x2a, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x21, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x61, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
- 0x00, 0x77, 0x76, 0x70, 0x00, 0x00, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/texture2d_f.h b/deps/vitaGL/source/shaders/texture2d_f.h
deleted file mode 100644
index e5017a4c37..0000000000
--- a/deps/vitaGL/source/shaders/texture2d_f.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#ifndef __texture2d_f__
-#define __texture2d_f__
-
-static unsigned int size_texture2d_f = 1284;
-static unsigned char texture2d_f[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0x01, 0x05, 0x00, 0x00, 0xa0, 0xad, 0x6e, 0x36,
- 0x32, 0x6a, 0xc9, 0x2c, 0x09, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xa8, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x08, 0x00, 0x24, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x4d, 0x00, 0x00, 0x00,
- 0xc0, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x58, 0x03, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x0b, 0x00, 0x00, 0x00, 0xf4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x03, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x3c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x2c, 0x03, 0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x00, 0xd9, 0xc0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
- 0x47, 0x10, 0x44, 0xa4, 0xa6, 0x41, 0xa4, 0x08, 0x88, 0x10, 0x04, 0xa4, 0xaa, 0x00, 0xc0, 0x08,
- 0xcf, 0x00, 0x04, 0xa2, 0xa6, 0x08, 0xa4, 0x08, 0x49, 0x12, 0x04, 0xaf, 0xa4, 0x10, 0xa4, 0x08,
- 0x02, 0x3e, 0x00, 0x00, 0x02, 0x00, 0x80, 0x30, 0x40, 0x82, 0xe4, 0xa1, 0x82, 0x10, 0x84, 0x08,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x44, 0xfa, 0x17, 0x84, 0x07, 0xf0, 0x81, 0x06, 0xa8, 0x48,
- 0x04, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x04, 0x02, 0x03, 0xa0, 0x8c, 0x0d, 0x80, 0x40,
- 0x06, 0x03, 0x43, 0xa0, 0x8c, 0x0d, 0x80, 0x40, 0x1a, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x15, 0x84, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x81, 0x00, 0x04, 0xb0, 0x84, 0x41, 0xa4, 0x08,
- 0xc2, 0x00, 0x44, 0xb0, 0x88, 0x41, 0xc0, 0x08, 0x16, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x16, 0x84, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x0f, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x18, 0x84, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x09, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8, 0x04, 0x81, 0x99, 0xff, 0xbc, 0x0d, 0xc0, 0x40,
- 0x02, 0x01, 0x5d, 0x8f, 0x84, 0x8b, 0xa1, 0x18, 0x41, 0x5f, 0x44, 0x1f, 0x84, 0x1b, 0xa5, 0x08,
- 0x40, 0x6f, 0x04, 0x10, 0x84, 0x09, 0xa5, 0x08, 0x40, 0x6f, 0x4d, 0x10, 0x80, 0x00, 0x81, 0x08,
- 0x03, 0x0f, 0x4c, 0x20, 0x00, 0x11, 0x80, 0x08, 0x0a, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x41, 0x24, 0x00, 0xf0, 0x84, 0x91, 0xa0, 0x00, 0x02, 0x34, 0x40, 0xf0, 0x84, 0x00, 0x80, 0x00,
- 0x83, 0x00, 0x46, 0xe0, 0x08, 0x11, 0xc0, 0x08, 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x80, 0x02, 0x60, 0xe0, 0x08, 0x00, 0xc1, 0x50, 0x04, 0x81, 0x81, 0xff, 0x9c, 0x0d, 0xc0, 0x40,
- 0x43, 0x00, 0x11, 0x8f, 0xc0, 0x8b, 0xb1, 0x18, 0xbc, 0x30, 0x04, 0x80, 0x84, 0x91, 0x80, 0x00,
- 0xfc, 0x30, 0x50, 0x80, 0x84, 0x40, 0x80, 0x00, 0x9a, 0x83, 0x07, 0xf0, 0x81, 0x06, 0xa8, 0x48,
- 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x0c, 0xa0, 0x85, 0x01, 0x8b, 0x48,
- 0x12, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8, 0x95, 0x83, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x80, 0x80, 0x03, 0x30, 0x15, 0xc9, 0x88, 0x48, 0x0f, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x96, 0x83, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x80, 0x80, 0x03, 0x30, 0x95, 0xca, 0x88, 0x48,
- 0x0c, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x98, 0x83, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x80, 0x80, 0x03, 0x30, 0x95, 0xc2, 0x88, 0x48, 0x09, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x99, 0x83, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x80, 0x80, 0x03, 0x30, 0x95, 0xc1, 0x88, 0x48,
- 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x97, 0x83, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x80, 0x80, 0x03, 0x30, 0x15, 0xc5, 0x88, 0x48, 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x9b, 0x83, 0x07, 0xf0, 0x85, 0x01, 0x88, 0x48, 0x80, 0x80, 0x03, 0x30, 0x95, 0xc6, 0x88, 0x4a,
- 0x14, 0x0a, 0x00, 0xf0, 0x06, 0x04, 0x30, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x04, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x99, 0x84, 0x07, 0xf0, 0x81, 0x06, 0xa8, 0x48,
- 0x14, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xfd, 0x95, 0x84, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x0b, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x96, 0x84, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0xc1, 0x00, 0x00, 0xe0, 0x82, 0x08, 0x80, 0x08,
- 0x00, 0x00, 0x00, 0xaf, 0x80, 0x08, 0x80, 0x08, 0x4e, 0x80, 0x01, 0xcf, 0x80, 0x80, 0xe1, 0x18,
- 0x01, 0x3e, 0x00, 0x00, 0x02, 0x06, 0x80, 0x30, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x01, 0x02, 0x00, 0xe0, 0x82, 0x00, 0x80, 0x08, 0x01, 0x00, 0x00, 0x80, 0x02, 0x06, 0x80, 0x30,
- 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8, 0x07, 0x10, 0x10, 0xf0, 0xa6, 0x00, 0x80, 0x00,
- 0x0e, 0x50, 0x04, 0xb0, 0x86, 0x08, 0xa4, 0x08, 0x00, 0x60, 0x00, 0x9f, 0x80, 0x08, 0xa5, 0x08,
- 0x0c, 0x85, 0xa1, 0xff, 0x9c, 0x0d, 0xc0, 0x40, 0x3d, 0x11, 0x41, 0x0f, 0xc0, 0x8b, 0xb1, 0x18,
- 0x00, 0x11, 0x01, 0x00, 0x80, 0x81, 0xb1, 0x18, 0x01, 0x90, 0x40, 0x00, 0x80, 0x80, 0xb1, 0x18,
- 0x02, 0x80, 0x19, 0x00, 0x7e, 0x0d, 0x80, 0x40, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
- 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
- 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x09, 0x00, 0x00, 0x00, 0x26, 0x35, 0x05, 0xc0,
- 0x0a, 0x00, 0x00, 0x00, 0x3b, 0xaa, 0xb8, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
- 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x13, 0x00, 0x00, 0x00, 0x14, 0x00, 0x0b, 0x00,
- 0xd0, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xc9, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
- 0xc1, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
- 0xbb, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
- 0xb2, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
- 0xab, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
- 0xa4, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
- 0xa0, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
- 0x99, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
- 0x91, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
- 0x8d, 0x00, 0x00, 0x00, 0x02, 0x04, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x61, 0x6c, 0x70, 0x68, 0x61, 0x43, 0x75, 0x74, 0x00, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x4f, 0x70,
- 0x00, 0x74, 0x69, 0x6e, 0x74, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x74, 0x65, 0x78, 0x45, 0x6e,
- 0x76, 0x00, 0x66, 0x6f, 0x67, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x00, 0x66, 0x6f, 0x67, 0x43, 0x6f,
- 0x6c, 0x6f, 0x72, 0x00, 0x74, 0x65, 0x78, 0x45, 0x6e, 0x76, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00,
- 0x66, 0x6f, 0x67, 0x5f, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x66, 0x6f, 0x67, 0x5f, 0x66, 0x61, 0x72,
- 0x00, 0x66, 0x6f, 0x67, 0x5f, 0x64, 0x65, 0x6e, 0x73, 0x69, 0x74, 0x79, 0x00, 0x74, 0x65, 0x78,
- 0x00, 0x00, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/texture2d_rgba_f.h b/deps/vitaGL/source/shaders/texture2d_rgba_f.h
deleted file mode 100644
index 494bce1638..0000000000
--- a/deps/vitaGL/source/shaders/texture2d_rgba_f.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef __texture2d_rgba_f__
-#define __texture2d_rgba_f__
-
-static unsigned int size_texture2d_rgba_f = 1320;
-static unsigned char texture2d_rgba_f[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0x27, 0x05, 0x00, 0x00, 0xf0, 0x40, 0x0f, 0xe9,
- 0x85, 0x99, 0xb7, 0x4d, 0x09, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x0c, 0x00, 0x1b, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x55, 0x00, 0x00, 0x00,
- 0xc0, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x98, 0x03, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x0b, 0x00, 0x00, 0x00, 0x34, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x03, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x7c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0x03, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x6c, 0x03, 0x00, 0x00, 0x18, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x02, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x00, 0xa9, 0xd0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
- 0x0f, 0xd0, 0xc0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x0d, 0x80, 0x68, 0xa3, 0xa6, 0x08, 0xc0, 0x08, 0xc7, 0x11, 0x04, 0xaf, 0xa4, 0x10, 0xa4, 0x08,
- 0x02, 0x3e, 0x40, 0x00, 0x02, 0x00, 0x80, 0x30, 0xc2, 0x81, 0xe4, 0xa1, 0x82, 0x10, 0x84, 0x08,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x04, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x44, 0xfa, 0x93, 0x81, 0x07, 0xf0, 0x81, 0x06, 0xa8, 0x48,
- 0x04, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x04, 0x02, 0x03, 0xa0, 0x8c, 0x0d, 0x80, 0x40,
- 0x06, 0x03, 0x43, 0xa0, 0x8e, 0x0d, 0x80, 0x40, 0x20, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x91, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x80, 0x00, 0x04, 0xa0, 0x84, 0x41, 0xa4, 0x08,
- 0xc1, 0x00, 0x04, 0xa1, 0x8a, 0x41, 0xc0, 0x08, 0x1b, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x92, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x13, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x94, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x09, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8, 0x02, 0x80, 0x99, 0xaf, 0xbc, 0x0d, 0xc0, 0x40,
- 0x02, 0x01, 0x5d, 0x8f, 0x84, 0x8b, 0xa1, 0x18, 0x41, 0x5f, 0x44, 0x1f, 0x84, 0x1b, 0xa5, 0x08,
- 0x40, 0x6f, 0x04, 0x10, 0x84, 0x09, 0xa5, 0x08, 0x40, 0x6f, 0x4d, 0x10, 0x82, 0x00, 0x81, 0x08,
- 0x03, 0x0f, 0x4c, 0x20, 0x02, 0x11, 0x80, 0x08, 0x10, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8, 0x02, 0x80, 0x99, 0xaf, 0xbc, 0x0d, 0xc0, 0x40,
- 0x06, 0x82, 0xa1, 0xaf, 0x9c, 0x0d, 0xc0, 0x40, 0x05, 0x01, 0x91, 0xdf, 0x80, 0x8b, 0xb1, 0x18,
- 0x3d, 0x21, 0x11, 0x00, 0xc0, 0x89, 0xb1, 0x18, 0xbd, 0xa0, 0x48, 0x00, 0xc2, 0x80, 0xb1, 0x18,
- 0x03, 0x0f, 0x4c, 0x20, 0x02, 0x11, 0x80, 0x08, 0x08, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8, 0x06, 0x82, 0x81, 0xaf, 0x9c, 0x0d, 0xc0, 0x40,
- 0x00, 0x01, 0x1d, 0x8f, 0xc4, 0x8b, 0xa1, 0x18, 0xc0, 0xc0, 0x13, 0xa0, 0x80, 0x81, 0xa0, 0x00,
- 0xc1, 0xc0, 0x5b, 0xa0, 0x82, 0x00, 0x80, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x08, 0x04, 0x43, 0xa0, 0x8e, 0x0d, 0x80, 0x40, 0x16, 0x81, 0x07, 0xf0, 0x81, 0x06, 0xa8, 0x48,
- 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x0c, 0xa0, 0x85, 0x01, 0x8b, 0x48,
- 0x12, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8, 0x11, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x80, 0x80, 0x03, 0xb0, 0x15, 0xc9, 0x88, 0x48, 0x0f, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x12, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x80, 0x80, 0x03, 0xb0, 0x95, 0xca, 0x88, 0x48,
- 0x0c, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x14, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x80, 0x80, 0x03, 0xb0, 0x95, 0xc2, 0x88, 0x48, 0x09, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x15, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48, 0x80, 0x80, 0x03, 0xb0, 0x95, 0xc1, 0x88, 0x48,
- 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x13, 0x81, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x80, 0x80, 0x03, 0xb0, 0x15, 0xc5, 0x88, 0x48, 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x17, 0x81, 0x07, 0xf0, 0x85, 0x01, 0x88, 0x48, 0x80, 0x80, 0x03, 0xb0, 0x95, 0xc6, 0x88, 0x4a,
- 0x10, 0x08, 0x00, 0xf0, 0x06, 0x04, 0x30, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x04, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x15, 0x82, 0x07, 0xf0, 0x81, 0x06, 0xa8, 0x48,
- 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x03, 0x00, 0x8e, 0x0d, 0x80, 0x40,
- 0x14, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8, 0x11, 0x82, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x0b, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x12, 0x82, 0x07, 0xf0, 0x81, 0x01, 0xa8, 0x48,
- 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9, 0x05, 0x80, 0x24, 0xe0, 0x82, 0x08, 0x84, 0x08,
- 0x00, 0x00, 0x00, 0xaf, 0x80, 0x08, 0x80, 0x08, 0x4c, 0x80, 0x01, 0xcf, 0x80, 0x80, 0xe1, 0x18,
- 0x01, 0x3e, 0x00, 0x00, 0x02, 0x06, 0x80, 0x30, 0x05, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8,
- 0x45, 0x03, 0x00, 0xe0, 0x82, 0x00, 0x80, 0x08, 0x01, 0x00, 0x00, 0x80, 0x02, 0x06, 0x80, 0x30,
- 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf8, 0x87, 0x50, 0x10, 0xf0, 0xa6, 0x00, 0x80, 0x00,
- 0x0c, 0x50, 0x04, 0xb0, 0x86, 0x08, 0xa4, 0x08, 0x00, 0x60, 0x00, 0x9f, 0x80, 0x08, 0xa5, 0x08,
- 0x08, 0x83, 0xa1, 0xff, 0x9c, 0x0d, 0xc0, 0x40, 0x3d, 0x11, 0x41, 0x0f, 0xc0, 0x8b, 0xb1, 0x18,
- 0x00, 0x11, 0x01, 0x00, 0x82, 0x81, 0xb1, 0x18, 0x01, 0x90, 0x40, 0x80, 0x82, 0x80, 0xb1, 0x18,
- 0x02, 0x80, 0x19, 0xa0, 0x7e, 0x0d, 0x80, 0x40, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
- 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
- 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x09, 0x00, 0x00, 0x00, 0x26, 0x35, 0x05, 0xc0,
- 0x0a, 0x00, 0x00, 0x00, 0x3b, 0xaa, 0xb8, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00,
- 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x13, 0x00, 0x00, 0x00, 0x10, 0x00, 0x0b, 0x00,
- 0xc0, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xb9, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
- 0xb1, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
- 0xa8, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
- 0xa1, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
- 0x9a, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
- 0x96, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
- 0x8f, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
- 0x87, 0x00, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
- 0x83, 0x00, 0x00, 0x00, 0x02, 0x04, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x61, 0x6c, 0x70, 0x68, 0x61, 0x43, 0x75, 0x74, 0x00, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x4f, 0x70,
- 0x00, 0x74, 0x65, 0x78, 0x45, 0x6e, 0x76, 0x00, 0x66, 0x6f, 0x67, 0x5f, 0x6d, 0x6f, 0x64, 0x65,
- 0x00, 0x66, 0x6f, 0x67, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x74, 0x65, 0x78, 0x45, 0x6e, 0x76,
- 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x66, 0x6f, 0x67, 0x5f, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x66,
- 0x6f, 0x67, 0x5f, 0x66, 0x61, 0x72, 0x00, 0x66, 0x6f, 0x67, 0x5f, 0x64, 0x65, 0x6e, 0x73, 0x69,
- 0x74, 0x79, 0x00, 0x74, 0x65, 0x78, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/texture2d_rgba_v.h b/deps/vitaGL/source/shaders/texture2d_rgba_v.h
deleted file mode 100644
index a233deec22..0000000000
--- a/deps/vitaGL/source/shaders/texture2d_rgba_v.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef __texture2d_rgba_v__
-#define __texture2d_rgba_v__
-
-static unsigned int size_texture2d_rgba_v = 668;
-static unsigned char texture2d_rgba_v[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0x99, 0x02, 0x00, 0x00, 0x03, 0x54, 0x4f, 0xaa,
- 0x6e, 0x7a, 0x89, 0x04, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x0c, 0x00, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x15, 0x00, 0x00, 0x00,
- 0xe0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x70, 0x01, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x54, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x01, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x54, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x0f, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x18, 0x00, 0x0b,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xa6,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x00, 0x60, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x05, 0x40, 0xa6,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x01, 0x64, 0x82, 0x02, 0x05, 0x80, 0x38, 0x07, 0x01, 0x83, 0xa5,
- 0x8e, 0x0d, 0x80, 0x40, 0x0f, 0x05, 0xc3, 0xa5, 0x8e, 0x0d, 0x80, 0x40, 0x05, 0x00, 0x03, 0xa5,
- 0x8e, 0x0d, 0x80, 0x40, 0x0d, 0x04, 0x43, 0xa5, 0x8e, 0x0d, 0x80, 0x40, 0x00, 0x00, 0x40, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x00, 0x04, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x04, 0x00, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x01, 0x00, 0x82, 0x02, 0x05, 0x84, 0x38, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x01, 0x0e, 0x01, 0x01, 0x02, 0x00, 0x10, 0xfa,
- 0x80, 0x00, 0x08, 0x83, 0x21, 0x25, 0x80, 0x38, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x10, 0xfa,
- 0x27, 0x90, 0x07, 0xf0, 0x81, 0x06, 0xc8, 0x48, 0xc0, 0x04, 0xf0, 0xc1, 0x00, 0x05, 0x80, 0x38,
- 0x41, 0x92, 0x40, 0x41, 0x81, 0x80, 0xd3, 0x18, 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8, 0x02, 0x80, 0x81, 0xaf, 0x9c, 0x0d, 0x80, 0x40,
- 0x08, 0xa2, 0xbd, 0xc0, 0x82, 0x38, 0x90, 0x18, 0x24, 0x91, 0x99, 0xff, 0xbc, 0x0d, 0x80, 0x40,
- 0x02, 0xa2, 0x51, 0x81, 0x81, 0x80, 0xd1, 0x18, 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8,
- 0x02, 0x80, 0x81, 0xaf, 0x9c, 0x0d, 0xc0, 0x40, 0x2e, 0x96, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40,
- 0x18, 0x11, 0x49, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 0x14, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18,
- 0x01, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 0x00, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18,
- 0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f,
- 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00,
- 0x13, 0x00, 0x00, 0x00, 0x26, 0x00, 0x02, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
- 0x00, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00,
- 0x77, 0x76, 0x70, 0x00, 0x63, 0x6c, 0x69, 0x70, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x30, 0x00,
- 0x63, 0x6c, 0x69, 0x70, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x30, 0x5f, 0x65, 0x71, 0x00, 0x6d,
- 0x6f, 0x64, 0x65, 0x6c, 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shaders/texture2d_v.h b/deps/vitaGL/source/shaders/texture2d_v.h
deleted file mode 100644
index 276c3abf17..0000000000
--- a/deps/vitaGL/source/shaders/texture2d_v.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef __texture2d_v__
-#define __texture2d_v__
-
-static unsigned int size_texture2d_v = 628;
-static unsigned char texture2d_v[] __attribute__((aligned(16))) = {
- 0x47, 0x58, 0x50, 0x00, 0x01, 0x05, 0x50, 0x03, 0x73, 0x02, 0x00, 0x00, 0xd5, 0xed, 0x20, 0x1e,
- 0xe4, 0x17, 0x9c, 0x83, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00,
- 0x08, 0x00, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x13, 0x00, 0x00, 0x00,
- 0xe0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0xc0, 0x3d, 0x03, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x01, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x01, 0x00, 0x00,
- 0x02, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 0x07,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xa6,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x00, 0x60, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x05, 0x40, 0xa6,
- 0x0a, 0x00, 0x81, 0x50, 0xc0, 0x01, 0x64, 0x82, 0x02, 0x05, 0x80, 0x38, 0x07, 0x01, 0x83, 0xa5,
- 0x8e, 0x0d, 0x80, 0x40, 0x0f, 0x05, 0xc3, 0xa5, 0x8e, 0x0d, 0x80, 0x40, 0x05, 0x00, 0x03, 0xa5,
- 0x8e, 0x0d, 0x80, 0x40, 0x0d, 0x04, 0x43, 0xa5, 0x8e, 0x0d, 0x80, 0x40, 0x00, 0x00, 0x40, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x00, 0x04, 0x82, 0x02, 0x05, 0x80, 0x38, 0x00, 0x04, 0x00, 0xa0,
- 0x0a, 0x00, 0x81, 0x50, 0x80, 0x01, 0x00, 0x82, 0x02, 0x05, 0x84, 0x38, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x44, 0xfa, 0x80, 0x00, 0x08, 0x83, 0x21, 0x05, 0x80, 0x38,
- 0x27, 0x90, 0x07, 0xf0, 0x81, 0x06, 0xc8, 0x48, 0xc0, 0x04, 0xf0, 0xc1, 0x00, 0x05, 0x80, 0x38,
- 0x41, 0x92, 0xc0, 0x40, 0x81, 0x80, 0xd3, 0x18, 0x06, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xf9,
- 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8, 0x02, 0x80, 0x81, 0xaf, 0x9c, 0x0d, 0x80, 0x40,
- 0x08, 0xa2, 0x3d, 0xc0, 0x81, 0x38, 0x90, 0x18, 0x24, 0x91, 0x99, 0xff, 0xbc, 0x0d, 0x80, 0x40,
- 0x00, 0xa2, 0xd1, 0x40, 0x81, 0x80, 0xd1, 0x18, 0x00, 0x00, 0x00, 0x00, 0x40, 0x09, 0x00, 0xf8,
- 0x02, 0x80, 0x81, 0xaf, 0x9c, 0x0d, 0xc0, 0x40, 0x2e, 0x96, 0xb9, 0xff, 0xbc, 0x0d, 0xc0, 0x40,
- 0x18, 0x11, 0x49, 0xcf, 0x80, 0x8f, 0xb1, 0x18, 0x14, 0x11, 0x45, 0xcf, 0x80, 0x8f, 0xb1, 0x18,
- 0x01, 0x11, 0x01, 0xc0, 0x81, 0x81, 0xb1, 0x18, 0x00, 0xd1, 0x42, 0xc0, 0x81, 0x81, 0xb1, 0x18,
- 0x00, 0x00, 0x20, 0xa0, 0x00, 0x50, 0x27, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f,
- 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00,
- 0x13, 0x00, 0x00, 0x00, 0x26, 0x00, 0x02, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x01, 0xe4, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
- 0x00, 0x74, 0x65, 0x78, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x00, 0x77, 0x76, 0x70, 0x00, 0x63, 0x6c,
- 0x69, 0x70, 0x5f, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x30, 0x00, 0x63, 0x6c, 0x69, 0x70, 0x5f, 0x70,
- 0x6c, 0x61, 0x6e, 0x65, 0x30, 0x5f, 0x65, 0x71, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x76, 0x69,
- 0x65, 0x77, 0x00, 0x00,
-};
-
-#endif
diff --git a/deps/vitaGL/source/shared.h b/deps/vitaGL/source/shared.h
deleted file mode 100644
index 5a1f41f11e..0000000000
--- a/deps/vitaGL/source/shared.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * shared.h:
- * All functions/definitions that shouldn't be exposed to
- * end users but are used in multiple source files must be here
- */
-
-#ifndef _SHARED_H_
-#define _SHARED_H_
-
-// Internal constants
-#define TEXTURES_NUM 16384 // Available textures
-#define COMPRESSED_TEXTURE_FORMATS_NUM 9 // The number of supported texture formats.
-#define MODELVIEW_STACK_DEPTH 32 // Depth of modelview matrix stack
-#define GENERIC_STACK_DEPTH 2 // Depth of generic matrix stack
-#define DISPLAY_WIDTH_DEF 960 // Default display width in pixels
-#define DISPLAY_HEIGHT_DEF 544 // Default display height in pixels
-#define DISPLAY_BUFFER_COUNT 2 // Display buffers to use
-#define GXM_TEX_MAX_SIZE 4096 // Maximum width/height in pixels per texture
-#define BUFFERS_ADDR 0xA000 // Starting address for buffers indexing
-#define BUFFERS_NUM 128 // Maximum number of allocatable buffers
-
-// Internal constants set in bootup phase
-extern int DISPLAY_WIDTH; // Display width in pixels
-extern int DISPLAY_HEIGHT; // Display height in pixels
-extern int DISPLAY_STRIDE; // Display stride in pixels
-extern float DISPLAY_WIDTH_FLOAT; // Display width in pixels (float)
-extern float DISPLAY_HEIGHT_FLOAT; // Display height in pixels (float)
-
-#include
-#include
-#include
-
-#include "vitaGL.h"
-
-#include "utils/gpu_utils.h"
-#include "utils/math_utils.h"
-#include "utils/mem_utils.h"
-
-#include "state.h"
-#include "texture_callbacks.h"
-
-#define SET_GL_ERROR(x) \
- vgl_error = x; \
- return;
-
-// Texture environment mode
-typedef enum texEnvMode {
- MODULATE = 0,
- DECAL = 1,
- BLEND = 2,
- ADD = 3,
- REPLACE = 4
-} texEnvMode;
-
-// 3D vertex for position + 4D vertex for RGBA color struct
-typedef struct rgba_vertex {
- vector3f position;
- vector4f color;
-} rgba_vertex;
-
-// 3D vertex for position + 3D vertex for RGB color struct
-typedef struct rgb_vertex {
- vector3f position;
- vector3f color;
-} rgb_vertex;
-
-// 3D vertex for position + 2D vertex for UV map struct
-typedef struct texture2d_vertex {
- vector3f position;
- vector2f texcoord;
-} texture2d_vertex;
-
-// Non native primitives implemented
-typedef enum SceGxmPrimitiveTypeExtra {
- SCE_GXM_PRIMITIVE_NONE = 0,
- SCE_GXM_PRIMITIVE_QUADS = 1
-} SceGxmPrimitiveTypeExtra;
-
-#include "shaders.h"
-
-// Internal stuffs
-extern void *frag_uniforms;
-extern void *vert_uniforms;
-extern SceGxmMultisampleMode msaa_mode;
-extern GLboolean use_extra_mem;
-
-// Debugging tool
-#ifdef ENABLE_LOG
-void LOG(const char *format, ...);
-#endif
-
-// Logging callback for vitaShaRK
-#if defined(HAVE_SHARK) && defined(HAVE_SHARK_LOG)
-void shark_log_cb(const char *msg, shark_log_level msg_level, int line);
-#endif
-
-// Depending on SDK, these could be or not defined
-#ifndef max
-#define max(a, b) ((a) > (b) ? (a) : (b))
-#endif
-#ifndef min
-#define min(a, b) ((a) < (b) ? (a) : (b))
-#endif
-
-extern uint8_t use_shark; // Flag to check if vitaShaRK should be initialized at vitaGL boot
-extern uint8_t is_shark_online; // Current vitaShaRK status
-
-// sceGxm viewport setup (NOTE: origin is on center screen)
-extern float x_port;
-extern float y_port;
-extern float z_port;
-extern float x_scale;
-extern float y_scale;
-extern float z_scale;
-
-// Fullscreen sceGxm viewport (NOTE: origin is on center screen)
-extern float fullscreen_x_port;
-extern float fullscreen_y_port;
-extern float fullscreen_z_port;
-extern float fullscreen_x_scale;
-extern float fullscreen_y_scale;
-extern float fullscreen_z_scale;
-
-extern SceGxmContext *gxm_context; // sceGxm context instance
-extern GLenum vgl_error; // Error returned by glGetError
-extern SceGxmShaderPatcher *gxm_shader_patcher; // sceGxmShaderPatcher shader patcher instance
-extern void *gxm_depth_surface_addr; // Depth surface memblock starting address
-extern uint8_t system_app_mode; // Flag for system app mode usage
-
-extern matrix4x4 mvp_matrix; // ModelViewProjection Matrix
-extern matrix4x4 projection_matrix; // Projection Matrix
-extern matrix4x4 modelview_matrix; // ModelView Matrix
-extern GLboolean mvp_modified; // Check if ModelViewProjection matrix needs to be recreated
-
-extern GLuint cur_program; // Current in use custom program (0 = No custom program)
-extern GLboolean vblank; // Current setting for VSync
-
-extern GLenum orig_depth_test; // Original depth test state (used for depth test invalidation)
-
-// Scissor test shaders
-extern SceGxmFragmentProgram *scissor_test_fragment_program; // Scissor test fragment program
-extern vector4f *scissor_test_vertices; // Scissor test region vertices
-extern SceUID scissor_test_vertices_uid; // Scissor test vertices memblock id
-
-extern uint16_t *depth_clear_indices; // Memblock starting address for clear screen indices
-
-// Clear screen shaders
-extern SceGxmVertexProgram *clear_vertex_program_patched; // Patched vertex program for clearing screen
-extern vector4f *clear_vertices; // Memblock starting address for clear screen vertices
-
-extern GLboolean fast_texture_compression; // Hints for texture compression
-
-/* gxm.c */
-void initGxm(void); // Inits sceGxm
-void initGxmContext(void); // Inits sceGxm context
-void termGxmContext(void); // Terms sceGxm context
-void createDisplayRenderTarget(void); // Creates render target for the display
-void destroyDisplayRenderTarget(void); // Destroys render target for the display
-void initDisplayColorSurfaces(void); // Creates color surfaces for the display
-void termDisplayColorSurfaces(void); // Destroys color surfaces for the display
-void initDepthStencilBuffer(uint32_t w, uint32_t h, SceGxmDepthStencilSurface *surface, void **depth_buffer, void **stencil_buffer, vglMemType *depth_type, vglMemType *stencil_type); // Creates depth and stencil surfaces
-void initDepthStencilSurfaces(void); // Creates depth and stencil surfaces for the display
-void termDepthStencilSurfaces(void); // Destroys depth and stencil surfaces for the display
-void startShaderPatcher(void); // Creates a shader patcher instance
-void stopShaderPatcher(void); // Destroys a shader patcher instance
-void waitRenderingDone(void); // Waits for rendering to be finished
-
-/* tests.c */
-void change_depth_write(SceGxmDepthWriteMode mode); // Changes current in use depth write mode
-void change_depth_func(void); // Changes current in use depth test function
-void invalidate_depth_test(void); // Invalidates depth test state
-void validate_depth_test(void); // Resets original depth test state after invalidation
-void change_stencil_settings(void); // Changes current in use stencil test parameters
-GLboolean change_stencil_config(SceGxmStencilOp *cfg, GLenum new); // Changes current in use stencil test operation value
-GLboolean change_stencil_func_config(SceGxmStencilFunc *cfg, GLenum new); // Changes current in use stencil test function value
-void update_alpha_test_settings(void); // Changes current in use alpha test operation value
-void update_scissor_test(void); // Changes current in use scissor test region
-void resetScissorTestRegion(void); // Resets scissor test region to default values
-
-/* blending.c */
-void change_blend_factor(void); // Changes current blending settings for all used shaders
-void disable_blend(void); // Disables blending for all used shaders
-
-/* custom_shaders.c */
-void resetCustomShaders(void); // Resets custom shaders
-void changeCustomShadersBlend(SceGxmBlendInfo *blend_info); // Change SceGxmBlendInfo value to all custom shaders
-void reloadCustomShader(void); // Reloads in use custom shader inside sceGxm
-void _vglDrawObjects_CustomShadersIMPL(GLenum mode, GLsizei count, GLboolean implicit_wvp); // vglDrawObjects implementation for rendering with custom shaders
-
-/* misc functions */
-void vector4f_convert_to_local_space(vector4f *out, int x, int y, int width, int height); // Converts screen coords to local space
-
-#endif
diff --git a/deps/vitaGL/source/state.c b/deps/vitaGL/source/state.c
deleted file mode 100644
index 2f7d928be5..0000000000
--- a/deps/vitaGL/source/state.c
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * state.c:
- * Initial config of the openGL machine state
- */
-
-#include "shared.h"
-
-// Blending
-GLboolean blend_state = GL_FALSE; // Current state for GL_BLEND
-SceGxmBlendFactor blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE; // Current in use RGB source blend factor
-SceGxmBlendFactor blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ZERO; // Current in use RGB dest blend factor
-SceGxmBlendFactor blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE; // Current in use A source blend factor
-SceGxmBlendFactor blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ZERO; // Current in use A dest blend factor
-
-// Polygon Mode
-GLfloat pol_factor = 0.0f; // Current factor for glPolygonOffset
-GLfloat pol_units = 0.0f; // Current units for glPolygonOffset
-
-// Texture Units
-int8_t client_texture_unit = 0; // Current in use client side texture unit
-
-// Miscellaneous
-glPhase phase = NONE; // Current drawing phase for legacy openGL
-vector4f clear_rgba_val; // Current clear color for glClear
-
-// Fogging
-GLboolean fogging = GL_FALSE; // Current fogging processor state
-GLint fog_mode = GL_EXP; // Current fogging mode (openGL)
-fogType internal_fog_mode = DISABLED; // Current fogging mode (sceGxm)
-GLfloat fog_density = 1.0f; // Current fogging density
-GLfloat fog_near = 0.0f; // Current fogging near distance
-GLfloat fog_far = 1.0f; // Current fogging far distance
-vector4f fog_color = { 0.0f, 0.0f, 0.0f, 0.0f }; // Current fogging color
-
-// Clipping Planes
-GLint clip_plane0 = GL_FALSE; // Current status of clip plane 0
-vector4f clip_plane0_eq = { 0.0f, 0.0f, 0.0f, 0.0f }; // Current equation of clip plane 0
-
-// Cullling
-GLboolean cull_face_state = GL_FALSE; // Current state for GL_CULL_FACE
-GLenum gl_cull_mode = GL_BACK; // Current in use openGL cull mode
-GLenum gl_front_face = GL_CCW; // Current in use openGL setting for front facing primitives
-GLboolean no_polygons_mode = GL_FALSE; // GL_TRUE when cull mode is set to GL_FRONT_AND_BACK
-
-// Polygon Offset
-GLboolean pol_offset_fill = GL_FALSE; // Current state for GL_POLYGON_OFFSET_FILL
-GLboolean pol_offset_line = GL_FALSE; // Current state for GL_POLYGON_OFFSET_LINE
-GLboolean pol_offset_point = GL_FALSE; // Current state for GL_POLYGON_OFFSET_POINT
-SceGxmPolygonMode polygon_mode_front = SCE_GXM_POLYGON_MODE_TRIANGLE_FILL; // Current in use polygon mode for front
-SceGxmPolygonMode polygon_mode_back = SCE_GXM_POLYGON_MODE_TRIANGLE_FILL; // Current in use polygon mode for back
-GLenum gl_polygon_mode_front = GL_FILL; // Current in use polygon mode for front
-GLenum gl_polygon_mode_back = GL_FILL; // Current in use polygon mode for back
-viewport gl_viewport; // Current viewport state
diff --git a/deps/vitaGL/source/state.h b/deps/vitaGL/source/state.h
deleted file mode 100644
index 2ff6e91e05..0000000000
--- a/deps/vitaGL/source/state.h
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * state.h:
- * Header file managing state of openGL machine
- */
-
-#ifndef _STATE_H_
-#define _STATE_H_
-
-// Drawing phases constants for legacy openGL
-typedef enum glPhase {
- NONE = 0,
- MODEL_CREATION = 1
-} glPhase;
-
-// Vertex array attributes struct
-typedef struct vertexArray {
- GLint size;
- GLint num;
- GLsizei stride;
- const GLvoid *pointer;
-} vertexArray;
-
-// Scissor test region struct
-typedef struct scissor_region {
- int x;
- int y;
- int w;
- int h;
-} scissor_region;
-
-// Viewport struct
-typedef struct viewport {
- int x;
- int y;
- int w;
- int h;
-} viewport;
-
-// Alpha operations for alpha testing
-typedef enum alphaOp {
- GREATER_EQUAL = 0,
- GREATER = 1,
- NOT_EQUAL = 2,
- EQUAL = 3,
- LESS_EQUAL = 4,
- LESS = 5,
- NEVER = 6,
- ALWAYS = 7
-} alphaOp;
-
-// Fog modes
-typedef enum fogType {
- LINEAR = 0,
- EXP = 1,
- EXP2 = 2,
- DISABLED = 3
-} fogType;
-
-// Texture unit struct
-typedef struct texture_unit {
- GLboolean enabled;
- GLboolean vertex_array_state;
- GLboolean color_array_state;
- GLboolean texture_array_state;
- matrix4x4 stack[GENERIC_STACK_DEPTH];
- vertexArray vertex_array;
- vertexArray color_array;
- vertexArray texture_array;
- GLenum color_object_type;
- void *vertex_object;
- void *color_object;
- void *texture_object;
- void *index_object;
- int env_mode;
- int tex_id;
-} texture_unit;
-
-// Framebuffer struct
-typedef struct framebuffer {
- uint8_t active;
- SceGxmRenderTarget *target;
- SceGxmColorSurface colorbuffer;
- SceGxmDepthStencilSurface depthbuffer;
- void *depth_buffer_addr;
- vglMemType depth_buffer_mem_type;
- void *stencil_buffer_addr;
- vglMemType stencil_buffer_mem_type;
- int width;
- int height;
-} framebuffer;
-
-// Blending
-extern GLboolean blend_state; // Current state for GL_BLEND
-extern SceGxmBlendFactor blend_sfactor_rgb; // Current in use RGB source blend factor
-extern SceGxmBlendFactor blend_dfactor_rgb; // Current in use RGB dest blend factor
-extern SceGxmBlendFactor blend_sfactor_a; // Current in use A source blend factor
-extern SceGxmBlendFactor blend_dfactor_a; // Current in use A dest blend factor
-
-// Depth Test
-extern GLboolean depth_test_state; // Current state for GL_DEPTH_TEST
-extern SceGxmDepthFunc gxm_depth; // Current in-use depth test func
-extern GLenum orig_depth_test; // Original depth test state (used for depth test invalidation)
-extern GLdouble depth_value; // Current depth test clear value
-extern GLboolean depth_mask_state; // Current state for glDepthMask
-
-// Scissor Test
-extern scissor_region region; // Current scissor test region setup
-extern GLboolean scissor_test_state; // Current state for GL_SCISSOR_TEST
-
-// Stencil Test
-extern uint8_t stencil_mask_front; // Current in use mask for stencil test on front
-extern uint8_t stencil_mask_back; // Current in use mask for stencil test on back
-extern uint8_t stencil_mask_front_write; // Current in use mask for write stencil test on front
-extern uint8_t stencil_mask_back_write; // Current in use mask for write stencil test on back
-extern uint8_t stencil_ref_front; // Current in use reference for stencil test on front
-extern uint8_t stencil_ref_back; // Current in use reference for stencil test on back
-extern SceGxmStencilOp stencil_fail_front; // Current in use stencil operation when stencil test fails for front
-extern SceGxmStencilOp depth_fail_front; // Current in use stencil operation when depth test fails for front
-extern SceGxmStencilOp depth_pass_front; // Current in use stencil operation when depth test passes for front
-extern SceGxmStencilOp stencil_fail_back; // Current in use stencil operation when stencil test fails for back
-extern SceGxmStencilOp depth_fail_back; // Current in use stencil operation when depth test fails for back
-extern SceGxmStencilOp depth_pass_back; // Current in use stencil operation when depth test passes for back
-extern SceGxmStencilFunc stencil_func_front; // Current in use stencil function on front
-extern SceGxmStencilFunc stencil_func_back; // Current in use stencil function on back
-extern GLboolean stencil_test_state; // Current state for GL_STENCIL_TEST
-extern GLint stencil_value; // Current stencil test clear value
-
-// Alpha Test
-extern GLenum alpha_func; // Current in use alpha test mode
-extern GLfloat alpha_ref; // Current in use alpha test reference value
-extern int alpha_op; // Current in use alpha test operation
-extern GLboolean alpha_test_state; // Current state for GL_ALPHA_TEST
-
-// Polygon Mode
-extern GLfloat pol_factor; // Current factor for glPolygonOffset
-extern GLfloat pol_units; // Current units for glPolygonOffset
-
-// Texture Units
-extern texture_unit texture_units[GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS]; // Available texture units
-extern texture vgl_textures[TEXTURES_NUM]; // Available texture slots
-extern int8_t server_texture_unit; // Current in use server side texture unit
-extern int8_t client_texture_unit; // Current in use client side texture unit
-extern palette *color_table; // Current in-use color table
-
-// Matrices
-extern matrix4x4 *matrix; // Current in-use matrix mode
-
-// Miscellaneous
-extern glPhase phase; // Current drawing phase for legacy openGL
-extern vector4f current_color; // Current in use color
-extern vector4f clear_rgba_val; // Current clear color for glClear
-extern viewport gl_viewport; // Current viewport state
-
-// Culling
-extern GLboolean no_polygons_mode; // GL_TRUE when cull mode is set to GL_FRONT_AND_BACK
-extern GLboolean cull_face_state; // Current state for GL_CULL_FACE
-extern GLenum gl_cull_mode; // Current in use openGL cull mode
-extern GLenum gl_front_face; // Current in use openGL setting for front facing primitives
-
-// Polygon Offset
-extern GLboolean pol_offset_fill; // Current state for GL_POLYGON_OFFSET_FILL
-extern GLboolean pol_offset_line; // Current state for GL_POLYGON_OFFSET_LINE
-extern GLboolean pol_offset_point; // Current state for GL_POLYGON_OFFSET_POINT
-extern SceGxmPolygonMode polygon_mode_front; // Current in use polygon mode for front
-extern SceGxmPolygonMode polygon_mode_back; // Current in use polygon mode for back
-extern GLenum gl_polygon_mode_front; // Current in use polygon mode for front
-extern GLenum gl_polygon_mode_back; // Current in use polygon mode for back
-
-// Texture Environment
-extern vector4f texenv_color; // Current in use texture environment color
-
-// Fogging
-extern GLboolean fogging; // Current fogging processor state
-extern GLint fog_mode; // Current fogging mode (openGL)
-extern fogType internal_fog_mode; // Current fogging mode (sceGxm)
-extern GLfloat fog_density; // Current fogging density
-extern GLfloat fog_near; // Current fogging near distance
-extern GLfloat fog_far; // Current fogging far distance
-extern vector4f fog_color; // Current fogging color
-
-// Clipping Planes
-extern GLint clip_plane0; // Current status of clip plane 0
-extern vector4f clip_plane0_eq; // Current equation of clip plane 0
-
-// Framebuffers
-extern framebuffer *active_read_fb; // Current readback framebuffer in use
-extern framebuffer *active_write_fb; // Current write framebuffer in use
-
-#endif
diff --git a/deps/vitaGL/source/tests.c b/deps/vitaGL/source/tests.c
deleted file mode 100644
index 8e0251412a..0000000000
--- a/deps/vitaGL/source/tests.c
+++ /dev/null
@@ -1,510 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * tests.c:
- * Implementation for all drawing tests functions
- */
-
-#include "shared.h"
-
-// Depth Test
-GLboolean depth_test_state = GL_FALSE; // Current state for GL_DEPTH_TEST
-SceGxmDepthFunc gxm_depth = SCE_GXM_DEPTH_FUNC_LESS; // Current in-use depth test func
-GLenum orig_depth_test; // Original depth test state (used for depth test invalidation)
-GLdouble depth_value = 1.0f; // Current depth test clear value
-GLboolean depth_mask_state = GL_TRUE; // Current state for glDepthMask
-
-// Scissor Test
-scissor_region region; // Current scissor test region setup
-GLboolean scissor_test_state = GL_FALSE; // Current state for GL_SCISSOR_TEST
-SceGxmFragmentProgram *scissor_test_fragment_program; // Scissor test fragment program
-vector4f *scissor_test_vertices = NULL; // Scissor test region vertices
-SceUID scissor_test_vertices_uid; // Scissor test vertices memblock id
-
-// Stencil Test
-uint8_t stencil_mask_front = 0xFF; // Current in use mask for stencil test on front
-uint8_t stencil_mask_back = 0xFF; // Current in use mask for stencil test on back
-uint8_t stencil_mask_front_write = 0xFF; // Current in use mask for write stencil test on front
-uint8_t stencil_mask_back_write = 0xFF; // Current in use mask for write stencil test on back
-uint8_t stencil_ref_front = 0; // Current in use reference for stencil test on front
-uint8_t stencil_ref_back = 0; // Current in use reference for stencil test on back
-SceGxmStencilOp stencil_fail_front = SCE_GXM_STENCIL_OP_KEEP; // Current in use stencil operation when stencil test fails for front
-SceGxmStencilOp depth_fail_front = SCE_GXM_STENCIL_OP_KEEP; // Current in use stencil operation when depth test fails for front
-SceGxmStencilOp depth_pass_front = SCE_GXM_STENCIL_OP_KEEP; // Current in use stencil operation when depth test passes for front
-SceGxmStencilOp stencil_fail_back = SCE_GXM_STENCIL_OP_KEEP; // Current in use stencil operation when stencil test fails for back
-SceGxmStencilOp depth_fail_back = SCE_GXM_STENCIL_OP_KEEP; // Current in use stencil operation when depth test fails for back
-SceGxmStencilOp depth_pass_back = SCE_GXM_STENCIL_OP_KEEP; // Current in use stencil operation when depth test passes for back
-SceGxmStencilFunc stencil_func_front = SCE_GXM_STENCIL_FUNC_ALWAYS; // Current in use stencil function on front
-SceGxmStencilFunc stencil_func_back = SCE_GXM_STENCIL_FUNC_ALWAYS; // Current in use stencil function on back
-GLboolean stencil_test_state = GL_FALSE; // Current state for GL_STENCIL_TEST
-GLint stencil_value = 0; // Current stencil test clear value
-
-// Alpha Test
-GLenum alpha_func = GL_ALWAYS; // Current in-use alpha test mode
-GLfloat alpha_ref = 0.0f; // Current in use alpha test reference value
-int alpha_op = ALWAYS; // Current in use alpha test operation
-GLboolean alpha_test_state = GL_FALSE; // Current state for GL_ALPHA_TEST
-
-void change_depth_write(SceGxmDepthWriteMode mode) {
- // Change depth write mode for both front and back primitives
- sceGxmSetFrontDepthWriteEnable(gxm_context, mode);
- sceGxmSetBackDepthWriteEnable(gxm_context, mode);
-}
-
-void change_depth_func() {
- // Setting depth function for both front and back primitives
- sceGxmSetFrontDepthFunc(gxm_context, depth_test_state ? gxm_depth : SCE_GXM_DEPTH_FUNC_ALWAYS);
- sceGxmSetBackDepthFunc(gxm_context, depth_test_state ? gxm_depth : SCE_GXM_DEPTH_FUNC_ALWAYS);
-
- // Calling an update for the depth write mode
- change_depth_write(depth_mask_state ? SCE_GXM_DEPTH_WRITE_ENABLED : SCE_GXM_DEPTH_WRITE_DISABLED);
-}
-
-void invalidate_depth_test() {
- // Invalidating current depth test state
- orig_depth_test = depth_test_state;
- depth_test_state = GL_FALSE;
-
- // Invoking a depth function update
- change_depth_func();
-}
-
-void validate_depth_test() {
- // Restoring original depth test state
- depth_test_state = orig_depth_test;
-
- // Invoking a depth function update
- change_depth_func();
-}
-
-void invalidate_viewport() {
- // Invalidating current viewport
- sceGxmSetViewport(gxm_context, fullscreen_x_port, fullscreen_x_scale, fullscreen_y_port, fullscreen_y_scale, fullscreen_z_port, fullscreen_z_scale);
-}
-
-void validate_viewport() {
- // Restoring original viewport
- sceGxmSetViewport(gxm_context, x_port, x_scale, y_port, y_scale, z_port, z_scale);
-}
-
-void change_stencil_settings() {
- if (stencil_test_state) {
- // Setting stencil function for both front and back primitives
- sceGxmSetFrontStencilFunc(gxm_context,
- stencil_func_front,
- stencil_fail_front,
- depth_fail_front,
- depth_pass_front,
- stencil_mask_front, stencil_mask_front_write);
- sceGxmSetBackStencilFunc(gxm_context,
- stencil_func_back,
- stencil_fail_back,
- depth_fail_back,
- depth_pass_back,
- stencil_mask_back, stencil_mask_back_write);
-
- // Setting stencil ref for both front and back primitives
- sceGxmSetFrontStencilRef(gxm_context, stencil_ref_front);
- sceGxmSetBackStencilRef(gxm_context, stencil_ref_back);
-
- } else {
- sceGxmSetFrontStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_ALWAYS,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- 0, 0);
- sceGxmSetBackStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_ALWAYS,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- 0, 0);
- }
-}
-
-GLboolean change_stencil_config(SceGxmStencilOp *cfg, GLenum new) {
- // Translating openGL stencil operation value to sceGxm one
- GLboolean ret = GL_TRUE;
- switch (new) {
- case GL_KEEP:
- *cfg = SCE_GXM_STENCIL_OP_KEEP;
- break;
- case GL_ZERO:
- *cfg = SCE_GXM_STENCIL_OP_ZERO;
- break;
- case GL_REPLACE:
- *cfg = SCE_GXM_STENCIL_OP_REPLACE;
- break;
- case GL_INCR:
- *cfg = SCE_GXM_STENCIL_OP_INCR;
- break;
- case GL_INCR_WRAP:
- *cfg = SCE_GXM_STENCIL_OP_INCR_WRAP;
- break;
- case GL_DECR:
- *cfg = SCE_GXM_STENCIL_OP_DECR;
- break;
- case GL_DECR_WRAP:
- *cfg = SCE_GXM_STENCIL_OP_DECR_WRAP;
- break;
- case GL_INVERT:
- *cfg = SCE_GXM_STENCIL_OP_INVERT;
- break;
- default:
- ret = GL_FALSE;
- break;
- }
- return ret;
-}
-
-GLboolean change_stencil_func_config(SceGxmStencilFunc *cfg, GLenum new) {
- // Translating openGL stencil function to sceGxm one
- GLboolean ret = GL_TRUE;
- switch (new) {
- case GL_NEVER:
- *cfg = SCE_GXM_STENCIL_FUNC_NEVER;
- break;
- case GL_LESS:
- *cfg = SCE_GXM_STENCIL_FUNC_LESS;
- break;
- case GL_LEQUAL:
- *cfg = SCE_GXM_STENCIL_FUNC_LESS_EQUAL;
- break;
- case GL_GREATER:
- *cfg = SCE_GXM_STENCIL_FUNC_GREATER;
- break;
- case GL_GEQUAL:
- *cfg = SCE_GXM_STENCIL_FUNC_GREATER_EQUAL;
- break;
- case GL_EQUAL:
- *cfg = SCE_GXM_STENCIL_FUNC_EQUAL;
- break;
- case GL_NOTEQUAL:
- *cfg = SCE_GXM_STENCIL_FUNC_NOT_EQUAL;
- break;
- case GL_ALWAYS:
- *cfg = SCE_GXM_STENCIL_FUNC_ALWAYS;
- break;
- default:
- ret = GL_FALSE;
- break;
- }
- return ret;
-}
-
-void update_alpha_test_settings() {
- // Translating openGL alpha test operation to internal one
- if (alpha_test_state) {
- switch (alpha_func) {
- case GL_EQUAL:
- alpha_op = EQUAL;
- break;
- case GL_LEQUAL:
- alpha_op = LESS_EQUAL;
- break;
- case GL_GEQUAL:
- alpha_op = GREATER_EQUAL;
- break;
- case GL_LESS:
- alpha_op = LESS;
- break;
- case GL_GREATER:
- alpha_op = GREATER;
- break;
- case GL_NOTEQUAL:
- alpha_op = NOT_EQUAL;
- break;
- case GL_NEVER:
- alpha_op = NEVER;
- break;
- default:
- alpha_op = ALWAYS;
- break;
- }
- } else
- alpha_op = ALWAYS;
-}
-
-void update_scissor_test() {
- // Setting current vertex program to clear screen one and fragment program to scissor test one
- sceGxmSetVertexProgram(gxm_context, clear_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, scissor_test_fragment_program);
-
- // Invalidating viewport
- invalidate_viewport();
-
- // Invalidating internal tile based region clip
- sceGxmSetRegionClip(gxm_context, SCE_GXM_REGION_CLIP_OUTSIDE, 0, 0, DISPLAY_WIDTH - 1, DISPLAY_HEIGHT - 1);
-
- if (scissor_test_state) {
- // Calculating scissor test region vertices
- vector4f_convert_to_local_space(scissor_test_vertices, region.x, region.y, region.w, region.h);
-
- void *vertex_buffer;
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_buffer);
- sceGxmSetUniformDataF(vertex_buffer, clear_position, 0, 4, &clear_vertices->x);
-
- // Cleaning stencil surface mask update bit on the whole screen
- sceGxmSetFrontStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_NEVER,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- 0, 0);
- sceGxmSetBackStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_NEVER,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- 0, 0);
- sceGxmDraw(gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_FAN, SCE_GXM_INDEX_FORMAT_U16, depth_clear_indices, 4);
- }
-
- // Setting stencil surface mask update bit on the scissor test region
- sceGxmSetFrontStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_ALWAYS,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- 0, 0);
- sceGxmSetBackStencilFunc(gxm_context,
- SCE_GXM_STENCIL_FUNC_ALWAYS,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- SCE_GXM_STENCIL_OP_KEEP,
- 0, 0);
-
- void *vertex_buffer;
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_buffer);
- if (scissor_test_state)
- sceGxmSetUniformDataF(vertex_buffer, clear_position, 0, 4, &scissor_test_vertices->x);
- else
- sceGxmSetUniformDataF(vertex_buffer, clear_position, 0, 4, &clear_vertices->x);
- sceGxmDraw(gxm_context, SCE_GXM_PRIMITIVE_TRIANGLE_FAN, SCE_GXM_INDEX_FORMAT_U16, depth_clear_indices, 4);
-
- // Restoring viewport
- validate_viewport();
-
- // Reducing GPU workload by performing tile granularity clipping
- if (scissor_test_state)
- sceGxmSetRegionClip(gxm_context, SCE_GXM_REGION_CLIP_OUTSIDE, region.x, region.y, region.x + region.w - 1, region.y + region.h - 1);
-
- // Restoring original stencil test settings
- change_stencil_settings();
-}
-
-void resetScissorTestRegion(void) {
- // Setting scissor test region to default values
- region.x = region.y = 0;
- region.w = DISPLAY_WIDTH;
- region.h = DISPLAY_HEIGHT;
-}
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if ((width < 0) || (height < 0)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Converting openGL scissor test region to sceGxm one
- region.x = x;
- region.y = DISPLAY_HEIGHT - y - height;
- region.w = width;
- region.h = height;
-
- // Updating in use scissor test parameters if GL_SCISSOR_TEST is enabled
- if (scissor_test_state)
- update_scissor_test();
-}
-
-void glDepthFunc(GLenum func) {
- // Properly translating openGL function to sceGxm one
- switch (func) {
- case GL_NEVER:
- gxm_depth = SCE_GXM_DEPTH_FUNC_NEVER;
- break;
- case GL_LESS:
- gxm_depth = SCE_GXM_DEPTH_FUNC_LESS;
- break;
- case GL_EQUAL:
- gxm_depth = SCE_GXM_DEPTH_FUNC_EQUAL;
- break;
- case GL_LEQUAL:
- gxm_depth = SCE_GXM_DEPTH_FUNC_LESS_EQUAL;
- break;
- case GL_GREATER:
- gxm_depth = SCE_GXM_DEPTH_FUNC_GREATER;
- break;
- case GL_NOTEQUAL:
- gxm_depth = SCE_GXM_DEPTH_FUNC_NOT_EQUAL;
- break;
- case GL_GEQUAL:
- gxm_depth = SCE_GXM_DEPTH_FUNC_GREATER_EQUAL;
- break;
- case GL_ALWAYS:
- gxm_depth = SCE_GXM_DEPTH_FUNC_ALWAYS;
- break;
- }
-
- // Updating in use depth function
- change_depth_func();
-}
-
-void glClearDepth(GLdouble depth) {
- // Set current in use depth test depth value
- depth_value = depth;
-}
-
-void glDepthMask(GLboolean flag) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- // Set current in use depth mask and invoking a depth write mode update
- depth_mask_state = flag;
- change_depth_write(depth_mask_state ? SCE_GXM_DEPTH_WRITE_ENABLED : SCE_GXM_DEPTH_WRITE_DISABLED);
-}
-
-void glAlphaFunc(GLenum func, GLfloat ref) {
- // Updating in use alpha test parameters
- alpha_func = func;
- alpha_ref = ref;
- update_alpha_test_settings();
-}
-
-void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
- // Properly updating stencil operation settings
- switch (face) {
- case GL_FRONT:
- if (!change_stencil_config(&stencil_fail_front, sfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_fail_front, dpfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_pass_front, dppass))
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- case GL_BACK:
- if (!change_stencil_config(&stencil_fail_back, sfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_fail_back, dpfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_pass_front, dppass))
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- case GL_FRONT_AND_BACK:
- if (!change_stencil_config(&stencil_fail_front, sfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&stencil_fail_back, sfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_fail_front, dpfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_fail_back, dpfail))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_pass_front, dppass))
- SET_GL_ERROR(GL_INVALID_ENUM)
- if (!change_stencil_config(&depth_pass_back, dppass))
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- change_stencil_settings();
-}
-
-void glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) {
- glStencilOpSeparate(GL_FRONT_AND_BACK, sfail, dpfail, dppass);
-}
-
-void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
- // Properly updating stencil test function settings
- switch (face) {
- case GL_FRONT:
- if (!change_stencil_func_config(&stencil_func_front, func)) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- }
- stencil_mask_front = mask;
- stencil_ref_front = ref;
- break;
- case GL_BACK:
- if (!change_stencil_func_config(&stencil_func_back, func)) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- }
- stencil_mask_back = mask;
- stencil_ref_back = ref;
- break;
- case GL_FRONT_AND_BACK:
- if (!change_stencil_func_config(&stencil_func_front, func)) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- }
- if (!change_stencil_func_config(&stencil_func_back, func)) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- }
- stencil_mask_front = stencil_mask_back = mask;
- stencil_ref_front = stencil_ref_back = ref;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- change_stencil_settings();
-}
-
-void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
- glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
-}
-
-void glStencilMaskSeparate(GLenum face, GLuint mask) {
- // Properly updating stencil test mask settings
- switch (face) {
- case GL_FRONT:
- stencil_mask_front_write = mask;
- break;
- case GL_BACK:
- stencil_mask_back_write = mask;
- break;
- case GL_FRONT_AND_BACK:
- stencil_mask_front_write = stencil_mask_back_write = mask;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- return;
- }
- change_stencil_settings();
-}
-
-void glStencilMask(GLuint mask) {
- glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
-}
-
-void glClearStencil(GLint s) {
- stencil_value = s;
-}
diff --git a/deps/vitaGL/source/texture_callbacks.c b/deps/vitaGL/source/texture_callbacks.c
deleted file mode 100644
index d23cc227a8..0000000000
--- a/deps/vitaGL/source/texture_callbacks.c
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * texture_callbacks.c:
- * Implementation for texture data reading/writing callbacks
- */
-
-#include
-#include
-
-#include "vitaGL.h"
-#include "texture_callbacks.h"
-
-#define convert_u16_to_u32_cspace(color, lshift, rshift, mask) ((((color << lshift) >> rshift) & mask) * 0xFF) / mask
-
-// Read callback for 32bpp unsigned ABGR format
-uint32_t readBGRA(void *data) {
- uint32_t res;
- memcpy_neon(&res, data, 4);
- uint8_t *p = (uint8_t *)&res;
- uint8_t tmp = p[0];
- p[0] = p[2];
- p[2] = tmp;
- return res;
-}
-
-// Read callback for 32bpp unsigned RGBA format
-uint32_t readRGBA(void *data) {
- uint32_t res;
- memcpy_neon(&res, data, 4);
- return res;
-}
-
-// Read callback for 16bpp unsigned RGBA5551 format
-uint32_t readRGBA5551(void *data) {
- uint16_t clr;
- uint32_t r, g, b, a;
- memcpy_neon(&clr, data, 2);
- r = convert_u16_to_u32_cspace(clr, 0, 11, 0x1F);
- g = convert_u16_to_u32_cspace(clr, 5, 11, 0x1F);
- b = convert_u16_to_u32_cspace(clr, 10, 11, 0x1F);
- a = convert_u16_to_u32_cspace(clr, 15, 15, 0x01);
- return ((a << 24) | (b << 16) | (g << 8) | r);
-}
-
-// Read callback for 16bpp unsigned RGBA4444 format
-uint32_t readRGBA4444(void *data) {
- uint16_t clr;
- uint32_t r, g, b, a;
- memcpy_neon(&clr, data, 2);
- r = convert_u16_to_u32_cspace(clr, 0, 12, 0x0F);
- g = convert_u16_to_u32_cspace(clr, 4, 12, 0x0F);
- b = convert_u16_to_u32_cspace(clr, 8, 12, 0x0F);
- a = convert_u16_to_u32_cspace(clr, 12, 12, 0x0F);
- return ((a << 24) | (b << 16) | (g << 8) | r);
-}
-
-// Read callback for 16bpp unsigned RGB565 format
-uint32_t readRGB565(void *data) {
- uint16_t clr;
- uint32_t r, g, b;
- memcpy_neon(&clr, data, 2);
- r = convert_u16_to_u32_cspace(clr, 0, 11, 0x1F);
- g = convert_u16_to_u32_cspace(clr, 5, 10, 0x3F);
- b = convert_u16_to_u32_cspace(clr, 11, 11, 0x1F);
- return ((0xFF << 24) | (b << 16) | (g << 8) | r);
-}
-
-// Read callback for 24bpp unsigned BGR format
-uint32_t readBGR(void *data) {
- uint32_t res = 0xFFFFFFFF;
- uint8_t *src = (uint8_t *)data;
- uint8_t *dst = (uint8_t *)res;
- dst[0] = src[2];
- dst[1] = src[1];
- dst[2] = src[0];
- return res;
-}
-
-// Read callback for 24bpp unsigned RGB format
-uint32_t readRGB(void *data) {
- uint32_t res = 0xFFFFFFFF;
- memcpy_neon(&res, data, 3);
- return res;
-}
-
-// Read callback for 16bpp unsigned RG format
-uint32_t readRG(void *data) {
- uint32_t res = 0xFFFFFFFF;
- memcpy_neon(&res, data, 2);
- return res;
-}
-
-// Read callback for 8bpp unsigned R format
-uint32_t readR(void *data) {
- uint32_t res = 0xFFFFFFFF;
- memcpy_neon(&res, data, 1);
- return res;
-}
-
-// Write callback for 32bpp unsigned RGBA format
-void writeRGBA(void *data, uint32_t color) {
- memcpy_neon(data, &color, 4);
-}
-
-// Write callback for 32bpp unsigned BGRA format
-void writeBGRA(void *data, uint32_t color) {
- memcpy_neon(data, &color, 4);
- uint8_t *p = (uint8_t *)data;
- uint8_t tmp = p[0];
- p[0] = p[2];
- p[2] = tmp;
-}
-
-// Write callback for 24bpp unsigned RGB format
-void writeRGB(void *data, uint32_t color) {
- memcpy_neon(data, &color, 3);
-}
-
-// Write callback for 24bpp unsigned BGR format
-void writeBGR(void *data, uint32_t color) {
- uint8_t *src = (uint8_t *)&color;
- uint8_t *dst = (uint8_t *)data;
- dst[0] = src[2];
- dst[1] = src[1];
- dst[2] = src[0];
-}
-
-// Write callback for 16bpp unsigned RG format
-void writeRG(void *data, uint32_t color) {
- memcpy_neon(data, &color, 2);
-}
-
-// Write callback for 16bpp unsigned RA format
-void writeRA(void *data, uint32_t color) {
- uint8_t *dst = (uint8_t *)data;
- uint8_t *src = (uint8_t *)&color;
- dst[0] = src[0];
- dst[1] = src[3];
-}
-
-// Write callback for 8bpp unsigned R format
-void writeR(void *data, uint32_t color) {
- memcpy_neon(data, &color, 1);
-}
\ No newline at end of file
diff --git a/deps/vitaGL/source/texture_callbacks.h b/deps/vitaGL/source/texture_callbacks.h
deleted file mode 100644
index bff9541963..0000000000
--- a/deps/vitaGL/source/texture_callbacks.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * texture_callbacks.h:
- * Header file for texture data reading/writing callbacks exposed by texture_callbacks.c
- */
-
-#ifndef _TEXTURE_CALLBACKS_H_
-#define _TEXTURE_CALLBACKS_H_
-
-// Read callbacks
-uint32_t readR(void *data);
-uint32_t readRG(void *data);
-uint32_t readRGB(void *data);
-uint32_t readBGR(void *data);
-uint32_t readRGB565(void *data);
-uint32_t readRGBA(void *data);
-uint32_t readBGRA(void *data);
-uint32_t readRGBA5551(void *data);
-uint32_t readRGBA4444(void *data);
-
-// Write callbacks
-void writeR(void *data, uint32_t color);
-void writeRG(void *data, uint32_t color);
-void writeRA(void *data, uint32_t color);
-void writeRGB(void *data, uint32_t color);
-void writeBGR(void *data, uint32_t color);
-void writeRGBA(void *data, uint32_t color);
-void writeBGRA(void *data, uint32_t color);
-
-#endif
diff --git a/deps/vitaGL/source/textures.c b/deps/vitaGL/source/textures.c
deleted file mode 100644
index 9f6b3c350a..0000000000
--- a/deps/vitaGL/source/textures.c
+++ /dev/null
@@ -1,980 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * textures.c:
- * Implementation for textures related functions
- */
-
-#include "shared.h"
-
-texture_unit texture_units[GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS]; // Available texture units
-texture vgl_textures[TEXTURES_NUM]; // Available texture slots
-palette *color_table = NULL; // Current in-use color table
-int8_t server_texture_unit = 0; // Current in use server side texture unit
-
-/*
- * ------------------------------
- * - IMPLEMENTATION STARTS HERE -
- * ------------------------------
- */
-
-void glGenTextures(GLsizei n, GLuint *res) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (n < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Aliasing to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
-
- // Reserving a texture and returning its id if available
- int i, j = 0;
- for (i = 1; i < TEXTURES_NUM; i++) {
- if (!(vgl_textures[i].used)) {
- res[j++] = i;
- vgl_textures[i].used = 1;
-
- // Resetting texture parameters to their default values
- vgl_textures[i].min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- vgl_textures[i].mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- vgl_textures[i].mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- vgl_textures[i].u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT;
- vgl_textures[i].v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT;
- vgl_textures[i].lod_bias = GL_MAX_TEXTURE_LOD_BIAS; // sceGxm range is 0 - (GL_MAX_TEXTURE_LOD_BIAS*2 + 1)
- }
- if (j >= n)
- break;
- }
-}
-
-void glBindTexture(GLenum target, GLuint texture) {
- // Aliasing to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
-
- // Setting current in use texture id for the in use server texture unit
- switch (target) {
- case GL_TEXTURE_2D:
- tex_unit->tex_id = texture;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glDeleteTextures(GLsizei n, const GLuint *gl_textures) {
-#ifndef SKIP_ERROR_HANDLING
- // Error handling
- if (n < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Aliasing to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
-
- // Deallocating given vgl_textures and invalidating used texture ids
- int j;
- for (j = 0; j < n; j++) {
- GLuint i = gl_textures[j];
- if (i > 0) {
- vgl_textures[i].used = 0;
-
- // Resetting texture parameters to their default values
- vgl_textures[i].min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- vgl_textures[i].mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- vgl_textures[i].mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- vgl_textures[i].u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT;
- vgl_textures[i].v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT;
- vgl_textures[i].lod_bias = GL_MAX_TEXTURE_LOD_BIAS; // sceGxm range is 0 - (GL_MAX_TEXTURE_LOD_BIAS*2 + 1)
-
- gpu_free_texture(&vgl_textures[i]);
- if (i == tex_unit->tex_id)
- tex_unit->tex_id = 0;
- }
- }
-}
-
-void glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *data) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- SceGxmTextureFormat tex_format;
- uint8_t data_bpp = 0;
- uint8_t fast_store = GL_FALSE;
-
- // Support for legacy GL1.0 internalFormat
- switch (internalFormat) {
- case 1:
- internalFormat = GL_RED;
- break;
- case 2:
- internalFormat = GL_RG;
- break;
- case 3:
- internalFormat = GL_RGB;
- break;
- case 4:
- internalFormat = GL_RGBA;
- break;
- }
-
- /*
- * Callbacks are actually used to just perform down/up-sampling
- * between U8 texture formats. Reads are expected to give as result
- * a RGBA sample that will be wrote depending on texture format
- * by the write callback
- */
- void (*write_cb)(void *, uint32_t) = NULL;
- uint32_t (*read_cb)(void *) = NULL;
-
- // Detecting proper read callaback and source bpp
- switch (format) {
- case GL_RED:
- case GL_ALPHA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- read_cb = readR;
- data_bpp = 1;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RG:
- case GL_LUMINANCE_ALPHA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- read_cb = readRG;
- data_bpp = 2;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_BGR:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 3;
- if (internalFormat == GL_BGR)
- fast_store = GL_TRUE;
- else
- read_cb = readBGR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RGB:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 3;
- if (internalFormat == GL_RGB)
- fast_store = GL_TRUE;
- else
- read_cb = readRGB;
- break;
- case GL_UNSIGNED_SHORT_5_6_5:
- data_bpp = 2;
- read_cb = readRGB565;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_BGRA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 4;
- if (internalFormat == GL_BGRA)
- fast_store = GL_TRUE;
- else
- read_cb = readBGRA;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RGBA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 4;
- if (internalFormat == GL_RGBA)
- fast_store = GL_TRUE;
- else
- read_cb = readRGBA;
- break;
- case GL_UNSIGNED_SHORT_5_5_5_1:
- data_bpp = 2;
- read_cb = readRGBA5551;
- break;
- case GL_UNSIGNED_SHORT_4_4_4_4:
- data_bpp = 2;
- read_cb = readRGBA4444;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- }
-
- switch (target) {
- case GL_TEXTURE_2D:
-
- // Detecting proper write callback and texture format
- switch (internalFormat) {
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
- tex_format = SCE_GXM_TEXTURE_FORMAT_UBC1_ABGR;
- break;
- case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
- tex_format = SCE_GXM_TEXTURE_FORMAT_UBC3_ABGR;
- break;
- case GL_RGB:
- write_cb = writeRGB;
- tex_format = SCE_GXM_TEXTURE_FORMAT_U8U8U8_BGR;
- break;
- case GL_BGR:
- write_cb = writeBGR;
- tex_format = SCE_GXM_TEXTURE_FORMAT_U8U8U8_RGB;
- break;
- case GL_RGBA:
- write_cb = writeRGBA;
- tex_format = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR;
- break;
- case GL_BGRA:
- write_cb = writeBGRA;
- tex_format = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ARGB;
- break;
- case GL_LUMINANCE:
- write_cb = writeR;
- tex_format = SCE_GXM_TEXTURE_FORMAT_L8;
- break;
- case GL_LUMINANCE_ALPHA:
- write_cb = writeRG;
- tex_format = SCE_GXM_TEXTURE_FORMAT_A8L8;
- break;
- case GL_INTENSITY:
- write_cb = writeR;
- tex_format = SCE_GXM_TEXTURE_FORMAT_U8_RRRR;
- break;
- case GL_ALPHA:
- write_cb = writeR;
- tex_format = SCE_GXM_TEXTURE_FORMAT_A8;
- break;
- case GL_COLOR_INDEX8_EXT:
- write_cb = writeR; // TODO: This is a hack
- tex_format = SCE_GXM_TEXTURE_FORMAT_P8_ABGR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Checking if texture is too big for sceGxm
- if (width > GXM_TEX_MAX_SIZE || height > GXM_TEX_MAX_SIZE) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-
- // Allocating texture/mipmaps depending on user call
- tex->type = internalFormat;
- tex->write_cb = write_cb;
- if (level == 0)
- if (tex->write_cb)
- gpu_alloc_texture(width, height, tex_format, data, tex, data_bpp, read_cb, write_cb, fast_store);
- else
- gpu_alloc_compressed_texture(width, height, tex_format, 0, data, tex, data_bpp, read_cb);
- else
- gpu_alloc_mipmaps(level, tex);
-
- // Setting texture parameters
- sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex->u_mode);
- sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex->v_mode);
- sceGxmTextureSetMinFilter(&tex->gxm_tex, tex->min_filter);
- sceGxmTextureSetMagFilter(&tex->gxm_tex, tex->mag_filter);
- sceGxmTextureSetMipFilter(&tex->gxm_tex, tex->mip_filter);
- sceGxmTextureSetLodBias(&tex->gxm_tex, tex->lod_bias);
-
- // Setting palette if the format requests one
- if (tex->valid && tex->palette_UID)
- sceGxmTextureSetPalette(&tex->gxm_tex, color_table->data);
-
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *target_texture = &vgl_textures[texture2d_idx];
-
- // Calculating implicit texture stride and start address of requested texture modification
- uint32_t orig_w = sceGxmTextureGetWidth(&target_texture->gxm_tex);
- uint32_t orig_h = sceGxmTextureGetHeight(&target_texture->gxm_tex);
- SceGxmTextureFormat tex_format = sceGxmTextureGetFormat(&target_texture->gxm_tex);
- uint8_t bpp = tex_format_to_bytespp(tex_format);
- uint32_t stride = ALIGN(orig_w, 8) * bpp;
- uint8_t *ptr = (uint8_t *)sceGxmTextureGetData(&target_texture->gxm_tex) + xoffset * bpp + yoffset * stride;
- uint8_t *ptr_line = ptr;
- uint8_t data_bpp = 0;
- int i, j;
-
- if (xoffset + width > orig_w) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- } else if (yoffset + height > orig_h) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-
- // Support for legacy GL1.0 format
- switch (format) {
- case 1:
- format = GL_RED;
- break;
- case 2:
- format = GL_RG;
- break;
- case 3:
- format = GL_RGB;
- break;
- case 4:
- format = GL_RGBA;
- break;
- }
-
- /*
- * Callbacks are actually used to just perform down/up-sampling
- * between U8 texture formats. Reads are expected to give as result
- * a RGBA sample that will be wrote depending on texture format
- * by the write callback
- */
- void (*write_cb)(void *, uint32_t) = NULL;
- uint32_t (*read_cb)(void *) = NULL;
-
- // Detecting proper read callback and source bpp
- switch (format) {
- case GL_RED:
- case GL_ALPHA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- read_cb = readR;
- data_bpp = 1;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RG:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- read_cb = readRG;
- data_bpp = 2;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RGB:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 3;
- read_cb = readRGB;
- break;
- case GL_UNSIGNED_SHORT_5_6_5:
- data_bpp = 2;
- read_cb = readRGB565;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_BGR:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 3;
- read_cb = readBGR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_RGBA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 4;
- read_cb = readRGBA;
- break;
- case GL_UNSIGNED_SHORT_5_5_5_1:
- data_bpp = 2;
- read_cb = readRGBA5551;
- break;
- case GL_UNSIGNED_SHORT_4_4_4_4:
- data_bpp = 2;
- read_cb = readRGBA4444;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- case GL_BGRA:
- switch (type) {
- case GL_UNSIGNED_BYTE:
- data_bpp = 4;
- read_cb = readBGRA;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- }
-
- switch (target) {
- case GL_TEXTURE_2D:
-
- // Detecting proper write callback
- switch (target_texture->type) {
- case GL_RGB:
- write_cb = writeRGB;
- break;
- case GL_BGR:
- write_cb = writeBGR;
- break;
- case GL_RGBA:
- write_cb = writeRGBA;
- break;
- case GL_BGRA:
- write_cb = writeBGRA;
- break;
- case GL_LUMINANCE:
- write_cb = writeR;
- break;
- case GL_LUMINANCE_ALPHA:
- write_cb = writeRG;
- break;
- case GL_INTENSITY:
- write_cb = writeR;
- break;
- case GL_ALPHA:
- write_cb = writeR;
- break;
- }
-
- // Executing texture modification via callbacks
- uint8_t *data = (uint8_t *)pixels;
- for (i = 0; i < height; i++) {
- for (j = 0; j < width; j++) {
- uint32_t clr = read_cb((uint8_t *)data);
- write_cb(ptr, clr);
- data += data_bpp;
- ptr += bpp;
- }
- ptr = ptr_line + stride;
- ptr_line = ptr;
- }
-
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- SceGxmTextureFormat tex_format;
-
-#ifndef SKIP_ERROR_HANDLING
- // Checking if texture is too big for sceGxm
- if (width > GXM_TEX_MAX_SIZE || height > GXM_TEX_MAX_SIZE) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-
- // Checking if texture dimensions are not a power of two
- if (((width & (width - 1)) != 0) || ((height & (height - 1)) != 0)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-
- // Ensure imageSize isn't zero.
- if (imageSize == 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- switch (target) {
- case GL_TEXTURE_2D:
- // Detecting proper write callback and texture format
- switch (internalFormat) {
- case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
- case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
- tex_format = SCE_GXM_TEXTURE_FORMAT_UBC1_ABGR;
- break;
- case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
- tex_format = SCE_GXM_TEXTURE_FORMAT_UBC3_ABGR;
- break;
- case GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG:
- tex_format = SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_1BGR;
- break;
- case GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:
- tex_format = SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_ABGR;
- break;
- case GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG:
- tex_format = SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_1BGR;
- break;
- case GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:
- tex_format = SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_ABGR;
- break;
- case GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG:
- tex_format = SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP_ABGR;
- break;
- case GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG:
- tex_format = SCE_GXM_TEXTURE_FORMAT_PVRTII4BPP_ABGR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Allocating texture/mipmaps depending on user call
- tex->type = internalFormat;
- gpu_alloc_compressed_texture(width, height, tex_format, imageSize, data, tex, 0, NULL);
-
- // Setting texture parameters
- sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex->u_mode);
- sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex->v_mode);
- sceGxmTextureSetMinFilter(&tex->gxm_tex, tex->min_filter);
- sceGxmTextureSetMagFilter(&tex->gxm_tex, tex->mag_filter);
- sceGxmTextureSetMipFilter(&tex->gxm_tex, tex->mip_filter);
- sceGxmTextureSetLodBias(&tex->gxm_tex, tex->lod_bias);
-
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *data) {
- // Checking if a color table is already enabled, if so, deallocating it
- if (color_table != NULL) {
- gpu_free_palette(color_table);
- color_table = NULL;
- }
-
- // Calculating color table bpp
- uint8_t bpp = 0;
- switch (target) {
- case GL_COLOR_TABLE:
- switch (format) {
- case GL_RGBA:
- bpp = 4;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- // Allocating and initializing color table
- color_table = gpu_alloc_palette(data, width, bpp);
-}
-
-void glTexParameteri(GLenum target, GLenum pname, GLint param) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- switch (target) {
- case GL_TEXTURE_2D:
- switch (pname) {
- case GL_TEXTURE_MIN_FILTER: // Min filter
- switch (param) {
- case GL_NEAREST: // Point
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_POINT;
- break;
- case GL_LINEAR: // Linear
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- break;
- case GL_NEAREST_MIPMAP_NEAREST:
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_POINT;
- break;
- case GL_LINEAR_MIPMAP_NEAREST:
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_ENABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_POINT;
- break;
- case GL_NEAREST_MIPMAP_LINEAR:
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_LINEAR;
- break;
- case GL_LINEAR_MIPMAP_LINEAR:
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_ENABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_LINEAR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- sceGxmTextureSetMinFilter(&tex->gxm_tex, tex->min_filter);
- break;
- case GL_TEXTURE_MAG_FILTER: // Mag Filter
- switch (param) {
- case GL_NEAREST:
- tex->mag_filter = SCE_GXM_TEXTURE_FILTER_POINT;
- break;
- case GL_LINEAR:
- tex->mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- sceGxmTextureSetMagFilter(&tex->gxm_tex, tex->mag_filter);
- break;
- case GL_TEXTURE_WRAP_S: // U Mode
- switch (param) {
- case GL_CLAMP_TO_EDGE: // Clamp
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_CLAMP;
- break;
- case GL_REPEAT: // Repeat
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT;
- break;
- case GL_MIRRORED_REPEAT: // Mirror
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR;
- break;
- case GL_MIRROR_CLAMP_EXT: // Mirror Clamp
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex->u_mode);
- break;
- case GL_TEXTURE_WRAP_T: // V Mode
- switch (param) {
- case GL_CLAMP_TO_EDGE: // Clamp
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_CLAMP;
- break;
- case GL_REPEAT: // Repeat
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT;
- break;
- case GL_MIRRORED_REPEAT: // Mirror
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_MIRROR;
- break;
- case GL_MIRROR_CLAMP_EXT: // Mirror Clamp
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex->v_mode);
- break;
- case GL_TEXTURE_LOD_BIAS: // Distant LOD bias
- tex->lod_bias = (uint32_t)(param + GL_MAX_TEXTURE_LOD_BIAS);
- sceGxmTextureSetLodBias(&tex->gxm_tex, tex->lod_bias);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- switch (target) {
- case GL_TEXTURE_2D:
- switch (pname) {
- case GL_TEXTURE_MIN_FILTER: // Min Filter
- if (param == GL_NEAREST) {
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_POINT;
- }
- if (param == GL_LINEAR) {
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- }
- if (param == GL_NEAREST_MIPMAP_NEAREST) {
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_POINT;
- }
- if (param == GL_LINEAR_MIPMAP_NEAREST) {
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_ENABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_POINT;
- }
- if (param == GL_NEAREST_MIPMAP_LINEAR) {
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_DISABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_LINEAR;
- }
- if (param == GL_LINEAR_MIPMAP_LINEAR) {
- tex->mip_filter = SCE_GXM_TEXTURE_MIP_FILTER_ENABLED;
- tex->min_filter = SCE_GXM_TEXTURE_FILTER_MIPMAP_LINEAR;
- }
- sceGxmTextureSetMinFilter(&tex->gxm_tex, tex->min_filter);
- sceGxmTextureSetMipFilter(&tex->gxm_tex, tex->mip_filter);
- break;
- case GL_TEXTURE_MAG_FILTER: // Mag filter
- if (param == GL_NEAREST)
- tex->mag_filter = SCE_GXM_TEXTURE_FILTER_POINT;
- else if (param == GL_LINEAR)
- tex->mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR;
- sceGxmTextureSetMagFilter(&tex->gxm_tex, tex->mag_filter);
- break;
- case GL_TEXTURE_WRAP_S: // U Mode
- if (param == GL_CLAMP_TO_EDGE)
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_CLAMP; // Clamp
- else if (param == GL_REPEAT)
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; // Repeat
- else if (param == GL_MIRRORED_REPEAT)
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR; // Mirror
- else if (param == GL_MIRROR_CLAMP_EXT)
- tex->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP; // Mirror Clamp
- sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex->u_mode);
- break;
- case GL_TEXTURE_WRAP_T: // V Mode
- if (param == GL_CLAMP_TO_EDGE)
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_CLAMP; // Clamp
- else if (param == GL_REPEAT)
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; // Repeat
- else if (param == GL_MIRRORED_REPEAT)
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_MIRROR; // Mirror
- else if (param == GL_MIRROR_CLAMP_EXT)
- tex->v_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP; // Mirror Clamp
- sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex->v_mode);
- break;
- case GL_TEXTURE_LOD_BIAS: // Distant LOD bias
- tex->lod_bias = (uint32_t)(param + GL_MAX_TEXTURE_LOD_BIAS);
- sceGxmTextureSetLodBias(&tex->gxm_tex, tex->lod_bias);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glActiveTexture(GLenum texture) {
- // Changing current in use server texture unit
-#ifndef SKIP_ERROR_HANDLING
- if ((texture < GL_TEXTURE0) && (texture > GL_TEXTURE31)) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- } else
-#endif
- server_texture_unit = texture - GL_TEXTURE0;
-}
-
-void glGenerateMipmap(GLenum target) {
- // Setting some aliases to make code more readable
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
-#ifndef SKIP_ERROR_HANDLING
- // Checking if current texture is valid
- if (!tex->valid)
- return;
-#endif
-
- switch (target) {
- case GL_TEXTURE_2D:
-
- // Generating mipmaps to the max possible level
- gpu_alloc_mipmaps(-1, tex);
-
- // Setting texture parameters
- sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex->u_mode);
- sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex->v_mode);
- sceGxmTextureSetMinFilter(&tex->gxm_tex, tex->min_filter);
- sceGxmTextureSetMagFilter(&tex->gxm_tex, tex->mag_filter);
- sceGxmTextureSetMipFilter(&tex->gxm_tex, tex->mip_filter);
- sceGxmTextureSetLodBias(&tex->gxm_tex, tex->lod_bias);
-
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
- // Aliasing texture unit for cleaner code
- texture_unit *tex_unit = &texture_units[server_texture_unit];
-
- // Properly changing texture environment settings as per request
- switch (target) {
- case GL_TEXTURE_ENV:
- switch (pname) {
- case GL_TEXTURE_ENV_MODE:
- if (param == GL_MODULATE)
- tex_unit->env_mode = MODULATE;
- else if (param == GL_DECAL)
- tex_unit->env_mode = DECAL;
- else if (param == GL_REPLACE)
- tex_unit->env_mode = REPLACE;
- else if (param == GL_BLEND)
- tex_unit->env_mode = BLEND;
- else if (param == GL_ADD)
- tex_unit->env_mode = ADD;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glTexEnvfv(GLenum target, GLenum pname, GLfloat *param) {
- // Properly changing texture environment settings as per request
- switch (target) {
- case GL_TEXTURE_ENV:
- switch (pname) {
- case GL_TEXTURE_ENV_COLOR:
- memcpy_neon(&texenv_color.r, param, sizeof(GLfloat) * 4);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glTexEnvi(GLenum target, GLenum pname, GLint param) {
- // Aliasing texture unit for cleaner code
- texture_unit *tex_unit = &texture_units[server_texture_unit];
-
- // Properly changing texture environment settings as per request
- switch (target) {
- case GL_TEXTURE_ENV:
- switch (pname) {
- case GL_TEXTURE_ENV_MODE:
- switch (param) {
- case GL_MODULATE:
- tex_unit->env_mode = MODULATE;
- break;
- case GL_DECAL:
- tex_unit->env_mode = DECAL;
- break;
- case GL_REPLACE:
- tex_unit->env_mode = REPLACE;
- break;
- case GL_BLEND:
- tex_unit->env_mode = BLEND;
- break;
- case GL_ADD:
- tex_unit->env_mode = ADD;
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void *vglGetTexDataPointer(GLenum target) {
- // Aliasing texture unit for cleaner code
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- switch (target) {
- case GL_TEXTURE_2D:
- return tex->data;
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- break;
- }
-
- return NULL;
-}
-
-SceGxmTexture *vglGetGxmTexture(GLenum target) {
- // Aliasing texture unit for cleaner code
- texture_unit *tex_unit = &texture_units[server_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- texture *tex = &vgl_textures[texture2d_idx];
-
- switch (target) {
- case GL_TEXTURE_2D:
- return &tex->gxm_tex;
- break;
- default:
- vgl_error = GL_INVALID_ENUM;
- break;
- }
-
- return NULL;
-}
diff --git a/deps/vitaGL/source/utils/gpu_utils.c b/deps/vitaGL/source/utils/gpu_utils.c
deleted file mode 100644
index a8159849f2..0000000000
--- a/deps/vitaGL/source/utils/gpu_utils.c
+++ /dev/null
@@ -1,542 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * gpu_utils.c:
- * Utilities for GPU usage
- */
-
-#include "../shared.h"
-#include "stb_dxt.h"
-
-#ifndef MIN
-#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-#define MAX(a, b) (((a) < (b)) ? (b) : (a))
-#define CEIL(a) ((a - (int)a) == 0 ? (int)a : (int)a + 1)
-#endif
-
-// VRAM usage setting
-uint8_t use_vram = 0;
-uint8_t use_vram_for_usse = 0;
-
-// Newlib mempool usage setting
-GLboolean use_extra_mem = GL_TRUE;
-
-// vitaGL memory pool setup
-static void *pool_addr = NULL;
-static unsigned int pool_index = 0;
-static unsigned int pool_size = 0;
-
-// USSE memory settings
-vglMemType frag_usse_type;
-vglMemType vert_usse_type;
-
-uint64_t morton_1(uint64_t x) {
- x = x & 0x5555555555555555;
- x = (x | (x >> 1)) & 0x3333333333333333;
- x = (x | (x >> 2)) & 0x0F0F0F0F0F0F0F0F;
- x = (x | (x >> 4)) & 0x00FF00FF00FF00FF;
- x = (x | (x >> 8)) & 0x0000FFFF0000FFFF;
- x = (x | (x >> 16)) & 0xFFFFFFFFFFFFFFFF;
- return x;
-}
-
-void d2xy_morton(uint64_t d, uint64_t *x, uint64_t *y) {
- *x = morton_1(d);
- *y = morton_1(d >> 1);
-}
-
-void extract_block(const uint8_t *src, int width, uint8_t *block) {
- int j;
- for (j = 0; j < 4; j++) {
- memcpy_neon(&block[j * 4 * 4], src, 16);
- src += width * 4;
- }
-}
-
-void dxt_compress(uint8_t *dst, uint8_t *src, int w, int h, int isdxt5) {
- uint8_t block[64];
- int s = MAX(w, h);
- uint32_t num_blocks = (s * s) / 16;
- uint64_t d, offs_x, offs_y;
- for (d = 0; d < num_blocks; d++) {
- d2xy_morton(d, &offs_x, &offs_y);
- if (offs_x * 4 >= h)
- continue;
- if (offs_y * 4 >= w)
- continue;
- extract_block(src + offs_y * 16 + offs_x * w * 16, w, block);
- stb_compress_dxt_block(dst, block, isdxt5, fast_texture_compression ? STB_DXT_NORMAL : STB_DXT_HIGHQUAL);
- dst += isdxt5 ? 16 : 8;
- }
-}
-
-void swizzle_compressed_texture(uint8_t *dst, uint8_t *src, int w, int h, int isdxt5, int ispvrt2bpp) {
- int blocksize = isdxt5 ? 16 : 8;
-
- int s = MAX(w, h);
- uint32_t num_blocks = (s * s) / 16;
- uint64_t d, offs_x, offs_y;
- for (d = 0; d < num_blocks; d++) {
- d2xy_morton(d, &offs_x, &offs_y);
- if (offs_x * 4 >= h)
- continue;
- if (offs_y * (ispvrt2bpp ? 8 : 4) >= w)
- continue;
- memcpy(dst, src + offs_y * blocksize + offs_x * (w / (ispvrt2bpp ? 8 : 4)) * blocksize, blocksize);
- dst += isdxt5 ? 16 : 8;
- }
-}
-
-void *gpu_alloc_mapped(size_t size, vglMemType *type) {
- // Allocating requested memblock
- void *res = vgl_mempool_alloc(size, *type);
-
- // Requested memory type finished, using other one
- if (res == NULL) {
- *type = *type == VGL_MEM_VRAM ? VGL_MEM_RAM : VGL_MEM_VRAM;
- res = vgl_mempool_alloc(size, *type);
- }
-
- // Even the other one failed, using our last resort
- if (res == NULL) {
- *type = VGL_MEM_SLOW;
- res = vgl_mempool_alloc(size, *type);
- }
-
- if (res == NULL && use_extra_mem) {
- *type = VGL_MEM_EXTERNAL;
- res = malloc(size);
- }
-
- return res;
-}
-
-void *gpu_vertex_usse_alloc_mapped(size_t size, unsigned int *usse_offset) {
- // Allocating memblock
- vert_usse_type = use_vram_for_usse ? VGL_MEM_VRAM : VGL_MEM_RAM;
- void *addr = gpu_alloc_mapped(size, &vert_usse_type);
-
- // Mapping memblock into sceGxm as vertex USSE memory
- sceGxmMapVertexUsseMemory(addr, size, usse_offset);
-
- // Returning memblock starting address
- return addr;
-}
-
-void gpu_vertex_usse_free_mapped(void *addr) {
- // Unmapping memblock from sceGxm as vertex USSE memory
- sceGxmUnmapVertexUsseMemory(addr);
-
- // Deallocating memblock
- vgl_mem_free(addr, vert_usse_type);
-}
-
-void *gpu_fragment_usse_alloc_mapped(size_t size, unsigned int *usse_offset) {
- // Allocating memblock
- frag_usse_type = use_vram_for_usse ? VGL_MEM_VRAM : VGL_MEM_RAM;
- void *addr = gpu_alloc_mapped(size, &frag_usse_type);
-
- // Mapping memblock into sceGxm as fragment USSE memory
- sceGxmMapFragmentUsseMemory(addr, size, usse_offset);
-
- // Returning memblock starting address
- return addr;
-}
-
-void gpu_fragment_usse_free_mapped(void *addr) {
- // Unmapping memblock from sceGxm as fragment USSE memory
- sceGxmUnmapFragmentUsseMemory(addr);
-
- // Deallocating memblock
- vgl_mem_free(addr, frag_usse_type);
-}
-
-void *gpu_pool_malloc(unsigned int size) {
- // Reserving vitaGL mempool space
- if ((pool_index + size) < pool_size) {
- void *addr = (void *)((unsigned int)pool_addr + pool_index);
- pool_index += size;
- return addr;
- }
-
- return NULL;
-}
-
-void *gpu_pool_memalign(unsigned int size, unsigned int alignment) {
- // Aligning requested memory size
- unsigned int new_index = ALIGN(pool_index, alignment);
-
- // Reserving vitaGL mempool space
- if ((new_index + size) < pool_size) {
- void *addr = (void *)((unsigned int)pool_addr + new_index);
- pool_index = new_index + size;
- return addr;
- }
- return NULL;
-}
-
-unsigned int gpu_pool_free_space() {
- // Returning vitaGL available mempool space
- return pool_size - pool_index;
-}
-
-void gpu_pool_reset() {
- // Resetting vitaGL available mempool space
- pool_index = 0;
-}
-
-void gpu_pool_init(uint32_t temp_pool_size) {
- // Allocating vitaGL mempool
- pool_size = temp_pool_size;
- vglMemType type = VGL_MEM_RAM;
- pool_addr = gpu_alloc_mapped(temp_pool_size, &type);
-}
-
-int tex_format_to_bytespp(SceGxmTextureFormat format) {
- // Calculating bpp for the requested texture format
- switch (format & 0x9f000000U) {
- case SCE_GXM_TEXTURE_BASE_FORMAT_U8:
- case SCE_GXM_TEXTURE_BASE_FORMAT_S8:
- case SCE_GXM_TEXTURE_BASE_FORMAT_P8:
- return 1;
- case SCE_GXM_TEXTURE_BASE_FORMAT_U4U4U4U4:
- case SCE_GXM_TEXTURE_BASE_FORMAT_U8U3U3U2:
- case SCE_GXM_TEXTURE_BASE_FORMAT_U1U5U5U5:
- case SCE_GXM_TEXTURE_BASE_FORMAT_U5U6U5:
- case SCE_GXM_TEXTURE_BASE_FORMAT_S5S5U6:
- case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8:
- case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8:
- return 2;
- case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8:
- case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8:
- return 3;
- case SCE_GXM_TEXTURE_BASE_FORMAT_U8U8U8U8:
- case SCE_GXM_TEXTURE_BASE_FORMAT_S8S8S8S8:
- case SCE_GXM_TEXTURE_BASE_FORMAT_F32:
- case SCE_GXM_TEXTURE_BASE_FORMAT_U32:
- case SCE_GXM_TEXTURE_BASE_FORMAT_S32:
- default:
- return 4;
- }
-}
-
-int tex_format_to_alignment(SceGxmTextureFormat format) {
- switch (format & 0x9f000000U) {
- case SCE_GXM_TEXTURE_BASE_FORMAT_UBC3:
- return 16;
- default:
- return 8;
- }
-}
-
-palette *gpu_alloc_palette(const void *data, uint32_t w, uint32_t bpe) {
- // Allocating a palette object
- palette *res = (palette *)malloc(sizeof(palette));
- res->type = use_vram ? VGL_MEM_VRAM : VGL_MEM_RAM;
-
- // Allocating palette data buffer
- void *texture_palette = gpu_alloc_mapped(256 * sizeof(uint32_t), &res->type);
-
- // Initializing palette
- if (data == NULL)
- memset(texture_palette, 0, 256 * sizeof(uint32_t));
- else if (bpe == 4)
- memcpy_neon(texture_palette, data, w * sizeof(uint32_t));
- res->data = texture_palette;
-
- // Returning palette
- return res;
-}
-
-void gpu_free_texture(texture *tex) {
- // Deallocating texture
- if (tex->data != NULL)
- vgl_mem_free(tex->data, tex->mtype);
-
- // Invalidating texture object
- tex->valid = 0;
-}
-
-void gpu_alloc_texture(uint32_t w, uint32_t h, SceGxmTextureFormat format, const void *data, texture *tex, uint8_t src_bpp, uint32_t (*read_cb)(void *), void (*write_cb)(void *, uint32_t), uint8_t fast_store) {
- // If there's already a texture in passed texture object we first dealloc it
- if (tex->valid)
- gpu_free_texture(tex);
-
- // Getting texture format bpp
- uint8_t bpp = tex_format_to_bytespp(format);
-
- // Allocating texture data buffer
- tex->mtype = use_vram ? VGL_MEM_VRAM : VGL_MEM_RAM;
- const int tex_size = ALIGN(w, 8) * h * bpp;
- void *texture_data = gpu_alloc_mapped(tex_size, &tex->mtype);
-
- if (texture_data != NULL) {
- // Initializing texture data buffer
- if (data != NULL) {
- int i, j;
- uint8_t *src = (uint8_t *)data;
- uint8_t *dst;
- if (fast_store) { // Internal Format and Data Format are the same, we can just use memcpy_neon for better performance
- uint32_t line_size = w * bpp;
- for (i = 0; i < h; i++) {
- dst = ((uint8_t *)texture_data) + (ALIGN(w, 8) * bpp) * i;
- memcpy_neon(dst, src, line_size);
- src += line_size;
- }
- } else { // Different internal and data formats, we need to go with slower callbacks system
- for (i = 0; i < h; i++) {
- dst = ((uint8_t *)texture_data) + (ALIGN(w, 8) * bpp) * i;
- for (j = 0; j < w; j++) {
- uint32_t clr = read_cb(src);
- write_cb(dst, clr);
- src += src_bpp;
- dst += bpp;
- }
- }
- }
- } else
- memset(texture_data, 0, tex_size);
-
- // Initializing texture and validating it
- sceGxmTextureInitLinear(&tex->gxm_tex, texture_data, format, w, h, 0);
- if ((format & 0x9f000000U) == SCE_GXM_TEXTURE_BASE_FORMAT_P8)
- tex->palette_UID = 1;
- else
- tex->palette_UID = 0;
- tex->valid = 1;
- tex->data = texture_data;
- }
-}
-
-void gpu_alloc_compressed_texture(uint32_t w, uint32_t h, SceGxmTextureFormat format, uint32_t image_size, const void *data, texture *tex, uint8_t src_bpp, uint32_t (*read_cb)(void *)) {
- // If there's already a texture in passed texture object we first dealloc it
- if (tex->valid)
- gpu_free_texture(tex);
-
- // Getting texture format alignment
- uint8_t alignment = tex_format_to_alignment(format);
-
- // Calculating swizzled compressed texture size on memory
- tex->mtype = use_vram ? VGL_MEM_VRAM : VGL_MEM_RAM;
-
- int tex_size = 0;
- switch (format) {
- case SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_1BGR:
- case SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_ABGR:
- tex_size = (MAX(w, 8) * MAX(h, 8) * 2 + 7) / 8;
- break;
- case SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_1BGR:
- case SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_ABGR:
- tex_size = (MAX(w, 8) * MAX(h, 8) * 4 + 7) / 8;
- break;
- case SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP_ABGR:
- tex_size = CEIL(w / 8.0) * CEIL(h / 4.0) * 8.0;
- break;
- case SCE_GXM_TEXTURE_FORMAT_PVRTII4BPP_ABGR:
- tex_size = CEIL(w / 4.0) * CEIL(h / 4.0) * 8.0;
- break;
- case SCE_GXM_TEXTURE_FORMAT_UBC1_ABGR:
- tex_size = (w * h) / 2;
- break;
- case SCE_GXM_TEXTURE_FORMAT_UBC3_ABGR:
- tex_size = w * h;
- break;
- }
-
-#ifndef SKIP_ERROR_HANDLING
- // Check the given texture data size.
- if (image_size != 0 && image_size != tex_size) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
-
- // Allocating texture data buffer
- void *texture_data = gpu_alloc_mapped(tex_size, &tex->mtype);
-
- // Initializing texture data buffer
- if (texture_data != NULL) {
- if (data != NULL) {
- if (read_cb != NULL) {
- void *temp = (void *)data;
-
- // stb_dxt expects input as RGBA8888, so we convert input texture if necessary
- if (read_cb != readRGBA) {
- temp = malloc(w * h * 4);
- uint8_t *src = (uint8_t *)data;
- uint32_t *dst = (uint32_t *)temp;
- int i;
- for (i = 0; i < w * h; i++) {
- uint32_t clr = read_cb(src);
- writeRGBA(dst++, clr);
- src += src_bpp;
- }
- }
-
- // Performing swizzling and DXT compression
- dxt_compress(texture_data, temp, w, h, alignment == 16);
-
- // Freeing temporary data if necessary
- if (read_cb != readRGBA)
- free(temp);
- } else {
- // Perform swizzling if necessary.
- switch (format) {
- case SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_1BGR:
- case SCE_GXM_TEXTURE_FORMAT_PVRT2BPP_ABGR:
- case SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_1BGR:
- case SCE_GXM_TEXTURE_FORMAT_PVRT4BPP_ABGR:
- memcpy_neon(texture_data, data, tex_size);
- break;
- case SCE_GXM_TEXTURE_FORMAT_UBC3_ABGR:
- swizzle_compressed_texture(texture_data, (void *)data, w, h, 1, 0);
- break;
- case SCE_GXM_TEXTURE_FORMAT_PVRTII2BPP_ABGR:
- swizzle_compressed_texture(texture_data, (void *)data, w, h, 0, 1);
- break;
- default:
- swizzle_compressed_texture(texture_data, (void *)data, w, h, 0, 0);
- break;
- }
- }
-
- } else
- memset(texture_data, 0, tex_size);
-
- // Initializing texture and validating it
- sceGxmTextureInitSwizzled(&tex->gxm_tex, texture_data, format, w, h, 0);
- tex->palette_UID = 0;
- tex->valid = 1;
- tex->data = texture_data;
- }
-}
-
-void gpu_alloc_mipmaps(int level, texture *tex) {
- // Getting current mipmap count in passed texture
- uint32_t count = sceGxmTextureGetMipmapCount(&tex->gxm_tex);
-
- // Getting textures info and calculating bpp
- uint32_t w, h, stride;
- uint32_t orig_w = sceGxmTextureGetWidth(&tex->gxm_tex);
- uint32_t orig_h = sceGxmTextureGetHeight(&tex->gxm_tex);
- SceGxmTextureFormat format = sceGxmTextureGetFormat(&tex->gxm_tex);
- uint32_t bpp = tex_format_to_bytespp(format);
-
- // Checking if we need at least one more new mipmap level
- if ((level > count) || (level < 0)) { // Note: level < 0 means we will use max possible mipmaps level
-
- uint32_t jumps[10];
- for (w = 1; w < orig_w; w <<= 1) {
- }
- for (h = 1; h < orig_h; h <<= 1) {
- }
-
- // Calculating new texture data buffer size
- uint32_t size = 0;
- int j;
- if (level > 0) {
- for (j = 0; j < level; j++) {
- jumps[j] = max(w, 8) * h * bpp;
- size += jumps[j];
- w /= 2;
- h /= 2;
- }
- } else {
- level = 0;
- while ((w > 1) && (h > 1)) {
- jumps[level] = max(w, 8) * h * bpp;
- size += jumps[level];
- w /= 2;
- h /= 2;
- level++;
- }
- }
-
- // Calculating needed sceGxmTransfer format for the downscale process
- SceGxmTransferFormat fmt;
- switch (tex->type) {
- case GL_RGBA:
- fmt = SCE_GXM_TRANSFER_FORMAT_U8U8U8U8_ABGR;
- break;
- case GL_RGB:
- fmt = SCE_GXM_TRANSFER_FORMAT_U8U8U8_BGR;
- default:
- break;
- }
-
- // Moving texture data to heap and deallocating texture memblock
- GLboolean has_temp_buffer = GL_TRUE;
- stride = ALIGN(orig_w, 8);
- void *temp = (void *)malloc(stride * orig_h * bpp);
- if (temp == NULL) { // If we finished newlib heap, we delay texture free
- has_temp_buffer = GL_FALSE;
- temp = sceGxmTextureGetData(&tex->gxm_tex);
- } else {
- memcpy_neon(temp, sceGxmTextureGetData(&tex->gxm_tex), stride * orig_h * bpp);
- gpu_free_texture(tex);
- }
-
- // Allocating the new texture data buffer
- tex->mtype = use_vram ? VGL_MEM_VRAM : VGL_MEM_RAM;
- void *texture_data = gpu_alloc_mapped(size, &tex->mtype);
-
- // Moving back old texture data from heap to texture memblock
- memcpy_neon(texture_data, temp, stride * orig_h * bpp);
- if (has_temp_buffer)
- free(temp);
- else
- gpu_free_texture(tex);
- tex->valid = 1;
-
- // Performing a chain downscale process to generate requested mipmaps
- uint8_t *curPtr = (uint8_t *)texture_data;
- uint32_t curWidth = orig_w;
- uint32_t curHeight = orig_h;
- if (curWidth % 2)
- curWidth--;
- if (curHeight % 2)
- curHeight--;
- for (j = 0; j < level - 1; j++) {
- uint32_t curSrcStride = ALIGN(curWidth, 8);
- uint32_t curDstStride = ALIGN(curWidth >> 1, 8);
- uint8_t *dstPtr = curPtr + jumps[j];
- sceGxmTransferDownscale(
- fmt, curPtr, 0, 0,
- curWidth, curHeight,
- curSrcStride * bpp,
- fmt, dstPtr, 0, 0,
- curDstStride * bpp,
- NULL, SCE_GXM_TRANSFER_FRAGMENT_SYNC, NULL);
- curPtr = dstPtr;
- curWidth /= 2;
- curHeight /= 2;
- }
-
- // Initializing texture in sceGxm
- sceGxmTextureInitLinear(&tex->gxm_tex, texture_data, format, orig_w, orig_h, level);
- tex->data = texture_data;
- }
-}
-
-void gpu_free_palette(palette *pal) {
- // Deallocating palette memblock and object
- if (pal == NULL)
- return;
- vgl_mem_free(pal->data, pal->type);
- free(pal);
-}
\ No newline at end of file
diff --git a/deps/vitaGL/source/utils/gpu_utils.h b/deps/vitaGL/source/utils/gpu_utils.h
deleted file mode 100644
index 33d9a965ed..0000000000
--- a/deps/vitaGL/source/utils/gpu_utils.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * gpu_utils.h:
- * Header file for the GPU utilities exposed by gpu_utils.c
- */
-
-#ifndef _GPU_UTILS_H_
-#define _GPU_UTILS_H_
-
-#include "mem_utils.h"
-
-// Align a value to the requested alignment
-#define ALIGN(x, a) (((x) + ((a)-1)) & ~((a)-1))
-
-// Texture object struct
-typedef struct texture {
- SceGxmTexture gxm_tex;
- void *data;
- vglMemType mtype;
- SceUID palette_UID;
- SceUID depth_UID;
- uint8_t used;
- uint8_t valid;
- uint32_t type;
- void (*write_cb)(void *, uint32_t);
- SceGxmTextureFilter min_filter;
- SceGxmTextureFilter mag_filter;
- SceGxmTextureAddrMode u_mode;
- SceGxmTextureAddrMode v_mode;
- SceGxmTextureMipFilter mip_filter;
- uint32_t lod_bias;
-} texture;
-
-// Palette object struct
-typedef struct palette {
- void *data;
- vglMemType type;
-} palette;
-
-// Alloc a generic memblock into sceGxm mapped memory
-void *gpu_alloc_mapped(size_t size, vglMemType *type);
-
-// Alloc into sceGxm mapped memory a vertex USSE memblock
-void *gpu_vertex_usse_alloc_mapped(size_t size, unsigned int *usse_offset);
-
-// Dealloc from sceGxm mapped memory a vertex USSE memblock
-void gpu_vertex_usse_free_mapped(void *addr);
-
-// Alloc into sceGxm mapped memory a fragment USSE memblock
-void *gpu_fragment_usse_alloc_mapped(size_t size, unsigned int *usse_offset);
-
-// Dealloc from sceGxm mapped memory a fragment USSE memblock
-void gpu_fragment_usse_free_mapped(void *addr);
-
-// Reserve a memory space from vitaGL mempool
-void *gpu_pool_malloc(unsigned int size);
-
-// Reserve an aligned memory space from vitaGL mempool
-void *gpu_pool_memalign(unsigned int size, unsigned int alignment);
-
-// Returns available free space on vitaGL mempool
-unsigned int gpu_pool_free_space();
-
-// Resets vitaGL mempool
-void gpu_pool_reset();
-
-// Alloc vitaGL mempool
-void gpu_pool_init(uint32_t temp_pool_size);
-
-// Calculate bpp for a requested texture format
-int tex_format_to_bytespp(SceGxmTextureFormat format);
-
-// Alloc a texture
-void gpu_alloc_texture(uint32_t w, uint32_t h, SceGxmTextureFormat format, const void *data, texture *tex, uint8_t src_bpp, uint32_t (*read_cb)(void *), void (*write_cb)(void *, uint32_t), uint8_t fast_store);
-
-// Alloc a compresseed texture
-void gpu_alloc_compressed_texture(uint32_t w, uint32_t h, SceGxmTextureFormat format, uint32_t image_size, const void *data, texture *tex, uint8_t src_bpp, uint32_t (*read_cb)(void *));
-
-// Dealloc a texture
-void gpu_free_texture(texture *tex);
-
-// Alloc a palette
-palette *gpu_alloc_palette(const void *data, uint32_t w, uint32_t bpe);
-
-// Dealloc a palette
-void gpu_free_palette(palette *pal);
-
-// Generate mipmaps for a given texture
-void gpu_alloc_mipmaps(int level, texture *tex);
-
-#endif
diff --git a/deps/vitaGL/source/utils/math_utils.c b/deps/vitaGL/source/utils/math_utils.c
deleted file mode 100644
index ef9390781e..0000000000
--- a/deps/vitaGL/source/utils/math_utils.c
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * math_utils.c:
- * Utilities for math operations
- */
-
-#include "../shared.h"
-#include
-#include
-
-// NOTE: matrices are row-major.
-
-void matrix4x4_identity(matrix4x4 m) {
- m[0][1] = m[0][2] = m[0][3] = 0.0f;
- m[1][0] = m[1][2] = m[1][3] = 0.0f;
- m[2][0] = m[2][1] = m[2][3] = 0.0f;
- m[3][0] = m[3][1] = m[3][2] = 0.0f;
- m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1.0f;
-}
-
-void matrix4x4_copy(matrix4x4 dst, const matrix4x4 src) {
- memcpy_neon(dst, src, sizeof(matrix4x4));
-}
-
-void matrix4x4_multiply(matrix4x4 dst, const matrix4x4 src1, const matrix4x4 src2) {
- matmul4_neon((float *)src2, (float *)src1, (float *)dst);
-}
-
-void matrix4x4_init_rotation_x(matrix4x4 m, float rad) {
- float cs[2];
- sincosf_c(rad, cs);
-
- matrix4x4_identity(m);
-
- m[1][1] = cs[1];
- m[1][2] = -cs[0];
- m[2][1] = cs[0];
- m[2][2] = cs[1];
-}
-
-void matrix4x4_init_rotation_y(matrix4x4 m, float rad) {
- float cs[2];
- sincosf_c(rad, cs);
-
- matrix4x4_identity(m);
-
- m[0][0] = cs[1];
- m[0][2] = cs[0];
- m[2][0] = -cs[0];
- m[2][2] = cs[1];
-}
-
-void matrix4x4_init_rotation_z(matrix4x4 m, float rad) {
- float cs[2];
- sincosf_c(rad, cs);
-
- matrix4x4_identity(m);
-
- m[0][0] = cs[1];
- m[0][1] = -cs[0];
- m[1][0] = cs[0];
- m[1][1] = cs[1];
-}
-
-void matrix4x4_rotate_x(matrix4x4 m, float rad) {
- matrix4x4 m1, m2;
-
- matrix4x4_init_rotation_x(m1, rad);
- matrix4x4_multiply(m2, m, m1);
- matrix4x4_copy(m, m2);
-}
-
-void matrix4x4_rotate_y(matrix4x4 m, float rad) {
- matrix4x4 m1, m2;
-
- matrix4x4_init_rotation_y(m1, rad);
- matrix4x4_multiply(m2, m, m1);
- matrix4x4_copy(m, m2);
-}
-
-void matrix4x4_rotate_z(matrix4x4 m, float rad) {
- matrix4x4 m1, m2;
-
- matrix4x4_init_rotation_z(m1, rad);
- matrix4x4_multiply(m2, m, m1);
- matrix4x4_copy(m, m2);
-}
-
-void matrix4x4_init_translation(matrix4x4 m, float x, float y, float z) {
- matrix4x4_identity(m);
-
- m[0][3] = x;
- m[1][3] = y;
- m[2][3] = z;
-}
-
-void matrix4x4_translate(matrix4x4 m, float x, float y, float z) {
- matrix4x4 m1, m2;
-
- matrix4x4_init_translation(m1, x, y, z);
- matrix4x4_multiply(m2, m, m1);
- matrix4x4_copy(m, m2);
-}
-
-void matrix4x4_init_scaling(matrix4x4 m, float scale_x, float scale_y, float scale_z) {
- matrix4x4_identity(m);
-
- m[0][0] = scale_x;
- m[1][1] = scale_y;
- m[2][2] = scale_z;
-}
-
-void matrix4x4_scale(matrix4x4 m, float scale_x, float scale_y, float scale_z) {
- matrix4x4 m1, m2;
-
- matrix4x4_init_scaling(m1, scale_x, scale_y, scale_z);
- matrix4x4_multiply(m2, m, m1);
- matrix4x4_copy(m, m2);
-}
-
-void matrix4x4_transpose(matrix4x4 out, const matrix4x4 m) {
- int i, j;
-
- for (i = 0; i < 4; i++) {
- for (j = 0; j < 4; j++)
- out[i][j] = m[j][i];
- }
-}
-
-void matrix4x4_init_orthographic(matrix4x4 m, float left, float right, float bottom, float top, float near, float far) {
- m[0][0] = 2.0f / (right - left);
- m[0][1] = 0.0f;
- m[0][2] = 0.0f;
- m[0][3] = -(right + left) / (right - left);
-
- m[1][0] = 0.0f;
- m[1][1] = 2.0f / (top - bottom);
- m[1][2] = 0.0f;
- m[1][3] = -(top + bottom) / (top - bottom);
-
- m[2][0] = 0.0f;
- m[2][1] = 0.0f;
- m[2][2] = -2.0f / (far - near);
- m[2][3] = -(far + near) / (far - near);
-
- m[3][0] = 0.0f;
- m[3][1] = 0.0f;
- m[3][2] = 0.0f;
- m[3][3] = 1.0f;
-}
-
-void matrix4x4_init_frustum(matrix4x4 m, float left, float right, float bottom, float top, float near, float far) {
- m[0][0] = (2.0f * near) / (right - left);
- m[0][1] = 0.0f;
- m[0][2] = (right + left) / (right - left);
- m[0][3] = 0.0f;
-
- m[1][0] = 0.0f;
- m[1][1] = (2.0f * near) / (top - bottom);
- m[1][2] = (top + bottom) / (top - bottom);
- m[1][3] = 0.0f;
-
- m[2][0] = 0.0f;
- m[2][1] = 0.0f;
- m[2][2] = -(far + near) / (far - near);
- m[2][3] = (-2.0f * far * near) / (far - near);
-
- m[3][0] = 0.0f;
- m[3][1] = 0.0f;
- m[3][2] = -1.0f;
- m[3][3] = 0.0f;
-}
-
-void matrix4x4_init_perspective(matrix4x4 m, float fov, float aspect, float near, float far) {
- float half_height = near * tanf_neon(DEG_TO_RAD(fov) * 0.5f);
- float half_width = half_height * aspect;
-
- matrix4x4_init_frustum(m, -half_width, half_width, -half_height, half_height, near, far);
-}
-
-int matrix4x4_invert(matrix4x4 out, const matrix4x4 m) {
- int i, j;
-
- const float a0 = m[0][0] * m[1][1] - m[0][1] * m[1][0];
- const float a1 = m[0][0] * m[1][2] - m[0][2] * m[1][0];
- const float a2 = m[0][0] * m[1][3] - m[0][3] * m[1][0];
- const float a3 = m[0][1] * m[1][2] - m[0][2] * m[1][1];
- const float a4 = m[0][1] * m[1][3] - m[0][3] * m[1][1];
- const float a5 = m[0][2] * m[1][3] - m[0][3] * m[1][2];
- const float b0 = m[2][0] * m[3][1] - m[2][1] * m[3][0];
- const float b1 = m[2][0] * m[3][2] - m[2][2] * m[3][0];
- const float b2 = m[2][0] * m[3][3] - m[2][3] * m[3][0];
- const float b3 = m[2][1] * m[3][2] - m[2][2] * m[3][1];
- const float b4 = m[2][1] * m[3][3] - m[2][3] * m[3][1];
- const float b5 = m[2][2] * m[3][3] - m[2][3] * m[3][2];
-
- float det = a0 * b5 - a1 * b4 + a2 * b3 + a3 * b2 - a4 * b1 + a5 * b0;
-
- if (fabsf(det) > 0.0001f) {
- out[0][0] = m[0][1] * b5 - m[1][2] * b4 + m[1][3] * b3;
- out[1][0] = -m[1][0] * b5 + m[1][2] * b2 - m[1][3] * b1;
- out[2][0] = m[1][0] * b4 - m[1][1] * b2 + m[1][3] * b0;
- out[3][0] = -m[1][0] * b3 + m[1][1] * b1 - m[1][2] * b0;
- out[0][1] = -m[0][1] * b5 + m[0][2] * b4 - m[0][3] * b3;
- out[1][1] = m[0][0] * b5 - m[0][2] * b2 + m[0][3] * b1;
- out[2][1] = -m[0][0] * b4 + m[0][1] * b2 - m[0][3] * b0;
- out[3][1] = m[0][0] * b3 - m[0][1] * b1 + m[0][2] * b0;
- out[0][2] = m[3][1] * a5 - m[3][2] * a4 + m[3][3] * a3;
- out[1][2] = -m[3][0] * a5 + m[3][2] * a2 - m[3][3] * a1;
- out[2][2] = m[3][0] * a4 - m[3][1] * a2 + m[3][3] * a0;
- out[3][2] = -m[3][0] * a3 + m[3][1] * a1 - m[3][2] * a0;
- out[0][3] = -m[2][1] * a5 + m[2][2] * a4 - m[2][3] * a3;
- out[1][3] = m[2][0] * a5 - m[2][2] * a2 + m[2][3] * a1;
- out[2][3] = -m[2][0] * a4 + m[2][1] * a2 - m[2][3] * a0;
- out[3][3] = m[2][0] * a3 - m[2][1] * a1 + m[2][2] * a0;
-
- det = 1.0f / det;
-
- for (i = 0; i < 4; i++) {
- for (j = 0; j < 4; j++)
- out[i][j] *= det;
- }
-
- return 1;
- }
-
- return 0;
-}
-
-void vector4f_matrix4x4_mult(vector4f *u, const matrix4x4 m, const vector4f *v) {
- u->x = m[0][0] * v->x + m[0][1] * v->y + m[0][2] * v->z + m[0][3] * v->w;
- u->y = m[1][0] * v->x + m[1][1] * v->y + m[1][2] * v->z + m[1][3] * v->w;
- u->z = m[2][0] * v->x + m[2][1] * v->y + m[2][2] * v->z + m[2][3] * v->w;
- u->w = m[3][0] * v->x + m[3][1] * v->y + m[3][2] * v->z + m[3][3] * v->w;
-}
diff --git a/deps/vitaGL/source/utils/math_utils.h b/deps/vitaGL/source/utils/math_utils.h
deleted file mode 100644
index 1d51ad6795..0000000000
--- a/deps/vitaGL/source/utils/math_utils.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * math_utils.h:
- * Header file for the math utilities exposed by math_utils.c
- */
-
-#ifndef _MATH_UTILS_H_
-#define _MATH_UTILS_H_
-
-#include
-
-#ifndef DEG_TO_RAD
-#define DEG_TO_RAD(x) ((x)*M_PI / 180.0)
-#endif
-
-// clang-format off
-// vector of 2 floats struct
-typedef struct {
- float x, y;
-} vector2f;
-
-// vector of 3 floats struct
-typedef struct {
- union { float x; float r; };
- union { float y; float g; };
- union { float z; float b; };
-} vector3f;
-
-// vector of 4 floats struct
-typedef struct {
- union { float x; float r; };
- union { float y; float g; };
- union { float z; float b; };
- union { float w; float a; };
-} vector4f;
-// clang-format on
-
-// 4x4 matrix
-typedef float matrix4x4[4][4];
-
-// Creates an identity matrix
-void matrix4x4_identity(matrix4x4 m);
-
-// Copy a matrix to another one
-void matrix4x4_copy(matrix4x4 dst, const matrix4x4 src);
-
-// Perform a matrix per matrix moltiplication
-void matrix4x4_multiply(matrix4x4 dst, const matrix4x4 src1, const matrix4x4 src2);
-
-// Rotate a matrix on x,y,z axis
-void matrix4x4_rotate_x(matrix4x4 m, float rad);
-void matrix4x4_rotate_y(matrix4x4 m, float rad);
-void matrix4x4_rotate_z(matrix4x4 m, float rad);
-
-// Translate a matrix
-void matrix4x4_translate(matrix4x4 m, float x, float y, float z);
-
-// Scale a matrix
-void matrix4x4_scale(matrix4x4 m, float scale_x, float scale_y, float scale_z);
-
-// Transpose a matrix
-void matrix4x4_transpose(matrix4x4 out, const matrix4x4 m);
-
-// Init a matrix with different settings (ortho, frustum, perspective)
-void matrix4x4_init_orthographic(matrix4x4 m, float left, float right, float bottom, float top, float near, float far);
-void matrix4x4_init_frustum(matrix4x4 m, float left, float right, float bottom, float top, float near, float far);
-void matrix4x4_init_perspective(matrix4x4 m, float fov, float aspect, float near, float far);
-
-// Invert a matrix
-int matrix4x4_invert(matrix4x4 out, const matrix4x4 m);
-
-// Perform a matrix per vector moltiplication
-void vector4f_matrix4x4_mult(vector4f *u, const matrix4x4 m, const vector4f *v);
-
-#endif
diff --git a/deps/vitaGL/source/utils/mem_utils.c b/deps/vitaGL/source/utils/mem_utils.c
deleted file mode 100644
index b4d4c98a8a..0000000000
--- a/deps/vitaGL/source/utils/mem_utils.c
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * mem_utils.c:
- * Utilities for memory management
- */
-
-#include "../shared.h"
-
-#define MEM_ALIGNMENT 16
-
-typedef struct tm_block_s {
- struct tm_block_s *next; // next block in list (either free or allocated)
- int32_t type; // one of vglMemType (VGL_MEM_ALL when unused)
- uintptr_t base; // block start address
- uint32_t offset; // offset for USSE stuff (unused)
- uint32_t size; // block size
-} tm_block_t;
-
-static void *mempool_addr[3] = { NULL, NULL, NULL }; // addresses of heap memblocks (VRAM, RAM, PHYCONT RAM)
-static SceUID mempool_id[3] = { 0, 0, 0 }; // UIDs of heap memblocks (VRAM, RAM, PHYCONT RAM)
-static size_t mempool_size[3] = { 0, 0, 0 }; // sizes of heap memlbocks (VRAM, RAM, PHYCONT RAM)
-
-static int tm_initialized;
-
-static tm_block_t *tm_alloclist; // list of allocated blocks
-static tm_block_t *tm_freelist; // list of free blocks
-
-static uint32_t tm_free[VGL_MEM_TYPE_COUNT]; // see enum vglMemType
-
-// heap funcs //
-
-// get new block header
-static inline tm_block_t *heap_blk_new(void) {
- return calloc(1, sizeof(tm_block_t));
-}
-
-// release block header
-static inline void heap_blk_release(tm_block_t *block) {
- free(block);
-}
-
-// determine if two blocks can be merged into one
-// blocks of different types can't be merged,
-// blocks of same type can only be merged if they're next to each other
-// in memory and have matching offsets
-static inline int heap_blk_mergeable(tm_block_t *a, tm_block_t *b) {
- return a->type == b->type
- && a->base + a->size == b->base
- && a->offset + a->size == b->offset;
-}
-
-// inserts a block into the free list and merges with neighboring
-// free blocks if possible
-static void heap_blk_insert_free(tm_block_t *block) {
- tm_block_t *curblk = tm_freelist;
- tm_block_t *prevblk = NULL;
- while (curblk && curblk->base < block->base) {
- prevblk = curblk;
- curblk = curblk->next;
- }
-
- if (prevblk)
- prevblk->next = block;
- else
- tm_freelist = block;
-
- block->next = curblk;
- tm_free[block->type] += block->size;
- tm_free[0] += block->size;
-
- if (curblk && heap_blk_mergeable(block, curblk)) {
- block->size += curblk->size;
- block->next = curblk->next;
- heap_blk_release(curblk);
- }
-
- if (prevblk && heap_blk_mergeable(prevblk, block)) {
- prevblk->size += block->size;
- prevblk->next = block->next;
- heap_blk_release(block);
- }
-}
-
-// allocates a block from the heap
-// (removes it from free list and adds to alloc list)
-static tm_block_t *heap_blk_alloc(int32_t type, uint32_t size, uint32_t alignment) {
- tm_block_t *curblk = tm_freelist;
- tm_block_t *prevblk = NULL;
-
- while (curblk) {
- const uint32_t skip = ALIGN(curblk->base, alignment) - curblk->base;
-
- if (curblk->type == type && skip + size <= curblk->size) {
- tm_block_t *skipblk = NULL;
- tm_block_t *unusedblk = NULL;
-
- if (skip != 0) {
- skipblk = heap_blk_new();
- if (!skipblk)
- return NULL;
- }
-
- if (skip + size != curblk->size) {
- unusedblk = heap_blk_new();
- if (!unusedblk) {
- if (skipblk)
- heap_blk_release(skipblk);
- return NULL;
- }
- }
-
- if (skip != 0) {
- if (prevblk)
- prevblk->next = skipblk;
- else
- tm_freelist = skipblk;
-
- skipblk->next = curblk;
- skipblk->type = curblk->type;
- skipblk->base = curblk->base;
- skipblk->offset = curblk->offset;
- skipblk->size = skip;
-
- curblk->base += skip;
- curblk->offset += skip;
- curblk->size -= skip;
-
- prevblk = skipblk;
- }
-
- if (size != curblk->size) {
- unusedblk->next = curblk->next;
- curblk->next = unusedblk;
- unusedblk->type = curblk->type;
- unusedblk->base = curblk->base + size;
- unusedblk->offset = curblk->offset + size;
- unusedblk->size = curblk->size - size;
- curblk->size = size;
- }
-
- if (prevblk)
- prevblk->next = curblk->next;
- else
- tm_freelist = curblk->next;
-
- curblk->next = tm_alloclist;
- tm_alloclist = curblk;
- tm_free[type] -= size;
- tm_free[0] -= size;
- return curblk;
- }
-
- prevblk = curblk;
- curblk = curblk->next;
- }
-
- return NULL;
-}
-
-// frees a previously allocated heap block
-// (removes from alloc list and inserts into free list)
-static void heap_blk_free(uintptr_t base) {
- tm_block_t *curblk = tm_alloclist;
- tm_block_t *prevblk = NULL;
-
- while (curblk && curblk->base != base) {
- prevblk = curblk;
- curblk = curblk->next;
- }
-
- if (!curblk)
- return;
-
- if (prevblk)
- prevblk->next = curblk->next;
- else
- tm_alloclist = curblk->next;
-
- curblk->next = NULL;
-
- heap_blk_insert_free(curblk);
-}
-
-// initializes heap variables and blockpool
-static void heap_init(void) {
- tm_alloclist = NULL;
- tm_freelist = NULL;
-
- for (int i = 0; i < VGL_MEM_TYPE_COUNT; ++i)
- tm_free[i] = 0;
-
- tm_initialized = 1;
-}
-
-// resets heap state and frees allocated block headers
-static void heap_destroy(void) {
- tm_block_t *n;
-
- tm_block_t *p = tm_alloclist;
- while (p) {
- n = p->next;
- heap_blk_release(p);
- p = n;
- }
-
- p = tm_freelist;
- while (p) {
- n = p->next;
- heap_blk_release(p);
- p = n;
- }
-
- tm_initialized = 0;
-}
-
-// adds a memblock to the heap
-static void heap_extend(int32_t type, void *base, uint32_t size) {
- tm_block_t *block = heap_blk_new();
- block->next = NULL;
- block->type = type;
- block->base = (uintptr_t)base;
- block->offset = 0;
- block->size = size;
- heap_blk_insert_free(block);
-}
-
-// allocates memory from the heap (basically malloc())
-static void *heap_alloc(int32_t type, uint32_t size, uint32_t alignment) {
- tm_block_t *block = heap_blk_alloc(type, size, alignment);
-
- if (!block)
- return NULL;
-
- return (void *)block->base;
-}
-
-// frees previously allocated heap memory (basically free())
-static void heap_free(void *addr) {
- heap_blk_free((uintptr_t)addr);
-}
-
-void vgl_mem_term(void) {
- heap_destroy();
- if (mempool_addr[0] != NULL) {
- sceKernelFreeMemBlock(mempool_id[0]);
- sceKernelFreeMemBlock(mempool_id[1]);
- mempool_addr[0] = NULL;
- mempool_addr[1] = NULL;
- mempool_id[0] = 0;
- mempool_id[1] = 0;
- }
-}
-
-int vgl_mem_init(size_t size_ram, size_t size_cdram, size_t size_phycont) {
- if (mempool_addr[0] != NULL)
- vgl_mem_term();
-
- mempool_size[VGL_MEM_VRAM - 1] = ALIGN(size_cdram, 256 * 1024);
- mempool_size[VGL_MEM_RAM - 1] = ALIGN(size_ram, 4 * 1024);
- mempool_size[VGL_MEM_SLOW - 1] = ALIGN(size_phycont, 256 * 1024);
- if (size_cdram)
- mempool_id[VGL_MEM_VRAM - 1] = sceKernelAllocMemBlock("cdram_mempool", SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, mempool_size[VGL_MEM_VRAM - 1], NULL);
- mempool_id[VGL_MEM_RAM - 1] = sceKernelAllocMemBlock("ram_mempool", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW, mempool_size[VGL_MEM_RAM - 1], NULL);
- if (size_phycont)
- mempool_id[VGL_MEM_SLOW - 1] = sceKernelAllocMemBlock("phycont_mempool", SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_RW, mempool_size[VGL_MEM_SLOW - 1], NULL);
-
- for (int i = 0; i < VGL_MEM_TYPE_COUNT - 2; i++) {
- if (mempool_size[i]) {
- sceKernelGetMemBlockBase(mempool_id[i], &mempool_addr[i]);
- sceGxmMapMemory(mempool_addr[i], mempool_size[i], SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE);
- }
- }
-
- // Initialize heap
- heap_init();
-
- // Add memblocks to heap
- if (size_cdram)
- heap_extend(VGL_MEM_VRAM, mempool_addr[0], mempool_size[0]);
- heap_extend(VGL_MEM_RAM, mempool_addr[1], mempool_size[1]);
- if (size_phycont)
- heap_extend(VGL_MEM_SLOW, mempool_addr[2], mempool_size[2]);
-
- return 1;
-}
-
-void vgl_mem_free(void *ptr, vglMemType type) {
- if (type == VGL_MEM_EXTERNAL)
- free(ptr);
- else
- heap_free(ptr); // type is already stored in heap for alloc'd blocks
-}
-
-void *vgl_mempool_alloc(size_t size, vglMemType type) {
- void *res = NULL;
- if (size <= tm_free[type])
- res = heap_alloc(type, size, MEM_ALIGNMENT);
- return res;
-}
-
-// Returns currently free space on mempool
-size_t vgl_mempool_get_free_space(vglMemType type) {
- return tm_free[type];
-}
diff --git a/deps/vitaGL/source/utils/mem_utils.h b/deps/vitaGL/source/utils/mem_utils.h
deleted file mode 100644
index c54f46f89b..0000000000
--- a/deps/vitaGL/source/utils/mem_utils.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- * mem_utils.h:
- * Header file for the memory management utilities exposed by mem_utils.c
- */
-
-#ifndef _MEM_UTILS_H_
-#define _MEM_UTILS_H_
-
-int vgl_mem_init(size_t size_ram, size_t size_cdram, size_t size_phycont); // Initialize mempools
-void vgl_mem_term(void); // Terminate both CDRAM and RAM mempools
-size_t vgl_mempool_get_free_space(vglMemType type); // Return free space in bytes for a mempool
-void *vgl_mempool_alloc(size_t size, vglMemType type); // Allocate a memory block on a mempool
-void vgl_mem_free(void *ptr, vglMemType type); // Free a memory block on a mempool
-
-#endif
\ No newline at end of file
diff --git a/deps/vitaGL/source/utils/stb_dxt.h b/deps/vitaGL/source/utils/stb_dxt.h
deleted file mode 100644
index 7441bede63..0000000000
--- a/deps/vitaGL/source/utils/stb_dxt.h
+++ /dev/null
@@ -1,748 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-// stb_dxt.h - v1.09 - DXT1/DXT5 compressor - public domain
-// original by fabian "ryg" giesen - ported to C by stb
-// use '#define STB_DXT_IMPLEMENTATION' before including to create the implementation
-//
-// USAGE:
-// call stb_compress_dxt_block() for every block (you must pad)
-// source should be a 4x4 block of RGBA data in row-major order;
-// Alpha channel is not stored if you specify alpha=0 (but you
-// must supply some constant alpha in the alpha channel).
-// You can turn on dithering and "high quality" using mode.
-//
-// version history:
-// v1.09 - (stb) update documentation re: surprising alpha channel requirement
-// v1.08 - (stb) fix bug in dxt-with-alpha block
-// v1.07 - (stb) bc4; allow not using libc; add STB_DXT_STATIC
-// v1.06 - (stb) fix to known-broken 1.05
-// v1.05 - (stb) support bc5/3dc (Arvids Kokins), use extern "C" in C++ (Pavel Krajcevski)
-// v1.04 - (ryg) default to no rounding bias for lerped colors (as per S3TC/DX10 spec);
-// single color match fix (allow for inexact color interpolation);
-// optimal DXT5 index finder; "high quality" mode that runs multiple refinement steps.
-// v1.03 - (stb) endianness support
-// v1.02 - (stb) fix alpha encoding bug
-// v1.01 - (stb) fix bug converting to RGB that messed up quality, thanks ryg & cbloom
-// v1.00 - (stb) first release
-//
-// contributors:
-// Kevin Schmidt (#defines for "freestanding" compilation)
-// github:ppiastucki (BC4 support)
-//
-// LICENSE
-//
-// See end of file for license information.
-
-#ifndef STB_INCLUDE_STB_DXT_H
-#define STB_INCLUDE_STB_DXT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef STB_DXT_STATIC
-#define STBDDEF static
-#else
-#define STBDDEF extern
-#endif
-
-// compression mode (bitflags)
-#define STB_DXT_NORMAL 0
-#define STB_DXT_DITHER 1 // use dithering. dubious win. never use for normal maps and the like!
-#define STB_DXT_HIGHQUAL 2 // high quality mode, does two refinement steps instead of 1. ~30-40% slower.
-
-STBDDEF void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src_rgba_four_bytes_per_pixel, int alpha, int mode);
-STBDDEF void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src_r_one_byte_per_pixel);
-STBDDEF void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src_rg_two_byte_per_pixel);
-
-#define STB_COMPRESS_DXT_BLOCK
-
-#ifdef __cplusplus
-}
-#endif
-#endif // STB_INCLUDE_STB_DXT_H
-
-#ifdef STB_DXT_IMPLEMENTATION
-
-// configuration options for DXT encoder. set them in the project/makefile or just define
-// them at the top.
-
-// STB_DXT_USE_ROUNDING_BIAS
-// use a rounding bias during color interpolation. this is closer to what "ideal"
-// interpolation would do but doesn't match the S3TC/DX10 spec. old versions (pre-1.03)
-// implicitly had this turned on.
-//
-// in case you're targeting a specific type of hardware (e.g. console programmers):
-// NVidia and Intel GPUs (as of 2010) as well as DX9 ref use DXT decoders that are closer
-// to STB_DXT_USE_ROUNDING_BIAS. AMD/ATI, S3 and DX10 ref are closer to rounding with no bias.
-// you also see "(a*5 + b*3) / 8" on some old GPU designs.
-// #define STB_DXT_USE_ROUNDING_BIAS
-
-#include
-
-#if !defined(STBD_ABS) || !defined(STBI_FABS)
-#include
-#endif
-
-#ifndef STBD_ABS
-#define STBD_ABS(i) abs(i)
-#endif
-
-#ifndef STBD_FABS
-#define STBD_FABS(x) fabs(x)
-#endif
-
-#ifndef STBD_MEMSET
-#include
-#define STBD_MEMSET memset
-#endif
-
-static unsigned char stb__Expand5[32];
-static unsigned char stb__Expand6[64];
-static unsigned char stb__OMatch5[256][2];
-static unsigned char stb__OMatch6[256][2];
-static unsigned char stb__QuantRBTab[256+16];
-static unsigned char stb__QuantGTab[256+16];
-
-static int stb__Mul8Bit(int a, int b)
-{
- int t = a*b + 128;
- return (t + (t >> 8)) >> 8;
-}
-
-static void stb__From16Bit(unsigned char *out, unsigned short v)
-{
- int rv = (v & 0xf800) >> 11;
- int gv = (v & 0x07e0) >> 5;
- int bv = (v & 0x001f) >> 0;
-
- out[0] = stb__Expand5[rv];
- out[1] = stb__Expand6[gv];
- out[2] = stb__Expand5[bv];
- out[3] = 0;
-}
-
-static unsigned short stb__As16Bit(int r, int g, int b)
-{
- return (unsigned short)((stb__Mul8Bit(r,31) << 11) + (stb__Mul8Bit(g,63) << 5) + stb__Mul8Bit(b,31));
-}
-
-// linear interpolation at 1/3 point between a and b, using desired rounding type
-static int stb__Lerp13(int a, int b)
-{
-#ifdef STB_DXT_USE_ROUNDING_BIAS
- // with rounding bias
- return a + stb__Mul8Bit(b-a, 0x55);
-#else
- // without rounding bias
- // replace "/ 3" by "* 0xaaab) >> 17" if your compiler sucks or you really need every ounce of speed.
- return (2*a + b) / 3;
-#endif
-}
-
-// lerp RGB color
-static void stb__Lerp13RGB(unsigned char *out, unsigned char *p1, unsigned char *p2)
-{
- out[0] = (unsigned char)stb__Lerp13(p1[0], p2[0]);
- out[1] = (unsigned char)stb__Lerp13(p1[1], p2[1]);
- out[2] = (unsigned char)stb__Lerp13(p1[2], p2[2]);
-}
-
-/****************************************************************************/
-
-// compute table to reproduce constant colors as accurately as possible
-static void stb__PrepareOptTable(unsigned char *Table,const unsigned char *expand,int size)
-{
- int i,mn,mx;
- for (i=0;i<256;i++) {
- int bestErr = 256;
- for (mn=0;mn> 4)];
- ep1[0] = bp[ 0] - dp[ 0];
- dp[ 4] = quant[bp[ 4] + ((7*ep1[0] + 3*ep2[2] + 5*ep2[1] + ep2[0]) >> 4)];
- ep1[1] = bp[ 4] - dp[ 4];
- dp[ 8] = quant[bp[ 8] + ((7*ep1[1] + 3*ep2[3] + 5*ep2[2] + ep2[1]) >> 4)];
- ep1[2] = bp[ 8] - dp[ 8];
- dp[12] = quant[bp[12] + ((7*ep1[2] + 5*ep2[3] + ep2[2]) >> 4)];
- ep1[3] = bp[12] - dp[12];
- bp += 16;
- dp += 16;
- et = ep1, ep1 = ep2, ep2 = et; // swap
- }
- }
-}
-
-// The color matching function
-static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color,int dither)
-{
- unsigned int mask = 0;
- int dirr = color[0*4+0] - color[1*4+0];
- int dirg = color[0*4+1] - color[1*4+1];
- int dirb = color[0*4+2] - color[1*4+2];
- int dots[16];
- int stops[4];
- int i;
- int c0Point, halfPoint, c3Point;
-
- for(i=0;i<16;i++)
- dots[i] = block[i*4+0]*dirr + block[i*4+1]*dirg + block[i*4+2]*dirb;
-
- for(i=0;i<4;i++)
- stops[i] = color[i*4+0]*dirr + color[i*4+1]*dirg + color[i*4+2]*dirb;
-
- // think of the colors as arranged on a line; project point onto that line, then choose
- // next color out of available ones. we compute the crossover points for "best color in top
- // half"/"best in bottom half" and then the same inside that subinterval.
- //
- // relying on this 1d approximation isn't always optimal in terms of euclidean distance,
- // but it's very close and a lot faster.
- // http://cbloomrants.blogspot.com/2008/12/12-08-08-dxtc-summary.html
-
- c0Point = (stops[1] + stops[3]) >> 1;
- halfPoint = (stops[3] + stops[2]) >> 1;
- c3Point = (stops[2] + stops[0]) >> 1;
-
- if(!dither) {
- // the version without dithering is straightforward
- for (i=15;i>=0;i--) {
- int dot = dots[i];
- mask <<= 2;
-
- if(dot < halfPoint)
- mask |= (dot < c0Point) ? 1 : 3;
- else
- mask |= (dot < c3Point) ? 2 : 0;
- }
- } else {
- // with floyd-steinberg dithering
- int err[8],*ep1 = err,*ep2 = err+4;
- int *dp = dots, y;
-
- c0Point <<= 4;
- halfPoint <<= 4;
- c3Point <<= 4;
- for(i=0;i<8;i++)
- err[i] = 0;
-
- for(y=0;y<4;y++)
- {
- int dot,lmask,step;
-
- dot = (dp[0] << 4) + (3*ep2[1] + 5*ep2[0]);
- if(dot < halfPoint)
- step = (dot < c0Point) ? 1 : 3;
- else
- step = (dot < c3Point) ? 2 : 0;
- ep1[0] = dp[0] - stops[step];
- lmask = step;
-
- dot = (dp[1] << 4) + (7*ep1[0] + 3*ep2[2] + 5*ep2[1] + ep2[0]);
- if(dot < halfPoint)
- step = (dot < c0Point) ? 1 : 3;
- else
- step = (dot < c3Point) ? 2 : 0;
- ep1[1] = dp[1] - stops[step];
- lmask |= step<<2;
-
- dot = (dp[2] << 4) + (7*ep1[1] + 3*ep2[3] + 5*ep2[2] + ep2[1]);
- if(dot < halfPoint)
- step = (dot < c0Point) ? 1 : 3;
- else
- step = (dot < c3Point) ? 2 : 0;
- ep1[2] = dp[2] - stops[step];
- lmask |= step<<4;
-
- dot = (dp[3] << 4) + (7*ep1[2] + 5*ep2[3] + ep2[2]);
- if(dot < halfPoint)
- step = (dot < c0Point) ? 1 : 3;
- else
- step = (dot < c3Point) ? 2 : 0;
- ep1[3] = dp[3] - stops[step];
- lmask |= step<<6;
-
- dp += 4;
- mask |= lmask << (y*8);
- { int *et = ep1; ep1 = ep2; ep2 = et; } // swap
- }
- }
-
- return mask;
-}
-
-// The color optimization function. (Clever code, part 1)
-static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16)
-{
- int mind = 0x7fffffff,maxd = -0x7fffffff;
- unsigned char *minp, *maxp;
- double magn;
- int v_r,v_g,v_b;
- static const int nIterPower = 4;
- float covf[6],vfr,vfg,vfb;
-
- // determine color distribution
- int cov[6];
- int mu[3],min[3],max[3];
- int ch,i,iter;
-
- for(ch=0;ch<3;ch++)
- {
- const unsigned char *bp = ((const unsigned char *) block) + ch;
- int muv,minv,maxv;
-
- muv = minv = maxv = bp[0];
- for(i=4;i<64;i+=4)
- {
- muv += bp[i];
- if (bp[i] < minv) minv = bp[i];
- else if (bp[i] > maxv) maxv = bp[i];
- }
-
- mu[ch] = (muv + 8) >> 4;
- min[ch] = minv;
- max[ch] = maxv;
- }
-
- // determine covariance matrix
- for (i=0;i<6;i++)
- cov[i] = 0;
-
- for (i=0;i<16;i++)
- {
- int r = block[i*4+0] - mu[0];
- int g = block[i*4+1] - mu[1];
- int b = block[i*4+2] - mu[2];
-
- cov[0] += r*r;
- cov[1] += r*g;
- cov[2] += r*b;
- cov[3] += g*g;
- cov[4] += g*b;
- cov[5] += b*b;
- }
-
- // convert covariance matrix to float, find principal axis via power iter
- for(i=0;i<6;i++)
- covf[i] = cov[i] / 255.0f;
-
- vfr = (float) (max[0] - min[0]);
- vfg = (float) (max[1] - min[1]);
- vfb = (float) (max[2] - min[2]);
-
- for(iter=0;iter magn) magn = STBD_FABS(vfg);
- if (STBD_FABS(vfb) > magn) magn = STBD_FABS(vfb);
-
- if(magn < 4.0f) { // too small, default to luminance
- v_r = 299; // JPEG YCbCr luma coefs, scaled by 1000.
- v_g = 587;
- v_b = 114;
- } else {
- magn = 512.0 / magn;
- v_r = (int) (vfr * magn);
- v_g = (int) (vfg * magn);
- v_b = (int) (vfb * magn);
- }
-
- // Pick colors at extreme points
- for(i=0;i<16;i++)
- {
- int dot = block[i*4+0]*v_r + block[i*4+1]*v_g + block[i*4+2]*v_b;
-
- if (dot < mind) {
- mind = dot;
- minp = block+i*4;
- }
-
- if (dot > maxd) {
- maxd = dot;
- maxp = block+i*4;
- }
- }
-
- *pmax16 = stb__As16Bit(maxp[0],maxp[1],maxp[2]);
- *pmin16 = stb__As16Bit(minp[0],minp[1],minp[2]);
-}
-
-static int stb__sclamp(float y, int p0, int p1)
-{
- int x = (int) y;
- if (x < p0) return p0;
- if (x > p1) return p1;
- return x;
-}
-
-// The refinement function. (Clever code, part 2)
-// Tries to optimize colors to suit block contents better.
-// (By solving a least squares system via normal equations+Cramer's rule)
-static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask)
-{
- static const int w1Tab[4] = { 3,0,2,1 };
- static const int prods[4] = { 0x090000,0x000900,0x040102,0x010402 };
- // ^some magic to save a lot of multiplies in the accumulating loop...
- // (precomputed products of weights for least squares system, accumulated inside one 32-bit register)
-
- float frb,fg;
- unsigned short oldMin, oldMax, min16, max16;
- int i, akku = 0, xx,xy,yy;
- int At1_r,At1_g,At1_b;
- int At2_r,At2_g,At2_b;
- unsigned int cm = mask;
-
- oldMin = *pmin16;
- oldMax = *pmax16;
-
- if((mask ^ (mask<<2)) < 4) // all pixels have the same index?
- {
- // yes, linear system would be singular; solve using optimal
- // single-color match on average color
- int r = 8, g = 8, b = 8;
- for (i=0;i<16;++i) {
- r += block[i*4+0];
- g += block[i*4+1];
- b += block[i*4+2];
- }
-
- r >>= 4; g >>= 4; b >>= 4;
-
- max16 = (stb__OMatch5[r][0]<<11) | (stb__OMatch6[g][0]<<5) | stb__OMatch5[b][0];
- min16 = (stb__OMatch5[r][1]<<11) | (stb__OMatch6[g][1]<<5) | stb__OMatch5[b][1];
- } else {
- At1_r = At1_g = At1_b = 0;
- At2_r = At2_g = At2_b = 0;
- for (i=0;i<16;++i,cm>>=2) {
- int step = cm&3;
- int w1 = w1Tab[step];
- int r = block[i*4+0];
- int g = block[i*4+1];
- int b = block[i*4+2];
-
- akku += prods[step];
- At1_r += w1*r;
- At1_g += w1*g;
- At1_b += w1*b;
- At2_r += r;
- At2_g += g;
- At2_b += b;
- }
-
- At2_r = 3*At2_r - At1_r;
- At2_g = 3*At2_g - At1_g;
- At2_b = 3*At2_b - At1_b;
-
- // extract solutions and decide solvability
- xx = akku >> 16;
- yy = (akku >> 8) & 0xff;
- xy = (akku >> 0) & 0xff;
-
- frb = 3.0f * 31.0f / 255.0f / (xx*yy - xy*xy);
- fg = frb * 63.0f / 31.0f;
-
- // solve.
- max16 = (unsigned short)(stb__sclamp((At1_r*yy - At2_r*xy)*frb+0.5f,0,31) << 11);
- max16 |= (unsigned short)(stb__sclamp((At1_g*yy - At2_g*xy)*fg +0.5f,0,63) << 5);
- max16 |= (unsigned short)(stb__sclamp((At1_b*yy - At2_b*xy)*frb+0.5f,0,31) << 0);
-
- min16 = (unsigned short)(stb__sclamp((At2_r*xx - At1_r*xy)*frb+0.5f,0,31) << 11);
- min16 |= (unsigned short)(stb__sclamp((At2_g*xx - At1_g*xy)*fg +0.5f,0,63) << 5);
- min16 |= (unsigned short)(stb__sclamp((At2_b*xx - At1_b*xy)*frb+0.5f,0,31) << 0);
- }
-
- *pmin16 = min16;
- *pmax16 = max16;
- return oldMin != min16 || oldMax != max16;
-}
-
-// Color block compression
-static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block, int mode)
-{
- unsigned int mask;
- int i;
- int dither;
- int refinecount;
- unsigned short max16, min16;
- unsigned char dblock[16*4],color[4*4];
-
- dither = mode & STB_DXT_DITHER;
- refinecount = (mode & STB_DXT_HIGHQUAL) ? 2 : 1;
-
- // check if block is constant
- for (i=1;i<16;i++)
- if (((unsigned int *) block)[i] != ((unsigned int *) block)[0])
- break;
-
- if(i == 16) { // constant color
- int r = block[0], g = block[1], b = block[2];
- mask = 0xaaaaaaaa;
- max16 = (stb__OMatch5[r][0]<<11) | (stb__OMatch6[g][0]<<5) | stb__OMatch5[b][0];
- min16 = (stb__OMatch5[r][1]<<11) | (stb__OMatch6[g][1]<<5) | stb__OMatch5[b][1];
- } else {
- // first step: compute dithered version for PCA if desired
- if(dither)
- stb__DitherBlock(dblock,block);
-
- // second step: pca+map along principal axis
- stb__OptimizeColorsBlock(dither ? dblock : block,&max16,&min16);
- if (max16 != min16) {
- stb__EvalColors(color,max16,min16);
- mask = stb__MatchColorsBlock(block,color,dither);
- } else
- mask = 0;
-
- // third step: refine (multiple times if requested)
- for (i=0;i> 8);
- dest[2] = (unsigned char) (min16);
- dest[3] = (unsigned char) (min16 >> 8);
- dest[4] = (unsigned char) (mask);
- dest[5] = (unsigned char) (mask >> 8);
- dest[6] = (unsigned char) (mask >> 16);
- dest[7] = (unsigned char) (mask >> 24);
-}
-
-// Alpha block compression (this is easy for a change)
-static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src, int stride)
-{
- int i,dist,bias,dist4,dist2,bits,mask;
-
- // find min/max color
- int mn,mx;
- mn = mx = src[0];
-
- for (i=1;i<16;i++)
- {
- if (src[i*stride] < mn) mn = src[i*stride];
- else if (src[i*stride] > mx) mx = src[i*stride];
- }
-
- // encode them
- dest[0] = (unsigned char)mx;
- dest[1] = (unsigned char)mn;
- dest += 2;
-
- // determine bias and emit color indices
- // given the choice of mx/mn, these indices are optimal:
- // http://fgiesen.wordpress.com/2009/12/15/dxt5-alpha-block-index-determination/
- dist = mx-mn;
- dist4 = dist*4;
- dist2 = dist*2;
- bias = (dist < 8) ? (dist - 1) : (dist/2 + 2);
- bias -= mn * 7;
- bits = 0,mask=0;
-
- for (i=0;i<16;i++) {
- int a = src[i*stride]*7 + bias;
- int ind,t;
-
- // select index. this is a "linear scale" lerp factor between 0 (val=min) and 7 (val=max).
- t = (a >= dist4) ? -1 : 0; ind = t & 4; a -= dist4 & t;
- t = (a >= dist2) ? -1 : 0; ind += t & 2; a -= dist2 & t;
- ind += (a >= dist);
-
- // turn linear scale into DXT index (0/1 are extremal pts)
- ind = -ind & 7;
- ind ^= (2 > ind);
-
- // write index
- mask |= ind << bits;
- if((bits += 3) >= 8) {
- *dest++ = (unsigned char)mask;
- mask >>= 8;
- bits -= 8;
- }
- }
-}
-
-static void stb__InitDXT()
-{
- int i;
- for(i=0;i<32;i++)
- stb__Expand5[i] = (unsigned char)((i<<3)|(i>>2));
-
- for(i=0;i<64;i++)
- stb__Expand6[i] = (unsigned char)((i<<2)|(i>>4));
-
- for(i=0;i<256+16;i++)
- {
- int v = i-8 < 0 ? 0 : i-8 > 255 ? 255 : i-8;
- stb__QuantRBTab[i] = stb__Expand5[stb__Mul8Bit(v,31)];
- stb__QuantGTab[i] = stb__Expand6[stb__Mul8Bit(v,63)];
- }
-
- stb__PrepareOptTable(&stb__OMatch5[0][0],stb__Expand5,32);
- stb__PrepareOptTable(&stb__OMatch6[0][0],stb__Expand6,64);
-}
-
-void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int mode)
-{
- unsigned char data[16][4];
- static int init=1;
- if (init) {
- stb__InitDXT();
- init=0;
- }
-
- if (alpha) {
- int i;
- stb__CompressAlphaBlock(dest,(unsigned char*) src+3, 4);
- dest += 8;
- // make a new copy of the data in which alpha is opaque,
- // because code uses a fast test for color constancy
- memcpy_neon(data, src, 4*16);
- for (i=0; i < 16; ++i)
- data[i][3] = 255;
- src = &data[0][0];
- }
-
- stb__CompressColorBlock(dest,(unsigned char*) src,mode);
-}
-
-void stb_compress_bc4_block(unsigned char *dest, const unsigned char *src)
-{
- stb__CompressAlphaBlock(dest,(unsigned char*) src, 1);
-}
-
-void stb_compress_bc5_block(unsigned char *dest, const unsigned char *src)
-{
- stb__CompressAlphaBlock(dest,(unsigned char*) src,2);
- stb__CompressAlphaBlock(dest + 8,(unsigned char*) src+1,2);
-}
-#endif // STB_DXT_IMPLEMENTATION
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/
diff --git a/deps/vitaGL/source/vitaGL.c b/deps/vitaGL/source/vitaGL.c
deleted file mode 100644
index 68575e671c..0000000000
--- a/deps/vitaGL/source/vitaGL.c
+++ /dev/null
@@ -1,2245 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- * Copyright 2020 Asakura Reiko
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-/*
- *
- */
-#include "vitaGL.h"
-#include "shared.h"
-#include "texture_callbacks.h"
-
-// Shaders
-#include "shaders/clear_f.h"
-#include "shaders/clear_v.h"
-#include "shaders/disable_color_buffer_f.h"
-#include "shaders/rgb_v.h"
-#include "shaders/rgba_f.h"
-#include "shaders/rgba_v.h"
-#include "shaders/texture2d_f.h"
-#include "shaders/texture2d_rgba_f.h"
-#include "shaders/texture2d_rgba_v.h"
-#include "shaders/texture2d_v.h"
-
-// Disable color buffer shader
-SceGxmShaderPatcherId disable_color_buffer_fragment_id;
-const SceGxmProgramParameter *disable_color_buffer_position;
-SceGxmFragmentProgram *disable_color_buffer_fragment_program_patched;
-const SceGxmProgramParameter *clear_depth;
-
-// Clear shader
-SceGxmShaderPatcherId clear_vertex_id;
-SceGxmShaderPatcherId clear_fragment_id;
-const SceGxmProgramParameter *clear_position;
-const SceGxmProgramParameter *clear_color;
-SceGxmVertexProgram *clear_vertex_program_patched;
-SceGxmFragmentProgram *clear_fragment_program_patched;
-
-// Color (RGBA/RGB) shader
-SceGxmShaderPatcherId rgba_vertex_id;
-SceGxmShaderPatcherId rgb_vertex_id;
-SceGxmShaderPatcherId rgba_fragment_id;
-const SceGxmProgramParameter *rgba_position;
-const SceGxmProgramParameter *rgba_color;
-const SceGxmProgramParameter *rgba_wvp;
-const SceGxmProgramParameter *rgb_position;
-const SceGxmProgramParameter *rgb_color;
-const SceGxmProgramParameter *rgb_wvp;
-SceGxmVertexProgram *rgba_vertex_program_patched;
-SceGxmVertexProgram *rgba_u8n_vertex_program_patched;
-SceGxmVertexProgram *rgb_vertex_program_patched;
-SceGxmVertexProgram *rgb_u8n_vertex_program_patched;
-SceGxmFragmentProgram *rgba_fragment_program_patched;
-const SceGxmProgram *rgba_fragment_program;
-
-// Texture2D shader
-SceGxmShaderPatcherId texture2d_vertex_id;
-SceGxmShaderPatcherId texture2d_fragment_id;
-const SceGxmProgramParameter *texture2d_position;
-const SceGxmProgramParameter *texture2d_texcoord;
-const SceGxmProgramParameter *texture2d_wvp;
-const SceGxmProgramParameter *texture2d_alpha_cut;
-const SceGxmProgramParameter *texture2d_alpha_op;
-const SceGxmProgramParameter *texture2d_tint_color;
-const SceGxmProgramParameter *texture2d_tex_env;
-const SceGxmProgramParameter *texture2d_clip_plane0;
-const SceGxmProgramParameter *texture2d_clip_plane0_eq;
-const SceGxmProgramParameter *texture2d_mv;
-const SceGxmProgramParameter *texture2d_fog_mode;
-const SceGxmProgramParameter *texture2d_fog_near;
-const SceGxmProgramParameter *texture2d_fog_far;
-const SceGxmProgramParameter *texture2d_fog_density;
-const SceGxmProgramParameter *texture2d_fog_color;
-const SceGxmProgramParameter *texture2d_tex_env_color;
-SceGxmVertexProgram *texture2d_vertex_program_patched;
-SceGxmFragmentProgram *texture2d_fragment_program_patched;
-const SceGxmProgram *texture2d_fragment_program;
-
-// Texture2D+RGBA shader
-SceGxmShaderPatcherId texture2d_rgba_vertex_id;
-SceGxmShaderPatcherId texture2d_rgba_fragment_id;
-const SceGxmProgramParameter *texture2d_rgba_position;
-const SceGxmProgramParameter *texture2d_rgba_texcoord;
-const SceGxmProgramParameter *texture2d_rgba_wvp;
-const SceGxmProgramParameter *texture2d_rgba_alpha_cut;
-const SceGxmProgramParameter *texture2d_rgba_alpha_op;
-const SceGxmProgramParameter *texture2d_rgba_color;
-const SceGxmProgramParameter *texture2d_rgba_tex_env;
-const SceGxmProgramParameter *texture2d_rgba_clip_plane0;
-const SceGxmProgramParameter *texture2d_rgba_clip_plane0_eq;
-const SceGxmProgramParameter *texture2d_rgba_mv;
-const SceGxmProgramParameter *texture2d_rgba_fog_mode;
-const SceGxmProgramParameter *texture2d_rgba_fog_near;
-const SceGxmProgramParameter *texture2d_rgba_fog_far;
-const SceGxmProgramParameter *texture2d_rgba_fog_density;
-const SceGxmProgramParameter *texture2d_rgba_fog_color;
-const SceGxmProgramParameter *texture2d_rgba_tex_env_color;
-SceGxmVertexProgram *texture2d_rgba_vertex_program_patched;
-SceGxmVertexProgram *texture2d_rgba_u8n_vertex_program_patched;
-SceGxmFragmentProgram *texture2d_rgba_fragment_program_patched;
-const SceGxmProgram *texture2d_rgba_fragment_program;
-
-typedef struct gpubuffer {
- void *ptr;
- int32_t size;
-} gpubuffer;
-
-// sceGxm viewport setup (NOTE: origin is on center screen)
-float x_port = 480.0f;
-float y_port = 272.0f;
-float z_port = 0.5f;
-float x_scale = 480.0f;
-float y_scale = -272.0f;
-float z_scale = 0.5f;
-
-// Fullscreen sceGxm viewport (NOTE: origin is on center screen)
-float fullscreen_x_port = 480.0f;
-float fullscreen_y_port = 272.0f;
-float fullscreen_z_port = 0.5f;
-float fullscreen_x_scale = 480.0f;
-float fullscreen_y_scale = -272.0f;
-float fullscreen_z_scale = 0.5f;
-
-GLboolean vblank = GL_TRUE; // Current setting for VSync
-
-extern int _newlib_heap_memblock; // Newlib Heap memblock
-extern unsigned _newlib_heap_size; // Newlib Heap size
-
-static const SceGxmProgram *const gxm_program_disable_color_buffer_f = (SceGxmProgram *)&disable_color_buffer_f;
-static const SceGxmProgram *const gxm_program_clear_v = (SceGxmProgram *)&clear_v;
-static const SceGxmProgram *const gxm_program_clear_f = (SceGxmProgram *)&clear_f;
-static const SceGxmProgram *const gxm_program_rgba_v = (SceGxmProgram *)&rgba_v;
-static const SceGxmProgram *const gxm_program_rgba_f = (SceGxmProgram *)&rgba_f;
-static const SceGxmProgram *const gxm_program_rgb_v = (SceGxmProgram *)&rgb_v;
-static const SceGxmProgram *const gxm_program_texture2d_v = (SceGxmProgram *)&texture2d_v;
-static const SceGxmProgram *const gxm_program_texture2d_f = (SceGxmProgram *)&texture2d_f;
-static const SceGxmProgram *const gxm_program_texture2d_rgba_v = (SceGxmProgram *)&texture2d_rgba_v;
-static const SceGxmProgram *const gxm_program_texture2d_rgba_f = (SceGxmProgram *)&texture2d_rgba_f;
-
-// Disable color buffer shader
-uint16_t *depth_clear_indices = NULL; // Memblock starting address for clear screen indices
-
-// Clear shaders
-SceGxmVertexProgram *clear_vertex_program_patched; // Patched vertex program for clearing screen
-vector4f *clear_vertices = NULL; // Memblock starting address for clear screen vertices
-vector3f *depth_vertices = NULL; // Memblock starting address for depth clear screen vertices
-
-// Internal stuffs
-SceGxmMultisampleMode msaa_mode = SCE_GXM_MULTISAMPLE_NONE;
-
-extern uint8_t use_vram;
-extern uint8_t use_vram_for_usse;
-
-static GLuint buffers[BUFFERS_NUM]; // Buffers array
-static gpubuffer gpu_buffers[BUFFERS_NUM]; // Buffers array
-static SceGxmColorMask blend_color_mask = SCE_GXM_COLOR_MASK_ALL; // Current in-use color mask (glColorMask)
-static SceGxmBlendFunc blend_func_rgb = SCE_GXM_BLEND_FUNC_ADD; // Current in-use RGB blend func
-static SceGxmBlendFunc blend_func_a = SCE_GXM_BLEND_FUNC_ADD; // Current in-use A blend func
-static int vertex_array_unit = -1; // Current in-use vertex array unit
-static int index_array_unit = -1; // Current in-use index array unit
-
-vector4f texenv_color = { 0.0f, 0.0f, 0.0f, 0.0f }; // Current in use texture environment color
-
-// Internal functions
-
-#ifdef ENABLE_LOG
-void LOG(const char *format, ...) {
- __gnuc_va_list arg;
- int done;
- va_start(arg, format);
- char msg[512];
- done = vsprintf(msg, format, arg);
- va_end(arg);
- int i;
- sprintf(msg, "%s\n", msg);
- FILE *log = fopen("ux0:/data/vitaGL.log", "a+");
- if (log != NULL) {
- fwrite(msg, 1, strlen(msg), log);
- fclose(log);
- }
-}
-#endif
-
-static void _change_blend_factor(SceGxmBlendInfo *blend_info) {
- changeCustomShadersBlend(blend_info);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- rgba_fragment_id,
- SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa_mode,
- blend_info,
- NULL,
- &rgba_fragment_program_patched);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- texture2d_fragment_id,
- SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa_mode,
- blend_info,
- NULL,
- &texture2d_fragment_program_patched);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- texture2d_rgba_fragment_id,
- SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa_mode,
- blend_info,
- NULL,
- &texture2d_rgba_fragment_program_patched);
-}
-
-void change_blend_factor() {
- static SceGxmBlendInfo blend_info;
- blend_info.colorMask = blend_color_mask;
- blend_info.colorFunc = blend_func_rgb;
- blend_info.alphaFunc = blend_func_a;
- blend_info.colorSrc = blend_sfactor_rgb;
- blend_info.colorDst = blend_dfactor_rgb;
- blend_info.alphaSrc = blend_sfactor_a;
- blend_info.alphaDst = blend_dfactor_a;
-
- _change_blend_factor(&blend_info);
- if (cur_program != 0) {
- reloadCustomShader();
- }
-}
-
-void change_blend_mask() {
- static SceGxmBlendInfo blend_info;
- blend_info.colorMask = blend_color_mask;
- blend_info.colorFunc = SCE_GXM_BLEND_FUNC_NONE;
- blend_info.alphaFunc = SCE_GXM_BLEND_FUNC_NONE;
- blend_info.colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- blend_info.colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- blend_info.alphaSrc = SCE_GXM_BLEND_FACTOR_ONE;
- blend_info.alphaDst = SCE_GXM_BLEND_FACTOR_ZERO;
-
- _change_blend_factor(&blend_info);
- if (cur_program != 0) {
- reloadCustomShader();
- }
-}
-
-void disable_blend() {
- if (blend_color_mask == SCE_GXM_COLOR_MASK_ALL) {
- _change_blend_factor(NULL);
- if (cur_program != 0) {
- reloadCustomShader();
- }
- } else
- change_blend_mask();
-}
-
-void vector4f_convert_to_local_space(vector4f *out, int x, int y, int width, int height) {
- out[0].x = (float)(2 * x) / DISPLAY_WIDTH_FLOAT - 1.0f;
- out[0].y = (float)(2 * (x + width)) / DISPLAY_WIDTH_FLOAT - 1.0f;
- out[0].z = 1.0f - (float)(2 * y) / DISPLAY_HEIGHT_FLOAT;
- out[0].w = 1.0f - (float)(2 * (y + height)) / DISPLAY_HEIGHT_FLOAT;
-}
-
-// vitaGL specific functions
-
-void vglUseVram(GLboolean usage) {
- use_vram = usage;
-}
-
-void vglUseVramForUSSE(GLboolean usage) {
- use_vram_for_usse = usage;
-}
-
-void vglInitWithCustomSizes(uint32_t gpu_pool_size, int width, int height, int ram_pool_size, int cdram_pool_size, int phycont_pool_size, SceGxmMultisampleMode msaa) {
- // Setting our display size
- msaa_mode = msaa;
- DISPLAY_WIDTH = width;
- DISPLAY_HEIGHT = height;
- DISPLAY_WIDTH_FLOAT = width * 1.0f;
- DISPLAY_HEIGHT_FLOAT = height * 1.0f;
- DISPLAY_STRIDE = ALIGN(DISPLAY_WIDTH, 64);
-
- // Adjusting default values for internal viewport
- x_port = DISPLAY_WIDTH_FLOAT / 2.0f;
- x_scale = x_port;
- y_scale = -(DISPLAY_HEIGHT_FLOAT / 2.0f);
- y_port = -y_scale;
- fullscreen_x_port = x_port;
- fullscreen_x_scale = x_scale;
- fullscreen_y_port = y_port;
- fullscreen_y_scale = y_scale;
-
- // Init viewport state
- gl_viewport.x = 0;
- gl_viewport.y = 0;
- gl_viewport.w = DISPLAY_WIDTH;
- gl_viewport.h = DISPLAY_HEIGHT;
-
- // Initializing sceGxm
- initGxm();
-
- // Initializing memory heap for CDRAM and RAM memory
- vgl_mem_init(ram_pool_size, cdram_pool_size, phycont_pool_size);
-
- // Initializing sceGxm context
- initGxmContext();
-
- // Creating render target for the display
- createDisplayRenderTarget();
-
- // Creating color surfaces for the display
- initDisplayColorSurfaces();
-
- // Creating depth and stencil surfaces for the display
- initDepthStencilSurfaces();
-
- // Starting a sceGxmShaderPatcher instance
- startShaderPatcher();
-
- // Disable color buffer shader register
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_disable_color_buffer_f,
- &disable_color_buffer_fragment_id);
-
- const SceGxmProgram *disable_color_buffer_fragment_program = sceGxmShaderPatcherGetProgramFromId(disable_color_buffer_fragment_id);
-
- clear_depth = sceGxmProgramFindParameterByName(
- disable_color_buffer_fragment_program, "depth_clear");
-
- SceGxmBlendInfo disable_color_buffer_blend_info;
- memset(&disable_color_buffer_blend_info, 0, sizeof(SceGxmBlendInfo));
- disable_color_buffer_blend_info.colorMask = SCE_GXM_COLOR_MASK_NONE;
- disable_color_buffer_blend_info.colorFunc = SCE_GXM_BLEND_FUNC_NONE;
- disable_color_buffer_blend_info.alphaFunc = SCE_GXM_BLEND_FUNC_NONE;
- disable_color_buffer_blend_info.colorSrc = SCE_GXM_BLEND_FACTOR_ZERO;
- disable_color_buffer_blend_info.colorDst = SCE_GXM_BLEND_FACTOR_ZERO;
- disable_color_buffer_blend_info.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO;
- disable_color_buffer_blend_info.alphaDst = SCE_GXM_BLEND_FACTOR_ZERO;
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- disable_color_buffer_fragment_id,
- SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa,
- &disable_color_buffer_blend_info, NULL,
- &disable_color_buffer_fragment_program_patched);
-
- vglMemType type = VGL_MEM_RAM;
- clear_vertices = gpu_alloc_mapped(1 * sizeof(vector4f), &type);
- depth_clear_indices = gpu_alloc_mapped(4 * sizeof(unsigned short), &type);
-
- vector4f_convert_to_local_space(clear_vertices, 0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT);
-
- depth_clear_indices[0] = 0;
- depth_clear_indices[1] = 1;
- depth_clear_indices[2] = 2;
- depth_clear_indices[3] = 3;
-
- // Clear shader register
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_clear_v,
- &clear_vertex_id);
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_clear_f,
- &clear_fragment_id);
-
- const SceGxmProgram *clear_vertex_program = sceGxmShaderPatcherGetProgramFromId(clear_vertex_id);
- const SceGxmProgram *clear_fragment_program = sceGxmShaderPatcherGetProgramFromId(clear_fragment_id);
-
- clear_position = sceGxmProgramFindParameterByName(
- clear_vertex_program, "position");
-
- clear_color = sceGxmProgramFindParameterByName(
- clear_fragment_program, "u_clear_color");
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- clear_vertex_id, NULL, 0, NULL, 0, &clear_vertex_program_patched);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- clear_fragment_id, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa, NULL, NULL,
- &clear_fragment_program_patched);
-
- // Color shader register
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_rgba_v,
- &rgba_vertex_id);
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_rgb_v,
- &rgb_vertex_id);
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_rgba_f,
- &rgba_fragment_id);
-
- const SceGxmProgram *rgba_vertex_program = sceGxmShaderPatcherGetProgramFromId(rgba_vertex_id);
- const SceGxmProgram *rgb_vertex_program = sceGxmShaderPatcherGetProgramFromId(rgb_vertex_id);
- rgba_fragment_program = sceGxmShaderPatcherGetProgramFromId(rgba_fragment_id);
-
- rgba_position = sceGxmProgramFindParameterByName(
- rgba_vertex_program, "aPosition");
-
- rgba_color = sceGxmProgramFindParameterByName(
- rgba_vertex_program, "aColor");
-
- rgb_position = sceGxmProgramFindParameterByName(
- rgba_vertex_program, "aPosition");
-
- rgb_color = sceGxmProgramFindParameterByName(
- rgba_vertex_program, "aColor");
-
- SceGxmVertexAttribute rgba_vertex_attribute[2];
- SceGxmVertexStream rgba_vertex_stream[2];
- rgba_vertex_attribute[0].streamIndex = 0;
- rgba_vertex_attribute[0].offset = 0;
- rgba_vertex_attribute[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- rgba_vertex_attribute[0].componentCount = 3;
- rgba_vertex_attribute[0].regIndex = sceGxmProgramParameterGetResourceIndex(
- rgba_position);
- rgba_vertex_attribute[1].streamIndex = 1;
- rgba_vertex_attribute[1].offset = 0;
- rgba_vertex_attribute[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- rgba_vertex_attribute[1].componentCount = 4;
- rgba_vertex_attribute[1].regIndex = sceGxmProgramParameterGetResourceIndex(
- rgba_color);
- rgba_vertex_stream[0].stride = sizeof(vector3f);
- rgba_vertex_stream[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- rgba_vertex_stream[1].stride = sizeof(vector4f);
- rgba_vertex_stream[1].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- rgba_vertex_id, rgba_vertex_attribute,
- 2, rgba_vertex_stream, 2, &rgba_vertex_program_patched);
-
- rgba_vertex_attribute[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
- rgba_vertex_stream[1].stride = sizeof(uint8_t) * 4;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- rgba_vertex_id, rgba_vertex_attribute,
- 2, rgba_vertex_stream, 2, &rgba_u8n_vertex_program_patched);
-
- SceGxmVertexAttribute rgb_vertex_attribute[2];
- SceGxmVertexStream rgb_vertex_stream[2];
- rgb_vertex_attribute[0].streamIndex = 0;
- rgb_vertex_attribute[0].offset = 0;
- rgb_vertex_attribute[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- rgb_vertex_attribute[0].componentCount = 3;
- rgb_vertex_attribute[0].regIndex = sceGxmProgramParameterGetResourceIndex(
- rgb_position);
- rgb_vertex_attribute[1].streamIndex = 1;
- rgb_vertex_attribute[1].offset = 0;
- rgb_vertex_attribute[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- rgb_vertex_attribute[1].componentCount = 3;
- rgb_vertex_attribute[1].regIndex = sceGxmProgramParameterGetResourceIndex(
- rgb_color);
- rgb_vertex_stream[0].stride = sizeof(vector3f);
- rgb_vertex_stream[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- rgb_vertex_stream[1].stride = sizeof(vector3f);
- rgb_vertex_stream[1].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- rgb_vertex_id, rgb_vertex_attribute,
- 2, rgb_vertex_stream, 2, &rgb_vertex_program_patched);
-
- rgb_vertex_attribute[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
- rgb_vertex_stream[1].stride = sizeof(uint8_t) * 3;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- rgb_vertex_id, rgb_vertex_attribute,
- 2, rgb_vertex_stream, 2, &rgb_u8n_vertex_program_patched);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- rgba_fragment_id, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa, NULL, NULL,
- &rgba_fragment_program_patched);
-
- rgba_wvp = sceGxmProgramFindParameterByName(rgba_vertex_program, "wvp");
- rgb_wvp = sceGxmProgramFindParameterByName(rgb_vertex_program, "wvp");
-
- // Texture2D shader register
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_texture2d_v,
- &texture2d_vertex_id);
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_texture2d_f,
- &texture2d_fragment_id);
-
- const SceGxmProgram *texture2d_vertex_program = sceGxmShaderPatcherGetProgramFromId(texture2d_vertex_id);
- texture2d_fragment_program = sceGxmShaderPatcherGetProgramFromId(texture2d_fragment_id);
-
- texture2d_position = sceGxmProgramFindParameterByName(
- texture2d_vertex_program, "position");
-
- texture2d_texcoord = sceGxmProgramFindParameterByName(
- texture2d_vertex_program, "texcoord");
-
- texture2d_alpha_cut = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "alphaCut");
-
- texture2d_alpha_op = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "alphaOp");
-
- texture2d_tint_color = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "tintColor");
-
- texture2d_tex_env = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "texEnv");
-
- texture2d_fog_mode = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "fog_mode");
-
- texture2d_fog_color = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "fogColor");
-
- texture2d_clip_plane0 = sceGxmProgramFindParameterByName(
- texture2d_vertex_program, "clip_plane0");
-
- texture2d_clip_plane0_eq = sceGxmProgramFindParameterByName(
- texture2d_vertex_program, "clip_plane0_eq");
-
- texture2d_mv = sceGxmProgramFindParameterByName(
- texture2d_vertex_program, "modelview");
-
- texture2d_fog_near = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "fog_near");
-
- texture2d_fog_far = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "fog_far");
-
- texture2d_fog_density = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "fog_density");
-
- texture2d_tex_env_color = sceGxmProgramFindParameterByName(
- texture2d_fragment_program, "texEnvColor");
-
- SceGxmVertexAttribute texture2d_vertex_attribute[2];
- SceGxmVertexStream texture2d_vertex_stream[2];
- texture2d_vertex_attribute[0].streamIndex = 0;
- texture2d_vertex_attribute[0].offset = 0;
- texture2d_vertex_attribute[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- texture2d_vertex_attribute[0].componentCount = 3;
- texture2d_vertex_attribute[0].regIndex = sceGxmProgramParameterGetResourceIndex(
- texture2d_position);
- texture2d_vertex_attribute[1].streamIndex = 1;
- texture2d_vertex_attribute[1].offset = 0;
- texture2d_vertex_attribute[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- texture2d_vertex_attribute[1].componentCount = 2;
- texture2d_vertex_attribute[1].regIndex = sceGxmProgramParameterGetResourceIndex(
- texture2d_texcoord);
- texture2d_vertex_stream[0].stride = sizeof(vector3f);
- texture2d_vertex_stream[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- texture2d_vertex_stream[1].stride = sizeof(vector2f);
- texture2d_vertex_stream[1].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- texture2d_vertex_id, texture2d_vertex_attribute,
- 2, texture2d_vertex_stream, 2, &texture2d_vertex_program_patched);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- texture2d_fragment_id, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa, NULL, NULL,
- &texture2d_fragment_program_patched);
-
- texture2d_wvp = sceGxmProgramFindParameterByName(texture2d_vertex_program, "wvp");
-
- // Texture2D+RGBA shader register
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_texture2d_rgba_v,
- &texture2d_rgba_vertex_id);
- sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, gxm_program_texture2d_rgba_f,
- &texture2d_rgba_fragment_id);
-
- const SceGxmProgram *texture2d_rgba_vertex_program = sceGxmShaderPatcherGetProgramFromId(texture2d_rgba_vertex_id);
- texture2d_rgba_fragment_program = sceGxmShaderPatcherGetProgramFromId(texture2d_rgba_fragment_id);
-
- texture2d_rgba_position = sceGxmProgramFindParameterByName(
- texture2d_rgba_vertex_program, "position");
-
- texture2d_rgba_texcoord = sceGxmProgramFindParameterByName(
- texture2d_rgba_vertex_program, "texcoord");
-
- texture2d_rgba_alpha_cut = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "alphaCut");
-
- texture2d_rgba_alpha_op = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "alphaOp");
-
- texture2d_rgba_color = sceGxmProgramFindParameterByName(
- texture2d_rgba_vertex_program, "color");
-
- texture2d_rgba_tex_env = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "texEnv");
-
- texture2d_rgba_fog_mode = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "fog_mode");
-
- texture2d_rgba_clip_plane0 = sceGxmProgramFindParameterByName(
- texture2d_rgba_vertex_program, "clip_plane0");
-
- texture2d_rgba_clip_plane0_eq = sceGxmProgramFindParameterByName(
- texture2d_rgba_vertex_program, "clip_plane0_eq");
-
- texture2d_rgba_mv = sceGxmProgramFindParameterByName(
- texture2d_rgba_vertex_program, "modelview");
-
- texture2d_rgba_fog_near = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "fog_near");
-
- texture2d_rgba_fog_far = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "fog_far");
-
- texture2d_rgba_fog_density = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "fog_density");
-
- texture2d_rgba_fog_color = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "fogColor");
-
- texture2d_rgba_tex_env_color = sceGxmProgramFindParameterByName(
- texture2d_rgba_fragment_program, "texEnvColor");
-
- SceGxmVertexAttribute texture2d_rgba_vertex_attribute[3];
- SceGxmVertexStream texture2d_rgba_vertex_stream[3];
- texture2d_rgba_vertex_attribute[0].streamIndex = 0;
- texture2d_rgba_vertex_attribute[0].offset = 0;
- texture2d_rgba_vertex_attribute[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- texture2d_rgba_vertex_attribute[0].componentCount = 3;
- texture2d_rgba_vertex_attribute[0].regIndex = sceGxmProgramParameterGetResourceIndex(
- texture2d_rgba_position);
- texture2d_rgba_vertex_attribute[1].streamIndex = 1;
- texture2d_rgba_vertex_attribute[1].offset = 0;
- texture2d_rgba_vertex_attribute[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- texture2d_rgba_vertex_attribute[1].componentCount = 2;
- texture2d_rgba_vertex_attribute[1].regIndex = sceGxmProgramParameterGetResourceIndex(
- texture2d_rgba_texcoord);
- texture2d_rgba_vertex_attribute[2].streamIndex = 2;
- texture2d_rgba_vertex_attribute[2].offset = 0;
- texture2d_rgba_vertex_attribute[2].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
- texture2d_rgba_vertex_attribute[2].componentCount = 4;
- texture2d_rgba_vertex_attribute[2].regIndex = sceGxmProgramParameterGetResourceIndex(
- texture2d_rgba_color);
- texture2d_rgba_vertex_stream[0].stride = sizeof(vector3f);
- texture2d_rgba_vertex_stream[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- texture2d_rgba_vertex_stream[1].stride = sizeof(vector2f);
- texture2d_rgba_vertex_stream[1].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
- texture2d_rgba_vertex_stream[2].stride = sizeof(vector4f);
- texture2d_rgba_vertex_stream[2].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- texture2d_rgba_vertex_id, texture2d_rgba_vertex_attribute,
- 3, texture2d_rgba_vertex_stream, 3, &texture2d_rgba_vertex_program_patched);
-
- texture2d_rgba_vertex_attribute[2].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
- texture2d_rgba_vertex_stream[2].stride = sizeof(uint8_t) * 4;
-
- sceGxmShaderPatcherCreateVertexProgram(gxm_shader_patcher,
- texture2d_rgba_vertex_id, texture2d_rgba_vertex_attribute,
- 3, texture2d_rgba_vertex_stream, 3, &texture2d_rgba_u8n_vertex_program_patched);
-
- sceGxmShaderPatcherCreateFragmentProgram(gxm_shader_patcher,
- texture2d_rgba_fragment_id, SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
- msaa, NULL, NULL,
- &texture2d_rgba_fragment_program_patched);
-
- texture2d_rgba_wvp = sceGxmProgramFindParameterByName(texture2d_rgba_vertex_program, "wvp");
-
- sceGxmSetTwoSidedEnable(gxm_context, SCE_GXM_TWO_SIDED_ENABLED);
-
- // Scissor Test shader register
- sceGxmShaderPatcherCreateMaskUpdateFragmentProgram(gxm_shader_patcher, &scissor_test_fragment_program);
-
- scissor_test_vertices = gpu_alloc_mapped(1 * sizeof(vector4f), &type);
-
- // Allocate temp pool for non-VBO drawing
- gpu_pool_init(gpu_pool_size);
-
- // Init texture units
- int i, j;
- for (i = 0; i < GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS; i++) {
- texture_units[i].env_mode = MODULATE;
- texture_units[i].tex_id = 0;
- texture_units[i].enabled = GL_FALSE;
- }
-
- // Init texture slots
- for (j = 0; j < TEXTURES_NUM; j++) {
- vgl_textures[j].used = 0;
- vgl_textures[j].valid = 0;
- }
-
- // Init custom shaders
- resetCustomShaders();
-
- // Init buffers
- for (i = 0; i < BUFFERS_NUM; i++) {
- buffers[i] = BUFFERS_ADDR + i;
- gpu_buffers[i].ptr = NULL;
- }
-
- // Init scissor test state
- resetScissorTestRegion();
-
- // Getting newlib heap memblock starting address
- void *addr = NULL;
- sceKernelGetMemBlockBase(_newlib_heap_memblock, &addr);
-
- // Mapping newlib heap into sceGxm
- sceGxmMapMemory(addr, _newlib_heap_size, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE);
-
- // Allocating default texture object
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-}
-
-void vglInitExtended(uint32_t gpu_pool_size, int width, int height, int ram_threshold, SceGxmMultisampleMode msaa) {
- // Initializing sceGxm
- initGxm();
-
- // Getting max allocatable CDRAM and RAM memory
- if (system_app_mode) {
- SceAppMgrBudgetInfo info;
- info.size = sizeof(SceAppMgrBudgetInfo);
- sceAppMgrGetBudgetInfo(&info);
- vglInitWithCustomSizes(gpu_pool_size, width, height, info.free_user_rw > ram_threshold ? info.free_user_rw - ram_threshold : info.free_user_rw, 0, 0, msaa);
- } else {
- SceKernelFreeMemorySizeInfo info;
- info.size = sizeof(SceKernelFreeMemorySizeInfo);
- sceKernelGetFreeMemorySize(&info);
- vglInitWithCustomSizes(gpu_pool_size, width, height, info.size_user > ram_threshold ? info.size_user - ram_threshold : info.size_user, info.size_cdram - 256 * 1024, info.size_phycont - 1 * 1024 * 1024, msaa);
- }
-}
-
-void vglInit(uint32_t gpu_pool_size) {
- vglInitExtended(gpu_pool_size, DISPLAY_WIDTH_DEF, DISPLAY_HEIGHT_DEF, 0x1000000, SCE_GXM_MULTISAMPLE_NONE);
-}
-
-void vglEnd(void) {
- // Wait for rendering to be finished
- waitRenderingDone();
-
- // Deallocating default vertices buffers
- vgl_mem_free(clear_vertices, VGL_MEM_RAM);
- vgl_mem_free(depth_vertices, VGL_MEM_RAM);
- vgl_mem_free(depth_clear_indices, VGL_MEM_RAM);
- vgl_mem_free(scissor_test_vertices, VGL_MEM_RAM);
-
- // Releasing shader programs from sceGxmShaderPatcher
- sceGxmShaderPatcherReleaseFragmentProgram(gxm_shader_patcher, scissor_test_fragment_program);
- sceGxmShaderPatcherReleaseFragmentProgram(gxm_shader_patcher, disable_color_buffer_fragment_program_patched);
- sceGxmShaderPatcherReleaseVertexProgram(gxm_shader_patcher, clear_vertex_program_patched);
- sceGxmShaderPatcherReleaseFragmentProgram(gxm_shader_patcher, clear_fragment_program_patched);
- sceGxmShaderPatcherReleaseVertexProgram(gxm_shader_patcher, rgba_vertex_program_patched);
- sceGxmShaderPatcherReleaseVertexProgram(gxm_shader_patcher, rgb_vertex_program_patched);
- sceGxmShaderPatcherReleaseFragmentProgram(gxm_shader_patcher, rgba_fragment_program_patched);
- sceGxmShaderPatcherReleaseVertexProgram(gxm_shader_patcher, texture2d_vertex_program_patched);
- sceGxmShaderPatcherReleaseFragmentProgram(gxm_shader_patcher, texture2d_fragment_program_patched);
-
- // Unregistering shader programs from sceGxmShaderPatcher
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, clear_vertex_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, clear_fragment_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, rgb_vertex_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, rgba_vertex_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, rgba_fragment_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, texture2d_vertex_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, texture2d_fragment_id);
- sceGxmShaderPatcherUnregisterProgram(gxm_shader_patcher, disable_color_buffer_fragment_id);
-
- // Terminating shader patcher
- stopShaderPatcher();
-
- // Deallocating depth and stencil surfaces for display
- termDepthStencilSurfaces();
-
- // Terminating display's color surfaces
- termDisplayColorSurfaces();
-
- // Destroing display's render target
- destroyDisplayRenderTarget();
-
- // Terminating sceGxm context
- termGxmContext();
-
- // Terminating sceGxm
- sceGxmTerminate();
-}
-
-void vglWaitVblankStart(GLboolean enable) {
- vblank = enable;
-}
-
-// openGL implementation
-
-void glGenBuffers(GLsizei n, GLuint *res) {
- int i = 0, j = 0;
-#ifndef SKIP_ERROR_HANDLING
- if (n < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- for (i = 0; i < BUFFERS_NUM; i++) {
- if (buffers[i] != 0x0000) {
- res[j++] = buffers[i];
- buffers[i] = 0x0000;
- }
- if (j >= n)
- break;
- }
-}
-
-void glBindBuffer(GLenum target, GLuint buffer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((buffer != 0x0000) && ((buffer >= BUFFERS_ADDR + BUFFERS_NUM) || (buffer < BUFFERS_ADDR))) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- switch (target) {
- case GL_ARRAY_BUFFER:
- vertex_array_unit = buffer - BUFFERS_ADDR;
- break;
- case GL_ELEMENT_ARRAY_BUFFER:
- index_array_unit = buffer - BUFFERS_ADDR;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glDeleteBuffers(GLsizei n, const GLuint *gl_buffers) {
-#ifndef SKIP_ERROR_HANDLING
- if (n < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- return;
- }
-#endif
- int i, j;
- for (j = 0; j < n; j++) {
- if (gl_buffers[j] >= BUFFERS_ADDR && gl_buffers[j] < (BUFFERS_ADDR + BUFFERS_NUM)) {
- uint8_t idx = gl_buffers[j] - BUFFERS_ADDR;
- buffers[idx] = gl_buffers[j];
- if (gpu_buffers[idx].ptr != NULL) {
- vgl_mem_free(gpu_buffers[idx].ptr, VGL_MEM_VRAM);
- gpu_buffers[idx].ptr = NULL;
- gpu_buffers[idx].size = 0;
- }
- }
- }
-}
-
-void glBufferData(GLenum target, GLsizei size, const GLvoid *data, GLenum usage) {
- int idx = 0;
- switch (target) {
- case GL_ARRAY_BUFFER:
- idx = vertex_array_unit;
- break;
- case GL_ELEMENT_ARRAY_BUFFER:
- idx = index_array_unit;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-#ifndef SKIP_ERROR_HANDLING
- if (size < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-
- if (idx < 0) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
- vglMemType type = use_vram ? VGL_MEM_VRAM : VGL_MEM_RAM;
-
- // Free buffer if already existing.
- if (gpu_buffers[idx].ptr != NULL)
- vgl_mem_free(gpu_buffers[idx].ptr, type);
-
- gpu_buffers[idx].ptr = gpu_alloc_mapped(size, &type);
- gpu_buffers[idx].size = size;
-
-#ifndef SKIP_ERROR_HANDLING
- if (gpu_buffers[idx].ptr == NULL) {
- gpu_buffers[idx].size = 0;
- SET_GL_ERROR(GL_OUT_OF_MEMORY)
- }
-#endif
-
- memcpy_neon(gpu_buffers[idx].ptr, data, size);
-}
-
-void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) {
- int idx = 0;
- switch (target) {
- case GL_ARRAY_BUFFER:
- idx = vertex_array_unit;
- break;
- case GL_ELEMENT_ARRAY_BUFFER:
- idx = index_array_unit;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-#ifndef SKIP_ERROR_HANDLING
- if ((size < 0) || (offset < 0) || ((offset + size) > gpu_buffers[idx].size)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-
- if (idx < 0) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- }
-#endif
-
- memcpy_neon(gpu_buffers[idx].ptr + offset, data, size);
-}
-
-void glBlendFunc(GLenum sfactor, GLenum dfactor) {
- switch (sfactor) {
- case GL_ZERO:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ZERO;
- break;
- case GL_ONE:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE;
- break;
- case GL_SRC_COLOR:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_SRC_COLOR;
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- break;
- case GL_DST_COLOR:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_DST_COLOR;
- break;
- case GL_ONE_MINUS_DST_COLOR:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- break;
- case GL_SRC_ALPHA:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- break;
- case GL_DST_ALPHA:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_DST_ALPHA;
- break;
- case GL_ONE_MINUS_DST_ALPHA:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- break;
- case GL_SRC_ALPHA_SATURATE:
- blend_sfactor_rgb = blend_sfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- switch (dfactor) {
- case GL_ZERO:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ZERO;
- break;
- case GL_ONE:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE;
- break;
- case GL_SRC_COLOR:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_SRC_COLOR;
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- break;
- case GL_DST_COLOR:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_DST_COLOR;
- break;
- case GL_ONE_MINUS_DST_COLOR:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- break;
- case GL_SRC_ALPHA:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- break;
- case GL_DST_ALPHA:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_DST_ALPHA;
- break;
- case GL_ONE_MINUS_DST_ALPHA:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- break;
- case GL_SRC_ALPHA_SATURATE:
- blend_dfactor_rgb = blend_dfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (blend_state)
- change_blend_factor();
-}
-
-void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
- switch (srcRGB) {
- case GL_ZERO:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ZERO;
- break;
- case GL_ONE:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE;
- break;
- case GL_SRC_COLOR:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_SRC_COLOR;
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- break;
- case GL_DST_COLOR:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_DST_COLOR;
- break;
- case GL_ONE_MINUS_DST_COLOR:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- break;
- case GL_SRC_ALPHA:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- break;
- case GL_DST_ALPHA:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_DST_ALPHA;
- break;
- case GL_ONE_MINUS_DST_ALPHA:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- break;
- case GL_SRC_ALPHA_SATURATE:
- blend_sfactor_rgb = SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- switch (dstRGB) {
- case GL_ZERO:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ZERO;
- break;
- case GL_ONE:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE;
- break;
- case GL_SRC_COLOR:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_SRC_COLOR;
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- break;
- case GL_DST_COLOR:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_DST_COLOR;
- break;
- case GL_ONE_MINUS_DST_COLOR:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- break;
- case GL_SRC_ALPHA:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- break;
- case GL_DST_ALPHA:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_DST_ALPHA;
- break;
- case GL_ONE_MINUS_DST_ALPHA:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- break;
- case GL_SRC_ALPHA_SATURATE:
- blend_dfactor_rgb = SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- switch (srcAlpha) {
- case GL_ZERO:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ZERO;
- break;
- case GL_ONE:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE;
- break;
- case GL_SRC_COLOR:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_SRC_COLOR;
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- break;
- case GL_DST_COLOR:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_DST_COLOR;
- break;
- case GL_ONE_MINUS_DST_COLOR:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- break;
- case GL_SRC_ALPHA:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- break;
- case GL_DST_ALPHA:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_DST_ALPHA;
- break;
- case GL_ONE_MINUS_DST_ALPHA:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- break;
- case GL_SRC_ALPHA_SATURATE:
- blend_sfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- switch (dstAlpha) {
- case GL_ZERO:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ZERO;
- break;
- case GL_ONE:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE;
- break;
- case GL_SRC_COLOR:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_SRC_COLOR;
- break;
- case GL_ONE_MINUS_SRC_COLOR:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- break;
- case GL_DST_COLOR:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_DST_COLOR;
- break;
- case GL_ONE_MINUS_DST_COLOR:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- break;
- case GL_SRC_ALPHA:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA;
- break;
- case GL_ONE_MINUS_SRC_ALPHA:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- break;
- case GL_DST_ALPHA:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_DST_ALPHA;
- break;
- case GL_ONE_MINUS_DST_ALPHA:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- break;
- case GL_SRC_ALPHA_SATURATE:
- blend_dfactor_a = SCE_GXM_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (blend_state)
- change_blend_factor();
-}
-
-void glBlendEquation(GLenum mode) {
- switch (mode) {
- case GL_FUNC_ADD:
- blend_func_rgb = blend_func_a = SCE_GXM_BLEND_FUNC_ADD;
- break;
- case GL_FUNC_SUBTRACT:
- blend_func_rgb = blend_func_a = SCE_GXM_BLEND_FUNC_SUBTRACT;
- break;
- case GL_FUNC_REVERSE_SUBTRACT:
- blend_func_rgb = blend_func_a = SCE_GXM_BLEND_FUNC_REVERSE_SUBTRACT;
- break;
- case GL_MIN:
- blend_func_rgb = blend_func_a = SCE_GXM_BLEND_FUNC_MIN;
- break;
- case GL_MAX:
- blend_func_rgb = blend_func_a = SCE_GXM_BLEND_FUNC_MAX;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (blend_state)
- change_blend_factor();
-}
-
-void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
- switch (modeRGB) {
- case GL_FUNC_ADD:
- blend_func_rgb = SCE_GXM_BLEND_FUNC_ADD;
- break;
- case GL_FUNC_SUBTRACT:
- blend_func_rgb = SCE_GXM_BLEND_FUNC_SUBTRACT;
- break;
- case GL_FUNC_REVERSE_SUBTRACT:
- blend_func_rgb = SCE_GXM_BLEND_FUNC_REVERSE_SUBTRACT;
- break;
- case GL_MIN:
- blend_func_rgb = SCE_GXM_BLEND_FUNC_MIN;
- break;
- case GL_MAX:
- blend_func_rgb = SCE_GXM_BLEND_FUNC_MAX;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- switch (modeAlpha) {
- case GL_FUNC_ADD:
- blend_func_a = SCE_GXM_BLEND_FUNC_ADD;
- break;
- case GL_FUNC_SUBTRACT:
- blend_func_a = SCE_GXM_BLEND_FUNC_SUBTRACT;
- break;
- case GL_FUNC_REVERSE_SUBTRACT:
- blend_func_a = SCE_GXM_BLEND_FUNC_REVERSE_SUBTRACT;
- break;
- case GL_MIN:
- blend_func_a = SCE_GXM_BLEND_FUNC_MIN;
- break;
- case GL_MAX:
- blend_func_a = SCE_GXM_BLEND_FUNC_MAX;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (blend_state)
- change_blend_factor();
-}
-
-void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
- blend_color_mask = SCE_GXM_COLOR_MASK_NONE;
- if (red)
- blend_color_mask += SCE_GXM_COLOR_MASK_R;
- if (green)
- blend_color_mask += SCE_GXM_COLOR_MASK_G;
- if (blue)
- blend_color_mask += SCE_GXM_COLOR_MASK_B;
- if (alpha)
- blend_color_mask += SCE_GXM_COLOR_MASK_A;
- if (blend_state)
- change_blend_factor();
- else
- change_blend_mask();
-}
-
-void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((stride < 0) || (size < 2) || (size > 4)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- switch (type) {
- case GL_FLOAT:
- tex_unit->vertex_array.size = sizeof(GLfloat);
- break;
- case GL_SHORT:
- tex_unit->vertex_array.size = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- tex_unit->vertex_array.num = size;
- tex_unit->vertex_array.stride = stride;
- tex_unit->vertex_array.pointer = pointer;
-}
-
-void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((stride < 0) || (size < 3) || (size > 4)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- switch (type) {
- case GL_FLOAT:
- tex_unit->color_array.size = sizeof(GLfloat);
- break;
- case GL_SHORT:
- tex_unit->color_array.size = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- tex_unit->color_array.num = size;
- tex_unit->color_array.stride = stride;
- tex_unit->color_array.pointer = pointer;
-}
-
-void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((stride < 0) || (size < 2) || (size > 4)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- switch (type) {
- case GL_FLOAT:
- tex_unit->texture_array.size = sizeof(GLfloat);
- break;
- case GL_SHORT:
- tex_unit->texture_array.size = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-
- tex_unit->texture_array.num = size;
- tex_unit->texture_array.stride = stride;
- tex_unit->texture_array.pointer = pointer;
-}
-
-void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- SceGxmPrimitiveType gxm_p;
- if (tex_unit->vertex_array_state) {
- GLboolean skip_draw = GL_FALSE;
- switch (mode) {
- case GL_POINTS:
- gxm_p = SCE_GXM_PRIMITIVE_POINTS;
- break;
- case GL_LINES:
- gxm_p = SCE_GXM_PRIMITIVE_LINES;
- if ((count % 2) != 0)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLES:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLES;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- else if ((count % 3) != 0)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLE_STRIP:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLE_STRIP;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLE_FAN:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLE_FAN;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (!skip_draw) {
- if (mvp_modified) {
- matrix4x4_multiply(mvp_matrix, projection_matrix, modelview_matrix);
- mvp_modified = GL_FALSE;
- }
-
- if (tex_unit->texture_array_state) {
- if (!(vgl_textures[texture2d_idx].valid))
- return;
- if (tex_unit->color_array_state) {
- sceGxmSetVertexProgram(gxm_context, texture2d_rgba_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_rgba_fragment_program_patched);
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_alpha_op, 0, 1, &alpha_operation);
- float env_mode = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_tex_env, 0, 1, &env_mode);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_density, 0, 1, (const float *)&fog_density);
- } else {
- sceGxmSetVertexProgram(gxm_context, texture2d_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_fragment_program_patched);
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_op, 0, 1, &alpha_operation);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tint_color, 0, 4, ¤t_color.r);
- float env_mode = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env, 0, 1, &env_mode);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_density, 0, 1, (const float *)&fog_density);
- }
- } else if (tex_unit->color_array_state && (tex_unit->color_array.num == 3)) {
- sceGxmSetVertexProgram(gxm_context, rgb_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- } else {
- sceGxmSetVertexProgram(gxm_context, rgba_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- }
-
- void *vertex_wvp_buffer;
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_wvp_buffer);
-
- if (tex_unit->texture_array_state) {
- if (tex_unit->color_array_state) {
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_wvp, 0, 16, (const float *)mvp_matrix);
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_mv, 0, 16, (const float *)modelview_matrix);
- } else {
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_wvp, 0, 16, (const float *)mvp_matrix);
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_mv, 0, 16, (const float *)modelview_matrix);
- }
- sceGxmSetFragmentTexture(gxm_context, 0, &vgl_textures[texture2d_idx].gxm_tex);
- vector3f *vertices = NULL;
- vector2f *uv_map = NULL;
- vector4f *colors = NULL;
- uint16_t *indices;
- uint16_t n;
- if (vertex_array_unit >= 0) {
- if (tex_unit->vertex_array.stride == 0)
- vertices = (vector3f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer) + (first * (tex_unit->vertex_array.num * tex_unit->vertex_array.size)));
- else
- vertices = (vector3f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer) + (first * tex_unit->vertex_array.stride));
- if (tex_unit->texture_array.stride == 0)
- uv_map = (vector2f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->texture_array.pointer) + (first * (tex_unit->texture_array.num * tex_unit->texture_array.size)));
- else
- uv_map = (vector2f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->texture_array.pointer) + (first * tex_unit->texture_array.stride));
- if (tex_unit->color_array_state) {
- if (tex_unit->color_array.stride == 0)
- colors = (vector4f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->color_array.pointer) + (first * (tex_unit->color_array.num * tex_unit->color_array.size)));
- else
- colors = (vector4f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->color_array.pointer) + (first * tex_unit->color_array.stride));
- }
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- for (n = 0; n < count; n++) {
- indices[n] = n;
- }
- } else {
- uint8_t *ptr;
- uint8_t *ptr_tex;
- uint8_t *ptr_clr;
- vertices = (vector3f *)gpu_pool_memalign(count * sizeof(vector3f), sizeof(vector3f));
- uv_map = (vector2f *)gpu_pool_memalign(count * sizeof(vector2f), sizeof(vector2f));
- if (tex_unit->color_array_state)
- colors = (vector4f *)gpu_pool_memalign(count * sizeof(vector4f), sizeof(vector4f));
- memset(vertices, 0, (count * sizeof(vector3f)));
- uint8_t vec_set = 0, tex_set = 0, clr_set = 0;
- if (tex_unit->vertex_array.stride == 0) {
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (first * (tex_unit->vertex_array.num * tex_unit->vertex_array.size));
- memcpy_neon(&vertices[0], ptr, count * sizeof(vector3f));
- vec_set = 1;
- } else
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (first * tex_unit->vertex_array.stride);
- if (tex_unit->texture_array.stride == 0) {
- ptr_tex = ((uint8_t *)tex_unit->texture_array.pointer) + (first * (tex_unit->texture_array.num * tex_unit->texture_array.size));
- memcpy_neon(&uv_map[0], ptr_tex, count * sizeof(vector2f));
- tex_set = 1;
- } else
- ptr_tex = ((uint8_t *)tex_unit->texture_array.pointer) + (first * tex_unit->texture_array.stride);
- if (tex_unit->color_array_state) {
- if (tex_unit->color_array.stride == 0) {
- ptr_clr = ((uint8_t *)tex_unit->color_array.pointer) + (first * sizeof(vector4f));
- memcpy_neon(&colors[0], ptr_clr, count * sizeof(vector4f));
- clr_set = 1;
- } else
- ptr_clr = ((uint8_t *)tex_unit->color_array.pointer) + (first * tex_unit->color_array.stride);
- }
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- for (n = 0; n < count; n++) {
- if (!vec_set) {
- memcpy_neon(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
- ptr += tex_unit->vertex_array.stride;
- }
- if (!tex_set) {
- memcpy_neon(&uv_map[n], ptr_tex, tex_unit->texture_array.size * tex_unit->texture_array.num);
- ptr_tex += tex_unit->texture_array.stride;
- }
- if (tex_unit->color_array_state && (!clr_set)) {
- memcpy_neon(&colors[n], ptr_clr, tex_unit->color_array.size * tex_unit->color_array.num);
- ptr_clr += tex_unit->color_array.stride;
- }
- indices[n] = n;
- }
- }
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, uv_map);
- if (tex_unit->color_array_state)
- sceGxmSetVertexStream(gxm_context, 2, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, indices, count);
- } else if (tex_unit->color_array_state) {
- if (tex_unit->color_array.num == 3)
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgb_wvp, 0, 16, (const float *)mvp_matrix);
- else
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
- vector3f *vertices = NULL;
- uint8_t *colors = NULL;
- uint16_t *indices;
- uint16_t n = 0;
- if (vertex_array_unit >= 0) {
- if (tex_unit->vertex_array.stride == 0)
- vertices = (vector3f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer) + (first * (tex_unit->vertex_array.num * tex_unit->vertex_array.size)));
- else
- vertices = (vector3f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer) + (first * tex_unit->vertex_array.stride));
- if (tex_unit->color_array.stride == 0)
- colors = (uint8_t *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->color_array.pointer) + (first * (tex_unit->color_array.num * tex_unit->color_array.size)));
- else
- colors = (uint8_t *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->color_array.pointer) + (first * tex_unit->color_array.stride));
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- for (n = 0; n < count; n++) {
- indices[n] = n;
- }
- } else {
- uint8_t *ptr;
- uint8_t *ptr_clr;
- vertices = (vector3f *)gpu_pool_memalign(count * sizeof(vector3f), sizeof(vector3f));
- colors = (uint8_t *)gpu_pool_memalign(count * tex_unit->color_array.num * tex_unit->color_array.size, tex_unit->color_array.num * tex_unit->color_array.size);
- memset(vertices, 0, (count * sizeof(vector3f)));
- uint8_t vec_set = 0, clr_set = 0;
- if (tex_unit->vertex_array.stride == 0) {
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (first * ((tex_unit->vertex_array.num * tex_unit->vertex_array.size)));
- memcpy_neon(&vertices[n], ptr, count * sizeof(vector3f));
- vec_set = 1;
- } else
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (first * (tex_unit->vertex_array.stride));
- if (tex_unit->color_array.stride == 0) {
- ptr_clr = ((uint8_t *)tex_unit->color_array.pointer) + (first * ((tex_unit->color_array.num * tex_unit->color_array.size)));
- memcpy_neon(&colors[n], ptr_clr, count * tex_unit->color_array.num * tex_unit->color_array.size);
- clr_set = 1;
- } else
- ptr_clr = ((uint8_t *)tex_unit->color_array.pointer) + (first * tex_unit->color_array.size);
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- for (n = 0; n < count; n++) {
- if (!vec_set) {
- memcpy_neon(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
- ptr += tex_unit->vertex_array.stride;
- }
- if (!clr_set) {
- memcpy_neon(&colors[n * tex_unit->color_array.num * tex_unit->color_array.size], ptr_clr, tex_unit->color_array.size * tex_unit->color_array.num);
- ptr_clr += tex_unit->color_array.stride;
- }
- indices[n] = n;
- }
- }
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, indices, count);
- } else {
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
- vector3f *vertices = NULL;
- vector4f *colors = NULL;
- uint16_t *indices;
- uint16_t n = 0;
- if (vertex_array_unit >= 0) {
- if (tex_unit->vertex_array.stride == 0)
- vertices = (vector3f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer) + (first * (tex_unit->vertex_array.num * tex_unit->vertex_array.size)));
- else
- vertices = (vector3f *)(((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer) + (first * tex_unit->vertex_array.stride));
- colors = (vector4f *)gpu_pool_memalign(count * sizeof(vector4f), sizeof(vector4f));
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- for (n = 0; n < count; n++) {
- memcpy_neon(&colors[n], ¤t_color.r, sizeof(vector4f));
- indices[n] = n;
- }
- } else {
- uint8_t *ptr;
- vertices = (vector3f *)gpu_pool_memalign(count * sizeof(vector3f), sizeof(vector3f));
- colors = (vector4f *)gpu_pool_memalign(count * sizeof(vector4f), sizeof(vector4f));
- memset(vertices, 0, (count * sizeof(vector3f)));
- uint8_t vec_set = 0;
- if (tex_unit->vertex_array.stride == 0) {
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (first * ((tex_unit->vertex_array.num * tex_unit->vertex_array.size)));
- memcpy_neon(&vertices[n], ptr, count * sizeof(vector3f));
- vec_set = 1;
- } else
- ptr = ((uint8_t *)tex_unit->vertex_array.pointer) + (first * (tex_unit->vertex_array.stride));
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- for (n = 0; n < count; n++) {
- if (!vec_set) {
- memcpy_neon(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
- ptr += tex_unit->vertex_array.stride;
- }
- memcpy_neon(&colors[n], ¤t_color.r, sizeof(vector4f));
- indices[n] = n;
- }
- }
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, indices, count);
- }
- }
- }
-}
-
-void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *gl_indices) {
- SceGxmPrimitiveType gxm_p;
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
- if (tex_unit->vertex_array_state) {
- GLboolean skip_draw = GL_FALSE;
-#ifndef SKIP_ERROR_HANDLING
- if (type != GL_UNSIGNED_SHORT) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- } else if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- } else if (count < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- switch (mode) {
- case GL_POINTS:
- gxm_p = SCE_GXM_PRIMITIVE_POINTS;
- break;
- case GL_LINES:
- gxm_p = SCE_GXM_PRIMITIVE_LINES;
- break;
- case GL_TRIANGLES:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLES;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLE_STRIP:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLE_STRIP;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLE_FAN:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLE_FAN;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (!skip_draw) {
- if (mvp_modified) {
- matrix4x4_multiply(mvp_matrix, projection_matrix, modelview_matrix);
- mvp_modified = GL_FALSE;
- }
-
- if (tex_unit->texture_array_state) {
- if (!(vgl_textures[texture2d_idx].valid))
- return;
- if (tex_unit->color_array_state) {
- sceGxmSetVertexProgram(gxm_context, texture2d_rgba_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_rgba_fragment_program_patched);
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_alpha_op, 0, 1, &alpha_operation);
- float env_mode = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_tex_env, 0, 1, &env_mode);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_density, 0, 1, (const float *)&fog_density);
- } else {
- sceGxmSetVertexProgram(gxm_context, texture2d_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_fragment_program_patched);
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_op, 0, 1, &alpha_operation);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tint_color, 0, 4, ¤t_color.r);
- float env_mode = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env, 0, 1, &env_mode);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_density, 0, 1, (const float *)&fog_density);
- }
- } else if (tex_unit->color_array_state && (tex_unit->color_array.num == 3)) {
- sceGxmSetVertexProgram(gxm_context, rgb_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- } else {
- sceGxmSetVertexProgram(gxm_context, rgba_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- }
-
- void *vertex_wvp_buffer;
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_wvp_buffer);
-
- if (tex_unit->texture_array_state) {
- if (tex_unit->color_array_state) {
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_wvp, 0, 16, (const float *)mvp_matrix);
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_mv, 0, 16, (const float *)modelview_matrix);
- } else {
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_wvp, 0, 16, (const float *)mvp_matrix);
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_mv, 0, 16, (const float *)modelview_matrix);
- }
- sceGxmSetFragmentTexture(gxm_context, 0, &vgl_textures[texture2d_idx].gxm_tex);
- vector3f *vertices = NULL;
- vector2f *uv_map = NULL;
- vector4f *colors = NULL;
- uint16_t *indices;
- if (index_array_unit >= 0)
- indices = (uint16_t *)((uint32_t)gpu_buffers[index_array_unit].ptr + (uint32_t)gl_indices);
- else {
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- memcpy_neon(indices, gl_indices, sizeof(uint16_t) * count);
- }
- if (vertex_array_unit >= 0) {
- vertices = (vector3f *)((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer);
- uv_map = (vector2f *)((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->texture_array.pointer);
- if (tex_unit->color_array_state)
- colors = (vector4f *)((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->color_array.pointer);
- } else {
- int n = 0, j = 0;
- uint64_t vertex_count_int = 0;
- uint16_t *ptr_idx = (uint16_t *)gl_indices;
- while (j < count) {
- if (ptr_idx[j] >= vertex_count_int)
- vertex_count_int = ptr_idx[j] + 1;
- j++;
- }
- vertices = (vector3f *)gpu_pool_memalign(vertex_count_int * sizeof(vector3f), sizeof(vector3f));
- uv_map = (vector2f *)gpu_pool_memalign(vertex_count_int * sizeof(vector2f), sizeof(vector2f));
- colors = (vector4f *)gpu_pool_memalign(vertex_count_int * sizeof(vector4f), sizeof(vector4f));
- if (tex_unit->vertex_array.stride == 0)
- memcpy_neon(vertices, tex_unit->vertex_array.pointer, vertex_count_int * (tex_unit->vertex_array.size * tex_unit->vertex_array.num));
- if (tex_unit->texture_array.stride == 0)
- memcpy_neon(uv_map, tex_unit->texture_array.pointer, vertex_count_int * (tex_unit->texture_array.size * tex_unit->texture_array.num));
- if (tex_unit->color_array_state && (tex_unit->color_array.stride == 0))
- memcpy_neon(colors, tex_unit->color_array.pointer, vertex_count_int * (tex_unit->color_array.size * tex_unit->color_array.num));
- if ((tex_unit->vertex_array.stride != 0) || (tex_unit->texture_array.stride != 0)) {
- if (tex_unit->vertex_array.stride != 0)
- memset(vertices, 0, (vertex_count_int * sizeof(texture2d_vertex)));
- uint8_t *ptr = ((uint8_t *)tex_unit->vertex_array.pointer);
- uint8_t *ptr_tex = ((uint8_t *)tex_unit->texture_array.pointer);
- for (n = 0; n < vertex_count_int; n++) {
- if (tex_unit->vertex_array.stride != 0)
- memcpy_neon(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
- if (tex_unit->texture_array.stride != 0)
- memcpy_neon(&uv_map[n], ptr_tex, tex_unit->texture_array.size * tex_unit->texture_array.num);
- ptr += tex_unit->vertex_array.stride;
- ptr_tex += tex_unit->texture_array.stride;
- }
- }
- }
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, uv_map);
- if (tex_unit->color_array_state)
- sceGxmSetVertexStream(gxm_context, 2, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, indices, count);
- } else if (tex_unit->color_array_state) {
- if (tex_unit->color_array.num == 3)
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgb_wvp, 0, 16, (const float *)mvp_matrix);
- else
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
- vector3f *vertices = NULL;
- uint8_t *colors = NULL;
- uint16_t *indices;
- if (index_array_unit >= 0)
- indices = (uint16_t *)((uint32_t)gpu_buffers[index_array_unit].ptr + (uint32_t)gl_indices);
- else {
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- memcpy_neon(indices, gl_indices, sizeof(uint16_t) * count);
- }
- if (vertex_array_unit >= 0) {
- colors = (uint8_t *)((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->color_array.pointer);
- vertices = (vector3f *)((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer);
- } else {
- int n = 0, j = 0;
- uint64_t vertex_count_int = 0;
- uint16_t *ptr_idx = (uint16_t *)gl_indices;
- while (j < count) {
- if (ptr_idx[j] >= vertex_count_int)
- vertex_count_int = ptr_idx[j] + 1;
- j++;
- }
- vertices = (vector3f *)gpu_pool_memalign(vertex_count_int * sizeof(vector3f), sizeof(vector3f));
- colors = (uint8_t *)gpu_pool_memalign(vertex_count_int * tex_unit->color_array.num * tex_unit->color_array.size, tex_unit->color_array.num * tex_unit->color_array.size);
- if (tex_unit->vertex_array.stride == 0)
- memcpy_neon(vertices, tex_unit->vertex_array.pointer, vertex_count_int * (tex_unit->vertex_array.size * tex_unit->vertex_array.num));
- if (tex_unit->color_array.stride == 0)
- memcpy_neon(colors, tex_unit->color_array.pointer, vertex_count_int * (tex_unit->color_array.size * tex_unit->color_array.num));
- if ((tex_unit->vertex_array.stride != 0) || (tex_unit->color_array.stride != 0)) {
- if (tex_unit->vertex_array.stride != 0)
- memset(vertices, 0, (vertex_count_int * sizeof(texture2d_vertex)));
- uint8_t *ptr = ((uint8_t *)tex_unit->vertex_array.pointer);
- uint8_t *ptr_clr = ((uint8_t *)tex_unit->color_array.pointer);
- for (n = 0; n < vertex_count_int; n++) {
- if (tex_unit->vertex_array.stride != 0)
- memcpy_neon(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
- if (tex_unit->color_array.stride != 0)
- memcpy_neon(&colors[n * tex_unit->color_array.num * tex_unit->color_array.size], ptr_clr, tex_unit->color_array.size * tex_unit->color_array.num);
- ptr += tex_unit->vertex_array.stride;
- ptr_clr += tex_unit->color_array.stride;
- }
- }
- }
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, indices, count);
- } else {
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
- vector3f *vertices = NULL;
- vector4f *colors = NULL;
- uint16_t *indices;
- if (index_array_unit >= 0)
- indices = (uint16_t *)((uint32_t)gpu_buffers[index_array_unit].ptr + (uint32_t)gl_indices);
- else {
- indices = (uint16_t *)gpu_pool_memalign(count * sizeof(uint16_t), sizeof(uint16_t));
- memcpy_neon(indices, gl_indices, sizeof(uint16_t) * count);
- }
- int n = 0, j = 0;
- uint64_t vertex_count_int = 0;
- uint16_t *ptr_idx = (uint16_t *)gl_indices;
- while (j < count) {
- if (ptr_idx[j] >= vertex_count_int)
- vertex_count_int = ptr_idx[j] + 1;
- j++;
- }
- if (vertex_array_unit >= 0)
- vertices = (vector3f *)((uint32_t)gpu_buffers[vertex_array_unit].ptr + (uint32_t)tex_unit->vertex_array.pointer);
- else
- vertices = (vector3f *)gpu_pool_memalign(vertex_count_int * sizeof(vector3f), sizeof(vector3f));
- colors = (vector4f *)gpu_pool_memalign(vertex_count_int * tex_unit->color_array.num * tex_unit->color_array.size, tex_unit->color_array.num * tex_unit->color_array.size);
- if ((!vertex_array_unit) && tex_unit->vertex_array.stride == 0)
- memcpy_neon(vertices, tex_unit->vertex_array.pointer, vertex_count_int * (tex_unit->vertex_array.size * tex_unit->vertex_array.num));
- if ((!vertex_array_unit) && tex_unit->vertex_array.stride != 0)
- memset(vertices, 0, (vertex_count_int * sizeof(texture2d_vertex)));
- uint8_t *ptr = ((uint8_t *)tex_unit->vertex_array.pointer);
- for (n = 0; n < vertex_count_int; n++) {
- if ((!vertex_array_unit) && tex_unit->vertex_array.stride != 0)
- memcpy_neon(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num);
- memcpy_neon(&colors[n], ¤t_color.r, sizeof(vector4f));
- if (!vertex_array_unit)
- ptr += tex_unit->vertex_array.stride;
- }
- sceGxmSetVertexStream(gxm_context, 0, vertices);
- sceGxmSetVertexStream(gxm_context, 1, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, indices, count);
- }
- }
- }
-}
-
-void glEnableClientState(GLenum array) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- switch (array) {
- case GL_VERTEX_ARRAY:
- tex_unit->vertex_array_state = GL_TRUE;
- break;
- case GL_COLOR_ARRAY:
- tex_unit->color_array_state = GL_TRUE;
- break;
- case GL_TEXTURE_COORD_ARRAY:
- tex_unit->texture_array_state = GL_TRUE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glDisableClientState(GLenum array) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- switch (array) {
- case GL_VERTEX_ARRAY:
- tex_unit->vertex_array_state = GL_FALSE;
- break;
- case GL_COLOR_ARRAY:
- tex_unit->color_array_state = GL_FALSE;
- break;
- case GL_TEXTURE_COORD_ARRAY:
- tex_unit->texture_array_state = GL_FALSE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
-}
-
-void glClientActiveTexture(GLenum texture) {
-#ifndef SKIP_ERROR_HANDLING
- if ((texture < GL_TEXTURE0) && (texture > GL_TEXTURE31)) {
- SET_GL_ERROR(GL_INVALID_ENUM)
- } else
-#endif
- client_texture_unit = texture - GL_TEXTURE0;
-}
-
-// VGL_EXT_gpu_objects_array extension implementation
-
-void vglVertexPointer(GLint size, GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((stride < 0) || (size < 2) || (size > 4)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int bpe;
- switch (type) {
- case GL_FLOAT:
- bpe = sizeof(GLfloat);
- break;
- case GL_SHORT:
- bpe = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- tex_unit->vertex_object = gpu_pool_memalign(count * bpe * size, bpe * size);
- if (stride == 0)
- memcpy_neon(tex_unit->vertex_object, pointer, count * bpe * size);
- else {
- int i;
- uint8_t *dst = (uint8_t *)tex_unit->vertex_object;
- uint8_t *src = (uint8_t *)pointer;
- for (i = 0; i < count; i++) {
- memcpy_neon(dst, src, bpe * size);
- dst += (bpe * size);
- src += stride;
- }
- }
-}
-
-void vglColorPointer(GLint size, GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((stride < 0) || (size < 3) || (size > 4)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int bpe;
- switch (type) {
- case GL_FLOAT:
- bpe = sizeof(GLfloat);
- break;
- case GL_SHORT:
- bpe = sizeof(GLshort);
- break;
- case GL_UNSIGNED_BYTE:
- bpe = sizeof(uint8_t);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- tex_unit->color_object = gpu_pool_memalign(count * bpe * size, bpe * size);
- tex_unit->color_object_type = type;
- if (stride == 0)
- memcpy_neon(tex_unit->color_object, pointer, count * bpe * size);
- else {
- int i;
- uint8_t *dst = (uint8_t *)tex_unit->color_object;
- uint8_t *src = (uint8_t *)pointer;
- for (i = 0; i < count; i++) {
- memcpy_neon(dst, src, bpe * size);
- dst += (bpe * size);
- src += stride;
- }
- }
-}
-
-void vglTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if ((stride < 0) || (size < 2) || (size > 4)) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int bpe;
- switch (type) {
- case GL_FLOAT:
- bpe = sizeof(GLfloat);
- break;
- case GL_SHORT:
- bpe = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- tex_unit->texture_object = gpu_pool_memalign(count * bpe * size, bpe * size);
- if (stride == 0)
- memcpy_neon(tex_unit->texture_object, pointer, count * bpe * size);
- else {
- int i;
- uint8_t *dst = (uint8_t *)tex_unit->texture_object;
- uint8_t *src = (uint8_t *)pointer;
- for (i = 0; i < count; i++) {
- memcpy_neon(dst, src, bpe * size);
- dst += (bpe * size);
- src += stride;
- }
- }
-}
-
-void vglIndexPointer(GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer) {
-#ifndef SKIP_ERROR_HANDLING
- if (stride < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int bpe;
- switch (type) {
- case GL_FLOAT:
- bpe = sizeof(GLfloat);
- break;
- case GL_SHORT:
- bpe = sizeof(GLshort);
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- tex_unit->index_object = gpu_pool_memalign(count * bpe, bpe);
- if (stride == 0)
- memcpy_neon(tex_unit->index_object, pointer, count * bpe);
- else {
- int i;
- uint8_t *dst = (uint8_t *)tex_unit->index_object;
- uint8_t *src = (uint8_t *)pointer;
- for (i = 0; i < count; i++) {
- memcpy_neon(dst, src, bpe);
- dst += bpe;
- src += stride;
- }
- }
-}
-
-void vglVertexPointerMapped(const GLvoid *pointer) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- tex_unit->vertex_object = (GLvoid *)pointer;
-}
-
-void vglColorPointerMapped(GLenum type, const GLvoid *pointer) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- tex_unit->color_object = (GLvoid *)pointer;
- tex_unit->color_object_type = type;
-}
-
-void vglTexCoordPointerMapped(const GLvoid *pointer) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- tex_unit->texture_object = (GLvoid *)pointer;
-}
-
-void vglIndexPointerMapped(const GLvoid *pointer) {
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- tex_unit->index_object = (GLvoid *)pointer;
-}
-
-void vglDrawObjects(GLenum mode, GLsizei count, GLboolean implicit_wvp) {
- SceGxmPrimitiveType gxm_p;
- texture_unit *tex_unit = &texture_units[client_texture_unit];
- int texture2d_idx = tex_unit->tex_id;
-#ifndef SKIP_ERROR_HANDLING
- if (phase == MODEL_CREATION) {
- SET_GL_ERROR(GL_INVALID_OPERATION)
- } else if (count < 0) {
- SET_GL_ERROR(GL_INVALID_VALUE)
- }
-#endif
- GLboolean skip_draw = GL_FALSE;
- switch (mode) {
- case GL_POINTS:
- gxm_p = SCE_GXM_PRIMITIVE_POINTS;
- break;
- case GL_LINES:
- gxm_p = SCE_GXM_PRIMITIVE_LINES;
- break;
- case GL_TRIANGLES:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLES;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLE_STRIP:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLE_STRIP;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- case GL_TRIANGLE_FAN:
- gxm_p = SCE_GXM_PRIMITIVE_TRIANGLE_FAN;
- if (no_polygons_mode)
- skip_draw = GL_TRUE;
- break;
- default:
- SET_GL_ERROR(GL_INVALID_ENUM)
- break;
- }
- if (!skip_draw) {
- if (cur_program != 0) {
- _vglDrawObjects_CustomShadersIMPL(mode, count, implicit_wvp);
- sceGxmSetFragmentTexture(gxm_context, 0, &vgl_textures[texture2d_idx].gxm_tex);
-
- // TEXUNIT1 support for custom shaders
- texture_unit *tex_unit2 = &texture_units[client_texture_unit + 1];
- int texture2d_idx2 = tex_unit2->tex_id;
- if (vgl_textures[texture2d_idx2].valid)
- sceGxmSetFragmentTexture(gxm_context, 1, &vgl_textures[texture2d_idx2].gxm_tex);
-
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, tex_unit->index_object, count);
- } else {
- if (tex_unit->vertex_array_state) {
- if (mvp_modified) {
- matrix4x4_multiply(mvp_matrix, projection_matrix, modelview_matrix);
- mvp_modified = GL_FALSE;
- }
- if (tex_unit->texture_array_state) {
- if (!(vgl_textures[texture2d_idx].valid))
- return;
- if (tex_unit->color_array_state) {
- if (tex_unit->color_object_type == GL_FLOAT)
- sceGxmSetVertexProgram(gxm_context, texture2d_rgba_vertex_program_patched);
- else
- sceGxmSetVertexProgram(gxm_context, texture2d_rgba_u8n_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_rgba_fragment_program_patched);
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_alpha_op, 0, 1, &alpha_operation);
- float env_mode = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_tex_env, 0, 1, &env_mode);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_rgba_fog_density, 0, 1, (const float *)&fog_density);
- } else {
- sceGxmSetVertexProgram(gxm_context, texture2d_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, texture2d_fragment_program_patched);
- void *alpha_buffer;
- sceGxmReserveFragmentDefaultUniformBuffer(gxm_context, &alpha_buffer);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_cut, 0, 1, &alpha_ref);
- float alpha_operation = (float)alpha_op;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_alpha_op, 0, 1, &alpha_operation);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tint_color, 0, 4, ¤t_color.r);
- float env_mode = (float)tex_unit->env_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env, 0, 1, &env_mode);
- float fogmode = (float)internal_fog_mode;
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_mode, 0, 1, &fogmode);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_color, 0, 4, &fog_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tint_color, 0, 4, ¤t_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_tex_env_color, 0, 4, &texenv_color.r);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_near, 0, 1, (const float *)&fog_near);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_far, 0, 1, (const float *)&fog_far);
- sceGxmSetUniformDataF(alpha_buffer, texture2d_fog_density, 0, 1, (const float *)&fog_density);
- }
- } else if (tex_unit->color_array_state && (tex_unit->color_array.num == 3)) {
- if (tex_unit->color_object_type == GL_FLOAT)
- sceGxmSetVertexProgram(gxm_context, rgb_vertex_program_patched);
- else
- sceGxmSetVertexProgram(gxm_context, rgb_u8n_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- } else {
- if (tex_unit->color_object_type == GL_FLOAT)
- sceGxmSetVertexProgram(gxm_context, rgba_vertex_program_patched);
- else
- sceGxmSetVertexProgram(gxm_context, rgba_u8n_vertex_program_patched);
- sceGxmSetFragmentProgram(gxm_context, rgba_fragment_program_patched);
- }
- void *vertex_wvp_buffer;
- sceGxmReserveVertexDefaultUniformBuffer(gxm_context, &vertex_wvp_buffer);
- if (tex_unit->texture_array_state) {
- if (tex_unit->color_array_state) {
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_wvp, 0, 16, (const float *)mvp_matrix);
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_rgba_mv, 0, 16, (const float *)modelview_matrix);
- } else {
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_wvp, 0, 16, (const float *)mvp_matrix);
- float clipplane0 = (float)clip_plane0;
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0, 0, 1, &clipplane0);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_clip_plane0_eq, 0, 4, &clip_plane0_eq.x);
- sceGxmSetUniformDataF(vertex_wvp_buffer, texture2d_mv, 0, 16, (const float *)modelview_matrix);
- }
- sceGxmSetFragmentTexture(gxm_context, 0, &vgl_textures[texture2d_idx].gxm_tex);
- sceGxmSetVertexStream(gxm_context, 0, tex_unit->vertex_object);
- sceGxmSetVertexStream(gxm_context, 1, tex_unit->texture_object);
- if (tex_unit->color_array_state)
- sceGxmSetVertexStream(gxm_context, 2, tex_unit->color_object);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, tex_unit->index_object, count);
- } else if (tex_unit->color_array_state) {
- if (tex_unit->color_array.num == 3)
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgb_wvp, 0, 16, (const float *)mvp_matrix);
- else
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
- sceGxmSetVertexStream(gxm_context, 0, tex_unit->vertex_object);
- sceGxmSetVertexStream(gxm_context, 1, tex_unit->color_object);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, tex_unit->index_object, count);
- } else {
- sceGxmSetUniformDataF(vertex_wvp_buffer, rgba_wvp, 0, 16, (const float *)mvp_matrix);
- vector4f *colors = (vector4f *)gpu_pool_memalign(count * sizeof(vector4f), sizeof(vector4f));
- int n;
- for (n = 0; n < count; n++) {
- memcpy_neon(&colors[n], ¤t_color.r, sizeof(vector4f));
- }
- sceGxmSetVertexStream(gxm_context, 0, tex_unit->vertex_object);
- sceGxmSetVertexStream(gxm_context, 1, colors);
- sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, tex_unit->index_object, count);
- }
- }
- }
- }
-}
-
-size_t vglMemFree(vglMemType type) {
- if (type >= VGL_MEM_TYPE_COUNT)
- return 0;
- return vgl_mempool_get_free_space(type);
-}
-
-void *vglAlloc(uint32_t size, vglMemType type) {
- if (type >= VGL_MEM_TYPE_COUNT)
- return NULL;
- return vgl_mempool_alloc(size, type);
-}
-
-void vglFree(void *addr) {
- vgl_mem_free(addr, VGL_MEM_RAM); // Type is discarded so we just pass a random one
-}
-
-void vglUseExtraMem(GLboolean use) {
- use_extra_mem = use;
-}
-
-GLboolean vglHasRuntimeShaderCompiler(void) {
- return is_shark_online;
-}
\ No newline at end of file
diff --git a/deps/vitaGL/source/vitaGL.h b/deps/vitaGL/source/vitaGL.h
deleted file mode 100644
index b739267308..0000000000
--- a/deps/vitaGL/source/vitaGL.h
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-#ifndef _VITAGL_H_
-#define _VITAGL_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include
-#ifdef HAVE_SHARK
-#include
-#else
-#define shark_opt int32_t
-#endif
-
-// clang-format off
-#define GLboolean uint8_t
-#define GLbyte int8_t
-#define GLubyte uint8_t
-#define GLchar char
-#define GLshort int16_t
-#define GLushort uint16_t
-#define GLint int32_t
-#define GLuint uint32_t
-#define GLfixed int32_t
-#define GLint64 int64_t
-#define GLuint64 uint64_t
-#define GLsizei int32_t
-#define GLenum uint32_t
-#define GLintptr int32_t
-#define GLsizeiptr uint32_t
-#define GLsync int32_t
-#define GLfloat float
-#define GLclampf float
-#define GLdouble double
-#define GLclampd double
-#define GLvoid void
-
-#define GL_FALSE 0
-#define GL_TRUE 1
-
-#define GL_NO_ERROR 0
-
-#define GL_ZERO 0
-#define GL_ONE 1
-
-#define GL_NONE 0
-
-#define GL_POINTS 0x0000
-#define GL_LINES 0x0001
-#define GL_LINE_LOOP 0x0002
-#define GL_LINE_STRIP 0x0003
-#define GL_TRIANGLES 0x0004
-#define GL_TRIANGLE_STRIP 0x0005
-#define GL_TRIANGLE_FAN 0x0006
-#define GL_QUADS 0x0007
-#define GL_ADD 0x0104
-#define GL_NEVER 0x0200
-#define GL_NEVER 0x0200
-#define GL_LESS 0x0201
-#define GL_EQUAL 0x0202
-#define GL_LEQUAL 0x0203
-#define GL_GREATER 0x0204
-#define GL_NOTEQUAL 0x0205
-#define GL_GEQUAL 0x0206
-#define GL_ALWAYS 0x0207
-#define GL_SRC_COLOR 0x0300
-#define GL_ONE_MINUS_SRC_COLOR 0x0301
-#define GL_SRC_ALPHA 0x0302
-#define GL_ONE_MINUS_SRC_ALPHA 0x0303
-#define GL_DST_ALPHA 0x0304
-#define GL_ONE_MINUS_DST_ALPHA 0x0305
-#define GL_DST_COLOR 0x0306
-#define GL_ONE_MINUS_DST_COLOR 0x0307
-#define GL_SRC_ALPHA_SATURATE 0x0308
-#define GL_FRONT 0x0404
-#define GL_BACK 0x0405
-#define GL_FRONT_AND_BACK 0x0408
-#define GL_INVALID_ENUM 0x0500
-#define GL_INVALID_VALUE 0x0501
-#define GL_INVALID_OPERATION 0x0502
-#define GL_STACK_OVERFLOW 0x0503
-#define GL_STACK_UNDERFLOW 0x0504
-#define GL_OUT_OF_MEMORY 0x0505
-#define GL_EXP 0x0800
-#define GL_EXP2 0x0801
-#define GL_CW 0x0900
-#define GL_CCW 0x0901
-#define GL_POLYGON_MODE 0x0B40
-#define GL_CULL_FACE 0x0B44
-#define GL_FOG 0x0B60
-#define GL_FOG_DENSITY 0x0B62
-#define GL_FOG_START 0x0B63
-#define GL_FOG_END 0x0B64
-#define GL_FOG_MODE 0x0B65
-#define GL_FOG_COLOR 0x0B66
-#define GL_DEPTH_TEST 0x0B71
-#define GL_STENCIL_TEST 0x0B90
-#define GL_VIEWPORT 0x0BA2
-#define GL_MODELVIEW_MATRIX 0x0BA6
-#define GL_PROJECTION_MATRIX 0x0BA7
-#define GL_ALPHA_TEST 0x0BC0
-#define GL_BLEND 0x0BE2
-#define GL_SCISSOR_BOX 0x0C10
-#define GL_SCISSOR_TEST 0x0C11
-#define GL_MAX_TEXTURE_SIZE 0x0D33
-#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36
-#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38
-#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39
-#define GL_DEPTH_BITS 0x0D56
-#define GL_STENCIL_BITS 0x0D57
-#define GL_TEXTURE_2D 0x0DE1
-#define GL_DONT_CARE 0x1100
-#define GL_FASTEST 0x1101
-#define GL_NICEST 0x1102
-#define GL_BYTE 0x1400
-#define GL_UNSIGNED_BYTE 0x1401
-#define GL_SHORT 0x1402
-#define GL_UNSIGNED_SHORT 0x1403
-#define GL_FLOAT 0x1406
-#define GL_FIXED 0x140C
-#define GL_INVERT 0x150A
-#define GL_MODELVIEW 0x1700
-#define GL_PROJECTION 0x1701
-#define GL_COLOR_INDEX 0x1900
-#define GL_RED 0x1903
-#define GL_GREEN 0x1904
-#define GL_BLUE 0x1905
-#define GL_ALPHA 0x1906
-#define GL_RGB 0x1907
-#define GL_RGBA 0x1908
-#define GL_LUMINANCE 0x1909
-#define GL_LUMINANCE_ALPHA 0x190A
-#define GL_POINT 0x1B00
-#define GL_LINE 0x1B01
-#define GL_FILL 0x1B02
-#define GL_KEEP 0x1E00
-#define GL_REPLACE 0x1E01
-#define GL_INCR 0x1E02
-#define GL_DECR 0x1E03
-#define GL_VENDOR 0x1F00
-#define GL_RENDERER 0x1F01
-#define GL_VERSION 0x1F02
-#define GL_EXTENSIONS 0x1F03
-#define GL_MODULATE 0x2100
-#define GL_DECAL 0x2101
-#define GL_TEXTURE_ENV_MODE 0x2200
-#define GL_TEXTURE_ENV_COLOR 0x2201
-#define GL_TEXTURE_ENV 0x2300
-#define GL_NEAREST 0x2600
-#define GL_LINEAR 0x2601
-#define GL_NEAREST_MIPMAP_NEAREST 0x2700
-#define GL_LINEAR_MIPMAP_NEAREST 0x2701
-#define GL_NEAREST_MIPMAP_LINEAR 0x2702
-#define GL_LINEAR_MIPMAP_LINEAR 0x2703
-#define GL_TEXTURE_MAG_FILTER 0x2800
-#define GL_TEXTURE_MIN_FILTER 0x2801
-#define GL_TEXTURE_WRAP_S 0x2802
-#define GL_TEXTURE_WRAP_T 0x2803
-#define GL_REPEAT 0x2901
-#define GL_POLYGON_OFFSET_UNITS 0x2A00
-#define GL_POLYGON_OFFSET_POINT 0x2A01
-#define GL_POLYGON_OFFSET_LINE 0x2A02
-#define GL_CLIP_PLANE0 0x3000
-#define GL_FUNC_ADD 0x8006
-#define GL_MIN 0x8007
-#define GL_MAX 0x8008
-#define GL_FUNC_SUBTRACT 0x800A
-#define GL_FUNC_REVERSE_SUBTRACT 0x800B
-#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
-#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
-#define GL_POLYGON_OFFSET_FILL 0x8037
-#define GL_POLYGON_OFFSET_FACTOR 0x8038
-#define GL_INTENSITY 0x8049
-#define GL_TEXTURE_BINDING_2D 0x8069
-#define GL_VERTEX_ARRAY 0x8074
-#define GL_COLOR_ARRAY 0x8076
-#define GL_TEXTURE_COORD_ARRAY 0x8078
-#define GL_BLEND_DST_RGB 0x80C8
-#define GL_BLEND_SRC_RGB 0x80C9
-#define GL_BLEND_DST_ALPHA 0x80CA
-#define GL_BLEND_SRC_ALPHA 0x80CB
-#define GL_COLOR_TABLE 0x80D0
-#define GL_BGR 0x80E0
-#define GL_BGRA 0x80E1
-#define GL_COLOR_INDEX8_EXT 0x80E5
-#define GL_CLAMP_TO_EDGE 0x812F
-#define GL_RG 0x8227
-#define GL_UNSIGNED_SHORT_5_6_5 0x8363
-#define GL_MIRRORED_REPEAT 0x8370
-#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
-#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
-#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
-#define GL_TEXTURE0 0x84C0
-#define GL_TEXTURE1 0x84C1
-#define GL_TEXTURE2 0x84C2
-#define GL_TEXTURE3 0x84C3
-#define GL_TEXTURE4 0x84C4
-#define GL_TEXTURE5 0x84C5
-#define GL_TEXTURE6 0x84C6
-#define GL_TEXTURE7 0x84C7
-#define GL_TEXTURE8 0x84C8
-#define GL_TEXTURE9 0x84C9
-#define GL_TEXTURE10 0x84CA
-#define GL_TEXTURE11 0x84CB
-#define GL_TEXTURE12 0x84CC
-#define GL_TEXTURE13 0x84CD
-#define GL_TEXTURE14 0x84CE
-#define GL_TEXTURE15 0x84CF
-#define GL_TEXTURE16 0x84D0
-#define GL_TEXTURE17 0x84D1
-#define GL_TEXTURE18 0x84D2
-#define GL_TEXTURE19 0x84D3
-#define GL_TEXTURE20 0x84D4
-#define GL_TEXTURE21 0x84D5
-#define GL_TEXTURE22 0x84D6
-#define GL_TEXTURE23 0x84D7
-#define GL_TEXTURE24 0x84D8
-#define GL_TEXTURE25 0x84D9
-#define GL_TEXTURE26 0x84DA
-#define GL_TEXTURE27 0x84DB
-#define GL_TEXTURE28 0x84DC
-#define GL_TEXTURE29 0x84DD
-#define GL_TEXTURE30 0x84DE
-#define GL_TEXTURE31 0x84DF
-#define GL_ACTIVE_TEXTURE 0x84E0
-#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
-#define GL_TEXTURE_LOD_BIAS 0x8501
-#define GL_INCR_WRAP 0x8507
-#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
-#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
-#define GL_MIRROR_CLAMP_EXT 0x8742
-#define GL_DECR_WRAP 0x8508
-#define GL_ARRAY_BUFFER 0x8892
-#define GL_ELEMENT_ARRAY_BUFFER 0x8893
-#define GL_STREAM_DRAW 0x88E0
-#define GL_STREAM_READ 0x88E1
-#define GL_STREAM_COPY 0x88E2
-#define GL_STATIC_DRAW 0x88E4
-#define GL_STATIC_READ 0x88E5
-#define GL_STATIC_COPY 0x88E6
-#define GL_DYNAMIC_DRAW 0x88E8
-#define GL_DYNAMIC_READ 0x88E9
-#define GL_DYNAMIC_COPY 0x88EA
-#define GL_FRAGMENT_SHADER 0x8B30
-#define GL_VERTEX_SHADER 0x8B31
-#define GL_SHADER_TYPE 0x8B4F
-#define GL_COMPILE_STATUS 0x8B81
-#define GL_INFO_LOG_LENGTH 0x8B84
-#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
-#define GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01
-#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
-#define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03
-#define GL_READ_FRAMEBUFFER 0x8CA8
-#define GL_DRAW_FRAMEBUFFER 0x8CA9
-#define GL_COLOR_ATTACHMENT0 0x8CE0
-#define GL_FRAMEBUFFER 0x8D40
-#define GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG 0x9137
-#define GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG 0x9138
-
-#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 2
-#define GL_MAX_TEXTURE_LOD_BIAS 31
-
-// Aliases
-#define GL_CLAMP GL_CLAMP_TO_EDGE
-
-typedef enum GLbitfield{
- GL_DEPTH_BUFFER_BIT = 0x00000100,
- GL_STENCIL_BUFFER_BIT = 0x00000400,
- GL_COLOR_BUFFER_BIT = 0x00004000
-} GLbitfield;
-// clang-format on
-
-// gl*
-void glActiveTexture(GLenum texture);
-void glAlphaFunc(GLenum func, GLfloat ref);
-void glArrayElement(GLint i);
-void glAttachShader(GLuint prog, GLuint shad);
-void glBegin(GLenum mode);
-void glBindBuffer(GLenum target, GLuint buffer);
-void glBindFramebuffer(GLenum target, GLuint framebuffer);
-void glBindTexture(GLenum target, GLuint texture);
-void glBlendEquation(GLenum mode);
-void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
-void glBlendFunc(GLenum sfactor, GLenum dfactor);
-void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-void glBufferData(GLenum target, GLsizei size, const GLvoid *data, GLenum usage);
-void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
-void glClear(GLbitfield mask);
-void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-void glClearDepth(GLdouble depth);
-void glClearStencil(GLint s);
-void glClientActiveTexture(GLenum texture);
-void glClipPlane(GLenum plane, const GLdouble *equation);
-void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
-void glColor3fv(const GLfloat *v);
-void glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
-void glColor3ubv(const GLubyte *v);
-void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-void glColor4fv(const GLfloat *v);
-void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-void glColor4ubv(const GLubyte *v);
-void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *data);
-void glCompileShader(GLuint shader);
-void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); // Mipmap levels are ignored currently
-GLuint glCreateProgram(void);
-GLuint glCreateShader(GLenum shaderType);
-void glCullFace(GLenum mode);
-void glDeleteBuffers(GLsizei n, const GLuint *gl_buffers);
-void glDeleteFramebuffers(GLsizei n, GLuint *framebuffers);
-void glDeleteProgram(GLuint prog);
-void glDeleteShader(GLuint shad);
-void glDeleteTextures(GLsizei n, const GLuint *textures);
-void glDepthFunc(GLenum func);
-void glDepthMask(GLboolean flag);
-void glDepthRange(GLdouble nearVal, GLdouble farVal);
-void glDepthRangef(GLfloat nearVal, GLfloat farVal);
-void glDisable(GLenum cap);
-void glDisableClientState(GLenum array);
-void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-void glEnable(GLenum cap);
-void glEnableClientState(GLenum array);
-void glEnd(void);
-void glFinish(void);
-void glFogf(GLenum pname, GLfloat param);
-void glFogfv(GLenum pname, const GLfloat *params);
-void glFogi(GLenum pname, const GLint param);
-void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level);
-void glFrontFace(GLenum mode);
-void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearVal, GLdouble farVal);
-void glGenBuffers(GLsizei n, GLuint *buffers);
-void glGenerateMipmap(GLenum target);
-void glGenFramebuffers(GLsizei n, GLuint *ids);
-void glGenTextures(GLsizei n, GLuint *textures);
-void glGetBooleanv(GLenum pname, GLboolean *params);
-void glGetFloatv(GLenum pname, GLfloat *data);
-GLenum glGetError(void);
-void glGetIntegerv(GLenum pname, GLint *data);
-void glGetShaderInfoLog(GLuint handle, GLsizei maxLength, GLsizei *length, GLchar *infoLog);
-void glGetShaderiv(GLuint handle, GLenum pname, GLint *params);
-const GLubyte *glGetString(GLenum name);
-GLint glGetUniformLocation(GLuint prog, const GLchar *name);
-void glHint(GLenum target, GLenum mode);
-GLboolean glIsEnabled(GLenum cap);
-void glLineWidth(GLfloat width);
-void glLinkProgram(GLuint progr);
-void glLoadIdentity(void);
-void glLoadMatrixf(const GLfloat *m);
-void glMatrixMode(GLenum mode);
-void glMultMatrixf(const GLfloat *m);
-void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearVal, GLdouble farVal);
-void glPointSize(GLfloat size);
-void glPolygonMode(GLenum face, GLenum mode);
-void glPolygonOffset(GLfloat factor, GLfloat units);
-void glPopMatrix(void);
-void glPushMatrix(void);
-void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *data);
-void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-void glScalef(GLfloat x, GLfloat y, GLfloat z);
-void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-void glShaderBinary(GLsizei count, const GLuint *handles, GLenum binaryFormat, const void *binary, GLsizei length); // NOTE: Uses GXP shaders
-void glShaderSource(GLuint handle, GLsizei count, const GLchar *const *string, const GLint *length); // NOTE: Uses CG shader sources
-void glStencilFunc(GLenum func, GLint ref, GLuint mask);
-void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
-void glStencilMask(GLuint mask);
-void glStencilMaskSeparate(GLenum face, GLuint mask);
-void glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass);
-void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-void glTexCoord2f(GLfloat s, GLfloat t);
-void glTexCoord2fv(GLfloat *f);
-void glTexCoord2i(GLint s, GLint t);
-void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-void glTexEnvf(GLenum target, GLenum pname, GLfloat param);
-void glTexEnvfv(GLenum target, GLenum pname, GLfloat *param);
-void glTexEnvi(GLenum target, GLenum pname, GLint param);
-void glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *data);
-void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
-void glTexParameteri(GLenum target, GLenum pname, GLint param);
-void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-void glUniform1f(GLint location, GLfloat v0);
-void glUniform1i(GLint location, GLint v0);
-void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-void glUniform2i(GLint location, GLint v0, GLint v1);
-void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
-void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
-void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-void glUniform4fv(GLint location, GLsizei count, const GLfloat *value);
-void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-void glUseProgram(GLuint program);
-void glVertex2f(GLfloat x, GLfloat y);
-void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
-void glVertex3fv(const GLfloat *v);
-void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-
-// glu*
-void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
-
-// VGL_EXT_gpu_objects_array extension
-void vglColorPointer(GLint size, GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer);
-void vglColorPointerMapped(GLenum type, const GLvoid *pointer);
-void vglDrawObjects(GLenum mode, GLsizei count, GLboolean implicit_wvp);
-void vglIndexPointer(GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer);
-void vglIndexPointerMapped(const GLvoid *pointer);
-void vglTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer);
-void vglTexCoordPointerMapped(const GLvoid *pointer);
-void vglVertexPointer(GLint size, GLenum type, GLsizei stride, GLuint count, const GLvoid *pointer);
-void vglVertexPointerMapped(const GLvoid *pointer);
-
-// VGL_EXT_gxp_shaders extension implementation
-void vglBindAttribLocation(GLuint prog, GLuint index, const GLchar *name, const GLuint num, const GLenum type);
-GLint vglBindPackedAttribLocation(GLuint prog, const GLchar *name, const GLuint num, const GLenum type, GLuint offset, GLint stride);
-void vglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint count, const GLvoid *pointer);
-void vglVertexAttribPointerMapped(GLuint index, const GLvoid *pointer);
-
-typedef enum {
- VGL_MEM_ALL = 0, // any memory type (used to monitor total heap usage)
- VGL_MEM_VRAM, // CDRAM
- VGL_MEM_RAM, // USER_RW RAM
- VGL_MEM_SLOW, // PHYCONT_USER_RW RAM
- VGL_MEM_EXTERNAL, // newlib mem
- VGL_MEM_TYPE_COUNT
-} vglMemType;
-
-// vgl*
-void *vglAlloc(uint32_t size, vglMemType type);
-void vglEnableRuntimeShaderCompiler(GLboolean usage);
-void vglEnd(void);
-void vglFree(void *addr);
-SceGxmTexture *vglGetGxmTexture(GLenum target);
-void *vglGetTexDataPointer(GLenum target);
-GLboolean vglHasRuntimeShaderCompiler(void);
-void vglInit(uint32_t gpu_pool_size);
-void vglInitExtended(uint32_t gpu_pool_size, int width, int height, int ram_threshold, SceGxmMultisampleMode msaa);
-void vglInitWithCustomSizes(uint32_t gpu_pool_size, int width, int height, int ram_pool_size, int cdram_pool_size, int phycont_pool_size, SceGxmMultisampleMode msaa);
-size_t vglMemFree(vglMemType type);
-void vglSetParamBufferSize(uint32_t size);
-void vglSetupRuntimeShaderCompiler(shark_opt opt_level, int32_t use_fastmath, int32_t use_fastprecision, int32_t use_fastint);
-void vglStartRendering();
-void vglStopRendering();
-void vglStopRenderingInit();
-void vglStopRenderingTerm();
-void vglTexImageDepthBuffer(GLenum target);
-void vglUpdateCommonDialog();
-void vglUseVram(GLboolean usage);
-void vglUseVramForUSSE(GLboolean usage);
-void vglUseExtraMem(GLboolean usage);
-void vglWaitVblankStart(GLboolean enable);
-
-// NEON optimized memcpy
-void *memcpy_neon(void *destination, const void *source, size_t num);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/deps/vitaShaRK/.gitattributes b/deps/vitaShaRK/.gitattributes
deleted file mode 100644
index dfe0770424..0000000000
--- a/deps/vitaShaRK/.gitattributes
+++ /dev/null
@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto
diff --git a/deps/vitaShaRK/.github/FUNDING.yml b/deps/vitaShaRK/.github/FUNDING.yml
deleted file mode 100644
index dbd470e946..0000000000
--- a/deps/vitaShaRK/.github/FUNDING.yml
+++ /dev/null
@@ -1 +0,0 @@
-patreon: Rinnegatamante
diff --git a/deps/vitaShaRK/.gitignore b/deps/vitaShaRK/.gitignore
deleted file mode 100644
index 4a072bdd8b..0000000000
--- a/deps/vitaShaRK/.gitignore
+++ /dev/null
@@ -1,59 +0,0 @@
-*.vpk
-*.elf
-*.velf
-*.bin
-*.sfo
-*.S
-*.wo
-
-# Windows image file caches
-Thumbs.db
-ehthumbs.db
-
-# Folder config file
-Desktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
-
-# =========================
-# Operating System Files
-# =========================
-
-# OSX
-# =========================
-
-.DS_Store
-.AppleDouble
-.LSOverride
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-# Vita build stuffs
-*.a
-*.o
diff --git a/deps/vitaShaRK/LICENSE b/deps/vitaShaRK/LICENSE
deleted file mode 100644
index 8805d0dfad..0000000000
--- a/deps/vitaShaRK/LICENSE
+++ /dev/null
@@ -1,165 +0,0 @@
-GNU LESSER 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.
-
-
- This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
- 0. Additional Definitions.
-
- As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
- "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
- An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
- A "Combined Work" is a work produced by combining or linking an
-Application with the Library. The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
- The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
- The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
- 1. Exception to Section 3 of the GNU GPL.
-
- You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
- 2. Conveying Modified Versions.
-
- If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
- a) under this License, provided that you make a good faith effort to
- ensure that, in the event an Application does not supply the
- function or data, the facility still operates, and performs
- whatever part of its purpose remains meaningful, or
-
- b) under the GNU GPL, with none of the additional permissions of
- this License applicable to that copy.
-
- 3. Object Code Incorporating Material from Library Header Files.
-
- The object code form of an Application may incorporate material from
-a header file that is part of the Library. You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
- a) Give prominent notice with each copy of the object code that the
- Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the object code with a copy of the GNU GPL and this license
- document.
-
- 4. Combined Works.
-
- You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
- a) Give prominent notice with each copy of the Combined Work that
- the Library is used in it and that the Library and its use are
- covered by this License.
-
- b) Accompany the Combined Work with a copy of the GNU GPL and this license
- document.
-
- c) For a Combined Work that displays copyright notices during
- execution, include the copyright notice for the Library among
- these notices, as well as a reference directing the user to the
- copies of the GNU GPL and this license document.
-
- d) Do one of the following:
-
- 0) Convey the Minimal Corresponding Source under the terms of this
- License, and the Corresponding Application Code in a form
- suitable for, and under terms that permit, the user to
- recombine or relink the Application with a modified version of
- the Linked Version to produce a modified Combined Work, in the
- manner specified by section 6 of the GNU GPL for conveying
- Corresponding Source.
-
- 1) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (a) uses at run time
- a copy of the Library already present on the user's computer
- system, and (b) will operate properly with a modified version
- of the Library that is interface-compatible with the Linked
- Version.
-
- e) Provide Installation Information, but only if you would otherwise
- be required to provide such information under section 6 of the
- GNU GPL, and only to the extent that such information is
- necessary to install and execute a modified version of the
- Combined Work produced by recombining or relinking the
- Application with a modified version of the Linked Version. (If
- you use option 4d0, the Installation Information must accompany
- the Minimal Corresponding Source and Corresponding Application
- Code. If you use option 4d1, you must provide the Installation
- Information in the manner specified by section 6 of the GNU GPL
- for conveying Corresponding Source.)
-
- 5. Combined Libraries.
-
- You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
- a) Accompany the combined library with a copy of the same work based
- on the Library, uncombined with any other library facilities,
- conveyed under the terms of this License.
-
- b) Give prominent notice with the combined library that part of it
- is a work based on the Library, and explaining where to find the
- accompanying uncombined form of the same work.
-
- 6. Revised Versions of the GNU Lesser General Public License.
-
- The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
- If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
diff --git a/deps/vitaShaRK/Makefile b/deps/vitaShaRK/Makefile
deleted file mode 100644
index 58ce7401e2..0000000000
--- a/deps/vitaShaRK/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-TARGET := libvitashark
-SOURCES := source
-SHADERS := shaders
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-ASMFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.S))
-CGFILES := $(foreach dir,$(SHADERS), $(wildcard $(dir)/*.cg))
-HEADERS := $(CGFILES:.cg=.h)
-OBJS := $(CFILES:.c=.o) $(ASMFILES:.S=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-AR = $(PREFIX)-gcc-ar
-CFLAGS = -g -Wl,-q -O2 -ffast-math -mtune=cortex-a9 -mfpu=neon -ftree-vectorize
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).a
-
-$(TARGET).a: $(OBJS)
- $(AR) -rc $@ $^
-
-clean:
- @rm -rf $(TARGET).a $(TARGET).elf $(OBJS)
- @make -C samples/sample1 clean
- @make -C samples/sample2 clean
-
-install: $(TARGET).a
- @mkdir -p $(VITASDK)/$(PREFIX)/lib/
- cp $(TARGET).a $(VITASDK)/$(PREFIX)/lib/
- @mkdir -p $(VITASDK)/$(PREFIX)/include/
- cp source/vitashark.h $(VITASDK)/$(PREFIX)/include/
-
-samples: $(TARGET).a
- @make -C samples/sample1
- cp "samples/sample1/vitaShaRK-Sample001.vpk" .
- @make -C samples/sample2
- cp "samples/sample1/vitaShaRK-Sample002.vpk" .
diff --git a/deps/vitaShaRK/README.md b/deps/vitaShaRK/README.md
deleted file mode 100644
index 53d4cd9d4b..0000000000
--- a/deps/vitaShaRK/README.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# vitaShaRK
-**vita** **Sha**ders **R**untime **K**ompiler is a runtime shader compiler library for PSVITA/PSTV using the SceShaccCg module contained inside the PSM runtime.
-
-# Build Instructions
-In order to build vitaShaRK, you'll first need to build SceShaccCg stubs. This is a full list of commands you can use to install this library and the required stubs:
-```
-vita-libs-gen SceShaccCg.yml build
-cd build
-make install
-cd ..
-cp shacccg.h $VITASDK/arm-vita-eabi/psp2/shacccg.h
-make install
-```
-
-
-# Credits
-
-**frangarcj** for the original vita2d shader compiler source used as base to build up this library.
diff --git a/deps/vitaShaRK/SceShaccCg.yml b/deps/vitaShaRK/SceShaccCg.yml
deleted file mode 100644
index d20eae44a5..0000000000
--- a/deps/vitaShaRK/SceShaccCg.yml
+++ /dev/null
@@ -1,43 +0,0 @@
-version: 2
-firmware: 3.60
-modules:
- SceShaccCg:
- nid: 0xB3B90A35
- libraries:
- SceShaccCg:
- kernel: false
- nid: 0xA05BBEBB
- functions:
- SceShaccCg_0205DE96: 0x0205DE96
- SceShaccCg_07DDFC78: 0x07DDFC78
- SceShaccCg_0E1285A6: 0x0E1285A6
- SceShaccCg_152971B1: 0x152971B1
- SceShaccCg_17223BEB: 0x17223BEB
- SceShaccCg_2654E73A: 0x2654E73A
- SceShaccCg_268FAEE9: 0x268FAEE9
- sceShaccCgInitializeCompileOptions: 0x3B58AFA0
- SceShaccCg_4595A388: 0x4595A388
- SceShaccCg_46FA0303: 0x46FA0303
- SceShaccCg_56BFA825: 0x56BFA825
- SceShaccCg_648739F3: 0x648739F3
- sceShaccCgCompileProgram: 0x66814F35
- SceShaccCg_6BB58825: 0x6BB58825
- sceShaccCgSetDefaultAllocator: 0x6F01D573
- SceShaccCg_6FB40CA9: 0x6FB40CA9
- SceShaccCg_7B2CF324: 0x7B2CF324
- SceShaccCg_7BC25091: 0x7BC25091
- SceShaccCg_7F430CCD: 0x7F430CCD
- SceShaccCg_95F57A23: 0x95F57A23
- SceShaccCg_A067C481: 0xA067C481
- SceShaccCg_A13A8A1E: 0xA13A8A1E
- SceShaccCg_A56B1A5B: 0xA56B1A5B
- SceShaccCg_A7930FF6: 0xA7930FF6
- sceShaccCgInitializeCallbackList: 0xA8C2C1C8
- sceShaccCgDestroyCompileOutput: 0xAA82EF0C
- SceShaccCg_B4AC9943: 0xB4AC9943
- SceShaccCg_BB703EE1: 0xBB703EE1
- SceShaccCg_D4378DB1: 0xD4378DB1
- SceShaccCg_DAD4AAE4: 0xDAD4AAE4
- SceShaccCg_DF3DDCFD: 0xDF3DDCFD
- SceShaccCg_EF8D59D6: 0xEF8D59D6
- SceShaccCg_F4BAB902: 0xF4BAB902
diff --git a/deps/vitaShaRK/SceShaccCg/Makefile b/deps/vitaShaRK/SceShaccCg/Makefile
deleted file mode 100644
index 495b32a861..0000000000
--- a/deps/vitaShaRK/SceShaccCg/Makefile
+++ /dev/null
@@ -1,47 +0,0 @@
-ifdef VITASDK
-PREFIX = $(VITASDK)/bin/
-endif
-
-ARCH ?= $(PREFIX)arm-vita-eabi
-AS = $(ARCH)-as
-AR = $(ARCH)-ar
-RANLIB = $(ARCH)-ranlib
-
-TARGETS = libSceShaccCg_stub.a
-TARGETS_WEAK = libSceShaccCg_stub_weak.a
-
-SceShaccCg_OBJS = SceShaccCg_SceShaccCg_SceShaccCg_0205DE96.o SceShaccCg_SceShaccCg_SceShaccCg_07DDFC78.o SceShaccCg_SceShaccCg_SceShaccCg_0E1285A6.o SceShaccCg_SceShaccCg_SceShaccCg_152971B1.o SceShaccCg_SceShaccCg_SceShaccCg_17223BEB.o SceShaccCg_SceShaccCg_SceShaccCg_2654E73A.o SceShaccCg_SceShaccCg_SceShaccCg_268FAEE9.o SceShaccCg_SceShaccCg_sceShaccCgInitializeCompileOptions.o SceShaccCg_SceShaccCg_SceShaccCg_4595A388.o SceShaccCg_SceShaccCg_SceShaccCg_46FA0303.o SceShaccCg_SceShaccCg_SceShaccCg_56BFA825.o SceShaccCg_SceShaccCg_SceShaccCg_648739F3.o SceShaccCg_SceShaccCg_sceShaccCgCompileProgram.o SceShaccCg_SceShaccCg_SceShaccCg_6BB58825.o SceShaccCg_SceShaccCg_sceShaccCgSetDefaultAllocator.o SceShaccCg_SceShaccCg_SceShaccCg_6FB40CA9.o SceShaccCg_SceShaccCg_SceShaccCg_7B2CF324.o SceShaccCg_SceShaccCg_SceShaccCg_7BC25091.o SceShaccCg_SceShaccCg_SceShaccCg_7F430CCD.o SceShaccCg_SceShaccCg_SceShaccCg_95F57A23.o SceShaccCg_SceShaccCg_SceShaccCg_A067C481.o SceShaccCg_SceShaccCg_SceShaccCg_A13A8A1E.o SceShaccCg_SceShaccCg_SceShaccCg_A56B1A5B.o SceShaccCg_SceShaccCg_SceShaccCg_A7930FF6.o SceShaccCg_SceShaccCg_sceShaccCgInitializeCallbackList.o SceShaccCg_SceShaccCg_sceShaccCgDestroyCompileOutput.o SceShaccCg_SceShaccCg_SceShaccCg_B4AC9943.o SceShaccCg_SceShaccCg_SceShaccCg_BB703EE1.o SceShaccCg_SceShaccCg_SceShaccCg_D4378DB1.o SceShaccCg_SceShaccCg_SceShaccCg_DAD4AAE4.o SceShaccCg_SceShaccCg_SceShaccCg_DF3DDCFD.o SceShaccCg_SceShaccCg_SceShaccCg_EF8D59D6.o SceShaccCg_SceShaccCg_SceShaccCg_F4BAB902.o
-SceShaccCg_weak_OBJS = SceShaccCg_SceShaccCg_SceShaccCg_0205DE96.wo SceShaccCg_SceShaccCg_SceShaccCg_07DDFC78.wo SceShaccCg_SceShaccCg_SceShaccCg_0E1285A6.wo SceShaccCg_SceShaccCg_SceShaccCg_152971B1.wo SceShaccCg_SceShaccCg_SceShaccCg_17223BEB.wo SceShaccCg_SceShaccCg_SceShaccCg_2654E73A.wo SceShaccCg_SceShaccCg_SceShaccCg_268FAEE9.wo SceShaccCg_SceShaccCg_sceShaccCgInitializeCompileOptions.wo SceShaccCg_SceShaccCg_SceShaccCg_4595A388.wo SceShaccCg_SceShaccCg_SceShaccCg_46FA0303.wo SceShaccCg_SceShaccCg_SceShaccCg_56BFA825.wo SceShaccCg_SceShaccCg_SceShaccCg_648739F3.wo SceShaccCg_SceShaccCg_sceShaccCgCompileProgram.wo SceShaccCg_SceShaccCg_SceShaccCg_6BB58825.wo SceShaccCg_SceShaccCg_sceShaccCgSetDefaultAllocator.wo SceShaccCg_SceShaccCg_SceShaccCg_6FB40CA9.wo SceShaccCg_SceShaccCg_SceShaccCg_7B2CF324.wo SceShaccCg_SceShaccCg_SceShaccCg_7BC25091.wo SceShaccCg_SceShaccCg_SceShaccCg_7F430CCD.wo SceShaccCg_SceShaccCg_SceShaccCg_95F57A23.wo SceShaccCg_SceShaccCg_SceShaccCg_A067C481.wo SceShaccCg_SceShaccCg_SceShaccCg_A13A8A1E.wo SceShaccCg_SceShaccCg_SceShaccCg_A56B1A5B.wo SceShaccCg_SceShaccCg_SceShaccCg_A7930FF6.wo SceShaccCg_SceShaccCg_sceShaccCgInitializeCallbackList.wo SceShaccCg_SceShaccCg_sceShaccCgDestroyCompileOutput.wo SceShaccCg_SceShaccCg_SceShaccCg_B4AC9943.wo SceShaccCg_SceShaccCg_SceShaccCg_BB703EE1.wo SceShaccCg_SceShaccCg_SceShaccCg_D4378DB1.wo SceShaccCg_SceShaccCg_SceShaccCg_DAD4AAE4.wo SceShaccCg_SceShaccCg_SceShaccCg_DF3DDCFD.wo SceShaccCg_SceShaccCg_SceShaccCg_EF8D59D6.wo SceShaccCg_SceShaccCg_SceShaccCg_F4BAB902.wo
-SceKernel_OBJS =
-ALL_OBJS=
-
-all: $(TARGETS) $(TARGETS_WEAK)
-
-define LIBRARY_template
- $(1): $$($(1:lib%_stub.a=%)_OBJS)
- ALL_OBJS += $$($(1:lib%_stub.a=%)_OBJS)
-endef
-define LIBRARY_WEAK_template
- $(1): $$($(1:lib%_stub_weak.a=%)_weak_OBJS)
- ALL_OBJS += $$($(1:lib%_stub_weak.a=%)_weak_OBJS)
-endef
-
-$(foreach library,$(TARGETS),$(eval $(call LIBRARY_template,$(library))))
-$(foreach library,$(TARGETS_WEAK),$(eval $(call LIBRARY_WEAK_template,$(library))))
-
-install: $(TARGETS) $(TARGETS_WEAK)
- cp $(TARGETS) $(VITASDK)/arm-vita-eabi/lib
- cp $(TARGETS_WEAK) $(VITASDK)/arm-vita-eabi/lib
-
-clean:
- rm -f $(TARGETS) $(TARGETS_WEAK) $(ALL_OBJS)
-
-$(TARGETS) $(TARGETS_WEAK):
- $(AR) cru $@ $?
- $(RANLIB) $@
-
-%.o: %.S
- $(AS) --defsym GEN_WEAK_EXPORTS=0 $< -o $@
-
-%.wo: %.S
- $(AS) --defsym GEN_WEAK_EXPORTS=1 $< -o $@
diff --git a/deps/vitaShaRK/include/shacccg.h b/deps/vitaShaRK/include/shacccg.h
deleted file mode 100644
index aa9f6f06eb..0000000000
--- a/deps/vitaShaRK/include/shacccg.h
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef _PSP2_SHACCCG_H
-#define _PSP2_SHACCCG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif // def __cplusplus
-
-typedef struct SceShaccCgCompileOptions SceShaccCgCompileOptions;
-typedef struct SceShaccCgSourceFile SceShaccCgSourceFile;
-typedef struct SceShaccCgSourceLocation SceShaccCgSourceLocation;
-typedef void const *SceShaccCgParameter;
-
-typedef SceShaccCgSourceFile* (*SceShaccCgCallbackOpenFile)(
- const char *fileName,
- const SceShaccCgSourceLocation *includedFrom,
- const SceShaccCgCompileOptions *compileOptions,
- const char **errorString);
-
-typedef void (*SceShaccCgCallbackReleaseFile)(
- const SceShaccCgSourceFile *file,
- const SceShaccCgCompileOptions *compileOptions);
-
-typedef const char* (*SceShaccCgCallbackLocateFile)(
- const char *fileName,
- const SceShaccCgSourceLocation *includedFrom,
- uint32_t searchPathCount,
- const char *const*searchPaths,
- const SceShaccCgCompileOptions *compileOptions,
- const char **errorString);
-
-typedef const char* (*SceShaccCgCallbackAbsolutePath)(
- const char *fileName,
- const SceShaccCgSourceLocation *includedFrom,
- const SceShaccCgCompileOptions *compileOptions);
-
-typedef void (*SceShaccCgCallbackReleaseFileName)(
- const char *fileName,
- const SceShaccCgCompileOptions *compileOptions);
-
-typedef int32_t (*SceShaccCgCallbackFileDate)(
- const SceShaccCgSourceFile *file,
- const SceShaccCgSourceLocation *includedFrom,
- const SceShaccCgCompileOptions *compileOptions,
- int64_t *timeLastStatusChange,
- int64_t *timeLastModified);
-
-typedef enum SceShaccCgDiagnosticLevel {
- SCE_SHACCCG_DIAGNOSTIC_LEVEL_INFO,
- SCE_SHACCCG_DIAGNOSTIC_LEVEL_WARNING,
- SCE_SHACCCG_DIAGNOSTIC_LEVEL_ERROR
-} SceShaccCgDiagnosticLevel;
-
-typedef enum SceShaccCgTargetProfile {
- SCE_SHACCCG_PROFILE_VP,
- SCE_SHACCCG_PROFILE_FP
-} SceShaccCgTargetProfile;
-
-typedef enum SceShaccCgCallbackDefaults {
- SCE_SHACCCG_SYSTEM_FILES,
- SCE_SHACCCG_TRIVIAL
-} SceShaccCgCallbackDefaults;
-
-typedef enum SceShaccCgLocale {
- SCE_SHACCCG_ENGLISH,
- SCE_SHACCCG_JAPANESE
-} SceShaccCgLocale;
-
-typedef struct SceShaccCgSourceFile {
- const char *fileName;
- const char *text;
- uint32_t size;
-} SceShaccCgSourceFile;
-
-typedef struct SceShaccCgSourceLocation {
- const SceShaccCgSourceFile *file;
- uint32_t lineNumber;
- uint32_t columnNumber;
-} SceShaccCgSourceLocation;
-
-typedef struct SceShaccCgCallbackList {
- SceShaccCgCallbackOpenFile openFile;
- SceShaccCgCallbackReleaseFile releaseFile;
- SceShaccCgCallbackLocateFile locateFile;
- SceShaccCgCallbackAbsolutePath absolutePath;
- SceShaccCgCallbackReleaseFileName releaseFileName;
- SceShaccCgCallbackFileDate fileDate;
-} SceShaccCgCallbackList;
-
-typedef struct SceShaccCgCompileOptions {
- const char *mainSourceFile;
- SceShaccCgTargetProfile targetProfile;
- const char *entryFunctionName;
- uint32_t searchPathCount;
- const char* const *searchPaths;
- uint32_t macroDefinitionCount;
- const char* const *macroDefinitions;
- uint32_t includeFileCount;
- const char* const *includeFiles;
- uint32_t suppressedWarningsCount;
- const uint32_t *suppressedWarnings;
- SceShaccCgLocale locale;
- int32_t useFx;
- int32_t noStdlib;
- int32_t optimizationLevel;
- int32_t useFastmath;
- int32_t useFastprecision;
- int32_t useFastint;
- int32_t warningsAsErrors;
- int32_t performanceWarnings;
- int32_t warningLevel;
- int32_t pedantic;
- int32_t pedanticError;
- int field_5C;
- int field_60;
- int field_64;
-} SceShaccCgCompileOptions;
-
-typedef struct SceShaccCgDiagnosticMessage {
- SceShaccCgDiagnosticLevel level;
- uint32_t code;
- const SceShaccCgSourceLocation *location;
- const char *message;
-} SceShaccCgDiagnosticMessage;
-
-typedef struct SceShaccCgCompileOutput {
- const uint8_t *programData;
- uint32_t programSize;
- int32_t diagnosticCount;
- const SceShaccCgDiagnosticMessage *diagnostics;
-} SceShaccCgCompileOutput;
-
-
-int SceShaccCg_0205DE96(int);
-int SceShaccCg_07DDFC78(int);
-int SceShaccCg_0E1285A6(int);
-int SceShaccCg_152971B1(int);
-int SceShaccCg_17223BEB(int);
-int SceShaccCg_2654E73A(int);
-int SceShaccCg_268FAEE9(int);
-
-int sceShaccCgInitializeCompileOptions(
- SceShaccCgCompileOptions *options);
-
-int SceShaccCg_4595A388(int);
-int SceShaccCg_46FA0303(int);
-int SceShaccCg_56BFA825(int);
-int SceShaccCg_648739F3(int);
-
-SceShaccCgCompileOutput const *sceShaccCgCompileProgram(
- const SceShaccCgCompileOptions *options,
- const SceShaccCgCallbackList *callbacks,
- int unk);
-
-int SceShaccCg_6BB58825(int);
-int sceShaccCgSetDefaultAllocator(void *(*malloc_cb)(unsigned int), void (*free_cb)(void *));
-int SceShaccCg_6FB40CA9(int);
-int SceShaccCg_7B2CF324(int);
-int SceShaccCg_7BC25091(int);
-int SceShaccCg_7F430CCD(int);
-int SceShaccCg_95F57A23(int);
-int SceShaccCg_A067C481(int);
-int SceShaccCg_A13A8A1E(int);
-int SceShaccCg_A56B1A5B(int);
-int SceShaccCg_A7930FF6(int);
-
-void sceShaccCgInitializeCallbackList(
- SceShaccCgCallbackList *callbacks,
- SceShaccCgCallbackDefaults defaults);
-
-void sceShaccCgDestroyCompileOutput(
- SceShaccCgCompileOutput const *output);
-
-int SceShaccCg_B4AC9943(int);
-int SceShaccCg_BB703EE1(int);
-int SceShaccCg_D4378DB1(int);
-int SceShaccCg_DAD4AAE4(int);
-int SceShaccCg_DF3DDCFD(int);
-int SceShaccCg_EF8D59D6(int);
-int SceShaccCg_F4BAB902(int);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* _PSP2_SHACCCG_H */
diff --git a/deps/vitaShaRK/samples/sample1/Makefile b/deps/vitaShaRK/samples/sample1/Makefile
deleted file mode 100644
index 0202cf37cc..0000000000
--- a/deps/vitaShaRK/samples/sample1/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-SAMPLE_NUM := 001
-TARGET := vitaShaRK-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitashark -lSceLibKernel_stub -lSceShaccCg_stub
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VSHARK$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaShaRK/samples/sample1/main.c b/deps/vitaShaRK/samples/sample1/main.c
deleted file mode 100644
index 1e312c51a7..0000000000
--- a/deps/vitaShaRK/samples/sample1/main.c
+++ /dev/null
@@ -1,59 +0,0 @@
-// Simple compiler with no logging
-
-#include
-#include
-#include
-
-const char fragment_shader[] =
- "float4 main(uniform float4 u_clear_color) : COLOR\n"
- "{\n"
- " return u_clear_color;\n"
- "}"
- ;
-
-const char vertex_shader[] =
- "void main(\n"
- "float3 aPosition,\n"
- "float3 aColor,\n"
- "uniform float4x4 wvp,\n"
- "float4 out vPosition: POSITION,\n"
- "float4 out vColor: COLOR)\n"
- "{\n"
- " vPosition = mul(float4(aPosition, 1.f), wvp);\n"
- " vColor = float4(aColor, 1.f);\n"
- "}"
- ;
-
-void saveGXP(SceGxmProgram *p, uint32_t size, const char *fname) {
- FILE *f = fopen(fname, "wb");
- fwrite(p, 1, size, f);
- fclose(f);
-}
-
-int main() {
- // Initializing vitaShaRK
- if (shark_init(NULL) < 0) // NOTE: libshacccg.suprx will need to be placed in ur0:data
- return -1;
-
- // Compiling fragment shader
- uint32_t size = sizeof(fragment_shader) - 1;
- SceGxmProgram *p = shark_compile_shader(fragment_shader, &size, SHARK_FRAGMENT_SHADER);
-
- // Saving compiled GXP file on SD
- if (p) saveGXP(p, size, "ux0:data/clear_f.gxp");
-
- shark_clear_output();
-
- // Compiling vertex shader
- size = sizeof(vertex_shader) - 1;
- p = shark_compile_shader(vertex_shader, &size, SHARK_VERTEX_SHADER);
-
- // Saving compiled GXP file on SD
- if (p) saveGXP(p, size, "ux0:data/rgb_v.gxp");
-
- shark_clear_output();
-
- shark_end();
-
- return 0;
-}
diff --git a/deps/vitaShaRK/samples/sample2/Makefile b/deps/vitaShaRK/samples/sample2/Makefile
deleted file mode 100644
index e41643545a..0000000000
--- a/deps/vitaShaRK/samples/sample2/Makefile
+++ /dev/null
@@ -1,37 +0,0 @@
-SAMPLE_NUM := 002
-TARGET := vitaShaRK-Sample$(SAMPLE_NUM)
-SOURCES := .
-
-INCLUDES := include
-
-LIBS = -lvitashark -lSceLibKernel_stub -lSceShaccCg_stub
-
-CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c))
-CPPFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.cpp))
-BINFILES := $(foreach dir,$(DATA), $(wildcard $(dir)/*.bin))
-OBJS := $(addsuffix .o,$(BINFILES)) $(CFILES:.c=.o) $(CPPFILES:.cpp=.o)
-
-PREFIX = arm-vita-eabi
-CC = $(PREFIX)-gcc
-CXX = $(PREFIX)-g++
-CFLAGS = -g -Wl,-q -O2 -ftree-vectorize
-CXXFLAGS = $(CFLAGS) -fno-exceptions -std=gnu++11 -fpermissive
-ASFLAGS = $(CFLAGS)
-
-all: $(TARGET).vpk
-
-$(TARGET).vpk: eboot.bin
- vita-mksfoex -s TITLE_ID=VSHARK$(SAMPLE_NUM) "$(TARGET)" param.sfo
- vita-pack-vpk -s param.sfo -b eboot.bin $@
-
-eboot.bin: $(TARGET).velf
- vita-make-fself -s $< eboot.bin
-
-%.velf: %.elf
- vita-elf-create $< $@
-
-$(TARGET).elf: $(OBJS)
- $(CC) $(CFLAGS) $^ $(LIBS) -o $@
-
-clean:
- @rm -rf *.velf *.elf *.vpk $(OBJS) param.sfo eboot.bin
diff --git a/deps/vitaShaRK/samples/sample2/main.c b/deps/vitaShaRK/samples/sample2/main.c
deleted file mode 100644
index 0d585e0201..0000000000
--- a/deps/vitaShaRK/samples/sample2/main.c
+++ /dev/null
@@ -1,85 +0,0 @@
-// Simple compiler with file logging
-
-#include
-#include
-#include
-
-const char fragment_shader[] =
- "float4 main(uniform float4 u_clear_color) : COLOR\n"
- "{\n"
- " return u_clear_color;\n"
- "}"
- ;
-
-const char vertex_shader[] =
- "void main(\n"
- "float3 aPosition,\n"
- "float3 aColor,\n"
- "uniform float4x4 wvp,\n"
- "float4 out vPosition: POSITION,\n"
- "float4 out vColor: COLOR)\n"
- "{\n"
- " vPosition = mul(float4(aPosition, 1.f), wvp);\n"
- " vColor = float4(aColor, 1.f);\n"
- "}"
- ;
-
-char curr_compilation[256];
-
-void log_cb(const char *msg, shark_log_level msg_level, int line) {
- FILE *f = fopen("ux0:/data/shark.log", "a+");
- switch (msg_level) {
- case SHARK_LOG_INFO:
- fprintf(f, "%s) INFO: %s at line %d\n", curr_compilation, msg, line);
- break;
- case SHARK_LOG_WARNING:
- fprintf(f, "%s) WARNING: %s at line %d\n", curr_compilation, msg, line);
- break;
- case SHARK_LOG_ERROR:
- fprintf(f, "%s) ERROR: %s at line %d\n", curr_compilation, msg, line);
- break;
- default:
- break;
- }
- fclose(f);
-}
-
-void saveGXP(SceGxmProgram *p, uint32_t size, const char *fname) {
- FILE *f = fopen(fname, "wb");
- fwrite(p, 1, size, f);
- fclose(f);
-}
-
-int main() {
- // Initializing vitaShaRK
- if (shark_init(NULL) < 0) // NOTE: libshacccg.suprx will need to be placed in ur0:data
- return -1;
-
- // Setting up logger
- shark_install_log_cb(log_cb);
- shark_set_warnings_level(SHARK_WARN_MAX);
-
- // Compiling fragment shader
- sprintf(curr_compilation, "clear_f.gxp");
- uint32_t size = sizeof(fragment_shader) - 1;
- SceGxmProgram *p = shark_compile_shader(fragment_shader, &size, SHARK_FRAGMENT_SHADER);
-
- // Saving compiled GXP file on SD
- if (p) saveGXP(p, size, "ux0:data/clear_f.gxp");
-
- shark_clear_output();
-
- // Compiling vertex shader
- sprintf(curr_compilation, "rgb_v.gxp");
- size = sizeof(vertex_shader) - 1;
- p = shark_compile_shader(vertex_shader, &size, SHARK_VERTEX_SHADER);
-
- // Saving compiled GXP file on SD
- if (p) saveGXP(p, size, "ux0:data/rgb_v.gxp");
-
- shark_clear_output();
-
- shark_end();
-
- return 0;
-}
diff --git a/deps/vitaShaRK/source/vitashark.c b/deps/vitaShaRK/source/vitashark.c
deleted file mode 100644
index 96a6c719aa..0000000000
--- a/deps/vitaShaRK/source/vitashark.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * This file is part of vitaGL
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- * Copyright 2020 Asakura Reiko
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-#include "vitashark.h"
-#include
-#include "shacccg.h"
-
-// Default path for SceShaccCg module location
-#define DEFAULT_SHACCCG_PATH "ur0:/data/libshacccg.suprx"
-
-static void (*shark_log_cb)(const char *msg, shark_log_level msg_level, int line) = NULL;
-static shark_warn_level shark_warnings_level = SHARK_WARN_SILENT;
-
-static SceUID shark_module_id = 0;
-static uint8_t shark_initialized = 0;
-static SceShaccCgCompileOutput *shark_output = NULL;
-static SceShaccCgSourceFile shark_input;
-
-// Dummy Open File callback
-static SceShaccCgSourceFile *shark_open_file_cb(const char *fileName,
- const SceShaccCgSourceLocation *includedFrom,
- const SceShaccCgCompileOptions *compileOptions,
- const char **errorString)
-{
- return &shark_input;
-}
-
-int shark_init(const char *path) {
- // Initializing sceShaccCg module
- if (!shark_initialized) {
- shark_module_id = sceKernelLoadStartModule(path ? path : DEFAULT_SHACCCG_PATH, 0, NULL, 0, NULL, NULL);
- if (shark_module_id < 0) return -1;
- sceShaccCgSetDefaultAllocator(malloc, free);
- shark_initialized = 1;
- }
- return 0;
-}
-
-void shark_end() {
- if (!shark_initialized) return;
-
- // Terminating sceShaccCg module
- sceKernelStopUnloadModule(shark_module_id, 0, NULL, 0, NULL, NULL);
- shark_initialized = 0;
-}
-
-void shark_install_log_cb(void (*cb)(const char *msg, shark_log_level msg_level, int line)) {
- shark_log_cb = cb;
-}
-
-void shark_set_warnings_level(shark_warn_level level) {
- // Changing current warnings level
- shark_warnings_level = level;
-}
-
-void shark_clear_output() {
- // Clearing sceShaccCg output
- if (shark_output) {
- sceShaccCgDestroyCompileOutput(shark_output);
- shark_output = NULL;
- }
-}
-
-SceGxmProgram *shark_compile_shader_extended(const char *src, uint32_t *size, shark_type type, shark_opt opt, int32_t use_fastmath, int32_t use_fastprecision, int32_t use_fastint) {
- if (!shark_initialized) return NULL;
-
- // Forcing usage for memory source for the shader to compile
- shark_input.fileName = "";
- shark_input.text = src;
- shark_input.size = *size;
-
- // Properly configuring SceShaccCg with requqested settings
- SceShaccCgCompileOptions options = {0};
- options.mainSourceFile = shark_input.fileName;
- options.targetProfile = type;
- options.entryFunctionName = "main";
- options.macroDefinitions = NULL;
- options.useFx = 1;
- options.warningLevel = shark_warnings_level;
- options.optimizationLevel = opt;
- options.useFastmath = use_fastmath;
- options.useFastint = use_fastint;
- options.useFastprecision = use_fastprecision;
- options.pedantic = shark_warnings_level > SHARK_WARN_MEDIUM ? SHARK_ENABLE : SHARK_DISABLE;
- options.performanceWarnings = shark_warnings_level > SHARK_WARN_SILENT ? SHARK_ENABLE : SHARK_DISABLE;
-
- // Executing shader compilation
- SceShaccCgCallbackList callbacks = {0};
- sceShaccCgInitializeCallbackList(&callbacks, SCE_SHACCCG_TRIVIAL);
- callbacks.openFile = shark_open_file_cb;
- const SceShaccCgCompileOutput *shark_output = sceShaccCgCompileProgram(&options, &callbacks, 0);
-
- // Executing logging
- if (shark_log_cb) {
- for (int i = 0; i < shark_output->diagnosticCount; ++i) {
- const SceShaccCgDiagnosticMessage *log = &shark_output->diagnostics[i];
- shark_log_cb(log->message, log->level, log->location->lineNumber);
- }
- }
-
- // Returning output
- if (shark_output->programData) *size = shark_output->programSize;
- return (SceGxmProgram *)shark_output->programData;
-}
-
-SceGxmProgram *shark_compile_shader(const char *src, uint32_t *size, shark_type type) {
- return shark_compile_shader_extended(src, size, type, SHARK_OPT_DEFAULT, SHARK_DISABLE, SHARK_DISABLE, SHARK_DISABLE);
-}
diff --git a/deps/vitaShaRK/source/vitashark.h b/deps/vitaShaRK/source/vitashark.h
deleted file mode 100644
index 61d1966084..0000000000
--- a/deps/vitaShaRK/source/vitashark.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * This file is part of vitaShaRK
- * Copyright 2017, 2018, 2019, 2020 Rinnegatamante
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, 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 .
- */
-
-#ifndef _VITASHARK_H_
-#define _VITASHARK_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include
-
-typedef enum shark_opt {
- SHARK_OPT_SLOW, //!< Equivalent to O0
- SHARK_OPT_SAFE, //!< Equivalent to O1
- SHARK_OPT_DEFAULT, //!< Equivalent to O2
- SHARK_OPT_FAST, //!< Equivalent to O3
- SHARK_OPT_UNSAFE //!< Equivalent to Ofast
-} shark_opt;
-
-typedef enum shark_type {
- SHARK_VERTEX_SHADER,
- SHARK_FRAGMENT_SHADER
-} shark_type;
-
-typedef enum shark_log_level {
- SHARK_LOG_INFO,
- SHARK_LOG_WARNING,
- SHARK_LOG_ERROR
-} shark_log_level;
-
-typedef enum shark_warn_level {
- SHARK_WARN_SILENT,
- SHARK_WARN_LOW,
- SHARK_WARN_MEDIUM,
- SHARK_WARN_HIGH,
- SHARK_WARN_MAX
-} shark_warn_level;
-
-#define SHARK_DISABLE 0
-#define SHARK_ENABLE 1
-
-// Init/term routines
-int shark_init(const char *path); //!< Initializes runtime shader compiler
-void shark_end(); //!< Terminates runtime shader compiler and frees used memory
-
-// Compiling routines
-SceGxmProgram *shark_compile_shader_extended(const char *src, uint32_t *size, shark_type type, shark_opt opt, int32_t use_fastmath, int32_t use_fastprecision, int32_t use_fastint); //!< Compiles a shader with extended settings
-SceGxmProgram *shark_compile_shader(const char *src, uint32_t *size, shark_type type); //!< Compiles a shader
-void shark_clear_output(); //!< Clears output of a compilation attempt
-
-// Logging routines
-void shark_install_log_cb(void (*cb)(const char *msg, shark_log_level msg_level, int line)); //!< Installs a log function for info, warnings and errors
-void shark_set_warnings_level(shark_warn_level level); //!< Sets warnings level for logging
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif