Show Posts
This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.
void THreadFunc(void* userdata)
{
//...
}
bool IsColOnAxis(const VECTOR axisA, const VECTOR axisB, const VECTOR rectA[], const VECTOR rectB[])
{
VECTOR axisAB = axisA - axisB; // should be perpendicular axis, not parallel, but doesn't matter for rectangles.
// if you want to correct that, though, you would do this instead of axisA - axisB:
axisAB.y = axisA.x - axisB.x;
axisAB.x = axisB.y - axisA.y; // now axisAB is perpendicular to AB, not parallel
// but again this REALLY doesn't matter with rectangles because each of the 2 important
// axis are perpendicular to each other anyway. If you were doing some other
// kind of shape, though, this would have screwed it up.
float Aprojections[4];
float Bprojections[4];
//rect A
for(int i=0;i<4;i++)
{
Aprojections[i] = RetDotProduct(axisAB,rectA[i]-axisA) / RetDotProduct(axisAB,axisAB); // probably should be "rectA[i]-axisB" since axisB is your origin.
// but that really doesn't matter. All that will do is negate all your projected lines, but they will all be negated the same
// way, so it won't really affect anything. I only bring it up because it confused me a little when I first saw it.
}
//rect B
for(int i=0;i<4;i++)
{
Bprojections[i] = RetDotProduct(axisAB,rectB[i]-axisA) / RetDotProduct(axisAB,axisAB); // same notes as above
}
float Amax = FindMax(Aprojections);
float Amin = FindMin(Aprojections);
float Bmax = FindMax(Bprojections);
float Bmin = FindMin(Bprojections);
// you only check to see if the B points are "inside" the A line
// you do not check to see if the A points are inside the B line, which will cause a failure
// when the A line is fully enclosed in the B line.
//
// IE:
// ================================== <- B
// ============= <- A
//
// In this case, your test was returning false, but it should be returning true. This is why the function was failing sometimes.
/*
if((Bmin > Amin && Bmin < Amax) || (Bmax > Amin && Bmax < Amax)
|| (Amin > Bmin && Amin < Bmax) || (Amax > Bmin && Amax < Bmax)) // <- to fix you can add this
return true;
return false;
*/
// Although the massive if statements are fugly and confusing. Instead I would get rid of the above junk and do this instead:
if(Bmax < Amin) return false;
if(Amax < Bmin) return false;
if(Bmin > Amax) return false;
if(Amin > Bmax) return false;
return true;
// much simpler. Also note that this is fewer checks (4 conditionals instead of 8) so it'll likely be faster.
// You could also optimize this for rectangles. The thing with rectangles is 2 of their sides are parallel with the other 2 sides.
// so really you only need to project 2 corners and not 4 (specifically, the corners that are not adjacent to each other, like [0] and [2])
//
// You also only need to project them onto 2 axis, not 4. Because the other 2 axis will be parallel.
}No! The point is to find something new that's much better than the current API. Ok, maybe the final result will be something very close to it, but please try to be as open as possible
So a sprite would have to declare a getter/setter for every possible state: shader, view, transform, texture, blend mode.
I don't think that getting rid of global states is a good idea. It's more flexible:
some states are better activated once, globally, than assigned to every entity (view, shader)
you can combine a transform with the current one (parent/child relationship)
- an object can set the states that it needs, while enjoying other states that it doesn't care about
sf::RenderState lowlevelstate;
lowlevelstate.SetTexture( blah );
lowlevelstate.SetWhatever( whatever );
sf::Mesh mymesh = blah;
sf::Sprite mysprite = blah;
target.Draw( mymesh, lowlevelstate ); // uses low-level state
mysprite.Draw(target); // uses sf::Sprite's internal state
while(_render.IsOpened())
{
// empty the event queue
sf::Event currentEvent;
while(_render.PollEvent(currentEvent)) // <- while, not if
{
// notice in here we only do event stuff. Do not render the scene here
if(currentEvent.Type == currentEvent.Closed)
_render.Close();
}
// NOW render the scene
_render.Clear();
_render.Display();
}
Since GetFrameTime() and sf::Clocks both use Uint32, the minimum time that we can find is 1 ms, which gives us a top of 1000 FPS when measuring with 1/GetFrameTime().
But that makes no sense.
Why would it work on 1.6
why does it happen when returning from main() in 'return EXIT_SUCCESS'?
Happens only when I create an object of the class TtfText.
P = vBA * k + A
Q = vDC * m + C
P = Q
vBA * k + A = vDC * m + Ck = (vDC * m + vCA) / vBA
m = (vBA * k - vCA) / vDCk = (vDC.x * m + vCA.x) / vBA.x
and
k = (vDC.y * m + vCA.y) / vBA.yk = (vDC.x * m + vCA.x) / vBA.x
m = (vBA.y * k - vCA.y) / vDC.y
so
k = (vDC.x * ( m ) + vCA.x) / vBA.x
k = (vDC.x * ((vBA.y * k - vCA.y) / vDC.y) + vCA.x) / vBA.xk = (vDC.y*vCA.x - vDC.x*vCA.y) / (vDC.y*vBA.x - vDC.x*vBA.y)
m = (vBA.y*vCA.x - vBA.x*vCA.y) / (vDC.y*vBA.x - vDC.x*vBA.y)inline double PerpDot(const Point& a,const Point& b) { return (a.y*b.x) - (a.x*b.y); }
k = PerpDot(vDC,vCA) / PerpDot(vDC,vBA)
m = PerpDot(vBA,vCA) / PerpDot(vDC,vBA)
bool LineCollision( const Point& A, const Point& B, // line AB
const Point& C, const Point& D, // line CD
Point* out ) // filled with intersection point
{
Point vBA(B - A);
Point vDC(D - C);
double f = PerpDot(vDC,vBA);
if(!f) // lines are parallel
return false;
Point vCA(C - A);
double k = PerpDot(vDC,vCA) / f;
if(k < 0) return false;
if(k > 1) return false;
double m = PerpDot(vBA,vCA) / f;
if(m < 0) return false;
if(m > 1) return false;
if(out)
*out = (vDC * m) + C; // or (vBA * k) + A if you prefer -- same thing
return true;
}
it seems that the performance decreased significantly. It worked at about 2000 FPS with 1.6, but about 700 FPS with 2.0.