반환타입이 다르게 가상함수 재정의할 수 있는가?

코딩중 궁금하여 Test 해본 코드이다. 순수가상함수가 있다고 할때 이를 속상받는 클래스에서 순수가상함수를 재정의할때 반환타입을 다르게 할 수 있는가라는 스스로의 질문에 대한 정리이다.

기본적으로 Base가 되는 클래스 둘이 있는데 아래와 같다.

class ReturnType {
protected:
	int x;
public:
	ReturnType(int x) {
		this->x = x;
	}

	virtual int GetValue() {
		return x;
	}
};

class Base {
public:
	virtual ReturnType* Get(int a, int b) = 0;
};

클래스 Base는 Get이라는 순수가상함수를 가지고 있고 반환값으로 ReturnType을 갖는다. 여기서 따져보고 싶은 것은 Base의 Get이라는 순수가상함수의 반환 Type을 다르게 하여 선언할 수 있냐는 것이다. 대답은 “않된다”이지만 반환 Type도 OO의 다형성을 활용해서 다르게 선언할 수 있다는 것이다. 아래를 보자.

class ReturnType2 : public ReturnType {
public:
	ReturnType2(int x) : ReturnType(x) {
	}

	virtual int GetValue() {
		return x*x;
	}
};

class Derive1 : public Base {
public:
	virtual ReturnType2* Get(int a, int b) {
		ReturnType2* pRT = new ReturnType2(a+b);
		return pRT;
	}
};

class Derive2 : public Base {
public:
	virtual ReturnType* Get(int a, int b) {
		ReturnType* pRT = new ReturnType(a*2+b*2);
		return pRT;
	}
};

ReturnType으로부터 상속받은 ReturnType2 클래스가 있으며 Base로부터 상속받은 Derive1과 Derive2가 있다. 분명한것은 GetValue라는 순수가상함수의 반환타입이 상속받은 Base와 다르다는 점이다. 하지만 완전이 다른것은 아니고 반환타입이 상속관계를 갖는다. 이런 상속관계가 반환타입을 다르게 할 수 있는 이유가 되는 것이다.

C++에서 기본클래스의 생성자에서는 순수가상함수를 호출할 수 없다!?

다소 황당하기도 하고, 언젠가 책에서 본것같기도 한 내용입니다. 하지만 저는 당연이 되리라 생각했던지라… 왜 않되냐며 약간 열 받기도 하였습니다. 어떤 내용인냐면…

먼저 Base라는 클래스가 있고, 이 클래스는 A라는 순수 가상 함수가 있습니다.

class Base {
public:
	Base() { };

	void TTT() {
		A();
	}

public:
	virtual void A() = 0;
};

보시면 TTT라는 함수에서 A 함수를 호출하고 있구요. 이제 Base를 상속받는 Derv라는 함수를 정의해 봅니다.

class Derv : public Base {
public:
	virtual void A() {
		printf("impl");
	}
};

상속받는 클래스는 기본 클래스의 순수 가상 함수를 구현해야할 책임이 있으므로 A 함수를 구현합니다. 이제 Base 함수를 사용해 보면…

int _tmain(int argc, _TCHAR* argv[])
{
	Base *p = new Derv();

	p->TTT();

	delete p;

	return 0;
}

화면상에 “impl”이라는 문자가 찍힙니다. 잘됩니다. 그렇다면 Base 클래스를 아래처럼 수정합니다.

class Base {
public:
	Base() { A(); };

	void TTT() {
		A();
	}

public:
	virtual void A() = 0;
};

변경된 부분은 Base의 생성자에서 순사 가상 함수를 호출하고 있습니다. 실행해보면… 않됩니다. Base::A(void) 외부 기호를 확인할 수 없다는 경고입니다. 원래 C++ 표준도 않되는 것인지.. 아니면 MS의 C++ 만 않되는 것인지는 모르겠지만, 당연히 될줄알고 사용했던지라 매우 난감했습니다. 아무튼 않되는 것을 알았으니 돌아가야겠습니다.

STL map의 비교함수자 제공하는 코드

필요할때마다 잊는지라, 이곳에 메모해 봅니다.. ^^

#include 


using namespace std;

class Standard {
private:
	int a;
public:
	Standard(int a) {
		this->a = a;
	}

	int Get() {
		return a;
	}
};

class Value {
public:
	Standard *pStandard;
	Value(Standard *pStandard) {
		this->pStandard = pStandard;
	}
};

class CustomCompare {
public:
	bool operator()(Standard* s1, Standard* s2) const {
		return s1->Get() == s2->Get();
	}
};

int main(int argc, _TCHAR* argv[])
{
	map container;

	Standard *pStand1 = new Standard(10);
	Value *pValue1 = new Value(pStand1);
	
	Standard *pStand2 = new Standard(20);
	Value *pValue2 = new Value(pStand2);

	container[pStand1] = pValue1;
	container[pStand2] = pValue2;

	Standard *pStand3 = new Standard(20);

	printf("%d\n", container[pStand3]->pStandard->Get());

	delete pStand3;
	delete pStand1;
	delete pStand2;
	delete pValue1;
	delete pValue2;

	return 0;
}

OpenGL Shader – 32

GLSL 예제 : Texture(MultiTexture) – 3/3

원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?textureMulti

멀티 텍스쳐링은 GLSL에서는 정말 쉽다. 해야할 것은 두개의 텍스쳐에 접근하는 일이 전부다. 그리고 이 장에서는 동일한 텍스쳐 좌표를 사용할 것이기 때문에 버텍스 쉐이더를 재작성하지 않고 이전 강좌의 것을 그대로 사용한다. 프레그먼트 쉐이더 또한 두개의 텍스쳐 색상을 추가하는 최소한의 변화만 있다.

