int LOBJECT_METHOD(drawPoints, SDL_Renderer * renderer){
if (state.is_table(1)){
int count = state.obj_len(1);
if (count>0){
SDL_Point* points = new SDL_Point[count];
int final_count = 0;
for (int i=0; i< count; i++){
state.push_integer(i+1);
state.get_table(1); // 1 T
if (state.is_table(-1)){
state.get_field(-1, "x"); // 1 T x
state.get_field(-2, "y"); // 1 T x y
points[final_count].x = state.to_integer(-2);
points[final_count].y = state.to_integer(-1);
final_count++;
state.pop(3);
}else{
state.pop(1);
}
}
state.push_boolean(SDL_RenderDrawPoints(renderer, points, final_count) == 0);
delete[] points;
return 1;
}
}
return 0;
}
bool j1Render::DrawCircle(int x, int y, int radius, Uint8 r, Uint8 g, Uint8 b, Uint8 a, bool use_camera) const
{
bool ret = true;
uint scale = App->win->GetScale();
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, r, g, b, a);
int result = -1;
SDL_Point points[360];
float factor = (float)M_PI / 180.0f;
for(uint i = 0; i < 360; ++i)
{
points[i].x = (int)(x + radius * cos(i * factor));
points[i].y = (int)(y + radius * sin(i * factor));
}
result = SDL_RenderDrawPoints(renderer, points, 360);
if(result != 0)
{
LOG("Cannot draw quad to screen. SDL_RenderFillRect error: %s", SDL_GetError());
ret = false;
}
return ret;
}
void renderCircle(struct renderstate *render, int centerX, int centerY,
double radius)
{
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int left, right, top, bottom;
int x, y;
int point_count = 0;
double radius_squared = pow(radius, 2);
top = MAX(0, centerY - radius);
bottom = MIN(render->height, centerY + radius);
left = MAX(0, centerX - radius);
right = MIN(render->width, centerX + radius);
for (x = left; x < right; x++) {
for (y = top; y < bottom; y++) {
if ((pow(centerX - x, 2) + pow(centerY - y, 2)) <=
radius_squared) {
render->points[point_count].x = x;
render->points[point_count].y = y;
point_count++;
// SDL_RenderDrawPoint(render->renderer, x, y);
}
}
}
SDL_RenderDrawPoints(render->renderer, render->points, point_count);
}
void Circle::draw()
{
int window_w, window_h;
SDL_GetWindowSize(window, &window_w, &window_h);
std::vector<SDL_Point> draw_points;
// get drawing area of circle and don't draw outside the window
int tlx = position.x - radius;
tlx = tlx >= 0? tlx : 0;
int tly = position.y - radius;
tly = tly >= 0? tly : 0;
int brx = position.x + radius;
brx = brx <= window_w? brx : window_w;
int bry = position.y + radius;
bry = bry <= window_h? bry : window_h;
// for each pixel in this area
for(int x = tlx; x <= brx; x++)
{
for(int y = tly; y <= bry; y++)
{
// get distance between this pixel and the center of the circle
int x_length = abs(position.x - x);
int y_length = abs(position.y - y);
double r = sqrt(x_length*x_length + y_length*y_length);
// if this circle is in range (ceilinged)
if(ceil(r) <= radius+1)
{
// draw it, with anti aliasing if i'm at the very edge of the circle and the radius doesn't fully reach this pixel
int anti_alias = 0;
if(r > radius)
{
anti_alias = floor(double(255) * (r - double(radius)));
}
// draw each anti-aliased pixel separately
if(anti_alias > 0)
{
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a - anti_alias > 0? color.a - anti_alias : 0);
SDL_RenderDrawPoint(renderer, x, y);
}
// non anti-aliased pixels will be drawn all at once using RenderDrawPoints
else
{
SDL_Point p;
p.x = x;
p.y = y;
draw_points.push_back(p);
}
}
}
}
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
SDL_RenderDrawPoints(renderer, &draw_points[0], draw_points.size());
}
// Circle_Texture::Circle_Texture
Circle_Texture::Circle_Texture (unsigned radius, Color color) {
c.calculate_points(Point(radius, radius), radius);
create_blank(radius * 2 + 1, radius * 2 + 1, SDL_TEXTUREACCESS_TARGET);
Renderer::set_render_target(this->texture());
Renderer::set_draw_color(color);
if (SDL_RenderDrawPoints(Renderer::renderer(), (SDL_Point*)c.data(), c.size()) != 0)
cerr<<"ERROR: "<<__func__<<" SDL_RenderDrawPoints failed!\nSDL Error: "<<SDL_GetError()<<'\n';
Renderer::reset_render_target();
}
CAMLprim value
caml_SDL_RenderDrawPoints(value renderer, value ml_points)
{
unsigned int i;
unsigned int count = Wosize_val(ml_points);
SDL_Point * points = malloc(count * sizeof(SDL_Point));
for (i = 0; i < count; i++) {
value p = Field(ml_points, i);
points[i].x = Int_val(Field(p, 0));
points[i].y = Int_val(Field(p, 1));
}
int r = SDL_RenderDrawPoints(
SDL_Renderer_val(renderer),
points, count);
free(points);
if (r) caml_failwith("Sdlrender.draw_points");
return Val_unit;
}
void Level::render(GameEngine* ge)
{
Timer rendertime;
//rendertime.start();
SDL_SetRenderDrawColor(ge->renderer, 0xff, 0xff, 0xff, 0);
SDL_RenderClear(ge->renderer);
if (is_a_player_dead && (respawn_timer.getTime() > 3.0f))
{
spawnLevel();
score.battleMessage = 0;
if (score.warMessage != 0)
{
score.resetScores();
score.warMessage = 0;
}
}
for (int i = 0; i < gObstacleTotal; i++)
{
obstacles[i].render(ge->renderer);
}
// draw terrain
SDL_SetRenderDrawColor(ge->renderer, 0x00, 0x00, 0x00, 1);
SDL_RenderDrawPoints(ge->renderer, points, point_count);
cannonL.render(ge->renderer);
cannonR.render(ge->renderer);
ball.render(ge->renderer);
if (shooting)
SDL_RenderCopy(ge->renderer, force_texture, NULL, &force_rect);
score.render(ge->renderer);
SDL_RenderPresent(ge->renderer);
//std::cout << rendertime.getTime() << std::endl;
}
//Draws points at the specified positions
//param:pointsArray->The array to draw from
//param:numberOfPoints->The size of the array. No bounds checking performed
//param:color->The color to set the points to
//Returns 0 for success, -1 for errors
int SpriteBatch::DrawPoints(SDL_Point* pointsArray, int numberOfPoints, SDL_Color color)
{
//Check if spritebatch.begin has been called
if(!begun)
{
std::cout<<"Begin must be called before attempting to draw"<<std::endl;
return -1;
}
//Check the size
if(numberOfPoints<= 0)
{
std::cout<<"DrawPoints error: Number of points must be greater than 0" <<std::endl;
return -1;
}
int result = 0;
//set the color
result = SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
//check for color setting problems
if(result != 0)
{
std::cout<<"DrawPoints error: Problem setting points color"<<std::endl;
return result;
}
//Draw the points
result = SDL_RenderDrawPoints(renderer, pointsArray, numberOfPoints);
//Check for draw problems
if(result != 0)
{
std::cout<<"DrawPoints error: Problem drawing points"<<std::endl;
return result;
}
//return success
return result;
}
bool j1Render::DrawCone(int x, int y, int radius, int angle, float up_rad, float down_rad, Uint8 r, Uint8 g, Uint8 b, Uint8 a, bool use_camera)
{
bool ret = true;
uint scale = App->win->GetScale();
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, r, g, b, a);
int op = angle;
int result = -1;
SDL_Point points[30];
float factor = (float)M_PI / 180.0f;
if (use_camera)
{
x *= scale;
y *= scale;
x += camera.x;
y += camera.y;
}
for (uint i = 0; i < 360; ++i)
{
points[i].x = (int)(x + radius * cos(i * factor) * scale);
points[i].y = (int)(y + radius * sin(i * factor) * scale);
}
result = SDL_RenderDrawPoints(renderer, points, 50);
if (result != 0)
{
LOG("Cannot draw cone to screen. SDL_RenderFillRect error: %s", SDL_GetError());
ret = false;
}
return ret;
}
void drawCircle(int cx, int cy, int radius, int r, int g, int b, int a)
{
int x = radius;
int y = 0;
int radiusError = 1 - x;
SDL_Point p[8];
SDL_SetRenderDrawColor(app.renderer, r, g, b, a);
SDL_SetRenderDrawBlendMode(app.renderer, SDL_BLENDMODE_BLEND);
while (x >= y)
{
p[0].x = x + cx; p[0].y = y + cy;
p[1].x = y + cx; p[1].y = x + cy;
p[2].x = -x + cx; p[2].y = y + cy;
p[3].x = -y + cx; p[3].y = x + cy;
p[4].x = -x + cx; p[4].y = -y + cy;
p[5].x = -y + cx; p[5].y = -x + cy;
p[6].x = x + cx; p[6].y = -y + cy;
p[7].x = y + cx; p[7].y = -x + cy;
SDL_RenderDrawPoints(app.renderer, p, 8);
y++;
if (radiusError < 0)
{
radiusError += 2 * y + 1;
}
else
{
x--;
radiusError += 2 * (y - x) + 1;
}
}
SDL_SetRenderDrawBlendMode(app.renderer, SDL_BLENDMODE_NONE);
}
void points(int p[][2], int n)
{
//Grapic& g = Grapic::singleton();
SDL_RenderDrawPoints(renderer(), ((const SDL_Point*)(p)), n);
}
