struggling with rendering on Oculus [sdk 0.7 / 0.8]

#include "Oculus.h"

extern PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf;

// Create oculus object (GL window must have been already created)
COculus::COculus()
{
	glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)wglGetProcAddress("glLoadTransposeMatrixf");

}

bool COculus::Initialise()
{
	ovrResult error;

	error = ovr_Initialize(nullptr);
	if (!OVR_SUCCESS(error)) {
		return false;
	}

	ovrGraphicsLuid luid;
	error = ovr_Create(&hmd, &luid);
	if (!OVR_SUCCESS(error)) {
		return false;
	}

	HmdDesc = ovr_GetHmdDesc(hmd);

	error = ovr_ConfigureTracking(hmd, ovrTrackingCap_Orientation | ovrTrackingCap_MagYawCorrection | ovrTrackingCap_Position, 0);
	if (!OVR_SUCCESS(error)) {
		return false;
	}

	return true;
}

// Delete object
COculus::~COculus()
{
	ovr_Destroy(hmd);
	ovr_Shutdown();
}


bool COculus::CreateBuffers(int winX, int winY,float PixelScale)
{
	ovrResult error;

	//resolution = HmdDesc.Resolution;
	resolution.w = winX;
	resolution.h = winY;


	// Make eye render buffers
	for (int eye = 0; eye < 2; ++eye)
	{
		idealTextureSize[eye] = ovr_GetFovTextureSize(hmd, ovrEyeType(eye), HmdDesc.DefaultEyeFov[eye], PixelScale);
		error = ovr_CreateSwapTextureSetGL(hmd, GL_SRGB8_ALPHA8, idealTextureSize[eye].w, idealTextureSize[eye].h, &TextureSet[eye]);
		if (!OVR_SUCCESS(error)) {
			return false;
		}

		for (int i = 0; i < TextureSet[eye]->TextureCount; ++i)
		{
			ovrGLTexture* tex = (ovrGLTexture*)&TextureSet[eye]->Textures[i];

			glBindTexture(GL_TEXTURE_2D, tex->OGL.TexId);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		}

		glGenFramebuffers(1, &fbID[eye]);
			
		glGenTextures(1, &dbID[eye]);
		glBindTexture(GL_TEXTURE_2D, dbID[eye]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		GLenum internalFormat = GL_DEPTH_COMPONENT24;
		GLenum type = GL_UNSIGNED_INT;

		glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, idealTextureSize[eye].w, idealTextureSize[eye].h, 0, GL_DEPTH_COMPONENT, type, NULL);

	}

	// Create mirror texture and an FBO used to copy mirror texture to back buffer
	error = ovr_CreateMirrorTextureGL(hmd, GL_SRGB8_ALPHA8, resolution.w, resolution.h, reinterpret_cast<ovrTexture**>(&mirrorTexture));
	if (!OVR_SUCCESS(error)) {
		return false;
	}


	// Configure the mirror read buffer
	glGenFramebuffers(1, &mirrorFBO);
	glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFBO);
	glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mirrorTexture->OGL.TexId, 0);
	glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
	
	EyeRenderDesc[0] = ovr_GetRenderDesc(hmd, ovrEye_Left, HmdDesc.DefaultEyeFov[0]);
	EyeRenderDesc[1] = ovr_GetRenderDesc(hmd, ovrEye_Right, HmdDesc.DefaultEyeFov[1]);
	
	return true;

}

void COculus::BeginFrame()
{
	// Get eye poses, feeding in correct IPD offset
	ViewOffset[0] = EyeRenderDesc[0].HmdToEyeViewOffset;
	ViewOffset[1] = EyeRenderDesc[1].HmdToEyeViewOffset;

	// Keeping sensorSampleTime as close to ovr_GetTrackingState as possible - fed into the layer
	sensorSampleTime = ovr_GetTimeInSeconds();

	ovrTrackingState hmdState = ovr_GetTrackingState(hmd, ovr_GetPredictedDisplayTime(hmd, 0), ovrTrue);
	
	ovr_CalcEyePoses(hmdState.HeadPose.ThePose, ViewOffset, EyeRenderPose);
}




