Jump to content

  • Log In with Google      Sign In   
  • Create Account

Banner advertising on our site currently available from just $5!


1. Learn about the promo. 2. Sign up for GDNet+. 3. Set up your advert!


Allen Chou

Member Since 15 Jul 2010
Online Last Active Today, 12:56 AM

Topics I've Started

Game Math: More on Numeric Springing

Yesterday, 02:39 AM

Original Blog Post with Pretty Equations
  
This post is part of my Game Math Series.  
  
Previously, I talked about numeric springing and provided some examples.  
  
I have been saving up miscellaneous topics I would like to discuss about numeric spring, and now I have enough to write another post. Here are the topics:  
  
1. Using The Semi-Implicit Euler Method  
2. Numeric Springing vs. Tweening  
3. Half-Life Parameterization  
  
Using The Semi-Implicit Euler Method
  
Recall the differential equation for a damped spring:  
  
(d^2 x)/(d t^2) + 2 zeta omega (d x)(d t) + omega^2 (x - x_t) = 0  
  
And the equations for simulating such system obtained by the implicit Euler method:  
  
x_{i+1} &= Delta_x / Delta  
v_{i+1} &= Delta_v / Delta  
  
where:  
  
Delta = (1 + 2 h zeta) + h^2 omega^2  
Delta_x = (1 + 2 h zeta omega) x_i + h v_i + h^2 omega^2 x_t  
Delta_v = v_i + h ^2 (x_t - x_i)  
  
I presented the equations obtained by the implicit Euler method, because they are always stable. We can obtain a different set of equations that can also be used to simulate a damped spring system by the semi-implicit Euler method[/b]:  
  
v_{i+1} = (1 - 2 h zeta omega) v_i + h omega^2 (x_t - x_i)  
x_{i+1} = x_i + h v_{i+1}  
  
The equations obtained by the semi-implicit Euler method involve much less arithmetic operations, compared to the equations obtained by the implicit Euler method. There is a catch: the equations obtained by the semi-implicit Euler method can be unstable under certain configurations and the simulation will blow up over time. This can happen when you have a large zeta and omega. However, the zeta and omega on most use cases are far from the breaking values. You would almost never use an overdamped spring, so zeta is usually kept under 1. Even if zeta is set to 1 (critically damped spring), omega can be safely set up to 10 pi (5Hz), which is a very fast oscillation you probably would never use on anything.  
  
So, if your choice of zeta and omega result in a stable simulation with the equations obtained by the semi-implicit Euler method, you can use them instead of the equations obtained by the implicit Euler method, making your simulation more efficient.  
  
Here's a sample implementation:  
  
    /*
      x     - value             (input/output)
      v     - velocity          (input/output)
      xt    - target value      (input)
      zeta  - damping ratio     (input)
      omega - angular frequency (input)
      h     - time step         (input)
    */
    void SpringSemiImplicitEuler
    (
      float &x, float &v, float xt, 
      float zeta, float omega, float h
    )
    {
      v += -2.0f * h * zeta * omega * v 
           + h * omega * omega * (xt - x);
      x += h * v;
    }
  
  
Numeric Springing vs. Tweening
  
