AnimSprite::AnimSprite(const char* a_cpTexture, GLFWwindow* window)
{
	GameWindow = window;
	m_dElapsedTime = 0;
	
	m_v3Position = Vector3(g_gl_width/2, g_gl_height/2, 0);

	LoadVertShader("./resources/VertexShader.glsl");
	LoadFragShader("./resources/FragmentShader.glsl");
	LinkShaders();
	GLint uvAttrib = glGetAttribLocation(m_ShaderProgram, "texcoord");
	glEnableVertexAttribArray(uvAttrib);
	matrix_location = glGetUniformLocation(m_ShaderProgram, "matrix");

	LoadSlices(a_cpTexture);
	LoadAnimations(m_atlas.sAnimations.c_str());
	LoadTexture(m_atlas.sSheet.c_str());

	m_dFrameDuration = (1.0/5.0);
	m_sCurrentAnimation = "move N";
	m_sCurrentSlice = "move N 0";
	iCurrentFrame = 0;
	iLoopMarker = 0;
	currentCycle = LOOP;
	m_texSize = m_atlas.v2Size;

	SetSlice();
	UVSetup();

}
GameEntity::GameEntity( const char* a_pSpriteSheet, GLFWwindow * window)
{
	GameWindow = window;
	elapsedTime = 0;
	LoadVertShader("./Resources/LoadVertexShader.glsl");
	LoadFragShader("./Resources/LoadFragmentShader.glsl");
	LinkShaders();
	GLint uvAttrib = glGetAttribLocation(m_ShaderProgram,"texcoord");
	glEnableVertexAttribArray(uvAttrib);
	matrix_location = glGetUniformLocation (m_ShaderProgram, "matrix");
	LoadSprites(a_pSpriteSheet);
	LoadAnimations(atlas.sAnimations.c_str());
	LoadTexture(atlas.sSheet.c_str());


	m_dFrames = (1.0/15.0);
	currentAnimation = "Idle";
	currentSprite = "Idle_01";
	currentFrame = 0;
	currentPlayType = SINGLE;
	m_uvScale.m_fX = atlas.v2Size.m_fY;
	m_uvScale.m_fY	= atlas.v2Size.m_fX;
	SetSprite();
	SetUVData();
	iFacing = "Right"; //flag for facing


}
Sprite::Sprite(const char* a_pTexture, int a_iWidth, int a_iHeight, Vector4 a_v4Color, GLFWwindow* window) {

	//load in the shaders using the new functions in quad
	GameWindow = window;

	LoadVertShader("../resources/VertexShader.glsl");
	LoadFragShader("../resources/FragmentShader.glsl");
	LinkShaders();

	GLuint uvAttrib = glGetAttribLocation(m_ShaderProgram, "texcoord");
	glEnableVertexAttribArray(uvAttrib);
	matrix_location = glGetUniformLocation(m_ShaderProgram, "matrix");
	LoadTexture(a_pTexture);

	m_v4SpriteColor = a_v4Color;

	m_aoVerts[0].Color = m_v4SpriteColor;
	m_aoVerts[1].Color = m_v4SpriteColor;
	m_aoVerts[2].Color = m_v4SpriteColor;
	m_aoVerts[3].Color = m_v4SpriteColor;

	m_v2Scale = Vector2::Vector2(a_iWidth, a_iHeight);

	m_v3Position = Vector3::Vector3(g_gl_width / 2, g_gl_height / 2, 0.0f);
}
Beispiel #4
0
uint GLShader::SetupShader(
	const char*							VertexShader,
	const char*							GeometryShader,
	const char*							FragmentShader)
{
	String ShaderPath =  FindShaderPath(FragmentShader);

	uint VertShaderID=0, GeomShaderID=0, FragShaderID=0, ID=0;

	if(VertexShader) {
		String VertShaderPath = ShaderPath + String(VertexShader) + ".vert";
		VertShaderID = LoadShader(GL_VERTEX_SHADER, VertShaderPath.Val());
	}

	if(GeometryShader) {
		String GeomShaderPath = ShaderPath + String(GeometryShader) + ".geom";
		GeomShaderID = LoadShader(GL_GEOMETRY_SHADER, GeomShaderPath.Val());
	}

	if(FragmentShader) {
		String FragShaderPath = ShaderPath + String(FragmentShader) + ".frag";
		FragShaderID = LoadShader(GL_FRAGMENT_SHADER, FragShaderPath.Val());
	}

	ProgramID[NrShaders++] = ID = LinkShaders(VertShaderID, GeomShaderID, FragShaderID);

	return ID;
}
Beispiel #5
0
static void
Init(void)
{
   static const char *fragShaderText =
      "void main() {\n"
      "   gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n"
      "}\n";
   static const char *vertShaderText =
      "void main() {\n"
      "   gl_Position = gl_Vertex;\n"
      "}\n";

   if (!ShadersSupported())
      exit(1);

   fragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);

   vertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);

   program = LinkShaders(vertShader, fragShader);

   glUseProgram(program);

   assert(glGetError() == 0);

   glClearColor(0.3f, 0.3f, 0.3f, 1.0f);

   printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));

   assert(glIsProgram(program));
   assert(glIsShader(fragShader));
   assert(glIsShader(vertShader));

   glColor3f(1, 0, 0);
}
Beispiel #6
0
static void
Init(void)
{
   if (!ShadersSupported())
      exit(1);

   vertShader = CompileShaderText(GL_VERTEX_SHADER, VertShaderText);
   fragShader = CompileShaderText(GL_FRAGMENT_SHADER, FragShaderText);
   program = LinkShaders(vertShader, fragShader);

   glUseProgram(program);

   SetUniformValues(program, Uniforms);
   PrintUniforms(Uniforms);

   assert(glGetError() == 0);

   glClearColor(0.4f, 0.4f, 0.8f, 0.0f);

   printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));

   assert(glIsProgram(program));
   assert(glIsShader(fragShader));
   assert(glIsShader(vertShader));

   glColor3f(1, 0, 0);
}
Beispiel #7
0
void Graphics::LoadShaders()
{
  mVertexShader = glCreateShader(GL_VERTEX_SHADER);
  mFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  mBasicProgram = glCreateProgram();

  //TODO: add delete commands in case these fail

  if( !CompileShader("vertexshader.vert", GL_VERTEX_SHADER, mVertexShader, mBasicProgram) )
    return; //crash inc

  if( !CompileShader("fragmentshader.frag", GL_FRAGMENT_SHADER, mFragmentShader, mBasicProgram) )
    return; //crash inc

  if( !LinkShaders( mBasicProgram ) )
    return; //crash inc



  //mFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  
  //const char* `VertexShader = CompileShader("vertexshader.vert", mVertexShader);
  //const char* FragmentShader = CompileShader("fragmentshader.frag", mFragmentShader);
  
}
GLuint LoadShaderProgram(const char *pszFilename, std::string &infoLog)
{
    infoLog.clear();

    GLuint program = 0;
    std::string buffer;

    // Read the text file containing the GLSL shader program.
    // This file contains 1 vertex shader and 1 fragment shader.
    ReadTextFile(pszFilename, buffer);

    // Compile and link the vertex and fragment shaders.
    if (buffer.length() > 0)
    {
        const GLchar *pSource = 0;
        GLint length = 0;
        GLuint vertShader = 0;
        GLuint fragShader = 0;

        std::string::size_type vertOffset = buffer.find("[vert]");
        std::string::size_type fragOffset = buffer.find("[frag]");

        try
        {
            // Get the vertex shader source and compile it.
            // The source is between the [vert] and [frag] tags.
            if (vertOffset != std::string::npos)
            {
                vertOffset += 6;        // skip over the [vert] tag
                pSource = reinterpret_cast<const GLchar *>(&buffer[vertOffset]);
                length = static_cast<GLint>(fragOffset - vertOffset);
                vertShader = CompileShader(GL_VERTEX_SHADER, pSource, length);
            }

            // Get the fragment shader source and compile it.
            // The source is between the [frag] tag and the end of the file.
            if (fragOffset != std::string::npos)
            {
                fragOffset += 6;        // skip over the [frag] tag
                pSource = reinterpret_cast<const GLchar *>(&buffer[fragOffset]);
                length = static_cast<GLint>(buffer.length() - fragOffset - 1);
                fragShader = CompileShader(GL_FRAGMENT_SHADER, pSource, length);
            }

            // Now link the vertex and fragment shaders into a shader program.
            program = LinkShaders(vertShader, fragShader);
        }
        catch (const std::string &errors)
        {
            infoLog = errors;
        }
    }

    return program;
}
Beispiel #9
0
	void ShaderProgram::Init( StrongHandle<VertexShader> a_vp, StrongHandle<FragShader> a_fp )
	{
		ASSERT( a_vp != nullptr );
		ASSERT( a_fp != nullptr );
		
		m_vp = a_vp;
		m_fp = a_fp;
		
		LinkShaders();
		
		ShaderManager::Ref().RegisterShaderProgram(this, a_vp->GetFileName().c_str(), a_fp->GetFileName().c_str() );
	}
