How do I perform image clipping efficiently within a parent RECT? - c++

Question

So,
I'm playing around with the DIRECTX API in C++ and designing a sprite interface that does clipping within parent RECT's, like a UI window or another sprite or what have you.
This is because, later on, I'm going to make a scrolling function for a UI window.
I think an image would be appropriate to demonstrate what I am trying to achieve.
In order to do clipping calculations, at least four variables/structs are required (from what I can discern):
Parent RECT: the "clipping" bounds
D3DXIMAGE_INFO: containing the image information, such as width and height
Sprite position
Draw RECT: for the LPD3DXSPRITE->Draw() function. Basically, what part of the image should be drawn. This is where the "clipping" is done.
Now, I think it would be confusing if I showed you my entire interface and its inner workings and how it handles the variables.
So, instead,
this piece of code demonstrates how I'm currently calculating the clipping.
void ClippingCalculation(){
RECT parent_bounds, draw_rect;
D3DXVECTOR2 sprite_position; //Relative to parent rect
D3DXIMAGE_INFO img_info;
//Fill image info
D3DXGetImageInfoFromFile("image.png", &img_info); //Image is 100x100px
//Define the rects
SetRect(&parent_bounds, 0, 0, 200, 200);
SetRect(&draw_rect, 0, 0, img_info.Width, img_info.Height); //Draw the entire image by default
//Give it a position that makes a portion go out of parent bounds
sprite_position = D3DXVECTOR2(150, 150); // 3/4 of the entire image is out of bounds
//Check if completely within bounds
bool min_x = (sprite_position.x > parent_bounds.left),
min_y = (sprite_position.y > parent_bounds.top),
max_x = (sprite_position.x+img_info.Width < parent_bounds.right),
max_y = (sprite_position.y+img_info.Height < parent_bounds.bottom);
if(min_x && min_y && max_x && max_y)
return; //No clipping needs to be done
float delta_top = parent_bounds.top - sprite_position.y,
delta_left = parent_bounds.left - sprite_position.x,
delta_bottom = parent_bounds.bottom - sprite_position.y,
delta_right = parent_bounds.right - sprite_position.x;
//Check if completely outside bounds
bool out_left = (delta_left >= img_info.Width),
out_top = (delta_top >= img_info.Height),
out_bottom = (delta_bottom >= img_info.Height),
out_right = (delta_right >= img_info.Width);
if(out_left || out_top || out_bottom || out_right){
//No drawing needs to be done, it's not even visible
return; //No clipping
}
if(!min_x) draw_rect.left = delta_left;
if(!min_x) draw_rect.top = delta_top;
if(!max_x) draw_rect.right = delta_right;
if(!max_y) draw_rect.bottom = delta_bottom;
return;
}
My questions are:
Do you see anything immediately wrong with the code?
Is it efficient or inefficient?
The clipping is done every time the sprite is repositioned, loaded or when a parent is added.
Is the math solid? Should I approach it differently?
Could it be done in a better way and could you provide examples?

Answer 1

Clipping a RECT is a lot easier than this:
clipped_rect.left= MAX(rect_a.left, rect_b.left);
clipped_rect.right= MIN(rect_a.right, rect_b.right);
clipped_rect.top= MIN(rect_a.top, rect_b.top);
clipped_rect.bottom= MAX(rect_a.bottom, rect_b.bottom);
bool completely_clipped=
clipped_rect.left>=clipped_rect.right ||
clipped_rect.bottom>=clipped_rect.top
This assumes Y increases as you go up. It should be pretty easy to find a platform specific version of MIN and MAX that are performant.