/3/ - 3DCG

[Anonymous No.547521]

Does someone know how i could emulate PS1 graphics in maya?

The PS1 rendering had something that truly defined the console and gave it that feel that only it had.

I did some research and i found why its that way. Apparently if you look closely the vertices seem to snap on a grid. probably because ps1 didnt have good float values for vertices so they would snap visibly. It also seemed to do that from the camera point of view and not from the world. So points would snap if camera moved.

But then i dont really know how to do that on maya..

Anyone have a clue?

[Anonymous No.547522]

ill post a few more examples of this.

[Anonymous No.547523]

[Anonymous No.547525]

>>547521


you could find something that renders shadows really shittily and fuck with it. Get it to make those blocky shadows.

[Anonymous No.547528]

>>547521
Make low resolution textures with low color depth, models that are all low poly, turn off anti aliasing on the textures and the models, and then just use global illumination for lighting.

[Anonymous No.547532]

>>547525
>>547528
Why don't you faggots try actually reading the post

[Anonymous No.547536]

i don't think that's the problem, seems like an issue with the texture streaming/filtering.

[Anonymous No.547541]

>>547536
>▶
go on..

[Anonymous No.547543]

>>547541
https://www.youtube.com/watch?v=MZFyW48d2A0

you could be right about the vertex snapping. however i don't think there is a way to replicate it easily since 3d programs don't work backwards

[Anonymous No.547548]

I've gotten a wiggly polygon look by putting a decimatation modifier over the armature modifier but it's not the same. Would anyone notice the difference between genuine integer vertices and a lowpoly mesh with some sort of animated distortion, like a really small wave?

[Anonymous No.547551]

>>547548
The problem with this sort of thing is if its even a tiny bit different it'll look really off when compared to the original, the viewer probably wont be able to pinpoint what is off about it but the human brain is just too innaity complex that it can tell anyone that there is a difference even when not being able to come up with what the difference is, this is a problem we face with a lot of things in 3d when trying to replicate effects n dynamics ect.. Anyway good luck to OP with emulating this effect, i personally cant seem to come up with a suitable solution.

[Anonymous No.547552]

>>547548
can't you really change the interpolation method key to flat? achieve similar stuff, not quite

[Anonymous No.547603]

>>547521
really you need to write a deformer to do this, but heres how to do it for a single frame using python: (you could easily extend it to multiple frames if you dont mind having a duplicate of your mesh for each frame lol)

import pymel.core as pm

obj = pm.ls(sl=1)[0]
snapTolerance = 0.01 #change this to adjust how fucked u want it

for vert in obj.verts:
pos = vert.getPosition()
vert.setPosition([pos[0]-(pos[0]%snapTolerance),pos[1]-(pos[1]%snapTolerance),pos[2]-(pos[2]%snapTolerance)])

[Anonymous No.547606]

>>547521
Don't know about maya, but just checked it in blender, you can snap everything to the blender grid. I've tried it and it looks similar to it, but then again I'm not an artist.

[Anonymous No.547615]

>>547606
ok, after playing with it a bit, finally got to the result that may or may not be like it. This is a very extremely low precision 0.1 units, but I like the effect, although my current script is not applicable to any kind of animation.
I will investigate further, I will try and code some desktop app on opengl to see how will this be implemented, cause I don't see it being implemented into a game without the engine gridding everything, it's impossible with an armature, except maybe if the animation is done frame by frame and the bones have been gridded, but the vertex deformation is still on large floats. As for doing it on 3D applications, I don't think it's possible without hardcoding/plugins and even then it will be easier to cheat it with gridding on every frame.
For animation I suggest that you use this guy's suggestion
>>547603
But it's tiresome as fuck, best case scenario you do it only for the frame and after rendering the frame you delete the effect.

[Anonymous No.547617]

>>547615
If you want to use it for animation, here's how I'd do it in pseudo-code in Blender.

on every frame:
{
duplicate the object
on the copy apply any modifier(armature)
hide the original
grid the copy's verteces
render the scene
save the image
delete the copy
unhide the original
}

his >>547603 suggestion is destructive, only modify instances of the object, never modify the object itself, you may fuck up your model that way

[Anonymous No.547618]

>>547606
>>547615
>>547617

Cool stuff, yeah i see its doable in blender with modifiers but someone way back made a script for this in maya and i tought maybe he'd still be around.


>>547603

Would that python script work in maya?

I'm ready to offer money to anyone that can make a script to do it for every frame

[Anonymous No.547620]

A demonstration of the unstable and shaky polygons inherent in the original PlayStation(PS1/PSX) games
https://www.youtube.com/watch?v=nqw2HMUrNiA

A shader used on the game BallisticNG that mimics the same retro graphics as the PSX (Unity 5)
https://www.youtube.com/watch?v=Y3i-bcbh4Q0

Some exemples of shaders in game engines:
https://www.youtube.com/watch?v=0NJGJh6t9ZE
https://www.youtube.com/watch?v=OUbU5TbmITs
https://www.youtube.com/watch?v=2nDnKV7pKik
https://www.youtube.com/watch?v=F-k4c8cTrCg
https://www.youtube.com/watch?v=MxcLA--2v-Y

maybe it would be easier to do it on a game engine using shaders.

[Anonymous No.547621]

>>547618
yeah, it uses maya's PyMEL library

i'll paste the version for each frame in a second, though i don't recommend using it since it generates new geometry for each frame. will try to write a deformer using OpenMaya at some point

