What do you want in Project64 ?

[Doomulation]

Let's redefine that sentence. OpenGL support in the drivers is very good. But so is DirectX. That means if an application uses the API appropriately, it can achieve the same speed using OpenGL as DirectX, and possibly more.
It depends on the application and HOW it is used. Thus an application can perform better with OpenGL and slower with DirectX and vice versa. Also take into other factors that can slow down things.

 

[Iconoclast]

Let's redefine that sentence. OpenGL support in the drivers is very good. But so is DirectX. That means if an application uses the API appropriately, it can achieve the same speed using OpenGL as DirectX, and possibly more.
It depends on the application and HOW it is used. Thus an application can perform better with OpenGL and slower with DirectX and vice versa. Also take into other factors that can slow down things.

I'm not saying DirectX is ALWAYS faster than OpenGL or that OpenGL is ALWAYS slower than DirectX; I'm only saying that OpenGL is not ALWAYS faster on NVidia cards than DirectX, which was what squall_leonhart said. He didn't say the word 'always', but he didn't specify 'sometimes', either. I'm only saying, I've got an FX 5200, and OpenGL is not fast over here.

 

[Doomulation]

The point was, as I think squall put it, that OpenGL is always faster than DirectX in the driver implementation. This does not always equal to real world speeds.

 

[Jabo]

I dropped support for OpenGL mostly at the time due to its lack of blending features, today I'm not sure it matters as much if you are using shaders, but for anything without shaders OpenGL really is a pain in the ass, and I'm not say that direct3d is a breeze, because its definitely not.

The sexiest thing about OpenGL is its cross platform, but their non-shader support really blows, in 2-3 years this will matter even less than it does right now.

 

[X-Fi6]

Oh. Well, anyways, frame buffer emulation could be a little better. I think Glide64 with Gonetz's updated version of Hacktaruz's glide wrapper is probably the best with hardware frame buffer emulation and yours is second-best.

I wonder how both of them would feel like if their source was copied into your plugin.

 

[mudlord]

That would be infeasible.

The wrapper uses FBO's and some custom memory caching code for HWFBE. From what I understand about Direct3D, there are already features in DX8 that do a similar job. Which would mean that its pointless copying code as:

a) they use 2 different APIs
b) it wouldn't do much, since there is pretty much equivalent functions for render-to-texture to so there is no need to copy HWFBE code.

What I would like is better framebuffer detection, and more accurate framebuffer rendering. Like for instance, Perfect Dark's camspy (which is partially correct in Jabo's plugin, and perfect in Glide64 w/ wrapper).

 

[overkill]

I'm posting a bit late in the game, but two additions I'd like to see are basic surround sound support and 'portability'. I'm not sure how hard it would be to add surround sound support, but with the exception of the transfer pack that's the one feature the N64 has that I haven't seen yet, not so important though. I'm more interested in the ability to take PJ64 with me on a usb drive (etc.) With the size of the games and generally better computers it's something to considder. I haven't seen what's been done with 1.7, but I don't think it would be hard to implement. 1.6 meets all of the requirements except for a relative ROM directory and the ability to work without touching the regestry. It could be done through an install option, a seporate build or something like that...

For the record, I support the other suggestions over this, especially netplay. Thanks for everything.

 

[A.I.]

Cupholders and a input plugin for a Wii remote!

But seriously on a note that may seem trival an option to hide the damn cursor! :getlost:

 

[squall_leonhart]

I dropped support for OpenGL mostly at the time due to its lack of blending features, today I'm not sure it matters as much if you are using shaders, but for anything without shaders OpenGL really is a pain in the ass, and I'm not say that direct3d is a breeze, because its definitely not.

The sexiest thing about OpenGL is its cross platform, but their non-shader support really blows, in 2-3 years this will matter even less than it does right now.

Opengl 1.5-2.0 are the shader level extensions so opengl of today does shaders, and does it well.

actually.. im sure opengl has had shader support since 1.4 as NWN is a opengl 1.4 game and you can use pixel shaded water in it?...?

