Code::Blocks - User contributions [en]

Using FreeGlut with Code::Blocks

2015-08-20T05:16:51Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''May 11th 2013''' known as Martin Payne's Windows binaries. )

Download freeglut 2.8.1‑1 for MinGW --------> freeglut-MinGW-2.8.1-1.mp.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

[[File:fileextensions.jpg]]

[[File:Bothshouldbelookedat.jpg]]

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.8.1-1.mp.zip ] ( '''Latest stable release dated 2013''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''Also, this line "if (!VerifyLibFile(dir_nomacro_lib, _T("glut32"), _T("GLUT's"))) return false;" should now say "if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;"

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2015-08-18T16:18:10Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

EDIT UPDATE : I made an updated tutorial on how to install freeglut without using this hack tutorial. In this tutorial I share how to install a lot of libraries.
'''8.8.2015'''

https://www.youtube.com/watch?v=LRsDUK0azpQ

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''May 11th 2013''' known as Martin Payne's Windows binaries. )

Download freeglut 2.8.1‑1 for MinGW --------> freeglut-MinGW-2.8.1-1.mp.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

[[File:fileextensions.jpg]]

[[File:Bothshouldbelookedat.jpg]]

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.8.1-1.mp.zip ] ( '''Latest stable release dated 2013''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''Also, this line "if (!VerifyLibFile(dir_nomacro_lib, _T("glut32"), _T("GLUT's"))) return false;" should now say "if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;"

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2015-08-18T16:17:46Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

EDIT UPDATE : I made an updated tutorial on how to install freeglut without using this hack tutorial. In this tutorial I share how to install a lot of libraries.
'''8.8.2015'''
https://www.youtube.com/watch?v=LRsDUK0azpQ

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''May 11th 2013''' known as Martin Payne's Windows binaries. )

Download freeglut 2.8.1‑1 for MinGW --------> freeglut-MinGW-2.8.1-1.mp.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

[[File:fileextensions.jpg]]

[[File:Bothshouldbelookedat.jpg]]

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.8.1-1.mp.zip ] ( '''Latest stable release dated 2013''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''Also, this line "if (!VerifyLibFile(dir_nomacro_lib, _T("glut32"), _T("GLUT's"))) return false;" should now say "if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;"

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

User:JackDawson

2015-07-21T02:42:52Z

JackDawson:

[[Using FreeGlut with Code::Blocks]]

My real name is John Mieske.

My aliases are JackDawson and janequorzar as well as TheKnoxxGamer ( Youtube ).

User:JackDawson

2015-07-21T02:42:22Z

JackDawson:

[[Using FreeGlut with Code::Blocks]]

My real name is John Mieske.

My aliases are JackDawson and janequorzar as well as The Knoxx Gamer.

Using FreeGlut with Code::Blocks

2011-12-04T22:12:03Z

JackDawson: /* Operating System Info */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

[[File:fileextensions.jpg]]

[[File:Bothshouldbelookedat.jpg]]

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-12-04T22:11:46Z

JackDawson: /* Operating System Info */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

[[File:fileextensions.jpg|800px]]

[[File:Bothshouldbelookedat.jpg|800px]]

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

File:Bothshouldbelookedat.jpg

2011-12-04T22:10:11Z

JackDawson: These are what you need to use to fix the hidden files problem.

These are what you need to use to fix the hidden files problem.

Using FreeGlut with Code::Blocks

2011-12-04T22:02:42Z

JackDawson: /* Operating System Info */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

[[File:fileextensions.jpg]]

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

File:Fileextensions.jpg

2011-12-04T22:01:40Z

JackDawson: This is where a lot of people can click to get to windows Vista / 7 folder options.

This is where a lot of people can click to get to windows Vista / 7 folder options.

Using FreeGlut with Code::Blocks

2011-12-04T21:52:53Z

JackDawson: /* Operating System Info */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, well keep in mind its about file extensions that are hidden. You can change your extensions to show up in your Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-12-04T21:51:07Z

JackDawson: /* Operating System Info */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

'''EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, its about extensions. You can change your extensions in the Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.'''

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-12-04T21:48:09Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

EDIT ( December 4th 2011 ) : Because I am constantly being asked why they cannot see the files to edit that I listed below, its about extensions. You can change your extensions in the Windows Explorer ORGANIZE. So its ORGANIZE --> FOLDER AND SEARCH OPTIONS --> VIEW ( TAb ) and then you should see where its saying to hide the file extensions. You do NOT want to hide your extensions except your protected system files. Leave those hidden.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