[Anonymous No.547622]

>>547618
here you go:

import pymel.core as pm

obj = pm.ls(sl=1)[0]
pm.hide(obj)
grp = pm.group(em=1,n='kek')
snapTolerance = 0.05 #change this to adjust how fucked u want it

for i in range(int(cmds.playbackOptions(q=1,min=1)),int(cmds.playbackOptions(q=1,max=1))):
pm.currentTime(i)
dupe = pm.duplicate(obj)[0]
pm.setKeyframe(dupe,t=i-1,at='visibility',v=0)
pm.setKeyframe(dupe,t=i,at='visibility',v=1)
pm.setKeyframe(dupe,t=i+1,at='visibility',v=0)
pm.parent(dupe,grp)
for vert in dupe.verts:
pos = vert.getPosition()
vert.setPosition([pos[0]-(pos[0]%snapTolerance),pos[1]-(pos[1]%snapTolerance),pos[2]-(pos[2]%snapTolerance)])
print "done: "+str(i)

[Anonymous No.547678]

>>547620
woah fuck, unity has something like that???

this gives me ideas, thanks for the links!


>>547621
>>547622

YES amazing!! Thats fine i'll probably use it at the end when im done animating.

You rock man. Here's a discord room to keep in touch for whoever is interested into doing this type of stuff. https://discord.gg/mnqy2kq

[Anonymous No.547713]

a bit late to the party, but I've been looking (unsuccessfully) for an article I read a few years back on the PSX's inter-processor communication that caused this. The answer here is correct, but I'll keep looking for more technical sources:

http://gamedev.stackexchange.com/a/26826

Maybe not directly helpful, but could get you in the right direction

TL;DR: the vector unit & rasterizer both only did fixed-point math, but you could only pass integers between the two

[Anonymous No.547716]

>>547713
this guy again with a bit of a better explanation (with links to a more technical description) but still not the one I was looking for. Link to the full thread's in the top-right:

http://www.neogaf.com/forum/showpost.php?p=126418709&postcount=86

[Anonymous No.547765]

>>547521
Its because the psx lacked z buffer, thats why when you try to grab geometry from a ps1 game it ends all flat.

[Anonymous No.547797]

>>547765
wrong
It lacked z-buffer, but polygons could be sorted offline to fix this. the Crash games on the psx (1 through Warped, Team Racing didn't have this) all had pre-computed depth rendered on SGI machines.
Second part has nothing to do with z-buffer. Most emulators flatten the rendered screen output (because that's what happened on the original hardware) for other reasons, like FX rendering.

[Anonymous No.547943]

Thanks for all you guys help and interest i didnt think anyone would be interested.

I'm very close to have the same render if i can somehow reproduce that texture wobbleness.

Here's some HD dragonball ds models for your trouble.

[Anonymous No.547955]

>>547943
Speaking of the DS, it's another system where the vertex snapping effect happens (in some games - most 3d heavy titles). Pretty interesting to see it there, given how different it is to the PSX.

I've seen this effect happen in modern (think, last decade) titles on modern consoles, too, which was odd. Polygons and vertices just shook around violently.
One of the games where I remember this happening the most was Assassin's Creed 3, mostly in cutscenes. Some games have jittering but for completely different reasons, like in GTA 4 in one of Niko's idle animations due to crap motion capture cleanup.

The grid snap effect carried on to the ps2, albeit on a much smaller scale. I remember seeing it distinctively happening in Max Payne, where a camera glitch allows you to see his model up close. The geometry warps just like in any PSX game.

Best of luck on your renders.

[Anonymous No.547988]

>>547622
>Pink_guy_dubstep.webm

I'm not trolling but seriously ask /vr/ they know more about ps1 rendering than the devs that worked on it

[Anonymous No.548052]

>>547955

Yeah, it's another case of vertices having less detailed values for positionning to save CPU?

[Anonymous No.548053]

I have heard the term polygonal jitter - Devil Daggers used it in it's rendering techniques, I don't know of it's worth looking into?

[Anonymous No.548058]

>>547943
I wish there was a way to the models from DB Origins. They're so perfectly crafted I need to know how they were made.

[Anonymous No.548413]

>>547615
that does look pretty close but the effect is too exaggerated
hope you get it to work in animation too

[Anonymous No.548426]

I have this picture about the textures.

[Anonymous No.548434]

>>548413
It does work in animation, but at the moment it does the same thing as >>547622
this script without snapping the polygons, because that script is incorrect as the values will not round to the nearest grid point, but rather to the lower multiplied number, to properly emulate the effect, you need to grid it to the nearest point, that means round the value.
basically if let's say you have a vertex at 12.745, it will be correctly round up to 12, or 12.7, whatever.
I haven't checked anything about emulating the texture stretching problems, though.

[Anonymous No.548452]

>>548434
To be really accurate, it'd have to be 12, as the console's chips used integers.

[Anonymous No.548459]

>>548434
Fixed point arithmetic units truncate rather than round...

[Anonymous No.548992]

>>547615
Couldn't you just multiply the position by like 400, floor it, and then divide by 400 in the vert shader?

[Anonymous No.549308]

>>547943

[Anonymous No.549309]

>>547943
>>548058
The Ultimate Butouden game by the same team also looks beautiful.

[Anonymous No.549310]

[Anonymous No.550027]

well shit, i never knew that
but yeah i seriously doubt a modern renderer will allow something like that