also, opengl has better blending support now since OGL 1.5 and most cards support 1.5 (Geforce 4 TI +)

for instance.. using FW97.28 i have opengl 2.1 with the following stuff

System Info
Windows XP Professional

Vendor
NVIDIA Corporation
2.1.0

Renderer
GeForce FX 5900XT/AGP/SSE/3DNOW!

Extensions
GL_ARB_depth_texture
GL_ARB_fragment_program
GL_ARB_fragment_program_shadow
GL_ARB_fragment_shader
GL_ARB_half_float_pixel
GL_ARB_imaging
GL_ARB_multisample
GL_ARB_multitexture
GL_ARB_occlusion_query
GL_ARB_pixel_buffer_object
GL_ARB_point_parameters
GL_ARB_point_sprite
GL_ARB_shader_objects
GL_ARB_shading_language_100
GL_ARB_shadow
GL_ARB_texture_border_clamp
GL_ARB_texture_compression
GL_ARB_texture_cube_map
GL_ARB_texture_env_add
GL_ARB_texture_env_combine
GL_ARB_texture_env_dot3
GL_ARB_texture_mirrored_repeat
GL_ARB_texture_rectangle
GL_ARB_transpose_matrix
GL_ARB_vertex_buffer_object
GL_ARB_vertex_program
GL_ARB_vertex_shader
GL_ARB_window_pos
GL_EXT_abgr
GL_EXT_bgra
GL_EXT_blend_color
GL_EXT_blend_func_separate
GL_EXT_blend_minmax
GL_EXT_blend_subtract
GL_EXT_Cg_shader
GL_EXT_compiled_vertex_array
GL_EXT_depth_bounds_test
GL_EXT_draw_range_elements
GL_EXT_fog_coord
GL_EXT_framebuffer_blit
GL_EXT_framebuffer_multisample
GL_EXT_framebuffer_object
GL_EXT_gpu_program_parameters
GL_EXT_multi_draw_arrays
GL_EXT_packed_depth_stencil
GL_EXT_packed_pixels
GL_EXT_paletted_texture
GL_EXT_pixel_buffer_object
GL_EXT_point_parameters
GL_EXT_rescale_normal
GL_EXT_secondary_color
GL_EXT_separate_specular_color
GL_EXT_shadow_funcs
GL_EXT_shared_texture_palette
GL_EXT_stencil_two_side
GL_EXT_stencil_wrap
GL_EXT_texture3D
GL_EXT_texture_compression_s3tc
GL_EXT_texture_cube_map
GL_EXT_texture_edge_clamp
GL_EXT_texture_env_add
GL_EXT_texture_env_combine
GL_EXT_texture_env_dot3
GL_EXT_texture_filter_anisotropic
GL_EXT_texture_lod
GL_EXT_texture_lod_bias
GL_EXT_texture_object
GL_EXT_texture_sRGB
GL_EXT_timer_query
GL_EXT_vertex_array
GL_HP_occlusion_test
GL_IBM_rasterpos_clip
GL_IBM_texture_mirrored_repeat
GL_KTX_buffer_region
GL_NV_blend_square
GL_NV_copy_depth_to_color
GL_NV_depth_clamp
GL_NV_fence
GL_NV_float_buffer
GL_NV_fog_distance

the real problem with opengl is the complexity

and Iconoclaust,.. Opengl is faster then directx even on a 5200 but it depends what game your using to test this

many opengl games are locked to the refresh rate in code.

but on my FX5900XT
in Opengl, i get 150fps in UT GOTYE, where as in Direct3D i only get 80max

 

[god0fgod]

More compability with drivers? Are you implying you are seeing graphics bugs in the emulation? Or do you want more graphics card compability (ie more cards should work)?
Emulation can be a memory hog; I don't think this will change.


Perhaps you should be more specific.

Well it seems the full extent of my graphics card isn't used in project64.

Mario party games have problems but they are really good games. i have mario party 3 and it used to run fine but now it's all slow.

 

[Iconoclast]

and Iconoclaust,.. Opengl is faster then directx even on a 5200 but it depends what game your using to test this