Numeric springing and tweening (usually used with the famous Robert Penner's easing equations[\url] might seem very similar at first, as they are both techniques to procedurally animate a numeric value towards a target value; however, they are actually fundamentally different. Tweening requires a pre-determined duration; numeric springing, on the other hand, does not have such requirement: numeric springing provides a simulation that goes on indefinitely. If you were to interrupt a procedural numeric animation and give it a new target value, numeric springing would handle this gracefully and the animation would still look very natural and smooth; it is a non-trivial task to interrupt a tweened animation, set up a new tween animation towards the new target value, and prevent the animation from looking visually jarring.  
  
Don't get me wrong. I'm not saying numeric springing is absolutely superior over tweening. They both have their uses. If your target value can change dynamically and you still want your animation to look nice, use numeric springing. If your animation has a fixed duration with no interruption, then tweening seems to be a better choice; in addition, there are a lot of different easing equations you can choose from that look visually interesting and not necessarily have a springy feel (e.g. sine, circ, bounce, slow-mo).  
  
  
Half-Life Parameterization
  
Previously, I proposed a parameterization for numeric springing that consisted of 3 parameters: the oscillation frequency f in Hz, and the fraction of oscillation magnitude reduced p_d over a specific duration t_d due to damping.  
  
I have received various feedback from forum comments, private messages, friends, and colleagues. The most suggested alternative parameterizatoin was the half-life parameterization, i.e. you specify the duration when the oscillation magnitude is reduced by 50%. This seems like a fair suggestion; thus, I'll to show you how to derive zeta to plug into numeric springing simulations, based on a given half-life.  
  
I'll use lambda to denote half-life. And yes, it is the same symbol from both Chemistry and the game.  
  
As previously discussed, the curve representing the oscillation magnitude decreases exponentially with this curve:  
  
x(t) = e^ {-zeta omega t}  
  
By definition, half-life is the duration of reduction by 50%:  
  
x(lambda) = e^ {-zeta omega lambda} = 0.5  
  
So we have:  
  
zeta omega = -ln(0.5) / lambda  
  
Once we decide the desired lambda, we lock in omega and compute zeta:  
  
zeta = -ln(0.5) / (omega lambda)  
  
And here's a sample implementation:  
  
    void SpringByHalfLife
    (
      float &x, float &v, float xt, 
      float omega, float h, float lambda
    )
    {
      const float zeta = (-lambda / omega) * ln(0.5f);
      Spring(x, v, xt, zeta, omega, h);
    }
  
Here's a graph showing lambda = 0.5 and omega = 4 pi (2Hz). You can clearly see that the oscillation magnitude is reduced by 50% every half second, i.e. 25% every second.  
  
underdamped.png
  
  
Conclusion
  
I've discussed how to implement numeric springing using the faster but less stable semi-implicit Euler method, the difference between numeric springing versus tweening, and the half-life parameterization of numeric springing.  
  
I hope this post has given you a better understanding of various aspects and applications of numeric springing.


Apparently, Game Devs Are Considered Non-Threatening to US National Security at All

25 April 2015 - 04:00 AM

 
I would like to share an interesting story about my past two visits to American Institute in Taiwan (AIT).
 
For people in Taiwan to study or work in the US, they need a student visa or a work visa. Visas are acquired by interviewing with an official at one of the two AIT offices. Luckily, one of them is very close to where I lived in Taipei.
 
I went to AIT to get my student visa for DigiPen in 2011, as well as my work visa stamp for Naughty Dog in 2015. My experience with both visits told me that, apparently, game devs are considered non-threatening to US national security at all.
 
My Student Visa (2011)
 
This was my first time interviewing at AIT by myself. When I had visited the US with my family before this, it was my parents who did the talking at the interviews for visitor visas.
 
As I got in line at the AIT office, I started practicing the interview in my head, trying to prepare my self with acceptable answers for various possible questions related to national security. When I got closer to the interview booths, I tried to eavesdrop on the interviews to get a better idea on what sort of questions were asked.
 
For many people before me, they were asked tons of security questions, and a few of them got rejected. As I heard more questions and saw people getting rejected, I became more and more nervous.
 
Then, it was my turn.
 
I went up to the booth, and the interviewer took my documents.
 
"You're going to study in the US?"
 
"Yes, sir."
 
"This school. DigiPen. What are you studying there?"
 
"Making video games."
 
"Oh? What type of games do you play?"
 
"...Sorry?"
 
"I said what type of games do you play?"
 
"Uh...mostly action games and platformers."
 
"Really? Like what?"
 
"Well...like the Assassin's Creed series...and the Uncharted series."
 
"Ah. I've never got to play Assassin's Creed, but I play a lot of Call of Duty."
 
"Um...I'm not that into shooters."
 
"I see. You should try."
 
"I did play some shooters, but not much."
 
"Okay. I see. Thank you."
 
Then the the interviewer stamped my passport and gave me my documents.
 
"So...." I was confused.
 
"You're good to go! The exit is right over there."
 
That was the entire interview. Not a single national-security question asked.
 
 
My Work Visa Stamp (2015)
 
After leaving DigiPen in April 2014, I started working at Naughty Dog in May 2014 without leaving the US. For the first few months, I was working under Optional Practical Training (OPT), which is an extension program that allows new grads to stay and work in the US for a year, with a possible 17-month extra extension.
 
Work visas are issued en mass around October by lottery. I got my work visa in October 2014 (the chance of getting one was about 50% in 2014). However, I had to get a physical work visa stamp on my passport from AIT if I wanted to leave the US and come back later. I had planned a trip to Korea earlier this year in March, so I had to arrange a visit back to Taiwan after Korea.
 
Again, I was in line at AIT. This time I was less nervous based on the experience from last time. Then, it was my turn for the interview.
 
"So you need a work visa stamp, huh?"
 
"Yes."
 
"Ooooh. Naughty Dog. I know this company. You guys make video games, right?"
 
"Yes."
 
Then the interviewer quickly stamped my passport and returned my other documents.
 
"Here you go. Have a nice day!"
 
And that was it. It took me less then a minute, which was unbelievably quick compared to other interviewees.
 
Apparently, game devs are considered non-threatening to US national security at all.
 
They probably don't know that some game devs (like Zombie Studios) make serious games for military training purposes. Oh well.

Game Math: Numeric Springing Examples

11 April 2015 - 11:52 AM

  
This post is part of my Game Math Series.  
  
So, you have seen how to precisely control numeric springing in my previous post.  
  
I showed this animation as an example.  
  
spring.gif
  
Letting artists manually fine-tune the animation with animation curves probably will give better results, if it's fixed animation, that is.  
  
One big advantage of numeric springing over animation curves is that it can be dynamic and interactive. I will show you several examples in this post.  
  
Before that, let's quickly review the spring function presented in my previous post.  
  
    /*
      x     - value             (input/output)
      v     - velocity          (input/output)
      xt    - target value      (input)
      zeta  - damping ratio     (input)
      omega - angular frequency (input)
      h     - time step         (input)
    */
    void Spring
    (
      float &x, float &v, float xt, 
      float zeta, float omega, float h
    )
    {
      const float f = 1.0f + 2.0f * h * zeta * omega;
      const float oo = omega * omega;
      const float hoo = h * oo;
      const float hhoo = h * hoo;
      const float detInv = 1.0f / (f + hhoo);
      const float detX = f * x + h * v + hhoo * xt;
      const float detV = v + hoo * (xt - x);
      x = detX * detInv;
      v = detV * detInv;
    }
  
Positional Springing  
  
We can dynamically set the target position based on user input and have object spring to the target position accordingly.  
  
button-spring.gif
  
Here's the code for this example:
 
    void OnButonClicked(int buttonIndex)
    {
      obj.targetY = buttons[buttonIndex].positionY;
      obj.velocityY = 0.0f;
    }
    
    void Update(float timeStep)
    {
      Spring
      (
        obj.positionY, obj.velocityY, obj.targetY, 
        zeta, omega, timeStep
      );
    }
  
Rotational Springing  
  
Numeric springing can also be used to make a pointer try align itself to the mouse cursor.  
  
angular-spring.gif
  
Here's the code for this example:  
  
    void Init()
    {
      obj.angle = 0.0f;
      obj.angularVelocity = 0.0f;
    }
    
    void Update(float timeStep)
    {
      obj.targetAngle = 
        Atan2(obj.positionY - mouse.y, obj.positionX - mouse.x);
    
      Spring
      (
        obj.angle, obj.angularVelocity, obj.targetAngle, 
        zeta, omega, timeStep
      );
    }
  
Animation Springing  
  
We can even apply numeric springing to the frame number of an animation, creating a dynamic animation that has a springy feel.  
  
Giving this animation below:  
  
animation-spring-raw.gif
  
If we apply numeric springing to the frame number shown based on the mouse position, we get this effect:  
  
animation-spring.gif
  
Pretty neat, huh?  
  
And here's the code for this example:  
  
    void Init()
    {
      x = 0.0f;
      v = 0.0f;
    }
    
    void Update(float timeStep)
    {
      xt = mouse.x;
    
      Spring
      (
        x, v, xt, 
        zeta, omega, timeStep
      );
    
      obj.frame = int(obj.numFrames * (x / window.width));
    }
  
Orientational Springing  
  
Lastly, let's bring numeric springing to the third dimension.  
  
cube-spring.gif
  
Here's the code for this example:  
  
    void Init()
    {
      angle = 0.0f;
      angularVelocity = 0.0f;
      targetAngle = 0.0f;
      tiltDirection.Set(0.0f, 0.0f, 0.0f);
    }
    
    void Update(float timeStep)
    {
      if (mouse.isPressed) // true for one frame pressed
      {
        pressPosition.x = mouse.x;
        pressPosition.y = mouse.y;
      }
    
      if (mouse.isDown) // true when held down
      {
        const float dx = mouse.x - pressPosition.x;
        const float dy = mouse.y - pressPosition.y;
        tiltDirection.Set(dx, 0.0f, dy);
        targetAngle = Sqrt(dx * dx + dy * dy);
      }
    
      Spring
      (
        angle, angularVelocity, targetAngle, 
        zeta, omega, timeStep
      );
    
      const Vector axis = Cross(yAxis, tiltDirection);
      obj.orientation = OrientationFromAxisAngle(axis, angle);
    }
  
  
End of Numeric Springing Examples  
  
That's it!  
  
I hope these examples have inspired you to get creative with numeric springing. :)  

