Java-Gaming.org Hi !
Featured games (91)
games approved by the League of Dukes
Games in Showcase (807)
Games in Android Showcase (239)
games submitted by our members
Games in WIP (872)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: 1 ... 215 216 [217]
  ignore  |  Print  
  What I did today  (Read 3746250 times)
0 Members and 5 Guests are viewing this topic.
Offline buddyBro
« Reply #6480 - Posted 2020-04-23 17:18:11 »

Spent way too much time trying to make a super simple animation  Tongue
I'm not artsy  Clueless
Click to Play

Click to Play
Offline buddyBro
« Reply #6481 - Posted 2020-04-25 18:55:45 »

I taught it to fly  Shocked

Click to Play
Offline KaiHH

JGO Kernel


Medals: 819



« Reply #6482 - Posted 2020-04-28 17:54:47 »

This was not really something which I _did_, apart from accepting yet another pull request for JOML which fixes a bug introduced by trusting Eclipse's method invocation inline refactor. Ever since I did some inlining of some methods in JOML's classes, bug reports and pull requests are pouring in which fix obvious errors.
And the reason in all such cases was the use of Eclipse's (Shift+Alt+I) method call inlining which I did to many methods in order to reduce the call depth.
Take for example this simplified class:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
public class Vector2f {
  public float x, y;
  public Vector2f perpendicular() {
    return this.set(y, -x);
  }
  private Vector2f set(float x, float y) {
    this.x = x;
    this.y = y;
    return this;
  }
}

Now inline the `this.set(y, -x)` invocation. This will result in this new and totally buggy implementation:
1  
2  
3  
4  
5  
  public Vector2f perpendicular() {
    this.x = y; // <- set this.x
    this.y = -x; // <- read the updated this.x, which is this.y now!
    return this;
  }

So, Eclipse's method call inlining did not take into account that Java's call convention is by-value, first evaluating the call arguments and _then_ using them to set the fields. So, in order to inline this call, we actually _need_ a temporary variable here!
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline yboya
« Reply #6483 - Posted 2020-04-28 18:35:31 »

I am not sure there is much gain in inlining methods with java. Modern processors and/or compilers are so performing, that one more indirection will not affect much program speed.
Offline KaiHH

JGO Kernel


Medals: 819



« Reply #6484 - Posted 2020-04-28 18:46:23 »

The goal here was to keep the call depth as shallow as possible, to not reach the JVM's default inlining threshold in client code, which would likely have avoided escape analysis to identify that the called vector instance does not escape and therefore allowing scalar replacement to avoid Vector2f allocations altogether in client code.
It is true that there are two thresholds to consider here:
- C2 inline depth threshold; and:
- C2 frequent/hot method bytecode length
which are both at play to in the end avoid escape analysis and scalar replacement in client code. However, in this case with a very small method, it is more likely to hit the call depth threshold first, which made manually inlining this more worthwhile to make escape analysis in client code more likely to happen.
And that actually makes a HUGE difference in performance.
There is much more to inlining in modern JVMs and the further optimizations that it enables than initially meets the eye. But you are right, method call dispatch performance was not the concern here.
Offline Ali-RS

Junior Devvie


Medals: 17
Projects: 1


Java Game Developer & Korean Drama Fan


« Reply #6485 - Posted 2020-04-29 10:54:06 »

And this time working on a collision shape editor using jMonkeyEngine Smiley

<a href="http://www.youtube.com/v/X2rCEStGD1U?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/X2rCEStGD1U?version=3&amp;hl=en_US&amp;start=</a>

Offline buddyBro
« Reply #6486 - Posted 2020-04-30 22:38:58 »

I made a kitty for our flying buddy to play with Tongue

Click to Play


My model editor:

Click to Play
Offline elect

JGO Ninja


Medals: 81



« Reply #6487 - Posted 2020-05-04 15:43:23 »

Imgui Docking branch available for testing

Click to Play


https://github.com/kotlin-graphics/imgui/issues/140

I would have posted in the imgui thread, but apparently if you dont write often in a thread, you cant reply anymore..