I don't want to argue with you. I'm the one using this PC, so I'm the one who can tell which rendering engine is faster on it, and I say it's DirectX. Doomulation just got done explaining why either rendering engine could be faster than the other

 

[Beaner(lui)]

Maby A rom Editor, I mean Editor editor Models and everything,levels,sounds,
That Would Be Nice...
Heh Heh...

 

[Doomulation]

Well it seems the full extent of my graphics card isn't used in project64.

Mario party games have problems but they are really good games. i have mario party 3 and it used to run fine but now it's all slow.

Pj supports all cards ranging from the minimum requirements. Mario party games doesn't run slow because of your Graphics Card nor your processor - it's mean emulation issue.
If it ran okay before and slow now, that points to that something has happened with your system.

 

[squall_leonhart]

I don't want to argue with you. I'm the one using this PC, so I'm the one who can tell which rendering engine is faster on it, and I say it's DirectX. Doomulation just got done explaining why either rendering engine could be faster than the other

play a game that has both opengl and direct3d and you'll see opengl is faster

playing different games is not a good way to test this as different games play differently.

for example.. Doom3 is locked at 60fps unless otherwise stated where as Half life 2 is just vsynched.



a good way to test performance is with UT GOTYE or Half Life 1 (the original) and fps test it in both Direct3D and opengl

 

[Jabo]

play a game that has both opengl and direct3d and you'll see opengl is faster

playing different games is not a good way to test this as different games play differently.

for example.. Doom3 is locked at 60fps unless otherwise stated where as Half life 2 is just vsynched.



a good way to test performance is with UT GOTYE or Half Life 1 (the original) and fps test it in both Direct3D and opengl

I probably shouldn't be encouraging this debate, but.. Comparing OpenGL to Direct3D isn't really a fair comparison, they both are 3D api's but that is about where their similarities end more or less. OpenGL is implemented on a per vendor basis. I don't want to entertain an in depth discussion here, but that little nugget should be considered.

 

[squall_leonhart]

that is also a good point to make jabo.

Nvidia is usually faster on opengl cards, vs direct3d where the game supports both,. compared to ati where it can be slower as the atigl still has some catching up to do.

i have one good way to show this and that is by running EPSXE with petes opengl and direct3d plugins.

the opengl plugin handles framebuffers much faster then the direct3d plugin... which is pretty much why gpupete dropped d3d plugin support and worked soley on the best OGL 2.0 plugin there is for PSX emulation

 

[Doomulation]

Whoa now, don't jump to conclusions. Pete may or may not have dropped d3d because of your stated reasons, but in terms of functionality, OpenGL and Direct3D is about the same.

 

[squall_leonhart]

yes and no, Opengl is used as the workstation renderer for a reason

Opengl has been able to prerender realistic graphics for a good long time its only with Dx10 that microsoft can actually claim the same thing. with previous builds it still appeared plasticy....


although harder to work with, opengl when implemented correctly, can be Faster and higher quality then Direct3D... its just like with all developers...... they tend to take the easy way out and restrict it to easier strings and stuff...

..i dunno.. opengl has just always been faster for me in applications that can run both modes.

the only reason why rice video can't say the same is becoz its been implemented badly and is incomplete....

still.... i can say that for me.... in opengl mode it does run smoother then in Direct3d mode... but theres to many flaws with various games... if only someone would take up the Rice video source and further the development.

and i have had a 5200 handy to test opengl before and i still got better results.

just depends on that game is all....

still we should get back on topic.

 

[god0fgod]

Pj supports all cards ranging from the minimum requirements. Mario party games doesn't run slow because of your Graphics Card nor your processor - it's mean emulation issue.
If it ran okay before and slow now, that points to that something has happened with your system.

Yes there's a problem with the emulator and games can be run much faster and efficently.

 

[Rice]

OpenGL supports pixel shaders, like Direct3D. Shaders in OpenGL usually refers to vertex shaders. Pixel shader in DirectX is called fragment_program in OpenGL. Programming pixel shader in DirectX and fragment_program in OpenGL is about exactly the same.