VentureReality Engine v0.1 alpha preview.

[paul_g_griffiths]

Still like my verify numbers have changes before performing calculation.

Each line of code is either a single calculation or single logic.

Retrieve verify bits from memory, if not changed go on to next calculation. If changed, retrieve calculation from memory and the 2 variables, perform calculation, store result as variable and set verify bit.

Even go as far as advanced memory where the memory goes through each verify bits looking for changes. Could be a while before finding a change.

Seems different than current processors and memory to me.
The overhead is nothing compared to a possible length of no change.

Run the memory as a separate clock and be faster. While performing a calculation the memory could be looking for next possible change, that being it unless the calculation being performed is logic and going somewhere else. May be a lot of maths calculations before coming across logic.
Would be no slower but could be many many times faster.

Work for arrays too if know specific calculation.
Guess sometimes no profit so then use non verified numbers.

I got 8 gig of memory, a lot not being used.

Could have verify function too.
May be even classes.

Think it's patentable with new memory and clock.

[paul_g_griffiths]

This is my project and theirs existing technology companies.

I'm willing to exchange if others are too.

[paul_g_griffiths]

Seems as CPU's are multicore my "Distributor/Skipper" device may be part of the CPU.
May be lucky and work with existing OS & Software when some operations setting a "Always execute" bit. Using ~ may be before a line of code.
Without any recompiling, will see some increase in speed as my "Distributor/Skipper" will possibly know the next execution before the CPU has finished current execution.
To be honest a new "Standard" needs to be created between the CPU, GPU, Memory and my "Distributor/Skipper" to enjoy it's full effect.

[paul_g_griffiths]

Going along with c/c++ Computers and "Distributor & skipper".
I need machine codes and operations for each logic & maths function.
For now I'm guessing a 1500 times faster computer.
Guess the graphics at 60 frames a second would the equivalent of 30 seconds of processing of todays computers.
This is just a guess as hard for me to say.
Need random and encrypted machine codes, memory & storage and dedicated individual custom encryptor/decryptor with a unique boot code for software security.
Don't need the clock for the Distributor & skipper.
I like the idea of SPI Ports with Network ID's destination. NSPI.

[paul_g_griffiths]

I'm not liking c++ for quite a lot of reasons and creating new language called GRCode+.
Having fun translating GRCode+ for objects, inheritance and interface in to GRCode.
GRCode then converted to GRN, GRCode Numbers for ==, !=, <, <=, >, >=, &&, %, +, -, /, *, &, and =.
Compiled programs consisting of function numbers, function ends, variable numbers and GRN. With an Interface file for objects(.gri). Equivalent of a header file which is extracted from your source(.grs)

It's a lot easier and doesn't require assembly!

Say have line:

if (position == vec3(10.0, 15.0, 0.0)) elephant.setState(Elephant:STATES:JUMPING)

if position has changed then would require 3 instructions and the 3 pairs of variables to be sent to 3 separate processor units and then the 3 results compared to be all true.

So may be 3 times faster though require more hardware, but then transistors are only so fast so may be good.
Consecutive conditions is a problem for my skipper so an amount of bits added to the processor used to compare consecutive conditions would work. A new "Consecutive unit". Or use the above.

Let's say there's a run function thread, after it and all functions called, at end then all the variables that have changed in the functions, the "Changed" bits in the skipper has to be updated so no longer seen as changed. So an extra bit is required for "Require Update" and iterate, set both bits to 0.

Seems doable, I want to jump 20/22/24 years, I want my G1500, G3000 or G6000 based Computer platform.

Guess "Reality" would be GRCode+ too. Probably no difference other than additional interface.

Show my efforts tomorrow.

[paul_g_griffiths]

Here's something what GRCode+ may look like:

vec3(float x, float y, float z)
[
]
 
Elephant
[
	enum STATES
	{
		STANDING = 0
		WALING
		SITTING
		JUMPING
	}
 
	vec3 position(25.5, 15.0, .5)
 
	STATES state
 
	void setState(STATE state)
	{
		:state = state
	}
]
 
Jacket
[
	vec3 colour(1.0, 0, .5)
 
	void setColour(vec3 color)
	{
		:color = color
	}
]
 
Hat
[
	vec3 colour(1.0, 0, .5)
 
	void setColour(vec3 color)
	{
		:color = color
	}
]
 
ClothedElephant:Elephant, Hat, Jacket
[
	Hat:setColor(0.0, 1.0, 0.0)
	Jacket:setColor(0.0, 1.0, 0.0)
 
	setState(STATE state)
	{
		:setState(state)
 
		switch (state)
		{
			STANDING
			{
				Hat:setColour(1.0, 0.0, 0.0)
			}
 
			WALING
			{
				Hat:setColour(0.0, 1.0, 0.0)
			}
 
			SITTING
			{
				Hat:setColour(0.0, 0.0, 1.0)
			}
 
			JUMPING
			{
				Hat:setColour(1.0, 1.0, 1.0)
			}
 
			default
			{
				Hat:setColour(0.0, 0.0, 0.0)
			}
		}
	}
 
	void setColour(vec3 color)
	{
		Hat:setColour(color)
		Jacket:setColour(color)
	}
]
 