User:JackDawson

2011-09-28T04:06:44Z

JackDawson:

[[Using FreeGlut with Code::Blocks]]

My real name is John Mieske.

My aliases are JackDawson and janequorzar.

Using FreeGlut with Code::Blocks

2011-07-10T21:55:20Z

JackDawson: /* A little Info on Glut32 and FreeGlut */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )

Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:54:56Z

JackDawson: /* A little Info on Glut32 and FreeGlut */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' known as Martin Payne's Windows binaries. )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:51:32Z

JackDawson: /* What You Need To Download */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ] ( '''Latest stable release dated 2010''' )

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:50:32Z

JackDawson: /* What You Need To Download */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the original source code to Glut32 was never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website. You can however still play with the Ported Glut32 source code. It's latest stable release was back in 2001 though.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:48:27Z

JackDawson: /* What You Need To Download */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:46:48Z

JackDawson: /* A little Info on Glut32 and FreeGlut */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that Is described in this tutorial.
( NOTE : Latest Binary release is dated '''January 23rd 2010''' )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:45:40Z

JackDawson: /* A little Info on Glut32 and FreeGlut */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.

http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( '''Dated Nov 8, 2001''' )

This is the freeglut download links.

http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link

http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that I describe in the tutorial. ( NOTE : Latest Binary release is dated '''January 23rd 2010''' )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-10T21:43:40Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 23:43, 10 July 2011 (CEST) )

== A little Info on Glut32 and FreeGlut ==

The original Glut32 written by Mark Kilgard was ported over by Nate Robins. And you can get the ported Glut32 Binaries if you want to see it.
http://www.xmission.com/~nate/glut.html

NOTE : The latest version of the Glut32 library is 3.7.6 ( [b]Dated Nov 8, 2001[/b] )

This is the freeglut download links.
http://freeglut.sourceforge.net/index.php#download

in that link you will see the title : Prepackaged Releases and the first link takes you to the binaries to be downloaded on this link
http://www.transmissionzero.co.uk/software/freeglut-devel/

Its in there where you will see the MinGW download package that I describe in the tutorial. ( NOTE : Latest Binary release is dated [b]January 23rd 2010[/b] )
Download freeglut 2.6.0‑3 for MinGW --------> freeglut-MinGW.zip

This was in reference to Windows and Linux packages according to their website.

When Glut32 was ported over it stopped being updated in 2001. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:48:40Z

JackDawson: /* Installation */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD or NOTEPADD ++, do Not use Microsoft word or WordPad.'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:47:30Z

JackDawson: /* Installation */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:46:51Z

JackDawson: /* Installation */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
and in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:45:06Z

JackDawson: /* Installation */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Move all of those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:44:17Z

JackDawson: /* Installation */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files and folders into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:41:08Z

