Molly Rocket

New CUDA LLVM compiler

NeARAZ — Fri May 11, 2012 2:25 pm

Author: NeARAZ

Posted: Fri May 11, 2012 2:25 pm

CUDA is very much like OpenCL. Except CUDA works on NVIDIA hardware only; but that gives it a bit more control in some places.

Can one write a pure function in C?

jai — Fri Apr 27, 2012 8:47 pm

Author: jai

Posted: Fri Apr 27, 2012 8:47 pm

Here's John Carmack talking about functional approaches to C++ and pure functions:

http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/

Is this Ryg's blog? [answered: yes]

jai — Wed Apr 25, 2012 6:27 pm

Author: jai

Posted: Wed Apr 25, 2012 6:27 pm

Cool. Was working on my matrix multiplication code and stumbled on his article. At the end of it I was like: "Hey let's see what else this guy has," and low and behold there was 'ryg' at the top. Small internet.[/list]

if you can use this, enjoy

jai — Wed Apr 18, 2012 2:52 am

Author: jai

Posted: Wed Apr 18, 2012 2:52 am

Was updating some old artwork. Thought some of the folks here might like to use this, so I'd like to share. It's yours! It's free! It's handy.

Uploaded a 2048 but it disappeared.

Are the interactive dev tools we were talking about here now

jetro — Mon Mar 26, 2012 9:59 am

Author: jetro

Posted: Mon Mar 26, 2012 9:59 am

My approach so far has been to use the "style objects" what NeARAZ suggested. I have a Style base which has these things: is key focus allowed?, activates from up / down event?, hit testing for given x & y, render this widget. A style object is then always passed to imgui, e.g.: if (imgui.button(id, x, y, style)) { ... }. This way the actual UI core is pretty small and doesn't actually draw anything.

About the state thing for transitions etc, I have just shoved up some of that stuff to a customized style object, or in the app side. At times that has ended up in a bit messy code at the place which needs the UI, having some animating stuff and state conditions where it feels like it is annoying fluff.

I have thought about the ability to be data-driven from UI config, and mix that with custom IMGUI driven from code. I have an idea that it could work out just nicely by using string ids and maybe some default cfg in code: if (imgui.button("main.options", defaultX, defaultY)) { ... }
And then have the imgui system check if there is loaded definition for "main.options" - if there is, use all the info from there, or otherwise put that button right at the default X,Y. But I haven't actually done & tested this approach in a project yet to have actual experiences.

Frameless Rendering

sean — Sat Mar 24, 2012 12:17 am

Author: sean

Posted: Sat Mar 24, 2012 12:17 am

I don't hear graphics programmers saying that at all; I hear them saying 'our image quality is so far from film quality it's embarassing, let's fix that'. But maybe we listen to different graphics programmers.

my indie games site SloppyNinja.com

sloppyninja — Tue Mar 13, 2012 11:55 pm

Author: sloppyninja

Posted: Tue Mar 13, 2012 11:55 pm

Hi guys,

I opened a new site for my independent games at :
http://sloppyninja.com

i'd appreciate comments and suggestions.

thanks

GJK and EPA in C++ & SFML (2D)

Zylinski — Tue Mar 06, 2012 2:00 am

Author: Zylinski

Posted: Tue Mar 06, 2012 2:00 am

Hi fourms!
I made an 2D implementation of GJK and EPA (Expanding Polytope Algorithm, for handling collision response, goes great with GJK) in C++. It's made to work out of the box with SFML 2.0! It's complete with a "test application".

It's based one these two great guides:
http://www.codezealot.org/archives/88
http://www.codezealot.org/archives/180

You can find a post about the algorithms, a more in-depth description and links to the actual code on my blog: http://blog.zylinski.se/?p=251. Direct link to just the code: http://files.zylinski.se/KarlZylinskiGJKandEPA.cpp

Code:

