GSdx

[DaisukeJP]

i've got it allready..
thx for ur warning anywayz

[Dragonheart.by]

Still the same prob with DQVIII and SVN 792.

[gabest]

Video recording works again, control+f8 to start and stop, be sure to stop it before closing the emu or else the avi will not play.

[AndreaB]

posted again my gs of "gundam battle assault 3"

Blurried image ( lika a lowres image over the 3d graphic ) and dark bar on the right side of the screen. It seems ok in software mode.

http://www.deltalink.it/andreab/gundam.zip

[YukiSakura]

I used GSdx version 0.1.8 - sse2 with these options

but it didn't work. (Although it works with version 0.1.7 - same options)
My PC's specification:
- CPU : Core 2 Duo - Merom T5600
- GPU : NVidia Geforce Go 7400
- OS : Windows Vista 64bit
Thanks for viewing my post.

[davidep85]

Originally Posted by YukiSakura

I used GSdx version 0.1.8 - sse2 with these options

but it didn't work. (Although it works with version 0.1.7 - same options)
My PC's specification:
- CPU : Core 2 Duo - Merom T5600
- GPU : NVidia Geforce Go 7400
- OS : Windows Vista 64bit
Thanks for viewing my post.

try to install drectx redist june 2008

[NexXxus]

hmmm
Vibration in FFX/FFX-2 does not work with Xpad, but in KH it works, but more lighter than with SSSPSXPAD...
and yes i enabled Vibration in the options menu of both games.

[jos708]

I have a 7600GT with WinXp and would like to know if 0.1.8 also works for DX9 cards ?
I already tried al 3 versions (SS2 and SSS3 should work with my Core2Duo).
Upon starting emulation pcsx2 just crashes. Am I doing something wrong ?

[GothicIII]

If theres something wrong with that, then sry for posting this:

Has anyone already succesfully compiled the svn793 or do we have to wait for the next release?

I can't, cause I'm getting gsvector4i-errors

SPOILER: Highlight text to view.

error C2039: 'gather32_32': Is no element of 'GSVector4i' (GSLocalMemory.h)

[AndreaB]

same error for me , could not compile.

my vs 2005 say:

inactive preprocessro block, and the gather32_32 function is inside.

