Unexpected behaviour with GLSL Matrix - opengl

The following simple fragment shader exhibits very odd behaviour. Without the loop the output is all red, as expected. But with the loop it turns yellow, i. e. rgb(1,1,0). Might someone enlighten me as to what is happening here?
void main(void)
{
mat4 redUnit = mat4(
1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0
);
mat4 greenUnit = mat4(
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0
);
mat4 blueUnit = mat4(
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0
);
for (int x = -1; x < 3; x++) {
for (int y = -1; y < 3; y++) {
redUnit[x+1][y+1] = 1.0;
greenUnit[x+1][y+1] = 0.0;
blueUnit[x+1][y+1] = 0.0;
}
}
gl_FragColor = vec4(redUnit[0][0], greenUnit[0][0], blueUnit[0][0], 1.0);
}
EDIT: The output color depends on the order in which the variables are declared. So somehow memory boundaries are being violated. Still doesn't explain the behaviour though.


In case anyone else encounters this: It is a bug in the Intel GMA graphics driver. On another machine with a different graphics card everything works just fine.

Related

Calculate Normals in Shader

I am new to OpenGL and Shaders.
I want to write a toon shader.
I have this OpenGL code:
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
float black[] = { 0.0, 0.0, 0.0, 1.0 };
float red[] = { 1.0, 0.0, 0.0, 1.0 };
float green[] = { 0.0, 1.0, 0.0, 1.0 };
float blue[] = { 0.0, 0.0, 1.0, 1.0 };
float white[] = { 1.0, 1.0, 1.0, 1.0 };
float lowAmbient[] = { 0.2, 0.2, 0.2, 1.0 };
float fullAmbient[] = { 1.0, 1.0, 1.0, 1.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, blue);
glMaterialfv(GL_FRONT, GL_DIFFUSE, blue);
glMaterialfv(GL_FRONT, GL_SPECULAR, white);
glMaterialf(GL_FRONT, GL_SHININESS, 128.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, lowAmbient);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -9);
glRotatef(45, 1, 0, 0);
glRotatef(45, 0, 0, 1);
glBegin(GL_QUADS);
//front
glNormal3f(0.0, 0.0, -1.0);
glVertex3f(-1.0, 1.0, 1.0);
glVertex3f(-1.0, -1.0, 1.0);
glVertex3f(1.0, -1.0, 1.0);
glVertex3f(1.0, 1.0, 1.0);
//back
glNormal3f(0.0, 0.0, 1.0);
glVertex3f(1.0, 1.0, -1.0);
glVertex3f(1.0, -1.0, -1.0);
glVertex3f(-1.0, -1.0, -1.0);
glVertex3f(-1.0, 1.0, -1.0);
//right
glNormal3f(1.0, 0.0, 0.0);
glVertex3f(1.0, 1.0, 1.0);
glVertex3f(1.0, -1.0, 1.0);
glVertex3f(1.0, -1.0, -1.0);
glVertex3f(1.0, 1.0, -1.0);
//left
glNormal3f(-1.0, 0.0, 0.0);
glVertex3f(-1.0, 1.0, -1.0);
glVertex3f(-1.0, -1.0, -1.0);
glVertex3f(-1.0, -1.0, 1.0);
glVertex3f(-1.0, 1.0, 1.0);
//top
glNormal3f(0.0, 1.0, 0.0);
glVertex3f(-1.0, 1.0, -1.0);
glVertex3f(-1.0, 1.0, 1.0);
glVertex3f(1.0, 1.0, 1.0);
glVertex3f(1.0, 1.0, -1.0);
//bottom
glNormal3f(0.0, -1.0, 0.0);
glVertex3f(-1.0, -1.0, -1.0);
glVertex3f(-1.0, -1.0, 1.0);
glVertex3f(1.0, -1.0, 1.0);
glVertex3f(1.0, -1.0, -1.0);
glEnd();
//Swap back and front buffer
glutSwapBuffers();
}
void init()
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glEnable(GL_DEPTH_TEST);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
float ambientLight[] = { 0.2,0.2,0.2,1.0 };
float diffuseLight[] = { 0.8,0.8,0.8,1.0 };
float specularLight[] = { 1.0,1.0,1.0,1.0 };
float lightPosition[] = { 0.5,0.5,0.0,1.0 };
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
}
My Shader Codes:
#shader vertex
#version 330 core
void main()
{
}
#shader fragment
#version 330 core
vec3 LightPosition = gl_LightSource[0].position;//I don't know this is true or not
vec3 Normal;//I don't know how to calculate
void main()
{
vec4 color1 = gl_FrontMaterial.diffuse + gl_FrontMaterial.specular +
gl_FrontMaterial.ambient;
vec4 color2;
float intensity = dot(LightPosition, Normal);
if (intensity > 0.95) color2 = vec4(1.0, 1.0, 1.0, 1.0);
else if (intensity > 0.75) color2 = vec4(0.8, 0.8, 0.8, 1.0);
else if (intensity > 0.50) color2 = vec4(0.6, 0.6, 0.6, 1.0);
else if (intensity > 0.25) color2 = vec4(0.4, 0.4, 0.4, 1.0);
else color2 = vec4(0.2, 0.2, 0.2, 1.0);
gl_FragColor = color1 * color2;
}
To calculate light intensity and apply colors to my cube object I should know normals.
How can I calculate, or if there is a way, reach them?
(I have no problem with the shader compilation, or other OpenGL stuff. If I close my shader compilation lines I can see a green cube.)

