marcellperger1 / minecraft_clone_1 Goto Github PK

Use WebAssembly for better performance
because the vertex bundler is very bad performance in JavaScript so rewrite it in C++:
the renderer.renderFrame -> renderer.addWorldData ( -> addBlock -> addBlockTextures -> ...) takes up 95% of the performance!!

However this requires a LOT of work (learning emscripten, etc.)

Put all textures into one big texture atlas because then:

• don't need to switch out uniforms
• don't need batch drawing
• can do all the drawing in one call
• no switching uniforms required
• better performance

Back and right side of cube texture coordinates flipped in y axis.

More block types:

• Dirt
• Stone
• Wood (log/planks) ?

Separate folder for generated files so can just .gitignore that folder

This issue is for the bare minimum tests for deepMerge

Remove cube faces between 2 opaque blocks (sorta vertex culling??) for better performance

World class to keep track of blocks & support for different types of blocks - perhaps also serialization?

Movement vector (horizontal) needs to be normalized to length 1, then multiplied by speed.
This means that all movements in a frame need to be added up and controller.moveCamera needs to be called once with the normalized values.

The World class has a lot of closely related buffer methods.
These could be extracted (together with the data) into a separate class with

• those methods
• the buffers (name of buffer = attribute name)

The aforementioned methods could then be used by doing (where this is renderer):

• this.buffers.make or
• this.buffers.setData etc.

Rendering stops after vertical movement because player.position set to NaN

Config very messy right now, some global consts, some config classes.
Fix this by making one global config object

Tests for config_loader, including:

• Basic json loading
• Comments in json
• Config Class handling
• Inheritance handling
  • Comments in inheritance
  • Recursive inheritance ?!! (at least throw an error early!)
  • Everything inheriting from default
  • Correct merging
• Handles Symbol keys ( /values? )
• +/- Infinity as values

Fix the source map error (loading src/simplex-noise.ts)

The build workflow should commit the built texture atlas.

Deepcopy all Config attributes when merging Configs.
Also deepcopy:

• arrays
  • Objects within arrays: update or override
• what to do about wrapped primitives?? (probably just use unwrapped value)
• Functions? (or just assign) - wont be much of these in configs as they can't be in json

X axis is currently:

            ^
            |
           +Z
            |
            |
<-- +X ---- 0 --- -X -->
            |
            |
           -Z
            |
            v

But it would make more sense if it was:

            ^
            |
           +Z
            |
            |
<-- -X ---- 0 --- +X -->
            |
            |
           -Z
            |
            v

This is merely a visual bug

Default & current Config loading from JSON

Necessary

• Config loading
  • Determine correct class
  • File for current and default config (TODO current)
  • Use the loaded Configs instead of defaults in config.js

Useful

• Config storing perhaps
• Json with comments?

Textures of different blocks don't line up perfectly:

so you can see the things behind it in that gap

Sometimes when exiting pointerlock (by pressing Esc), the camera angle completely changes. Very hard to reproduce so very hard to fix.

The texture coords of bottom of face not quite right because the bottom face doesn't align perfectly with the sides.

Split world into separate chunks to enable

• Only re-rendering chunks that have changed
• Remaking the mesh of all chunks in different frames (so no huge lag-spikes)
• Chunk loading (infinite worlds)
• Biomes?

More tests for deepMerge, specifically:

• Returns correct class/prototype
  • Copying & merging
  • Weak prototype/constructor handling
• #96

Reproduce:

• Click on game
• Press and hold w
• Press Esc
• Release w
• You keeep moving until press and release w again

Fix:

• Un-press all keys when pointerlock changed to null

No .js files should be on root directory except main.js - even that shouldn't contain 10+lines
Possible new dirctory structure:

main.js
index.html
style.css
src/
    utils/
        ...
    input/
        ...
    renderer/
        renderer.js
        vertex_bundle.js
        [vertex_culling.js]
    game/
        ... (eg. world gen, level format)

Merge vRotMin and vRotMax into vRotRange

Add randomly placed trees.

How to get positions randomly

• Could use a PRNG to generate coordinates / index
  • How to do it forwards-compatibly / to make backwards-compatibility easier??

I should write some documentation eventually.
Especially for:

• Config stuff
• (Later) Where all the code is and project 'architecture' (low-ish prio)

Add a config for canvas size. There could be problems here:

• How to interact with styles from js?
• Should it really change canvas size at some point during loading

More configs for:

• world generation
• world size??

Use 1D list instead of a 3 deep nested list to store blocks in World class.
This is better because:

• Easier and simpler to create empty world (only no nested loop)
• More performant indexing
• Iterating over all blocks may be a little different but not much.

Load shaders asynchronously - sync is deprecated and results in slow website loading.

Some sort of 'inheritance' for configs (extends: ...)

• Handle extends attribute
• Values for extends attribute: default, others??
• (Perhaps?) multiple inheritance

Add transparent leaves (see dev-transparency branch).
This involves sorting the faces which I have implemented but WebGL doesn't appear to be behaving very well with it.

Nested Config structure would allow for a much more clearly structured Config object.
This would guarantee no clashes between different config entries with same name.

Add a new config for area around tree where there are no other trees.

Make a nodejs script to auto-generate texture atlas. Part of #23
Fixed with commit 2610ed6

Use octave noise for terrain generation

• Implement octave noise
• New Configs for octave noise (persistence/lancunarity?)
• One seed to generate all octaves
  • If seed is number
  • If seed is string

Make .github/workflows/
Make action on pull request / push to main

Use WebGL scissor to improve performance

Each block should be able to store some data:

Now

• Wood logs: direction

Later

• Container contents
• sign text
• etc.

Separate concerns of Renderer class. Should really have a global Game class with .renderer, .world, etc.
These should ideally be in separate directories.

Transparent favicon doesn't show up AT ALL on chrome & just can't get it to work

Also use getOwnPropertySymbols()

Progress bar for shader and texture loading (only start game once textures loaded)

Compile shaders asynchronously - then link shaders after both done.

Reasoning

Perhaps array items should be merged because if you have

{ objs: [ { v: 1, other: 9 } ] }

and

{ objs: [ { v: 2 } ] }

the output should surely be

{ objs: [ {v: 2, other: 9 } ] }

not

{ objs: [ { v: 2 } ] }

Implementation detail

Current value is array:

• If previous values was object, override it fully
• If previous value was array merge with it (use largest length)
  If previous value was array:
• If current value is object, override it fully

On the first frame of the game, r.deltaT is HUGE because r.now is set to 0 and not current time.
Solution:

• Initalise both r.now and r.then to null.
• On first frame, r.deltaT should be overridden to 0 and r.then should be set to current time.
• From next frame, everything can continue as normal.

Randomness

Using seedrandom (@davidbau/seedrandom)
What pseudo-random number generator to use?

World generation

Which noise to use?

• Perlin noise
• simplex noise
• other?