crap policy for tools area, I hope we can move the forum asap
Offline philfrei
« Reply #6488 - Posted 2020-05-05 00:12:45 »

Good one, @Gjallar, figuring out how to reopen the thread for @elect!
Thanks.

What have I done today (so far, as long as I am here)?

An extra credit lab assignment pertaining iptables on an Ubuntu VM. (Taking a class on CyberSecurity for Web Applications at SF City College. Finals are next week, and I probably need mucho extra credit to ensure my "A" if the final is at all challenging.)

A tutorial on Docker. Started [urlhttps://github.com/docker/labs/blob/master/beginner/chapters/alpine.md]here[/url], and am half way through part 2. This is quality writing as far as I am concerned (from the beginner's perspective). Nice walk-throughs and explanations AND the author takes the time to clean up afterwards. So many tutorials: they tell you how to DO things but not how to STOP or UNDO or cleanup afterwards.

Monkey brains: always focused on the Yang and forgetting about the Yin.

Speaking of brains, if I have any left by the end of the day, I'll get back to my current JavaFX program/problem. Saving the best for last.

music and music apps: http://adonax.com
Offline buddyBro
« Reply #6489 - Posted 2020-05-09 20:55:17 »

The dude's got a stick, but you've got a laser  Wink
Click to Play


Here's an earlier animation test with black outlines, let me know if it looks better than the white outlines

Click to Play
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline VaTTeRGeR
« Reply #6490 - Posted 2020-05-09 21:08:09 »

@buddyBro I would prefer black as it gives the model more perceived depth and doesn't distract from the base colors as much. This also highly depends on the background color IMO.
Offline buddyBro
« Reply #6491 - Posted 2020-05-12 15:26:13 »

Fiddling with my attempt at grass. At the moment, I'm not sure which directinon to pursue?  Undecided Clueless Huh

A billboards approach looks weird when the cammera is looking down
Click to Play

Click to Play

Click to Play


And a volume approach looks weird when the camera is looking horizontal.
Click to Play

Click to Play

Click to Play


There's room for tweaking both approaches, so this is less of a 'which looks better in their current state', and more of a which would be worth pursuing further' kind of dilema.
At the moment, I'm leaning towards the billboard approach, though it's can only render so many blades due to performance; unlike the volume sliced implementation.

Meanwhile, also changed the outlines to black and added a background gradiant.

Edit, Replying here to avoid spamming this topic:

> Second approach with transparency gradient toward the top?

The last gif (6th) does have an alpha gradiant. Each layer has alpha .2, I believe; bottom layers look more opaque because they're compouned with the layers above. The transparancy is apparent when looking at the grass in front of the blue character. Is that what you're suggesting, or am I misunderstanding?
Offline elect

JGO Ninja


Medals: 81



« Reply #6492 - Posted 2020-05-13 12:27:34 »

Second approach with transparency gradient toward the top?
Offline Ali-RS

Junior Devvie


Medals: 17
Projects: 1


Java Game Developer & Korean Drama Fan


« Reply #6493 - Posted 2020-05-13 13:59:53 »

Testing character pathfinding & physics

Character rotation on waypoints is not smoothed out yet and no animation is applied to the character.

<a href="http://www.youtube.com/v/JaxeD2VFfUE?version=3&amp;hl=en_US&amp;start=" target="_blank">http://www.youtube.com/v/JaxeD2VFfUE?version=3&amp;hl=en_US&amp;start=</a>

Offline buddyBro
« Reply #6494 - Posted 2020-05-15 16:00:18 »

I'm failing horribly at getting things to feel and look right. Cry
Reminds of the time when I was tasked with creating a visual debug tool. Despite how many hours I tried to make it intuitive and elegant, it was just off. Then I showed it to our UX; after a quick discussion, he drew up a mock in 10 minutes. It was just minor tweaks and rearrangements and took a few hours to implement the changes, but the improvement was night and day.
Perhaps I should pause coding and look into some sort of tutorial on how to make things aesthetically pleasing.
Click to Play
Offline VaTTeRGeR
« Reply #6495 - Posted 2020-05-15 17:47:17 »

@buddyBro The only real nasty sin i see there are the status bars being too small, very close to each other and lacking in contrast. There is no way you could keep track of them while in combat. And even worse is that they have no identification symbol and no special shape that tells the player what the individual bars mean.

Edit: Have a look at Left 4 dead 2s GUI for a real positive example that would also work for your game, i think you can basically steal their layout and be good.
Offline Guerra2442

JGO Knight


Medals: 94
Exp: 4 years


Guerra24


« Reply #6496 - Posted 2020-05-16 02:35:15 »

Implemented ray march AO for fun, not optimized in any way. Running at full res 16 samples with only TAA for denoising, can be improved.

No AO, very basic SSAO (that is barely noticeable), ray march AO.




Working on Anarchy Engine.
Offline KaiHH

JGO Kernel


Medals: 819



« Reply #6497 - Posted 2020-05-18 15:46:15 »

Gave the current Panama vectorIntrinsics branch another shot, and it looks like it's finally getting somewhere promising:
Simple test code:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
import static jdk.incubator.vector.FloatVector.SPECIES_128;
import static jdk.incubator.vector.FloatVector.fromArray;
public class Matrix4fv {
    private final float[] es = new float[16];
    public Matrix4fv add(Matrix4fv other) {
        for (int i = 0; i < 4; i++) {
            fromArray(SPECIES_128, es, i<<2)
                    .add(fromArray(SPECIES_128, other.es, i<<2))
                    .intoArray(es, i<<2);
        }
        return this;
    }
}

and the current scalar version for comparison:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
public class Matrix4f {
    float m00, m01, m02, m03;
    float m10, m11, m12, m13;
    float m20, m21, m22, m23;
    float m30, m31, m32, m33;
    public Matrix4f add(Matrix4f other) {
        m00 = m00 + other.m00;
        m01 = m01 + other.m01;
        m02 = m02 + other.m02;
        m03 = m03 + other.m03;
        m10 = m10 + other.m10;
        m11 = m11 + other.m11;
        m12 = m12 + other.m12;
        m13 = m13 + other.m13;
        m20 = m20 + other.m20;
        m21 = m21 + other.m21;
        m22 = m22 + other.m22;
        m23 = m23 + other.m23;
        m30 = m30 + other.m30;
        m31 = m31 + other.m31;
        m32 = m32 + other.m32;
        m33 = m33 + other.m33;
        return this;
    }
}

JMH benchmark:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.concurrent.TimeUnit;
@State(Scope.Benchmark)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 8, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@BenchmarkMode(Mode.AverageTime)
public class Bench {
    private final Matrix4f m4 = new Matrix4f();
    private final Matrix4fv m4v = new Matrix4fv();
    @Benchmark
    public void vector() {
        m4v.add(m4v);
    }
    @Benchmark
    public void scalar() {
        m4.add(m4);
    }
    public static void main(String[] args) throws Exception {
        new Runner(new OptionsBuilder()
                .include(Bench.class.getName())
                .forks(1)
                .jvmArgsAppend("--add-modules=jdk.incubator.vector",
                               "-Djdk.incubator.vector.VECTOR_ACCESS_OOB_CHECK=0")
                .build()).run();
    }
}

Results:
1  
2  
3  
Benchmark     Mode  Cnt  Score   Error  Units
Bench.scalar  avgt    8  5.421 ± 0.029  ns/op
Bench.vector  avgt    8  2.539 ± 0.025  ns/op
Offline princec

« JGO Spiffy Duke »


Medals: 1146
Projects: 3
Exp: 20 years


Eh? Who? What? ... Me?


« Reply #6498 - Posted 2020-05-18 16:00:23 »

Oooh, not bad - a doubling in performance is never to be sniffed at. How long before it reaches the JDK proper?

Cas Smiley

Offline KaiHH

JGO Kernel


Medals: 819



« Reply #6499 - Posted 2020-05-18 16:16:45 »

The two projects (Panama, Valhalla) and their sub-projects/goals (Panama: Vector API + native interop; Valhalla: value/inline types + generics specialization) are so intertwined and likely want to integrate with one another well and they are constantly changing things (especially in Panama) which are so very deep at the core bottom of things and they remove/add Vector API methods constantly, so the API is anywhere except stable, let alone optimized... that I personally don't expect general availability of it within the next three years or so, also given the time span they already work on it.
Also, in order to shape the future JOML 2.0 I need to know whether Panama Vector API will hit the shelves before inline types do or whether both happen at the same time, making the whole "operation modifies this" semantics then completely obsolete and JOML objects can finally behave as mathematical identity-less value objects, as they always should have. But if Vector API will be available well before inline types are, then it makes sense to add another matrix/vector class implementation using float[16] arrays as backing store and port all operations to the Vector API.

EDIT: Now, when doing anything a bit more complicated than a simple add(), then performance breaks down horribly Smiley
This:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
/**
 * https://stackoverflow.com/questions/18499971/efficient-4x4-matrix-multiplication-c-vs-assembly#answer-18508113
 */

public Matrix4fv mul(Matrix4fv o) {
    FloatVector row1 = FloatVector.fromArray(SPECIES_128, o.es, 0);
    FloatVector row2 = FloatVector.fromArray(SPECIES_128, o.es, 4);
    FloatVector row3 = FloatVector.fromArray(SPECIES_128, o.es, 8);
    FloatVector row4 = FloatVector.fromArray(SPECIES_128, o.es, 12);
    for (int i = 0; i < 4; i++) {
        FloatVector r = FloatVector.fromArray(SPECIES_128, es, 4*i);
        FloatVector brod1 = FloatVector.broadcast(SPECIES_128, r.lane(0));
        FloatVector brod2 = FloatVector.broadcast(SPECIES_128, r.lane(1));
        FloatVector brod3 = FloatVector.broadcast(SPECIES_128, r.lane(2));
        FloatVector brod4 = FloatVector.broadcast(SPECIES_128, r.lane(3));
        brod1.fma(row1, brod2.fma(row2, brod3.fma(row3, brod4.mul(row4)))).intoArray(es, 4*i);
    }
    return this;
}

takes 200 ns/op, whereas the straight-forward scalar version in JOML takes ~14ns/op....

EDIT2: Got it down to ~22 ns/op with:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
private static final VectorShuffle<Float> s0 = VectorShuffle.fromValues(SPECIES_128, 0, 0, 0, 0);
private static final VectorShuffle<Float> s1 = VectorShuffle.fromValues(SPECIES_128, 1, 1, 1, 1);
private static final VectorShuffle<Float> s2 = VectorShuffle.fromValues(SPECIES_128, 2, 2, 2, 2);
private static final VectorShuffle<Float> s3 = VectorShuffle.fromValues(SPECIES_128, 3, 3, 3, 3);
public Matrix4fv mul(Matrix4fv o) {
    FloatVector row1 = FloatVector.fromArray(SPECIES_128, o.es, 0);
    FloatVector row2 = FloatVector.fromArray(SPECIES_128, o.es, 4);
    FloatVector row3 = FloatVector.fromArray(SPECIES_128, o.es, 8);
    FloatVector row4 = FloatVector.fromArray(SPECIES_128, o.es, 12);
    for (int i = 0; i < 4; i++) {
        FloatVector r = FloatVector.fromArray(SPECIES_128, es, 4*i);
        r.rearrange(s0).mul(row1)
         .add(r.rearrange(s1).mul(row2))
         .add(r.rearrange(s2).mul(row3))
         .add(r.rearrange(s3).mul(row4))
         .intoArray(es, 4*i);
    }
    return this;
}

This is sooo fragile and finnicky. So rearrange(VectorShuffle) compiles to alot faster code than broadcast(lane()). Also now inlining s0-s3 will get us to ~100ns/op again.
Offline orange451

JGO Kernel


Medals: 571
Projects: 9
Exp: 8 years


Your face? Your ass? What's the difference?


« Reply #6500 - Posted 2020-05-18 23:28:20 »

Nothing crazy, just updated the default button style in LWJGUI light theme


First Recon. A java made online first person shooter!
Offline FabulousFell

Junior Devvie


Medals: 6



« Reply #6501 - Posted 2020-05-19 21:58:45 »

I went to my local vintage video game store and got 2 sonic games for PC.  I need Windows 95 or a DOS box.  I'm gonna try to install windows 95 on an old computer, just to see if I can.
Offline orange451

JGO Kernel


Medals: 571
Projects: 9
Exp: 8 years


Your face? Your ass? What's the difference?


« Reply #6502 - Posted 2020-05-20 06:38:41 »

Added a nicer insert gui in AnarchyEngine


Click to Play

First Recon. A java made online first person shooter!
Offline Guerra2442

JGO Knight


Medals: 94
Exp: 4 years


Guerra24


« Reply #6503 - Posted 2020-05-20 22:48:06 »

Implemented ray march screen-space global illumination using the same code from the AO, which I've also improved.

Debug view, missing hit depth and normal checks.


Final look.


Added depth check to AO, fixed color calculation. (Before, After)


I need a blur/denoise pass asap.

Working on Anarchy Engine.
Offline KaiHH

JGO Kernel


Medals: 819



« Reply #6504 - Posted 2020-05-21 18:22:28 »

Changed the backing data store of the matrix from float array to a direct ByteBuffer (so we can hand the matrix to native libraries like OpenGL with zero-copy!) and runtime of the following code was ~33ns/op. So, I built the hsdis library from the panama vectorIntrinsics branch and analyzed why the following code performs worse than simple scalar multiplication followed by sun.misc.Unsafe puts of the float members into a ByteBuffer:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
private static final VectorShuffle<Float> s0 = SPECIES_128.shuffleFromValues(0, 0, 0, 0);
private static final VectorShuffle<Float> s1 = SPECIES_128.shuffleFromValues(1, 1, 1, 1);
private static final VectorShuffle<Float> s2 = SPECIES_128.shuffleFromValues(2, 2, 2, 2);
private static final VectorShuffle<Float> s3 = SPECIES_128.shuffleFromValues(3, 3, 3, 3);

private final ByteBuffer es = ByteBuffer.allocateDirect(16*4).order(ByteOrder.nativeOrder());

public Matrix4fv mul(Matrix4fv o) {
    FloatVector row1 = FloatVector.fromByteBuffer(SPECIES_128, o.es, 0, n);
    FloatVector row2 = FloatVector.fromByteBuffer(SPECIES_128, o.es, 16, n);
    FloatVector row3 = FloatVector.fromByteBuffer(SPECIES_128, o.es, 32, n);
    FloatVector row4 = FloatVector.fromByteBuffer(SPECIES_128, o.es, 48, n);
    for (int i = 0; i < 4; i++) {
        FloatVector r = FloatVector.fromByteBuffer(SPECIES_128, es, i<<4, n);
        r.rearrange(s0).fma(row1,
        r.rearrange(s1).fma(row2,
        r.rearrange(s2).fma(row3,
        r.rearrange(s3).mul(row4))))
         .intoByteBuffer(es, i<<4, n);
    }
    return this;
}

It all comes down to a TON of index and other validation checks for FloatVector.rearrange() and fromByteBuffer/intoByteBuffer calls (even in C2). Java really wants to be save here and obviously not crash with a hardware exception, instead of generating high-performance code. Yes, there is this JVM property that you can set to eliminate out-of-bounds checks, but that does not disable every check. So, I guess, if you want really fast SIMD code, the JVM is not the platform of choice; or you patch the JDK classes and remove all index checks. Smiley
The latter is certainly doable by the way and the JDK build process has become ridiculously simple: `bash configure` (once) and then `make images`.
The other thing that hampers performance severly is the fact that the Vector API uses runtime values "vector species" to decide at runtime which kind of vector you are operating on. A 128, 256 or 512 bit vector. This species information is dragged through all calls and evaluated whenever a native intrinsic is to be called, which can also be seen in the disassembly. You cannot say: Here, this is a Float128Vector (this class is package-private in the JDK and selected based on the "species" at runtime). This is stupid. Maybe the compiler will take care of this in the future by eliminating values that it knows are constant at the callsite.
There is also a nice comment on the vspecies() method which is called to know the "species" of a runtime vector instance:
1  
2  
3  
4  
5  
6  
public FloatSpecies vspecies() {
    // ISSUE:  This should probably be a @Stable
    // field inside AbstractVector, rather than
    // a megamorphic method.
    return VSPECIES;
}

YES?!

After I eliminated all rearrange and fromByteBuffer/toByteBuffer index checks in the JDK's source of FloatVector, runtime got down from ~33 ns/op for this ByteBuffer backed method to ~16ns/op, making it faster than the float-field-based scalar version storing into ByteBuffer at the end (which was ~23 ns/op).

EDIT: When using an AVX version of a 4x4 multiply from https://stackoverflow.com/questions/19806222/matrix-vector-multiplication-in-avx-not-proportionately-faster-than-in-sse#answer-46058667 then speedup is even greater. Also, without any index checks, an equivalent Java Vector API code gets the read-from-direct-bytebuffer + 4x4 multiply + store-into-direct-bytebuffer in ~11 ns/op.
Super-fast multiplication:
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
public Matrix4fv mul256(Matrix4fv o) {
    FloatVector t0 = FloatVector.fromByteBuffer(SPECIES_256, es, 0, n),
                t1 = FloatVector.fromByteBuffer(SPECIES_256, es, 32, n);
    FloatVector u0 = FloatVector.fromByteBuffer(SPECIES_256, o.es, 0, n),
                u1 = FloatVector.fromByteBuffer(SPECIES_256, o.es, 32, n);
    t0.rearrange(s4)
      .fma(u0.rearrange(s5), t0.rearrange(s6).mul(u0.rearrange(s7)))
      .add(t0.rearrange(s9).fma(u1.rearrange(s7), t0.rearrange(s8).mul(u1.rearrange(s5))))
      .intoByteBuffer(es, 0, n);
    t1.rearrange(s4)
      .fma(u0.rearrange(s5), t1.rearrange(s6).mul(u0.rearrange(s7)))
      .add(t1.rearrange(s9).fma(u1.rearrange(s7), t1.rearrange(s8).mul(u1.rearrange(s5))))
      .intoByteBuffer(es, 32, n);
    return this;
}
Offline KaiHH

JGO Kernel


Medals: 819



« Reply #6505 - Posted 2020-05-23 16:41:32 »

For anyone wanting to follow the performance of the Panama Vector API project, I've created a repo which I will update from time to time when significant changes happen to Panama's vectorIntrinsics branch: https://github.com/JOML-CI/panama-vector-bench
Pages: 1 ... 215 216 [217]
  ignore  |  Print  
 
 

 
Riven (843 views)
2019-09-04 15:33:17

hadezbladez (5777 views)
2018-11-16 13:46:03

hadezbladez (2597 views)
2018-11-16 13:41:33

hadezbladez (6195 views)
2018-11-16 13:35:35

hadezbladez (1494 views)
2018-11-16 13:32:03

EgonOlsen (4729 views)
2018-06-10 19:43:48

EgonOlsen (5779 views)
2018-06-10 19:43:44

EgonOlsen (3270 views)
2018-06-10 19:43:20

DesertCoockie (4171 views)
2018-05-13 18:23:11

nelsongames (5481 views)
2018-04-24 18:15:36
A NON-ideal modular configuration for Eclipse with JavaFX
by philfrei
2019-12-19 19:35:12

Java Gaming Resources
by philfrei
2019-05-14 16:15:13

Deployment and Packaging
by philfrei
2019-05-08 15:15:36

Deployment and Packaging
by philfrei
2019-05-08 15:13:34

Deployment and Packaging
by philfrei
2019-02-17 20:25:53

Deployment and Packaging
by mudlee
2018-08-22 18:09:50

Java Gaming Resources
by gouessej
2018-08-22 08:19:41

Deployment and Packaging
by gouessej
2018-08-22 08:04:08
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!