Game Math: Precise Control over Numeric Springing

08 April 2015 - 10:11 AM

 
This post is part of my Game Math Series.
 
Numeric springing is a very powerful tool for procedural animation. You specify the initial value, initial velocity, target value, and some spring-related parameters; the result is a smooth springing effect. You can apply this technique to all sorts of numeric properties, some common ones being position, rotation, and scale of an object.
 
spring.gif
 
 
The Common But Designer-Unfriendly Way
 
Here is a common, yet designer-unfriendly, implementation of numeric springing. Let x_i and v_i denote the numeric value and velocity, respectively, at frame i; and let k, d, h, x_t, denote the spring stiffness, damping factor, time step between frames, and target value, respectively.   
  
    v_{i+1} = d * v_i + h * k * (x_t - x_i)  
    x_{i+1} = x_i + h * v_{i+1}  
  
Let's dissect this implementation.  
  
The difference between the target value and the current value (x_t - x_i) contributes to the velocity change after multiplied by the spring stiffness k. The larger the difference and spring stiffness, the larger the change in velocity.  
  
The new velocity v_{i+1} inherits the value from the old velocity v_i scaled by the damping factor d, which should be a value between zero and one. If the damping factor is equal to one, then no scaling happens, and the new velocity completely inherits the value from the old velocity. If the damping factor is a fraction of one, then the magnitude of oscillation will decrease gradually.  
  
