Thread #1: let's do a coding project together

do not deviate from the plan.

no bot, I did it manually.

I am not deviating you tard.

I was hoping we could have a friendly community to collaborate on this project together.

okay, I'll start
#include intmain(int argc, char *argv[]){ printf("\/thread"); return 0;}

We need some guys to make a program that generates logos.

#include intmain(int argc, char *argv[]){ printf("\/thread"); return 0;}

YOU ARE DOING IT WRONG YOU FUCK

...

#include #include int_tmain(int argc,_TCHAR* argv[]){putchar('\/'); putchar('t'); putchar('h');putchar('r'); putchar('e'); putchar('a'); putchar('d'); getch(); }

Neckbear pls.

Slash doesn't need escaping you fucking tards.

You're right, I got /t and \t backwards. See user, we make a great team!

I thought that and the missing newline were the joke.

missing newline? The program isn't finished user

We're writing a shell in x86 assembly, let's use this as a base:
github.com/unixist/ash
Action plan:
1. Change everything to Intel syntax.
2. Create basic command parser, using builtin commands to test it.
3. Make it able to start external programs.

Don't know Assembly? Get off your lazy ass and learn.
mark.masmcode.com/

*x86_64

Haven't we already learned that Holla Forums knows so little about asm that even echo was made worse? Seems like a mistake.

...

Maybe I didn't see the final version but after a month the one I tested was still running several times slower for non-trivial cases.

It's still being updated, there is no final version
github.com/faissaloo/echo

I'm at work so I can't test it but looking at that code it's using a 'fast' strlen trick that is 20 years out of date and very slow today. That variant is only used on embedded processors that lack SSE instructions.

That's what I mean by it being a bad project, Holla Forums's idea of state-of-the-art in asm is from before many here were born.

Most of the bloat in things like GNU comes from library shit that is automatically pulled in. You can get most of the benefits while retaining portability if you cut that out instead of handoptimizing assembly.

lets just pick a program Holla Forums likes for linux and fully automate the installation process so that it works on the most popular OSs and then some more

I suggest gimp or libre office

...

what more is there to automate, that's like a single command with most package managers

...

They have easy installers already.

Buy Krita on Steam
Double click the installer .exe

ARE YOU FUCKERS EVEN FROM Holla Forums?!

Spending money on software isn't really the issue, software being proprietary is. The Krita version he's talking about is fully FOSS, it just happens to cost money.

the issue I have with it is requiring people to buy software to participate in an activity that I believe to be for fun

Lots of fun things cost money. What's special about this one?

nothing worth debating you about

You fucking hypocrite.

I was responding to a retard who wants to build crutches for users of package-manager-deficient OSes but can't even do the most basic research. Seems like you can't read either.

go watch your hyperscat

elaborate

...

This already exists. Gimp has had an automated installer on win32 for probably longer than you've been alive, from the sound of things.

An Imageboard meticulously programmed in perfect assembly to end all imageboard cuck wars

only RISC-V asm is acceptable

so gimp has a linux executable that runs on all linux

the real solution would probably be an IRC style protocol that lets boards communicate between each other. you know how there's loads of different IRC clients

How to choose logo:
1. Generate it randomly
2. The end
/*icongen.cppGenerates a random square bitmap with the given file name and side length.*/#include #include #include #include "bitmap_image.hpp" /* github.com/ArashPartow/bitmap */intmain(int argc, char** argv) { if(argc < 3) { puts("Usage: icongen \n"); exit(1); } int size = atoi(argv[2]); bitmap_image icon(size, size); srand(time(NULL)); for(int x=0; x

underrated post

it's a stale meme

I say we fork templeOS with a focus on networking then set up a way to shitpost through said networking capabilities.

