Jump to content
  • Advertisement

Search the Community

Showing results for tags 'Theory'.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Categories

  • Audio
    • Music and Sound FX
  • Business
    • Business and Law
    • Career Development
    • Production and Management
  • Game Design
    • Game Design and Theory
    • Writing for Games
    • UX for Games
  • Industry
    • Interviews
    • Event Coverage
  • Programming
    • Artificial Intelligence
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Engines and Middleware
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
  • Archive

Categories

  • Audio
  • Visual Arts
  • Programming
  • Writing

Categories

  • Game Dev Loadout
  • Game Dev Unchained

Categories

  • Game Developers Conference
    • GDC 2017
    • GDC 2018
  • Power-Up Digital Games Conference
    • PDGC I: Words of Wisdom
    • PDGC II: The Devs Strike Back
    • PDGC III: Syntax Error

Forums

  • Audio
    • Music and Sound FX
  • Business
    • Games Career Development
    • Production and Management
    • Games Business and Law
  • Game Design
    • Game Design and Theory
    • Writing for Games
  • Programming
    • Artificial Intelligence
    • Engines and Middleware
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
    • 2D and 3D Art
    • Art Critique and Feedback
  • Community
    • GameDev Challenges
    • GDNet+ Member Forum
    • GDNet Lounge
    • GDNet Comments, Suggestions, and Ideas
    • Coding Horrors
    • Your Announcements
    • Hobby Project Classifieds
    • Indie Showcase
    • Article Writing
  • Affiliates
    • NeHe Productions
    • AngelCode
  • Topical
    • Virtual and Augmented Reality
    • News
  • Workshops
    • C# Workshop
    • CPP Workshop
    • Freehand Drawing Workshop
    • Hands-On Interactive Game Development
    • SICP Workshop
    • XNA 4.0 Workshop
  • Archive
    • Topical
    • Affiliates
    • Contests
    • Technical
  • GameDev Challenges's Topics
  • For Beginners's Forum
  • Unreal Engine Users's Unreal Engine Group Forum
  • Unity Developers's Forum
  • Unity Developers's Asset Share

Calendars

  • Community Calendar
  • Games Industry Events
  • Game Jams
  • GameDev Challenges's Schedule

Blogs

There are no results to display.

There are no results to display.

Product Groups

  • Advertisements
  • GameDev Gear

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


About Me


Website


Role


Twitter


Github


Twitch


Steam