vec3 position
int a;
int b;
int c;
Elephant elephant;
ClothedElephant elephants[][];
 
void init()
{
	a = 10
	position(10.0, 15.0, 20.0)
	elephant.setState(Elephant:STATES:SITTING)
 
	elephants[8];
	elephants[][12];
}
 
void run()
{
	if (position == vec3(10.0, 15.0, 0.0)) elephant.setState(Elephant:STATES:JUMPING)
 
	if (a < 5) elephants[][]
}

[paul_g_griffiths]

Thinking about an nBit computer, choose the bit size like bit[n]. May be useful for neural or more simulation.
May need to create array memory, bit[][][][][], Something like that, may be Serial network based for simplicity([roblem though with transistor switch on rise) or variable parallel type deal and with a max nBit size.

10,050,000,000(34 bit) is about the size of the planet with mm accuracy. So 40 bit would be great resolution.

Unlimited cores too. 1 or more program/'s/object/'s/function/'s/loop/'s/operation/'s can run in a core, some sort of thread wait going on.
A nBit64 GRCode Unlimited Modular Computer with wireless network capability.
x by y by z stackable.

Platform games---.....___

Never did much of digital at college... May need to create my own software for simulation.

Since the planet is going to pot, and we're be huddled on the poles like penguins sucking on ice lolly's from nuclear driven warehouses, need something to look at other than baked mud, at least until the ground drop and we're down with devil.

Seems these holes in russia are old produced by falling water, then eventually very slowly covered and now dropped, may be many times. Or visited by Independence day long time ago. See the rest, some old, some new.

On topic, we may need to create very tall tubes and extract the pollution by blowing the air in to large containers containing a liquid that can absorb the pollution. May be switch off and extract the rising carbon monoxide, or take the above.

Propellers, electrical wire and polythene tubes!

Or pump air constantly in to our old oil wells at the bottom to recreate the insulation layer which was once oil? Shame air rises and air expels heat.
John Conner with The Terminator never had this problem.

[IonutCava]

Since the planet is going to pot, and we're be huddled on the poles like penguins sucking on ice lolly's from nuclear driven warehouses, need something to look at other than baked mud, at least until the ground drop and we're down with devil.

Am I the only one enjoying this thread? )

But back on topic:
Cudos on your code, don't get what you're trying to achieve here, but at least it runs which is something, I guess.

But one tiny issue: This is an OpenGL forum, emphasis on Open. You're talking about software patents and whatnot while using (I hope) google translate. That's where most people's attention will fall of a cliff.
Don't expect much traction for this thread. Unless you want the same kind of responses you got from the thread you linked in the original post.

Let's get back to basics, shall we?

Are you trying to code an engine in C++ using OpenGL?
If so, are you looking for feedback, advice and constructive criticism?

[paul_g_griffiths]

Am I the only one enjoying this thread? )

But back on topic:
Cudos on your code, don't get what you're trying to achieve here, but at least it runs which is something, I guess.

But one tiny issue: This is an OpenGL forum, emphasis on Open. You're talking about software patents and whatnot while using (I hope) google translate. That's where most people's attention will fall of a cliff.
Don't expect much traction for this thread. Unless you want the same kind of responses you got from the thread you linked in the original post.

Let's get back to basics, shall we?

Are you trying to code an engine in C++ using OpenGL?
If so, are you looking for feedback, advice and constructive criticism?

OpenGL is open and yes I'm talking of Patents for my Reality Computer and Engine.
But yes my Computer will use OpenGL.
This thread started off me showing off my portals but has advanced due to my inventions of new motherboard and processor technologies. I'm sure many will use it as I'm predicting at least a 1600 times increase in speed, to be honest looking at internal images of processors I'm imagining very far beyond it. If my processors are 1 thousandth of the size then multiply 1600 by that.
Yes I'm open to criticism.

I have completed my code comparators logic(<, >, <=, >= & =) for my Reality Computer, can't show it all but I'm sure your extremely impressed compared to PC's etc assembly based processors, there based on 40 years old plus technology, with an emphasis on backwards compatibility.

Image below is 8 bit, so 8 of it and a little extra logic required for 64 bit. Will need to create logic for maths and my Distributor and Skipper. Start off using standard memory but will be changed once I'm in the position to do so.

[paul_g_griffiths]

I have designed a lot of circuits for my Reality Processor and luckily so far each circuit executes in 1 clock cycle. If this continues then will have an impressive processor.

I have completed my design for total security from Memory, Processor, Operating System, Software, Server and Server access. Beat that!