Let's Enhance® it
/* * icongen.cpp v2, licensed under GPLv3 by Anonymous * Generates a random square bitmap with the given file name and side length. * */#include #include #include #include "bitmap_image.hpp" /* github.com/ArashPartow/bitmap *//* mask for generation modes */#define CHANNEL_R 0x0001#define CHANNEL_G 0x0002#define CHANNEL_B 0x0004#define GEN_BW 0x0008#define CHANNEL_ALL 0x0007intget_generation_modes(char str[]) { int modes = 0; for (int i(0); i < strlen(str); ++i) { switch(str[i]) { case 'r': modes |= CHANNEL_R; break; case 'g': modes |= CHANNEL_G; break; case 'b': modes |= CHANNEL_B; break; case 'A': modes |= CHANNEL_ALL; break; case 'w': modes |= GEN_BW; break; default: fprintf(stderr, "[Warning] Unknown mode option \'%c\'\n", str[i]); } } return modes;}intmain(int argc, char** argv) { if(argc < 3) { puts("Usage: icongen [modes]\n"); exit(1); } int modes; if (argc >= 4) { modes = get_generation_modes(argv[3]); } else { modes = CHANNEL_ALL; } unsigned int size = atoi(argv[2]); bitmap_image icon(size, size); srand(time(NULL)); for(int x(0); x < size; x++) { for(int y(0); y < size; y++) { unsigned char red = 0, blue = 0, green = 0, value = rand()%256; if (modes & CHANNEL_R) red = modes & GEN_BW ? value : rand() % 256; if (modes & CHANNEL_G) green = modes & GEN_BW ? value : rand() % 256; if (modes & CHANNEL_B) blue = modes & GEN_BW ? value : rand() % 256; icon.set_pixel(x, y, red, green, blue); } } icon.save_image(argv[1]); return 0;}

Tested and working on Debian Jessie with G++ 4.9.2
I added a third parameter to set generation modes, each one defined by a single character. The default mode is equivalent to "A", and will generate an image the same way as the previous version.

'r', 'g', 'b' activate randomness on the R, G, B channels. Default value for these if not set is 0. For example, an image with the flag 'b' generates randomness in the blue channel only.
'A' is equivalent to "rgb", it sets all channels.
'w' is Black and White mode. Instead of giving each channel a separate random value, it sets the same on across all of them, thus generating a monochrome image. For example, "rgw" generates a monochrome ('w') yellow ('r'+'g') image.

Adding cyan, yellow and magenta modes should be trivial... or not :^)

Forgot to add, question for beginners:
If you pass "w" only as the modes argument, the image generated is 100% black instead of being a grayscale. Spot why.

Default for 'r', 'g' and 'b' is 0, in monochrome it's still RGB(0, 0, 0) i.e. black.
What do I win ?

Half an Internet, my friend.

We need to have it draw shapes, but only regular polygons, circles and squares because they're visually pleasing shapes. No rectangle or ellipse nonsense.
Also, we need to get it to use golden ratio or rule of thirds to figure out where to position things in a visually pleasing manner.
We also need to make sure that shapes drawn next to each other are inversions of each other so that they have good contrast.

Half an internet onward,
All in the valley of Death

How about a privacy oriented fork of chromium without the botnet? :^)

We can call it "Tin".

Just make all the channels one 32-bit int to save RAM.

Actually that way we could do in one operation, rgb^0x00FFFFFF

I don't understand what you mean there.
Making the variables r, g and b in main() to be a single int? That would not reduce the RAM usage.

Good idea, could you write a draw_polygon() function? Using the following structure, maybe.
struct Polygon { float rotation_angle; /* in radians */ float radius; unsigned int n_sides;};

Forgot to add a couple fields to the structure.
struct Polygon { float rotation_angle; /* in radians */ float radius; unsigned int n_sides; /* Or better use a Color structure for these */ char r_fill, g_fill, b_fill; char r_border, g_border, b_border;};

There's no need for the struct, since we won't need to modify the item on the canvas after drawing it, just the function, what we do need however is a draw_point() and draw_line() function with which we can build more complex drawing functions. We need a good looking anti-aliasing algorithm for draw_line(), speed doesn't matter when we're making a logo.

We should use either the Gupta-Sproull or Xiaolin Wu line drawing algorithm, anyone know which looks better?

voiddraw_line(bitmap_image& image, Color& color, Point& origin, Point& destination);
then?

No, it shouldn't have a color argument, color should be a global variable that is set when it needs to change, that way it is faster for when we want to draw multiple lines with one color.

Please adopt a consistent position on this.

(Note: I understand there are other benefits to a global color variable system like OpenGL)

Xiaolin Wu seems to be simpler to implement.

I have a consistent position, what I said was correct when you take into account context.
When we're making a logo, the speed shouldn't be prioritised over looks
There is no benefit to using the slow method here.

That's irrelevant here, the question is: does it look better?

From what I've found, the result is identical.

Then use the fastest

Samefag shill.

You all be good kids and stay in this containment site now.

...