varying vec3 lightDir,normal;
uniform sampler2D tex,l3d;

void main()
{
    vec3 ct,cf;
    vec4 texel;
    float intensity,at,af;
		
    intensity = max(dot(lightDir,normalize(normal)),0.0);
	
    cf = intensity * (gl_FrontMaterial.diffuse).rgb + 
         gl_FrontMaterial.ambient.rgb;
    af = gl_FrontMaterial.diffuse.a;
	
    texel = texture2D(tex,gl_TexCoord[0].st)+
            texture2D(l3d,gl_TexCoord[0].st);

    ct = texel.rgb;
    at = texel.a;
	
    gl_FragColor = vec4(ct * cf, at * af);	
}

그리고 이제, 약간 다른 특별한 것을 해보자: Glow in the Drak Effect. 이 특별한 효과는 두번째 텍스쳐를 어둠속에서 타오르는듯하게 보이는 것이다. 예를들어, 완전이 밝아졌다가 어두워지는 듯한 효과.
두 단계로 최종 색상을 다시 계산해야 하는데, 먼저 첫번째 텍스쳐를 프레그먼트 색상으로 조정된 상태의 색상을 계산하고, 이후에 두번째 텍스쳐 유닛을 강도에 기반해서 추가하는 것이다.

intensity가 0이라면, 두번째 텍스쳐가 전체적으로 완전하게 표시된다. 반대로 intensity가 1이라면, 두번째 텍스쳐를 10% 정도만 표시되도록 한다. 이런 표시를 위해 smoothStep라는 함수를 통해 구현할 것이다. 이 함수의 시그니쳐는 다음과 같다.

genType smoothStep(genType edge0, genType edge1, genType x);

만약 x<=edge0이면 결과는 0이고,  x>=edge1이면 1 그리고 edge0< x <edge1이면 Hermit 보간 연산이 수행된다. 우리의 경우 다음 함수를 호출한다.

coef = smoothStep(1.0, 0.2, intensity);

다음은 프레그먼트 쉐이더 코드이다.

varying vec3 lightDir,normal;
uniform sampler2D tex,l3d;

void main()
{
    vec3 ct,cf,c;
    vec4 texel;
    float intensity,at,af,a;
	
    intensity = max(dot(lightDir,normalize(normal)),0.0);
	
    cf = intensity * (gl_FrontMaterial.diffuse).rgb + 
             gl_FrontMaterial.ambient.rgb;
    af = gl_FrontMaterial.diffuse.a;
	
    texel = texture2D(tex,gl_TexCoord[0].st);
		
    ct = texel.rgb;
    at = texel.a;
	
    c = cf * ct;
    a = af * at;
		
    float coef = smoothstep(1.0,0.2,intensity);
    c += coef *  vec3(texture2D(l3d,gl_TexCoord[0].st));
	
    gl_FragColor = vec4(c, a);	
}

OpenGL Shader – 31

GLSL 예제 : Texture(Combine Texture + Fragment) – 2/3

원문 : http://www.lighthouse3d.com/opengl/glsl/index.php?dirlightpix

OpenGL은 다양한 방법으로 텍스쳐 색상과 프레그먼트 생상을 혼합하는 방법을 제공한다.  바로 아래의 내용은 RGBA 모드를 위한 몇가지 모드이다.

GL_REPLACE      C = Ct                           A = At 
GL_MODULATE     C = Ct*Cf                        A = At*Af 
GL_DECAL        C = Cf * (1 - At) + Ct * At      A = Af

Ct와 At는 텍스쳐의 색상과 알파값이고, Cf와 Af는 프레그먼트의 색상과 알파값이며 C와 A는 최종적인 색상과 알파값이다.

이전 섹션에서 제공되었던 예제는 GL_REPLACE의 경우의 예였다. 여기서는 정육면체에 GL_MODULATE의 내용을 구현해보자. 쉐이더들은 하얀색의 Diffuse Directional Light를 가지고 Diffuse와 Ambient 요소만을 계산한다. 재질에 대한 완전한 정의는 Lighting(광원) 섹션을 살펴보길 바란다.

빛을 사용하기 때문에, 그래서 법선벡터에 대해,  버텍스 쉐이더는 몇가지 작업을 해야한다. 주로 법선벡터를 카메라 좌표계로 변환하고 정규화하는 일이며 빛의 방향에 대해서도 정규화를 해야한다. (빛의 방향은 이미 OpenGL에 의해서 카메라 좌표계로 변환되어졌다). 지금 단계에서 버텍스 쉐이더는 다음과 같다.

varying vec3 lightDir,normal;
	
void main()
{
    normal = normalize(gl_NormalMatrix * gl_Normal);
    lightDir = normalize(vec3(gl_LightSource[0].position));
		
    gl_TexCoord[0] = gl_MultiTexCoord0;
    gl_Position = ftransform();
}

프레그먼트 쉐이더에서, 프레그먼트의 색상과 알파값은 각각 cf와 af에 계산되어진다. 위에서 언급한 GL_MODULATE 공식을 계산하는 나머지 쉐이더 코드는 다음과 같다.

varying vec3 lightDir,normal;
uniform sampler2D tex;
	
void main()
{
    vec3 ct,cf;
    vec4 texel;
    float intensity,at,af;
		
    intensity = max(dot(lightDir,normalize(normal)),0.0);
		
    cf = intensity * (gl_FrontMaterial.diffuse).rgb + 
              gl_FrontMaterial.ambient.rgb;
    af = gl_FrontMaterial.diffuse.a;
		
    texel = texture2D(tex,gl_TexCoord[0].st);
    ct = texel.rgb;
    at = texel.a;
		
    gl_FragColor = vec4(ct * cf, at * af);	
}