/*
GJK & EPA algorithm for 2D SFML.
Written by Karl Zylinski, use it however you want!
Follow me on twitter: http://twitter.com/KarlZylinski and on my programming blog: http://zylinski.se
Got questions? Email karl@zylinski.se or add karl.zylinski on Skype!

Written with the help of these excellent tutorials:
http://www.codezealot.org/archives/88 (GJK)
http://www.codezealot.org/archives/180 (EPA)
*/

#include <SFML/Graphics.hpp>
#include <SFML/Graphics/ConvexShape.hpp>
#include <iostream>

// We need these two static and global to be able to modify them from our handle-function!
static sf::ConvexShape B;
// Velocity of moveable rectangle (B)
static sf::Vector2f vel;

/*
FUNCTIONS SHARED BY GJK&EPA BEGINS HERE
*/

float dot(const sf::Vector2f& v1, const sf::Vector2f& v2){
return (v1.x * v2.x + v1.y * v2.y);
}

// A simplex is just a list of points. It contains 2-3 points for GJK algorithm and 3+ for EPA.
typedef std::vector<sf::Vector2f> Simplex;

// Find point furthest away in a particular direction in a shape
size_t GetFurthestInDirection(const sf::ConvexShape& shape, const sf::Vector2f& direction){
// transform is needed to get correct position from rectangleshapes, otherwise you just end up with points at the origin
// if the algorithm is modified to use another form of shapes which, this can probably be removed
const sf::Transform& shapeTrans = shape.GetTransform();

float furthestDot = dot(shapeTrans.TransformPoint(shape.GetPoint(0)), direction);
size_t furthestIndex = 0;

for(size_t i = 0; i < shape.GetPointCount(); ++i){
   // if the dot product between the point and the diretion is larger than any other point in the shape, it's furthest away
   float curDot = dot(shapeTrans.TransformPoint(shape.GetPoint(i)), direction);
   if(curDot > furthestDot){
      furthestDot = curDot;
      furthestIndex = i;
   }
}

return furthestIndex;
}

// This returns a single vector in the minkowski sum which also is furthest away in the specified direction (this avoids using points which aren't part of the minkowski difference hull). Used by both EPA & GJK algorithm
sf::Vector2f Support(const sf::ConvexShape& shape1, const sf::ConvexShape& shape2, const sf::Vector2f& direction){
sf::Vector2f p1 = shape1.GetTransform().TransformPoint(shape1.GetPoint(GetFurthestInDirection(shape1, direction)));
sf::Vector2f p2 = shape2.GetTransform().TransformPoint(shape2.GetPoint(GetFurthestInDirection(shape2, -direction)));

sf::Vector2f p3 = p1 - p2;

return p3;
}

/*
FUNCTIONS SHARED BY GJK&EPA ENDS HERE
*/

/*
EPA ALGORITHM BEGINS HERE
epa begins with the simplex from the GJK-algorithm which was used to find the collision. It then expands it until it finds the edge of the polygon!
*/

// A edge described using a normal, used by EPA algorithm
struct Edge {
sf::Vector2f normal;
float distance;
size_t index;
};

// Finds the edge closest to the origin in the simplex
Edge FindClosestEdge(const Simplex& simplex){
Edge closest;

// set distance to maximum of a float
closest.distance = FLT_MAX;

for(size_t i = 0; i < simplex.size(); ++i){
   size_t j = i + 1 == simplex.size() ? 0 : i + 1;

   // i is the current point in the simplex and j is the next

   const sf::Vector2f& a = simplex.at(i);
   const sf::Vector2f& b = simplex.at(j);

   // find our edge
   sf::Vector2f e = b - a;

   // find the normal of the edge
   sf::Vector2f n(-e.y, e.x);
   n *= 1/sqrt(dot(n,n)); // normalize!

   float d = dot(a,n); // distance between orgin and normal (a is the vector between origin and a since: a - origin = a - [0,0] = a)

   // if d is less than the previously closest
   if(d < closest.distance){
      closest.distance = d;
      closest.normal = n;
      closest.index = j; // we use an index for performance reasons, so we can just look it up in the simplex later
   }
}

return closest;
}