That seems all reasonable and good, but just what exactly are the values for k and d do we need to achieve a specific springing effect, say an oscillation at 5Hz frequency and the oscillation magnitude decreases 90% every one second? Many people just decide to bite the bullet and spend a large amount of time hand-tweaking the values for k and d, until the result is acceptably close to the desired effect.  
  
  
We Can Be Exact
  
Now let's take a look at the differential equation for a damped spring system centered around x = x_t.  
  
    x'' + 2 * zeta * omega * x' + omega^2 * (x - x_t) = 0,   
  
I won't go into details as to how this equation is derived. All you really need to know is that omega and governs how the system behaves and what they mean.  
  
Omega is the angular frequency of the oscillation. An angular frequency of 2 pi (radians per second) means the oscillation completes one full period over one second, i.e. 1Hz.  
  
Zeta is the damping ratio. A damping ratio of zero means there is no damping at all, and the oscillation just continues indefinitely. A damping ratio between zero and one means the spring system is underdamped; oscillation happens, and the magnitude of oscillation decreases exponentially over time. A damping ratio of 1 signifies a critically damped system, where this is the point the system stops showing oscillation, but only converging to the target value exponentially. Any damping ratio above 1 means the system is overdamped, and the effect of springing becomes more draggy as the damping ratio increases.  
  
Here's a figure I borrowed form Erin Catto's presentation on soft constraints, to show you the comparison of undamped, underdamped, critically damped, and overdamped systems.  
  
damping-ratios.png
  
Below are the equations for simulating a damped spring system using the implicit Euler method.  
  
    x_{i+1} = x_i + h * v_{i+1}  
    v_{i+1} = v_i - h * (2 * zeta * omega v_{i+1}) - h omega^2 * (x_{i + 1} - x_t)  
  
Solving x_{i+1} and v_{i+1} in terms of x_i and v_i using Cramer's rule, we get:  
  
    x_{i+1} = Delta_x / Delta  
    v_{i+1} = Delta_v / Delta  
  
where:  
  
    Delta = (1 + 2 * h * zeta * omega) + h^2 * omega^2  
    Delta_x = (1 + 2 h * zeta * omega) x_i + h * v_i + h^2 * omega^2 * x_t  
    Delta_v = v_i + h * omega^2 * (x_t - x_i)  
  