Sorry my M_SSE is set to 0 i don't know why. every block under m_sse >0 is not compiled for me. ( i have penryn )

	#if _M_SSE >= 0x400

	template<int i> GSVector4i insert8(int a) const
	{
		return GSVector4i(_mm_insert_epi8(m, a, i));
	}

	template<int i> int extract8() const
	{
		return _mm_extract_epi8(m, i);
	}

	template<int i> GSVector4i insert16(int a) const
	{
		return GSVector4i(_mm_insert_epi16(m, a, i));
	}

	template<int i> int extract16() const
	{
		return _mm_extract_epi16(m, i);
	}

	template<int i> GSVector4i insert32(int a) const
	{
		return GSVector4i(_mm_insert_epi32(m, a, i));
	}

	template<int i> int extract32() const
	{
		return _mm_extract_epi32(m, i);
	}

	#ifdef _M_AMD64

	template<int i> GSVector4i insert64(__int64 a) const
	{
		return GSVector4i(_mm_insert_epi64(m, a, i));
	}

	template<int i> __int64 extract64() const
	{
		return _mm_extract_epi64(m, i);
	}

	#endif

	template<int src, class T> __forceinline GSVector4i gather8_4(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert8<0>((int)ptr[extract8<src + 0>() & 0xf]);
		v = v.insert8<1>((int)ptr[extract8<src + 0>() >> 4]);
		v = v.insert8<2>((int)ptr[extract8<src + 1>() & 0xf]);
		v = v.insert8<3>((int)ptr[extract8<src + 1>() >> 4]);
		v = v.insert8<4>((int)ptr[extract8<src + 2>() & 0xf]);
		v = v.insert8<5>((int)ptr[extract8<src + 2>() >> 4]);
		v = v.insert8<6>((int)ptr[extract8<src + 3>() & 0xf]);
		v = v.insert8<7>((int)ptr[extract8<src + 3>() >> 4]);
		v = v.insert8<8>((int)ptr[extract8<src + 4>() & 0xf]);
		v = v.insert8<9>((int)ptr[extract8<src + 4>() >> 4]);
		v = v.insert8<10>((int)ptr[extract8<src + 5>() & 0xf]);
		v = v.insert8<11>((int)ptr[extract8<src + 5>() >> 4]);
		v = v.insert8<12>((int)ptr[extract8<src + 6>() & 0xf]);
		v = v.insert8<13>((int)ptr[extract8<src + 6>() >> 4]);
		v = v.insert8<14>((int)ptr[extract8<src + 7>() & 0xf]);
		v = v.insert8<15>((int)ptr[extract8<src + 7>() >> 4]);

		return v;
	}

	template<class T> __forceinline GSVector4i gather8_8(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert8<0>((int)ptr[extract8<0>()]);
		v = v.insert8<1>((int)ptr[extract8<1>()]);
		v = v.insert8<2>((int)ptr[extract8<2>()]);
		v = v.insert8<3>((int)ptr[extract8<3>()]);
		v = v.insert8<4>((int)ptr[extract8<4>()]);
		v = v.insert8<5>((int)ptr[extract8<5>()]);
		v = v.insert8<6>((int)ptr[extract8<6>()]);
		v = v.insert8<7>((int)ptr[extract8<7>()]);
		v = v.insert8<8>((int)ptr[extract8<8>()]);
		v = v.insert8<9>((int)ptr[extract8<9>()]);
		v = v.insert8<10>((int)ptr[extract8<10>()]);
		v = v.insert8<11>((int)ptr[extract8<11>()]);
		v = v.insert8<12>((int)ptr[extract8<12>()]);
		v = v.insert8<13>((int)ptr[extract8<13>()]);
		v = v.insert8<14>((int)ptr[extract8<14>()]);
		v = v.insert8<15>((int)ptr[extract8<15>()]);

		return v;
	}

	template<int dst, class T> __forceinline GSVector4i gather8_16(const T* ptr, const GSVector4i& a) const
	{
		GSVector4i v = a;

		v = v.insert8<dst + 0>((int)ptr[extract16<0>()]);
		v = v.insert8<dst + 1>((int)ptr[extract16<1>()]);
		v = v.insert8<dst + 2>((int)ptr[extract16<2>()]);
		v = v.insert8<dst + 3>((int)ptr[extract16<3>()]);
		v = v.insert8<dst + 4>((int)ptr[extract16<4>()]);
		v = v.insert8<dst + 5>((int)ptr[extract16<5>()]);
		v = v.insert8<dst + 6>((int)ptr[extract16<6>()]);
		v = v.insert8<dst + 7>((int)ptr[extract16<7>()]);

		return v;
	}

	template<int dst, class T> __forceinline GSVector4i gather8_32(const T* ptr, const GSVector4i& a) const
	{
		GSVector4i v = a;

		v = v.insert8<dst + 0>((int)ptr[extract32<0>()]);
		v = v.insert8<dst + 1>((int)ptr[extract32<1>()]);
		v = v.insert8<dst + 2>((int)ptr[extract32<2>()]);
		v = v.insert8<dst + 3>((int)ptr[extract32<3>()]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather16_4(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert16<0>((int)ptr[extract8<src + 0>() & 0xf]);
		v = v.insert16<1>((int)ptr[extract8<src + 0>() >> 4]);
		v = v.insert16<2>((int)ptr[extract8<src + 1>() & 0xf]);
		v = v.insert16<3>((int)ptr[extract8<src + 1>() >> 4]);
		v = v.insert16<4>((int)ptr[extract8<src + 2>() & 0xf]);
		v = v.insert16<5>((int)ptr[extract8<src + 2>() >> 4]);
		v = v.insert16<6>((int)ptr[extract8<src + 3>() & 0xf]);
		v = v.insert16<7>((int)ptr[extract8<src + 3>() >> 4]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather16_8(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert16<0>((int)ptr[extract8<src + 0>()]);
		v = v.insert16<1>((int)ptr[extract8<src + 1>()]);
		v = v.insert16<2>((int)ptr[extract8<src + 2>()]);
		v = v.insert16<3>((int)ptr[extract8<src + 3>()]);
		v = v.insert16<4>((int)ptr[extract8<src + 4>()]);
		v = v.insert16<5>((int)ptr[extract8<src + 5>()]);
		v = v.insert16<6>((int)ptr[extract8<src + 6>()]);
		v = v.insert16<7>((int)ptr[extract8<src + 7>()]);

		return v;
	}

	template<class T>__forceinline GSVector4i gather16_16(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert16<0>((int)ptr[extract8<0>()]);
		v = v.insert16<1>((int)ptr[extract8<1>()]);
		v = v.insert16<2>((int)ptr[extract8<2>()]);
		v = v.insert16<3>((int)ptr[extract8<3>()]);
		v = v.insert16<4>((int)ptr[extract8<4>()]);
		v = v.insert16<5>((int)ptr[extract8<5>()]);
		v = v.insert16<6>((int)ptr[extract8<6>()]);
		v = v.insert16<7>((int)ptr[extract8<7>()]);

		return v;
	}

	template<int dst, class T> __forceinline GSVector4i gather16_32(const T* ptr, const GSVector4i& a) const
	{
		GSVector4i v = a;

		v = v.insert16<dst + 0>((int)ptr[extract32<0>()]);
		v = v.insert16<dst + 1>((int)ptr[extract32<1>()]);
		v = v.insert16<dst + 2>((int)ptr[extract32<2>()]);
		v = v.insert16<dst + 3>((int)ptr[extract32<3>()]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather32_4(const T* ptr) const
	{
		GSVector4i v;

		int a = (int)ptr[extract8<src + 0>() & 0xf];
		int b = (int)ptr[extract8<src + 0>() >> 4];
		int c = (int)ptr[extract8<src + 1>() & 0xf];
		int d = (int)ptr[extract8<src + 1>() >> 4];

		v = GSVector4i(a, b, c, d);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather32_8(const T* ptr) const
	{
		GSVector4i v;

		int a = (int)ptr[extract8<src + 0>()];
		int b = (int)ptr[extract8<src + 1>()];
		int c = (int)ptr[extract8<src + 2>()];
		int d = (int)ptr[extract8<src + 3>()];

		v = GSVector4i(a, b, c, d);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather32_16(const T* ptr) const
	{
		GSVector4i v;

		int a = (int)ptr[extract16<src + 0>()];
		int b = (int)ptr[extract16<src + 1>()];
		int c = (int)ptr[extract16<src + 2>()];
		int d = (int)ptr[extract16<src + 3>()];

		v = GSVector4i(a, b, c, d);

		return v;
	}

	template<class T> __forceinline GSVector4i gather32_32(const T* ptr) const
	{
		GSVector4i v;
/*
		GSVector4i v0 = GSVector4i(_mm_cvtsi32_si128((int)ptr[extract32<0>()]));
		GSVector4i v2 = GSVector4i(_mm_cvtsi32_si128((int)ptr[extract32<2>()]));

		v0 = v0.upl32(v2);

		GSVector4i v1 = GSVector4i(_mm_cvtsi32_si128((int)ptr[extract32<1>()]));
		GSVector4i v3 = GSVector4i(_mm_cvtsi32_si128((int)ptr[extract32<3>()]));

		v1 = v1.upl32(v3);

		v = v0.upl32(v1);
*/
		int a = (int)ptr[extract32<0>()];
		int b = (int)ptr[extract32<1>()];
		int c = (int)ptr[extract32<2>()];
		int d = (int)ptr[extract32<3>()];

		v = GSVector4i(a, b, c, d);

		return v;
	}

	#ifdef _M_AMD64

	template<int src, class T> __forceinline GSVector4i gather64_4(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert64<0>((__int64)ptr[extract8<src + 0>() & 0xf]);
		v = v.insert64<1>((__int64)ptr[extract8<src + 0>() >> 4]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather64_8(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert64<0>((__int64)ptr[extract8<src + 0>()]);
		v = v.insert64<1>((__int64)ptr[extract8<src + 1>()]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather64_16(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert64<0>((__int64)ptr[extract16<src + 0>()]);
		v = v.insert64<1>((__int64)ptr[extract16<src + 1>()]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather64_32(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert64<0>((__int64)ptr[extract32<src + 0>()]);
		v = v.insert64<1>((__int64)ptr[extract32<src + 1>()]);

		return v;
	}

	template<class T> __forceinline GSVector4i gather64_64(const T* ptr) const
	{
		GSVector4i v;

		v = v.insert64<0>((__int64)ptr[extract64<0>()]);
		v = v.insert64<1>((__int64)ptr[extract64<1>()]);

		return v;
	}

	#else

	template<int src, class T> __forceinline GSVector4i gather64_4(const T* ptr) const
	{
		GSVector4i v;

		v = v.loadu(&ptr[extract8<src + 0>() & 0xf], &ptr[extract8<src + 0>() >> 4]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather64_8(const T* ptr) const
	{
		GSVector4i v;

		v = v.loadu(&ptr[extract8<src + 0>()], &ptr[extract8<src + 1>()]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather64_16(const T* ptr) const
	{
		GSVector4i v;

		v = v.loadu(&ptr[extract16<src + 0>()], &ptr[extract16<src + 1>()]);

		return v;
	}

	template<int src, class T> __forceinline GSVector4i gather64_32(const T* ptr) const
	{
		GSVector4i v;

		v = v.loadu(&ptr[extract32<src + 0>()], &ptr[extract32<src + 1>()]);

		return v;
	}

	#endif

	template<class T> __forceinline void gather8_4(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather8_4<0>(ptr);
		dst[1] = gather8_4<8>(ptr);
	}

	__forceinline void gather8_8(const BYTE* ptr, GSVector4i* dst) const
	{
		dst[0] = gather8_8<>(ptr);
	}

	template<class T> __forceinline void gather16_4(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather16_4<0>(ptr);
		dst[1] = gather16_4<4>(ptr);
		dst[2] = gather16_4<8>(ptr);
		dst[3] = gather16_4<12>(ptr);
	}

	template<class T> __forceinline void gather16_8(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather16_8<0>(ptr);
		dst[1] = gather16_8<8>(ptr);
	}

	template<class T> __forceinline void gather16_16(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather16_16<>(ptr);
	}

	template<class T> __forceinline void gather32_4(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather32_4<0>(ptr);
		dst[1] = gather32_4<2>(ptr);
		dst[2] = gather32_4<4>(ptr);
		dst[3] = gather32_4<6>(ptr);
		dst[4] = gather32_4<8>(ptr);
		dst[5] = gather32_4<10>(ptr);
		dst[6] = gather32_4<12>(ptr);
		dst[7] = gather32_4<14>(ptr);
	}

	template<class T> __forceinline void gather32_8(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather32_8<0>(ptr);
		dst[1] = gather32_8<4>(ptr);
		dst[2] = gather32_8<8>(ptr);
		dst[3] = gather32_8<12>(ptr);
	}

	template<class T> __forceinline void gather32_16(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather32_16<0>(ptr);
		dst[1] = gather32_16<4>(ptr);
	}

	template<class T> __forceinline void gather32_32(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather32_32<>(ptr);
	}

	template<class T> __forceinline void gather64_4(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather64_4<0>(ptr);
		dst[1] = gather64_4<1>(ptr);
		dst[2] = gather64_4<2>(ptr);
		dst[3] = gather64_4<3>(ptr);
		dst[4] = gather64_4<4>(ptr);
		dst[5] = gather64_4<5>(ptr);
		dst[6] = gather64_4<6>(ptr);
		dst[7] = gather64_4<7>(ptr);
		dst[8] = gather64_4<8>(ptr);
		dst[9] = gather64_4<9>(ptr);
		dst[10] = gather64_4<10>(ptr);
		dst[11] = gather64_4<11>(ptr);
		dst[12] = gather64_4<12>(ptr);
		dst[13] = gather64_4<13>(ptr);
		dst[14] = gather64_4<14>(ptr);
		dst[15] = gather64_4<15>(ptr);
	}

	template<class T> __forceinline void gather64_8(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather64_8<0>(ptr);
		dst[1] = gather64_8<2>(ptr);
		dst[2] = gather64_8<4>(ptr);
		dst[3] = gather64_8<6>(ptr);
		dst[4] = gather64_8<8>(ptr);
		dst[5] = gather64_8<10>(ptr);
		dst[6] = gather64_8<12>(ptr);
		dst[7] = gather64_8<14>(ptr);
	}

	template<class T> __forceinline void gather64_16(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather64_16<0>(ptr);
		dst[1] = gather64_16<2>(ptr);
		dst[2] = gather64_16<4>(ptr);
		dst[3] = gather64_16<8>(ptr);
	}

	template<class T> __forceinline void gather64_32(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather64_32<0>(ptr);
		dst[1] = gather64_32<2>(ptr);
	}

	#ifdef _M_AMD64

	template<class T> __forceinline void gather64_64(const T* ptr, GSVector4i* dst) const
	{
		dst[0] = gather64_64<>(ptr);
	}

	#endif

	#endif

[J0hnny]

Simply the code is not finished. Wait for new revision.
What difference between GSdx 0.1.8 and GSdx 0.1.7 or GSdx 0.1.6.......? may be should to add some change Log?

[grimlord]

When you say "Games which had the post-processing effect removed:" on the first page, does that mean those games have that removed in order to remove vertical stripes from them? If that's the case, then why my One Piece Grand Adventure still has 'em? Perhaps I have a different version? What do numbers in the brackets next to game means? How can I know is my version of the game the same?

[J0hnny]

How can I know is my version of the game the same?

If game CRC = 0xXXXXX is your version of the game. CRC writing in console when you run the game.

[gabest]

Fix0red the svn for < sse4 builds.

AndreaB: You need VS2008 to compile anything above sse2.

[YukiSakura]

Originally Posted by davidep85

try to install drectx redist june 2008

Thank you very much. It worked now.
But I think this plugin should alert user if there is no required dll files.

[NexXxus]

Originally Posted by YukiSakura

But I think this plugin should alert user if there is no required dll files.

no. why?
its enough when its mentioned in a readme or in the text of the first post.

@gabest, can you open another thread for Xpad?
because discussion about two different plugins in one thread, well.....

[Anatasia]

Originally Posted by gabest

Latest: GSdx 0.1.8 (7z)

Additional DLLs: DirectX End-User Runtime Web Installer, DirectX End-User Runtimes

There is.

[cottonvibes]

Originally Posted by NexXxus

@gabest, can you open another thread for Xpad?
because discussion about two different plugins in one thread, well.....

yeah i think another thread would be best, since many people don't even see the xpad link on the bottom of the post

[Prafull]

Video capture isnt working for me.. It just creates an 85 kb file... Am I missing something?

[gabest]

Only tested with ffdshow in vfw mode, that should work.