Jump to content
  • Advertisement
Sign in to follow this  
DallyLama

OpenGL Drawing the inside of a cube

This topic is 3120 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hello All, I'm kinda a beginner in openGL and I'm trying to draw the inside of a room using openGLES, what I've done so far was that... I create a cube [-1,1]x[-1,1]x[-1,1] and since on my platform I don't have support for most of the openGL API i created my own projection Matrix. Using only my projection Matrix (built like every other openGL matrices) assuming the camera is in the origin and glViewport i rendered the cube, but it looks horrible I only see one wall and it is all flattened, it doesn't have that nice 3D feel to it. I did switch the normals so it will look on the inside but I feel like im doing something fundamentally wrong... Any tips, ideas tutorial or links pointing to the right direction will be gladly Appreciated. Thx all.

Share this post


Link to post
Share on other sites
Advertisement
how are you rdrawing the cube? reversing the direction you pass the vertices in (or indices if your doing it that way) will change the faces to point inwards instead of outwards. Otherwise you can change full face to back
glCullFace(GL_BACK); (I think thats it, you could disable culling enritly too).

I would advise againstmessing with the culling though.

Share this post


Link to post
Share on other sites
If your cube looked flattened then it could be either of the following.

(1) The vertices are defined properly.
(2) The projection matrix is not defined properly.

Share this post


Link to post
Share on other sites
Quote:
Do you mean you see the walls, just not the corners/edges? If so, did you enable lighting?


Yes that is exactly what I mean. I do my lightning inside the fragment shader, I don't use any of the GLstates or predefined attributes, I pass it all manually!

Quote:
how are you rdrawing the cube? reversing the direction you pass the vertices in (or indices if your doing it that way) will change the faces to point inwards instead of outwards.


As I said before I do my own attributes calculation's that means normal's too,
And no cullMode is enabled at least I hope so. does openGL does defualt culling?

Quote:
If your cube looked flattened then it could be either of the following.

(1) The vertices are defined properly.
(2) The projection matrix is not defined properly.


here is the definition of my projection matrix and the definition of the cube:


//the cube:
#define VAL 1.0
#define M_VAL -VAL

glBindTexture(GL_TEXTURE_2D, texture[0]);
float cube_position[]= {
M_VAL, M_VAL, VAL , VAL , M_VAL, VAL , M_VAL, VAL , VAL ,
VAL , M_VAL, VAL , VAL , VAL , VAL , M_VAL, VAL , VAL ,

M_VAL, VAL , VAL , VAL , VAL , VAL , M_VAL, VAL , M_VAL,
VAL , VAL , VAL , VAL , VAL , M_VAL, M_VAL, VAL , M_VAL,

M_VAL, VAL , M_VAL, VAL , VAL , M_VAL, M_VAL, M_VAL, M_VAL,
VAL , VAL , M_VAL, VAL , M_VAL, M_VAL, M_VAL, M_VAL, M_VAL,

M_VAL, M_VAL, M_VAL, VAL , M_VAL, M_VAL, M_VAL, M_VAL, VAL ,
VAL , M_VAL, M_VAL, VAL , M_VAL, VAL , M_VAL, M_VAL, VAL ,

VAL , M_VAL, VAL , VAL , M_VAL, M_VAL, VAL , VAL , VAL ,
VAL , M_VAL,M_VAL, VAL , VAL , M_VAL, VAL , VAL , VAL ,

M_VAL, M_VAL, M_VAL, M_VAL, M_VAL, VAL , M_VAL, VAL ,M_VAL,
M_VAL, M_VAL, VAL , M_VAL, VAL , VAL , M_VAL, VAL , M_VAL };

float cube_normal[]= {
0, 0, 1.0f, 0, 0, 1.0f, 0, 0, 1.0f,
0, 0, 1.0f, 0, 0, 1.0f, 0, 0, 1.0f,

0, 1.0f, 0, 0, 1.0f, 0, 0, 1.0f, 0,
0, 1.0f, 0, 0, 1.0f, 0, 0, 1.0f, 0,

0, 0, -1.0f, 0, 0, -1.0f, 0, 0, -1.0f,
0, 0, -1.0f, 0, 0, -1.0f, 0, 0, -1.0f,

0, -1.0f, 0, 0, -1.0f, 0, 0, -1.0f, 0,
0, -1.0f, 0, 0, -1.0f, 0, 0, -1.0f, 0,

1.0f, 0, 0, 1.0f, 0, 0, 1.0f, 0, 0,
1.0f, 0, 0, 1.0f, 0, 0, 1.0f, 0, 0,

-1.0f, 0, 0, -1.0f, 0, 0, -1.0f, 0, 0,
-1.0f, 0, 0, -1.0f, 0, 0, -1.0f, 0, 0,
};

float cube_uvs[] = {
M_ONE, M_ONE, ONE , M_ONE, M_ONE, ONE,
ONE , M_ONE, ONE , ONE, M_ONE, ONE,

M_ONE, M_ONE, ONE , M_ONE, M_ONE, ONE,
ONE , M_ONE, ONE , ONE, M_ONE, ONE,

M_ONE, M_ONE, ONE , M_ONE, M_ONE, ONE,
ONE , M_ONE, ONE , ONE, M_ONE, ONE,

M_ONE, M_ONE, ONE , M_ONE, M_ONE, ONE,
ONE , M_ONE, ONE , ONE, M_ONE, ONE,

M_ONE, M_ONE, ONE , M_ONE, M_ONE, ONE,
ONE , M_ONE, ONE , ONE, M_ONE, ONE,

M_ONE, M_ONE, ONE , M_ONE, M_ONE, ONE,
ONE , M_ONE, ONE , ONE, M_ONE, ONE,

};

