Add object collision classification and resolution functions

coresdk/src/backend/graphics_driver.cpp

@@ -2129,15 +2129,10 @@ namespace splashkit_lib
         return result;
     }
 
-    sk_drawing_surface sk_load_bitmap(const char * filename)
+    sk_drawing_surface sk_load_from_surface(SDL_Surface *surface)
     {
-        internal_sk_init();
         sk_drawing_surface result = { SGDS_Unknown, 0, 0, nullptr };
 
-        SDL_Surface *surface;
-
-        surface = IMG_Load(filename);
-
         if ( ! surface ) {
             std::cout << "error loading image " << IMG_GetError() << std::endl;
             return result;
@@ -2171,7 +2166,23 @@ namespace splashkit_lib
 
         return result;
     }
-
+
+    sk_drawing_surface sk_load_bitmap(const char * filename)
+    {
+        internal_sk_init();
+
+        return sk_load_from_surface(IMG_Load(filename));
+    }
+
+    sk_drawing_surface sk_load_bitmap_from_memory(const vector<int8_t>& img_data)
+    {
+        internal_sk_init();
+
+        SDL_RWops *rw = SDL_RWFromConstMem(&img_data[0], img_data.size());
+
+        return sk_load_from_surface(IMG_LoadTyped_RW(rw, 1, "PNG"));
+    }
+
     //x, y is the position to draw the bitmap to. As bitmaps scale around their centre, (x, y) is the top-left of the bitmap IF and ONLY IF scale = 1.
     //Angle is in degrees, 0 being right way up
     //Centre is the point to rotate around, relative to the bitmap centre (therefore (0,0) would rotate around the centre point)

coresdk/src/backend/graphics_driver.h

@@ -50,7 +50,7 @@ namespace splashkit_lib
     sk_drawing_surface sk_create_bitmap(int width, int height);
 
     sk_drawing_surface sk_load_bitmap(const char * filename);
-
+    sk_drawing_surface sk_load_bitmap_from_memory(const vector<int8_t>& img_data);
 
     void sk_draw_bitmap( sk_drawing_surface * src, sk_drawing_surface * dst, double * src_data, int src_data_sz, double * dst_data, int dst_data_sz, sk_renderer_flip flip );
 

coresdk/src/backend/utility_functions.cpp

@@ -587,4 +587,47 @@ namespace splashkit_lib
     double lin_interp(double v0, double v1, double t) {
         return v0 * (1.0 - t) + v1 * t;
     }
+
+    vector<int8_t> base64_decode_data(const char* in)
+    {
+        const string BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+        //Lookup decimal values for base64 string (base64 -> base10)
+        vector<uint8_t> map;
+        for (int i = 0; i < strlen(in); i++)
+        {
+            for(int j = 0; j < 64; j++)
+            {
+                if(in[i] == BASE64_CHARS[j])
+                {
+                    //Remove 00 prefix from byte by bit shifting
+                    map.push_back(j << 2);
+                }
+            }
+        }
+
+        vector<int8_t> out;
+        int8_t a;
+        int8_t b;
+        int lb = 0;
+        int rb = 6;
+        //Base64 encoded data should always be divisible  into chunks of four
+        for (int i = 0; i < map.size(); i++)
+        {
+            //Concatenate six bits of a and two bits of b to get val c
+            a = (map[i] << lb);
+            b = (map[i+1] >> rb);
+            out.push_back(a + b);
+            //Shift cursors to concatenate correct chunks
+            lb+=2;
+            rb-=2;
+            if(rb == 0)
+            {
+                lb = 0;
+                rb = 6;
+                ++i;
+            }
+        }
+        return out;
+    }
 }

coresdk/src/backend/utility_functions.h

@@ -195,6 +195,8 @@ collection.erase(collection.begin());\
 
     double lin_interp(double v0, double v1, double t);
 
+    vector<int8_t> base64_decode_data(const char* in);
+
     // Notify the listeners that a resource has been freed. Implemented in resources.
     void notify_of_free(void *resource);
 }