JackDawson: /* The wizard.script File */

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:36:17Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known by his game name as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:35:16Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( Also known as [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:34:43Z

JackDawson:

[[Category:User Documentation]]

Written By John Mieske ( [[User:JackDawson|JackDawson]] 15:34, 8 July 2011 (CEST) )

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

Using FreeGlut with Code::Blocks

2011-07-08T13:34:02Z

JackDawson:

Using FreeGlut with Code::Blocks

2011-07-08T13:28:31Z

JackDawson:

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made graphic software a little easier to code when it comes to programming OpenGL with 3D in mind.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 15:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T13:26:36Z

JackDawson: /* The reason for using freeGlut */

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is freeGlut and Glut32 can be installed just about the same way for Code::Blocks, with the exception that you would not have to edit the two scripts if your installing Glut32. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made using 3D a little easier when it comes to programming OpenGL.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 15:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T13:18:41Z

JackDawson: /* Installation */

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is how you install freeglut can ALSO be used to install Glut32 for Code::Blocks, with the exception that you would not have to edit the two scripts. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made using 3D a little easier when it comes to programming OpenGL.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now that you have copied the correct files and are ready to setup Code::Blocks, go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut
in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 15:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T13:11:28Z

JackDawson: /* Time to run the demo code from Code::Blocks itself */

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is how you install freeglut can ALSO be used to install Glut32 for Code::Blocks, with the exception that you would not have to edit the two scripts. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made using 3D a little easier when it comes to programming OpenGL.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 15:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T13:09:37Z

JackDawson:

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is how you install freeglut can ALSO be used to install Glut32 for Code::Blocks, with the exception that you would not have to edit the two scripts. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made using 3D a little easier when it comes to programming OpenGL.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 15:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T13:08:54Z

JackDawson:

== The reason for using freeGlut ==

Glut32 is not a free library. So some folks decided to recreate it and named it FreeGlut. The interesting part is how you install freeglut can ALSO be used to install Glut32 for Code::Blocks, with the exception that you would not have to edit the two scripts. FreeGlut and Glut32 are a set of functions for use with OpenGL. It has made using 3D a little easier when it comes to programming OpenGL.

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:44, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T13:03:09Z

JackDawson:

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

[[File:Freeglut_5.jpg]]

[[File:Freeglut_6.jpg]]

[[File:Freeglut_7.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:44, 8 July 2011 (CEST)

File:Freeglut 7.jpg

2011-07-08T12:59:42Z

JackDawson: The actual code template that Code::Blocks produces for you.

The actual code template that Code::Blocks produces for you.

File:Freeglut 6.jpg

2011-07-08T12:58:52Z

JackDawson: Since this is for MinGW, choose GNU GCC.

Since this is for MinGW, choose GNU GCC.

File:Freeglut 5.jpg

2011-07-08T12:58:01Z

JackDawson: The Path to MinGW ( Which is where Code::Blocks with Glut needs to know where the Include folder is kept. )

The Path to MinGW

( Which is where Code::Blocks with Glut needs to know where the Include folder is kept. )

Using FreeGlut with Code::Blocks

2011-07-08T12:55:59Z

JackDawson:

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

[[File:Freeglut_3.jpg]]

[[File:Freeglut_4.jpg]]

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:44, 8 July 2011 (CEST)

File:Freeglut 4.jpg

2011-07-08T12:54:48Z

JackDawson: Create the Glut Project.

Create the Glut Project.

File:Freeglut 3.jpg

2011-07-08T12:54:07Z

JackDawson: Choosing the Glut / Glut Project option.

Choosing the Glut / Glut Project option.

Using FreeGlut with Code::Blocks

2011-07-08T12:44:58Z

JackDawson:

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

== Time to run the demo code from Code::Blocks itself ==

Start up code::blocks and choose Create New Project and then choose Glut / Glut Project. Click next and give it a name and point to where you want the project saved too. Click next again and where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )

So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:44, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T12:33:19Z

JackDawson:

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup Code::Blocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

So save those files and run code::blocks. Choose Glut. And where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )
So yea.. run the demo right out of the original Code::Blocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:33, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T12:29:13Z

JackDawson:

== Operating System Info ==

This tutorial was demonstrated to work under as well as assumes that your using Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the '''freeglut.dll''' file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It is easier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup CodeBlocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where code::blocks installed too.

So now go to this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

'''NOTE : USE NOTEPADD / NOTEPADD ++'''

Here is what it should look like.

== The wizard.script File ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

'''NOTE''' : Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== The glut.cbp File ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

So save those files and run codeblocks. Choose Glut. And where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )
So yea.. run the demo right out of the original CodeBlocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T12:19:58Z

JackDawson:

== Operating System Info ==

This tutorial was demonstrated to work under Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

== Installation ==

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the freeglut.dll file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It iseasier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup CodeBlocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where codeblocks installed too.

So now goto this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

NOTE : USE NOTEPADD

Here is what it should look like.

== wizard.script ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== glut.cbp ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

So save those files and run codeblocks. Choose Glut. And where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )
So yea.. run the demo right out of the original CodeBlocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:09, 8 July 2011 (CEST)

Using FreeGlut with Code::Blocks

2011-07-08T12:16:35Z

JackDawson:

This tutorial was demonstrated to work under Microsoft Windows 7 64-Bit. However, it should work on any windows system ( as long as Code::Blocks and OpenGL are supported on that Operating System ) as well as Linux. In this tutorial you will see the path reference as the 64-Bit style of the folder ( x86 ).

An example of what I mean is : C:\Program Files (x86)\CodeBlocks\

On a 32-Bit Windows system you will see it as : C:\Program Files\CodeBlocks\

Notice the ( x86 ) is missing.

== What You Need To Download ==