// the projection matrix

void gl2_projection(float* mat, float n, float r, float t, float f)
{
gl2_identity(mat);
mat[0] = n/r;
mat[5] = n/t;
mat[10] = -(f+n)/(f-n);
mat[11] = -(2*f*n)/(f-n);
mat[14] = -1;
mat[15] = 0;

}

//drawing function

//defining the transformations
gl2_identity(projection_matrix);
gl2_identity(modelview_matrix);
gl2_projection(projection_matrix, 0.1, 2.0, 2.0 , 5.0);
gl2_rotate(modelview_matrix,mAngle,1.0f,1.0f,1.0f);
MulMatrix(projection_matrix,modelview_matrix,mvp_matrix);
glViewport(0,0,480,800);

// passing all the necessary attributes to the sahders...

//drawing

int mFirstIndex = 0;
int mStripCount = 12;

for(int i = 0; i < mStripCount; i++)
{
glDrawArrays(GL_TRIANGLE_STRIP, mFirstIndex, 3);
mFirstIndex += 3;
}



And to all of you great thanks


Share this post


Link to post
Share on other sites
I see you're rotating the camera to see the edges/corners, don't you?

Could you post your shader code?


One thing wrt. your normals:

Your first wall is placed at positive z (VAL) and its normals also point in positive z direction (0,0,1). The opposite wall is located at negative z (M_VAL) and its normals all point to negative z (0,0,-1).

This means your normals are pointing outwards and a normal lighting calculation would just apply ambient light to the vertices if the camera is located inside the cube.


P.S.: per default backface culling is turned on, but since you see the walls, that should not be your problem.

Share this post


Link to post
Share on other sites
Quote:
I see you're rotating the camera to see the edges/corners, don't you?


No this is dead code mAngle is set to 0.

Quote:
Could you post your shader code?


I will post them up later today not near my computer.

Quote:
Your first wall is placed at positive z (VAL) and its normals also point in positive z direction (0,0,1). The opposite wall is located at negative z (M_VAL) and its normals all point to negative z (0,0,-1).


I reverse the normal in the fragment shader... again later today I'll post my shders.

Share this post


Link to post
Share on other sites
If you're not rotating the camera it might also just be that the corners/edges lie outside your view frustum. Did you check that?

Share this post


Link to post
Share on other sites
Cant Say I have, but since my view frustrum span from [-4,4]x[-4,4]

I believe it should be.

But i will check the math nevertheless.

Share this post


Link to post
Share on other sites
shader code attached im trying to make deferred shading so ill just attach the lighting pass fragment shader...


#define MAX_LIGHTS 20


#define COSSPOTCUTOFF 0.988 // cos(pi/12)

uniform vec3 lightDirection[MAX_LIGHTS];
//uniform vec3 spotDirection[MAX_LIGHTS];
uniform vec3 lightColor[MAX_LIGHTS];

uniform int maxLights;

uniform sampler2D Env,normalTex,posTex;

varying vec2 vTexCoord;

const vec4 red = vec4(1.0, 0.0, 0.0 ,1.0);
const vec4 blue = vec4(0.0, 0.0, 1.0 ,1.0);
const vec4 green = vec4(0.0, 1.0, 0.0 ,1.0);

void main(void)
{
vec3 v_eyePosition = vec3(0.0,0.0,-25.0);

// sampling the pre made textures
//vec3 normal = texture2D( normalTex, vTexCoord ).xyz;
vec4 t = texture2D( normalTex, vTexCoord );
t =( t*2.0)-vec4(1.0,1.0,1.0,1.0); // transforming back to the normal range

vec3 normal = t.xyz;

vec4 pos = texture2D( posTex, vTexCoord );
pos = (pos*2.0) - vec4(1.0,1.0,1.0,1.0);
vec4 texColor = texture2D( Env, vTexCoord )*1.5;

vec4 diffuse;
vec4 color = vec4(0.1, 0.1, 0.1, 1.0); //this is the ambient term
vec4 specular;
normal = normalize(normal);
vec3 eyeVector = normalize((pos*10.0).xyz - v_eyePosition);
float p = 0.0;
vec4 dif;
for (int i = 0; i < maxLights; i++)
{
//i =;
vec3 lightDir = (pos*10.0).xyz - (lightDirection*20.0);
float NdotL = -dot(normalize(-lightDirection),normal);
//p = NdotL;
if (NdotL > 0.0)
{
float spotEffect = dot(normalize(-lightDirection), normalize(lightDir));
if (spotEffect > COSSPOTCUTOFF)
{

//attanuation factors
spotEffect = pow(spotEffect, 80.0);
float att = spotEffect / (0.02 * length(lightDir));
p = att;


vec3 ref = reflect(normalize(lightDir), normal);

diffuse = NdotL*vec4(lightColor,1.0); //diffuse term

float RdotE = max(dot(-normalize(ref), eyeVector),0.0);
specular = pow(RdotE, 35.0)*vec4(lightColor,1.0); //specular term
color += att * (diffuse + specular);
dif = color;
}
}
}
gl_FragColor = texColor*color;
}




just to explain the array lightDirection is actually the positions of the spotlights, and all the spot direction are the direction between the position and the origin

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

We are the game development community.

Whether you are an indie, hobbyist, AAA developer, or just trying to learn, GameDev.net is the place for you to learn, share, and connect with the games industry. Learn more About Us or sign up!

Sign me up!