// Main function for handling the collision. The shapes passed to this function MUST BE COLLIDING. The simplex is the simplex which was used to find the collision, that is the terminating simplex of the GJK-algorithm
void Handle(const sf::ConvexShape& shape1, const sf::ConvexShape& shape2, Simplex& simplex){
int i = 0; // i is just for security, preventing infinit loop (shouldn't happen though)
while(++i < 100){
   // find the edge closest to the origin in the simplex
   Edge e = FindClosestEdge(simplex);

   // find the furthest minkowski difference point in the direction of the normal
   const sf::Vector2f& p = Support(shape1, shape2, e.normal);

   // find the distance between the point and the edge
   float d = dot(p, e.normal);

   // find if we've hit the border of the minkowski difference!
   if(d - e.distance < 0.1){
      // handle the collision here, this is just an example. The normal direction can be used to to special tricks depending on angle
      std::cout << "move: " << d << " in direction: " << e.normal.x << " " << e.normal.y << std::endl;
      vel += (d + 0.001f) * e.normal; // pushes the velocity back in the oppsite direction
      return;
   } else {
      // add the point inbetween the points where it was found (due to the need of correct winding)
      simplex.insert(simplex.begin() + e.index, p);
   }
}
}

/*
END OF EPA ALGORITHM
*/

/*
GJK ALGORITHM BEGINS HERE
GJK tries to find a tringle in the minkowski difference of two convex shapes which includes the origin.
*/

// finds out if our simplex contains the origin or not! also modifies the search direction (the direction in which we should further expand our simplex)
// note that the parameters are references, making it possible to modify them
bool ContainsOrigin(std::vector<sf::Vector2f>& simplex, sf::Vector2f& direction){
// a is the newest point
// b&c are the "old points"

const sf::Vector2f& a = simplex.back();
sf::Vector2f ao = -a; // vector from newest point in simplex to the origin

// triangular simplex, will check if the triangle includes the origin. If it does not it removes the "last" points from the simplex
if(simplex.size() == 3){
   const sf::Vector2f& b = simplex.at(0);
   const sf::Vector2f& c = simplex.at(1);

   sf::Vector2f ab = b - a; // vector between a and b
   sf::Vector2f abPerp(-ab.y, ab.x); // the perpendicular vector to ab, possibly becomes new search direction if collision is not found
   if(dot(abPerp,c) >= 0){ // new direction might "wrong way", check against other side
      abPerp = -abPerp;
   }

   if(dot(abPerp, ao) > 0){ // we are in area of direction abPerp
      simplex.erase(std::find(simplex.begin(), simplex.end(), c)); // remove point in simplex, making it a line

      direction = abPerp; // set a new search direction, where we should look for an new third point
   } else { // we are in area of direction acPerp
      sf::Vector2f ac = c - a; // sme as for ab and abPerp but between a and c
      sf::Vector2f acPerp(-ac.y, ac.x);
      if(dot(acPerp,b) >= 0){
         acPerp = -acPerp;
      }

      if(dot(acPerp, ao) <= 0) // the origin isn't in the direction of acPerp, we just detected a collision! This is true since we already know that it isn't int the direction of abPerp
         return true; // fast exit

      // does the following only if collision is not found. Erases a point, making the simplex a line and sets a new serach direction in the direction perpendicular to the one between a and c.
      simplex.erase(std::find(simplex.begin(), simplex.end(), b));
      direction = acPerp;
   }
}else if(simplex.size() == 2){ // simplex is a line
   const sf::Vector2f& b = simplex.at(0);

   // find the vector between the two points
   sf::Vector2f ab = b - a;

   // find the perpendicular vector in the direction of the origin
   sf::Vector2f abPerp(-ab.y, ab.x);
   if(dot(abPerp,ao) >= 0){
      abPerp = -abPerp;
   }

   // set direction to the perpendicular vector, this is the direction where we want to look for a third point
   direction = abPerp;
}

// no collision this iteration
return false;
}

