Shaders are built-in instead of being loaded from external files. (27a6f8af) · Commits · Elphel / kicad-source-mirror

common/CMakeLists.txt

+15 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,20 @@ include_directories(
		)

		if(KICAD_GAL)
		# Generate files containing shader programs
		add_custom_command (
		OUTPUT gal/opengl/shader_src.h
		DEPENDS gal/opengl/make_shader_src_h.sh
		WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/common/gal/opengl
		COMMAND ${SHELL}
		ARGS ${PROJECT_SOURCE_DIR}/common/gal/opengl/make_shader_src_h.sh
		)

		add_custom_target (
		ShaderHeader ALL
		DEPENDS gal/opengl/shader_src.h
		)

		set(GAL_SRCS
		drawpanel_gal.cpp
		painter.cpp
		@@ -27,6 +41,7 @@ set(GAL_SRCS
		)

		add_library(gal STATIC ${GAL_SRCS})
		add_dependencies(gal ShaderHeader)

		if(WIN32)
		add_definitions(-DGLEW_STATIC)

common/drawpanel_gal.cpp

+0 −7

Original line number	Diff line number	Diff line
		@@ -27,7 +27,6 @@
		#include <wx/window.h>
		#include <wx/event.h>
		#include <wx/colour.h>
		#include <wx/stdpaths.h>
		#include <wx/filename.h>

		#include <class_drawpanel_gal.h>
		@@ -56,11 +55,6 @@ EDA_DRAW_PANEL_GAL::EDA_DRAW_PANEL_GAL( wxWindow* aParentWindow, wxWindowID aWin
		m_view = NULL;
		m_painter = NULL;

		wxStandardPaths paths;
		wxFileName executableFile( paths.GetExecutablePath() );
		m_galShaderPath = std::string( ( executableFile.GetPath() +
		wxT( "/../../common/gal/opengl" ) ).mb_str() );

		SwitchBackend( aGalType, true );
		SetBackgroundStyle( wxBG_STYLE_CUSTOM );

		@@ -170,7 +164,6 @@ void EDA_DRAW_PANEL_GAL::SwitchBackend( GalType aGalType, bool aUseShaders )
		{
		case GAL_TYPE_OPENGL:
		m_gal = new KiGfx::OPENGL_GAL( this, this, this, aUseShaders );
		static_cast<KiGfx::OPENGL_GAL*> (m_gal)->SetShaderPath( m_galShaderPath );
		break;

		case GAL_TYPE_CAIRO:

common/gal/opengl/make_shader_src_h.sh

0 → 100755

+39 −0

Original line number	Diff line number	Diff line
		#!/bin/bash

		# Make a header file containing GLSL source code
		echo "Generating headers containing GLSL source code.."

		# Source files to be included
		SHADER_SRC=( "shader.vert" "shader.frag" )
		# Number of shaders
		SHADERS_NUMBER=${#SHADER_SRC[@]}
		OUTPUT="shader_src.h"

		# Prepare GLSL source to be included in C array
		function processSrc {
		# 1st part: remove /* */ comments
		# 2nd part: remove // comments
		# 3rd part: remove blank lines (or containing only whitespaces)
		# 4th & 5th part: wrap every line in quotation marks
		sed '/\/\/,/\\//d; s/[ \t]\/\/.$//; /^[ \t]$/d; s/^[ \t]/"/; s/[ \t]*$/\\n"/' $1 >> $OUTPUT
		echo "," >> $OUTPUT
		}

		# Header
		echo "#ifndef SHADER_SRC_H
		#define SHADER_SRC_H

		const unsigned int shaders_number = $SHADERS_NUMBER;
		const char *shaders_src[] = {" > $OUTPUT

		# Main contents
		for filename in "${SHADER_SRC[@]}"
		do
		processSrc $filename
		done

		# Footer
		echo "};
		#endif /* SHADER_SRC_H */" >> $OUTPUT

		echo "Done."

common/gal/opengl/opengl_gal.cpp

+2 −3

Original line number	Diff line number	Diff line
		@@ -74,7 +74,6 @@ OPENGL_GAL::OPENGL_GAL( wxWindow* aParent, wxEvtHandler* aMouseListener,
		isUseShader = isUseShaders;
		isShaderInitialized = false;
		isGrouping = false;
		shaderPath = "../../common/gal/opengl";
		wxSize parentSize = aParent->GetSize();

		isVboInitialized = false;
		@@ -359,12 +358,12 @@ void OPENGL_GAL::BeginDrawing()
		// Compile the shaders
		if( !isShaderInitialized && isUseShader )
		{
		if( !shader.AddSource( shaderPath + std::string( "/shader.vert" ), SHADER_TYPE_VERTEX ) )
		if( !shader.LoadBuiltinShader( 0, SHADER_TYPE_VERTEX ) )
		{
		wxLogFatalError( wxT( "Cannot compile vertex shader!" ) );
		}

		if( !shader.AddSource( shaderPath + std::string( "/shader.frag" ), SHADER_TYPE_FRAGMENT ) )
		if( !shader.LoadBuiltinShader( 1, SHADER_TYPE_FRAGMENT ) )
		{
		wxLogFatalError( wxT( "Cannot compile fragment shader!" ) );
		}

common/gal/opengl/shader.cpp

+91 −74

Original line number	Diff line number	Diff line
		@@ -32,14 +32,15 @@
		#include <wx/log.h>

		#include <gal/opengl/shader.h>
		#include "shader_src.h"

		using namespace KiGfx;

		SHADER::SHADER() :
		isProgramCreated( false ),
		isShaderLinked( false ),
		maximumVertices( 4 ),
		active( false ),
		maximumVertices( 4 ),
		geomInputType( GL_LINES ),
		geomOutputType( GL_LINES )
		{
		@@ -62,7 +63,84 @@ SHADER::~SHADER()
		}


		void SHADER::ProgramInfo( GLuint aProgram )
		bool SHADER::LoadBuiltinShader( unsigned int aShaderNumber, ShaderType aShaderType )
		{
		if( aShaderNumber >= shaders_number )
		return false;

		return addSource( std::string( shaders_src[aShaderNumber] ), aShaderType );
		}


		bool SHADER::LoadShaderFromFile( const std::string& aShaderSourceName, ShaderType aShaderType )
		{
		// Load shader sources
		const std::string shaderSource = readSource( aShaderSourceName );

		return addSource( shaderSource, aShaderType );
		}


		void SHADER::ConfigureGeometryShader( GLuint maxVertices, GLuint geometryInputType,
		GLuint geometryOutputType )
		{
		maximumVertices = maxVertices;
		geomInputType = geometryInputType;
		geomOutputType = geometryOutputType;
		}


		bool SHADER::Link()
		{
		// Shader linking
		glLinkProgram( programNumber );
		programInfo( programNumber );

		// Check the Link state
		glGetObjectParameterivARB( programNumber, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &isShaderLinked );

		#ifdef __WXDEBUG__
		if( !isShaderLinked )
		{
		int maxLength;
		glGetProgramiv( programNumber, GL_INFO_LOG_LENGTH, &maxLength );
		maxLength = maxLength + 1;
		char *linkInfoLog = new char[maxLength];
		glGetProgramInfoLog( programNumber, maxLength, &maxLength, linkInfoLog );
		std::cerr << "Shader linking error:" << std::endl;
		std::cerr << linkInfoLog;
		delete[] linkInfoLog;
		}
		#endif /* __WXDEBUG__ */

		return isShaderLinked;
		}


		void SHADER::AddParameter( const std::string& aParameterName )
		{
		GLint location = glGetUniformLocation( programNumber, aParameterName.c_str() );

		if( location != -1 )
		{
		parameterLocation.push_back( location );
		}
		}


		void SHADER::SetParameter( int parameterNumber, float value )
		{
		glUniform1f( parameterLocation[parameterNumber], value );
		}


		int SHADER::GetAttribute( std::string aAttributeName ) const
		{
		return glGetAttribLocation( programNumber, aAttributeName.c_str() );
		}


		void SHADER::programInfo( GLuint aProgram )
		{
		GLint glInfoLogLength = 0;
		GLint writtenChars = 0;
		@@ -83,7 +161,7 @@ void SHADER::ProgramInfo( GLuint aProgram )
		}


		void SHADER::ShaderInfo( GLuint aShader )
		void SHADER::shaderInfo( GLuint aShader )
		{
		GLint glInfoLogLength = 0;
		GLint writtenChars = 0;
		@@ -104,7 +182,7 @@ void SHADER::ShaderInfo( GLuint aShader )
		}


		std::string SHADER::ReadSource( std::string aShaderSourceName )
		std::string SHADER::readSource( std::string aShaderSourceName )
		{
		// Open the shader source for reading
		std::ifstream inputFile( aShaderSourceName.c_str(), std::ifstream::in );
		@@ -130,7 +208,7 @@ std::string SHADER::ReadSource( std::string aShaderSourceName )
		}


		bool SHADER::AddSource( const std::string& aShaderSourceName, ShaderType aShaderType )
		bool SHADER::addSource( const std::string& aShaderSource, ShaderType aShaderType )
		{
		if( isShaderLinked )
		{
		@@ -144,24 +222,21 @@ bool SHADER::AddSource( const std::string& aShaderSourceName, ShaderType aShader
		isProgramCreated = true;
		}

		// Load shader sources
		std::string shaderSource = ReadSource( aShaderSourceName );

		// Create a shader
		GLuint shaderNumber = glCreateShader( aShaderType );
		shaderNumbers.push_back( shaderNumber );

		// Get the program info
		ProgramInfo( programNumber );
		programInfo( programNumber );

		// Copy to char array
		char* source = new char[shaderSource.size() + 1];
		strcpy( source, shaderSource.c_str() );
		char* source = new char[aShaderSource.size() + 1];
		strcpy( source, aShaderSource.c_str() );
		const char source_ = (const char) ( &source );

		// Attach the source
		glShaderSource( shaderNumber, 1, source_, NULL );
		ProgramInfo( programNumber );
		programInfo( programNumber );

		// Compile and attach shader to the program
		glCompileShader( shaderNumber );
		@@ -171,13 +246,13 @@ bool SHADER::AddSource( const std::string& aShaderSourceName, ShaderType aShader
		{
		wxLogError( wxT( "Shader compilation error" ) );

		ShaderInfo( shaderNumber );
		shaderInfo( shaderNumber );

		return false;
		}

		glAttachShader( programNumber, shaderNumber );
		ProgramInfo( programNumber );
		programInfo( programNumber );

		// Special handling for the geometry shader
		if( aShaderType == SHADER_TYPE_GEOMETRY )
		@@ -193,61 +268,3 @@ bool SHADER::AddSource( const std::string& aShaderSourceName, ShaderType aShader
		return true;
		}


		void SHADER::ConfigureGeometryShader( GLuint maxVertices, GLuint geometryInputType,
		GLuint geometryOutputType )
		{
		maximumVertices = maxVertices;
		geomInputType = geometryInputType;
		geomOutputType = geometryOutputType;
		}


		bool SHADER::Link()
		{
		// Shader linking
		glLinkProgram( programNumber );
		ProgramInfo( programNumber );

		// Check the Link state
		glGetObjectParameterivARB( programNumber, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &isShaderLinked );

		#ifdef __WXDEBUG__
		if( !isShaderLinked )
		{
		int maxLength;
		glGetProgramiv( programNumber, GL_INFO_LOG_LENGTH, &maxLength );
		maxLength = maxLength + 1;
		char *linkInfoLog = new char[maxLength];
		glGetProgramInfoLog( programNumber, maxLength, &maxLength, linkInfoLog );
		std::cerr << "Shader linking error:" << std::endl;
		std::cerr << linkInfoLog;
		delete[] linkInfoLog;
		}
		#endif /* __WXDEBUG__ */

		return isShaderLinked;
		}


		void SHADER::AddParameter( const std::string& aParameterName )
		{
		GLint location = glGetUniformLocation( programNumber, aParameterName.c_str() );

		if( location != -1 )
		{
		parameterLocation.push_back( location );
		}
		}


		void SHADER::SetParameter( int parameterNumber, float value )
		{
		glUniform1f( parameterLocation[parameterNumber], value );
		}


		int SHADER::GetAttribute( std::string aAttributeName ) const
		{
		return glGetAttribLocation( programNumber, aAttributeName.c_str() );
		}

Admin message