void COculus::BindFrameBuffer(int eye)
{
	TextureSet[eye]->CurrentIndex = (TextureSet[eye]->CurrentIndex + 1) % TextureSet[eye]->TextureCount;

	auto tex = reinterpret_cast<ovrGLTexture*>(&TextureSet[eye]->Textures[TextureSet[eye]->CurrentIndex]);
	glBindFramebuffer(GL_FRAMEBUFFER, fbID[eye]);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex->OGL.TexId, 0);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, dbID[eye], 0);
}

void COculus::SetView(int eye, float nearPlane, float farPlane)
{
	glViewport(0, 0, idealTextureSize[eye].w, idealTextureSize[eye].h);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_FRAMEBUFFER_SRGB);

	ovrMatrix4f proj = ovrMatrix4f_Projection(HmdDesc.DefaultEyeFov[eye], nearPlane, farPlane, ovrProjection_RightHanded);

	glMatrixMode(GL_PROJECTION);
	glLoadTransposeMatrixf(proj.M[0]);
}

void COculus::UnbindFrameBuffer(int eye)
{
	glBindFramebuffer(GL_FRAMEBUFFER, fbID[eye]);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
}

void COculus::EndFrame(float scale)
{
	// Set up positional data.
	ovrViewScaleDesc viewScaleDesc;
	viewScaleDesc.HmdSpaceToWorldScaleInMeters = scale;
	viewScaleDesc.HmdToEyeViewOffset[0] = ViewOffset[0];
	viewScaleDesc.HmdToEyeViewOffset[1] = ViewOffset[1];
		
	ovrLayerEyeFov ld;
	ld.Header.Type = ovrLayerType_EyeFov;
	ld.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft;   // Because OpenGL.

	for (int eye = 0; eye < 2; ++eye)
	{
		ld.ColorTexture[eye] = TextureSet[eye];
		ld.Viewport[eye].Pos.x = 0;
		ld.Viewport[eye].Pos.y = 0;
		ld.Viewport[eye].Size = idealTextureSize[eye];
		ld.Fov[eye] = HmdDesc.DefaultEyeFov[eye];
		ld.RenderPose[eye] = EyeRenderPose[eye];
		ld.SensorSampleTime = sensorSampleTime;
	}

	ovrLayerHeader* layers = &ld.Header;
	ovrResult result = ovr_SubmitFrame(hmd, 0, &viewScaleDesc, &layers, 1);

	// Blit mirror texture to back buffer
	glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFBO);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
	
	GLint w = mirrorTexture->OGL.Header.TextureSize.w;
	GLint h = mirrorTexture->OGL.Header.TextureSize.h;
	
	glBlitFramebuffer(0, h, w, 0, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);


}


void COculus::GetHeadTracking(double Q[4])
{
	// Query the HMD for the current tracking state.
	ovrTrackingState ts = ovr_GetTrackingState(hmd, ovr_GetPredictedDisplayTime(hmd, 0), ovrTrue);
	if (ts.StatusFlags & (ovrStatus_OrientationTracked))
	{
		Posef pose = ts.HeadPose.ThePose;
				
		Q[0]=pose.Rotation.w;
		Q[1]=pose.Rotation.x;
		Q[2]=pose.Rotation.y;
		Q[3]=pose.Rotation.z;
	}
}

void COculus::GetEulerAngles(float* yaw,float* pitch,float* roll)
{
	// Query the HMD for the current tracking state.
	ovrTrackingState ts = ovr_GetTrackingState(hmd, ovr_GetPredictedDisplayTime(hmd, 0), ovrTrue);
	if (ts.StatusFlags & (ovrStatus_OrientationTracked))
	{
		Posef pose = ts.HeadPose.ThePose;

		pose.Rotation.GetEulerAngles<Axis_Y, Axis_X, Axis_Z>(yaw, pitch, roll);
		
	}
}

void COculus::GetOffset(int eye,float* OffetX, float* OffetY, float* OffetZ)
{
	*OffetX = EyeRenderDesc[eye].HmdToEyeViewOffset.x;
	*OffetY = EyeRenderDesc[eye].HmdToEyeViewOffset.y;
	*OffetZ = EyeRenderDesc[eye].HmdToEyeViewOffset.z;

}

