MHDoom finished

[revelator]

Havent updated any libs in the engine the libs i changed where allready the latest i could find :/ glew-1.10.0 and jpeg9a rest are the original id libraries ogg/vorbis + openal.

Update the shadow bug seems to be back, after i did a full clean and recompile grrr. (msvc 2013 build still slower also)

I did remove a lot of stuff mh had left in the engine but was disabled because he removed most of the editor sources but besides that and running it through astyle i havent touched anything,
besides removing the experimental GLSL interaction renderer and making 2 new functions to avoid a few more state changes.
Removing the rest of the editor code was what broke compatibility with original game dll's but that should not cause this.

[revelator]

Uploading a test build with a more modern menu + HD textures and HD models.
For the ones who want the full shebang i also included sikkmod with the new menus.
its big because of the HD textures sorry about that.

I changed a few things in the renderer to use BFG's code it made certain areas a bit more bright so you dont have to spam the flashlight anymore.
It also uses the special smartflt resample code from twilight (configurable).
changed a few things to try and get rid of the shadow bug and its better but not fixed totally (atleast not on AMD).

sikkmods parallax code will not affect the gui anymore but it still causes texture sliding on surfaces that dont support it (working on a material solution).

still uploading but you can find it here https://sourceforge.net/projects/cbadva ... nt/MHDoom/

[toneddu2000]

it asks to login

[leileilol]

He meant to post this link.

[revelator]

whoops yeah, the other one only i am able to use

[revelator]

btw heres a shot of whats causing the shadows to go nuts, its not easy to see unless you compare the two shots.



as you can see theres a ghostly image of the wall to the left, when it happens to clip a shadow they dissapear.



looks like a depthbuffer image somehow but im not sure how that came to pass

[revelator]

I think i fixed it but theres room for improvement still.

Ran a codeanalysis by msvc 2013 and found several places where the same function was recast to another type.

like idStr somestring;

was cast to char *somestring; inside the same function and even more glaring whoopsies where a global was cast to something else inside a function.

The compiler should be smart enough to optimize things like that out but its bad practice to say the least and funneling it out actually gave me a rather nice performance boost hoho .

there was a rather nasty example of the above in the stencil shadow code which ment an array could easily use the wrong type.

Latest build here http://sourceforge.net/projects/cbadvan ... z/download

This guy looked shocked to say the least

[revelator]

Sikkmod looks pretty nice with this besides a few buggers which only happen on ATI it seems.

soft shadows (when enabled turns blood decals green Oo).
ssao seems to have even worse bugs than on nvidia outlines are seen even on particles on nvidia its mostly visible on skyboxes / heathaze, the bfg will trigger a tunnel effect when fired with ssao on.

rest works pretty much ok though.

todo. fixup the depth capture / render to work correctly.

change sikkmodd3xp to use the 1.02 game dll code and gui (keep the d3xp images though).

[toneddu2000]

soft shadows (when enabled turns blood decals green Oo).

Apparently ATI wants to convert us all to a non violence gamers gang!
Great work reckless, though

[qbism]

Green: Try disabling Catalyst AI and disable downsize in config?

[revelator]

Downsize is disabled by default i had an auoexec.cfg with that turned of in my doom directory for ages.
Turned off cat ai (not the easiest thing btw) need to lookup the profiles.xml in appdata\local\ati\ace and set it to disable in it.

Still working on routing out the last places where the same var is used both locally and globally or locally and then recast to something else locally (happens in loads of places actually).
also changing C style casts to C++ style and trying to get rid of _alloca (tall order btw since the special _alloca16 uses 16 bit alignment and im not quite sure how to do that with new and delete ).

[Spiney]

If you're going to include sikkmod you might as well add Treb's soft shadow mapping, way better than the hacky sikkmod soft shadows
They also give me higher perf over shadow volumes.

[revelator]

Is planned sometime though since its made for BFG porting it may not be to easy

[revelator]

Something interresting i found on the net.

Code: Select all

#if defined(WIN32) || defined(_WIN32)

namespace dsa {

	/****************************************************************************************************
	stack_array<T> constructs n elements of T type on a given memory buffer at initialization in ctor,
	and destructs these elements in its dtor. It does not allocate or deallocate memory.

	The given memory buffer should be at least sizeof(T)*n bytes.
	T must be default constructible and its dtor should not throw.

	Its main purpose is to simulate T arr[n]; on stack using alloca with n unknown at compile time.
	This allocates the array really fast compared to using dynamic memory allocation from heap.
	*****************************************************************************************************/
	template <typename T>
	class stack_array
	{
	public:
		stack_array(T* p, size_t n) : p_(p), n_(n) { init_elements(); }
		~stack_array() { uninit_elements(n_); }

		// use like T ts[n], ts+i, ts[i] etc.
		operator T* () { return p_; }

		// very limited container like support support.
		size_t size() { return n_; }
		T* begin() { return p_; }
		T* end() { return p_ + n_; }

	private:
		// uninitialize the first n elements in reverse order.
		void uninit_elements(size_t n)
		{
			while (n > 0)
			{
				p_[--n].~T();
			}
		}

		// default construct all elements, or none at exception.
		void init_elements()
		{
			size_t i = 0;
			try
			{
				for (; i < n_; ++i)
				{
					// note: boost::has_trivial_default_constructor avoids unnecessary ctor calls explicitly
					T* pi_ = new (p_ + i) T;
					// if this breaks, initial buffer may not hold n elements for element alignment problems
					assert(pi_ == p_ + i);
				}
			}
			catch (...)
			{	// when T ctor throws
				uninit_elements(i);	// clean up initialized objects.
				throw;	// re-throw the exception.
			}
		}
	private:
		T*       p_;
		size_t   n_;
	};
} // dsa

// allocate from stack a memory buffer that holds n T objects.
// This does not handle the case that _alloca fails. Handling that is platform specific.
#define NEW_ON_STACK(T, n)                static_cast<T*>(_alloca(sizeof(T)* (n)))

// auxilliary macro to be used with stack_array:
//   dsa::stack_array<T> arr(NEW_STACK_ARRAY(T,n));
#define NEW_STACK_ARRAY(T, n)             NEW_ON_STACK(T, (n)), (n)

// convenience macro to create a stack_array object arr of n T type objects on stack.
#define DYNAMIC_STACK_ARRAY(T, arr, n)    dsa::stack_array<T> arr(NEW_STACK_ARRAY(T, n))

this is obviously intended for c++ code, what it does is creating dynamic arrays.

say you got some array like int array[MAX_SOMETHING]; or int *array;

delete that and do DYNAMIC_STACK_ARRAY(int, array, MAX_SOMETHING);
or DYNAMIC_STACK_ARRAY(int, array, size the array should hold); can be a counter like for (i=0;i<seomthing;i++) DYNAMIC_STACK_ARRAY(int, array, i);

I tried it out in MHDoom and it does very much as it says

[revelator]

Btw the name change was to keep in line with my username on sourceforge its still me