Error LSTM sentiment analysis using Tensorflow - ValueError: Cannot feed value of shape

I am learning LSTM model for sentiment analysis.
Below is the code that generates the feature sets from 5000 positive and negative sentences:
import nltk
from nltk.tokenize import word_tokenize
import numpy as np
import random
from collections import Counter
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
hm_lines = 100000
def create_lexicon(pos, neg):
lexicon = []
with open(pos, 'r') as f:
contents = f.readlines()
for l in contents[:len(contents)]:
l= l.decode('utf-8')
all_words = word_tokenize(l)
lexicon += list(all_words)
f.close()
with open(neg, 'r') as f:
contents = f.readlines()
for l in contents[:len(contents)]:
l= l.decode('utf-8')
all_words = word_tokenize(l)
lexicon += list(all_words)
f.close()
lexicon = [lemmatizer.lemmatize(i) for i in lexicon]
w_counts = Counter(lexicon)
l2 = []
for w in w_counts:
if 1000 > w_counts[w] > 50:
l2.append(w)
print("Lexicon length create_lexicon: ",len(lexicon))
return l2
def sample_handling(sample, lexicon, classification):
featureset = []
print("Lexicon length Sample handling: ",len(lexicon))
with open(sample, 'r') as f:
contents = f.readlines()
for l in contents[:len(contents)]:
l= l.decode('utf-8')
current_words = word_tokenize(l.lower())
current_words= [lemmatizer.lemmatize(i) for i in current_words]
features = np.zeros(len(lexicon))
for word in current_words:
if word.lower() in lexicon:
index_value = lexicon.index(word.lower())
features[index_value] +=1
features = list(features)
featureset.append([features, classification])
f.close()
print("Feature SET------")
print(len(featureset))
return featureset
def create_feature_sets_and_labels(pos, neg, test_size = 0.1):
global m_lexicon
m_lexicon = create_lexicon(pos, neg)
features = []
features += sample_handling(pos, m_lexicon, [1,0])
features += sample_handling(neg, m_lexicon, [0,1])
random.shuffle(features)
features = np.array(features)
testing_size = int(test_size * len(features))
train_x = list(features[:,0][:-testing_size])
train_y = list(features[:,1][:-testing_size])
test_x = list(features[:,0][-testing_size:])
test_y = list(features[:,1][-testing_size:])
return train_x, train_y, test_x, test_y
def get_lexicon():
global m_lexicon
return m_lexicon
Below is the code for LSTM:
import tensorflow as tf
from tensorflow.contrib import rnn
from create_sentiment_featuresets import create_feature_sets_and_labels
from create_sentiment_featuresets import get_lexicon
import numpy as np
# extras for testing
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
#- end extras
train_x, train_y, test_x, test_y = create_feature_sets_and_labels('pos.txt', 'neg.txt')
print(len(train_x))
print(len(train_x[0]))
input_vec_size= len(train_x[0]) # = lstm size
hm_epochs = 3
n_classes = 2
batch_size = 100
rnn_size = 128 # hidden layers
x = tf.placeholder('float', [None, input_vec_size, n_classes])
y = tf.placeholder('float')
def recurrent_neural_network(x):
layer = {'weights': tf.Variable(tf.random_normal([rnn_size, n_classes])), 'biases': tf.Variable(tf.random_normal([n_classes]))}
x = tf.transpose(x, [1,0,2])
x = tf.reshape(x, [-1, input_vec_size])
x = tf.split(x, 2, 0)
lstm_cell = rnn.BasicLSTMCell(rnn_size, state_is_tuple=True)
outputs, states = rnn.static_rnn(lstm_cell, x, dtype= tf.float32)
output = tf.matmul(outputs[-1], layer['weights']) + layer['biases']
return output
def train_neural_network(x):
prediction = recurrent_neural_network(x)
cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits= prediction, labels= y))
optimizer = tf.train.AdamOptimizer(learning_rate= 0.001).minimize(cost)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(hm_epochs):
epoch_loss = 0
i = 0
while i < len(train_x):
start = i
end = i+ batch_size
batch_x = train_x[start: end]
batch_y = train_y[start: end]
_, c = sess.run([optimizer, cost], feed_dict= {x: batch_x, y: batch_y})
epoch_loss += c
i+= batch_size
print('Epoch', epoch+ 1, 'completed out of ', hm_epochs, 'loss:', epoch_loss)
correct= tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct, 'float'))
print('Accuracy:', accuracy.eval({x:test_x, y:test_y}))
# prediction for single --------------
m_lexicon= get_lexicon()
print('Lexicon length: ',len(m_lexicon))
input_data= "David likes to go out with Kary"
current_words= word_tokenize(input_data.lower())
current_words = [lemmatizer.lemmatize(i) for i in current_words]
features = np.zeros(len(m_lexicon))
for word in current_words:
if word.lower() in m_lexicon:
index_value = m_lexicon.index(word.lower())
features[index_value] +=1
features = np.array(list(features)).reshape(1,-1) # if reshape is remove, add x:[features]
print('features length: ',len(features))
result = sess.run(tf.argmax(prediction.eval(feed_dict={x:features}), 1))
print('RESULT: ', result)
print(prediction.eval(feed_dict={x:features}))
if result[0] == 0:
print('Positive: ', input_data)
elif result[0] == 1:
print('Negative: ', input_data)
train_neural_network(x)
The above code is giving the following error:
2017-06-07 16:36:52.775649: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.1 instructions, but these are available on your machine and could speed up CPU computations.
2017-06-07 16:36:52.775682: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use SSE4.2 instructions, but these are available on your machine and could speed up CPU computations.
2017-06-07 16:36:52.775702: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations.
2017-06-07 16:36:52.775714: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations.
2017-06-07 16:36:52.775724: W tensorflow/core/platform/cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use FMA instructions, but these are available on your machine and could speed up CPU computations.
2017-06-07 16:36:53.094522: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2017-06-07 16:36:53.094925: I tensorflow/core/common_runtime/gpu/gpu_device.cc:887] Found device 0 with properties:
name: GeForce 930MX
major: 5 minor: 0 memoryClockRate (GHz) 1.0195
pciBusID 0000:01:00.0
Total memory: 1.96GiB
Free memory: 1.76GiB
2017-06-07 16:36:53.094958: I tensorflow/core/common_runtime/gpu/gpu_device.cc:908] DMA: 0
2017-06-07 16:36:53.094966: I tensorflow/core/common_runtime/gpu/gpu_device.cc:918] 0: Y
2017-06-07 16:36:53.094975: I tensorflow/core/common_runtime/gpu/gpu_device.cc:977] Creating TensorFlow device (/gpu:0) -> (device: 0, name: GeForce 930MX, pci bus id: 0000:01:00.0)
Traceback (most recent call last):
File "sentiment_demo_lstm2.py", line 119, in <module>
train_neural_network(x)
File "sentiment_demo_lstm2.py", line 79, in train_neural_network
_, c = sess.run([optimizer, cost], feed_dict= {x: batch_x, y: batch_y})
File "/home/lsmpc/tensorflow/local/lib/python2.7/site-packages/tensorflow/python/client/session.py", line 778, in run
run_metadata_ptr)
File "/home/lsmpc/tensorflow/local/lib/python2.7/site-packages/tensorflow/python/client/session.py", line 961, in _run
% (np_val.shape, subfeed_t.name, str(subfeed_t.get_shape())))
ValueError: Cannot feed value of shape (100, 423) for Tensor u'Placeholder:0', which has shape '(?, 423, 2)'
Please help.
Also I am having difficulty understanding this part:
x = tf.transpose(x, [1,0,2])
x = tf.reshape(x, [-1, input_vec_size])
x = tf.split(x, 2, 0)
Output of
print(train_x[0])
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
print(train_y[0])
[0, 1]
len(train_x)= 9596, len(train_x[0]) = 423
Thanks.