Found 121 results

  1. I'm doing my bachelor graduation project and it's about a game with somewhat realistic physics simulation. I'd like to dig a bit deeper and find some relevant research papers or books, any suggestions where to start? thanks a lot!
  2. Peter Hutsul

    What name is better for game?

    Online turn based strategy. Blazing strategy Blazing tactico Tactic of Tactico Strategy of honor Tactic of honor Strategy of Smoud Smoud tactico online Well played tactico Creature of Strategy Strategy void Void of strategy void commander Nova strategy Natural choice Natural move Supreme commander Realm of strategy Fairytale of commander Story of commander commander`s story Creatures commander Force of commander Grand commander Great commander great commander story
  3. In episode 11, Jeremy discusses how he came to realize (while playing Double Dragon IV for some reason) that games as a medium, demonstrate the peaceful coexistence of grand design, determinism, and free will in one possibility space. Jeremy also uses Super Mario Maker as another example of the triple confluence.
  4. In episode 11, Jeremy discusses how he came to realize (while playing Double Dragon IV for some reason) that games as a medium, demonstrate the peaceful coexistence of grand design, determinism, and free will in one possibility space. Jeremy also uses Super Mario Maker as another example of the triple confluence. View full story
  5. In episode 11, Jeremy discusses how he came to realize (while playing Double Dragon IV for some reason) that games as a medium, demonstrate the peaceful coexistence of grand design, determinism, and free will in one possibility space. Jeremy also uses Super Mario Maker as another example of the triple confluence.
  6. In episode 11, Jeremy discusses how he came to realize (while playing Double Dragon IV for some reason) that games as a medium, demonstrate the peaceful coexistence of grand design, determinism, and free will in one possibility space. Jeremy also uses Super Mario Maker as another example of the triple confluence. View full story
  7. ThinkSmall98

    Capsule-Capsule Detection

    Hi, I used the 3D shortest distance between two line segments algorithm at this website: http://geomalgorithms.com/a07-_distance.html#dist3D_Segment_to_Segment This function in Python is checking if two capsules intersect. I checked the algorithm from the website and it seems to work. I tried implementing an epsilon to help with floating point error, but I don't think I did it correctly. Help would be much appreciated. def check_intersection(particle1,particle2): decimal.getcontext().prec = 100 epsilon = 2**-52 #implement epsilon small_num = 0.00000001 #number to check if they're closely parallel u = particle1.get_s() #s1 v = particle2.get_s() #s2 p0 = particle1.get_p1_position() #P0 q0 = particle2.get_p1_position() #Q0 w = np.array([p0[0]-q0[0], p0[1]-q0[1], p0[2]-q0[2]]) #distance from 2 particles from their p1's a = u[0]**2 + u[1]**2 + u[2]**2 #dot product of u*u. Always >=0 b = u[0]*v[0] + u[1]*v[1] + u[2]*v[2] #dot product of u*v. c = v[0]**2 + v[1]**2 + v[2]**2 #dot product of v*v. Always >=0 d = u[0]*w[0] + u[1]*w[1] + u[2]*w[2] #dot product of u*w e = v[0]*w[0] + v[1]*w[1] + v[2]*w[2] #dot product of v*w D = (a*c)-b**2 #always >=0 #Set all to defaults sc = sN = sD = D #sc = sN / sD, default sD = D >= 0 tc = tN = tD = D #tc = tN / tD, default tD = D >= 0 if D**2 < small_num: # checks if SCs are parallel sN = 0.0 # force using point P0 on segment S1 sD = 1.0 # to prevent possible division by 0.0 later tN = e tD = c else: # get the closest points on the infinite lines sN = (b * e) - (c * d) tN = (a * e) -(b * d) if sN < 0.0: sN = 0.0 tN = e tD = c elif sN > sD: # sc > 1 => the s=1 edge is visible sN = sD tN = (e + b) tD = c if tN < 0.0: # tc < 0 => the t=0 edge is visible tN = 0.0 # recompute sc for this edge if -d < 0.0: sN = 0.0 elif -d > a: sN = sD else: sN = -d sD = a elif tN > tD: # tc > 1 => the t=1 edge is visible tN = tD # recompute sc for this edge if (-d + b) < 0.0: sN = 0.0 elif (-d + b) > a: sN = sD else: sN = (-d + b) sD = a # division to get sc and tc if abs(sN) < small_num: sc = 0.0 else: sc = sN / sD if abs(tN) < small_num: tc = 0.0 else: tc = tN / tD # difference of 2 closest points dP = np.array( [w[0] + (sc * u[0]) - (tc * v[0]), w[1] + (sc * u[1]) - (tc * v[1]), w[2] + (sc * u[2]) - (tc * v[2])] ) # dP = w + np.multiply(sc,u) - np.multiply(tc,v) #S1(sc) - S2(tc) close_d = (math.sqrt(dP[0] ** 2 + dP[1] ** 2 + dP[2] ** 2) ) # closest distance b/w 2 lines # check if distance <= radius * 2, if so, INTERSECTION! diff = abs( close_d - (2*S_RADIUS) ) if(diff <= epsilon): return True else: return False
  8. Hello, It's my first time posting anything on this forum but I thought it was time to step up my knowledge about gaming theory and game design if I want to get into the industry. I have a lot of ideas of games that would be great. I write everything, draw characters, right stories, design and think about gameplay mechanics etc. A day I had an epiphany about a fighting game with Sekiro's gameplay. I know of course there would be a lot of problems with...camera being wonky, the guard bar must be readjusted, and the major problem would be the deflect spamming. But personally I think that with some adjustments, great character, some risk reward (like you can cancel an attack to throw of your opponent or if you try to deflect and miss your deflect you get punished for 'spamming') mechanics, It would be an engaging experience. It would be intuitive, easy to learn hard to master and mind games. Of course, I write all of this because I intent to begin digging a bit deeper with that idea. If any of you think this is crap or it is the wrong section of the forum feel free to report me. Sorry if it is the case ^^. Hope it will interest anybody.
  9. So, in real life, incoming dot normal at the silhouette is always 0. With smooth shaded meshes, it never is, not naturally, not outside of contrived situations. (Not with flat shaded meshes either, I guess.) And incoming dot normal is one of the bedrocks of CG. Probably the equal of 4x4 matrix multiplication. Problems with silhouette normals show up in Fresnel, in diffuse lighting, in environment mapping.... everywhere. But I can't really find anybody talking about it. (Maybe I'm not Googling the right terms.) Obviously, the problem decreases as poly count goes up, eventually reaching a point where it's dwarfed by other silhouette problems (like translucency or micro-occlusion) that CG doesn't handle well either. But, if I'm reasoning correctly, normal maps don't improve the problem-- they're as likely to exacerbate it as improve it, and the exacerbations are, aesthetically speaking, probably worse than the improvements are better. I've tried playing with crude fixes-- basically, rotating normals toward incoming by a percentage, or of course clamping incoming dot normal (like we all have to do) to prevent it from bending behind the mesh. Nothing I've tried looks good. I suppose the best option might be to rotate normals to perpendicular to incoming at the silhouette and then interpolate to the nearest inflection point of something like screen space depth to preserve curvature, but the math for how to do that is beyond me, and I'm not sure it would look any better. Or maybe, instead, somehow, adjust the drawn silhouette to match the silhouette defined by incoming dot normal? Not even sure how that would work, not if the normal was pointing away from incoming. I don't know-- is this a solvable problem? Has anyone tried other stuff and given up, pursued anything that was promising but too expensive, anything like that? Are there any papers I'm missing? It's really surprising to me that I can't find anyone else talking about this. (Apologies if I chose the wrong subforum for this. I considered art forums, but I felt that people frequenting the programming forums would have more to say on the subject.)
  10. I'm trying to calculate normals of my grid surface. The map is 29952px x 19968px and each cell is 128px x 128px. So I have 36895 vertices. My flat map array is sent to shaders with the following structure: float vertices[368950] = { // x y z znoise xTex yTex xNorm yNorm zNorm Type 16384,16256,-16256, 0, 0.54, 0.45, 0, 0, 1, 1, 16256,16384,-16384, 0, 0.54, 0.45, 0, 0, 1, 1, ...... } I calculate the zNoise with a function float noise(float x, float y){}; And it works (I ad