holland01
commented
9 years ago Primary
RGBGen
Take care of rgbGen vertex; remove the color attrib entirely if identity or identitylighting settings are used.
TCGen
Looks like images can be used with the environment setting. See if you can figure out exactly what this means; does it mean that there is a reflective (or refractive??) quality to these images which is dependent on a number of reflection passes into a framebuffer?(note: still unsure on the refractive)You'll need to produce a recursive pass through to ensure that the reflection which is generated from the raytrace is computed relative to the face's view transform. Essentially, what this means is that the frustum will need to be culled relative to the face view transformation and not the main camera view transformation: this way, all of the faces which are supposed to be rendered at that moment will be properly generated. So, you'll need a mechanism to save the entire state of everything prior to the recursive call. This means surfaces, the view transform, the frustum's data, etc. There should only be one level more deep of a recursive render from the root, to prevent insanity (i.e., a boolean should check to see if we're currently in a recursive call and bail if so). Once all of the envmap passes have been made, you can restore the previous state via a transformStash_t structure (note: make sure you do this prior to any checks for envmaps in the DrawFromTuple function; this way, everything necessary will be taken care of without unnecessary uniform buffer updates). Continue testing with the view transforms you've generated for each envmap face to ensure this.For the texture arrays, note that the textures in the shader stages will delete the sampler object in their destructor call. It would be more memory efficient to create the samplers right before adding them to theTextureBuffer. To save memory, it would also be worthwhile to allocate all of the texture structs in the shader stages on the heap, and then delete each one after their pixel data has been transferred to theTextureBuffer. Next up would be filling any 24 bit texture buffers with a 255 alpha channel for each pixel, since the texture array will have a GL_SRGB8_ALPHA8 internal format for each member. You will also need to supply some kind of index attribute which can looked up in the fragment shader to sample the appropriate texture. For simplicity's sake, you can add an integer for each vertex which takes care of this. If the integer in the shader is -1, there's no need to actually sample it. Be sure to create a separate struct which acts as a vertex for the GPU data; this way, the bspVertex_t struct won't need to be modified. You'll need to replace all client side buffer stores with that type as well.- Find a means to take an abritrary number of faces an map their texcoords so that the farthest face will represent the very ending texels of a texture and the first face will represent the beginning.
Currently, you can iterate through the prim count of a face row and multiply that by a number of rows. You can than create a 1D texture array which can be indexed via gl_PrimitiveID in the shader. This will produce x and y coordinates (when unpacked from their rgba float values into two sixteen bit integers) which will map into the current row and column for the current primitive. What comes next is figuring out the proper scalar value to multiply the st coordinates against. Maybe something like
( x + y * width ) / ( width * height ). Each st = 1.0 will map to the upper right corner of a primitive where each st = 0.0 will map to the lower left corner of the primitive. This means that there must be some offset O applied to the multiplication of the st by scalar S. So the equation would look something like:st_xy = O + st * S. What might be useful is something likeO = ( x + y * width ) / ( width * height )andS = 1 / ( width * height ). You could then clamp the result between 0 and one (obviously) to prevent an out of bounds coordinate access on the last primitive. The last primitive's access will be something likeO = ( width - 1 + ( height - 1 ) * width ) / ( width * height ). ( NOTE, O should actually be something more likeO = vec2( x / width, y / height ), and then do:st_xy = vec2( x / width, y / height ) + st * vec2( 1 / width, 1 / height );
( Side note on the mip mapping: the bias uniform being provided in the shader might be causing problems for some of the mip levels. If this is the case, see if there's anything which can be done in terms of properly fetching a particular mip level at the shader level, and using mipWidth / megaDims.x, mipHeight / megaDims.y in these instances instead. texelFetch in GLSL might be a good mechanism for this, or seeing if there is another way to select the mip level to sample from within a draw call.
Texture arrays are mostly finished. Be sure to modify the generated GLSL programs from the effect shaders to accomodate for this. Also, make sure no image is loaded twice so that memory is properly saved. Any kind of setting which is used to produce a sampler object should also be freed once it's no longer needed - a lot of the texture data being stored in the effect shaders won't be necessary to keep once the texture arrays are allocated (things liketexture_t::minFilter,texture_t::magFilter, texture_t::pixels, etc. It would likely be a good idea to have 3 different texture arrays:one for the textures which map to the effect shaders (and any other images which aren't referenced by the shaders themslves)lightmap textures
SkyParms
- Should take care of this after tcgen is finished.
Main TODO
WebGL SupportSecondary
For Vertex Deforms
glfwGetTime()is multiplied directly with something like the deform spread; this may spread the animation movement out a bit...