Beispiel #10
0
static void
Init(void)
{
   /* Fragment shader: modulate raster color by texture, discard fragments
    * with alpha < 1.0
    */
   static const char *fragShaderText =
      "uniform sampler2D tex2d; \n"
      "void main() {\n"
      "   vec4 c = texture2D(tex2d, gl_TexCoord[0].xy); \n"
      "   if (c.w < 1.0) \n"
      "      discard; \n"
      "   gl_FragColor = c * gl_Color; \n"
      "}\n";
   /* Vertex shader: compute new vertex position based on incoming vertex pos,
    * texcoords and special scale factor.
    */
   static const char *vertShaderText =
      "uniform vec2 scale; \n"
      "void main() {\n"
      "   vec4 p = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
      "   gl_Position.xy = p.xy + gl_MultiTexCoord0.xy * scale * p.w; \n"
      "   gl_Position.zw = p.zw; \n"
      "   gl_TexCoord[0] = gl_MultiTexCoord0; \n"
      "   gl_FrontColor = gl_Color; \n"
      "}\n";

   if (!ShadersSupported())
      exit(1);

   VertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
   FragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
   Program = LinkShaders(VertShader, FragShader);

   glUseProgram(Program);

   uScale = glGetUniformLocation(Program, "scale");
   uTex = glGetUniformLocation(Program, "tex2d");
   if (uTex != -1) {
      glUniform1i(uTex, 0);  /* tex unit 0 */
   }

   glUseProgram(0);

   glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_NORMALIZE);
   glEnable(GL_LIGHT0);

   MakeBitmapTextures();
}
Beispiel #11
0
	void ShaderProgram::Init( const char * a_filename_vp, const char* a_filename_fp )
	{
		ASSERT( a_filename_vp );
		ASSERT( a_filename_fp );
		
		m_vp = new VertexShader();
		m_vp->Init(a_filename_vp);
		m_fp = new FragShader();
		m_fp->Init(a_filename_fp);
		
		LinkShaders();
		
		ShaderManager::Ref().RegisterShaderProgram(this, a_filename_vp, a_filename_fp );
	}