coresdk/src/coresdk/circle_geometry.cpp

@@ -98,6 +98,41 @@ namespace splashkit_lib
             return (v - sqrt(d));
     }
 
+    bool circle_ray_intersection(const point_2d &origin, const vector_2d &heading, const circle &circ)
+    {
+        point_2d hit_point;
+        double hit_distance;
+        return circle_ray_intersection(origin, heading, circ, hit_point, hit_distance);
+    }
+
+    bool circle_ray_intersection(const point_2d &origin, const vector_2d &heading, const circle &circ, point_2d &hit_point, double &hit_distance)
+    {
+        vector_2d unit_heading = unit_vector(heading);
+
+        // check whether unit heading is a zero vector
+        if (vector_magnitude_squared(unit_heading) < __DBL_EPSILON__)
+        {
+            return false;
+        }
+
+        if (point_in_circle(origin, circ))
+        {
+            hit_point = origin;
+            hit_distance = 0.0;
+            return true;
+        }
+
+        float distance = ray_circle_intersect_distance(origin, unit_heading, circ);
+        if (distance < 0.0f)
+        {
+            return false;
+        }
+
+        hit_distance = static_cast<double>(distance);
+        hit_point = point_offset_by(origin, vector_multiply(unit_heading, hit_distance));
+        return true;
+    }
+
     bool circles_intersect(circle c1, circle c2)
     {
         return point_point_distance(c1.center, c2.center) < c1.radius + c2.radius;
@@ -192,4 +227,19 @@ namespace splashkit_lib
 
         return true;
     }
+
+    bool circle_quad_intersect(const circle &c, const quad &q)
+    {
+        vector<triangle> q_tris = triangles_from(q);
+
+        for (size_t i = 0; i < q_tris.size(); i++)
+        {
+            if (circle_triangle_intersect(c, q_tris[i]))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

coresdk/src/coresdk/circle_geometry.h

@@ -150,6 +150,35 @@ namespace splashkit_lib
      */
     float ray_circle_intersect_distance(const point_2d &ray_origin, const vector_2d &ray_heading, const circle &c);
 
+    /**
+     * Detects if a ray intersects a circle.
+     * 
+     * @param origin        The starting point of the ray
+     * @param heading       The direction of the ray as a vector
+     * @param circ          The circle to check for intersection
+     * @returns             True if the ray intersects the circle, false otherwise
+     */
+    bool circle_ray_intersection(const point_2d &origin, const vector_2d &heading, const circle &circ);
+
+    /**
+     * Detects if a ray intersects a circle. If an intersection is found, the
+     * `hit_point` and `hit_distance` are set to the point of intersection and the
+     * distance from the ray's origin to the intersection point. If the ray's `origin`
+     * is contained within the circle, `hit_point` is set to the `origin` and `hit_distance`
+     * is set to 0. If no intersection is found, `hit_point` and `hit_distance` are not modified.
+     * 
+     * @param origin        The starting point of the ray
+     * @param heading       The direction of the ray as a vector
+     * @param circ          The circle to check for intersection
+     * @param hit_point     The point to set to where the ray intersects the circle
+     * @param hit_distance  The double to set to the distance from the ray's origin to
+     *                      the intersection point
+     * @returns             True if the ray intersects the circle, false otherwise
+     * 
+     * @attribute suffix    with_hit_point_and_distance
+     */
+    bool circle_ray_intersection(const point_2d &origin, const vector_2d &heading, const circle &circ, point_2d &hit_point, double &hit_distance);
+
     /**
      *  Returns the circle radius.
      *
@@ -217,5 +246,13 @@ namespace splashkit_lib
      */
     bool tangent_points(const point_2d &from_pt, const circle &c, point_2d &p1, point_2d &p2);
 
+    /**
+     * Detects if a circle intersects with a quad.
+     *
+     * @param  c  The circle to test
+     * @param  q  The quad to test
+     * @return    True if the circle and quad intersect, false otherwise
+     */
+    bool circle_quad_intersect(const circle &c, const quad &q);
 }
 #endif /* circle_geometry_hpp */