// Circle centred at (cx,cy) of radius r, see :
// http://content.gpwiki.org/index.php/SDL:Tutorials:Drawing_and_Filling_Circles
void Shorthand_SDL_RenderDrawCircle(SDL_Renderer *rend, int cx, int cy, int r)
{
double dx, dy;
dx = floor(sqrt((2.0 * r ) ));
SDL_RenderDrawLine(rend, cx-dx, cy+r, cx+dx, cy+r);
SDL_RenderDrawLine(rend, cx-dx, cy-r, cx+dx, cy-r);
for (dy = 1; dy <= r; dy += 1.0) {
dx = floor(sqrt((2.0 * r * dy) - (dy * dy)));
SDL_RenderDrawPoint(rend, cx+dx, cy+r-dy);
SDL_RenderDrawPoint(rend, cx+dx, cy-r+dy);
SDL_RenderDrawPoint(rend, cx-dx, cy+r-dy);
SDL_RenderDrawPoint(rend, cx-dx, cy-r+dy);
}
}
void Renderer::drawPixel(const Color &color, int x, int y)
{
SDL_SetRenderTarget(this->renderer, this->nativeTexture);
SDL_SetRenderDrawColor(this->renderer, color.getR(), color.getG(),
color.getB(), color.getA());
SDL_RenderDrawPoint(this->renderer, x, y);
}
void S013010C_Aaron_Smith_Tank::DrawDebugCircle(Vector2D centrePoint, float radius)
{
Vector2D polarVec;
polarVec.x = 0.0f;
polarVec.y = radius;
float stepSize = 0.05f;
float _360DegAsRads = DegsToRads(360.0);
while (polarVec.x < _360DegAsRads)
{
Vector2D polarAsCart;
polarAsCart.x = polarVec.y * cosf(polarVec.x);
polarAsCart.y = polarVec.y * sinf(polarVec.x);
Vector2D drawPoint;
drawPoint.x = centrePoint.x + polarAsCart.x;
drawPoint.y = centrePoint.y + polarAsCart.y;
SDL_SetRenderDrawColor(mRenderer, 0, 0, 0, 255);
SDL_RenderDrawPoint(mRenderer, drawPoint.x, drawPoint.y);
polarVec.x += stepSize;
}
}
//Draws a point at the specified coordinates
//param:x->X coordinate of the point
//param:y->Y coordinate of the point
//param:color->Color to draw the point
//returns 0 for success, -1 for errors
int SpriteBatch::DrawPoint(int x, int y, 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;
}
int result = 0;
//Set the point color
result = SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
//Check for color setting problems
if(result != 0)
{
std::cout<<"DrawPoint error: Problem setting point color"<<std::endl;
return result;
}
//Draw the point
result = SDL_RenderDrawPoint(renderer, x, y);
//Check for drawing problems
if(result != 0)
{
std::cout<<"DrawPoint error: Problem drawing the point"<<std::endl;
return result;
}
//return success
return result;
}
GraphicsManager& GraphicsManager::DrawPixel (int x, int y, const Color& color)
{
SDL_SetRenderDrawColor(device, color.Red(), color.Green(), color.Blue(), color.Alpha());
SDL_RenderDrawPoint(device, x, y);
return *this;
}
void Range::generateTexture(SDL_Renderer * renderer)
{
if(texture != nullptr)
{
SDL_DestroyTexture(texture);
texture = nullptr;
}
setWidth(value * 2);
setHeight(value * 2);
SDL_Texture * prevRenderTarget = SDL_GetRenderTarget(renderer);
texture = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,getWidth(),getHeight());
SDL_SetTextureBlendMode(texture,SDL_BLENDMODE_BLEND);
SDL_SetRenderTarget(renderer,texture);
SDL_SetRenderDrawColor(renderer,0,0,0,0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer,255,0,0,255);
for(double i = 0; i<=360; i+=0.01)
{
int x = value + value * cos(i);
int y = value + value * sin(i);
SDL_RenderDrawPoint(renderer,x,y);
}
SDL_SetRenderTarget(renderer,prevRenderTarget);
}
//Affiche un point aux coordonnées de la souris
void afficherPoint()
{
static int x, y;
SDL_GetMouseState(&x, &y);
SDL_RenderDrawPoint(globalRenderer, x, y);
SDL_RenderPresent(globalRenderer);
}
void render_point(renderer *renderer, world *world, int id) {
position pos = world->positions[id];
color color = world->colors[id];
(void)printf("Rendering point %d at %d, %d\n", id, pos.x, pos.y);
SDL_SetRenderDrawColor(renderer->sdl_renderer, color.r, color.g, color.b, color.a);
SDL_RenderDrawPoint(renderer->sdl_renderer, pos.x, pos.y);
}
void renderRadius(GraphicsData *graphicsData, SDL_Point *point, double radius, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
double currOffsetX, currOffsetY;
point->x += graphicsData->navigationOffset.x;
point->y += graphicsData->navigationOffset.y;
SDL_SetRenderDrawColor(graphicsData->renderer, r,g,b, a);
for (currOffsetY = 1; currOffsetY <= radius; currOffsetY ++) {
currOffsetX = floor(sqrt((2.0 * radius * currOffsetY) - (pow(currOffsetY, 2))));
SDL_RenderDrawPoint(graphicsData->renderer, point->x - currOffsetX, point->y + radius - currOffsetY);
SDL_RenderDrawPoint(graphicsData->renderer, point->x - currOffsetX, point->y - radius + currOffsetY);
SDL_RenderDrawPoint(graphicsData->renderer, point->x + currOffsetX, point->y + radius - currOffsetY);
SDL_RenderDrawPoint(graphicsData->renderer, point->x + currOffsetX, point->y - radius + currOffsetY);
}
}
/* this is as low as it gets. slams pixels onto surface */
static void drawBetweenPoints(SDL_Point* p1, SDL_Point* p2, SDL_Color c, int w) {
double divDiff;
bool yLonger = false;
int incrementVal;
int shortLen;
int longLen;
int i;
if (!p1 || !p2) {
return;
}
shortLen = p2->y - p1->y;
longLen = p2->x - p1->x;
//determine long
if (abs(shortLen)>abs(longLen)) {
int swap = shortLen;
shortLen = longLen;
longLen = swap;
yLonger = true;
}
if (longLen<0) incrementVal = -1;
else incrementVal = 1;
if (shortLen == 0) divDiff = longLen;
else divDiff = (double)longLen / (double)shortLen;
//ok time to draw
SDL_SetRenderDrawColor(global_renderer, c.r, c.g, c.b, 255);
if (yLonger) {
for (i = 0; i != longLen; i += incrementVal) {
int x = p1->x + (int)((double)i / divDiff) + gDrawOffset_x;
int y = p1->y + i + gDrawOffset_y;
SDL_RenderDrawPoint(global_renderer, x, y);
}
}
else {
for (i = 0; i != longLen; i += incrementVal) {
int x = p1->x + i + gDrawOffset_x;
int y = p1->y + (int)((double)i / divDiff) + gDrawOffset_y;
SDL_RenderDrawPoint(global_renderer, x, y);
}
}
}
int LOBJECT_METHOD(drawPoint, SDL_Renderer * renderer){
if (state.is_number(1) && state.is_number(2)){
state.push_boolean(SDL_RenderDrawPoint(renderer, state.to_integer(1), state.to_integer(2)) == 0);
return 1;
}else{
return 0;
}
}
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());
}
/*
* Set the pixel at (x, y) to the given value
*/
void SDLHardwareImage::drawPixel(int x, int y, const Color& color) {
if (!surface) return;
SDL_SetRenderTarget(renderer, surface);
SDL_SetTextureBlendMode(surface, SDL_BLENDMODE_BLEND);
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
SDL_RenderDrawPoint(renderer, x, y);
SDL_SetRenderTarget(renderer, NULL);
}
CAMLprim value
caml_SDL_RenderDrawPoint2(value renderer, value x, value y)
{
int r = SDL_RenderDrawPoint(
SDL_Renderer_val(renderer),
Int_val(x), Int_val(y));
if (r) caml_failwith("Sdlrender.draw_point2");
return Val_unit;
}
void Bullet::Render()
{
if(alive)
{
// Render and color
SDL_SetRenderDrawColor(m_renderer, 255, 255, 255, 255);
SDL_RenderDrawPoint(m_renderer,points[0].x,points[0].y);
}
}
void buffer_plot_pixel(int x, int y, u8 r, u8 g, u8 b, u8 a)
{
if(rendering_world)
{
if(x > SCREEN_WIDTH+SCREEN_SHIFT_X || x < SCREEN_SHIFT_X || y < SCREEN_SHIFT_Y || y > SCREEN_HEIGHT+SCREEN_SHIFT_Y)
return;
}
SDL_SetRenderDrawColor(displayRenderer, r, g, b, a);
SDL_RenderDrawPoint(displayRenderer, x, y);
}
CAMLprim value
caml_SDL_RenderDrawPoint(value renderer, value p)
{
int r = SDL_RenderDrawPoint(
SDL_Renderer_val(renderer),
Int_val(Field(p, 0)),
Int_val(Field(p, 1)));
if (r) caml_failwith("Sdlrender.draw_point");
return Val_unit;
}
void draw_point( int x, int y, Uint32 color )
{
Uint8 r, g, b, a;
SDL_GetRenderDrawColor( render, &r, &g, &b, &a );
SDL_SetRenderDrawColor( render, color >> 16, ( color >> 8 ) & 0xFF,
( color & 0xFF ), 255 );
SDL_RenderDrawPoint( render, x, y );
SDL_SetRenderDrawColor( render, r, g, b, a );
}
void
SDLRenderer::renderPoint(const vec2& position, const Color& color) {
SDL_SetRenderDrawColor(_renderer,
color.red * 255,
color.green * 255,
color.blue * 255,
color.alpha * 255);
auto p = AffineTransform::applyTransform(_origin, position);
SDL_RenderDrawPoint(_renderer, p.x, p.y);
}
void zSDL_RenderDrawPoint( SDL_Renderer * renderer, Uint16 x, Uint16 y) {
Uint16 xz;
Uint16 yz;
//return;tf
for (yz=0;yz<zoom;yz++){
for (xz=0;xz<zoom;xz++){
SDL_RenderDrawPoint(renderer, x*zoom+xz, y *zoom +yz);
}
}
}
void drawStars(void)
{
int i;
int c;
for (i = 0 ; i < MAX_STARS ; i++)
{
c = 64 * stars[i].speed;
SDL_SetRenderDrawColor(app.renderer, c, c, c, 255);
SDL_RenderDrawPoint(app.renderer, stars[i].x, stars[i].y);
if (c >= 240)
{
SDL_RenderDrawPoint(app.renderer, stars[i].x + 1, stars[i].y + 1);
}
}
}
void PRJ_render_point(SDL_Renderer* renderer,
double vertex[],
int res[]) {
int point_2d[2];
PRJ_transform_point(point_2d,
vertex,
PRJ_position,
res);
SDL_RenderDrawPoint(renderer, point_2d[0], point_2d[1]);
}
// Called by Rocket when it wants to render geometry that it does not wish to optimise.
void RocketSDL2Renderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
{
// SDL uses shaders that we need to disable here
glUseProgramObjectARB(0);
glPushMatrix();
glTranslatef(translation.x, translation.y, 0);
std::vector<Rocket::Core::Vector2f> Positions(num_vertices);
std::vector<Rocket::Core::Colourb> Colors(num_vertices);
std::vector<Rocket::Core::Vector2f> TexCoords(num_vertices);
float texw, texh;
SDL_Texture* sdl_texture = NULL;
if(texture)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
sdl_texture = (SDL_Texture *) texture;
SDL_GL_BindTexture(sdl_texture, &texw, &texh);
}
for(int i = 0; i < num_vertices; i++) {
Positions[i] = vertices[i].position;
Colors[i] = vertices[i].colour;
if (sdl_texture) {
TexCoords[i].x = vertices[i].tex_coord.x * texw;
TexCoords[i].y = vertices[i].tex_coord.y * texh;
}
else TexCoords[i] = vertices[i].tex_coord;
};
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, &Positions[0]);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, &Colors[0]);
glTexCoordPointer(2, GL_FLOAT, 0, &TexCoords[0]);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDrawElements(GL_TRIANGLES, num_indices, GL_UNSIGNED_INT, indices);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
if (sdl_texture) {
SDL_GL_UnbindTexture(sdl_texture);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glColor4f(1.0, 1.0, 1.0, 1.0);
glPopMatrix();
/* Reset blending and draw a fake point just outside the screen to let SDL know that it needs to reset its state in case it wants to render a texture */
glDisable(GL_BLEND);
SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_NONE);
SDL_RenderDrawPoint(mRenderer, -1, -1);
}
//Draw Points
void CSprite::DrawPoint(Type2<slong> pos, _COLOR<uchar> color)
{
if (color.a == 0)
return;
if (this->m_eCoordinateSystem == CARTESIAN)
pos.y = SCREEN_HEIGHT - pos.y;
SDL_SetRenderDrawColor(this->m_pRen, color.r, color.g, color.b, color.a);
SDL_RenderDrawPoint(this->m_pRen, pos.x, pos.y);
}
void cGraphicsSDL2::DrawFillCircle(int &x, int &y,
uint32_t &radius,
sColor *color /*= nullptr*/) {
SetDrawColor(color);
int tmpX = 0;
int tmpY = 0;
for (int i = 0; i < 360; i++) {
tmpX = x + (sin(i) * radius);
tmpY = y + (cos(i) * radius);
SDL_RenderDrawPoint(m_Renderer, tmpX, tmpY);
}
}
void Display::drawFragment(const Vertex & v) {
float x = v.attrs[0].x, y = v.attrs[0].y;
if (v.attrs.size() >= 2) {
glm::vec4 color = v.attrs[1];
int X = (int)(round(x)), Y = (int)(round(y));
color.x *= 255;
color.y *= 255;
color.z *= 255;
SDL_SetRenderDrawColor(renderer, color.x, color.y, color.z, 255);
SDL_RenderDrawPoint(renderer, X, Y);
}
}
void SDLWindow::DrawEllipse(const Rect &rect)
{
// This is how often points will be drawn
const static double granularity = 0.001;
// We roll our own ellipse...
double angle = 0;
int x = rect.x, y = rect.y, w = rect.w, h = rect.h;
while (angle <= M_PI * 2) {
SDL_RenderDrawPoint(this->write_to, x + (w*cos(angle)), y + (h*sin(angle)));
angle += granularity;
}
}
void CPhysicsDebugDraw::DrawPoint(const b2Vec2& p, float32 size, const b2Color& color)
{
//SDL_SetRenderDrawColor(g_app->sdlRenderer,color.r,color.g,color.b,255);
SDL_RenderDrawPoint(g_app->sdlRenderer,(int)(p.x),(int)(p.y));
//glPointSize(size);
//glBegin(GL_POINTS);
//glColor3f(color.r, color.g, color.b);
//glVertex2f(p.x, p.y);
//glEnd();
//glPointSize(1.0f);
}
void drawLissajousFigure(SDL_Renderer *ren, int m, int n)
{
int x, y;
SDL_SetRenderDrawColor(ren, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(ren);
SDL_SetRenderDrawColor(ren, 0xFF, 0xFF, 0xFF, 0xFF);
for(double i = 0; i <= 180; i += 0.01)
{
x = (SCREEN_WIDTH / 2) + (SCREEN_WIDTH / 2) * cos(m * i), y = (SCREEN_HIGHT / 2) + (SCREEN_HIGHT / 2) * sin(n * i);
SDL_RenderDrawPoint(ren, x, y);
}
SDL_RenderPresent(ren);
}
void Line::draw()
{
int window_w, window_h;
SDL_GetWindowSize(window, &window_w, &window_h);
std::vector<SDL_Point> draw_points;
// try to get minimal drawing area, so i don't have to draw across the entire window
int tlx = window_w;
int tly = window_h;
int brx = 0;
int bry = 0;
if(start_point.x < tlx) tlx = start_point.x;
if(end_point.x < tlx) tlx = end_point.x;
if(start_point.y < tly) tly = start_point.y;
if(end_point.y < tly) tly = end_point.y;
if(start_point.x > brx) brx = start_point.x;
if(end_point.x > brx) brx = end_point.x;
if(start_point.y > bry) bry = start_point.y;
if(end_point.y > bry) bry = end_point.y;
// don't draw if it goes off screen either
if(tlx < 0) tlx = 0;
if(tly < 0) tly = 0;
if(brx > window_w) brx = window_w;
if(bry > window_h) bry = window_h;
double slope = end_point.x - start_point.x != 0? double(end_point.y - start_point.y) / double(end_point.x - start_point.x) : global::VERTICAL_SLOPE;
int b = start_point.y - slope * start_point.x;
// for each pixel in drawing area
for(int x = tlx; x <= brx; x++)
{
for(int y = tly; y <= bry; y++)
{
double dist = double(y - slope * x - b) / sqrt(slope*slope + 1);
if(dist < 0) dist *= -1;
// if distance is within 1 pixel, it's an edge
if(dist <= 1)
{
int anti_alias = 255 * dist;
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a - anti_alias);
SDL_RenderDrawPoint(renderer, x, y);
}
}
}
}
