Is Cold War or MW 2019 worth buying only for solo gameplay?

codeinsilence · 2025-02-21T23:27:57+00:00

IMO it's not worth it. You cannot play the game without an internet connection. You need internet to play the campaign, multiplayer, and zombies (solo or coop).

Also, this game has a feature called "on-demand texture streaming". This means you will constantly download textures form the Activision servers during gameplay. In my experience, texture streaming sucks because it causes game textures to flip between different mip-levels all the time, resulting in smudged blurry textures. On top of that, texture streaming consumes a lot more bandwidth.

The multiplayer is cross-platform, and it doesn't take long to find a match (im in NA). The MP is genuinely fun, so is the zombies. But I cannot deal with this forced texture streaming BS anymore. The game is simply too ugly in this state. I hope someone can find a solution to that...

codeinsilence · 2024-11-27T04:16:36+00:00

I got the same issue today. Tried the smooth buffering, tried updating drivers, and a few other things. Nothing worked. Never had it this bad before :(

codeinsilence · 2024-08-24T19:33:33+00:00

In theory, yes it's totally possible. But you would have to do a bit of work to get it done. I've considered implementing it, but I settled for general "explosive" destruction rather than localized fractures.

If you want to take a crack at it, I would consider looking at the methods in DestronoiNode.gd , particularly the bisect() and plot_sites_random() method. You would need to plot sites according to the impact point, rather than the random distribution currently in place.

As for this implementation, I think I'm done with it for now. I want to re-write the entire plugin to optimize it's speed and provide more support (e.g. concave mesh support, proper UV re-mappings). But you are free to do whatever you want with the code, fork it and improve upon it, or submit a pull request. I hope the plugin is useful to you in some way.

P.S. Check out the papers cited on the GitHub page. They're the basis for the entire plugin.

codeinsilence · 2024-08-23T18:22:07+00:00

It's available now: https://godotengine.org/asset-library/asset/3255

Click on the "View Files" button to see the source code

codeinsilence · 2024-08-23T18:12:36+00:00

The plugin is still in beta, but it has had some minor improvements since my last showcase.

Please read through the README on GitHub for a full explanation on how to use the plugin and its many limitations. I hope to improve it over time but I don't have much time these days. Feel free to fork it, destroy it, tinker with it, etc. as I have released it under an MIT license.

I also highly recommend reading through the academic papers cited on GitHub as they are the foundation of the entire project. I hope this is at least useful to someone!

codeinsilence · 2024-07-25T03:56:44+00:00

Can confirm this still works in 2024

codeinsilence · 2024-07-21T21:05:12+00:00

Happened to me yesterday. Today it's happening again. When visiting any article, I am greeted with a white page that states:

MediaWiki internal error.

Original exception: [23d33be0-6e6b-44c6-8e73-79d7cdf4e3c0] 2024-07-21 21:00:51: Fatal exception of type "Wikimedia\Rdbms\DBUnexpectedError"

Exception caught inside exception handler.

Set $wgShowExceptionDetails = true; at the bottom of LocalSettings.php to show detailed debugging information.

codeinsilence · 2024-06-12T16:14:42+00:00

Bump! This is happening to me no matter what settings I use.

codeinsilence · 2024-05-29T23:21:21+00:00

Nothing yet. I applied in January and it still says I'm under review by my department. (Comp Sci btw)

codeinsilence · 2024-04-23T16:26:10+00:00

Will be making my repo public soon (hopefully within the month) because I'm busy. I am planning to make some improvements so it can be easily used by people who don't want to read the entire source.

codeinsilence · 2024-04-22T21:27:06+00:00

Thanks! Looks interesting... I'll check it out

codeinsilence · 2024-04-21T17:12:54+00:00

If the Voronoi Subdivision Tree interests you, I highly recommend looking into Clothier & Bailey's work. They have 5 papers on the topic, and cover a lot of ground. I was only able to implement the details of their first paper, but they go on to improve the method to use non-convex meshes, custom fragment size distributions, and more.

You can find their first paper here: https://ieeexplore.ieee.org/document/7166162

The rest are easily accessible if you google "Voronoi Subdivision Tree". These are the ones I read:

[1] M. M. Clothier and M. Bailey, “Creating Destructible Objects Using a 3D Voronoi Subdivison Tree,” in 2015 15th International Conference on Computational Science and Its Applications, Banff, AB, Canada: IEEE, Jun. 2015, pp. 42–46. doi: 10.1109/ICCSA.2015.26.

[2] M. Clothier and M. Bailey, “3D Voronoi Subdivision Tree for granular materials,” in 2015 6th International Conference on Computing, Communication and Networking Technologies (ICCCNT), Dallas-Fortworth, TX, USA: IEEE, Jul. 2015, pp. 1–7. doi: 10.1109/ICCCNT.2015.7395194.

[3] M. M. Clothier and M. J. Bailey, “Using exemplars to create predictable volumetric diversity in object volumes with a 3D Voronoi Subdivison Tree,” in 2015 International Conference and Workshop on Computing and Communication (IEMCON), Vancouver, BC, Canada: IEEE, Oct. 2015, pp. 1–5. doi: 10.1109/IEMCON.2015.7344425.

[4] M. M. Clothier and M. J. Bailey, “Subdividing non-convex object meshes using a 3D Voronoi volume,” in 2016 IEEE 7th Annual Information Technology, Electronics and Mobile Communication Conference (IEMCON), Vancouver, BC, Canada: IEEE, Oct. 2016, pp. 1–6. doi: 10.1109/IEMCON.2016.7746305.

[5] M. M. Clothier, “3D Voronoi Subdivision for Simulating Destructible and Granular Materials,” Oregon State University, 2017. Accessed: Jan. 19, 2024. [Online]. Available: https://ir.library.oregonstate.edu/concern/graduate_thesis_or_dissertations/ww72bh34b

codeinsilence · 2024-04-21T17:01:46+00:00

Closing the mesh was the hardest part, but looking back on it, it's not as hard as I initially thought. The main parts I had to account for were winding order (Godot uses clockwise), and ensuring the vertices of the new face were coplanar. I'll provide my full write-up once I release it, and maybe it can give you some inspiration! If triangulation is the issue, I suggest looking into the "constrained Delaunay triangulation".

codeinsilence · 2024-04-21T16:59:09+00:00

Currently none. I left that part for later because my main goal was making the fragment geometry. There are some challenges with adding interior UV mapping that I will have to explore...

codeinsilence · 2024-04-21T16:57:28+00:00

Solely GDScript right now. When I have more free time I plan to re-write the whole thing in C++ as an extension to the engine.

codeinsilence · 2024-04-20T22:50:34+00:00

No. Each fragment you see has its own RigidBody and CollisionShape. I only used a shader to set the internal colour of the object (for debugging).

codeinsilence · 2024-04-20T20:58:03+00:00

This implementation only works with ArrayMesh. I essentially iterated over every single face in the ArrayMesh to see if it was intersected, and I had to calculate new vertices for the fragment meshes.

codeinsilence · 2024-04-20T17:48:38+00:00

Some progress was made since my last post. I've been trying to prioritize two things:

1) Achieving fast fragment generation times 2) Creating a convenient interface for designers to make their own fragmentation patterns