// Main GJK functionm, starts EPA algorithm (Handle-function) in case it finds a collision
void DetectIntersectionAndHandle(const sf::ConvexShape& shape1, const sf::ConvexShape& shape2){
// create an empty simplex
Simplex simplex;

// look in any direction, (1,1) is just an example
sf::Vector2f direction = sf::Vector2f(1,1);
// find a point in minkowski difference in the direction
simplex.push_back(Support(shape1, shape2, direction));
// look in the opposite direction
direction = -direction;

int i = 0;
while(++i < 100){
   // find a new vector in the search direction
   sf::Vector2f newVec = Support(shape1,shape2, direction);
   if(dot(newVec, direction) < 0){ // if we couldn't find a new point in the direction, we stop
      return;
   } else { // we found a new point!
      simplex.push_back(newVec); // add to simplex

      // if the simplex contains the origin, send it to the EPA Handle-function and then exit the function.
      if(ContainsOrigin(simplex, direction)){
         Handle(shape1, shape2, simplex);
         return;
      }
   }
}
}

/*
END OF GJK ALGORITHM
*/

// test program, renders two boxes, makes one of them movable with arrow keys, makes them rotatable with I & O-keys and then uses the GJK&EPA algorithms on them
int main(){
sf::RenderWindow window(sf::VideoMode(1024,768), "GJK&EPA test!");
sf::Event evt;
window.SetFramerateLimit(30);

// the static Shape (can only be rotated, not moved)
sf::ConvexShape A(4);

// Declartion of B is at the top of this file
B.SetPointCount(4);
B.SetPoint(0, sf::Vector2f(0,0));
B.SetPoint(1, sf::Vector2f(50,0));
B.SetPoint(2, sf::Vector2f(50,80));
B.SetPoint(3, sf::Vector2f(0,80));
B.SetFillColor(sf::Color::Green);

A.SetPoint(0, sf::Vector2f(0,0));
A.SetPoint(1, sf::Vector2f(200,0));
A.SetPoint(2, sf::Vector2f(200,120));
A.SetPoint(3, sf::Vector2f(0,120));
A.SetPosition(300,300);
A.SetFillColor(sf::Color::Red);

while(window.IsOpen()){
   while(window.PollEvent(evt)){
      if(evt.Type == sf::Event::Closed)
         window.Close();
   }

   // Movmement stuff
   if(sf::Keyboard::IsKeyPressed(sf::Keyboard::Left)){
      vel.x -= 1;
   } else if(sf::Keyboard::IsKeyPressed(sf::Keyboard::Right)){
      vel.x += 1;
   } else {
      vel.x *= 0.2f;
   }

   if(sf::Keyboard::IsKeyPressed(sf::Keyboard::Up)){
      vel.y -= 1;
   } else if(sf::Keyboard::IsKeyPressed(sf::Keyboard::Down)){
      vel.y += 1;
   } else {
      vel.y *= 0.2f;
   }

   if(vel.x > 1){
      vel.x = 1;
   }

   if(vel.x < -1){
      vel.x = -1;
   }

   if(vel.y > 1){
      vel.y = 1;
   }

   if(vel.y < -1){
      vel.y = -1;
   }

   if(sf::Keyboard::IsKeyPressed(sf::Keyboard::O))
      A.Rotate(0.25f);

   if(sf::Keyboard::IsKeyPressed(sf::Keyboard::I))
      B.Rotate(0.25f);

   B.Move(vel);

   // Do GJK & possibly EPA
   DetectIntersectionAndHandle(A,B);

   window.Clear();

   window.Draw(B);
   window.Draw(A);

   window.Display();
}
}