Translating Matriz in GLSL won't work with variables

So... i made this mat4 matriz which would translate a triangle according to the coordinates. I realized that with the following matriz, the triangle would translate to the right of the screen:
Camera[0] = vec4(1.0, 0.0, 0.0, 0.0);
Camera[1] = vec4(0.0, 1.0, 0.0, 0.0);
Camera[2] = vec4(0.0, 0.0, 1.0, 0.0);
Camera[3] = vec4(0.5, 0.0, 0.0, 1.0);
Now, i read that a translating matriz in GLSL would look like this:
Camera[0] = vec4(1.0, 0.0, 0.0, 0.0);
Camera[1] = vec4(0.0, 1.0, 0.0, 0.0);
Camera[2] = vec4(0.0, 0.0, 1.0, 0.0);
Camera[3] = vec4(X, Y, Z, 1.0);
So therefore, i created a variable, which would contain these 3 values.
layout(location = 2) in vec3 CAM;
And i would do the following to establish the values in the corresponding places:
Camera[0] = vec4(1.0, 0.0, 0.0, 0.0);
Camera[1] = vec4(0.0, 1.0, 0.0, 0.0);
Camera[2] = vec4(0.0, 0.0, 1.0, 0.0);
Camera[3] = vec4(CAM.x, CAM.y, CAM.z, 1.0);
I thought that if CAM.x = 0.5 And CAM.y = 0.0, CAM.z = 0.0, i would have the same result as i had when i established manually X to be 0.5, and both Y and Z to be 0.0, since those are precisely the values of CAM. But rather, i got completely different results.
Camera[0] = vec4(1.0, 0.0, 0.0, 0.0);
Camera[1] = vec4(0.0, 1.0, 0.0, 0.0);
Camera[2] = vec4(0.0, 0.0, 1.0, 0.0);
Camera[3] = vec4(0.5, 0.0, 0.0, 1.0);
Gives me the following result:
And
Camera[0] = vec4(1.0, 0.0, 0.0, 0.0);
Camera[1] = vec4(0.0, 1.0, 0.0, 0.0);
Camera[2] = vec4(0.0, 0.0, 1.0, 0.0);
Camera[3] = vec4(CAM.x, CAM.y, CAM.z, 1.0);
gave me the following result:
Even though CAM.x = 0.5; CAM.y = 0.0; CAM.z = 0.0. (I checked it myself inside the vertex Shader by changing the red color of one of the vertices if the values of CAM were correct. By adding the following code: if(CAM.x == 0.5) ColorValue.x = 0.0; I got the following result: ). How can this be??
This is the whole Vertex Code by the way:
#version 330 core
layout(location = 0) in vec3 VertexPosition;
layout(location = 1) in vec3 COR;
layout(location = 2) in vec3 CAM;
out vec3 ColorValue;
void main(){
mat4 Camera;
Camera[0] = vec4(1.0, 0.0, 0.0, 0.0);
Camera[1] = vec4(0.0, 1.0, 0.0, 0.0);
Camera[2] = vec4(0.0, 0.0, 1.0, 0.0);
Camera[3] = vec4(CAM.x, 0.0, 0.0, 1.0);
vec4 point = vec4(VertexPosition.x, VertexPosition.y, VertexPosition.z, 1.0);
vec4 Transformed_Point = Camera * point;
gl_Position = Transformed_Point;
ColorValue.xyz = COR.xyz;
}