Below is a sample implementation in C++. The variables x and v are initialized once and then passed into the function by reference every frame, where the function keeps updating their values every time it's called.  
 
    /*
      x     - value             (input/output)
      v     - velocity          (input/output)
      xt    - target value      (input)
      zeta  - damping ratio     (input)
      omega - angular frequency (input)
      h     - time step         (input)
    */  
    void Spring  
    (  
      float &x, float &v, float xt, 
      float zeta, float omega, float h  
    )  
    {  
      const float f = 1.0f + 2.0f * h * zeta * omega;  
      const float oo = omega * omega;  
      const float hoo = h * oo;  
      const float hhoo = h * hoo;  
      const float detInv = 1.0f / (f + hhoo);  
      const float detX = f * x + h * v + hhoo * xt;  
      const float detV = v + hoo * (xt - x);  
      x = detX * detInv;  
      v = detV * detInv;  
    }  
  
  
Designer-Friendly Parameters
  
Now we have our formula and implementation all worked out, what parameters should we expose to the designers from our spring system so that they can easily tweak the system?  
  
Inspired by the aforementioned presentation by Erin Catto, I propose exposing the oscillation frequency f in Hz, and the fraction of oscillation magnitude reduced p_d over a specific duration t_d due to damping.  
  
Mapping f to omega is easy, you just multiply it by 2 pi:  
  
    omega = 2 * pi * f  
  
Mapping p_d and t_d to zeta is a little bit more tricky.  
  
First you need to understand that the oscillation magnitude decreases exponentially with this curve:  
  
    y(t) = e^{-zeta * omega * t}  
  
After plugging in p_d and t_d, we get:  
  
    y(t_d) = e^{-zeta * omega * t_d} = p_d  
  
So we can solve for zeta:  
  
    zeta = ln(p_d)} / (-omega * t_d)  
  
For example, if we want the oscillation to reduce 90% (p_d = 0.1) every 0.5 second (t_d = 0.5) with oscillation frequency 2Hz (omega = 4 pi), then we get:  
  
    zeta = ln(0.1)} / (-4 * pi * 0.5) = 0.367  
  
  
Conclusion
  
Numeric springing is a very powerful tool for procedural animation, and now you know how to precisely control it. Given the desired oscillation frequency and percentage of oscillation magnitude reduction over a specific duration, you can now compute the exact angular frequency omega and damping ratio zeta necessary to create the desired springing effect.  
  
By the way, let's look at the animated example shown above again:  
  
spring.gif
  
This animation was created with omega = 8 pi (4 full oscillation periods per second) and zeta = 0.23 (oscillation magnitude reduces 99.7% every second).  

GDC Social Tips

25 January 2015 - 04:24 AM

Hi, all:
 
I wrote some GDC social tips on my blog. I hope you find this useful smile.png
 
Blog Post Link
 
I wrote some tips on meeting people at GDC a while ago. It was the GDC that lead me to my current job (more on this here). Recently, I got some friends asking me for advice on breaking into the game industry, how to present yourself, and how to meet people at GDC. So I decided to write another post about it. This will be a collection of what I learned from the Career Service Center and the career workshops at DigiPen, plus my own experience.
 
These tips worked for me, but they might not suit everyone. Feel free to disregard any of them at your discretion.
 
Email, Twitter, Domain Name
 
Before doing anything else, you should have a professional-looking email address. Don't use random internet names like AwesomeDude7345; that makes your address look unprofessional. Make sure the only thing present in the name part of the address is your name. The email address I share with people is MingLun.Chou[at]gmail.com.
 
Applying the same rule to your Twitter handle and domain name can help them appear more professional as well. My Twitter handle is TheAllenChou, and my domain name is AllenChou.net. Of course, you can always throw in some variation if that helps express more about yourself, such as JasonGameDev.net or AmysArt.net.
 
LinkedIn
Get a LinkedIn account, period. LinkedIn is a professional social network where you can build online professional connections. You can join groups and follow companies on LinkedIn. Your profile page is the place to show people your professional side; maintain it well. Many recruiters actively look for potential hires on LinkedIn by going through his/her 1st, 2st, and 3rd degree connections. It is important that you build connections with people in the industry on LinkedIn. I constantly receive messages on LinkedIn from recruiters in the game industry and software engineering industry.
 
You can customize your LinkedIn profile page's URL. Choose one that follows the aforementioned rule for your email address. My LinkedIn profile page URL is linkedin.com/in/MingLunChou.
 
Business Cards
Always keep a stack of business cards with you, so you are prepared when the time has come for you to exchange contact information, or when you just want to present yourself to others. To make yourself appear more professional, use a card holder. It looks much more professional to pull out business cards from a card holder than from a jeans pocket.
 
After you give someone your business card and leave, that person might want to write down some notes about you on your business card, so they can still remember you after meeting many other people at GDC. Choosing a material that is easy to write on for your business card would make this process easier, as well as using a light color on the back of your card and leaving some writing space.
 