1.) [https://www.codeblocks.org Code::Blocks] You can install the default settings or check mark ALL boxes and install everything. Either way, it's up to you. I prefer to install everything just in case.

2.) [http://www.mingw.org MinGW] ('''NOTE : This is optional''' )

3.) [http://freeglut.sourceforge.net FreeGlut] Do NOT get the source code. GET THE BINARIES. [ Example : freeglut-MinGW-2.6.0-3.mp.zip ]

'''Think of freeglut as if it was the Glut32 Binaries, which the source code to Glut32 is never available since its proprietary. But once you get the GLUT demo working, you can play with the freeglut source code from their website.'''

Once you install Code::Blocks, then you can download and unzip the freeglut ZIP file, which will contain this..

[[File:Freeglut_1.jpg]]

Copy all those files into the C:\Program Files (x86)\CodeBlocks\mingw folder. ( This is the folder where you see Include and Lib folders. This is important. ) If it asks you to overwrite folders, that's OK, say yes. It will not overwrite anything important.

Now copy, do not move, just copy the freeglut.dll file that should currently be in your C:\Program Files (x86)\CodeBlocks\minGW folder into your C:\Windows folder. The reason to copy this into that folder is because C:\Windows is in your path, and to keep the confusion down, It iseasier to just copy it to there. You can always change it later. It would be highly advised that you add the C:\Program Files (x86)\CodeBlocks\MinGW\bin folder to your path as well.

So now you have copied the correct files and are ready to setup CodeBlocks.

So now, if you installed this on a 64Bit Windows, you should have a folder that has Program Files as a name but with the x86 on it too. Well that is where codeblocks installed too.

So now goto this folder : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates\wizard\glut

in there you will see a file named wizard.script. Its this file where it is looking for Glut32. You just simply replace any reference to Glut32 with freeglut. And it really is that simple.

NOTE : USE NOTEPADD

Here is what it should look like.

== wizard.script ==

<source lang=cpp>
////////////////////////////////////////////////////////////////////////////////
//
// GLUT project wizard
//
////////////////////////////////////////////////////////////////////////////////

// globals
GlutPathDefault <- _T("$(#glut)");
GlutPathDefaultInc <- _T("$(#glut.include)");
GlutPathDefaultLib <- _T("$(#glut.lib)");
GlutPath <- _T("");

function BeginWizard()
{
local intro_msg = _T("Welcome to the new GLUT project wizard!\n\n" +
"This wizard will guide you to create a new project\n" +
"using the GLUT OpenGL extensions.\n\n" +
"When you 're ready to proceed, please click \"Next\"...");

local glutpath_descr = _T("Please select the location of GLUT on your computer.\n" +
"This is the top-level folder where GLUT was installed (unpacked).\n" +
"To help you, this folder must contain the subfolders\n" +
"\"include\" and \"lib\".");

Wizard.AddInfoPage(_T("GlutIntro"), intro_msg);
Wizard.AddProjectPathPage();
if (PLATFORM == PLATFORM_MAC)
{
GlutPathDefault="/System/Library/Frameworks/GLUT.framework";
}
else
Wizard.AddGenericSelectPathPage(_T("GlutPath"), glutpath_descr, _T("Please select GLUT's location:"), GlutPathDefault);
Wizard.AddCompilerPage(_T(""), _T("*"), true, true);
}

////////////////////////////////////////////////////////////////////////////////
// GLUT's path page
////////////////////////////////////////////////////////////////////////////////

function OnLeave_GlutPath(fwd)
{
if (fwd)
{
local dir = Wizard.GetTextControlValue(_T("txtFolder")); // txtFolder is the text control in GenericSelectPathPage
local dir_nomacro = VerifyDirectory(dir);

if (dir_nomacro.IsEmpty())
return false;

// verify include dependencies
local dir_nomacro_inc = GetCompilerIncludeDir(dir, GlutPathDefault, GlutPathDefaultInc);
if (dir_nomacro_inc.IsEmpty())
return false;
if (!VerifyFile(dir_nomacro_inc + wxFILE_SEP_PATH + _T("GL"), _T("glut.h"), _T("GLUT's include"))) return false;

// verify library dependencies
local dir_nomacro_lib = GetCompilerLibDir(dir, GlutPathDefault, GlutPathDefaultLib);
if (dir_nomacro_lib.IsEmpty())
return false;

if (PLATFORM == PLATFORM_MSW)
{
if (!VerifyLibFile(dir_nomacro_lib, _T("freeglut"), _T("GLUT's"))) return false;
}
else
{
if (!VerifyLibFile(dir_nomacro_lib, _T("glut"), _T("GLUT's"))) return false;
}

GlutPath = dir; // Remember the original selection.

local is_macro = _T("");

// try to resolve the include directory as macro
is_macro = GetCompilerIncludeMacro(dir, GlutPathDefault, GlutPathDefaultInc);
if (is_macro.IsEmpty())
{
// not possible -> use the real inc path we had computed instead
GlutPathDefaultInc = dir_nomacro_inc;
}

// try to resolve the library directory as macro
is_macro = GetCompilerLibMacro(dir, GlutPathDefault, GlutPathDefaultLib);
if (is_macro.IsEmpty())
{
// not possible -> use the real lib path we had computed instead
GlutPathDefaultLib = dir_nomacro_lib;
}
}
return true;
}

// return the files this project contains
function GetFilesDir()
{
return _T("glut/files");
}

// setup the already created project
function SetupProject(project)
{
// set project options
if (PLATFORM != PLATFORM_MAC)
{
project.AddIncludeDir(GlutPathDefaultInc);
project.AddLibDir(GlutPathDefaultLib);
}

// add link libraries
if (PLATFORM == PLATFORM_MSW)
{
project.AddLinkLib(_T("freeglut"));
project.AddLinkLib(_T("opengl32"));
project.AddLinkLib(_T("glu32"));
project.AddLinkLib(_T("winmm"));
project.AddLinkLib(_T("gdi32"));
}
else if (PLATFORM == PLATFORM_MAC)
{
project.AddLinkerOption(_T("-framework GLUT"));
project.AddLinkerOption(_T("-framework OpenGL"));

project.AddLinkerOption(_T("-framework Cocoa")); // GLUT dependency
}
else
{
project.AddLinkLib(_T("glut"));
project.AddLinkLib(_T("GL"));
project.AddLinkLib(_T("GLU"));
project.AddLinkLib(_T("Xxf86vm"));
}

// enable compiler warnings (project-wide)
WarningsOn(project, Wizard.GetCompilerID());

// Debug
local target = project.GetBuildTarget(Wizard.GetDebugName());
if (!IsNull(target))
{
target.SetTargetType(ttConsoleOnly); // ttConsoleOnly: console for debugging
target.SetOutputFilename(Wizard.GetDebugOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable generation of debugging symbols for target
DebugSymbolsOn(target, Wizard.GetCompilerID());
}

// Release
target = project.GetBuildTarget(Wizard.GetReleaseName());
if (!IsNull(target))
{
target.SetTargetType(ttExecutable); // ttExecutable: no console
target.SetOutputFilename(Wizard.GetReleaseOutputDir() + Wizard.GetProjectName() + DOT_EXT_EXECUTABLE);
target.SetWorkingDir(GlutPath + _T("/bin"));
// enable optimizations for target
OptimizationsOn(target, Wizard.GetCompilerID());
}

return true;
}

</source>

'''This line "project.AddLinkLib(_T("Glut32"));" should now say "project.AddLinkLib(_T("freeglut"));"'''

Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

Now.. one more file to edit and your done..

go to this folder by back tracking a little bit : C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\templates

in there you will find glut.cbp

This is the file that is for your project to work off of. You need to edit this too. Here is the code :

== glut.cbp ==

<source lang=xml>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="4" />
<Project>
<Option title="glut" />
<Option pch_mode="0" />
<Option compiler="gcc" />
<Build>
<Target title="default">
<Option output="glut.exe" />
<Option type="0" />
<Option compiler="gcc" />
<Option includeInTargetAll="1" />
</Target>
</Build>
<Compiler>
<Add directory="$(#glut.include)" />
</Compiler>
<Linker>
<Add library="freeglut" />
<Add library="glu32" />
<Add library="opengl32" />
<Add library="winmm" />
<Add library="gdi32" />
<Add library="user32" />
<Add library="kernel32" />
<Add directory="$(#glut.lib)" />
</Linker>
<Unit filename="main.cpp">
<Option compilerVar="CPP" />
<Option target="default" />
</Unit>
</Project>
</CodeBlocks_project_file>

</source>

'''See this line "<Add library="Glut32" />" should now say "<Add library="freeglut" />"'''

Because of windows Protections, it will force you to save it somewhere else. Just save it to your desktop and then MOVE the file into the same folder as the old one and overwrite. It will ask for permission, click continue. ( or yes on some machines ).

So save those files and run codeblocks. Choose Glut. And where it asks where Glut is, point to : C:\Program Files (x86)\CodeBlocks\MinGW. It will find the glut.h file you need. It will ask you what compiler, I use GNU GCC Compiler. ( The name MinGW is not in the list for some reason. )
So yea.. run the demo right out of the original CodeBlocks code and you will see some red spinning objects. :)

[[File:Freeglut_2.jpg]]

[[User:JackDawson|JackDawson]] 14:09, 8 July 2011 (CEST)