From 8533d54dc8e26214e927338dba054b01f899c2d3 Mon Sep 17 00:00:00 2001 From: squid233 <60126026+squid233@users.noreply.github.com> Date: Sat, 4 May 2024 15:48:41 +0800 Subject: [PATCH] Add Program, Shader, Texture, VAO and VBO --- LICENSE | 142 ++++------------------- README.md | 8 +- build.gradle.kts | 10 +- gradle.properties | 28 ++--- src/main/java/module-info.java | 26 +++++ src/main/java/org/example/Main.java | 13 --- src/main/java/overrun/glgc/GLObject.java | 36 ++++++ src/main/java/overrun/glgc/Program.java | 65 +++++++++++ src/main/java/overrun/glgc/Shader.java | 66 +++++++++++ src/main/java/overrun/glgc/Texture.java | 78 +++++++++++++ src/main/java/overrun/glgc/VAO.java | 77 ++++++++++++ src/main/java/overrun/glgc/VBO.java | 77 ++++++++++++ 12 files changed, 471 insertions(+), 155 deletions(-) create mode 100644 src/main/java/module-info.java delete mode 100644 src/main/java/org/example/Main.java create mode 100644 src/main/java/overrun/glgc/GLObject.java create mode 100644 src/main/java/overrun/glgc/Program.java create mode 100644 src/main/java/overrun/glgc/Shader.java create mode 100644 src/main/java/overrun/glgc/Texture.java create mode 100644 src/main/java/overrun/glgc/VAO.java create mode 100644 src/main/java/overrun/glgc/VBO.java diff --git a/LICENSE b/LICENSE index 0e259d4..0532fc2 100644 --- a/LICENSE +++ b/LICENSE @@ -1,121 +1,21 @@ -Creative Commons Legal Code - -CC0 1.0 Universal - - CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE - LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN - ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS - INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES - REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS - PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM - THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED - HEREUNDER. - -Statement of Purpose - -The laws of most jurisdictions throughout the world automatically confer -exclusive Copyright and Related Rights (defined below) upon the creator -and subsequent owner(s) (each and all, an "owner") of an original work of -authorship and/or a database (each, a "Work"). - -Certain owners wish to permanently relinquish those rights to a Work for -the purpose of contributing to a commons of creative, cultural and -scientific works ("Commons") that the public can reliably and without fear -of later claims of infringement build upon, modify, incorporate in other -works, reuse and redistribute as freely as possible in any form whatsoever -and for any purposes, including without limitation commercial purposes. -These owners may contribute to the Commons to promote the ideal of a free -culture and the further production of creative, cultural and scientific -works, or to gain reputation or greater distribution for their Work in -part through the use and efforts of others. - -For these and/or other purposes and motivations, and without any -expectation of additional consideration or compensation, the person -associating CC0 with a Work (the "Affirmer"), to the extent that he or she -is an owner of Copyright and Related Rights in the Work, voluntarily -elects to apply CC0 to the Work and publicly distribute the Work under its -terms, with knowledge of his or her Copyright and Related Rights in the -Work and the meaning and intended legal effect of CC0 on those rights. - -1. Copyright and Related Rights. A Work made available under CC0 may be -protected by copyright and related or neighboring rights ("Copyright and -Related Rights"). Copyright and Related Rights include, but are not -limited to, the following: - - i. the right to reproduce, adapt, distribute, perform, display, - communicate, and translate a Work; - ii. moral rights retained by the original author(s) and/or performer(s); -iii. publicity and privacy rights pertaining to a person's image or - likeness depicted in a Work; - iv. rights protecting against unfair competition in regards to a Work, - subject to the limitations in paragraph 4(a), below; - v. rights protecting the extraction, dissemination, use and reuse of data - in a Work; - vi. database rights (such as those arising under Directive 96/9/EC of the - European Parliament and of the Council of 11 March 1996 on the legal - protection of databases, and under any national implementation - thereof, including any amended or successor version of such - directive); and -vii. other similar, equivalent or corresponding rights throughout the - world based on applicable law or treaty, and any national - implementations thereof. - -2. Waiver. To the greatest extent permitted by, but not in contravention -of, applicable law, Affirmer hereby overtly, fully, permanently, -irrevocably and unconditionally waives, abandons, and surrenders all of -Affirmer's Copyright and Related Rights and associated claims and causes -of action, whether now known or unknown (including existing as well as -future claims and causes of action), in the Work (i) in all territories -worldwide, (ii) for the maximum duration provided by applicable law or -treaty (including future time extensions), (iii) in any current or future -medium and for any number of copies, and (iv) for any purpose whatsoever, -including without limitation commercial, advertising or promotional -purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each -member of the public at large and to the detriment of Affirmer's heirs and -successors, fully intending that such Waiver shall not be subject to -revocation, rescission, cancellation, termination, or any other legal or -equitable action to disrupt the quiet enjoyment of the Work by the public -as contemplated by Affirmer's express Statement of Purpose. - -3. Public License Fallback. Should any part of the Waiver for any reason -be judged legally invalid or ineffective under applicable law, then the -Waiver shall be preserved to the maximum extent permitted taking into -account Affirmer's express Statement of Purpose. In addition, to the -extent the Waiver is so judged Affirmer hereby grants to each affected -person a royalty-free, non transferable, non sublicensable, non exclusive, -irrevocable and unconditional license to exercise Affirmer's Copyright and -Related Rights in the Work (i) in all territories worldwide, (ii) for the -maximum duration provided by applicable law or treaty (including future -time extensions), (iii) in any current or future medium and for any number -of copies, and (iv) for any purpose whatsoever, including without -limitation commercial, advertising or promotional purposes (the -"License"). The License shall be deemed effective as of the date CC0 was -applied by Affirmer to the Work. Should any part of the License for any -reason be judged legally invalid or ineffective under applicable law, such -partial invalidity or ineffectiveness shall not invalidate the remainder -of the License, and in such case Affirmer hereby affirms that he or she -will not (i) exercise any of his or her remaining Copyright and Related -Rights in the Work or (ii) assert any associated claims and causes of -action with respect to the Work, in either case contrary to Affirmer's -express Statement of Purpose. - -4. Limitations and Disclaimers. - - a. No trademark or patent rights held by Affirmer are waived, abandoned, - surrendered, licensed or otherwise affected by this document. - b. Affirmer offers the Work as-is and makes no representations or - warranties of any kind concerning the Work, express, implied, - statutory or otherwise, including without limitation warranties of - title, merchantability, fitness for a particular purpose, non - infringement, or the absence of latent or other defects, accuracy, or - the present or absence of errors, whether or not discoverable, all to - the greatest extent permissible under applicable law. - c. Affirmer disclaims responsibility for clearing rights of other persons - that may apply to the Work or any use thereof, including without - limitation any person's Copyright and Related Rights in the Work. - Further, Affirmer disclaims responsibility for obtaining any necessary - consents, permissions or other rights required for any use of the - Work. - d. Affirmer understands and acknowledges that Creative Commons is not a - party to this document and has no duty or obligation with respect to - this CC0 or use of the Work. +MIT License + +Copyright (c) 2024 Overrun Organization + +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. diff --git a/README.md b/README.md index 22c9291..cfd39e1 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,3 @@ -# Example Project +# OpenGL Garbage Collector -This is an example project. - -You can change the options in gradle.properties and build.gradle.kts. - -You can use this template by clicking "Use this template" or download ZIP. +This library provides a garbage collector for OpenGL. diff --git a/build.gradle.kts b/build.gradle.kts index 40c91dd..6c8f401 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -31,9 +31,10 @@ val jdkEnablePreview: String by rootProject val jdkEarlyAccessDoc: String? by rootProject val targetJavaVersion = jdkVersion.toInt() +val overrunglVersion: String by rootProject val projDevelopers = arrayOf( - Developer("example") + Developer("squid233") ) data class Organization( @@ -77,7 +78,7 @@ version = projVersion repositories { mavenCentral() // snapshot repositories - //maven("https://s01.oss.sonatype.org/content/repositories/snapshots") + maven("https://s01.oss.sonatype.org/content/repositories/snapshots") //maven("https://oss.sonatype.org/content/repositories/snapshots") //maven("https://s01.oss.sonatype.org/content/repositories/releases") @@ -86,6 +87,10 @@ repositories { dependencies { // add your dependencies + implementation(platform("io.github.over-run:overrungl-bom:$overrunglVersion")) + implementation("io.github.over-run:overrungl") + implementation("io.github.over-run:overrungl-opengl") + implementation("io.github.over-run:marshal:0.1.0-alpha.24-jdk22") // todo } tasks.withType { @@ -234,6 +239,7 @@ if (hasPublication.toBoolean() && publicationRepo != null) { else publicationRepo.releaseRepo ) } + mavenLocal() } signing { diff --git a/gradle.properties b/gradle.properties index 49cf0d1..6433cef 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,35 +1,37 @@ # Gradle Options org.gradle.jvmargs=-Dfile.encoding=UTF-8 -hasPublication=false -publicationSigning=false +hasPublication=true +publicationSigning=true -hasJavadocJar=false -hasSourcesJar=false +hasJavadocJar=true +hasSourcesJar=true # Project Information -projGroupId=org.example -projArtifactId=example +projGroupId=io.github.over-run +projArtifactId=glgc # The project name should only contain lowercase letters, numbers and hyphen. -projName=project-template +projName=glgc projVersion=0.1.0-SNAPSHOT -projDesc=An example project. +projDesc=OpenGL Garbage Collector # Uncomment them if you want to publish to maven repository. #projUrl=https://github.com/Over-Run/project-template #projLicenseUrl=https://raw.githubusercontent.com/Over-Run/project-template/main/LICENSE #projScmConnection=scm:git:https://github.com/Over-Run/project-template.git #projScmUrl=https://github.com/Over-Run/project-template.git -projLicense=CC0-1.0 +projLicense=MIT projLicenseFileName=LICENSE # Organization Information -orgName=Example -orgUrl=https://example.org/ +orgName=Overrun Organization +orgUrl=https://over-run.github.io/ # JDK Options -jdkVersion=21 -jdkEnablePreview=false +jdkVersion=22 +jdkEnablePreview=true # javadoc link of JDK early access build # https://download.java.net/java/early_access/$jdkEarlyAccessDoc/docs/api/ # Uncomment it if you need to use EA build of JDK. #jdkEarlyAccessDoc=jdk22 + +overrunglVersion=0.1.0-SNAPSHOT diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java new file mode 100644 index 0000000..c49ebaf --- /dev/null +++ b/src/main/java/module-info.java @@ -0,0 +1,26 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +/** + * OpenGL Garbage Collector + * + * @author squid233 + * @since 0.1.0 + */ +module io.github.overrun.glgc { + exports overrun.glgc; + requires overrungl.opengl; +} diff --git a/src/main/java/org/example/Main.java b/src/main/java/org/example/Main.java deleted file mode 100644 index c34d46a..0000000 --- a/src/main/java/org/example/Main.java +++ /dev/null @@ -1,13 +0,0 @@ -package org.example; - -/** - * An example - * - * @author You - * @since 0.1.0 - */ -public class Main { - public static void main(String[] args) { - System.out.println("Hello world"); - } -} diff --git a/src/main/java/overrun/glgc/GLObject.java b/src/main/java/overrun/glgc/GLObject.java new file mode 100644 index 0000000..34063e8 --- /dev/null +++ b/src/main/java/overrun/glgc/GLObject.java @@ -0,0 +1,36 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +package overrun.glgc; + +/** + * An OpenGL object. + * + * @author squid233 + * @since 0.1.0 + */ +public interface GLObject extends AutoCloseable { + /** + * {@return the id of this object} + */ + int id(); + + /** + * Disposes this object. + */ + @Override + void close(); +} diff --git a/src/main/java/overrun/glgc/Program.java b/src/main/java/overrun/glgc/Program.java new file mode 100644 index 0000000..62ee449 --- /dev/null +++ b/src/main/java/overrun/glgc/Program.java @@ -0,0 +1,65 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +package overrun.glgc; + +import overrungl.opengl.GL20C; + +import java.lang.ref.Cleaner; + +/** + * The OpenGL program. + * + * @author squid233 + * @since 0.1.0 + */ +public final class Program implements GLObject { + private static final Cleaner CLEANER = Cleaner.create(); + private final State state; + private final Cleaner.Cleanable cleanable; + + private Program(GL20C gl, int id) { + this.state = new State(gl, id); + this.cleanable = CLEANER.register(this, state); + } + + private record State(GL20C gl, int id) implements Runnable { + @Override + public void run() { + gl.deleteProgram(id); + } + } + + /** + * Creates an OpenGL program with {@link GL20C#createProgram()}. + * + * @param gl the OpenGL context + * @return the OpenGL program + */ + public static Program create(GL20C gl) { + return new Program(gl, gl.createProgram()); + } + + @Override + public int id() { + return state.id(); + } + + @Override + public void close() { + cleanable.clean(); + } +} diff --git a/src/main/java/overrun/glgc/Shader.java b/src/main/java/overrun/glgc/Shader.java new file mode 100644 index 0000000..44c721d --- /dev/null +++ b/src/main/java/overrun/glgc/Shader.java @@ -0,0 +1,66 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +package overrun.glgc; + +import overrungl.opengl.GL20C; + +import java.lang.ref.Cleaner; + +/** + * The OpenGL shader. + * + * @author squid233 + * @since 0.1.0 + */ +public final class Shader implements GLObject { + private static final Cleaner CLEANER = Cleaner.create(); + private final State state; + private final Cleaner.Cleanable cleanable; + + private Shader(GL20C gl, int id) { + this.state = new State(gl, id); + this.cleanable = CLEANER.register(this, state); + } + + private record State(GL20C gl, int id) implements Runnable { + @Override + public void run() { + gl.deleteShader(id); + } + } + + /** + * Creates an OpenGL shader with {@link GL20C#createShader(int)}. + * + * @param gl the OpenGL context + * @param type the shader type + * @return the OpenGL shader + */ + public static Shader create(GL20C gl, int type) { + return new Shader(gl, gl.createShader(type)); + } + + @Override + public int id() { + return state.id(); + } + + @Override + public void close() { + cleanable.clean(); + } +} diff --git a/src/main/java/overrun/glgc/Texture.java b/src/main/java/overrun/glgc/Texture.java new file mode 100644 index 0000000..8657489 --- /dev/null +++ b/src/main/java/overrun/glgc/Texture.java @@ -0,0 +1,78 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +package overrun.glgc; + +import overrungl.opengl.GL11C; +import overrungl.opengl.GL45C; + +import java.lang.ref.Cleaner; + +/** + * The OpenGL texture. + * + * @author squid233 + * @since 0.1.0 + */ +public final class Texture implements GLObject { + private static final Cleaner CLEANER = Cleaner.create(); + private final State state; + private final Cleaner.Cleanable cleanable; + + private Texture(GL11C gl, int id) { + this.state = new State(gl, id); + this.cleanable = CLEANER.register(this, state); + } + + private record State(GL11C gl, int id) implements Runnable { + @Override + public void run() { + gl.deleteTextures(id); + } + } + + /** + * Generates an OpenGL texture with {@link GL11C#genTextures()}. + * + * @param gl the OpenGL context + * @return the OpenGL texture + */ + public static Texture gen(GL11C gl) { + return new Texture(gl, gl.genTextures()); + } + + /** + * Creates an OpenGL texture with {@link GL45C#createTextures(int)}. + * + * @param gl the OpenGL context + * @param target the texture target + * @param the OpenGL context type + * @return the OpenGL texture + */ + public static Texture create(T gl, int target) { + return new Texture(gl, gl.createTextures(target)); + } + + @Override + public int id() { + return state.id(); + } + + @Override + public void close() { + cleanable.clean(); + } +} diff --git a/src/main/java/overrun/glgc/VAO.java b/src/main/java/overrun/glgc/VAO.java new file mode 100644 index 0000000..965b73c --- /dev/null +++ b/src/main/java/overrun/glgc/VAO.java @@ -0,0 +1,77 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +package overrun.glgc; + +import overrungl.opengl.GL30C; +import overrungl.opengl.GL45C; + +import java.lang.ref.Cleaner; + +/** + * The OpenGL vertex array object. + * + * @author squid233 + * @since 0.1.0 + */ +public final class VAO implements GLObject { + private static final Cleaner CLEANER = Cleaner.create(); + private final State state; + private final Cleaner.Cleanable cleanable; + + private VAO(GL30C gl, int id) { + this.state = new State(gl, id); + this.cleanable = CLEANER.register(this, state); + } + + private record State(GL30C gl, int id) implements Runnable { + @Override + public void run() { + gl.deleteVertexArrays(id); + } + } + + /** + * Generates an OpenGL vertex array object with {@link GL30C#genVertexArrays()}. + * + * @param gl the OpenGL context + * @return the OpenGL vertex array object + */ + public static VAO gen(GL30C gl) { + return new VAO(gl, gl.genVertexArrays()); + } + + /** + * Creates an OpenGL vertex array object with {@link GL45C#createVertexArrays()}. + * + * @param gl the OpenGL context + * @param the OpenGL context type + * @return the OpenGL vertex array object + */ + public static VAO create(T gl) { + return new VAO(gl, gl.createVertexArrays()); + } + + @Override + public int id() { + return state.id(); + } + + @Override + public void close() { + cleanable.clean(); + } +} diff --git a/src/main/java/overrun/glgc/VBO.java b/src/main/java/overrun/glgc/VBO.java new file mode 100644 index 0000000..01e3322 --- /dev/null +++ b/src/main/java/overrun/glgc/VBO.java @@ -0,0 +1,77 @@ +/* + * MIT License + * + * Copyright (c) 2024 Overrun Organization + * + * 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. + */ + +package overrun.glgc; + +import overrungl.opengl.GL15C; +import overrungl.opengl.GL45C; + +import java.lang.ref.Cleaner; + +/** + * The OpenGL vertex buffer object. + * + * @author squid233 + * @since 0.1.0 + */ +public final class VBO implements GLObject { + private static final Cleaner CLEANER = Cleaner.create(); + private final State state; + private final Cleaner.Cleanable cleanable; + + private VBO(GL15C gl, int id) { + this.state = new State(gl, id); + this.cleanable = CLEANER.register(this, state); + } + + private record State(GL15C gl, int id) implements Runnable { + @Override + public void run() { + gl.deleteBuffers(id); + } + } + + /** + * Generates an OpenGL vertex buffer object with {@link GL15C#genBuffers()}. + * + * @param gl the OpenGL context + * @return the OpenGL vertex buffer object + */ + public static VBO gen(GL15C gl) { + return new VBO(gl, gl.genBuffers()); + } + + /** + * Creates an OpenGL vertex buffer object with {@link GL45C#createBuffers()}. + * + * @param gl the OpenGL context + * @param the OpenGL context type + * @return the OpenGL vertex buffer object + */ + public static VBO create(T gl) { + return new VBO(gl, gl.createBuffers()); + } + + @Override + public int id() { + return state.id(); + } + + @Override + public void close() { + cleanable.clean(); + } +}