Make sure your name is the most noticeable text element on your business card. If you want to, just use a few stand-alone words to describe your profession. Don't try to squeeze a wall of text that describes every positive thing you have to say about yourself. Once I received a card with a wall of text, saying how passionate a designer the person is and his many holy life goals as a designer. I read the first few sentences and put the card away, never bothering finishing it. This is a business card, not a cover letter.
 
Below is my current business card design. My name is the largest text element and is at the direct center. I put down four of my primary professional skills (Physics, Graphics, Procedural Animation, and Visuals) below my name. My contact information is at the bottom, including my website URL, email address, LinkedIn profile URL, Twitter handle, and Google+ handle.
 
business-card.jpg
 
Resumes
 
Most recruiters prefer resumes with only one page, but some recruiters prefer two pages. So I just keep my resume one-page.
 
If you want to send a resume to a company that you are applying for, always tailor the resume to fit the company. One company, one specific resume. Look for the requirements for the position you are applying for on the company's website, and make sure they are the first things on your resume. Also, do not forget to include an objective line that states the position you intend to apply for.
 
In addition, prepare a generic version of the resume. This way, you can show it on your website, and present it at the company booths in the expo hall at GDC.
 
Personal Branding
 
Personal branding is optional, but it is a powerful tool if done right.
I put down Long Bunny, a little character I designed, on my business cards, resumes, and this website.
 
long-bunny-e1422170764705.png
 
At first, I designed Long Bunny just for fun, because I love bunnies. Then, I thought I could fill it in the extra space on my business cards and resumes. This turned out to be the right thing to do, and Long Bunny became my personal branding.
 
On a Sucker Punch company day at DigiPen, I gave the recruiter my business card and resume. The next time I talked to her at another company day one year later, she did not recognize me at first. But after I showed her my business card, she instantly remembered me, saying it's because of the Long Bunny. Also, in all my follow-up emails (a separate tip that will be covered later), I start with "Hi, I'm Allen Chou. My business card has a long bunny on it." Most people would remember me because of my personal branding.
 
The W Hotel Lobby
 
At GDC, it is well known that many attendees who want to socialize and do not have a party to go to will hang out at the lobby bar of The W Hotel. If you want to meet people from the game industry at GDC and have no party on your list, then The W Hotel is the place to go. My friends and I usually come back from the afternoon GDC activities to our hotel and chill out until 8pm. Then we would head out to The W Hotel's lobby bar. That is where we meet new people from the industry and introduce ourselves. We usually stay there at least until 11pm, and would stay longer if we are in a long conversation.
 
Starting A Conversation
 
The hardest part to meeting people is to start a conversation. The first time I went to GDC, I was too shy to walk up to a stranger and start talking. This is a skill you must practice if you want to meet people.
 
There is really nothing scary about opening a conversation. Almost everyone at The W Hotel's lobby bar during GDC is in the game industry, very laid back, and welcomes conversations. Just pick someone that does not seem to be occupied, say hi, and introduce yourself. I usually start with what I do and then ask what the other person does, and then at some point casually ask for a business card exchange, either by saying "here's my business card" or "hey, do you have a business card?" It's that simple.
 
If you feel like the conversation needs to be ended, either because the other person appears to be not interested in talking any more, or you are running out of things to say, say "nice meeting/talking to you", "I'm gonna take off", and leave. No hassle.
 
Follow-Ups
 
Following up with an email is very important after obtaining contact information. After the person that has given you his/her business card leaves, write down notes about the conversation you had and reminders for sending the person your work or resumes (if asked). Within 48 hours, write an email to re-introduce yourself, make comments on the conversation, and thank the person for talking to you. This shows that you care. Also, be sure to connect with the person on LinkedIn if you can find his/her page.
 
Tablets
 
I always bring a tablet with me to GDC, loaded with demo reels. I actively look for opportunity during a conversation to pull out my tablet and demonstrate my work. I also upload the demo reels to my phone, just in case my tablet runs out of battery.
 
Notepads & Pens
 
It's convenient to carry a mini notepad and a pen with you at all times. GDC is quite a busy event, and people can quickly run out of business cards. When you give someone your business card and the person is out of cards, you can ask the person to write down contact information on your notepad with your pen.
 
That's It
 
I hope these tips will help you prepare for the upcoming GDC this year. Go meet people and have fun!

PARTNERS