Beispiel #12
0
//Create a vertex and fragment shader  
void Shader::CreateShader(char *vertexPath, char *fragmentPath)
{
	//Create a handle for the program
	m_ProgramHandle = glCreateProgram();

	//Add vertex shader to the program
	AddShader(vertexPath, VERTEX_SHADER);

	//Add fragment shader to the program
	AddShader(fragmentPath, FRAGMENT_SHADER);

	//Link the shaders in the program and check for errors
	LinkShaders();
}
bool CGLComputeTechnique::Load(const CResourceObject& resource_obj)
{
	Renderer::ShaderType t = resource_obj.m_ShaderType;

	CGLSLCompiler compiler;
	StGLSLCompilerOptions option;
	option.m_InputFile = resource_obj.m_Path;
	compiler.Initialize(option);

	m_Shaders[0] = compiler.Process();

	LinkShaders(&m_Shaders[0], m_Shaders.size());

	return true;
}
void FSlateOpenGLElementProgram::CreateProgram( const FSlateOpenGLVS& VertexShader, const FSlateOpenGLPS& PixelShader )
{
	// Link the vertex and pixel shader for this program
	LinkShaders( VertexShader, PixelShader );

	// Set up uniform parameters
	ViewProjectionMatrixParam = glGetUniformLocation( ProgramID, "ViewProjectionMatrix" );
	VertexShaderParam = glGetUniformLocation( ProgramID, "VertexShaderParams" );
	TextureParam = glGetUniformLocation( ProgramID, "ElementTexture" );
	EffectsDisabledParam = glGetUniformLocation( ProgramID, "EffectsDisabled" );
	IgnoreTextureAlphaParam = glGetUniformLocation( ProgramID, "IgnoreTextureAlpha" );
	ShaderTypeParam = glGetUniformLocation( ProgramID, "ShaderType" );
	MarginUVsParam = glGetUniformLocation( ProgramID, "MarginUVs" );

	CHECK_GL_ERRORS;
}
Beispiel #15
0
static void
Init(void)
{
   static const char *fragShaderText =
      "uniform ivec2 WinSize; \n"
      "void main() {\n"
      "   vec2 d = dFdy(gl_TexCoord[0].xy) * vec2(WinSize); \n"
      "   gl_FragColor =  vec4(d.x, d.y, 0.0, 1.0);\n"
      "  // gl_FragColor = gl_TexCoord[0];\n"
      "}\n";
   static const char *vertShaderText =
      "void main() {\n"
      "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
      "   gl_TexCoord[0] = gl_MultiTexCoord0;\n"
      "}\n";

   if (!ShadersSupported())
      exit(1);

   vertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
   fragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
   program = LinkShaders(vertShader, fragShader);

   glUseProgram(program);
   WinSizeUniform = glGetUniformLocation(program, "WinSize");

   /*assert(glGetError() == 0);*/

   glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
   glEnable(GL_DEPTH_TEST);

   MakeSphere();
   MakeRect();

   CurList = SphereList;

   printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));

   assert(glIsProgram(program));
   assert(glIsShader(fragShader));
   assert(glIsShader(vertShader));

   glColor3f(1, 0, 0);
}
bool CGLRenderTechnique::Load( const CResourceObject& resource_obj )
{
	Renderer::ShaderType t = resource_obj.m_ShaderType;

	CGLSLCompiler compiler;
	StGLSLCompilerOptions option;
	option.m_InputFile = resource_obj.m_Path;
	compiler.Initialize(option);

	m_Shaders[t] = compiler.Process();

	// PixelShader will be loaded at the last one, so perform linking step here 
	if(t == Renderer::SHA_PIXEL_SHADER)
	{
		return LinkShaders(&m_Shaders[0], m_Shaders.size());
	}

	return true;
}
Beispiel #17
0
// --------------------------------------------------------------------------------------------------------------------
GLuint CreateProgram(const std::string& _vsFilename, const std::string& _psFilename, const std::string& _shaderPrefix)
{
    GLuint vs = CompileShaderFromFile(GL_VERTEX_SHADER, _vsFilename, _shaderPrefix),
           fs = CompileShaderFromFile(GL_FRAGMENT_SHADER, _psFilename, _shaderPrefix);

    // If any are 0, dump out early.
    if ((vs * fs) == 0) {
        return 0;
    }

    GLuint retProgram = LinkShaders(vs, fs);

    // Flag these now, they're either attached (linked in) and will be cleaned up with the link, or the
    // link failed and we're about to lose track of them anyways.
    glDeleteShader(fs);
    glDeleteShader(vs);

    return retProgram;
}
AnimatedSprite::AnimatedSprite(const char* a_pSpriteSheet, GLFWwindow * window) {
	GameWindow = window;
	m_dElapsedTime = 0;
	LoadVertShader("../resources/VertexShader.glsl");
	LoadFragShader("../resources/FragShader.glsl");
	LinkShaders();

	GLint uvAttrib = glGetAttribLocation(m_ShaderProgram, "texcoord");
	glEnableVertexAttribArray(uvAttrib);
	matrix_location = glGetUniformLocation(m_ShaderProgram, "matrix");
	LoadSprites(a_pSpriteSheet);
	LoadAnimations(atlas.sAnimations.c_str());

	m_dFrames = (1.0 / 15.0);
	sCurrentAnimation = "";
	sCurrentSprite ="idle 0";
	CurrentPlayType = SINGLE;
	m_uvScale.m_fX = atlas.v2Size.m_fY;
	m_uvScale.m_fY = atlas.v2Size.m_fX;
	SetSprite();
	SetUVData();
}
Sprite::Sprite() {
	srand(time(NULL));
	LoadVertShader("../resources/VertexShader.glsl");
	LoadFragShader("../resources/FragmentShader.glsl");
	LinkShaders();

	m_v4SpriteColor = Vector4::Vector4(1.0f, 1.0f, 1.0f, 1.0f);

	m_aoVerts[0].Color = m_v4SpriteColor;
	m_aoVerts[1].Color = m_v4SpriteColor;
	m_aoVerts[2].Color = m_v4SpriteColor;
	m_aoVerts[3].Color = m_v4SpriteColor;

	m_aoVerts[0].UV = Vector2::Vector2(1.0f, 0.0f);
	m_aoVerts[1].UV = Vector2::Vector2(0.0f, 1.0f);
	m_aoVerts[2].UV = Vector2::Vector2(1.0f, 0.0f);
	m_aoVerts[3].UV = Vector2::Vector2(1.0f, 1.0f);

	m_v2Scale = Vector2::Vector2(1.0f, 1.0f);

	m_v3Position = Vector3::Vector3(g_gl_width / 2, g_gl_height / 2, 0.0f);
}
AnimatedSprite::AnimatedSprite( const char* a_pSpriteSheet, GLFWwindow * window)
{
	//Make GameWindow equal window
	GameWindow = window;
	//Make elapsedTime equal 0
	elapsedTime = 0;
	//Load the Shaders
	LoadVertShader("resources/VertexShader.glsl");
	LoadFragShader("resources/FragmentShader.glsl");
	//Link the Shaders
	LinkShaders();
	//Make a GLint and equal it to glGetAttribLocation
	GLint uvAttrib = glGetAttribLocation(m_ShaderProgram,"texcoord");
	//Call glEnableVertexAttribArray with the required data
	glEnableVertexAttribArray(uvAttrib);
	//Make matrix_location equal to glGetUniformLocation
	matrix_location = glGetUniformLocation (m_ShaderProgram, "matrix");
	
	//Load the Sprites,Animations, and Texture
	LoadSprites(a_pSpriteSheet);
	//
	LoadTexture(atlas.sSheet.c_str());
	//Make m_dFrames equal to 1 divided by 2
	m_dFrames = (1.0/2.0);
	//Make currentAnimation equal nothing
	currentAnimation = "";
	//Make the currentSprite equal idle
	//currentSprite = "idle";
	//Make the currentFrame equal 0
	currentFrame = 0;
	//Make uvScale equale the atlas size
	m_uvScale.m_fX = atlas.v2Size.m_fY;
	m_uvScale.m_fY	= atlas.v2Size.m_fX;
	//Call SetSprite
	SetSprite();
	//call SetUVData
	SetUVData();
}
Beispiel #21
0
static void
Init(void)
{
   if (!ShadersSupported())
      exit(1);

   vertShader = CompileShaderFile(GL_VERTEX_SHADER, VertProgFile);
   fragShader = CompileShaderFile(GL_FRAGMENT_SHADER, FragProgFile);
   program = LinkShaders(vertShader, fragShader);

   glUseProgram(program);

   SetUniformValues(program, Uniforms);
   PrintUniforms(Uniforms);

   assert(glGetError() == 0);

   glClearColor(0.4f, 0.4f, 0.8f, 0.0f);

   glEnable(GL_DEPTH_TEST);

   glColor3f(1, 0, 0);
}
Beispiel #22
0
Sprite::Sprite( const char* a_pTexture, int a_iWidth, int a_iHeight, Vector4 a_v4Color , GLFWwindow * window)
{

	GameWindow = window;
	//Default Shaders for Default constructor

/*	const char * VertexShader =	// Vertex Shaders deal with objects in 3D space
		"#version 330\n"
		"in vec3 position;"
		"in vec4 color;"
		"in vec2 texcoord;"
		"out vec2 UV;"
		"out vec4 vColor;"
		"uniform mat4 matrix;" // our matrix
		"void main() {"
		"	UV = texcoord;"
		"	gl_Position = matrix * vec4 (position, 1.0);"
		"	vColor = color;"
		"}";

	const char * FragmentShader =	// Fragment Shaders dela with pixel data
		"#version 330\n"
		"in vec4 vColor;"
		"in vec2 UV;"
		"out vec4 outColour;"
		"uniform sampler2D diffuseTexture;"
		"void main () {"
		"	outColour =  texture2D(diffuseTexture, UV) * vColor;"
		"}";
	// Compile Vertex Shader
	m_VertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(m_VertexShader, 1, &VertexShader, NULL);
	glCompileShader(m_VertexShader);
	printShaderInfoLog(m_VertexShader);

	// Compile Fragment Shader
	m_FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(m_FragmentShader, 1, &FragmentShader, NULL);
	glCompileShader(m_FragmentShader);
	printShaderInfoLog(m_FragmentShader);
*/
	LoadVertShader("../resources/exampleVert.glsl");
	LoadFragShader("../resources/exampleFrag.glsl");
	LinkShaders();

	// Link Shaders into Shader Program
	m_ShaderProgram = glCreateProgram();

	glAttachShader(m_ShaderProgram, m_FragmentShader);
	glAttachShader(m_ShaderProgram, m_VertexShader);

	glLinkProgram(m_ShaderProgram);
	printProgramInfoLog(m_ShaderProgram);
	glUseProgram(m_ShaderProgram);

	m_v4SpriteColor = a_v4Color;

	m_aoVerts[0].Pos = Vector3(	-0.5f,  0.5f,  0.0f);
	m_aoVerts[1].Pos = Vector3(	0.5f,  0.5f,  0.0f);
	m_aoVerts[2].Pos = Vector3(	-0.5f,  -0.5f,  0.0f);
	m_aoVerts[3].Pos = Vector3(	0.5f,  -0.5f,  0.0f);
	

	m_aoVerts[0].Color = m_v4SpriteColor;
	m_aoVerts[1].Color = m_v4SpriteColor;
	m_aoVerts[2].Color = m_v4SpriteColor;
	m_aoVerts[3].Color = m_v4SpriteColor;



	m_aoVerts[0].UV = Vector2(0.0f,  0.0f);
	m_aoVerts[1].UV = Vector2(0.0f,  1.0f);
	m_aoVerts[2].UV = Vector2(1.0f,  0.0f);
	m_aoVerts[3].UV = Vector2(1.0f,  1.0f);

	GLuint elements[] =
	{
		0,1,2,3
	};

	//Gen Buffers
	glGenBuffers(1,&m_VBO);
	glGenBuffers(1,&m_EBO);
	glGenVertexArrays(1, &m_VAO);

	//Bind Buffers
	glBindVertexArray(m_VAO);
	glBindBuffer(GL_ARRAY_BUFFER, m_VBO);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_EBO);

	//Put Data into buffers
	glBufferData(GL_ARRAY_BUFFER, 4* sizeof(Vertex), m_aoVerts, GL_STATIC_DRAW);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);

	//Enable some attributes
	GLint posAttrib = glGetAttribLocation(m_ShaderProgram,"position");
	glEnableVertexAttribArray(posAttrib);
	GLint colAttrib = glGetAttribLocation(m_ShaderProgram,"color");
	glEnableVertexAttribArray(colAttrib);
	GLint uvAttrib = glGetAttribLocation(m_ShaderProgram,"texcoord");
	glEnableVertexAttribArray(uvAttrib);


	glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0);
	glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(3 * sizeof(float)));
	glVertexAttribPointer(uvAttrib, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(7 * sizeof(float)));

	glBindVertexArray(0);
	m_v3Position = Vector3(0,0,0);
	modelMatrix =new float[16];	
	float temp[]= 
	{
		1,0,0,0,
		0,1,0,0,
		0,0,1,0,
		0,0,0,1
	};
	memcpy(modelMatrix,temp,16*sizeof(float)); //not sure of a better way

	matrix_location = glGetUniformLocation (m_ShaderProgram, "matrix");

	m_uiTexture = 0;
	m_minUVCoords = Vector2( 0.f, 0.f );
	m_maxUVCoords = Vector2( 1.f, 1.f );
	m_uvScale = Vector2( 1.f, 1.f );
	m_uvOffset = Vector2( 0.f, 0.f );

	m_uSourceBlendMode	= GL_SRC_ALPHA;
	m_uDestinationBlendMode = GL_ONE_MINUS_SRC_ALPHA;

	glGenTextures(1, &m_uiTexture);
	glActiveTexture (GL_TEXTURE0);

	int width, height;
	unsigned char* image = SOIL_load_image(a_pTexture, &width, &height, 0, SOIL_LOAD_RGBA);
	glBindTexture( GL_TEXTURE_2D,m_uiTexture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
	SOIL_free_image_data(image);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	tex_loc = glGetUniformLocation (m_ShaderProgram, "diffuseTexture");
	glUseProgram (m_ShaderProgram);
	glUniform1i (tex_loc, 0); // use active texture 0

}
Beispiel #23
0
void UpdateOCIOGLState()
{
    // Step 0: Get the processor using any of the pipelines mentioned above.
    OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();

    OCIO::DisplayTransformRcPtr transform = OCIO::DisplayTransform::Create();
    transform->setInputColorSpaceName( g_inputColorSpace.c_str() );
    transform->setDisplay( g_display.c_str() );
    transform->setView( g_transformName.c_str() );

    // Add optional transforms to create a full-featured, "canonical" display pipeline
    // Fstop exposure control (in SCENE_LINEAR)
    {
        float gain = powf(2.0f, g_exposure_fstop);
        const float slope4f[] = { gain, gain, gain, gain };
        float m44[16];
        float offset4[4];
        OCIO::MatrixTransform::Scale(m44, offset4, slope4f);
        OCIO::MatrixTransformRcPtr mtx =  OCIO::MatrixTransform::Create();
        mtx->setValue(m44, offset4);
        transform->setLinearCC(mtx);
    }

    // Channel swizzling
    {
        float lumacoef[3];
        config->getDefaultLumaCoefs(lumacoef);
        float m44[16];
        float offset[4];
        OCIO::MatrixTransform::View(m44, offset, g_channelHot, lumacoef);
        OCIO::MatrixTransformRcPtr swizzle = OCIO::MatrixTransform::Create();
        swizzle->setValue(m44, offset);
        transform->setChannelView(swizzle);
    }

    // Post-display transform gamma
    {
        float exponent = 1.0f/std::max(1e-6f, static_cast<float>(g_display_gamma));
        const float exponent4f[] = { exponent, exponent, exponent, exponent };
        OCIO::ExponentTransformRcPtr expTransform =  OCIO::ExponentTransform::Create();
        expTransform->setValue(exponent4f);
        transform->setDisplayCC(expTransform);
    }

    OCIO::ConstProcessorRcPtr processor;
    try
    {
        processor = config->getProcessor(transform);
    }
    catch(OCIO::Exception & e)
    {
        std::cerr << e.what() << std::endl;
        return;
    }
    catch(...)
    {
        return;
    }

    // Step 1: Create a GPU Shader Description
    OCIO::GpuShaderDesc shaderDesc;
    shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_0);
    shaderDesc.setFunctionName("OCIODisplay");
    shaderDesc.setLut3DEdgeLen(LUT3D_EDGE_SIZE);

    // Step 2: Compute the 3D LUT
    std::string lut3dCacheID = processor->getGpuLut3DCacheID(shaderDesc);
    if(lut3dCacheID != g_lut3dcacheid)
    {
        //std::cerr << "Computing 3DLut " << g_lut3dcacheid << std::endl;

        g_lut3dcacheid = lut3dCacheID;
        processor->getGpuLut3D(&g_lut3d[0], shaderDesc);

        glBindTexture(GL_TEXTURE_3D, g_lut3dTexID);
        glTexSubImage3D(GL_TEXTURE_3D, 0,
                        0, 0, 0,
                        LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE,
                        GL_RGB,GL_FLOAT, &g_lut3d[0]);
    }

    // Step 3: Compute the Shader
    std::string shaderCacheID = processor->getGpuShaderTextCacheID(shaderDesc);
    if(g_program == 0 || shaderCacheID != g_shadercacheid)
    {
        //std::cerr << "Computing Shader " << g_shadercacheid << std::endl;

        g_shadercacheid = shaderCacheID;

        std::ostringstream os;
        os << processor->getGpuShaderText(shaderDesc) << "\n";
        os << g_fragShaderText;
        //std::cerr << os.str() << std::endl;

        if(g_fragShader) glDeleteShader(g_fragShader);
        g_fragShader = CompileShaderText(GL_FRAGMENT_SHADER, os.str().c_str());
        if(g_program) glDeleteProgram(g_program);
        g_program = LinkShaders(g_fragShader);
    }

    glUseProgram(g_program);
    glUniform1i(glGetUniformLocation(g_program, "tex1"), 1);
    glUniform1i(glGetUniformLocation(g_program, "tex2"), 2);
}
Beispiel #24
0
void
glmShaderMaterial(GLMmaterial *mat)
{
   static const float ambientLight[4] = { 0.1, 0.1, 0.1, 0.0 };
   static const float diffuseLight[4] = { 0.75, 0.75, 0.75, 1.0 };
   static const float specularLight[4] = { 1.0, 1.0, 1.0, 0.0 };

   if (!mat->prog) {
      /* make shader now */
      char newShader[10000];
      GLuint vs, fs;
      const char *diffuseTex = mat->texture_kd ? "true" : "false";
      const char *specularTex = mat->texture_ks ? "true" : "false";
      GLint uAmbientLight, uDiffuseLight, uSpecularLight;

      /* replace %d with 0 or 1 */
      sprintf(newShader, TexFragmentShader, diffuseTex, specularTex);
      if (0)
         printf("===== new shader =====\n%s\n============\n", newShader);

      vs = CompileShaderText(GL_VERTEX_SHADER, VertexShader);
      fs = CompileShaderText(GL_FRAGMENT_SHADER, newShader);
      mat->prog = LinkShaders(vs, fs);
      assert(mat->prog);

      glUseProgram(mat->prog);

      mat->uAmbient = glGetUniformLocation(mat->prog, "ambient");
      mat->uDiffuse = glGetUniformLocation(mat->prog, "diffuse");
      mat->uSpecular = glGetUniformLocation(mat->prog, "specular");
      mat->uShininess = glGetUniformLocation(mat->prog, "shininess");
      mat->uDiffTex = glGetUniformLocation(mat->prog, "diffTex");
      mat->uSpecTex = glGetUniformLocation(mat->prog, "specTex");

      uAmbientLight = glGetUniformLocation(mat->prog, "ambientLight");
      uDiffuseLight = glGetUniformLocation(mat->prog, "diffuseLight");
      uSpecularLight = glGetUniformLocation(mat->prog, "specularLight");

      glUniform4fv(mat->uAmbient, 1, mat->ambient);
      glUniform4fv(mat->uDiffuse, 1, mat->diffuse);
      glUniform4fv(mat->uSpecular, 1, mat->specular);
      glUniform1f(mat->uShininess, mat->shininess);
      glUniform1i(mat->uDiffTex, 0);
      glUniform1i(mat->uSpecTex, 1);

      glUniform4fv(uAmbientLight, 1, ambientLight);
      glUniform4fv(uDiffuseLight, 1, diffuseLight);
      glUniform4fv(uSpecularLight, 1, specularLight);
   }

   glActiveTexture(GL_TEXTURE1);
   if (mat->texture_ks)
      glBindTexture(GL_TEXTURE_CUBE_MAP, mat->texture_ks);
   else
      glBindTexture(GL_TEXTURE_CUBE_MAP, 0);

   glActiveTexture(GL_TEXTURE0);
   if (mat->texture_kd)
      glBindTexture(GL_TEXTURE_2D, mat->texture_kd);
   else
      glBindTexture(GL_TEXTURE_2D, 0);

   if (mat->diffuse[3] < 1.0) {
      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   }
   else {
      glDisable(GL_BLEND);
   }

   glUseProgram(mat->prog);
}
Beispiel #25
0
Sprite::Sprite( const char* a_pTexture, int a_iWidth, int a_iHeight, tbyte::Vector4 a_v4Color ,GLFWwindow * window)
{

	GameWindow = window;
	
	LoadVertShader("../resources/exampleVert.glsl");
	LoadFragShader("../resources/exampleFrag.glsl");
	LinkShaders();

	m_v4SpriteColor = a_v4Color;

	m_aoVerts[0].Pos = tbyte::Vector3(	-0.5f,  0.5f,  0.0f);
	m_aoVerts[1].Pos = tbyte::Vector3(	0.5f,  0.5f,  0.0f);
	m_aoVerts[2].Pos = tbyte::Vector3(	-0.5f,  -0.5f,  0.0f);
	m_aoVerts[3].Pos = tbyte::Vector3(	0.5f,  -0.5f,  0.0f);
	
	/*
	m_aoVerts[0].Color = tbyte::Vector4(1.0f,  0.0f,  0.0f, 1.0f);
	m_aoVerts[1].Color = tbyte::Vector4(0.0f,  1.0f,  0.0f, 1.0f);
	m_aoVerts[2].Color = tbyte::Vector4(0.0f,  0.0f,  1.0f, 1.0f);
	m_aoVerts[3].Color = tbyte::Vector4(1.0f,  1.0f,  1.0f, 1.0f);
	*/


	m_aoVerts[0].Color = m_v4SpriteColor;
	m_aoVerts[1].Color = m_v4SpriteColor;
	m_aoVerts[2].Color = m_v4SpriteColor;
	m_aoVerts[3].Color = m_v4SpriteColor;



	m_aoVerts[0].UV = tbyte::Vector2(0.0f,  0.0f);
	m_aoVerts[1].UV = tbyte::Vector2(0.0f,  1.0f);
	m_aoVerts[2].UV = tbyte::Vector2(1.0f,  0.0f);
	m_aoVerts[3].UV = tbyte::Vector2(1.0f,  1.0f);

	GLuint elements[] =
	{
		0,1,2,3
	};

	//Gen Buffers
	glGenBuffers(1,&m_VBO);
	glGenBuffers(1,&m_EBO);
	glGenVertexArrays(1, &m_VAO);

	//Bind Buffers
	glBindVertexArray(m_VAO);
	glBindBuffer(GL_ARRAY_BUFFER, m_VBO);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_EBO);

	//Put Data into buffers
	glBufferData(GL_ARRAY_BUFFER, 4* sizeof(Vertex), m_aoVerts, GL_STATIC_DRAW);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);

	//Enable some attributes
	GLint posAttrib = glGetAttribLocation(m_ShaderProgram,"position");
	glEnableVertexAttribArray(posAttrib);
	GLint colAttrib = glGetAttribLocation(m_ShaderProgram,"color");
	glEnableVertexAttribArray(colAttrib);
	GLint uvAttrib = glGetAttribLocation(m_ShaderProgram,"texcoord");
	glEnableVertexAttribArray(uvAttrib);


	glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0);
	glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(3 * sizeof(float)));
	glVertexAttribPointer(uvAttrib, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(7 * sizeof(float)));

	glBindVertexArray(0);
	m_v2Scale = tbyte::Vector2(a_iWidth,a_iHeight);
	m_v3Position = tbyte::Vector3(1024/2,768/2,0);
	
	modelMatrix = new tbyte::Matrix4();
	viewMatrix = new tbyte::Matrix4();

	*modelMatrix  = *viewMatrix = Matrix4::IdentityMatrix();
	
	ViewLookAt(tbyte::Vector4(0,0,0,0),tbyte::Vector4(0,0,.5,0),tbyte::Vector4(0,1,0,0), viewMatrix);

	modelMatrix->m_afArray[12] = m_v3Position.m_fX;
	modelMatrix->m_afArray[13] = m_v3Position.m_fY;
	modelMatrix->m_afArray[14] = m_v3Position.m_fZ;


	matrix_location = glGetUniformLocation (m_ShaderProgram, "matrix");


	m_uiTexture = 0;
	m_minUVCoords = tbyte::Vector2( 0.f, 0.f );
	m_maxUVCoords = tbyte::Vector2( 1.f, 1.f );
	m_uvScale = tbyte::Vector2( 1.f, 1.f );
	m_uvOffset = tbyte::Vector2( 0.f, 0.f );

	m_uSourceBlendMode	= GL_SRC_ALPHA;
	m_uDestinationBlendMode = GL_ONE_MINUS_SRC_ALPHA;

	glGenTextures(1, &m_uiTexture);
	glActiveTexture (GL_TEXTURE0);

	int width, height;
	unsigned char* image = SOIL_load_image(a_pTexture, &width, &height, 0, SOIL_LOAD_RGBA);
	glBindTexture( GL_TEXTURE_2D,m_uiTexture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
	SOIL_free_image_data(image);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);


	tex_location = glGetUniformLocation (m_ShaderProgram, "diffuseTexture");
	
	proj_location = glGetUniformLocation (m_ShaderProgram, "projection");
	
	view_location = glGetUniformLocation (m_ShaderProgram, "view");

}