graphitemaster / neothyne Goto Github PK

Displacement and normal mapping fails on map models despite having correct world and eye-world vectors.

Implement support for RGTC normal maps if the hardware supports it

Implement support for 3D positional audio in the audio engine

Needs to be implemented. Lots of annoying world sparklies on NV

Need to figure out the appropriate transform to make here

The only global state should be console variables and engine stuff

Like in Quake and Quake 2, slopes are treated as small stairs when walking them downwards. This feels rather sloppy (no pun intended!) and makes it hard to control your movement while on slopes.

Need to reimplement this. It was lost in the deferred rewrite. The sky fog gradient stuff should piggy back off of it as well. This also needs to be made part of the editing menu as well.

Reintroduce point lighting

Inflate exists already for loading maps and PNGs. Now we need the inverse of that so we can save maps and PNGs

Work on rendering portals

I have a working lexer and parser. Need to consider a execution pipeline for it, maybe bytecode AOT or just execute on the AST directly.

Implement FXAA

Implement model rendering

To make text easier to read and for scaling reasons

Full fledged loader including cubemaps. If the hardware lacks S3TC we'll decode it manually (KDE, Gimp, GNOME, Chrome, Firefox, Tesseract) all do it without fear of patents

Going to need to deal with audio resampling in the mixers

Implement support for materials in the engine.

When preparing geomMethods the vector that represents the geometry methods is resized according to the required shader permutations. In doing so, the contents of the vector on the first initialize calls the destructor for a geomMethod which does not exist (and conversely calls glDeleteProgram on an invalid shader)

I'll do this.

Get rid of SHA512 (it's rather slow and overkill) use SHA1 instead and implement SSE2 optimized variant

The setSize and setFree options cannot exist alone as they can operate on uninitialized data. To fix this we should consider setting the size and free as one thing "setStore".

We now have a decent frustum class that can be reused to do splitting for the directional light.

Implement online S2TC compression if the hardware cannot do any of the texture compression formats. We'll be reimplementing the work done by divVerent which he has strong reason to believe avoids the S3TC patent issues. We'll be enabling this by default for Mesa vendor strings and Intel on Windows (which has a horribly slow S3TC compressor.).

Once materials are implemented

I might need some assistance making textures for this map.

Basically the infastructure decided to do this reasonably is as follows

Determine static models based on hashing their position/rotation and scale,
if that information has not changed since the previous information then bake that
information directly into the world geometry (and then reuse that information for all subsequents)
If that information happened to be in world geometry already but the model changed, then reclaim
that world geometry for other models.

For dynamic models render them individually by transforming them into the world for the
lighting.

Make everything consistent, clean and documented

Culling is the new caching. Use the technique explained by eihrul to issue HOQs for groups of models, render them anyway but use the result the following frame to decide if they should be rendered for that frame. This prevents pipeline stalling.

texture.cpp:1759 (as of b728399) allocates the texture decoder on the stack, which may cause it to overflow. This realistically happens on OS X with the default stack size. Unfortunately, SDL2 doesn't expose an API to change the thread stack size. Allocating the decoder on the heap alleviates the issue.

Implement SSAO

Probably just go the offline font map method to eliminate the dependency on freetype.

Rework the texture compression system to support BPTC as well as DXT

After experimenting with various ways of representing HUD guns, the easiest way is to use the following pipeline setup

        p.setRotation(m::quat());
        p.setRotate({0, -99.0f, 0});
        p.setPosition({0, 0, 0});
        p.setWorldPosition({0.4f, -0.4f, 0.4f});

This seems to be sufficient for most, if not all HUD weapons.

We need to figure out how to render them without them causing SSAO to break.

Right now we depend on map, set, vector, string and unique_ptr. We should implement our own containers to replace these so that we need no depend on the version provided by the compiler

Curently just forwards the current frame. Can't scale this with respect to time since animations will look slow and choppy.

Doing so should prevent the hudguns from looking stretched.

After font is implemented work on an engine console

Due to the world stuff becoming game code the engines renderer no longer can render map models. Map models are in essence an engine concept and not a game concept so we can just put them in there like the rest.

Referencing #24 and #6