[QUOTE=Torrunt;51977691]I've been working on improving performance for my game as well improving the AI a bit. I managed to fix up part of the animated sprite system which improved performance a lot and allows the game to handle almost twice as many enemies on screen. That helps make the Mayhem and Gatling Defence mini-games more fun and challenging. Also tweaking the AI to make the zombies not walk up/down towards their target until they're a certain distance away from them helped spread them out more in these modes.
[video=youtube;lBDXOX1zGBc]http://www.youtube.com/watch?v=lBDXOX1zGBc[/video]
The zombies also now look and and point their arms in the direction of their target. Before it didn't look very good when a horde of zombies instantly turned around when you ran/dodged past them (since they all had their arms pointing straight forward when they flipped). I also think hordes of zombies look cooler now that you can see all the arms reaching out for you.[/QUOTE]
That's awesome! What do you use for your animations?
Finally got tooltips working.
The tooltip automatically sets its pivot in a way so it always stays inside the screen.
It reacts to [I]some[/I] events from the thing (ability, macro, unit, slot, item, ...) its bound to and the thing itself can trigger a refresh with RefreshTooltip();
That way I get automatic regeneration of the text for the most common things, while not overcomplicating everything. And I still have a way to refresh it manually if there's some complex mechanism going on...
It also uses roslyn to "recompile" the c# code from using string.Format and string.Concat/+ into a version that does everything with a StringBuilder, so there are no allocations and the whole thing is actually faster :)
Even though we all know that 90% of the awesomeness is in the code, everyone loves images - so here's one:
[IMG]http://i64.tinypic.com/9jnpsm.png[/IMG]
It was fun doing that and even tho I created a really solid solution for some problem, I feel a bit guilty that I put more time into this than maybe necessary; instead of working on actual features.
But I guess I'd feel guilty as well if I hadn't done it right haha... maybe you guys know what I mean
[QUOTE=DrDevil;51977998]Watched the video before reading what you changed (I'm not familiar with the game), and the zombie turning indeed seems pretty natural. However I kind of think that you could improve on that if you added a random delay to the turnrate of the zombies, that way it could look even more natural. You could use a simple low pass filter with a time constant randomly chosen using a gaussian distribution.[/QUOTE]
Each zombie already has a random arm turn speed. I should probably mess around with it a bit more though.
[QUOTE=chonks;51978577]That's awesome! What do you use for your animations?[/QUOTE]
Animations are done in Adobe Flash and then exported out as images and xml files using a little AIR program I made. My animated sprite system then uses the xml files to load them in and put them together.
[QUOTE=Torrunt;51979018]Each zombie already has a random arm turn speed. I should probably mess around with it a bit more though.
Animations are done in Adobe Flash and then exported out as images and xml files using a little AIR program I made. My animated sprite system then uses the xml files to load them in and put them together.[/QUOTE]
If you use a constant speed, it will look very stiff. Try using a low pass filter on the absolute position instead.
[QUOTE=DrDevil;51979087]If you use a constant speed, [b]it will look very stiff[/b]. Try using a low pass filter on the absolute position instead.[/QUOTE]
Well, I mean, they ARE zombies.
[QUOTE=Lett1;51978418]Trying my hand at a [URL="https://github.com/TheBerkin/Rant/issues/92"]typo generator[/URL]. Currently two modes are implemented: transposition and mistyping based on the keyboard layout.
Example string: [CODE]the quick brown fox jumps over the lazy dog 1234567890 -+ [] \ ; ' , . /[/CODE]
Transposing letters:
[CODE]teh qucik borwn fxo jupms ovre hte layz dgo 1234568790 +- ][ \ ; ' , . /
hte qucik rbown ofx jmups ovre hte layz odg 1235467890 +- ][ \ ; ' , . /
hte uqick borwn fxo jmups ovre teh layz dgo 1243567890 +- ][ \ ; ' , . /
teh qucik borwn ofx jupms oevr hte alzy dgo 1234657890 +- ][ \ ; ' , . /
teh qucik borwn fxo jmups oevr teh alzy odg 1243567890 +- ][ \ ; ' , . /
hte qiuck borwn fxo ujmps oevr hte alzy dgo 1234567980 +- ][ \ ; ' , . /
hte uqick rbown ofx jumsp voer hte layz odg 1234567809 +- ][ \ ; ' , . /
teh quikc brwon ofx jumsp oevr hte lzay odg 1234567809 +- ][ \ ; ' , . /
teh quikc rbown ofx ujmps ovre teh alzy odg 1234568790 +- ][ \ ; ' , . /
hte qucik borwn fxo ujmps oevr hte alzy odg 1234576890 +- ][ \ ; ' , . / [/CODE]
Mistyping Keys:
[CODE]the quick b3own fox jumps ove4 5he lasy d9g 1234567890 -+ [] \ ; ' , . /
the quick brown rox jumps pver the lqzy dog 12345u7890 -+ [] \ ; ' , . /
the quick brown fox jumps over the laay dog 1234567890 -+ [] \ ; ' , . /
the quick brown fox jumpc obe5 fhe lazy dov 1134567890 -+ [] \ ; ' , . /
ty4 qyick br;wn fox kumps ofer the .wzy dog 123e567890 -+ [] \ ; ' , . /
the 2uick bdiwn fox jujps ov45 the lazy dog 223456u8o- -+ [] \ ; ' , . /
the quicm browb fox jumps over thf lazy dog 1234567890 -+ [] \ ; ' , . /
th3 quick browj fox jumpa ;ver the lazy doy 12e45y7990 -+ [] \ ; ' , . /
the quick vr;wn fpx jumps over the lazy dog 1234567890 -+ [] \ ; ' , . /
the 1uick brown f0z jumps over the lazy dog 1234567890 -+ [] \ ; ' , . / [/CODE]
This one probably needs some adjustments but it looks pretty good so far.[/QUOTE]
Suggestion: One of the most common typos I make is holding the SHift key too long, causing me to capitalize too many letters. That would be a great typo mode to add.
I've been working on my android game, Mine field crosser. I decided to tone down the amount of stuff I was going to put in it. This allowed me to focus on finishing instead of still adding things. If I get a good response when I release I'll continue to add things and release updates. Other wise it's time to move on to a new project or two. In the video below I run into a crash at the end, with no error in the logcat. However the video shows most of the current state, and please excuse the high score names, I had an interesting time implementing things.
[video] https://www.youtube.com/watch?v=XaW3hH6s244 [/video]
[b]Things I plan to change/add:[/b]
Increase size of music and sound volume selectors for better selection control.
Ability to zoom out and back in a bit.
find source of crash ( i haven't tried to replicate it yet )
Create about game section to give proper attribution as needed.
Thanks for checkin this out. Most comments are welcome.
[b]edit:[/b]
Ok, so i can't reproduce the crash, I fixed the size of the sound bars, and I have a video of a complete run through the game, I need to check a few more things and do a little more polish, then I can release!!! yay!
[video]https://youtu.be/UHQI9b1fWsg[/video]
I'm trying to learn more unix style commands and scripting. I come across printf and man page it. On the page I see familiar escape characters like \n, but then I see
"\uHHHH" and "\uHHHHHHHH". My only response to when the fuck you'd use this is uhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
[QUOTE=DoctorSalt;51984086]I'm trying to learn more unix style commands and scripting. I come across printf and man page it. On the page I see familiar escape characters like \n, but then I see
"\uHHHH" and "\uHHHHHHHH". My only response to when the fuck you'd use this is uhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh[/QUOTE]
If you're serious about not knowing, they're for Unicode code points. The longer one is for surrogate pairs (e.g. emoji).
On an unrelated note, I just want to say I [I]love[/I] C# 7's new binary literals.
[img]http://i.imgur.com/Jbzmz27.png[/img]
Knowing some history of MS, and what the tech community largely thinks about MS I logically feel like I should detest them but C# is bae so I don't know what to feel.
[QUOTE=DoctorSalt;51984573]Knowing some history of MS, and what the tech community largely thinks about MS I logically feel like I should detest them but C# is bae so I don't know what to feel.[/QUOTE]
I've begun to keep my critical thoughts narrowed and precise.
When it comes to C++ for example, STL means I have nothing but positive things to think about the implementation team but it seems the compiler team is dropping the ball. Now that my friend works for the excel team, I kinda understand why that program is such a nightmare at times :v: (Holy fucking legacy code, Batman!)
[QUOTE=paindoc;51984678][...] (Holy fucking legacy code, Batman!)[/QUOTE]
I wonder when that stuff is going to be added to the official list of great scourges of mankind.
It's alive people..
[video=youtube;m_FZeHffAhw]http://www.youtube.com/watch?v=m_FZeHffAhw[/video]
Shapes created with particles and vector fields, I'd call it a happy accident. Ports over to UE4 exactly the same. So much potential. Booyahhhhhh. (Still gotta fix rotation happening anytime you click and move your mouse).
[QUOTE=jangalomph;51984996]It's alive people..
[video=youtube;m_FZeHffAhw]http://www.youtube.com/watch?v=m_FZeHffAhw[/video]
Shapes created with particles and vector fields, I'd call it a happy accident. Ports over to UE4 exactly the same. So much potential. Booyahhhhhh. (Still gotta fix rotation happening anytime you click and move your mouse).[/QUOTE]
There's something immensely satisfying about the way the window moves when you rotate the object.
I got most my modules expanded to work in 3D, and got spherical noisemap generation working :D
[t]http://i.imgur.com/t8uZJhB.png[/t]
This isn't the full module chain I need to get set up, and I haven't finished porting [I]all[/I] of the various modules in my library, but the vast majority are good to go. Downside: 3D is vastly more expensive, and this took about 7 seconds to generate (compared to less than one for 2D) at 8192x8192.
Also, if I make the dimensions unequal uh everything breaks quite hard:
[t]http://i.imgur.com/AFwqSEz.png[/t]
So I gotta fix that still, since its ideal in these equirectangular projections to have the X-dimensions be twice that of the Y-dimension. I also need to tune the performance and really work on memory consumption, and maybe find a way to make this less likely to crash a user's display driver :v:
[editline]19th March 2017[/editline]
Best part I'm looking forward to using: super easy to access this data on the GPU, so using it for real-time terrain rendering should be easy and really fast since you don't have to wait for it to stream to the GPU. I'm working on finding ways to pass a handle/pointer to this data to graphics APIs, and hope to test that soon. I've been working on my mesh LOD'ing stuff all in anticipation of getting to show off the two working together!
Jesus Christ sometimes i manage to impress myself... I have a crappy tablet and the touchscreen doesnt work and the brand went bankrupt a while ago which means i cant download the stock ROM anymore, so i did some disassembly and exported the UART port outside of the case, 7 hours of staring into console outputs later and i manage do discover some neat stuff!
Imagine burning an image file to an SD card, shoving it into the device and rebooting and- boom- rooted.
More info soon.
My speech synthesizer can now convert simple words to a phonemic representation, but all it can pronounce right now is vowels (not even diphthongs). It's something special.
[vid]https://my.mixtape.moe/prjavm.mp4[/vid]
Some highlights from my first attempt at a match between 3v3 bot teams.
[media]https://www.youtube.com/watch?v=QKcS2V8zCvs[/media]
It was a blowout because blue team was set to the wrong positions, causing them to lose every faceoff, but I let it run to see how many goals red could rack up. Also something was wrong with Namestikov's speech causing him to yell at everyone on both teams including himself.
[QUOTE=DrDevil;51979087]If you use a constant speed, it will look very stiff. Try using a low pass filter on the absolute position instead.[/QUOTE]
I'm using a cosine interpolation for that arm rotations now, I think it looks alright. Here's what that looks like:
[video=youtube;DPoYljd0PFI]http://www.youtube.com/watch?v=DPoYljd0PFI[/video]
(Zombie on the left has the slowest possible arms and the one on the right has the fastest)
and here's a quick video of it in action in mayhem:
[video=youtube;Y3JUYe66ES0]http://www.youtube.com/watch?v=Y3JUYe66ES0[/video]
I have published our game's source code: [url]https://github.com/PepperCarrotGame/peppercarrotgame_source[/url]
It still lacks the binary assets folder, I'll upload that later once I sort out licensing.
Some raytracer progress, with schoolmates.
[t]https://puu.sh/uRieQ/53df08fb3e.png[/t]
Procedural flares are ugly as fuck
Any idea how i could improve it ?
[code]
void drawflare(SDL_Surface *target, int x, int y, double distance)
{
int x1;
int y1;
double dist;
distance = 30 + (distance - 1) * (3 - 30) / (25 - 1);
x1 = 0;
y1 = 0;
while (x1 < target->w)
{
y1 = 0;
while (y1 < target->h)
{
dist = sqrt(pow((x1 - x), 2) + pow((y1 - y), 2));
if (dist < distance)
{
putpixel(target, x1, y1, 0xffffffff);
}
else
if ( dist < distance*10 )
{
putpixel(target, x1, y1, (( (Uint32)(255 + (dist - distance) * (0 - 255) / (distance*10 - distance)) << 24) + (255 << 16) + (255 << 8) + (255)));
}
y1++;
}
x1++;
}
}
[/code]
[QUOTE=jangalomph;51984996]It's alive people..
[video=youtube;m_FZeHffAhw]http://www.youtube.com/watch?v=m_FZeHffAhw[/video]
Shapes created with particles and vector fields, I'd call it a happy accident. Ports over to UE4 exactly the same. So much potential. Booyahhhhhh. (Still gotta fix rotation happening anytime you click and move your mouse).[/QUOTE]
That's a nice looking ImGui theme. Mind sharing it?
I'm hearing a lot of differing opinions about SDL vs. SFML
Now that SFML and SDL have version 2s, which do you think is better for 2d game engine development in C++, and why?
Reddit says SDL2 but I've heard a couple of arguments for SFML2.
[editline]20th March 2017[/editline]
I should state I intend on implimemting Lua and Tiled into what I am making
[QUOTE=Lett1;51978418]Trying my hand at a [URL="https://github.com/TheBerkin/Rant/issues/92"]typo generator[/URL]. Currently two modes are implemented: transposition and mistyping based on the keyboard layout.
Example string: [CODE]the quick brown fox jumps over the lazy dog 1234567890 -+ [] \ ; ' , . /[/CODE]
Transposing letters:
[CODE]teh qucik borwn fxo jupms ovre hte layz dgo 1234568790 +- ][ \ ; ' , . /
hte qucik rbown ofx jmups ovre hte layz odg 1235467890 +- ][ \ ; ' , . /
hte uqick borwn fxo jmups ovre teh layz dgo 1243567890 +- ][ \ ; ' , . /
teh qucik borwn ofx jupms oevr hte alzy dgo 1234657890 +- ][ \ ; ' , . /
teh qucik borwn fxo jmups oevr teh alzy odg 1243567890 +- ][ \ ; ' , . /
hte qiuck borwn fxo ujmps oevr hte alzy dgo 1234567980 +- ][ \ ; ' , . /
hte uqick rbown ofx jumsp voer hte layz odg 1234567809 +- ][ \ ; ' , . /
teh quikc brwon ofx jumsp oevr hte lzay odg 1234567809 +- ][ \ ; ' , . /
teh quikc rbown ofx ujmps ovre teh alzy odg 1234568790 +- ][ \ ; ' , . /
hte qucik borwn fxo ujmps oevr hte alzy odg 1234576890 +- ][ \ ; ' , . / [/CODE]
Mistyping Keys:
[CODE]the quick b3own fox jumps ove4 5he lasy d9g 1234567890 -+ [] \ ; ' , . /
the quick brown rox jumps pver the lqzy dog 12345u7890 -+ [] \ ; ' , . /
the quick brown fox jumps over the laay dog 1234567890 -+ [] \ ; ' , . /
the quick brown fox jumpc obe5 fhe lazy dov 1134567890 -+ [] \ ; ' , . /
ty4 qyick br;wn fox kumps ofer the .wzy dog 123e567890 -+ [] \ ; ' , . /
the 2uick bdiwn fox jujps ov45 the lazy dog 223456u8o- -+ [] \ ; ' , . /
the quicm browb fox jumps over thf lazy dog 1234567890 -+ [] \ ; ' , . /
th3 quick browj fox jumpa ;ver the lazy doy 12e45y7990 -+ [] \ ; ' , . /
the quick vr;wn fpx jumps over the lazy dog 1234567890 -+ [] \ ; ' , . /
the 1uick brown f0z jumps over the lazy dog 1234567890 -+ [] \ ; ' , . / [/CODE]
This one probably needs some adjustments but it looks pretty good so far.[/QUOTE]
I'm a bit late but a long time ago I did something similar in C# that does random capitalizations and stuff.
[url]https://github.com/protocol114/Fore/blob/master/Common/TypoGenerator/TypoGenerator.cs[/url]
It was actually paired with a shitty Markov chain and prepopulated dictionaries, with final output that looks like any of the following sentences:
[quote]
having the rainy bEGinner beginner radiate he helpful beginners beginners bird cOMPAny milk just hEAd delay?. delay?. plantation have a am AM beginners sUPPOSe a sticky cannnon s tease a just
mysterious bedroom stoMact raiNY WAtch watches helpless dude kick I careful cup plug a ctackers where wehere is an immense Piss wALLET mysTERIOUS lettuce,! flap the AFternoON
has clumsy stomach sQUEEze you you large peNCjl prick the awlaways in kill he rapid stomach have you you returN EASy pencil pnencil shxllow.? laNguage wAIK YO u there paprer[/quote]
[QUOTE=TeamEnternode;51986736]I'm hearing a lot of differing opinions about SDL vs. SFML
Now that SFML and SDL have version 2s, which do you think is better for 2d game engine development in C++, and why?
Reddit says SDL2 but I've heard a couple of arguments for SFML2.
[editline]20th March 2017[/editline]
I should state I intend on implimemting Lua and Tiled into what I am making[/QUOTE]
It's mostly a matter of taste. They differ mainly in API style, with SFML being pretty object oriented and SDL being plain C. I'd argue for something that's going to be a fairly low level component of an engine, the latter is better, but it's entirely up to personal taste.
It's in any case nothing to spend a lot of time on up front evaluating, just pick one and see if you like it. It's going to vanish pretty quickly inside your engine code anyways. I've always been a bit suspious of the built in sprite stuff they have and would recommend rolling that yourself using OpenGL because it's the more flexible route but that's also up to personal taste I guess.
FWIW I used both and liked SDL better because the C-ish API is a better format for libraries in my opinion but if you prefer to USE object oriented APIs, you might find SFML nicer to use.
[QUOTE=eirexe;51985857]I have published our game's source code: [url]https://github.com/PepperCarrotGame/peppercarrotgame_source[/url]
It still lacks the binary assets folder, I'll upload that later once I sort out licensing.[/QUOTE]
In case you used other engines previously, what is most different in Godot in your opinion?
[editline]20th March 2017[/editline]
[QUOTE=pierre0158;51986116][...]
Procedural flares are ugly as fuck
[...][/QUOTE]
They could use some irregularities, but I'm saying this as someone who wears glasses and as such gets pretty crazy patterns from these :v:
They seem overall way too strong/large, too.
[QUOTE=pierre0158;51986116]
[...]
Any idea how i could improve it ?
[...]
[/QUOTE]
Can't say much about the looks. But performance wise, I would do a row-major traversal for better cache utilization. Assuming your texture uses a conventional pixel layout.
And you could probably approximate a min-max region for x1 and y1. But I don't know math so idk.
You can also easily optimize your pow calls, since you use a fixed exponent. pow is slow af
[code]
float dx = x1 - x;
float dy = y1 - y;
dist = sqrt(dx*dx + dy*dy)
[/code]
I know you didn't ask for performance advice but I couldn't help myself sorry
[QUOTE=Z_guy;51986193]That's a nice looking ImGui theme. Mind sharing it?[/QUOTE]
[CODE]void VectorayGenStyle() {
auto& style = ImGui::GetStyle();
style.Alpha = 1.0f; // Global alpha applies to everything in ImGui
style.WindowPadding = ImVec2(8, 8); // Padding within a window
style.WindowMinSize = ImVec2(32, 32); // Minimum window size
style.WindowRounding = 0.0f; // Radius of window corners rounding. Set to 0.0f to have rectangular windows
style.WindowTitleAlign = ImGuiAlign_Left; // Alignment for title bar text
style.ChildWindowRounding = 0.0f; // Radius of child window corners rounding. Set to 0.0f to have rectangular child windows
style.FramePadding = ImVec2(4, 3); // Padding within a framed rectangle (used by most widgets)
style.FrameRounding = 0.0f; // Radius of frame corners rounding. Set to 0.0f to have rectangular frames (used by most widgets).
style.ItemSpacing = ImVec2(8, 4); // Horizontal and vertical spacing between widgets/lines
style.ItemInnerSpacing = ImVec2(4, 4); // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)
style.TouchExtraPadding = ImVec2(0, 0); // Expand reactive bounding box for touch-based system where touch position is not accurate enough. Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget. So don't grow this too much!
style.IndentSpacing = 21.0f; // Horizontal spacing when e.g. entering a tree node. Generally == (FontSize + FramePadding.x*2).
style.ColumnsMinSpacing = 6.0f; // Minimum horizontal spacing between two columns
style.ScrollbarSize = 16.0f; // Width of the vertical scrollbar, Height of the horizontal scrollbar
style.ScrollbarRounding = 9.0f; // Radius of grab corners rounding for scrollbar
style.GrabMinSize = 10.0f; // Minimum width/height of a grab box for slider/scrollbar
style.GrabRounding = 0.0f; // Radius of grabs corners rounding. Set to 0.0f to have rectangular slider grabs.
style.DisplayWindowPadding = ImVec2(22, 22); // Window positions are clamped to be visible within the display area by at least this amount. Only covers regular windows.
style.DisplaySafeAreaPadding = ImVec2(4, 4); // If you cannot see the edge of your screen (e.g. on a TV) increase the safe area padding. Covers popups/tooltips as well regular windows.
style.AntiAliasedLines = true; // Enable anti-aliasing on lines/borders. Disable if you are really short on CPU/GPU.
style.AntiAliasedShapes = true; // Enable anti-aliasing on filled shapes (rounded rectangles, circles, etc.)
style.CurveTessellationTol = 1.25f; // Tessellation tolerance. Decrease for highly tessellated curves (higher quality, more polygons), increase to reduce quality.
style.Colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f); // Fine
style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f); // Fine
style.Colors[ImGuiCol_WindowBg] = ImVec4(0.12f, 0.12f, 0.12f, 1.00f); // Fine
style.Colors[ImGuiCol_ChildWindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); // Fine
style.Colors[ImGuiCol_PopupBg] = ImVec4(0.05f, 0.05f, 0.10f, 1.00f); // Maybe?
style.Colors[ImGuiCol_Border] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f); // Fine
style.Colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); // Fine
style.Colors[ImGuiCol_FrameBg] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f); // Background of checkbox, radio button, plot, slider, text input
style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f); // Little box hover color
style.Colors[ImGuiCol_FrameBgActive] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_TitleBg] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f); //Title bar
style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.12f, 0.12f, 0.12f, 1.00f); //Title Bar
style.Colors[ImGuiCol_TitleBgActive] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f); //Title bar active (ORANGE) 1.00f, 0.47f, 0.00f, 1.00f
style.Colors[ImGuiCol_MenuBarBg] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f); //Scroll bar background
style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.40f, 0.40f, 1.00f); //Scroll Bar Color
style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.40f, 0.40f, 1.00f); //Scroll bar click color
style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.40f, 0.40f, 0.40f, 1.00f); //Scroll bar drag color
style.Colors[ImGuiCol_ComboBg] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f); // Drop down menus
style.Colors[ImGuiCol_CheckMark] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f); //Check Box
style.Colors[ImGuiCol_SliderGrab] = ImVec4(0.80f, 0.80f, 0.80f, 0.25f); //Slider/Float Slider color
style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f); //Slider/Float Slider Active Color
style.Colors[ImGuiCol_Button] = ImVec4(1.00f, 0.47f, 0.10f, 1.00f); //Button Color *FIX THIS*
style.Colors[ImGuiCol_ButtonHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
style.Colors[ImGuiCol_ButtonActive] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
style.Colors[ImGuiCol_Header] = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
style.Colors[ImGuiCol_HeaderHovered] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_HeaderActive] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_Column] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
style.Colors[ImGuiCol_ColumnHovered] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_ColumnActive] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_ResizeGripActive] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_CloseButton] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_CloseButtonHovered] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_CloseButtonActive] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
style.Colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_PlotHistogram] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(1.00f, 0.47f, 0.00f, 1.00f);
style.Colors[ImGuiCol_ModalWindowDarkening] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
}[/CODE]
We use an external file to control our colors so that we don't edit any of the files from the ImGui Library. Makes for easier updating. You should be able to get this to work for you :)
I've been meaning to implement ImGUI in my engine and drop the shitty ui I made.
If I use it then I'm going to have at least 3 separate libraries defining vector classes with: GLM, ImGUI, and ASSIMP all defining vec2 vec3 and vec4 :v:
I've been following [URL="https://www.youtube.com/playlist?list=PLbgaMIhjbmEnaH_LTkxLI7FMa2HsnawM_"]Bartosz Milewski's videos on Category Theory for Programmers[/URL], and I feel like it's blowing my mind on a regular basis. Furthermore, I am starting to see why Haskell is so well liked by people who "get it". The video series is bridging that gap between rough and tumble programming languages like C++, and the mathematical beauty and purity of what lies beneath all the dirty implementation details.
I might give Haskell another shot once I'm done with the series. I read the Learn You A Haskell For Great Good book a while ago, and understood the syntax fine, but it never really explained the "why" of Haskell, the almost philosophical arguments for why Haskell, or category theory in general, is a good thing to know about and use when programming.
[B]edit:
[/B]I still don't really know what a monad is
Sorry, you need to Log In to post a reply to this thread.
What are you working on? v67 - March 2017