You are handling the camera position as a vertex attribute. That's why the first vertex is correctly shifted but the other two are at their original positions (because their camera attribute is zero). Use a uniform instead.

Opengl Shader Basic Computation

OS: Win7 VS 2012
Graphics Card: Inter HD 4000
I have no problem generating an image without any computation.
However, when I added p*vPosition for a prospective projection,
My window opened and closed immediately after I executed the program.
Could anyone point out what I have done wrong?
My vshsader.glsl code looks like this:
#version 150
in vec4 vPosition;
in vec4 vColor;
out vec4 color;
void main()
{
float d = -10.0;
mat4 p = mat4( 1.0, 0.0, 0.0, 0.0
0.0, 0.0, 1.0, 0.0
0.0, 0.0, 1.0, 0.0
0.0, 0.0, 1/d, 0.0);
gl_Position = p*vPosition;
color = vColor;
}

You are missing commas at the end of each line of parameters to the mat4 constructor.
It should be:
mat4 p = mat4( 1.0, 0.0, 0.0, 0.0, // <- end with comma
0.0, 0.0, 1.0, 0.0, // <- end with comma
0.0, 0.0, 1.0, 0.0, // <- end with comma
0.0, 0.0, 1/d, 0.0);

Quaternion rotation x-axis 45 Degrees

Evening everyone,
I'm using glMultMatrixf in OpenGL to rotate my scene using the matrix:
float matrix[16] = { 1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0 };
I've been following this guide (link) but its a little bit over the top for what I need.
How could I simply rotate the x-axis by 45 degrees?
Cheers

Multiplying your transformation matrix by this rotation matrix should do the trick:
float rot45X[16] = { 1.0, 0.0, 0.0, 0.0,
0.0, cos(PI/4), -sin(PI/4), 0.0,
0.0, sin(PI/4), cos(PI/4), 0.0,
0.0, 0.0, 0.0, 1.0 };
Edit: You can also of course use the utility function
glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
where [x,y,z] indicate the axis of rotation (yes, it performs rotations around an arbitrary vector).
In your case you would need to call like this:
glRotatef(45, 1, 0, 0);