I warmly welcome criticism!

/Karl Zylinski

public domain truetype font rendering

sean — Fri Mar 02, 2012 12:09 pm

Author: sean

Posted: Fri Mar 02, 2012 12:09 pm

I have no idea, which is why I don't offer any guidance on that sort of thing.

I'm not aware of any anchor information in the TrueType specification, but I didn't look at every table so I'm not 100% sure. However, you certianly have one anchor, the character "origin"; when stb_truetype returns you a font bitmap, it doesn't just give you a width and a height, it gives you a bounding box relative to a (0,0) origin. So it's possible that you're just supposed to position the characters relative to that same origin. In a best possible world, the combining characters would come first, and they would have a 0 advance, which would cause you to draw each character in the same place until you reached a regular character which then advances. Maybe they did that? I have no idea.

public domain jpeg/png decompressor

NeARAZ — Tue Feb 28, 2012 2:57 pm

Author: NeARAZ

Posted: Tue Feb 28, 2012 2:57 pm

Only tangentially related to stb_image_write: I needed to quickly write OpenEXR files (think "HDR screenshots") and integrating whole official OpenEXR library seemed like overkill. So here's a small (and very limited!) code to write simplest possible .exr files: https://github.com/aras-p/miniexr/blob/master/miniexr.cpp

RGBA FP16 in (i.e. what you get in D3D10/11 from DXGI_FORMAT_R16G16B16A16_FLOAT resources), uncompressed BGR half-precision .exr out. Most of the code is just spelling out quite verbose .exr header structure.

This is all.

How long is a nanosecond?

Won — Mon Feb 27, 2012 7:04 pm

Author: Won

Posted: Mon Feb 27, 2012 7:04 pm

Also: don't forget that pi seconds is a nanocentury.

Immediate mode physics engine?

mariocaprino — Mon Feb 13, 2012 10:15 am

Author: mariocaprino

Posted: Mon Feb 13, 2012 10:15 am

Here are my ramblings about Immediate Mode Physics in the Chipmunk forums. Maybe it might be of interest to you if you are considering this approach.

I never did more then test the approach - but I still believe an IM Physics API would be better suited for some projects.

new open source DXTn texture compression library

random task — Wed Jan 11, 2012 3:15 pm

Author: random task

Posted: Wed Jan 11, 2012 3:15 pm

Interesting! I'll give it a try as soon as I get a free evening...

S3TC patent maybe invalid

Won — Thu Jan 05, 2012 7:53 pm

Author: Won

Posted: Thu Jan 05, 2012 7:53 pm

http://www.phoronix.com/scan.php?page=news_item&px=OTkxMQ

t += dt

casey — Wed Dec 21, 2011 6:26 pm

Author: casey

Posted: Wed Dec 21, 2011 6:26 pm

jai wrote:

On a related fantasy/OCD note: Is there a way, mathematically, to construct a set of instructions on a CPU which takes a fixed/and known amount of time? Sort of like how they redid the meter standard by defining it by the speed of light. If you had a set of instructions for say x86 that hypothetically would take exactly X ms to execute, could you use it as some kind of reference to see how off the timer is, and therefore adjust it, or use it to sync somehow? Maybe that doesn't make sense.

Not on the CPU specifically, for the by-definition reason that the CPU executes via its own internal clocking, so anything executed on it can't be isolated from problems with said internal clocking.

Hard-core people (RAD, for example ) already do use multiple system timers to try to detect errors, however. Since the CPU is not the only clocked device in the system, it is possible to sample many clocks (audio, vblank, bus, etc.) and write some "expert system" logic which will try to guess about what sorts of timing bugs might be happening.

It's totally ad hoc, though, obviously, since there's truly no way to ever know which clocks are right, except in obvious cases such as clocks going backwards (which does, in fact, happen, sadly).

- Casey