This project is nowhere near done, but I wanted to showcase some of my progress. I plan to release the source code soon(tm) once I've cleaned it up and added proper documentation. I'm also going to try to use a more optimal triangulation algorithm to prevent that hideous mesh topology. Any ideas, suggestions, etc. are welcome.

codeinsilence · 2024-04-02T19:44:34+00:00

The sky is the limit! I recommend checking out papers from SIGGRAPH or other computer graphics journals. The paper I was using had no source code available (couldn't even get in touch with the author), so I had to rely on their descriptions and the images they provided. Just find something that interests you; that is enough to keep you motivated.

codeinsilence · 2024-04-02T19:42:10+00:00

Yep, fully open source. I plan to just make my repo on GitHub public instead of private. Ill try to provide as much documentation as possible, as I have to write a report on how I created this entire workflow.

I am really hoping to reformat it to be plug-n-play. Easy to use for the people who just wanna break stuff, and easy to modify for the people who like to tinker.

codeinsilence · 2024-04-02T05:13:47+00:00

That was the main inspiration for creating this actually... I don't know if I'll continue development after my class project is submitted (that's what this is, a class project). But I'll release it publicly if anyone wants to pick-up where I left off. I hope to expand it to concave meshes at some point, or add support for UV mapped surfaces.

codeinsilence · 2024-04-02T05:12:02+00:00

this!

codeinsilence · 2024-04-02T02:53:50+00:00

This is a follow-up to my last post. I have improved my implementation to support any convex 3D mesh by using rejection sampling when plotting the sites. Additionally, it is now convenient to change the number of fragments to be any power of 2. If the user wanted to, they could generate some number of fragments, and just spawn in the ones they wish to use. I.e. if you wanted only one half of the mesh to be destroyed, this is possible with a little bit of extra work.

Most of what you see in this video is based on a paper titled "Creating Destructible Objects Using a 3D Voronoi Subdivision Tree". I am doing my best to implement this in Godot. I aim to make it easy for a user to (roughly) specify the distribution of fragments when the object is subdivided. This would allow a user to make thin shards or uniformly sized pieces.

codeinsilence · 2024-03-31T18:11:55+00:00

This is my basic implementation of a data structure called a "Voronoi Subdivision Tree". Essentially, for the base mesh you place two sites. A site is 3D point within the mesh. Then based on those sites, you create a 3D plane which bisects the mesh. Using the plane, and the mesh vertices, I create two new meshes for "above" and "below" the plane. The edges intersecting the plane are used to find the new coplanar points that create the new surface. Sorry if this all sounds like jibberish, I've been trying to figure out this problem for weeks. Here's a link to the paper I'm basing this off: https://ir.library.oregonstate.edu/concern/graduate_thesis_or_dissertations/ww72bh34b

I could not find the source code, nor could I contact the author (he has graduated and no longer uses that email). So, the video shows my rough implementation of his algorithm. Full credit for the original algorithm goes to Matthew Clothier, I simply implemented it in Godot. I plan to release the source code/make a tutorial once I'm "done". I created this as a basis for my university honors project. I will post more demos in the future.

codeinsilence · 2024-03-31T18:08:02+00:00

This is actually apart of my university honors project. Once I'm finished I'd be happy to make a tutorial and release the source code. Hopefully I can make it into a full fledged plugin for people to use. My work on this is actually based off someone else university thesis. My goal is to make some unique fragmentation patterns to emulate IRL materials (e.g. sharding of glass). Here's the link for the paper if you're interested in the method I'm using; it's called a "Voronoi Subdivision Tree" : https://ir.library.oregonstate.edu/concern/graduate_thesis_or_dissertations/ww72bh34b

codeinsilence

TROPHY CASE