commit 78c27dc77af4a03886058cc76f3553a0b3e28cc1 Author: Francisco José García García Date: Mon May 4 12:43:18 2020 +0200 Squashed 'deps/vitaGL/' content from commit 9a6e4b3397 git-subtree-dir: deps/vitaGL git-subtree-split: 9a6e4b3397c207e136b2d618fa4b58e2b37c383e diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000000..466a0cff41 --- /dev/null +++ b/.clang-format @@ -0,0 +1,99 @@ +--- +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/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..bdb0cabc87 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,17 @@ +# 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/.gitignore b/.gitignore new file mode 100644 index 0000000000..23410e348b --- /dev/null +++ b/.gitignore @@ -0,0 +1,57 @@ +*.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/COPYING b/COPYING new file mode 100644 index 0000000000..f288702d2f --- /dev/null +++ b/COPYING @@ -0,0 +1,674 @@ + 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/COPYING.LESSER b/COPYING.LESSER new file mode 100644 index 0000000000..0a041280bd --- /dev/null +++ b/COPYING.LESSER @@ -0,0 +1,165 @@ + 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/Makefile b/Makefile new file mode 100644 index 0000000000..f5efeb0449 --- /dev/null +++ b/Makefile @@ -0,0 +1,67 @@ +TARGET := libvitaGL +SOURCES := source source/utils +SHADERS := shaders + +ifeq ($(HAVE_SBRK),1) +SOURCES += source/hacks +endif + +CFILES := $(foreach dir,$(SOURCES), $(wildcard $(dir)/*.c)) +CGFILES := $(foreach dir,$(SHADERS), $(wildcard $(dir)/*.cg)) +HEADERS := $(CGFILES:.cg=.h) +OBJS := $(CFILES:.c=.o) + +PREFIX = arm-vita-eabi +CC = $(PREFIX)-gcc +AR = $(PREFIX)-gcc-ar +CFLAGS = -g -Wl,-q -O2 -ffast-math -mtune=cortex-a9 -mfpu=neon -flto -ftree-vectorize -DSTB_DXT_IMPLEMENTATION +ASFLAGS = $(CFLAGS) + +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 + +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" . diff --git a/README.md b/README.md new file mode 100644 index 0000000000..5accb88b97 --- /dev/null +++ b/README.md @@ -0,0 +1,44 @@ +# 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)
+[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)
+ +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
+[meritous](https://vitadb.rinnegatamante.it/#/info/411) - Port of meritous
diff --git a/format.bat b/format.bat new file mode 100644 index 0000000000..dab6c9f4a1 --- /dev/null +++ b/format.bat @@ -0,0 +1,6 @@ +@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/samples/sample1/Makefile b/samples/sample1/Makefile new file mode 100644 index 0000000000..006a1677b1 --- /dev/null +++ b/samples/sample1/Makefile @@ -0,0 +1,40 @@ +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/samples/sample1/main.c b/samples/sample1/main.c new file mode 100644 index 0000000000..45898dd51f --- /dev/null +++ b/samples/sample1/main.c @@ -0,0 +1,67 @@ +// 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/samples/sample1/texture.bmp b/samples/sample1/texture.bmp new file mode 100644 index 0000000000..cfcc30313b Binary files /dev/null and b/samples/sample1/texture.bmp differ diff --git a/samples/sample2/Makefile b/samples/sample2/Makefile new file mode 100644 index 0000000000..bdbdbd8e39 --- /dev/null +++ b/samples/sample2/Makefile @@ -0,0 +1,42 @@ +SAMPLE_NUM := 002 +TARGET := vitaGL-Sample$(SAMPLE_NUM) +SOURCES := . + +INCLUDES := include + +LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_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 + +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/samples/sample2/main.c b/samples/sample2/main.c new file mode 100644 index 0000000000..79b2746f44 --- /dev/null +++ b/samples/sample2/main.c @@ -0,0 +1,39 @@ +// 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/samples/sample3/Makefile b/samples/sample3/Makefile new file mode 100644 index 0000000000..887e53b8b7 --- /dev/null +++ b/samples/sample3/Makefile @@ -0,0 +1,38 @@ +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/samples/sample3/main.c b/samples/sample3/main.c new file mode 100644 index 0000000000..97cb9f186e --- /dev/null +++ b/samples/sample3/main.c @@ -0,0 +1,36 @@ +// 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/samples/sample4/Makefile b/samples/sample4/Makefile new file mode 100644 index 0000000000..5a2d34a73b --- /dev/null +++ b/samples/sample4/Makefile @@ -0,0 +1,37 @@ +SAMPLE_NUM := 004 +TARGET := vitaGL-Sample$(SAMPLE_NUM) +SOURCES := . + +INCLUDES := include + +LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_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/samples/sample4/main.c b/samples/sample4/main.c new file mode 100644 index 0000000000..c1ff0fda96 --- /dev/null +++ b/samples/sample4/main.c @@ -0,0 +1,38 @@ +// 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/samples/sample5/Makefile b/samples/sample5/Makefile new file mode 100644 index 0000000000..32f94c96c5 --- /dev/null +++ b/samples/sample5/Makefile @@ -0,0 +1,37 @@ +SAMPLE_NUM := 005 +TARGET := vitaGL-Sample$(SAMPLE_NUM) +SOURCES := . + +INCLUDES := include + +LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_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/samples/sample5/main.c b/samples/sample5/main.c new file mode 100644 index 0000000000..5d8f35edc3 --- /dev/null +++ b/samples/sample5/main.c @@ -0,0 +1,82 @@ +// 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 +}; + +void init_perspective(float fov, float aspect, float near, float far){ + float half_height = near * tanf(((fov * M_PI) / 180.0f) * 0.5f); + float half_width = half_height * aspect; + + glFrustum(-half_width, half_width, -half_height, half_height, near, far); +} + +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(); + init_perspective(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/samples/sample6/Makefile b/samples/sample6/Makefile new file mode 100644 index 0000000000..bc0a5fe656 --- /dev/null +++ b/samples/sample6/Makefile @@ -0,0 +1,37 @@ +SAMPLE_NUM := 006 +TARGET := vitaGL-Sample$(SAMPLE_NUM) +SOURCES := . + +INCLUDES := include + +LIBS = -lvitaGL -lc -lSceCommonDialog_stub -lm -lSceGxm_stub -lSceDisplay_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/samples/sample6/main.c b/samples/sample6/main.c new file mode 100644 index 0000000000..464c0be430 --- /dev/null +++ b/samples/sample6/main.c @@ -0,0 +1,96 @@ +// 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 +}; + +void init_perspective(float fov, float aspect, float near, float far){ + float half_height = near * tanf(((fov * M_PI) / 180.0f) * 0.5f); + float half_width = half_height * aspect; + + glFrustum(-half_width, half_width, -half_height, half_height, near, far); +} + +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(); + init_perspective(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/samples/sample7/Makefile b/samples/sample7/Makefile new file mode 100644 index 0000000000..8b33dfa4f8 --- /dev/null +++ b/samples/sample7/Makefile @@ -0,0 +1,40 @@ +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/samples/sample7/main.c b/samples/sample7/main.c new file mode 100644 index 0000000000..556bdad738 --- /dev/null +++ b/samples/sample7/main.c @@ -0,0 +1,91 @@ +// 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/samples/sample7/texture.bmp b/samples/sample7/texture.bmp new file mode 100644 index 0000000000..cfcc30313b Binary files /dev/null and b/samples/sample7/texture.bmp differ diff --git a/shaders/clear_f.cg b/shaders/clear_f.cg new file mode 100644 index 0000000000..aa28edf821 --- /dev/null +++ b/shaders/clear_f.cg @@ -0,0 +1,4 @@ +float4 main(uniform float4 u_clear_color) : COLOR +{ + return u_clear_color; +} diff --git a/shaders/clear_v.cg b/shaders/clear_v.cg new file mode 100644 index 0000000000..95a138108a --- /dev/null +++ b/shaders/clear_v.cg @@ -0,0 +1,7 @@ +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/shaders/disable_color_buffer_f.cg b/shaders/disable_color_buffer_f.cg new file mode 100644 index 0000000000..0202ff51c2 --- /dev/null +++ b/shaders/disable_color_buffer_f.cg @@ -0,0 +1,5 @@ +float main( + uniform float depth_clear) : DEPTH +{ + return depth_clear; +} diff --git a/shaders/rgb_v.cg b/shaders/rgb_v.cg new file mode 100644 index 0000000000..e4f62b03e6 --- /dev/null +++ b/shaders/rgb_v.cg @@ -0,0 +1,11 @@ +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/shaders/rgba_f.cg b/shaders/rgba_f.cg new file mode 100644 index 0000000000..39ef1af00c --- /dev/null +++ b/shaders/rgba_f.cg @@ -0,0 +1,4 @@ +float4 main(float4 vColor : COLOR) : COLOR +{ + return vColor; +} diff --git a/shaders/rgba_v.cg b/shaders/rgba_v.cg new file mode 100644 index 0000000000..93786fd01e --- /dev/null +++ b/shaders/rgba_v.cg @@ -0,0 +1,11 @@ +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/shaders/texture2d_f.cg b/shaders/texture2d_f.cg new file mode 100644 index 0000000000..2d202f7a9d --- /dev/null +++ b/shaders/texture2d_f.cg @@ -0,0 +1,83 @@ +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/shaders/texture2d_rgba_f.cg b/shaders/texture2d_rgba_f.cg new file mode 100644 index 0000000000..f76328fdf9 --- /dev/null +++ b/shaders/texture2d_rgba_f.cg @@ -0,0 +1,83 @@ +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/shaders/texture2d_rgba_v.cg b/shaders/texture2d_rgba_v.cg new file mode 100644 index 0000000000..a1bf531855 --- /dev/null +++ b/shaders/texture2d_rgba_v.cg @@ -0,0 +1,27 @@ +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/shaders/texture2d_v.cg b/shaders/texture2d_v.cg new file mode 100644 index 0000000000..5111a38ab3 --- /dev/null +++ b/shaders/texture2d_v.cg @@ -0,0 +1,24 @@ +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/source/custom_shaders.c b/source/custom_shaders.c new file mode 100644 index 0000000000..d3d5beeb34 --- /dev/null +++ b/source/custom_shaders.c @@ -0,0 +1,447 @@ +/* + * 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 32 // Maximum number of linkable custom shaders +#define MAX_SHADER_PARAMS 16 // Maximum number of parameters per custom shader + +// Internal stuffs +void *frag_uniforms = NULL; +void *vert_uniforms = NULL; + +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; +} shader; + +// Program struct holding vertex/fragment shader info +typedef struct program { + shader *vshader; + shader *fshader; + GLboolean valid; + SceGxmVertexAttribute attr[16]; + SceGxmVertexStream stream[16]; + SceGxmVertexProgram *vprog; + SceGxmFragmentProgram *fprog; + GLuint attr_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; + 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); +} + +void _vglDrawObjects_CustomShadersIMPL(GLenum mode, GLsizei count, GLboolean implicit_wvp) { + program *p = &progs[cur_program - 1]; + if (implicit_wvp) { + 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); + } +} + +/* + * ------------------------------ + * - IMPLEMENTATION STARTS HERE - + * ------------------------------ + */ + +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: + error = GL_INVALID_ENUM; + break; + } + shaders[res - 1].valid = GL_TRUE; + + return res; +} + +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((void *)s->prog, binary, length); + sceGxmShaderPatcherRegisterProgram(gxm_shader_patcher, s->prog, &s->id); + s->prog = sceGxmShaderPatcherGetProgramFromId(s->id); +} + +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); + } + 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 + 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->attr_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; + if (p->last_uniform != NULL) + p->last_uniform->chain = (void *)res; + p->last_uniform = res; + + // 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; + } + + return (GLint)res; +} + +void glUniform1f(GLint location, GLfloat v0) { + // 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 glUniform2fv(GLint location, GLsizei count, const GLfloat *value) { + // 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 glUniform4fv(GLint location, GLsizei count, const GLfloat *value) { + // 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) { + // 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); + + // 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_UNSIGNED_BYTE: + attributes->format = SCE_GXM_ATTRIBUTE_FORMAT_U8N; + bpe = sizeof(uint8_t); + break; + default: + 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; +} + +// Equivalent of glVertexAttribLocation 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) { + error = GL_INVALID_VALUE; + return; + } +#endif + + // Detecting type size + int bpe; + switch (type) { + case GL_FLOAT: + bpe = sizeof(GLfloat); + break; + case GL_SHORT: + bpe = sizeof(GLshort); + break; + default: + 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(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(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/source/framebuffers.c b/source/framebuffers.c new file mode 100644 index 0000000000..fc157443b7 --- /dev/null +++ b/source/framebuffers.c @@ -0,0 +1,184 @@ +/* + * 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: + 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) { + error = GL_INVALID_VALUE; + return; + } +#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) { + error = GL_INVALID_VALUE; + return; + } +#endif + while (n > 0) { + framebuffer *fb = (framebuffer *)framebuffers[n--]; + fb->active = 0; + if (fb->target) { + sceGxmDestroyRenderTarget(fb->target); + fb->target = NULL; + } + if (fb->depth_buffer_addr) { + mempool_free(fb->depth_buffer_addr, fb->depth_buffer_mem_type); + mempool_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: + 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: + error = GL_INVALID_ENUM; + break; + } + + // Aliasing to make code more readable + texture_unit *tex_unit = &texture_units[server_texture_unit]; + texture *tex = &tex_unit->textures[tex_id]; + + // Extracting texture sizes + int tex_w = sceGxmTextureGetWidth(&tex->gxm_tex); + int tex_h = 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, + tex_w, + tex_h, + tex_w, + sceGxmTextureGetData(&tex->gxm_tex)); + + // Allocating depth and stencil buffer (FIXME: This probably shouldn't be here) + initDepthStencilBuffer(tex_w, tex_h, &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: + error = GL_INVALID_ENUM; + break; + } +} diff --git a/source/get_info.c b/source/get_info.c new file mode 100644 index 0000000000..19459f6985 --- /dev/null +++ b/source/get_info.c @@ -0,0 +1,202 @@ +/* + * 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: + 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: + 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; + default: + 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; + default: + 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: + error = GL_INVALID_ENUM; + break; + } + return ret; +} + +GLenum glGetError(void) { + GLenum ret = error; + error = GL_NO_ERROR; + return ret; +} diff --git a/source/gxm.c b/source/gxm.c new file mode 100644 index 0000000000..f0b496a3a0 --- /dev/null +++ b/source/gxm.c @@ -0,0 +1,397 @@ +/* + * 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 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 +static 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 +static unsigned int gxm_front_buffer_index; // Display front buffer id +static 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 + +static 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 + +SceGxmContext *gxm_context; // sceGxm context instance +GLenum 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) + +// 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) { + // Initializing sceGxm init parameters + SceGxmInitializeParams gxm_init_params; + memset(&gxm_init_params, 0, sizeof(SceGxmInitializeParams)); + gxm_init_params.flags = 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 = SCE_GXM_DEFAULT_PARAMETER_BUFFER_SIZE; + + // Initializing sceGxm + sceGxmInitialize(&gxm_init_params); +} + +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 + mempool_free(vdm_ring_buffer_addr, VGL_MEM_VRAM); + mempool_free(vertex_ring_buffer_addr, VGL_MEM_VRAM); + mempool_free(fragment_ring_buffer_addr, VGL_MEM_VRAM); + gpu_fragment_usse_free_mapped(fragment_usse_ring_buffer_addr); + + // Destroying sceGxm context + sceGxmDestroyContext(gxm_context); +} + +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) { + vglMemType type = VGL_MEM_VRAM; + int i; + for (i = 0; i < DISPLAY_BUFFER_COUNT; i++) { + // Allocating color surface memblock + gxm_color_surfaces_addr[i] = gpu_alloc_mapped( + ALIGN(4 * DISPLAY_STRIDE * DISPLAY_HEIGHT, 1 * 1024 * 1024), + &type); + + // Initializing allocated color surface + memset(gxm_color_surfaces_addr[i], 0, DISPLAY_STRIDE * DISPLAY_HEIGHT); + 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++) { + mempool_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 + mempool_free(gxm_depth_surface_addr, VGL_MEM_VRAM); + mempool_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 + mempool_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 vglStartRendering(void) { + // Starting drawing scene + if (active_write_fb == NULL) { // Default framebuffer is used + 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); +} + +void vglStopRenderingTerm(void) { + if (active_write_fb == NULL) { // Default framebuffer is used + + // Properly requesting a display update + 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/source/hacks/sbrk.c b/source/hacks/sbrk.c new file mode 100644 index 0000000000..828ce3ca39 --- /dev/null +++ b/source/hacks/sbrk.c @@ -0,0 +1,114 @@ +/* + * 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/source/legacy.c b/source/legacy.c new file mode 100644 index 0000000000..48dbef3d9c --- /dev/null +++ b/source/legacy.c @@ -0,0 +1,599 @@ +/* + * 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) { + error = GL_INVALID_OPERATION; + return; + } +#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(&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) { + error = GL_INVALID_OPERATION; + return; + } +#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(&last_vert->v, v, sizeof(vector3f)); + memcpy(&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(¤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(¤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) { + error = GL_INVALID_OPERATION; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } +#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) { + error = GL_INVALID_VALUE; + return; + } +#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(&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(&last_clr->v, ptr_clr, tex_unit->color_array.size * tex_unit->color_array.num); + + } else { + // Populating new color element with current color + memcpy(&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(&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) { + error = GL_INVALID_OPERATION; + return; + } +#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: + 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) { + 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) && (tex_unit->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, &tex_unit->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(&vertices[n], &object->v, sizeof(vector3f)); + memcpy(&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(&vertices[j], &object->v, sizeof(vector3f)); + memcpy(&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(&vertices[n], &object->v, sizeof(vector3f)); + memcpy(&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(&vertices[j], &object->v, sizeof(vector3f)); + memcpy(&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/source/matrices.c b/source/matrices.c new file mode 100644 index 0000000000..0b7b64ce10 --- /dev/null +++ b/source/matrices.c @@ -0,0 +1,222 @@ +/* + * 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: + 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) { + error = GL_INVALID_OPERATION; + return; + } else if ((left == right) || (bottom == top) || (nearVal == farVal)) { + error = GL_INVALID_VALUE; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } else if ((left == right) || (bottom == top) || (nearVal < 0) || (farVal < 0)) { + error = GL_INVALID_VALUE; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } +#endif + + if (matrix == &modelview_matrix) { +#ifndef SKIP_ERROR_HANDLING + // Error handling + if (modelview_stack_counter >= MODELVIEW_STACK_DEPTH) { + 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) { + 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) { + error = GL_INVALID_OPERATION; + return; + } +#endif + + if (matrix == &modelview_matrix) { +#ifndef SKIP_ERROR_HANDLING + // Error handling + if (modelview_stack_counter == 0) + 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) + 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; +} diff --git a/source/misc.c b/source/misc.c new file mode 100644 index 0000000000..ca9cecdadd --- /dev/null +++ b/source/misc.c @@ -0,0 +1,554 @@ +/* + * 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" + +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: + 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: + 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)) { + error = GL_INVALID_VALUE; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } +#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: + error = GL_INVALID_ENUM; + break; + } +} + +void glDisable(GLenum cap) { +#ifndef SKIP_ERROR_HANDLING + if (phase == MODEL_CREATION) { + error = GL_INVALID_OPERATION; + return; + } +#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: + 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: + 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: + error = GL_INVALID_ENUM; + break; + } + break; + default: + error = GL_INVALID_ENUM; + break; + } +} + +void glLineWidth(GLfloat width) { +#ifndef SKIP_ERROR_HANDLING + // Error handling + if (width <= 0) { + error = GL_INVALID_VALUE; + return; + } +#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) { + error = GL_INVALID_VALUE; + return; + } +#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: + 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(&fog_color.r, params, sizeof(vector4f)); + break; + default: + 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: + 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(&clip_plane0_eq.x, &temp.x, sizeof(vector4f)); + break; + default: + error = GL_INVALID_ENUM; + break; + } +} diff --git a/source/shaders.h b/source/shaders.h new file mode 100644 index 0000000000..24a9db1c13 --- /dev/null +++ b/source/shaders.h @@ -0,0 +1,105 @@ +/* + * 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 +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; + +#endif diff --git a/source/shaders/clear_f.h b/source/shaders/clear_f.h new file mode 100644 index 0000000000..3efceae539 --- /dev/null +++ b/source/shaders/clear_f.h @@ -0,0 +1,23 @@ +#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/source/shaders/clear_v.h b/source/shaders/clear_v.h new file mode 100644 index 0000000000..1b55545922 --- /dev/null +++ b/source/shaders/clear_v.h @@ -0,0 +1,32 @@ +#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/source/shaders/disable_color_buffer_f.h b/source/shaders/disable_color_buffer_f.h new file mode 100644 index 0000000000..397bdc35c9 --- /dev/null +++ b/source/shaders/disable_color_buffer_f.h @@ -0,0 +1,26 @@ +#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/source/shaders/rgb_v.h b/source/shaders/rgb_v.h new file mode 100644 index 0000000000..bc5caf32a9 --- /dev/null +++ b/source/shaders/rgb_v.h @@ -0,0 +1,36 @@ +#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/source/shaders/rgba_f.h b/source/shaders/rgba_f.h new file mode 100644 index 0000000000..f89c9ae975 --- /dev/null +++ b/source/shaders/rgba_f.h @@ -0,0 +1,22 @@ +#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/source/shaders/rgba_v.h b/source/shaders/rgba_v.h new file mode 100644 index 0000000000..f72aaa45a4 --- /dev/null +++ b/source/shaders/rgba_v.h @@ -0,0 +1,36 @@ +#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/source/shaders/texture2d_f.h b/source/shaders/texture2d_f.h new file mode 100644 index 0000000000..e5017a4c37 --- /dev/null +++ b/source/shaders/texture2d_f.h @@ -0,0 +1,89 @@ +#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/source/shaders/texture2d_rgba_f.h b/source/shaders/texture2d_rgba_f.h new file mode 100644 index 0000000000..494bce1638 --- /dev/null +++ b/source/shaders/texture2d_rgba_f.h @@ -0,0 +1,91 @@ +#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/source/shaders/texture2d_rgba_v.h b/source/shaders/texture2d_rgba_v.h new file mode 100644 index 0000000000..a233deec22 --- /dev/null +++ b/source/shaders/texture2d_rgba_v.h @@ -0,0 +1,50 @@ +#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/source/shaders/texture2d_v.h b/source/shaders/texture2d_v.h new file mode 100644 index 0000000000..276c3abf17 --- /dev/null +++ b/source/shaders/texture2d_v.h @@ -0,0 +1,48 @@ +#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/source/shared.h b/source/shared.h new file mode 100644 index 0000000000..044dcfe7e9 --- /dev/null +++ b/source/shared.h @@ -0,0 +1,191 @@ +/* + * 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 4096 // Available textures per texture unit +#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" + +// 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 + +// Depending on SDK, that could be or not defined +#ifndef max +#define max(a, b) ((a) > (b) ? (a) : (b)) +#endif + +// 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 error; // Error returned by glGetError +extern SceGxmShaderPatcher *gxm_shader_patcher; // sceGxmShaderPatcher shader patcher instance + +matrix4x4 mvp_matrix; // ModelViewProjection Matrix +matrix4x4 projection_matrix; // Projection Matrix +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 + +/* 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/source/state.c b/source/state.c new file mode 100644 index 0000000000..2f7d928be5 --- /dev/null +++ b/source/state.c @@ -0,0 +1,71 @@ +/* + * 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/source/state.h b/source/state.h new file mode 100644 index 0000000000..fea6184987 --- /dev/null +++ b/source/state.h @@ -0,0 +1,209 @@ +/* + * 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]; + texture textures[TEXTURES_NUM]; + 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; + SceGxmTextureFilter min_filter; + SceGxmTextureFilter mag_filter; + SceGxmTextureAddrMode u_mode; + SceGxmTextureAddrMode v_mode; +} 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; +} 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 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/source/tests.c b/source/tests.c new file mode 100644 index 0000000000..e04c4b9f5a --- /dev/null +++ b/source/tests.c @@ -0,0 +1,508 @@ +/* + * 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)) { + error = GL_INVALID_VALUE; + return; + } +#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) { + error = GL_INVALID_OPERATION; + return; + } +#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)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_fail_front, dpfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_pass_front, dppass)) + error = GL_INVALID_ENUM; + break; + case GL_BACK: + if (!change_stencil_config(&stencil_fail_back, sfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_fail_back, dpfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_pass_front, dppass)) + error = GL_INVALID_ENUM; + break; + case GL_FRONT_AND_BACK: + if (!change_stencil_config(&stencil_fail_front, sfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&stencil_fail_back, sfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_fail_front, dpfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_fail_back, dpfail)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_pass_front, dppass)) + error = GL_INVALID_ENUM; + if (!change_stencil_config(&depth_pass_back, dppass)) + error = GL_INVALID_ENUM; + break; + default: + 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)) + 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)) + 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)) + error = GL_INVALID_ENUM; + if (!change_stencil_func_config(&stencil_func_back, func)) + error = GL_INVALID_ENUM; + stencil_mask_front = stencil_mask_back = mask; + stencil_ref_front = stencil_ref_back = ref; + break; + default: + 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: + 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/source/texture_callbacks.c b/source/texture_callbacks.c new file mode 100644 index 0000000000..08039147e4 --- /dev/null +++ b/source/texture_callbacks.c @@ -0,0 +1,95 @@ +/* + * 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 "texture_callbacks.h" + +// Read callback for 32bpp unsigned RGBA format +uint32_t readRGBA(void *data) { + uint32_t res; + memcpy(&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(&clr, data, 2); + r = (((clr >> 11) & 0x1F) * 0xFF) / 0x1F; + g = ((((clr << 5) >> 11) & 0x1F) * 0xFF) / 0x1F; + b = ((((clr << 10) >> 11) & 0x1F) * 0xFF) / 0x1F; + a = (((clr << 15) >> 15) & 0x1) == 1 ? 0xFF : 0x00; + return ((a << 24) | (b << 16) | (g << 8) | r); +} + +// Read callback for 24bpp unsigned RGB format +uint32_t readRGB(void *data) { + uint32_t res = 0xFFFFFFFF; + memcpy(&res, data, 3); + return res; +} + +// Read callback for 16bpp unsigned RG format +uint32_t readRG(void *data) { + uint32_t res = 0xFFFFFFFF; + memcpy(&res, data, 2); + return res; +} + +// Read callback for 8bpp unsigned R format +uint32_t readR(void *data) { + uint32_t res = 0xFFFFFFFF; + memcpy(&res, data, 1); + return res; +} + +// Write callback for 32bpp unsigned RGBA format +void writeRGBA(void *data, uint32_t color) { + memcpy(data, &color, 4); +} + +// Write callback for 24bpp unsigned RGB format +void writeRGB(void *data, uint32_t color) { + memcpy(data, &color, 3); +} + +// Write callback for 16bpp unsigned RG format +void writeRG(void *data, uint32_t color) { + memcpy(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(data, &color, 1); +} \ No newline at end of file diff --git a/source/texture_callbacks.h b/source/texture_callbacks.h new file mode 100644 index 0000000000..e9177ac78c --- /dev/null +++ b/source/texture_callbacks.h @@ -0,0 +1,41 @@ +/* + * 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 readRGBA(void *data); +uint32_t readRGBA5551(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 writeRGBA(void *data, uint32_t color); + +#endif diff --git a/source/textures.c b/source/textures.c new file mode 100644 index 0000000000..8533e38f0f --- /dev/null +++ b/source/textures.c @@ -0,0 +1,748 @@ +/* + * 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 +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) { + error = GL_INVALID_VALUE; + return; + } +#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 = 0; i < TEXTURES_NUM; i++) { + if (!(tex_unit->textures[i].used)) { + res[j++] = i; + tex_unit->textures[i].used = 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: + error = GL_INVALID_ENUM; + break; + } +} + +void glDeleteTextures(GLsizei n, const GLuint *gl_textures) { +#ifndef SKIP_ERROR_HANDLING + // Error handling + if (n < 0) { + error = GL_INVALID_VALUE; + return; + } +#endif + + // Aliasing to make code more readable + texture_unit *tex_unit = &texture_units[server_texture_unit]; + + // Deallocating given textures and invalidating used texture ids + int j; + for (j = 0; j < n; j++) { + GLuint i = gl_textures[j]; + tex_unit->textures[i].used = 0; + gpu_free_texture(&tex_unit->textures[i]); + } +} + +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 = &tex_unit->textures[texture2d_idx]; + + SceGxmTextureFormat tex_format; + uint8_t data_bpp = 0; + + // 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: + 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: + error = GL_INVALID_ENUM; + break; + } + break; + case GL_RGB: + switch (type) { + case GL_UNSIGNED_BYTE: + data_bpp = 3; + read_cb = readRGB; + break; + default: + 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; + default: + 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_RGBA: + write_cb = writeRGBA; + tex_format = SCE_GXM_TEXTURE_FORMAT_U8U8U8U8_ABGR; + 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: + error = GL_INVALID_ENUM; + break; + } + + // Checking if texture is too big for sceGxm + if (width > GXM_TEX_MAX_SIZE || height > GXM_TEX_MAX_SIZE) { + error = GL_INVALID_VALUE; + return; + } + + // 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); + else gpu_alloc_compressed_texture(width, height, tex_format, data, tex, data_bpp, read_cb); + else { + gpu_alloc_mipmaps(level, tex); + sceGxmTextureSetMipFilter(&tex->gxm_tex, SCE_GXM_TEXTURE_MIP_FILTER_ENABLED); + } + + // Setting texture parameters + sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex_unit->u_mode); + sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex_unit->v_mode); + sceGxmTextureSetMinFilter(&tex->gxm_tex, tex_unit->min_filter); + sceGxmTextureSetMagFilter(&tex->gxm_tex, tex_unit->mag_filter); + + // Setting palette if the format requests one + if (tex->valid && tex->palette_UID) + sceGxmTextureSetPalette(&tex->gxm_tex, color_table->data); + + break; + default: + 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 = &tex_unit->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) { + error = GL_INVALID_VALUE; + return; + } else if (yoffset + height > orig_h) { + error = GL_INVALID_VALUE; + return; + } + + // 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: + error = GL_INVALID_ENUM; + return; + break; + } + break; + case GL_RG: + switch (type) { + case GL_UNSIGNED_BYTE: + read_cb = readRG; + data_bpp = 2; + break; + default: + error = GL_INVALID_ENUM; + return; + break; + } + break; + case GL_RGB: + switch (type) { + case GL_UNSIGNED_BYTE: + data_bpp = 3; + read_cb = readRGB; + break; + default: + error = GL_INVALID_ENUM; + return; + 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; + default: + error = GL_INVALID_ENUM; + return; + 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_RGBA: + write_cb = writeRGBA; + 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: + 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: + error = GL_INVALID_ENUM; + break; + } + break; + default: + 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 = &tex_unit->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_unit->min_filter = SCE_GXM_TEXTURE_FILTER_POINT; + break; + case GL_LINEAR: // Linear + tex_unit->min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR; + break; + case GL_NEAREST_MIPMAP_NEAREST: // TODO: Implement this + break; + case GL_LINEAR_MIPMAP_NEAREST: // TODO: Implement this + break; + case GL_NEAREST_MIPMAP_LINEAR: // TODO: Implement this + break; + case GL_LINEAR_MIPMAP_LINEAR: // TODO: Implement this + break; + default: + error = GL_INVALID_ENUM; + break; + } + sceGxmTextureSetMinFilter(&tex->gxm_tex, tex_unit->min_filter); + break; + case GL_TEXTURE_MAG_FILTER: // Mag Filter + switch (param) { + case GL_NEAREST: // Point + tex_unit->mag_filter = SCE_GXM_TEXTURE_FILTER_POINT; + break; + case GL_LINEAR: // Linear + tex_unit->mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR; + break; + case GL_NEAREST_MIPMAP_NEAREST: // TODO: Implement this + break; + case GL_LINEAR_MIPMAP_NEAREST: // TODO: Implement this + break; + case GL_NEAREST_MIPMAP_LINEAR: // TODO: Implement this + break; + case GL_LINEAR_MIPMAP_LINEAR: // TODO: Implement this + break; + default: + error = GL_INVALID_ENUM; + break; + } + sceGxmTextureSetMagFilter(&tex->gxm_tex, tex_unit->mag_filter); + break; + case GL_TEXTURE_WRAP_S: // U Mode + switch (param) { + case GL_CLAMP_TO_EDGE: // Clamp + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_CLAMP; + break; + case GL_REPEAT: // Repeat + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; + break; + case GL_MIRRORED_REPEAT: // Mirror + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR; + break; + case GL_MIRROR_CLAMP_EXT: // Mirror Clamp + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP; + break; + default: + error = GL_INVALID_ENUM; + break; + } + sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex_unit->u_mode); + break; + case GL_TEXTURE_WRAP_T: // V Mode + switch (param) { + case GL_CLAMP_TO_EDGE: // Clamp + tex_unit->v_mode = SCE_GXM_TEXTURE_ADDR_CLAMP; + break; + case GL_REPEAT: // Repeat + tex_unit->v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; + break; + case GL_MIRRORED_REPEAT: // Mirror + tex_unit->v_mode = SCE_GXM_TEXTURE_ADDR_MIRROR; + break; + case GL_MIRROR_CLAMP_EXT: // Mirror Clamp + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP; + break; + default: + error = GL_INVALID_ENUM; + break; + } + sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex_unit->v_mode); + break; + default: + error = GL_INVALID_ENUM; + break; + } + break; + default: + 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 = &tex_unit->textures[texture2d_idx]; + + switch (target) { + case GL_TEXTURE_2D: + switch (pname) { + case GL_TEXTURE_MIN_FILTER: // Min Filter + if (param == GL_NEAREST) + tex_unit->min_filter = SCE_GXM_TEXTURE_FILTER_POINT; // Point + if (param == GL_LINEAR) + tex_unit->min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR; // Linear + sceGxmTextureSetMinFilter(&tex->gxm_tex, tex_unit->min_filter); + break; + case GL_TEXTURE_MAG_FILTER: // Mag filter + if (param == GL_NEAREST) + tex_unit->mag_filter = SCE_GXM_TEXTURE_FILTER_POINT; // Point + else if (param == GL_LINEAR) + tex_unit->mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR; // Linear + sceGxmTextureSetMagFilter(&tex->gxm_tex, tex_unit->mag_filter); + break; + case GL_TEXTURE_WRAP_S: // U Mode + if (param == GL_CLAMP_TO_EDGE) + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_CLAMP; // Clamp + else if (param == GL_REPEAT) + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; // Repeat + else if (param == GL_MIRRORED_REPEAT) + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR; // Mirror + else if (param == GL_MIRROR_CLAMP_EXT) + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP; // Mirror Clamp + sceGxmTextureSetUAddrMode(&tex->gxm_tex, tex_unit->u_mode); + break; + case GL_TEXTURE_WRAP_T: // V Mode + if (param == GL_CLAMP_TO_EDGE) + tex_unit->v_mode = SCE_GXM_TEXTURE_ADDR_CLAMP; // Clamp + else if (param == GL_REPEAT) + tex_unit->v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; // Repeat + else if (param == GL_MIRRORED_REPEAT) + tex_unit->v_mode = SCE_GXM_TEXTURE_ADDR_MIRROR; // Mirror + else if (param == GL_MIRROR_CLAMP_EXT) + tex_unit->u_mode = SCE_GXM_TEXTURE_ADDR_MIRROR_CLAMP; // Mirror Clamp + sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex_unit->v_mode); + break; + default: + error = GL_INVALID_ENUM; + break; + } + break; + default: + 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)) + 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 = &tex_unit->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_unit->u_mode); + sceGxmTextureSetVAddrMode(&tex->gxm_tex, tex_unit->v_mode); + sceGxmTextureSetMinFilter(&tex->gxm_tex, tex_unit->min_filter); + sceGxmTextureSetMagFilter(&tex->gxm_tex, tex_unit->mag_filter); + sceGxmTextureSetMipFilter(&tex->gxm_tex, SCE_GXM_TEXTURE_MIP_FILTER_ENABLED); + + break; + default: + 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: + error = GL_INVALID_ENUM; + break; + } + break; + default: + error = GL_INVALID_ENUM; + } +} + +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(&texenv_color.r, param, sizeof(GLfloat) * 4); + break; + default: + error = GL_INVALID_ENUM; + break; + } + break; + default: + error = GL_INVALID_ENUM; + } +} + +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: + error = GL_INVALID_ENUM; + break; + } + break; + default: + 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 = &tex_unit->textures[texture2d_idx]; + + switch (target) { + case GL_TEXTURE_2D: + return tex->data; + break; + default: + error = GL_INVALID_ENUM; + break; + } + + return NULL; +} diff --git a/source/utils/gpu_utils.c b/source/utils/gpu_utils.c new file mode 100644 index 0000000000..17ff1fb82f --- /dev/null +++ b/source/utils/gpu_utils.c @@ -0,0 +1,464 @@ +/* + * 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)) +#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(&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, STB_DXT_HIGHQUAL); + dst += isdxt5 ? 16 : 8; + } +} + +void *gpu_alloc_mapped(size_t size, vglMemType *type) { + // Allocating requested memblock + void *res = 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 = mempool_alloc(size, *type); + } + + // Even the other one failed, using our last resort + if (res == NULL) { + *type = VGL_MEM_SLOW; + res = 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 + mempool_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 + mempool_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(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) + mempool_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)) { + // 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; + 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, 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 = w * h; + if (alignment == 8) tex_size /= 2; + + // Allocating texture data buffer + void *texture_data = gpu_alloc_mapped(tex_size, &tex->mtype); + + // NOTE: Supports only GL_RGBA source format for now + + // Initializing texture data buffer + if (texture_data != NULL) { + // Initializing texture data buffer + if (data != NULL) { + //void *tmp = malloc(w * h * 4); + //void *tmp2 = malloc(tex_size); + /*int i, j; + uint8_t *src = (uint8_t *)data; + uint32_t *dst = (uint32_t*)tmp; + for (i = 0; i < h * w; i++) { + uint32_t clr = read_cb(src); + writeRGBA(dst++, src); + src += src_bpp; + }*/ + + // Performing swizzling and DXT compression + dxt_compress(texture_data, (void*)data, w, h, alignment == 16); + + + //swizzle(texture_data, tmp2, w, h, alignment << 3); + //free(tmp); + //free(tmp2); + } 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(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(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; + mempool_free(pal->data, pal->type); + free(pal); +} \ No newline at end of file diff --git a/source/utils/gpu_utils.h b/source/utils/gpu_utils.h new file mode 100644 index 0000000000..d5a93efc87 --- /dev/null +++ b/source/utils/gpu_utils.h @@ -0,0 +1,102 @@ +/* + * 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); +} 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)); + +// Alloc a compresseed texture +void gpu_alloc_compressed_texture(uint32_t w, uint32_t h, SceGxmTextureFormat format, 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/source/utils/math_utils.c b/source/utils/math_utils.c new file mode 100644 index 0000000000..3b2ab113c8 --- /dev/null +++ b/source/utils/math_utils.c @@ -0,0 +1,252 @@ +/* + * 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(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/source/utils/math_utils.h b/source/utils/math_utils.h new file mode 100644 index 0000000000..1d51ad6795 --- /dev/null +++ b/source/utils/math_utils.h @@ -0,0 +1,92 @@ +/* + * 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/source/utils/mem_utils.c b/source/utils/mem_utils.c new file mode 100644 index 0000000000..5fd4466447 --- /dev/null +++ b/source/utils/mem_utils.c @@ -0,0 +1,315 @@ +/* + * 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 8 // seems to be enough, set to 16 if something explodes + +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 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 mem_init(size_t size_ram, size_t size_cdram, size_t size_phycont) { + if (mempool_addr[0] != NULL) + mem_term(); + + mempool_size[0] = ALIGN(size_cdram, 256 * 1024); + mempool_size[1] = ALIGN(size_ram, 4 * 1024); + mempool_size[2] = ALIGN(size_phycont, 256 * 1024); + mempool_id[0] = sceKernelAllocMemBlock("cdram_mempool", SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, mempool_size[0], NULL); + mempool_id[1] = sceKernelAllocMemBlock("ram_mempool", SCE_KERNEL_MEMBLOCK_TYPE_USER_RW, mempool_size[1], NULL); + mempool_id[2] = sceKernelAllocMemBlock("phycont_mempool", SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_RW, mempool_size[2], NULL); + + for (int i = 0; i < VGL_MEM_TYPE_COUNT - 2; 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 + heap_extend(VGL_MEM_VRAM, mempool_addr[0], mempool_size[0]); + heap_extend(VGL_MEM_RAM, mempool_addr[1], mempool_size[1]); + heap_extend(VGL_MEM_SLOW, mempool_addr[2], mempool_size[2]); + + return 1; +} + +void mempool_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 *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 mempool_get_free_space(vglMemType type) { + return tm_free[type]; +} diff --git a/source/utils/mem_utils.h b/source/utils/mem_utils.h new file mode 100644 index 0000000000..05f4ea35cf --- /dev/null +++ b/source/utils/mem_utils.h @@ -0,0 +1,33 @@ +/* + * 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 mem_init(size_t size_ram, size_t size_cdram, size_t size_phycont); // Initialize mempools +void mem_term(void); // Terminate both CDRAM and RAM mempools +size_t mempool_get_free_space(vglMemType type); // Return free space in bytes for a mempool +void *mempool_alloc(size_t size, vglMemType type); // Allocate a memory block on a mempool +void mempool_free(void *ptr, vglMemType type); // Free a memory block on a mempool + +#endif \ No newline at end of file diff --git a/source/utils/stb_dxt.h b/source/utils/stb_dxt.h new file mode 100644 index 0000000000..9f7a4295a8 --- /dev/null +++ b/source/utils/stb_dxt.h @@ -0,0 +1,748 @@ +/* + * 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(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/source/vitaGL.c b/source/vitaGL.c new file mode 100644 index 0000000000..16e64a467a --- /dev/null +++ b/source/vitaGL.c @@ -0,0 +1,2106 @@ +/* + * 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" + +typedef struct gpubuffer { + void *ptr; +} 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 vglInitExtended(uint32_t gpu_pool_size, int width, int height, int ram_threshold, 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(); + + // Getting max allocatable CDRAM and RAM memory + SceKernelFreeMemorySizeInfo info; + info.size = sizeof(SceKernelFreeMemorySizeInfo); + sceKernelGetFreeMemorySize(&info); + + // Initializing memory heap for CDRAM and RAM memory + mem_init(info.size_user > ram_threshold ? info.size_user - ram_threshold : info.size_user, info.size_cdram - 256 * 1024, info.size_phycont - 1 * 1024 * 1024); // leave some just in case + + // 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++) { + for (j = 0; j < TEXTURES_NUM; j++) { + texture_units[i].textures[j].used = 0; + texture_units[i].textures[j].valid = 0; + } + texture_units[i].env_mode = MODULATE; + texture_units[i].tex_id = 0; + texture_units[i].enabled = 0; + texture_units[i].min_filter = SCE_GXM_TEXTURE_FILTER_LINEAR; + texture_units[i].mag_filter = SCE_GXM_TEXTURE_FILTER_LINEAR; + texture_units[i].u_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; + texture_units[i].v_mode = SCE_GXM_TEXTURE_ADDR_REPEAT; + } + + // 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); +} + +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 + mempool_free(clear_vertices, VGL_MEM_RAM); + mempool_free(depth_vertices, VGL_MEM_RAM); + mempool_free(depth_clear_indices, VGL_MEM_RAM); + mempool_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) { + error = GL_INVALID_VALUE; + return; + } +#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))) { + error = GL_INVALID_VALUE; + return; + } +#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: + error = GL_INVALID_ENUM; + break; + } +} + +void glDeleteBuffers(GLsizei n, const GLuint *gl_buffers) { +#ifndef SKIP_ERROR_HANDLING + if (n < 0) { + 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) { + mempool_free(gpu_buffers[idx].ptr, VGL_MEM_VRAM); + gpu_buffers[idx].ptr = NULL; + } + } + } +} + +void glBufferData(GLenum target, GLsizei size, const GLvoid *data, GLenum usage) { +#ifndef SKIP_ERROR_HANDLING + if (size < 0) { + error = GL_INVALID_VALUE; + return; + } +#endif + 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: + error = GL_INVALID_ENUM; + break; + } + vglMemType type = VGL_MEM_VRAM; + gpu_buffers[idx].ptr = gpu_alloc_mapped(size, &type); + memcpy(gpu_buffers[idx].ptr, 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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: + 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)) { + error = GL_INVALID_VALUE; + return; + } +#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: + 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)) { + error = GL_INVALID_VALUE; + return; + } +#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: + 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)) { + error = GL_INVALID_VALUE; + return; + } +#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: + 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: + 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 (!(tex_unit->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, &tex_unit->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(&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(&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(&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(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num); + ptr += tex_unit->vertex_array.stride; + } + if (!tex_set) { + memcpy(&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(&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(&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(&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(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num); + ptr += tex_unit->vertex_array.stride; + } + if (!clr_set) { + memcpy(&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(&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(&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(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num); + ptr += tex_unit->vertex_array.stride; + } + memcpy(&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) + error = GL_INVALID_ENUM; + else if (phase == MODEL_CREATION) + error = GL_INVALID_OPERATION; + else if (count < 0) + 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: + 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 (!(tex_unit->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, &texture_units[client_texture_unit].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(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(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(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(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(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num); + if (tex_unit->texture_array.stride != 0) + memcpy(&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(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(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(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(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num); + if (tex_unit->color_array.stride != 0) + memcpy(&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(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(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(&vertices[n], ptr, tex_unit->vertex_array.size * tex_unit->vertex_array.num); + memcpy(&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: + 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: + error = GL_INVALID_ENUM; + break; + } +} + +void glClientActiveTexture(GLenum texture) { +#ifndef SKIP_ERROR_HANDLING + if ((texture < GL_TEXTURE0) && (texture > GL_TEXTURE31)) + 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)) { + error = GL_INVALID_VALUE; + return; + } +#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: + error = GL_INVALID_ENUM; + break; + } + tex_unit->vertex_object = gpu_pool_memalign(count * bpe * size, bpe * size); + if (stride == 0) + memcpy(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(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)) { + error = GL_INVALID_VALUE; + return; + } +#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: + 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(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(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)) { + error = GL_INVALID_VALUE; + return; + } +#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: + error = GL_INVALID_ENUM; + break; + } + tex_unit->texture_object = gpu_pool_memalign(count * bpe * size, bpe * size); + if (stride == 0) + memcpy(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(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) { + error = GL_INVALID_VALUE; + return; + } +#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: + error = GL_INVALID_ENUM; + break; + } + tex_unit->index_object = gpu_pool_memalign(count * bpe, bpe); + if (stride == 0) + memcpy(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(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) + error = GL_INVALID_OPERATION; + else if (count < 0) + 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: + error = GL_INVALID_ENUM; + break; + } + if (!skip_draw) { + if (cur_program != 0) { + _vglDrawObjects_CustomShadersIMPL(mode, count, implicit_wvp); + sceGxmSetFragmentTexture(gxm_context, 0, &tex_unit->textures[texture2d_idx].gxm_tex); + sceGxmDraw(gxm_context, gxm_p, SCE_GXM_INDEX_FORMAT_U16, tex_unit->index_object, count); + vert_uniforms = NULL; + frag_uniforms = NULL; + } 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 (!(tex_unit->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, &tex_unit->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(&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 mempool_get_free_space(type); +} + +void *vglAlloc(uint32_t size, vglMemType type) { + if (type >= VGL_MEM_TYPE_COUNT) + return NULL; + return mempool_alloc(size, type); +} + +void vglFree(void *addr) { + mempool_free(addr, VGL_MEM_RAM); // Type is discarded so we just pass a random one +} + +void vglUseExtraMem(GLboolean use) { + use_extra_mem = use; +} \ No newline at end of file diff --git a/source/vitaGL.h b/source/vitaGL.h new file mode 100644 index 0000000000..4cfe1d5721 --- /dev/null +++ b/source/vitaGL.h @@ -0,0 +1,415 @@ +/* + * 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 + +// clang-format off +#define GLfloat float +#define GLint int32_t +#define GLdouble double +#define GLshort int16_t +#define GLuint uint32_t +#define GLsizei int32_t +#define GLenum uint16_t +#define GLubyte uint8_t +#define GLvoid void +#define GLbyte int8_t +#define GLboolean uint8_t +#define GLchar char + +#define GL_FALSE 0 +#define GL_TRUE 1 + +#define GL_NO_ERROR 0 + +#define GL_ZERO 0 +#define GL_ONE 1 + +#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_TEXTURE_2D 0x0DE1 +#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_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_INCR_WRAP 0x8507 +#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_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_FRAMEBUFFER 0x8D40 + +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 32 + +// 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 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); +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); +const GLubyte *glGetString(GLenum name); +GLint glGetUniformLocation(GLuint prog, const GLchar *name); +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 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 glUniform2fv(GLint location, GLsizei count, const GLfloat *value); +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); + +// 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); +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 vglEnd(void); +void vglFree(void *addr); +void *vglGetTexDataPointer(GLenum target); +void vglInit(uint32_t gpu_pool_size); +void vglInitExtended(uint32_t gpu_pool_size, int width, int height, int ram_threshold, SceGxmMultisampleMode msaa); +size_t vglMemFree(vglMemType type); +void vglStartRendering(); +void vglStopRendering(); +void vglStopRenderingInit(); +void vglStopRenderingTerm(); +void vglUpdateCommonDialog(); +void vglUseVram(GLboolean usage); +void vglUseVramForUSSE(GLboolean usage); +void vglUseExtraMem(GLboolean usage); +void vglWaitVblankStart(GLboolean enable); + +#ifdef __cplusplus +} +#endif + +#endif