void COculus::Recenter()
{
	ovr_RecenterPose(hmd);
}

#ifndef OCULUS_H
#define OCULUS_H

#define OVR_OS_WIN32

#include <GL/gl.h>

#include <OVR.h>
#include <OVR_CAPI_GL.h>

using namespace OVR;

class COculus
{

public:

	COculus();
	~COculus();

	bool Initialise();
	bool CreateBuffers(int winX, int winY, float PixelScale);

	void BeginFrame();

	void SetView(int eye, float near, float far);
	void BindFrameBuffer(int eye);
	void UnbindFrameBuffer(int eye);

	void EndFrame(float scale);

	void GetEulerAngles(float* yaw, float* pitch, float* roll);
	void GetHeadTracking(double Q[4]);
	void GetOffset(int eye, float* OffetX, float* OffetY, float* OffetZ);

	void Recenter();

private:
	ovrHmd				hmd;
	ovrHmdDesc          HmdDesc;
	ovrSwapTextureSet*	TextureSet[2];
	ovrVector3f			ViewOffset[2];
	ovrPosef			EyeRenderPose[2];
	double				sensorSampleTime;
	ovrSizei			idealTextureSize[2];
	ovrGLTexture*		mirrorTexture;
	ovrSizei			resolution;
	ovrEyeRenderDesc	EyeRenderDesc[2];
	GLuint				fbID[2];
	GLuint				dbID[2];
	GLuint				mirrorFBO;

};

#endif

"Mars3D" wrote:

Initialise
CreateBuffers

for each frame
{
BeginFrame
for each eye
{
SetView
BindFrameBuffer
GetOffset
Render Your Scene using the offset
UnbindFrameBuffer
}
EndFrame
}

void RenderScene(){

	glColor4f(1.f, 1.f, 1.f, 1.f);
	glBegin(GL_TRIANGLES);
	glColor3f(1.f, 0.f, 0.f);
	glVertex3f(-0.6f, -0.4f, 0.f);
	glColor3f(0.f, 1.f, 0.f);
	glVertex3f(0.6f, -0.4f, 0.f);
	glColor3f(0.f, 0.f, 1.f);
	glVertex3f(0.f, 0.6f, 0.f);
	glEnd();
}

"kojack" wrote:
Yep, you can't modify the texture names in the texture set. The texture set it gives you is never used internally, it has it's own copy and kkeps using the original values, it's only there for you to read the texture id it made for you.

"joan" wrote:
Have you looked at OculusRoomTinyGL sample in the SDK? It's a good starting point.

You are not supposed to create a texture on your side and try to force it into Oculus texture set. You must use the texture created by the runtime and draw onto it.

There is a recent thread about this aspect here.

"godjilla" wrote:

I just put the above code between the "BindFramebuffer" and "UnbindFramebuffer"
And I just got black void lonely scene.

Would you tell me with more detail?

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glTranslatef(-OffSetX, 0.0f, -6.0f);
	glDisable(GL_TEXTURE_2D);

	glColor4f(1.0f, 0.0f, 0.0f, 0.0f);
	glBegin(GL_TRIANGLES);                      // Drawing Using Triangles
	glVertex3f(0.0f, 1.0f, 0.0f);              // Top
	glVertex3f(-1.0f, -1.0f, 0.0f);              // Bottom Left
	glVertex3f(1.0f, -1.0f, 0.0f);              // Bottom Right
	glEnd();

"Mars3D" wrote:

"godjilla" wrote:

I just put the above code between the "BindFramebuffer" and "UnbindFramebuffer"
And I just got black void lonely scene.

Would you tell me with more detail?

The offsets are what you need to translate your modelview matrix by.

This should work,

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glTranslatef(-OffSetX, 0.0f, -6.0f);
	glDisable(GL_TEXTURE_2D);

	glColor4f(1.0f, 0.0f, 0.0f, 0.0f);
	glBegin(GL_TRIANGLES);                      // Drawing Using Triangles
	glVertex3f(0.0f, 1.0f, 0.0f);              // Top
	glVertex3f(-1.0f, -1.0f, 0.0f);              // Bottom Left
	glVertex3f(1.0f, -1.0f, 0.0f);              // Bottom Right
	glEnd();